Variable bcsConst

Type declaration

• bool:function

  • bool(options?): 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>(size, options?): BcsType<Uint8Array, Uint8Array>

  • 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, Uint8Array>

    Example

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

• enum:function

  • enum<T>(name, values, options?): 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, type, options?): 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>(cb): 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

      • • (): T

        • Returns T

    Returns T

• map:function

  • map<K, V, InputK, InputV>(keyType, valueType): 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<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?): 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>(name, fields, options?): 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>(types, options?): 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?): 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?): 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?): 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?): 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?): 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?): 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?): 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, options?): 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