@haneullabs/bcs 0.1.0

package/dist/esm/bcs-type.js

@@ -0,0 +1,366 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _write, _serialize, _schema, _bytes;
+import { fromBase58, fromBase64, toBase58, toBase64, fromHex, toHex } from "@haneullabs/utils";
+import { BcsReader } from "./reader.js";
+import { ulebEncode } from "./uleb.js";
+import { BcsWriter } from "./writer.js";
+const _BcsType = class _BcsType {
+  constructor(options) {
+    __privateAdd(this, _write);
+    __privateAdd(this, _serialize);
+    this.name = options.name;
+    this.read = options.read;
+    this.serializedSize = options.serializedSize ?? (() => null);
+    __privateSet(this, _write, options.write);
+    __privateSet(this, _serialize, options.serialize ?? ((value, options2) => {
+      const writer = new BcsWriter({
+        initialSize: this.serializedSize(value) ?? void 0,
+        ...options2
+      });
+      __privateGet(this, _write).call(this, value, writer);
+      return writer.toBytes();
+    }));
+    this.validate = options.validate ?? (() => {
+    });
+  }
+  write(value, writer) {
+    this.validate(value);
+    __privateGet(this, _write).call(this, value, writer);
+  }
+  serialize(value, options) {
+    this.validate(value);
+    return new SerializedBcs(this, __privateGet(this, _serialize).call(this, value, options));
+  }
+  parse(bytes) {
+    const reader = new BcsReader(bytes);
+    return this.read(reader);
+  }
+  fromHex(hex) {
+    return this.parse(fromHex(hex));
+  }
+  fromBase58(b64) {
+    return this.parse(fromBase58(b64));
+  }
+  fromBase64(b64) {
+    return this.parse(fromBase64(b64));
+  }
+  transform({
+    name,
+    input,
+    output,
+    validate
+  }) {
+    return new _BcsType({
+      name: name ?? this.name,
+      read: (reader) => output ? output(this.read(reader)) : this.read(reader),
+      write: (value, writer) => __privateGet(this, _write).call(this, input ? input(value) : value, writer),
+      serializedSize: (value) => this.serializedSize(input ? input(value) : value),
+      serialize: (value, options) => __privateGet(this, _serialize).call(this, input ? input(value) : value, options),
+      validate: (value) => {
+        validate?.(value);
+        this.validate(input ? input(value) : value);
+      }
+    });
+  }
+};
+_write = new WeakMap();
+_serialize = new WeakMap();
+let BcsType = _BcsType;
+const SERIALIZED_BCS_BRAND = Symbol.for("@haneullabs/serialized-bcs");
+function isSerializedBcs(obj) {
+  return !!obj && typeof obj === "object" && obj[SERIALIZED_BCS_BRAND] === true;
+}
+class SerializedBcs {
+  constructor(schema, bytes) {
+    __privateAdd(this, _schema);
+    __privateAdd(this, _bytes);
+    __privateSet(this, _schema, schema);
+    __privateSet(this, _bytes, bytes);
+  }
+  // Used to brand SerializedBcs so that they can be identified, even between multiple copies
+  // of the @haneullabs/bcs package are installed
+  get [SERIALIZED_BCS_BRAND]() {
+    return true;
+  }
+  toBytes() {
+    return __privateGet(this, _bytes);
+  }
+  toHex() {
+    return toHex(__privateGet(this, _bytes));
+  }
+  toBase64() {
+    return toBase64(__privateGet(this, _bytes));
+  }
+  toBase58() {
+    return toBase58(__privateGet(this, _bytes));
+  }
+  parse() {
+    return __privateGet(this, _schema).parse(__privateGet(this, _bytes));
+  }
+}
+_schema = new WeakMap();
+_bytes = new WeakMap();
+function fixedSizeBcsType({
+  size,
+  ...options
+}) {
+  return new BcsType({
+    ...options,
+    serializedSize: () => size
+  });
+}
+function uIntBcsType({
+  readMethod,
+  writeMethod,
+  ...options
+}) {
+  return fixedSizeBcsType({
+    ...options,
+    read: (reader) => reader[readMethod](),
+    write: (value, writer) => writer[writeMethod](value),
+    validate: (value) => {
+      if (value < 0 || value > options.maxValue) {
+        throw new TypeError(
+          `Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`
+        );
+      }
+      options.validate?.(value);
+    }
+  });
+}
+function bigUIntBcsType({
+  readMethod,
+  writeMethod,
+  ...options
+}) {
+  return fixedSizeBcsType({
+    ...options,
+    read: (reader) => reader[readMethod](),
+    write: (value, writer) => writer[writeMethod](BigInt(value)),
+    validate: (val) => {
+      const value = BigInt(val);
+      if (value < 0 || value > options.maxValue) {
+        throw new TypeError(
+          `Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`
+        );
+      }
+      options.validate?.(value);
+    }
+  });
+}
+function dynamicSizeBcsType({
+  serialize,
+  ...options
+}) {
+  const type = new BcsType({
+    ...options,
+    serialize,
+    write: (value, writer) => {
+      for (const byte of type.serialize(value).toBytes()) {
+        writer.write8(byte);
+      }
+    }
+  });
+  return type;
+}
+function stringLikeBcsType({
+  toBytes,
+  fromBytes,
+  ...options
+}) {
+  return new BcsType({
+    ...options,
+    read: (reader) => {
+      const length = reader.readULEB();
+      const bytes = reader.readBytes(length);
+      return fromBytes(bytes);
+    },
+    write: (hex, writer) => {
+      const bytes = toBytes(hex);
+      writer.writeULEB(bytes.length);
+      for (let i = 0; i < bytes.length; i++) {
+        writer.write8(bytes[i]);
+      }
+    },
+    serialize: (value) => {
+      const bytes = toBytes(value);
+      const size = ulebEncode(bytes.length);
+      const result = new Uint8Array(size.length + bytes.length);
+      result.set(size, 0);
+      result.set(bytes, size.length);
+      return result;
+    },
+    validate: (value) => {
+      if (typeof value !== "string") {
+        throw new TypeError(`Invalid ${options.name} value: ${value}. Expected string`);
+      }
+      options.validate?.(value);
+    }
+  });
+}
+function lazyBcsType(cb) {
+  let lazyType = null;
+  function getType() {
+    if (!lazyType) {
+      lazyType = cb();
+    }
+    return lazyType;
+  }
+  return new BcsType({
+    name: "lazy",
+    read: (data) => getType().read(data),
+    serializedSize: (value) => getType().serializedSize(value),
+    write: (value, writer) => getType().write(value, writer),
+    serialize: (value, options) => getType().serialize(value, options).toBytes()
+  });
+}
+class BcsStruct extends BcsType {
+  constructor({ name, fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      name,
+      serializedSize: (values) => {
+        let total = 0;
+        for (const [field, type] of canonicalOrder) {
+          const size = type.serializedSize(values[field]);
+          if (size == null) {
+            return null;
+          }
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = {};
+        for (const [field, type] of canonicalOrder) {
+          result[field] = type.read(reader);
+        }
+        return result;
+      },
+      write: (value, writer) => {
+        for (const [field, type] of canonicalOrder) {
+          type.write(value[field], writer);
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) {
+          throw new TypeError(`Expected object, found ${typeof value}`);
+        }
+      }
+    });
+  }
+}
+class BcsEnum extends BcsType {
+  constructor({ fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      read: (reader) => {
+        const index = reader.readULEB();
+        const enumEntry = canonicalOrder[index];
+        if (!enumEntry) {
+          throw new TypeError(`Unknown value ${index} for enum ${options.name}`);
+        }
+        const [kind, type] = enumEntry;
+        return {
+          [kind]: type?.read(reader) ?? true,
+          $kind: kind
+        };
+      },
+      write: (value, writer) => {
+        const [name, val] = Object.entries(value).filter(
+          ([name2]) => Object.hasOwn(fields, name2)
+        )[0];
+        for (let i = 0; i < canonicalOrder.length; i++) {
+          const [optionName, optionType] = canonicalOrder[i];
+          if (optionName === name) {
+            writer.writeULEB(i);
+            optionType?.write(val, writer);
+            return;
+          }
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) {
+          throw new TypeError(`Expected object, found ${typeof value}`);
+        }
+        const keys = Object.keys(value).filter(
+          (k) => value[k] !== void 0 && Object.hasOwn(fields, k)
+        );
+        if (keys.length !== 1) {
+          throw new TypeError(
+            `Expected object with one key, but found ${keys.length} for type ${options.name}}`
+          );
+        }
+        const [variant] = keys;
+        if (!Object.hasOwn(fields, variant)) {
+          throw new TypeError(`Invalid enum variant ${variant}`);
+        }
+      }
+    });
+  }
+}
+class BcsTuple extends BcsType {
+  constructor({ fields, name, ...options }) {
+    super({
+      name: name ?? `(${fields.map((t) => t.name).join(", ")})`,
+      serializedSize: (values) => {
+        let total = 0;
+        for (let i = 0; i < fields.length; i++) {
+          const size = fields[i].serializedSize(values[i]);
+          if (size == null) {
+            return null;
+          }
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = [];
+        for (const field of fields) {
+          result.push(field.read(reader));
+        }
+        return result;
+      },
+      write: (value, writer) => {
+        for (let i = 0; i < fields.length; i++) {
+          fields[i].write(value[i], writer);
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!Array.isArray(value)) {
+          throw new TypeError(`Expected array, found ${typeof value}`);
+        }
+        if (value.length !== fields.length) {
+          throw new TypeError(`Expected array of length ${fields.length}, found ${value.length}`);
+        }
+      }
+    });
+  }
+}
+export {
+  BcsEnum,
+  BcsStruct,
+  BcsTuple,
+  BcsType,
+  SerializedBcs,
+  bigUIntBcsType,
+  dynamicSizeBcsType,
+  fixedSizeBcsType,
+  isSerializedBcs,
+  lazyBcsType,
+  stringLikeBcsType,
+  uIntBcsType
+};
+//# sourceMappingURL=bcs-type.js.map

package/dist/esm/bcs-type.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/bcs-type.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase58, fromBase64, toBase58, toBase64, fromHex, toHex } from '@haneullabs/utils';\nimport { BcsReader } from './reader.js';\nimport { ulebEncode } from './uleb.js';\nimport type { BcsWriterOptions } from './writer.js';\nimport { BcsWriter } from './writer.js';\nimport type { EnumInputShape, EnumOutputShape, JoinString } from './types.js';\n\nexport interface BcsTypeOptions<T, Input = T, Name extends string = string> {\n\tname?: Name;\n\tvalidate?: (value: Input) => void;\n}\n\nexport class BcsType<T, Input = T, const Name extends string = string> {\n\t$inferType!: T;\n\t$inferInput!: Input;\n\tname: Name;\n\tread: (reader: BcsReader) => T;\n\tserializedSize: (value: Input, options?: BcsWriterOptions) => number | null;\n\tvalidate: (value: Input) => void;\n\t#write: (value: Input, writer: BcsWriter) => void;\n\t#serialize: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;\n\n\tconstructor(\n\t\toptions: {\n\t\t\tname: Name;\n\t\t\tread: (reader: BcsReader) => T;\n\t\t\twrite: (value: Input, writer: BcsWriter) => void;\n\t\t\tserialize?: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;\n\t\t\tserializedSize?: (value: Input) => number | null;\n\t\t\tvalidate?: (value: Input) => void;\n\t\t} & BcsTypeOptions<T, Input, Name>,\n\t) {\n\t\tthis.name = options.name;\n\t\tthis.read = options.read;\n\t\tthis.serializedSize = options.serializedSize ?? (() => null);\n\t\tthis.#write = options.write;\n\t\tthis.#serialize =\n\t\t\toptions.serialize ??\n\t\t\t((value, options) => {\n\t\t\t\tconst writer = new BcsWriter({\n\t\t\t\t\tinitialSize: this.serializedSize(value) ?? undefined,\n\t\t\t\t\t...options,\n\t\t\t\t});\n\t\t\t\tthis.#write(value, writer);\n\t\t\t\treturn writer.toBytes();\n\t\t\t});\n\n\t\tthis.validate = options.validate ?? (() => {});\n\t}\n\n\twrite(value: Input, writer: BcsWriter) {\n\t\tthis.validate(value);\n\t\tthis.#write(value, writer);\n\t}\n\n\tserialize(value: Input, options?: BcsWriterOptions) {\n\t\tthis.validate(value);\n\t\treturn new SerializedBcs(this, this.#serialize(value, options));\n\t}\n\n\tparse(bytes: Uint8Array): T {\n\t\tconst reader = new BcsReader(bytes);\n\t\treturn this.read(reader);\n\t}\n\n\tfromHex(hex: string) {\n\t\treturn this.parse(fromHex(hex));\n\t}\n\n\tfromBase58(b64: string) {\n\t\treturn this.parse(fromBase58(b64));\n\t}\n\n\tfromBase64(b64: string) {\n\t\treturn this.parse(fromBase64(b64));\n\t}\n\n\ttransform<T2 = T, Input2 = Input, NewName extends string = Name>({\n\t\tname,\n\t\tinput,\n\t\toutput,\n\t\tvalidate,\n\t}: {\n\t\tinput?: (val: Input2) => Input;\n\t\toutput?: (value: T) => T2;\n\t} & BcsTypeOptions<T2, Input2, NewName>) {\n\t\treturn new BcsType<T2, Input2, NewName>({\n\t\t\tname: (name ?? this.name) as NewName,\n\t\t\tread: (reader) => (output ? output(this.read(reader)) : (this.read(reader) as never)),\n\t\t\twrite: (value, writer) => this.#write(input ? input(value) : (value as never), writer),\n\t\t\tserializedSize: (value) => this.serializedSize(input ? input(value) : (value as never)),\n\t\t\tserialize: (value, options) =>\n\t\t\t\tthis.#serialize(input ? input(value) : (value as never), options),\n\t\t\tvalidate: (value) => {\n\t\t\t\tvalidate?.(value);\n\t\t\t\tthis.validate(input ? input(value) : (value as never));\n\t\t\t},\n\t\t});\n\t}\n}\n\nconst SERIALIZED_BCS_BRAND = Symbol.for('@haneullabs/serialized-bcs') as never;\nexport function isSerializedBcs(obj: unknown): obj is SerializedBcs<unknown> {\n\treturn !!obj && typeof obj === 'object' && (obj as any)[SERIALIZED_BCS_BRAND] === true;\n}\n\nexport class SerializedBcs<T, Input = T> {\n\t#schema: BcsType<T, Input>;\n\t#bytes: Uint8Array<ArrayBuffer>;\n\n\t// Used to brand SerializedBcs so that they can be identified, even between multiple copies\n\t// of the @haneullabs/bcs package are installed\n\tget [SERIALIZED_BCS_BRAND]() {\n\t\treturn true;\n\t}\n\n\tconstructor(schema: BcsType<T, Input>, bytes: Uint8Array<ArrayBuffer>) {\n\t\tthis.#schema = schema;\n\t\tthis.#bytes = bytes;\n\t}\n\n\ttoBytes() {\n\t\treturn this.#bytes;\n\t}\n\n\ttoHex() {\n\t\treturn toHex(this.#bytes);\n\t}\n\n\ttoBase64() {\n\t\treturn toBase64(this.#bytes);\n\t}\n\n\ttoBase58() {\n\t\treturn toBase58(this.#bytes);\n\t}\n\n\tparse() {\n\t\treturn this.#schema.parse(this.#bytes);\n\t}\n}\n\nexport function fixedSizeBcsType<T, Input = T, const Name extends string = string>({\n\tsize,\n\t...options\n}: {\n\tname: Name;\n\tsize: number;\n\tread: (reader: BcsReader) => T;\n\twrite: (value: Input, writer: BcsWriter) => void;\n} & BcsTypeOptions<T, Input, Name>) {\n\treturn new BcsType<T, Input, Name>({\n\t\t...options,\n\t\tserializedSize: () => size,\n\t});\n}\n\nexport function uIntBcsType<const Name extends string = string>({\n\treadMethod,\n\twriteMethod,\n\t...options\n}: {\n\tname: Name;\n\tsize: number;\n\treadMethod: `read${8 | 16 | 32}`;\n\twriteMethod: `write${8 | 16 | 32}`;\n\tmaxValue: number;\n} & BcsTypeOptions<number, number, Name>) {\n\treturn fixedSizeBcsType<number, number, Name>({\n\t\t...options,\n\t\tread: (reader) => reader[readMethod](),\n\t\twrite: (value, writer) => writer[writeMethod](value),\n\t\tvalidate: (value) => {\n\t\t\tif (value < 0 || value > options.maxValue) {\n\t\t\t\tthrow new TypeError(\n\t\t\t\t\t`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`,\n\t\t\t\t);\n\t\t\t}\n\t\t\toptions.validate?.(value);\n\t\t},\n\t});\n}\n\nexport function bigUIntBcsType<const Name extends string = string>({\n\treadMethod,\n\twriteMethod,\n\t...options\n}: {\n\tname: Name;\n\tsize: number;\n\treadMethod: `read${64 | 128 | 256}`;\n\twriteMethod: `write${64 | 128 | 256}`;\n\tmaxValue: bigint;\n} & BcsTypeOptions<string, string | number | bigint>) {\n\treturn fixedSizeBcsType<string, string | number | bigint, Name>({\n\t\t...options,\n\t\tread: (reader) => reader[readMethod](),\n\t\twrite: (value, writer) => writer[writeMethod](BigInt(value)),\n\t\tvalidate: (val) => {\n\t\t\tconst value = BigInt(val);\n\t\t\tif (value < 0 || value > options.maxValue) {\n\t\t\t\tthrow new TypeError(\n\t\t\t\t\t`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`,\n\t\t\t\t);\n\t\t\t}\n\t\t\toptions.validate?.(value);\n\t\t},\n\t});\n}\n\nexport function dynamicSizeBcsType<T, Input = T, const Name extends string = string>({\n\tserialize,\n\t...options\n}: {\n\tname: Name;\n\tread: (reader: BcsReader) => T;\n\tserialize: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;\n} & BcsTypeOptions<T, Input>) {\n\tconst type = new BcsType<T, Input>({\n\t\t...options,\n\t\tserialize,\n\t\twrite: (value, writer) => {\n\t\t\tfor (const byte of type.serialize(value).toBytes()) {\n\t\t\t\twriter.write8(byte);\n\t\t\t}\n\t\t},\n\t});\n\n\treturn type;\n}\n\nexport function stringLikeBcsType<const Name extends string = string>({\n\ttoBytes,\n\tfromBytes,\n\t...options\n}: {\n\tname: Name;\n\ttoBytes: (value: string) => Uint8Array;\n\tfromBytes: (bytes: Uint8Array) => string;\n\tserializedSize?: (value: string) => number | null;\n} & BcsTypeOptions<string, string, Name>) {\n\treturn new BcsType<string, string, Name>({\n\t\t...options,\n\t\tread: (reader) => {\n\t\t\tconst length = reader.readULEB();\n\t\t\tconst bytes = reader.readBytes(length);\n\n\t\t\treturn fromBytes(bytes);\n\t\t},\n\t\twrite: (hex, writer) => {\n\t\t\tconst bytes = toBytes(hex);\n\t\t\twriter.writeULEB(bytes.length);\n\t\t\tfor (let i = 0; i < bytes.length; i++) {\n\t\t\t\twriter.write8(bytes[i]);\n\t\t\t}\n\t\t},\n\t\tserialize: (value) => {\n\t\t\tconst bytes = toBytes(value);\n\t\t\tconst size = ulebEncode(bytes.length);\n\t\t\tconst result = new Uint8Array(size.length + bytes.length);\n\t\t\tresult.set(size, 0);\n\t\t\tresult.set(bytes, size.length);\n\n\t\t\treturn result;\n\t\t},\n\t\tvalidate: (value) => {\n\t\t\tif (typeof value !== 'string') {\n\t\t\t\tthrow new TypeError(`Invalid ${options.name} value: ${value}. Expected string`);\n\t\t\t}\n\t\t\toptions.validate?.(value);\n\t\t},\n\t});\n}\n\nexport function lazyBcsType<T, Input>(cb: () => BcsType<T, Input>) {\n\tlet lazyType: BcsType<T, Input> | null = null;\n\tfunction getType() {\n\t\tif (!lazyType) {\n\t\t\tlazyType = cb();\n\t\t}\n\t\treturn lazyType;\n\t}\n\n\treturn new BcsType<T, Input>({\n\t\tname: 'lazy' as never,\n\t\tread: (data) => getType().read(data),\n\t\tserializedSize: (value) => getType().serializedSize(value),\n\t\twrite: (value, writer) => getType().write(value, writer),\n\t\tserialize: (value, options) => getType().serialize(value, options).toBytes(),\n\t});\n}\n\nexport interface BcsStructOptions<\n\tT extends Record<string, BcsType<any>>,\n\tName extends string = string,\n> extends Omit<\n\tBcsTypeOptions<\n\t\t{\n\t\t\t[K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never;\n\t\t},\n\t\t{\n\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never;\n\t\t},\n\t\tName\n\t>,\n\t'name'\n> {\n\tname: Name;\n\tfields: T;\n}\n\nexport class BcsStruct<\n\tT extends Record<string, BcsType<any>>,\n\tconst Name extends string = string,\n> extends BcsType<\n\t{\n\t\t[K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never;\n\t},\n\t{\n\t\t[K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never;\n\t},\n\tName\n> {\n\tconstructor({ name, fields, ...options }: BcsStructOptions<T, Name>) {\n\t\tconst canonicalOrder = Object.entries(fields);\n\n\t\tsuper({\n\t\t\tname,\n\t\t\tserializedSize: (values) => {\n\t\t\t\tlet total = 0;\n\t\t\t\tfor (const [field, type] of canonicalOrder) {\n\t\t\t\t\tconst size = type.serializedSize(values[field]);\n\t\t\t\t\tif (size == null) {\n\t\t\t\t\t\treturn null;\n\t\t\t\t\t}\n\n\t\t\t\t\ttotal += size;\n\t\t\t\t}\n\n\t\t\t\treturn total;\n\t\t\t},\n\t\t\tread: (reader) => {\n\t\t\t\tconst result: Record<string, unknown> = {};\n\t\t\t\tfor (const [field, type] of canonicalOrder) {\n\t\t\t\t\tresult[field] = type.read(reader);\n\t\t\t\t}\n\n\t\t\t\treturn result as never;\n\t\t\t},\n\t\t\twrite: (value, writer) => {\n\t\t\t\tfor (const [field, type] of canonicalOrder) {\n\t\t\t\t\ttype.write(value[field], writer);\n\t\t\t\t}\n\t\t\t},\n\t\t\t...options,\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (typeof value !== 'object' || value == null) {\n\t\t\t\t\tthrow new TypeError(`Expected object, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t}\n}\n\nexport interface BcsEnumOptions<\n\tT extends Record<string, BcsType<any> | null>,\n\tName extends string = string,\n> extends Omit<\n\tBcsTypeOptions<\n\t\tEnumOutputShape<{\n\t\t\t[K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true;\n\t\t}>,\n\t\tEnumInputShape<{\n\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;\n\t\t}>,\n\t\tName\n\t>,\n\t'name'\n> {\n\tname: Name;\n\tfields: T;\n}\n\nexport class BcsEnum<\n\tT extends Record<string, BcsType<any> | null>,\n\tconst Name extends string = string,\n> extends BcsType<\n\tEnumOutputShape<{\n\t\t[K in keyof T]: T[K] extends BcsType<infer U, any> ? U : true;\n\t}>,\n\tEnumInputShape<{\n\t\t[K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;\n\t}>,\n\tName\n> {\n\tconstructor({ fields, ...options }: BcsEnumOptions<T, Name>) {\n\t\tconst canonicalOrder = Object.entries(fields as object);\n\t\tsuper({\n\t\t\tread: (reader) => {\n\t\t\t\tconst index = reader.readULEB();\n\n\t\t\t\tconst enumEntry = canonicalOrder[index];\n\t\t\t\tif (!enumEntry) {\n\t\t\t\t\tthrow new TypeError(`Unknown value ${index} for enum ${options.name}`);\n\t\t\t\t}\n\n\t\t\t\tconst [kind, type] = enumEntry;\n\n\t\t\t\treturn {\n\t\t\t\t\t[kind]: type?.read(reader) ?? true,\n\t\t\t\t\t$kind: kind,\n\t\t\t\t} as never;\n\t\t\t},\n\t\t\twrite: (value, writer) => {\n\t\t\t\tconst [name, val] = Object.entries(value).filter(([name]) =>\n\t\t\t\t\tObject.hasOwn(fields, name),\n\t\t\t\t)[0];\n\n\t\t\t\tfor (let i = 0; i < canonicalOrder.length; i++) {\n\t\t\t\t\tconst [optionName, optionType] = canonicalOrder[i];\n\t\t\t\t\tif (optionName === name) {\n\t\t\t\t\t\twriter.writeULEB(i);\n\t\t\t\t\t\toptionType?.write(val, writer);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\t\t\t...options,\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (typeof value !== 'object' || value == null) {\n\t\t\t\t\tthrow new TypeError(`Expected object, found ${typeof value}`);\n\t\t\t\t}\n\n\t\t\t\tconst keys = Object.keys(value).filter(\n\t\t\t\t\t(k) => value[k] !== undefined && Object.hasOwn(fields, k),\n\t\t\t\t);\n\n\t\t\t\tif (keys.length !== 1) {\n\t\t\t\t\tthrow new TypeError(\n\t\t\t\t\t\t`Expected object with one key, but found ${keys.length} for type ${options.name}}`,\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\tconst [variant] = keys;\n\n\t\t\t\tif (!Object.hasOwn(fields, variant)) {\n\t\t\t\t\tthrow new TypeError(`Invalid enum variant ${variant}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t}\n}\n\nexport interface BcsTupleOptions<\n\tT extends readonly BcsType<any>[],\n\tName extends string,\n> extends Omit<\n\tBcsTypeOptions<\n\t\t{\n\t\t\t-readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;\n\t\t},\n\t\t{\n\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;\n\t\t},\n\t\tName\n\t>,\n\t'name'\n> {\n\tname?: Name;\n\tfields: T;\n}\n\nexport class BcsTuple<\n\tconst T extends readonly BcsType<any>[],\n\tconst Name extends string =\n\t\t`(${JoinString<{ [K in keyof T]: T[K] extends BcsType<any, any, infer T> ? T : never }, ', '>})`,\n> extends BcsType<\n\t{\n\t\t-readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;\n\t},\n\t{\n\t\t[K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;\n\t},\n\tName\n> {\n\tconstructor({ fields, name, ...options }: BcsTupleOptions<T, Name>) {\n\t\tsuper({\n\t\t\tname: name ?? (`(${fields.map((t) => t.name).join(', ')})` as never),\n\t\t\tserializedSize: (values) => {\n\t\t\t\tlet total = 0;\n\t\t\t\tfor (let i = 0; i < fields.length; i++) {\n\t\t\t\t\tconst size = fields[i].serializedSize(values[i]);\n\t\t\t\t\tif (size == null) {\n\t\t\t\t\t\treturn null;\n\t\t\t\t\t}\n\n\t\t\t\t\ttotal += size;\n\t\t\t\t}\n\n\t\t\t\treturn total;\n\t\t\t},\n\t\t\tread: (reader) => {\n\t\t\t\tconst result: unknown[] = [];\n\t\t\t\tfor (const field of fields) {\n\t\t\t\t\tresult.push(field.read(reader));\n\t\t\t\t}\n\t\t\t\treturn result as never;\n\t\t\t},\n\t\t\twrite: (value, writer) => {\n\t\t\t\tfor (let i = 0; i < fields.length; i++) {\n\t\t\t\t\tfields[i].write(value[i], writer);\n\t\t\t\t}\n\t\t\t},\n\t\t\t...options,\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (!Array.isArray(value)) {\n\t\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t\tif (value.length !== fields.length) {\n\t\t\t\t\tthrow new TypeError(`Expected array of length ${fields.length}, found ${value.length}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t}\n}\n"],
+  "mappings": "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",
+  "names": ["options", "name"]
+}

