Variable bcsConst

Type declaration

• bool:function

  • bool(options?: BcsTypeOptions<boolean, boolean>): BcsType<boolean, boolean>

  • Creates a BcsType that can be used to read and write boolean values.

    Parameters

    • Optionaloptions: BcsTypeOptions<boolean, boolean>

    Returns BcsType<boolean, boolean>

    Example

    bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
    Copy

• bytes:function

  • bytes<T extends number>(
        size: T,
        options?: BcsTypeOptions<Uint8Array, Iterable<number>>,
    ): BcsType<Uint8Array, Iterable<number>>

  • Creates a BcsType representing a fixed length byte array

    Type Parameters

    • T extends number

    Parameters

    • size: T

      The number of bytes this types represents
    • Optionaloptions: BcsTypeOptions<Uint8Array, Iterable<number>>

    Returns BcsType<Uint8Array, Iterable<number>>

    Example

    bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
    Copy

• enum:function

  • enum<T extends Record<string, null | BcsType<any, any>>>(
        name: string,
        values: T,
        options?: Omit<
            BcsTypeOptions<
                EnumOutputShape<
                    {
                        [K in string
                        | number
                        | symbol]: T[K] extends BcsType<U, any> ? U : true
                    },
                >,
                EnumInputShape<
                    {
                        [K in string
                        | number
                        | symbol]: T[K] extends BcsType<any, U> ? U : null | boolean | object
                    },
                >,
            >,
            "name",
        >,
    ): BcsType<
        EnumOutputShape<
            {
                [K in string
                | number
                | symbol]: T[K] extends BcsType<U, any> ? U : true
            },
        >,
        EnumInputShape<
            {
                [K in string
                | number
                | symbol]: T[K] extends BcsType<any, U> ? U : null | boolean | object
            },
        >,
    >

  • Creates a BcsType representing an enum of a given set of options

    Type Parameters

    • T extends Record<string, null | BcsType<any, any>>

    Parameters

    • name: string

      The name of the enum
    • values: T

      The values of the enum. The order of the values affects how data is serialized and deserialized. null can be used to represent a variant with no data.
    • Optionaloptions: Omit<
          BcsTypeOptions<
              EnumOutputShape<
                  {
                      [K in string
                      | number
                      | symbol]: T[K] extends BcsType<U, any> ? U : true
                  },
              >,
              EnumInputShape<
                  {
                      [K in string
                      | number
                      | symbol]: T[K] extends BcsType<any, U> ? U : null | boolean | object
                  },
              >,
          >,
          "name",
      >

    Returns BcsType<
        EnumOutputShape<
            {
                [K in string
                | number
                | symbol]: T[K] extends BcsType<U, any> ? U : true
            },
        >,
        EnumInputShape<
            {
                [K in string
                | number
                | symbol]: T[K] extends BcsType<any, U> ? U : null | boolean | object
            },
        >,
    >

    Example

    const enum = bcs.enum('MyEnum', {
      A: bcs.u8(),
      B: bcs.string(),
      C: null,
    })
    enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
    enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
    enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
    Copy

• fixedArray:function

  • fixedArray<T, Input>(
        size: number,
        type: BcsType<T, Input>,
        options?: BcsTypeOptions<T[], Iterable<Input> & { length: number }>,
    ): BcsType<T[], Iterable<Input> & { length: number }>

  • Creates a BcsType that represents a fixed length array of a given type

    Type Parameters

    • T
    • Input

    Parameters

    • size: number

      The number of elements in the array
    • type: BcsType<T, Input>

      The BcsType of each element in the array
    • Optionaloptions: BcsTypeOptions<T[], Iterable<Input> & { length: number }>

    Returns BcsType<T[], Iterable<Input> & { length: number }>

    Example

    bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
    Copy

• lazy:function

  • lazy<T extends BcsType<any, any>>(cb: () => T): T

  • Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.

    Type Parameters

    • T extends BcsType<any, any>

    Parameters

    • cb: () => T

      A callback that returns the BcsType

    Returns T

• map:function

  • map<K, V, InputK = K, InputV = V>(
        keyType: BcsType<K, InputK>,
        valueType: BcsType<V, InputV>,
    ): BcsType<Map<K, V>, Map<InputK, InputV>>

  • Creates a BcsType representing a map of a given key and value type

    Type Parameters

    • K
    • V
    • InputK = K
    • InputV = V

    Parameters

    • keyType: BcsType<K, InputK>

      The BcsType of the key
    • valueType: BcsType<V, InputV>

      The BcsType of the value

    Returns BcsType<Map<K, V>, Map<InputK, InputV>>

    Example

    const map = bcs.map(bcs.u8(), bcs.string())
    map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
    Copy

• option:function

  • option<T, Input>(
        type: BcsType<T, Input>,
    ): BcsType<null | T, undefined | null | Input>

  • Creates a BcsType representing an optional value

    Type Parameters

    • T
    • Input

    Parameters

    • type: BcsType<T, Input>

      The BcsType of the optional value

    Returns BcsType<null | T, undefined | null | Input>

    Example

    bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
    bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
    Copy

• string:function

  • string(options?: BcsTypeOptions<string, string>): BcsType<string, string>

  • Creates a BcsType that can ser/de string values. Strings will be UTF-8 encoded

    Parameters

    • Optionaloptions: BcsTypeOptions<string, string>

    Returns BcsType<string, string>

    Example

    bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
    Copy

