@haneullabs/bcs 0.1.0

package/dist/cjs/reader.js

@@ -0,0 +1,136 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reader_exports = {};
+__export(reader_exports, {
+  BcsReader: () => BcsReader
+});
+module.exports = __toCommonJS(reader_exports);
+var import_uleb = require("./uleb.js");
+class BcsReader {
+  /**
+   * @param {Uint8Array} data Data to use as a buffer.
+   */
+  constructor(data) {
+    this.bytePosition = 0;
+    this.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  /**
+   * Shift current cursor position by `bytes`.
+   *
+   * @param {Number} bytes Number of bytes to
+   * @returns {this} Self for possible chaining.
+   */
+  shift(bytes) {
+    this.bytePosition += bytes;
+    return this;
+  }
+  /**
+   * Read U8 value from the buffer and shift cursor by 1.
+   * @returns
+   */
+  read8() {
+    const value = this.dataView.getUint8(this.bytePosition);
+    this.shift(1);
+    return value;
+  }
+  /**
+   * Read U16 value from the buffer and shift cursor by 2.
+   * @returns
+   */
+  read16() {
+    const value = this.dataView.getUint16(this.bytePosition, true);
+    this.shift(2);
+    return value;
+  }
+  /**
+   * Read U32 value from the buffer and shift cursor by 4.
+   * @returns
+   */
+  read32() {
+    const value = this.dataView.getUint32(this.bytePosition, true);
+    this.shift(4);
+    return value;
+  }
+  /**
+   * Read U64 value from the buffer and shift cursor by 8.
+   * @returns
+   */
+  read64() {
+    const value1 = this.read32();
+    const value2 = this.read32();
+    const result = value2.toString(16) + value1.toString(16).padStart(8, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+   * Read U128 value from the buffer and shift cursor by 16.
+   */
+  read128() {
+    const value1 = BigInt(this.read64());
+    const value2 = BigInt(this.read64());
+    const result = value2.toString(16) + value1.toString(16).padStart(16, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+   * Read U128 value from the buffer and shift cursor by 32.
+   * @returns
+   */
+  read256() {
+    const value1 = BigInt(this.read128());
+    const value2 = BigInt(this.read128());
+    const result = value2.toString(16) + value1.toString(16).padStart(32, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+   * Read `num` number of bytes from the buffer and shift cursor by `num`.
+   * @param num Number of bytes to read.
+   */
+  readBytes(num) {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const value = new Uint8Array(this.dataView.buffer, start, num);
+    this.shift(num);
+    return value;
+  }
+  /**
+   * Read ULEB value - an integer of varying size. Used for enum indexes and
+   * vector lengths.
+   * @returns {Number} The ULEB value.
+   */
+  readULEB() {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const buffer = new Uint8Array(this.dataView.buffer, start);
+    const { value, length } = (0, import_uleb.ulebDecode)(buffer);
+    this.shift(length);
+    return value;
+  }
+  /**
+   * Read a BCS vector: read a length and then apply function `cb` X times
+   * where X is the length of the vector, defined as ULEB in BCS bytes.
+   * @param cb Callback to process elements of vector.
+   * @returns {Array<Any>} Array of the resulting values, returned by callback.
+   */
+  readVec(cb) {
+    const length = this.readULEB();
+    const result = [];
+    for (let i = 0; i < length; i++) {
+      result.push(cb(this, i, length));
+    }
+    return result;
+  }
+}
+//# sourceMappingURL=reader.js.map

package/dist/cjs/reader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/reader.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ulebDecode } from './uleb.js';\n\n/**\n * Class used for reading BCS data chunk by chunk. Meant to be used\n * by some wrapper, which will make sure that data is valid and is\n * matching the desired format.\n *\n * @example\n * // data for this example is:\n * // { a: u8, b: u32, c: bool, d: u64 }\n *\n * let reader = new BcsReader(\"647f1a060001ffffe7890423c78a050102030405\");\n * let field1 = reader.read8();\n * let field2 = reader.read32();\n * let field3 = reader.read8() === '1'; // bool\n * let field4 = reader.read64();\n * // ....\n *\n * Reading vectors is another deal in bcs. To read a vector, you first need to read\n * its length using {@link readULEB}. Here's an example:\n * @example\n * // data encoded: { field: [1, 2, 3, 4, 5] }\n * let reader = new BcsReader(\"050102030405\");\n * let vec_length = reader.readULEB();\n * let elements = [];\n * for (let i = 0; i < vec_length; i++) {\n *   elements.push(reader.read8());\n * }\n * console.log(elements); // [1,2,3,4,5]\n *\n * @param {String} data HEX-encoded data (serialized BCS)\n */\nexport class BcsReader {\n\tprivate dataView: DataView;\n\tprivate bytePosition: number = 0;\n\n\t/**\n\t * @param {Uint8Array} data Data to use as a buffer.\n\t */\n\tconstructor(data: Uint8Array) {\n\t\tthis.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);\n\t}\n\t/**\n\t * Shift current cursor position by `bytes`.\n\t *\n\t * @param {Number} bytes Number of bytes to\n\t * @returns {this} Self for possible chaining.\n\t */\n\tshift(bytes: number) {\n\t\tthis.bytePosition += bytes;\n\t\treturn this;\n\t}\n\t/**\n\t * Read U8 value from the buffer and shift cursor by 1.\n\t * @returns\n\t */\n\tread8(): number {\n\t\tconst value = this.dataView.getUint8(this.bytePosition);\n\t\tthis.shift(1);\n\t\treturn value;\n\t}\n\t/**\n\t * Read U16 value from the buffer and shift cursor by 2.\n\t * @returns\n\t */\n\tread16(): number {\n\t\tconst value = this.dataView.getUint16(this.bytePosition, true);\n\t\tthis.shift(2);\n\t\treturn value;\n\t}\n\t/**\n\t * Read U32 value from the buffer and shift cursor by 4.\n\t * @returns\n\t */\n\tread32(): number {\n\t\tconst value = this.dataView.getUint32(this.bytePosition, true);\n\t\tthis.shift(4);\n\t\treturn value;\n\t}\n\t/**\n\t * Read U64 value from the buffer and shift cursor by 8.\n\t * @returns\n\t */\n\tread64(): string {\n\t\tconst value1 = this.read32();\n\t\tconst value2 = this.read32();\n\n\t\tconst result = value2.toString(16) + value1.toString(16).padStart(8, '0');\n\n\t\treturn BigInt('0x' + result).toString(10);\n\t}\n\t/**\n\t * Read U128 value from the buffer and shift cursor by 16.\n\t */\n\tread128(): string {\n\t\tconst value1 = BigInt(this.read64());\n\t\tconst value2 = BigInt(this.read64());\n\t\tconst result = value2.toString(16) + value1.toString(16).padStart(16, '0');\n\n\t\treturn BigInt('0x' + result).toString(10);\n\t}\n\t/**\n\t * Read U128 value from the buffer and shift cursor by 32.\n\t * @returns\n\t */\n\tread256(): string {\n\t\tconst value1 = BigInt(this.read128());\n\t\tconst value2 = BigInt(this.read128());\n\t\tconst result = value2.toString(16) + value1.toString(16).padStart(32, '0');\n\n\t\treturn BigInt('0x' + result).toString(10);\n\t}\n\t/**\n\t * Read `num` number of bytes from the buffer and shift cursor by `num`.\n\t * @param num Number of bytes to read.\n\t */\n\treadBytes(num: number): Uint8Array {\n\t\tconst start = this.bytePosition + this.dataView.byteOffset;\n\t\tconst value = new Uint8Array(this.dataView.buffer, start, num);\n\n\t\tthis.shift(num);\n\n\t\treturn value;\n\t}\n\t/**\n\t * Read ULEB value - an integer of varying size. Used for enum indexes and\n\t * vector lengths.\n\t * @returns {Number} The ULEB value.\n\t */\n\treadULEB(): number {\n\t\tconst start = this.bytePosition + this.dataView.byteOffset;\n\t\tconst buffer = new Uint8Array(this.dataView.buffer, start);\n\t\tconst { value, length } = ulebDecode(buffer);\n\n\t\tthis.shift(length);\n\n\t\treturn value;\n\t}\n\t/**\n\t * Read a BCS vector: read a length and then apply function `cb` X times\n\t * where X is the length of the vector, defined as ULEB in BCS bytes.\n\t * @param cb Callback to process elements of vector.\n\t * @returns {Array<Any>} Array of the resulting values, returned by callback.\n\t */\n\treadVec(cb: (reader: BcsReader, i: number, length: number) => any): any[] {\n\t\tconst length = this.readULEB();\n\t\tconst result = [];\n\t\tfor (let i = 0; i < length; i++) {\n\t\t\tresult.push(cb(this, i, length));\n\t\t}\n\t\treturn result;\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,kBAA2B;AAgCpB,MAAM,UAAU;AAAA;AAAA;AAAA;AAAA,EAOtB,YAAY,MAAkB;AAL9B,SAAQ,eAAuB;AAM9B,SAAK,WAAW,IAAI,SAAS,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,OAAe;AACpB,SAAK,gBAAgB;AACrB,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,QAAgB;AACf,UAAM,QAAQ,KAAK,SAAS,SAAS,KAAK,YAAY;AACtD,SAAK,MAAM,CAAC;AACZ,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,SAAiB;AAChB,UAAM,QAAQ,KAAK,SAAS,UAAU,KAAK,cAAc,IAAI;AAC7D,SAAK,MAAM,CAAC;AACZ,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,SAAiB;AAChB,UAAM,QAAQ,KAAK,SAAS,UAAU,KAAK,cAAc,IAAI;AAC7D,SAAK,MAAM,CAAC;AACZ,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,SAAiB;AAChB,UAAM,SAAS,KAAK,OAAO;AAC3B,UAAM,SAAS,KAAK,OAAO;AAE3B,UAAM,SAAS,OAAO,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAExE,WAAO,OAAO,OAAO,MAAM,EAAE,SAAS,EAAE;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAIA,UAAkB;AACjB,UAAM,SAAS,OAAO,KAAK,OAAO,CAAC;AACnC,UAAM,SAAS,OAAO,KAAK,OAAO,CAAC;AACnC,UAAM,SAAS,OAAO,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,EAAE,SAAS,IAAI,GAAG;AAEzE,WAAO,OAAO,OAAO,MAAM,EAAE,SAAS,EAAE;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,UAAkB;AACjB,UAAM,SAAS,OAAO,KAAK,QAAQ,CAAC;AACpC,UAAM,SAAS,OAAO,KAAK,QAAQ,CAAC;AACpC,UAAM,SAAS,OAAO,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,EAAE,SAAS,IAAI,GAAG;AAEzE,WAAO,OAAO,OAAO,MAAM,EAAE,SAAS,EAAE;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA,UAAU,KAAyB;AAClC,UAAM,QAAQ,KAAK,eAAe,KAAK,SAAS;AAChD,UAAM,QAAQ,IAAI,WAAW,KAAK,SAAS,QAAQ,OAAO,GAAG;AAE7D,SAAK,MAAM,GAAG;AAEd,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAmB;AAClB,UAAM,QAAQ,KAAK,eAAe,KAAK,SAAS;AAChD,UAAM,SAAS,IAAI,WAAW,KAAK,SAAS,QAAQ,KAAK;AACzD,UAAM,EAAE,OAAO,OAAO,QAAI,wBAAW,MAAM;AAE3C,SAAK,MAAM,MAAM;AAEjB,WAAO;AAAA,EACR;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAQ,IAAkE;AACzE,UAAM,SAAS,KAAK,SAAS;AAC7B,UAAM,SAAS,CAAC;AAChB,aAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAChC,aAAO,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACR;AACD;",
+  "names": []
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,28 @@
+import type { Simplify } from '@haneullabs/utils';
+import type { BcsType } from './bcs-type.js';
+/**
+ * Supported encodings.
+ * Used in `Reader.toString()` as well as in `decodeStr` and `encodeStr` functions.
+ */
+export type Encoding = 'base58' | 'base64' | 'hex';
+export type InferBcsType<T extends BcsType<any>> = T extends BcsType<infer U, any> ? U : never;
+export type InferBcsInput<T extends BcsType<any, any>> = T extends BcsType<any, infer U> ? U : never;
+export type EnumOutputShape<T extends Record<string, unknown>, Keys extends string = Extract<keyof T, string>, Values = T[keyof T] extends infer Type ? (Type extends BcsType<infer U> ? U : never) : never> = 0 extends Values ? EnumOutputShapeWithKeys<T, never> : 0n extends Values ? EnumOutputShapeWithKeys<T, never> : '' extends Values ? EnumOutputShapeWithKeys<T, never> : false extends Values ? EnumOutputShapeWithKeys<T, never> : EnumOutputShapeWithKeys<T, Keys>;
+export type EnumOutputShapeWithKeys<T extends Record<string, unknown>, Keys extends string> = {
+    [K in keyof T]: Exclude<Keys, K> extends infer Empty extends string ? Simplify<{
+        [K2 in K]: T[K];
+    } & {
+        [K in Empty]?: never;
+    } & {
+        $kind: K;
+    }> : never;
+}[keyof T];
+export type EnumInputShape<T extends Record<string, unknown>> = {
+    [K in keyof T]: {
+        [K2 in K]: T[K];
+    };
+}[keyof T];
+export type JoinString<T, Sep extends string> = T extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? [] extends R ? F : `${F}${Sep}${JoinString<R, Sep>}` : '';

package/dist/cjs/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Simplify } from '@haneullabs/utils';\nimport type { BcsType } from './bcs-type.js';\n\n/**\n * Supported encodings.\n * Used in `Reader.toString()` as well as in `decodeStr` and `encodeStr` functions.\n */\nexport type Encoding = 'base58' | 'base64' | 'hex';\n\nexport type InferBcsType<T extends BcsType<any>> = T extends BcsType<infer U, any> ? U : never;\nexport type InferBcsInput<T extends BcsType<any, any>> =\n\tT extends BcsType<any, infer U> ? U : never;\n\nexport type EnumOutputShape<\n\tT extends Record<string, unknown>,\n\tKeys extends string = Extract<keyof T, string>,\n\tValues = T[keyof T] extends infer Type ? (Type extends BcsType<infer U> ? U : never) : never,\n> = 0 extends Values\n\t? EnumOutputShapeWithKeys<T, never>\n\t: 0n extends Values\n\t\t? EnumOutputShapeWithKeys<T, never>\n\t\t: '' extends Values\n\t\t\t? EnumOutputShapeWithKeys<T, never>\n\t\t\t: false extends Values\n\t\t\t\t? EnumOutputShapeWithKeys<T, never>\n\t\t\t\t: EnumOutputShapeWithKeys<T, Keys>;\n\nexport type EnumOutputShapeWithKeys<T extends Record<string, unknown>, Keys extends string> = {\n\t[K in keyof T]: Exclude<Keys, K> extends infer Empty extends string\n\t\t? Simplify<\n\t\t\t\t{ [K2 in K]: T[K] } & { [K in Empty]?: never } & {\n\t\t\t\t\t$kind: K;\n\t\t\t\t}\n\t\t\t>\n\t\t: never;\n}[keyof T];\n\nexport type EnumInputShape<T extends Record<string, unknown>> = {\n\t[K in keyof T]: { [K2 in K]: T[K] };\n}[keyof T];\n\nexport type JoinString<T, Sep extends string> = T extends readonly [\n\tinfer F extends string,\n\t...infer R extends string[],\n]\n\t? [] extends R\n\t\t? F\n\t\t: `${F}${Sep}${JoinString<R, Sep>}`\n\t: '';\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/uleb.d.ts

@@ -0,0 +1,5 @@
+export declare function ulebEncode(num: number | bigint): number[];
+export declare function ulebDecode(arr: number[] | Uint8Array): {
+    value: number;
+    length: number;
+};

package/dist/cjs/uleb.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uleb_exports = {};
+__export(uleb_exports, {
+  ulebDecode: () => ulebDecode,
+  ulebEncode: () => ulebEncode
+});
+module.exports = __toCommonJS(uleb_exports);
+function ulebEncode(num) {
+  let bigNum = BigInt(num);
+  const arr = [];
+  let len = 0;
+  if (bigNum === 0n) {
+    return [0];
+  }
+  while (bigNum > 0) {
+    arr[len] = Number(bigNum & 0x7fn);
+    bigNum >>= 7n;
+    if (bigNum > 0n) {
+      arr[len] |= 128;
+    }
+    len += 1;
+  }
+  return arr;
+}
+function ulebDecode(arr) {
+  let total = 0n;
+  let shift = 0n;
+  let len = 0;
+  while (true) {
+    if (len >= arr.length) {
+      throw new Error("ULEB decode error: buffer overflow");
+    }
+    const byte = arr[len];
+    len += 1;
+    total += BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0) {
+      break;
+    }
+    shift += 7n;
+  }
+  if (total > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");
+  }
+  return {
+    value: Number(total),
+    length: len
+  };
+}
+//# sourceMappingURL=uleb.js.map

package/dist/cjs/uleb.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/uleb.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\n// Helper utility: write number as an ULEB array.\n// Original code is taken from: https://www.npmjs.com/package/uleb128 (no longer exists)\nexport function ulebEncode(num: number | bigint): number[] {\n\tlet bigNum = BigInt(num);\n\tconst arr: number[] = [];\n\tlet len = 0;\n\n\tif (bigNum === 0n) {\n\t\treturn [0];\n\t}\n\n\twhile (bigNum > 0) {\n\t\tarr[len] = Number(bigNum & 0x7fn);\n\t\tbigNum >>= 7n;\n\t\tif (bigNum > 0n) {\n\t\t\tarr[len] |= 0x80;\n\t\t}\n\t\tlen += 1;\n\t}\n\n\treturn arr;\n}\n\n// Helper utility: decode ULEB as an array of numbers.\n// Original code is taken from: https://www.npmjs.com/package/uleb128 (no longer exists)\nexport function ulebDecode(arr: number[] | Uint8Array): {\n\tvalue: number;\n\tlength: number;\n} {\n\tlet total = 0n;\n\tlet shift = 0n;\n\tlet len = 0;\n\n\t// eslint-disable-next-line no-constant-condition\n\twhile (true) {\n\t\tif (len >= arr.length) {\n\t\t\tthrow new Error('ULEB decode error: buffer overflow');\n\t\t}\n\n\t\tconst byte = arr[len];\n\t\tlen += 1;\n\t\ttotal += BigInt(byte & 0x7f) << shift;\n\t\tif ((byte & 0x80) === 0) {\n\t\t\tbreak;\n\t\t}\n\t\tshift += 7n;\n\t}\n\n\t// TODO: return bigint in next major version\n\tif (total > BigInt(Number.MAX_SAFE_INTEGER)) {\n\t\tthrow new Error('ULEB decode error: value exceeds MAX_SAFE_INTEGER');\n\t}\n\n\treturn {\n\t\tvalue: Number(total),\n\t\tlength: len,\n\t};\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,SAAS,WAAW,KAAgC;AAC1D,MAAI,SAAS,OAAO,GAAG;AACvB,QAAM,MAAgB,CAAC;AACvB,MAAI,MAAM;AAEV,MAAI,WAAW,IAAI;AAClB,WAAO,CAAC,CAAC;AAAA,EACV;AAEA,SAAO,SAAS,GAAG;AAClB,QAAI,GAAG,IAAI,OAAO,SAAS,KAAK;AAChC,eAAW;AACX,QAAI,SAAS,IAAI;AAChB,UAAI,GAAG,KAAK;AAAA,IACb;AACA,WAAO;AAAA,EACR;AAEA,SAAO;AACR;AAIO,SAAS,WAAW,KAGzB;AACD,MAAI,QAAQ;AACZ,MAAI,QAAQ;AACZ,MAAI,MAAM;AAGV,SAAO,MAAM;AACZ,QAAI,OAAO,IAAI,QAAQ;AACtB,YAAM,IAAI,MAAM,oCAAoC;AAAA,IACrD;AAEA,UAAM,OAAO,IAAI,GAAG;AACpB,WAAO;AACP,aAAS,OAAO,OAAO,GAAI,KAAK;AAChC,SAAK,OAAO,SAAU,GAAG;AACxB;AAAA,IACD;AACA,aAAS;AAAA,EACV;AAGA,MAAI,QAAQ,OAAO,OAAO,gBAAgB,GAAG;AAC5C,UAAM,IAAI,MAAM,mDAAmD;AAAA,EACpE;AAEA,SAAO;AAAA,IACN,OAAO,OAAO,KAAK;AAAA,IACnB,QAAQ;AAAA,EACT;AACD;",
+  "names": []
+}

package/dist/cjs/utils.d.ts

@@ -0,0 +1,18 @@
+import type { Encoding } from './types.js';
+/**
+ * Encode data with either `hex` or `base64`.
+ *
+ * @param {Uint8Array} data Data to encode.
+ * @param {String} encoding Encoding to use: base64 or hex
+ * @returns {String} Encoded value.
+ */
+export declare function encodeStr(data: Uint8Array, encoding: Encoding): string;
+/**
+ * Decode either `base64` or `hex` data.
+ *
+ * @param {String} data Data to encode.
+ * @param {String} encoding Encoding to use: base64 or hex
+ * @returns {Uint8Array} Encoded value.
+ */
+export declare function decodeStr(data: string, encoding: Encoding): Uint8Array;
+export declare function splitGenericParameters(str: string, genericSeparators?: [string, string]): string[];

package/dist/cjs/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  decodeStr: () => decodeStr,
+  encodeStr: () => encodeStr,
+  splitGenericParameters: () => splitGenericParameters
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@haneullabs/utils");
+function encodeStr(data, encoding) {
+  switch (encoding) {
+    case "base58":
+      return (0, import_utils.toBase58)(data);
+    case "base64":
+      return (0, import_utils.toBase64)(data);
+    case "hex":
+      return (0, import_utils.toHex)(data);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+function decodeStr(data, encoding) {
+  switch (encoding) {
+    case "base58":
+      return (0, import_utils.fromBase58)(data);
+    case "base64":
+      return (0, import_utils.fromBase64)(data);
+    case "hex":
+      return (0, import_utils.fromHex)(data);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
+  const [left, right] = genericSeparators;
+  const tok = [];
+  let word = "";
+  let nestedAngleBrackets = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === left) {
+      nestedAngleBrackets++;
+    }
+    if (char === right) {
+      nestedAngleBrackets--;
+    }
+    if (nestedAngleBrackets === 0 && char === ",") {
+      tok.push(word.trim());
+      word = "";
+      continue;
+    }
+    word += char;
+  }
+  tok.push(word.trim());
+  return tok;
+}
+//# sourceMappingURL=utils.js.map

package/dist/cjs/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils.ts"],
+  "sourcesContent": ["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { fromBase58, fromBase64, fromHex, toBase58, toBase64, toHex } from '@haneullabs/utils';\nimport type { Encoding } from './types.js';\n\n/**\n * Encode data with either `hex` or `base64`.\n *\n * @param {Uint8Array} data Data to encode.\n * @param {String} encoding Encoding to use: base64 or hex\n * @returns {String} Encoded value.\n */\nexport function encodeStr(data: Uint8Array, encoding: Encoding): string {\n\tswitch (encoding) {\n\t\tcase 'base58':\n\t\t\treturn toBase58(data);\n\t\tcase 'base64':\n\t\t\treturn toBase64(data);\n\t\tcase 'hex':\n\t\t\treturn toHex(data);\n\t\tdefault:\n\t\t\tthrow new Error('Unsupported encoding, supported values are: base64, hex');\n\t}\n}\n\n/**\n * Decode either `base64` or `hex` data.\n *\n * @param {String} data Data to encode.\n * @param {String} encoding Encoding to use: base64 or hex\n * @returns {Uint8Array} Encoded value.\n */\nexport function decodeStr(data: string, encoding: Encoding): Uint8Array {\n\tswitch (encoding) {\n\t\tcase 'base58':\n\t\t\treturn fromBase58(data);\n\t\tcase 'base64':\n\t\t\treturn fromBase64(data);\n\t\tcase 'hex':\n\t\t\treturn fromHex(data);\n\t\tdefault:\n\t\t\tthrow new Error('Unsupported encoding, supported values are: base64, hex');\n\t}\n}\n\nexport function splitGenericParameters(\n\tstr: string,\n\tgenericSeparators: [string, string] = ['<', '>'],\n) {\n\tconst [left, right] = genericSeparators;\n\tconst tok = [];\n\tlet word = '';\n\tlet nestedAngleBrackets = 0;\n\n\tfor (let i = 0; i < str.length; i++) {\n\t\tconst char = str[i];\n\t\tif (char === left) {\n\t\t\tnestedAngleBrackets++;\n\t\t}\n\t\tif (char === right) {\n\t\t\tnestedAngleBrackets--;\n\t\t}\n\t\tif (nestedAngleBrackets === 0 && char === ',') {\n\t\t\ttok.push(word.trim());\n\t\t\tword = '';\n\t\t\tcontinue;\n\t\t}\n\t\tword += char;\n\t}\n\n\ttok.push(word.trim());\n\n\treturn tok;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAA2E;AAUpE,SAAS,UAAU,MAAkB,UAA4B;AACvE,UAAQ,UAAU;AAAA,IACjB,KAAK;AACJ,iBAAO,uBAAS,IAAI;AAAA,IACrB,KAAK;AACJ,iBAAO,uBAAS,IAAI;AAAA,IACrB,KAAK;AACJ,iBAAO,oBAAM,IAAI;AAAA,IAClB;AACC,YAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACD;AASO,SAAS,UAAU,MAAc,UAAgC;AACvE,UAAQ,UAAU;AAAA,IACjB,KAAK;AACJ,iBAAO,yBAAW,IAAI;AAAA,IACvB,KAAK;AACJ,iBAAO,yBAAW,IAAI;AAAA,IACvB,KAAK;AACJ,iBAAO,sBAAQ,IAAI;AAAA,IACpB;AACC,YAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AACD;AAEO,SAAS,uBACf,KACA,oBAAsC,CAAC,KAAK,GAAG,GAC9C;AACD,QAAM,CAAC,MAAM,KAAK,IAAI;AACtB,QAAM,MAAM,CAAC;AACb,MAAI,OAAO;AACX,MAAI,sBAAsB;AAE1B,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACpC,UAAM,OAAO,IAAI,CAAC;AAClB,QAAI,SAAS,MAAM;AAClB;AAAA,IACD;AACA,QAAI,SAAS,OAAO;AACnB;AAAA,IACD;AACA,QAAI,wBAAwB,KAAK,SAAS,KAAK;AAC9C,UAAI,KAAK,KAAK,KAAK,CAAC;AACpB,aAAO;AACP;AAAA,IACD;AACA,YAAQ;AAAA,EACT;AAEA,MAAI,KAAK,KAAK,KAAK,CAAC;AAEpB,SAAO;AACR;",
+  "names": []
+}

package/dist/cjs/writer.d.ts

@@ -0,0 +1,117 @@
+import type { Encoding } from './types.js';
+export interface BcsWriterOptions {
+    /** The initial size (in bytes) of the buffer tht will be allocated */
+    initialSize?: number;
+    /** The maximum size (in bytes) that the buffer is allowed to grow to */
+    maxSize?: number;
+    /** The amount of bytes that will be allocated whenever additional memory is required */
+    allocateSize?: number;
+}
+/**
+ * Class used to write BCS data into a buffer. Initializer requires
+ * some size of a buffer to init; default value for this buffer is 1KB.
+ *
+ * Most methods are chainable, so it is possible to write them in one go.
+ *
+ * @example
+ * let serialized = new BcsWriter()
+ *   .write8(10)
+ *   .write32(1000000)
+ *   .write64(10000001000000)
+ *   .hex();
+ */
+/**
+ * Set of methods that allows data encoding/decoding as standalone
+ * BCS value or a part of a composed structure/vector.
+ */
+export declare class BcsWriter {
+    private dataView;
+    private bytePosition;
+    private size;
+    private maxSize;
+    private allocateSize;
+    constructor({ initialSize, maxSize, allocateSize, }?: BcsWriterOptions);
+    private ensureSizeOrGrow;
+    /**
+     * Shift current cursor position by `bytes`.
+     *
+     * @param {Number} bytes Number of bytes to
+     * @returns {this} Self for possible chaining.
+     */
+    shift(bytes: number): this;
+    /**
+     * Write a U8 value into a buffer and shift cursor position by 1.
+     * @param {Number} value Value to write.
+     * @returns {this}
+     */
+    write8(value: number | bigint): this;
+    /**
+     * Write a U8 value into a buffer and shift cursor position by 1.
+     * @param {Number} value Value to write.
+     * @returns {this}
+     */
+    writeBytes(bytes: Uint8Array): this;
+    /**
+     * Write a U16 value into a buffer and shift cursor position by 2.
+     * @param {Number} value Value to write.
+     * @returns {this}
+     */
+    write16(value: number | bigint): this;
+    /**
+     * Write a U32 value into a buffer and shift cursor position by 4.
+     * @param {Number} value Value to write.
+     * @returns {this}
+     */
+    write32(value: number | bigint): this;
+    /**
+     * Write a U64 value into a buffer and shift cursor position by 8.
+     * @param {bigint} value Value to write.
+     * @returns {this}
+     */
+    write64(value: number | bigint): this;
+    /**
+     * Write a U128 value into a buffer and shift cursor position by 16.
+     *
+     * @param {bigint} value Value to write.
+     * @returns {this}
+     */
+    write128(value: number | bigint): this;
+    /**
+     * Write a U256 value into a buffer and shift cursor position by 16.
+     *
+     * @param {bigint} value Value to write.
+     * @returns {this}
+     */
+    write256(value: number | bigint): this;
+    /**
+     * Write a ULEB value into a buffer and shift cursor position by number of bytes
+     * written.
+     * @param {Number} value Value to write.
+     * @returns {this}
+     */
+    writeULEB(value: number): this;
+    /**
+     * Write a vector into a buffer by first writing the vector length and then calling
+     * a callback on each passed value.
+     *
+     * @param {Array<Any>} vector Array of elements to write.
+     * @param {WriteVecCb} cb Callback to call on each element of the vector.
+     * @returns {this}
+     */
+    writeVec(vector: any[], cb: (writer: BcsWriter, el: any, i: number, len: number) => void): this;
+    /**
+     * Adds support for iterations over the object.
+     * @returns {Uint8Array}
+     */
+    [Symbol.iterator](): Iterator<number, Iterable<number>>;
+    /**
+     * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
+     * @returns {Uint8Array} Resulting bcs.
+     */
+    toBytes(): Uint8Array<ArrayBuffer>;
+    /**
+     * Represent data as 'hex' or 'base64'
+     * @param encoding Encoding to use: 'base64' or 'hex'
+     */
+    toString(encoding: Encoding): string;
+}