package/dist/esm/bcs.d.ts

@@ -0,0 +1,175 @@
+import type { BcsTypeOptions } from './bcs-type.js';
+import { BcsEnum, BcsStruct, BcsTuple, BcsType } from './bcs-type.js';
+import type { EnumInputShape, EnumOutputShape, InferBcsInput, InferBcsType, JoinString } from './types.js';
+declare function fixedArray<T extends BcsType<any>, Name extends string = string>(size: number, type: T, options?: BcsTypeOptions<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+    length: number;
+}, Name>): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+    length: number;
+}, Name>;
+declare function fixedArray<T, Input, Name extends string = string>(size: number, type: BcsType<T, Input>, options?: BcsTypeOptions<T[], Iterable<Input> & {
+    length: number;
+}, Name>): BcsType<T[], Iterable<Input> & {
+    length: number;
+}, Name>;
+declare function option<T extends BcsType<any>>(type: T): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`>;
+declare function option<T, Input, Name extends string = string>(type: BcsType<T, Input, Name>): BcsType<T | null, Input | null | undefined>;
+declare function vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(type: T, options?: BcsTypeOptions<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+    length: number;
+}, Name>): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+    length: number;
+}, Name>;
+declare function vector<T, Input, Name extends string = string>(type: BcsType<T, Input, Name>, options?: BcsTypeOptions<T[], Iterable<Input> & {
+    length: number;
+}, `vector<${Name}>`>): BcsType<T[], Iterable<Input> & {
+    length: number;
+}, `vector<${Name}>`>;
+declare function map<K extends BcsType<any>, V extends BcsType<any>>(keyType: K, valueType: V): BcsType<Map<InferBcsType<K>, InferBcsType<V>>, Map<InferBcsInput<K>, InferBcsInput<V>>, `Map<${K['name']}, ${V['name']}>`>;
+declare function map<K, V, InputK = K, InputV = V>(keyType: BcsType<K, InputK>, valueType: BcsType<V, InputV>): BcsType<Map<K, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;
+export declare const bcs: {
+    /**
+     * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
+     * @example
+     * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
+     */
+    u8(options?: BcsTypeOptions<number>): BcsType<number, number, "u8">;
+    /**
+     * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
+     * @example
+     * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
+     */
+    u16(options?: BcsTypeOptions<number>): BcsType<number, number, "u16">;
+    /**
+     * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
+     * @example
+     * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
+     */
+    u32(options?: BcsTypeOptions<number>): BcsType<number, number, "u32">;
+    /**
+     * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
+     * @example
+     * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
+     */
+    u64(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u64">;
+    /**
+     * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
+     * @example
+     * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+     */
+    u128(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u128">;
+    /**
+     * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
+     * @example
+     * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+     */
+    u256(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u256">;
+    /**
+     * Creates a BcsType that can be used to read and write boolean values.
+     * @example
+     * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
+     */
+    bool(options?: BcsTypeOptions<boolean>): BcsType<boolean, boolean, "bool">;
+    /**
+     * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
+     * @example
+     *
+     */
+    uleb128(options?: BcsTypeOptions<number>): BcsType<number, number, string>;
+    /**
+     * Creates a BcsType representing a fixed length byte array
+     * @param size The number of bytes this types represents
+     * @example
+     * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
+     */
+    bytes<T extends number>(size: T, options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, `bytes[${T}]`>;
+    /**
+     * Creates a BcsType representing a variable length byte array
+     *
+     * @example
+     * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
+     */
+    byteVector(options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+    /**
+     * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
+     * @example
+     * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
+     */
+    string(options?: BcsTypeOptions<string>): BcsType<string, string, "string">;
+    /**
+     * Creates a BcsType that represents a fixed length array of a given type
+     * @param size The number of elements in the array
+     * @param type The BcsType of each element in the array
+     * @example
+     * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
+     */
+    fixedArray: typeof fixedArray;
+    /**
+     * Creates a BcsType representing an optional value
+     * @param type The BcsType of the optional value
+     * @example
+     * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
+     * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
+     */
+    option: typeof option;
+    /**
+     * Creates a BcsType representing a variable length vector of a given type
+     * @param type The BcsType of each element in the vector
+     *
+     * @example
+     * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
+     */
+    vector: typeof vector;
+    /**
+     * Creates a BcsType representing a tuple of a given set of types
+     * @param types The BcsTypes for each element in the tuple
+     *
+     * @example
+     * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
+     * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
+     */
+    tuple<const T extends readonly BcsType<any, any>[], const Name extends string = `(${JoinString<{ [K in keyof T]: T[K] extends BcsType<any, any, infer T_1 extends string> ? T_1 : never; }, ", ">})`>(fields: T, options?: BcsTypeOptions<{ -readonly [K_1 in keyof T]: T[K_1] extends BcsType<infer T_1, any> ? T_1 : never; }, { [K_1 in keyof T]: T[K_1] extends BcsType<any, infer T_1> ? T_1 : never; }, Name>): BcsTuple<T, Name>;
+    /**
+     * Creates a BcsType representing a struct of a given set of fields
+     * @param name The name of the struct
+     * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
+     *
+     * @example
+     * const struct = bcs.struct('MyStruct', {
+     *  a: bcs.u8(),
+     *  b: bcs.string(),
+     * })
+     * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+     */
+    struct<T extends Record<string, BcsType<any>>, const Name extends string = string>(name: Name, fields: T, options?: Omit<BcsTypeOptions<{ [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never; }, { [K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never; }>, "name">): BcsStruct<T, string>;
+    /**
+     * Creates a BcsType representing an enum of a given set of options
+     * @param name The name of the enum
+     * @param values 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.
+     *
+     * @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 ]
+     */
+    enum<T extends Record<string, BcsType<any> | null>, const Name extends string = string>(name: Name, fields: T, options?: Omit<BcsTypeOptions<EnumOutputShape<{ [K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true; }>, EnumInputShape<{ [K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null; }>, Name>, "name">): BcsEnum<T, Name>;
+    /**
+     * Creates a BcsType representing a map of a given key and value type
+     * @param keyType The BcsType of the key
+     * @param valueType The BcsType of the value
+     * @example
+     * const map = bcs.map(bcs.u8(), bcs.string())
+     * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
+     */
+    map: typeof map;
+    /**
+     * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
+     * @param cb A callback that returns the BcsType
+     */
+    lazy<T extends BcsType<any>>(cb: () => T): T;
+};
+export {};