Class Codec<T, TParseInput>Abstract

constructor

• new Codec<T, TParseInput>(name): Codec<T, TParseInput>

• Type Parameters

  • T

  • TParseInput = T

  Parameters

  • name: string

  Returns Codec<T, TParseInput>

Readonly name

Abstract around

• around<TOutter, TOutterParseInput>(callbacks): Codec<TOutter, TOutterParseInput>

• Create a new codec which shares the same underlying molecule type but with different JavaScript type.

  This is useful to create a different view wrapper.

  Type Parameters

  • TOutter

  • TOutterParseInput

  Parameters

  • callbacks: {
        didUnpack: ((value, buffer) => TOutter);
        safeParse: ((input) => SafeParseReturnType<TOutter>);
        willPack: ((input) => T);
    }

    • didUnpack: ((value, buffer) => TOutter)

      Conversion callback after calling the inner unpack.

      • • (value, buffer): TOutter

        • Conversion callback after calling the inner unpack.

          Parameters

          • value: T

          • buffer: Uint8Array

          Returns TOutter

    • safeParse: ((input) => SafeParseReturnType<TOutter>)

      Implements the safeParse for the new codec.

      • • (input): SafeParseReturnType<TOutter>

        • Implements the safeParse for the new codec.

          Parameters

          • input: TOutterParseInput

          Returns SafeParseReturnType<TOutter>

    • willPack: ((input) => T)

      Conversion callback before calling the inner pack.

      • • (input): T

        • Conversion callback before calling the inner pack.

          Parameters

          • input: TOutter

          Returns T

  Returns Codec<TOutter, TOutterParseInput>

  Example

  import { mol } from "@ckb-cobuild/molecule";
  const ByteOpt = mol.option("ByteOpt", mol.byte);
  const BooleanOpt = ByteOpt.around({
    safeParse: (input: boolean | null) => mol.parseSuccess(input),
    willPack: (input: boolean | null) =>
      input !== null ? (input ? 1 : 0) : null,
    didUnpack: (value: number | null) => (value !== null ? value !== 0 : null),
  });
  Copy

beforeParse

• beforeParse<TOutterParseInput>(parse): Codec<T, TOutterParseInput>

• Chain a parse method before.

  Type Parameters

  • TOutterParseInput

  Parameters

  • parse: ((input) => TParseInput)

    • • (input): TParseInput

      • Parameters

        • input: TOutterParseInput

        Returns TParseInput

  Returns Codec<T, TOutterParseInput>

  Example

  import { mol } from "@ckb-cobuild/molecule";
  const ByteCoerce = mol.byte.beforeParse((input: any) => Number(input));
  Copy

beforeSafeParse

• beforeSafeParse<TOutterParseInput>(safeParse): Codec<T, TOutterParseInput>

• Chain a safeParse method before.

  Type Parameters

  • TOutterParseInput

  Parameters

  • safeParse: ((input) => SafeParseReturnType<TParseInput>)

    • • (input): SafeParseReturnType<TParseInput>

      • Parameters

        • input: TOutterParseInput

        Returns SafeParseReturnType<TParseInput>

  Returns Codec<T, TOutterParseInput>

  Example

  import { mol } from "@ckb-cobuild/molecule";
  const ByteCoerce = mol.byte.beforeSafeParse((input: any) => {
    const result = parseInt(input);
    if (!Number.isNaN(result)) {
      return mol.parseSuccess(result);
    }
    return mol.parseError("Not a number");
  });
  Copy

expectByteLength

• expectByteLength(byteLength, buffer): void
• Internal

  Parameters

  • byteLength: number

  • buffer: Uint8Array

  Returns void

expectMinimalByteLength

• expectMinimalByteLength(minimalByteLength, buffer): void
• Internal

  Parameters

  • minimalByteLength: number

  • buffer: Uint8Array

  Returns void

exportSchema

• exportSchema(): Map<string, string>

• Returns Map<string, string>

exportSchemaTo

• exportSchemaTo(exported): Map<string, string>

• Export the schema of this codec and all the dependencies into the map.

  The order of the map is guaranteed that the dependency is always exported before the dependent.

  Parameters

  • exported: Map<string, string>

  Returns Map<string, string>

getDepedencies

• getDepedencies(): Iterable<UnknownCodec>

• Direct dependencies of this codec.

  Returns Iterable<UnknownCodec>

Abstract getSchema

• getSchema(): string

• Get the schema specification of this codec as in the .mol file.

  Returns string

pack

• pack(value): Uint8Array

• Pack value into a molecule buffer.

  Parameters

  • value: T

  Returns Uint8Array

  See

  packTo

Abstract packTo

• packTo(value, writer): void

• Pack the value and append the buffer to the provided writer.

  Take the advantage of writer and append the buffer as blocks. The writer can concatenate all blocks into one buffer for the final result.

  Parameters

  • value: T

  • writer: BinaryWriter

  Returns void

parse

• parse(input): T

• Parse a compatible input.

  Parameters

  • input: TParseInput

  Returns T

  Throws

  CodecError

Abstract safeParse

• safeParse(input): SafeParseReturnType<T>

• Parse a compatible input. Return a result instead of throwing.

  Parameters

  • input: TParseInput

  Returns SafeParseReturnType<T>

  See

  parse

toString

• toString(): string

• Returns string

Abstract unpack

• unpack(buffer, strict?): T

• Unpack the value from the molecule buffer.

  Parameters

  • buffer: Uint8Array

  • Optional strict: boolean

    whehter to allow unknown fields in the buffer. True to enable. It is off by default.

  Returns T

  Throws

  CodecError