• struct:function

  • struct<T extends Record<string, BcsType<any, any>>>(
        name: string,
        fields: T,
        options?: Omit<
            BcsTypeOptions<
                {
                    [K in string
                    | number
                    | symbol]: T[K] extends BcsType<U, any> ? U : never
                },
                {
                    [K in string
                    | number
                    | symbol]: T[K] extends BcsType<any, U> ? U : never
                },
            >,
            "name",
        >,
    ): BcsType<
        {
            [K in string
            | number
            | symbol]: T[K] extends BcsType<U, any> ? U : never
        },
        {
            [K in string
            | number
            | symbol]: T[K] extends BcsType<any, U> ? U : never
        },
    >

  • Creates a BcsType representing a struct of a given set of fields

    Type Parameters

    • T extends Record<string, BcsType<any, any>>

    Parameters

    • name: string

      The name of the struct
    • fields: T

      The fields of the struct. The order of the fields affects how data is serialized and deserialized
    • Optionaloptions: Omit<
          BcsTypeOptions<
              {
                  [K in string
                  | number
                  | symbol]: T[K] extends BcsType<U, any> ? U : never
              },
              {
                  [K in string
                  | number
                  | symbol]: T[K] extends BcsType<any, U> ? U : never
              },
          >,
          "name",
      >

    Returns BcsType<
        {
            [K in string
            | number
            | symbol]: T[K] extends BcsType<U, any> ? U : never
        },
        {
            [K in string
            | number
            | symbol]: T[K] extends BcsType<any, U> ? U : never
        },
    >

    Example

    const struct = bcs.struct('MyStruct', {
     a: bcs.u8(),
     b: bcs.string(),
    })
    struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
    Copy

• tuple:function

  • tuple<const Types extends readonly BcsType<any, any>[]>(
        types: Types,
        options?: BcsTypeOptions<
            {
                -readonly [K in string
                | number
                | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
            },
            {
                [K in string
                | number
                | symbol]: Types[K<K>] extends BcsType<any, T> ? T : never
            },
        >,
    ): BcsType<
        {
            -readonly [K in string
            | number
            | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
        },
        {
            [K in string
            | number
            | symbol]: Types[K<K>] extends BcsType<any, T> ? T : never
        },
    >

  • Creates a BcsType representing a tuple of a given set of types

    Type Parameters

    • const Types extends readonly BcsType<any, any>[]

    Parameters

    • types: Types

      The BcsTypes for each element in the tuple
    • Optionaloptions: BcsTypeOptions<
          {
              -readonly [K in string
              | number
              | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
          },
          {
              [K in string
              | number
              | symbol]: Types[K<K>] extends BcsType<any, T> ? T : never
          },
      >

    Returns BcsType<
        {
            -readonly [K in string
            | number
            | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
        },
        {
            [K in string
            | number
            | symbol]: Types[K<K>] extends BcsType<any, T> ? T : never
        },
    >

    Example

    const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
    tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
    Copy

• u128:function

  • u128(
        options?: BcsTypeOptions<string, string | number | bigint>,
    ): BcsType<string, string | number | bigint>

  • Creates a BcsType that can be used to read and write a 128-bit unsigned integer.

    Parameters

    • Optionaloptions: BcsTypeOptions<string, string | number | bigint>

    Returns BcsType<string, string | number | bigint>

    Example

    bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
    Copy

• u16:function

  • u16(options?: BcsTypeOptions<number, number>): BcsType<number, number>

  • Creates a BcsType that can be used to read and write a 16-bit unsigned integer.

    Parameters

    • Optionaloptions: BcsTypeOptions<number, number>

    Returns BcsType<number, number>

    Example

    bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
    Copy

• u256:function

  • u256(
        options?: BcsTypeOptions<string, string | number | bigint>,
    ): BcsType<string, string | number | bigint>

  • Creates a BcsType that can be used to read and write a 256-bit unsigned integer.

    Parameters

    • Optionaloptions: BcsTypeOptions<string, string | number | bigint>

    Returns BcsType<string, string | number | bigint>

    Example

    bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
    Copy

• u32:function

  • u32(options?: BcsTypeOptions<number, number>): BcsType<number, number>

  • Creates a BcsType that can be used to read and write a 32-bit unsigned integer.

    Parameters

    • Optionaloptions: BcsTypeOptions<number, number>

    Returns BcsType<number, number>

    Example

    bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
    Copy

• u64:function

  • u64(
        options?: BcsTypeOptions<string, string | number | bigint>,
    ): BcsType<string, string | number | bigint>

  • Creates a BcsType that can be used to read and write a 64-bit unsigned integer.

    Parameters

    • Optionaloptions: BcsTypeOptions<string, string | number | bigint>

    Returns BcsType<string, string | number | bigint>

    Example

    bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
    Copy

• u8:function

  • u8(options?: BcsTypeOptions<number, number>): BcsType<number, number>

  • Creates a BcsType that can be used to read and write an 8-bit unsigned integer.

    Parameters

    • Optionaloptions: BcsTypeOptions<number, number>

    Returns BcsType<number, number>

    Example

    bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
    Copy

• uleb128:function

  • uleb128(options?: BcsTypeOptions<number, number>): BcsType<number, number>

  • Creates a BcsType that can be used to read and write unsigned LEB encoded integers

    Parameters

    • Optionaloptions: BcsTypeOptions<number, number>

    Returns BcsType<number, number>

    Example

    
    Copy

• vector:function

  • vector<T, Input>(
        type: BcsType<T, Input>,
        options?: BcsTypeOptions<T[], Iterable<Input> & { length: number }>,
    ): BcsType<T[], Iterable<Input> & { length: number }>

  • Creates a BcsType representing a variable length vector of a given type

    Type Parameters

    • T
    • Input

    Parameters

    • type: BcsType<T, Input>

      The BcsType of each element in the vector
    • Optionaloptions: BcsTypeOptions<T[], Iterable<Input> & { length: number }>

    Returns BcsType<T[], Iterable<Input> & { length: number }>

    Example

    bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
    Copy