@haneullabs/bcs 2.1.2 → 2.1.3

package/dist/reader.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reader.mjs","names":[],"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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAa,YAAb,MAAuB;;;;CAOtB,YAAY,MAAkB;EALC,KAAA,eAAA;EAM9B,KAAK,WAAW,IAAI,SAAS,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;CAC3E;;;;;;;CAOA,MAAM,OAAe;EACpB,KAAK,gBAAgB;EACrB,OAAO;CACR;;;;;CAKA,QAAgB;EACf,MAAM,QAAQ,KAAK,SAAS,SAAS,KAAK,YAAY;EACtD,KAAK,MAAM,CAAC;EACZ,OAAO;CACR;;;;;CAKA,SAAiB;EAChB,MAAM,QAAQ,KAAK,SAAS,UAAU,KAAK,cAAc,IAAI;EAC7D,KAAK,MAAM,CAAC;EACZ,OAAO;CACR;;;;;CAKA,SAAiB;EAChB,MAAM,QAAQ,KAAK,SAAS,UAAU,KAAK,cAAc,IAAI;EAC7D,KAAK,MAAM,CAAC;EACZ,OAAO;CACR;;;;;CAKA,SAAiB;EAChB,MAAM,SAAS,KAAK,OAAO;EAG3B,MAAM,SAFS,KAAK,OAEA,CAAC,CAAC,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;EAExE,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,EAAE;CACzC;;;;CAIA,UAAkB;EACjB,MAAM,SAAS,OAAO,KAAK,OAAO,CAAC;EAEnC,MAAM,SADS,OAAO,KAAK,OAAO,CACd,CAAC,CAAC,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG;EAEzE,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,EAAE;CACzC;;;;;CAKA,UAAkB;EACjB,MAAM,SAAS,OAAO,KAAK,QAAQ,CAAC;EAEpC,MAAM,SADS,OAAO,KAAK,QAAQ,CACf,CAAC,CAAC,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG;EAEzE,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,EAAE;CACzC;;;;;CAKA,UAAU,KAAyB;EAClC,MAAM,QAAQ,KAAK,eAAe,KAAK,SAAS;EAChD,MAAM,QAAQ,IAAI,WAAW,KAAK,SAAS,QAAQ,OAAO,GAAG;EAE7D,KAAK,MAAM,GAAG;EAEd,OAAO;CACR;;;;;;CAMA,WAAmB;EAClB,MAAM,QAAQ,KAAK,eAAe,KAAK,SAAS;EAChD,MAAM,SAAS,IAAI,WAAW,KAAK,SAAS,QAAQ,KAAK;EACzD,MAAM,EAAE,OAAO,WAAW,WAAW,MAAM;EAE3C,KAAK,MAAM,MAAM;EAEjB,OAAO;CACR;;;;;;;CAOA,QAAQ,IAAkE;EACzE,MAAM,SAAS,KAAK,SAAS;EAC7B,MAAM,SAAS,CAAC;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAC3B,OAAO,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;EAEhC,OAAO;CACR;AACD"}
+{"version":3,"file":"reader.mjs","names":[],"sources":["../src/reader.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\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 bytes: Uint8Array;\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\tthis.bytes = new Uint8Array(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 position = this.bytePosition;\n\t\tif (position >= this.bytes.length) {\n\t\t\tthrow new RangeError('Offset is outside the bounds of the DataView');\n\t\t}\n\t\tthis.bytePosition = position + 1;\n\t\treturn this.bytes[position];\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 value = this.dataView.getBigUint64(this.bytePosition, true);\n\t\tthis.shift(8);\n\t\treturn value.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\t// The underlying buffer may extend past this view, so check against the view's own length\n\t\tif (this.bytePosition + num > this.bytes.length) {\n\t\t\tthrow new RangeError('Offset is outside the bounds of the DataView');\n\t\t}\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 bytes = this.bytes;\n\t\tlet position = this.bytePosition;\n\t\tlet value = 0;\n\t\tlet multiplier = 1;\n\t\twhile (true) {\n\t\t\tif (position >= bytes.length) {\n\t\t\t\tthrow new Error('ULEB decode error: buffer overflow');\n\t\t\t}\n\t\t\tconst byte = bytes[position++];\n\t\t\tvalue += (byte & 0x7f) * multiplier;\n\t\t\tif ((byte & 0x80) === 0) {\n\t\t\t\t// A trailing zero group adds no value, so the encoding is not minimal\n\t\t\t\tif (byte === 0 && position - this.bytePosition > 1) {\n\t\t\t\t\tthrow new Error('ULEB decode error: non-canonical encoding');\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmultiplier *= 128;\n\t\t}\n\n\t\t// Also rejects NaN, from very long encodings where multiplier overflows to Infinity\n\t\tif (!(value <= Number.MAX_SAFE_INTEGER)) {\n\t\t\tthrow new Error('ULEB decode error: value exceeds MAX_SAFE_INTEGER');\n\t\t}\n\t\tthis.bytePosition = position;\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,YAAb,MAAuB;;;;CAQtB,YAAY,MAAkB;EALC,KAAA,eAAA;EAM9B,KAAK,WAAW,IAAI,SAAS,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;EAC1E,KAAK,QAAQ,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;CAC1E;;;;;;;CAOA,MAAM,OAAe;EACpB,KAAK,gBAAgB;EACrB,OAAO;CACR;;;;;CAKA,QAAgB;EACf,MAAM,WAAW,KAAK;EACtB,IAAI,YAAY,KAAK,MAAM,QAC1B,MAAM,IAAI,WAAW,8CAA8C;EAEpE,KAAK,eAAe,WAAW;EAC/B,OAAO,KAAK,MAAM;CACnB;;;;;CAKA,SAAiB;EAChB,MAAM,QAAQ,KAAK,SAAS,UAAU,KAAK,cAAc,IAAI;EAC7D,KAAK,MAAM,CAAC;EACZ,OAAO;CACR;;;;;CAKA,SAAiB;EAChB,MAAM,QAAQ,KAAK,SAAS,UAAU,KAAK,cAAc,IAAI;EAC7D,KAAK,MAAM,CAAC;EACZ,OAAO;CACR;;;;;CAKA,SAAiB;EAChB,MAAM,QAAQ,KAAK,SAAS,aAAa,KAAK,cAAc,IAAI;EAChE,KAAK,MAAM,CAAC;EACZ,OAAO,MAAM,SAAS,EAAE;CACzB;;;;CAIA,UAAkB;EACjB,MAAM,SAAS,OAAO,KAAK,OAAO,CAAC;EAEnC,MAAM,SADS,OAAO,KAAK,OAAO,CACd,CAAC,CAAC,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG;EAEzE,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,EAAE;CACzC;;;;;CAKA,UAAkB;EACjB,MAAM,SAAS,OAAO,KAAK,QAAQ,CAAC;EAEpC,MAAM,SADS,OAAO,KAAK,QAAQ,CACf,CAAC,CAAC,SAAS,EAAE,IAAI,OAAO,SAAS,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG;EAEzE,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS,EAAE;CACzC;;;;;CAKA,UAAU,KAAyB;EAElC,IAAI,KAAK,eAAe,MAAM,KAAK,MAAM,QACxC,MAAM,IAAI,WAAW,8CAA8C;EAEpE,MAAM,QAAQ,KAAK,eAAe,KAAK,SAAS;EAChD,MAAM,QAAQ,IAAI,WAAW,KAAK,SAAS,QAAQ,OAAO,GAAG;EAE7D,KAAK,MAAM,GAAG;EAEd,OAAO;CACR;;;;;;CAMA,WAAmB;EAClB,MAAM,QAAQ,KAAK;EACnB,IAAI,WAAW,KAAK;EACpB,IAAI,QAAQ;EACZ,IAAI,aAAa;EACjB,OAAO,MAAM;GACZ,IAAI,YAAY,MAAM,QACrB,MAAM,IAAI,MAAM,oCAAoC;GAErD,MAAM,OAAO,MAAM;GACnB,UAAU,OAAO,OAAQ;GACzB,KAAK,OAAO,SAAU,GAAG;IAExB,IAAI,SAAS,KAAK,WAAW,KAAK,eAAe,GAChD,MAAM,IAAI,MAAM,2CAA2C;IAE5D;GACD;GACA,cAAc;EACf;EAGA,IAAI,EAAE,SAAS,OAAO,mBACrB,MAAM,IAAI,MAAM,mDAAmD;EAEpE,KAAK,eAAe;EACpB,OAAO;CACR;;;;;;;CAOA,QAAQ,IAAkE;EACzE,MAAM,SAAS,KAAK,SAAS;EAC7B,MAAM,SAAS,CAAC;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAC3B,OAAO,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;EAEhC,OAAO;CACR;AACD"}

package/dist/writer.d.mts

@@ -27,6 +27,7 @@ interface BcsWriterOptions {
  */
 declare class BcsWriter {
   private dataView;
+  private bytes;
   private bytePosition;
   private size;
   private maxSize;
@@ -84,6 +85,7 @@ declare class BcsWriter {
    * @returns {this}
    */
   write256(value: number | bigint): this;
+  private writeBigLittleEndian;
   /**
    * Write a ULEB value into a buffer and shift cursor position by number of bytes
    * written.

package/dist/writer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"writer.d.mts","names":[],"sources":["../src/writer.ts"],"mappings":";;UAOiB;;EAEhB;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;cAqBY;UACJ;UACA;UACA;UACA;UACA;EAER,cACC,aACA,SACA,iBACE;UAOK;;;;;;;EA0BR,MAAM;;;;;;EASN,OAAO;;;;;;EAWP,WAAW,OAAO;;;;;;EAclB,QAAQ;;;;;;EAUR,QAAQ;;;;;;EAUR,QAAQ;;;;;;;EAWR,SAAS;;;;;;;EAWT,SAAS;;;;;;;EAWT,UAAU;;;;;;;;;EAYV,SAAS,eAAe,KAAK,QAAQ,WAAW,SAAS,WAAW;;;;;GAWlE,OAAO,aAAa,iBAAiB;;;;;EAWvC,WAAW,WAAW;;;;;EAQtB,SAAS,UAAU"}
+{"version":3,"file":"writer.d.mts","names":[],"sources":["../src/writer.ts"],"mappings":";;UAOiB;;EAEhB;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;cAqBY;UACJ;UACA;UACA;UACA;UACA;UACA;EAER,cACC,aACA,SACA,iBACE;UAQK;;;;;;;EA4BR,MAAM;;;;;;EASN,OAAO;;;;;;EAWP,WAAW,OAAO;;;;;;EAWlB,QAAQ;;;;;;EAUR,QAAQ;;;;;;EAUR,QAAQ;;;;;;;EASR,SAAS;;;;;;;EAST,SAAS;UAKD;;;;;;;EAgBR,UAAU;;;;;;;;;EAqBV,SAAS,eAAe,KAAK,QAAQ,WAAW,SAAS,WAAW;;;;;GAWlE,OAAO,aAAa,iBAAiB;;;;;EAWvC,WAAW,WAAW;;;;;EAQtB,SAAS,UAAU"}

package/dist/writer.mjs

@@ -25,6 +25,7 @@ var BcsWriter = class {
 		this.maxSize = maxSize;
 		this.allocateSize = allocateSize;
 		this.dataView = new DataView(new ArrayBuffer(initialSize));
+		this.bytes = new Uint8Array(this.dataView.buffer);
 	}
 	ensureSizeOrGrow(bytes) {
 		const requiredSize = this.bytePosition + bytes;
@@ -33,8 +34,10 @@ var BcsWriter = class {
 			if (requiredSize > nextSize) throw new Error(`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`);
 			this.size = nextSize;
 			const nextBuffer = new ArrayBuffer(this.size);
-			new Uint8Array(nextBuffer).set(new Uint8Array(this.dataView.buffer));
+			const nextBytes = new Uint8Array(nextBuffer);
+			nextBytes.set(this.bytes);
 			this.dataView = new DataView(nextBuffer);
+			this.bytes = nextBytes;
 		}
 	}
 	/**
@@ -54,7 +57,7 @@ var BcsWriter = class {
 	*/
 	write8(value) {
 		this.ensureSizeOrGrow(1);
-		this.dataView.setUint8(this.bytePosition, Number(value));
+		this.bytes[this.bytePosition] = Number(value);
 		return this.shift(1);
 	}
 	/**
@@ -64,7 +67,7 @@ var BcsWriter = class {
 	*/
 	writeBytes(bytes) {
 		this.ensureSizeOrGrow(bytes.length);
-		for (let i = 0; i < bytes.length; i++) this.dataView.setUint8(this.bytePosition + i, bytes[i]);
+		this.bytes.set(bytes, this.bytePosition);
 		return this.shift(bytes.length);
 	}
 	/**
@@ -93,8 +96,7 @@ var BcsWriter = class {
 	* @returns {this}
 	*/
 	write64(value) {
-		toLittleEndian(BigInt(value), 8).forEach((el) => this.write8(el));
-		return this;
+		return this.writeBigLittleEndian(BigInt(value), 8);
 	}
 	/**
 	* Write a U128 value into a buffer and shift cursor position by 16.
@@ -103,8 +105,7 @@ var BcsWriter = class {
 	* @returns {this}
 	*/
 	write128(value) {
-		toLittleEndian(BigInt(value), 16).forEach((el) => this.write8(el));
-		return this;
+		return this.writeBigLittleEndian(BigInt(value), 16);
 	}
 	/**
 	* Write a U256 value into a buffer and shift cursor position by 16.
@@ -113,8 +114,16 @@ var BcsWriter = class {
 	* @returns {this}
 	*/
 	write256(value) {
-		toLittleEndian(BigInt(value), 32).forEach((el) => this.write8(el));
-		return this;
+		return this.writeBigLittleEndian(BigInt(value), 32);
+	}
+	writeBigLittleEndian(value, size) {
+		this.ensureSizeOrGrow(size);
+		let remaining = value > 0n ? value : 0n;
+		for (let offset = 0; offset < size; offset += 8) {
+			this.dataView.setBigUint64(this.bytePosition + offset, BigInt.asUintN(64, remaining), true);
+			remaining >>= 64n;
+		}
+		return this.shift(size);
 	}
 	/**
 	* Write a ULEB value into a buffer and shift cursor position by number of bytes
@@ -123,6 +132,14 @@ var BcsWriter = class {
 	* @returns {this}
 	*/
 	writeULEB(value) {
+		if (value >= 0 && Number.isSafeInteger(value)) {
+			let remaining = value;
+			while (remaining >= 128) {
+				this.write8(remaining % 128 | 128);
+				remaining = Math.floor(remaining / 128);
+			}
+			return this.write8(remaining);
+		}
 		ulebEncode(value).forEach((el) => this.write8(el));
 		return this;
 	}
@@ -162,16 +179,6 @@ var BcsWriter = class {
 		return encodeStr(this.toBytes(), encoding);
 	}
 };
-function toLittleEndian(bigint, size) {
-	const result = new Uint8Array(size);
-	let i = 0;
-	while (bigint > 0) {
-		result[i] = Number(bigint % BigInt(256));
-		bigint = bigint / BigInt(256);
-		i += 1;
-	}
-	return result;
-}
 //#endregion
 export { BcsWriter };
 

package/dist/writer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"writer.mjs","names":[],"sources":["../src/writer.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Encoding } from './types.js';\nimport { ulebEncode } from './uleb.js';\nimport { encodeStr } from './utils.js';\n\nexport interface BcsWriterOptions {\n\t/** The initial size (in bytes) of the buffer tht will be allocated */\n\tinitialSize?: number;\n\t/** The maximum size (in bytes) that the buffer is allowed to grow to */\n\tmaxSize?: number;\n\t/** The amount of bytes that will be allocated whenever additional memory is required */\n\tallocateSize?: number;\n}\n\n/**\n * Class used to write BCS data into a buffer. Initializer requires\n * some size of a buffer to init; default value for this buffer is 1KB.\n *\n * Most methods are chainable, so it is possible to write them in one go.\n *\n * @example\n * let serialized = new BcsWriter()\n *   .write8(10)\n *   .write32(1000000)\n *   .write64(10000001000000)\n *   .hex();\n */\n\n/**\n * Set of methods that allows data encoding/decoding as standalone\n * BCS value or a part of a composed structure/vector.\n */\nexport class BcsWriter {\n\tprivate dataView: DataView<ArrayBuffer>;\n\tprivate bytePosition: number = 0;\n\tprivate size: number;\n\tprivate maxSize: number;\n\tprivate allocateSize: number;\n\n\tconstructor({\n\t\tinitialSize = 1024,\n\t\tmaxSize = Infinity,\n\t\tallocateSize = 1024,\n\t}: BcsWriterOptions = {}) {\n\t\tthis.size = initialSize;\n\t\tthis.maxSize = maxSize;\n\t\tthis.allocateSize = allocateSize;\n\t\tthis.dataView = new DataView(new ArrayBuffer(initialSize));\n\t}\n\n\tprivate ensureSizeOrGrow(bytes: number) {\n\t\tconst requiredSize = this.bytePosition + bytes;\n\t\tif (requiredSize > this.size) {\n\t\t\tconst nextSize = Math.min(\n\t\t\t\tthis.maxSize,\n\t\t\t\tMath.max(this.size + requiredSize, this.size + this.allocateSize),\n\t\t\t);\n\t\t\tif (requiredSize > nextSize) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tthis.size = nextSize;\n\t\t\tconst nextBuffer = new ArrayBuffer(this.size);\n\t\t\tnew Uint8Array(nextBuffer).set(new Uint8Array(this.dataView.buffer));\n\t\t\tthis.dataView = new DataView(nextBuffer);\n\t\t}\n\t}\n\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): this {\n\t\tthis.bytePosition += bytes;\n\t\treturn this;\n\t}\n\t/**\n\t * Write a U8 value into a buffer and shift cursor position by 1.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twrite8(value: number | bigint): this {\n\t\tthis.ensureSizeOrGrow(1);\n\t\tthis.dataView.setUint8(this.bytePosition, Number(value));\n\t\treturn this.shift(1);\n\t}\n\n\t/**\n\t * Write a U8 value into a buffer and shift cursor position by 1.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twriteBytes(bytes: Uint8Array): this {\n\t\tthis.ensureSizeOrGrow(bytes.length);\n\n\t\tfor (let i = 0; i < bytes.length; i++) {\n\t\t\tthis.dataView.setUint8(this.bytePosition + i, bytes[i]);\n\t\t}\n\n\t\treturn this.shift(bytes.length);\n\t}\n\t/**\n\t * Write a U16 value into a buffer and shift cursor position by 2.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twrite16(value: number | bigint): this {\n\t\tthis.ensureSizeOrGrow(2);\n\t\tthis.dataView.setUint16(this.bytePosition, Number(value), true);\n\t\treturn this.shift(2);\n\t}\n\t/**\n\t * Write a U32 value into a buffer and shift cursor position by 4.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twrite32(value: number | bigint): this {\n\t\tthis.ensureSizeOrGrow(4);\n\t\tthis.dataView.setUint32(this.bytePosition, Number(value), true);\n\t\treturn this.shift(4);\n\t}\n\t/**\n\t * Write a U64 value into a buffer and shift cursor position by 8.\n\t * @param {bigint} value Value to write.\n\t * @returns {this}\n\t */\n\twrite64(value: number | bigint): this {\n\t\ttoLittleEndian(BigInt(value), 8).forEach((el) => this.write8(el));\n\n\t\treturn this;\n\t}\n\t/**\n\t * Write a U128 value into a buffer and shift cursor position by 16.\n\t *\n\t * @param {bigint} value Value to write.\n\t * @returns {this}\n\t */\n\twrite128(value: number | bigint): this {\n\t\ttoLittleEndian(BigInt(value), 16).forEach((el) => this.write8(el));\n\n\t\treturn this;\n\t}\n\t/**\n\t * Write a U256 value into a buffer and shift cursor position by 16.\n\t *\n\t * @param {bigint} value Value to write.\n\t * @returns {this}\n\t */\n\twrite256(value: number | bigint): this {\n\t\ttoLittleEndian(BigInt(value), 32).forEach((el) => this.write8(el));\n\n\t\treturn this;\n\t}\n\t/**\n\t * Write a ULEB value into a buffer and shift cursor position by number of bytes\n\t * written.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twriteULEB(value: number): this {\n\t\tulebEncode(value).forEach((el) => this.write8(el));\n\t\treturn this;\n\t}\n\t/**\n\t * Write a vector into a buffer by first writing the vector length and then calling\n\t * a callback on each passed value.\n\t *\n\t * @param {Array<Any>} vector Array of elements to write.\n\t * @param {WriteVecCb} cb Callback to call on each element of the vector.\n\t * @returns {this}\n\t */\n\twriteVec(vector: any[], cb: (writer: BcsWriter, el: any, i: number, len: number) => void): this {\n\t\tthis.writeULEB(vector.length);\n\t\tArray.from(vector).forEach((el, i) => cb(this, el, i, vector.length));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds support for iterations over the object.\n\t * @returns {Uint8Array}\n\t */\n\t// oxlint-disable-next-line require-yields\n\t*[Symbol.iterator](): Iterator<number, Iterable<number>> {\n\t\tfor (let i = 0; i < this.bytePosition; i++) {\n\t\t\tyield this.dataView.getUint8(i);\n\t\t}\n\t\treturn this.toBytes();\n\t}\n\n\t/**\n\t * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).\n\t * @returns {Uint8Array} Resulting bcs.\n\t */\n\ttoBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));\n\t}\n\n\t/**\n\t * Represent data as 'hex' or 'base64'\n\t * @param encoding Encoding to use: 'base64' or 'hex'\n\t */\n\ttoString(encoding: Encoding): string {\n\t\treturn encodeStr(this.toBytes(), encoding);\n\t}\n}\n\nfunction toLittleEndian(bigint: bigint, size: number) {\n\tconst result = new Uint8Array(size);\n\tlet i = 0;\n\twhile (bigint > 0) {\n\t\tresult[i] = Number(bigint % BigInt(256));\n\t\tbigint = bigint / BigInt(256);\n\t\ti += 1;\n\t}\n\treturn result;\n}\n"],"mappings":"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"}
+{"version":3,"file":"writer.mjs","names":[],"sources":["../src/writer.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Encoding } from './types.js';\nimport { ulebEncode } from './uleb.js';\nimport { encodeStr } from './utils.js';\n\nexport interface BcsWriterOptions {\n\t/** The initial size (in bytes) of the buffer tht will be allocated */\n\tinitialSize?: number;\n\t/** The maximum size (in bytes) that the buffer is allowed to grow to */\n\tmaxSize?: number;\n\t/** The amount of bytes that will be allocated whenever additional memory is required */\n\tallocateSize?: number;\n}\n\n/**\n * Class used to write BCS data into a buffer. Initializer requires\n * some size of a buffer to init; default value for this buffer is 1KB.\n *\n * Most methods are chainable, so it is possible to write them in one go.\n *\n * @example\n * let serialized = new BcsWriter()\n *   .write8(10)\n *   .write32(1000000)\n *   .write64(10000001000000)\n *   .hex();\n */\n\n/**\n * Set of methods that allows data encoding/decoding as standalone\n * BCS value or a part of a composed structure/vector.\n */\nexport class BcsWriter {\n\tprivate dataView: DataView<ArrayBuffer>;\n\tprivate bytes: Uint8Array<ArrayBuffer>;\n\tprivate bytePosition: number = 0;\n\tprivate size: number;\n\tprivate maxSize: number;\n\tprivate allocateSize: number;\n\n\tconstructor({\n\t\tinitialSize = 1024,\n\t\tmaxSize = Infinity,\n\t\tallocateSize = 1024,\n\t}: BcsWriterOptions = {}) {\n\t\tthis.size = initialSize;\n\t\tthis.maxSize = maxSize;\n\t\tthis.allocateSize = allocateSize;\n\t\tthis.dataView = new DataView(new ArrayBuffer(initialSize));\n\t\tthis.bytes = new Uint8Array(this.dataView.buffer);\n\t}\n\n\tprivate ensureSizeOrGrow(bytes: number) {\n\t\tconst requiredSize = this.bytePosition + bytes;\n\t\tif (requiredSize > this.size) {\n\t\t\tconst nextSize = Math.min(\n\t\t\t\tthis.maxSize,\n\t\t\t\tMath.max(this.size + requiredSize, this.size + this.allocateSize),\n\t\t\t);\n\t\t\tif (requiredSize > nextSize) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tthis.size = nextSize;\n\t\t\tconst nextBuffer = new ArrayBuffer(this.size);\n\t\t\tconst nextBytes = new Uint8Array(nextBuffer);\n\t\t\tnextBytes.set(this.bytes);\n\t\t\tthis.dataView = new DataView(nextBuffer);\n\t\t\tthis.bytes = nextBytes;\n\t\t}\n\t}\n\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): this {\n\t\tthis.bytePosition += bytes;\n\t\treturn this;\n\t}\n\t/**\n\t * Write a U8 value into a buffer and shift cursor position by 1.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twrite8(value: number | bigint): this {\n\t\tthis.ensureSizeOrGrow(1);\n\t\tthis.bytes[this.bytePosition] = Number(value);\n\t\treturn this.shift(1);\n\t}\n\n\t/**\n\t * Write a U8 value into a buffer and shift cursor position by 1.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twriteBytes(bytes: Uint8Array): this {\n\t\tthis.ensureSizeOrGrow(bytes.length);\n\t\tthis.bytes.set(bytes, this.bytePosition);\n\n\t\treturn this.shift(bytes.length);\n\t}\n\t/**\n\t * Write a U16 value into a buffer and shift cursor position by 2.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twrite16(value: number | bigint): this {\n\t\tthis.ensureSizeOrGrow(2);\n\t\tthis.dataView.setUint16(this.bytePosition, Number(value), true);\n\t\treturn this.shift(2);\n\t}\n\t/**\n\t * Write a U32 value into a buffer and shift cursor position by 4.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twrite32(value: number | bigint): this {\n\t\tthis.ensureSizeOrGrow(4);\n\t\tthis.dataView.setUint32(this.bytePosition, Number(value), true);\n\t\treturn this.shift(4);\n\t}\n\t/**\n\t * Write a U64 value into a buffer and shift cursor position by 8.\n\t * @param {bigint} value Value to write.\n\t * @returns {this}\n\t */\n\twrite64(value: number | bigint): this {\n\t\treturn this.writeBigLittleEndian(BigInt(value), 8);\n\t}\n\t/**\n\t * Write a U128 value into a buffer and shift cursor position by 16.\n\t *\n\t * @param {bigint} value Value to write.\n\t * @returns {this}\n\t */\n\twrite128(value: number | bigint): this {\n\t\treturn this.writeBigLittleEndian(BigInt(value), 16);\n\t}\n\t/**\n\t * Write a U256 value into a buffer and shift cursor position by 16.\n\t *\n\t * @param {bigint} value Value to write.\n\t * @returns {this}\n\t */\n\twrite256(value: number | bigint): this {\n\t\treturn this.writeBigLittleEndian(BigInt(value), 32);\n\t}\n\n\t// Negative values encode as zero and values that overflow `size` keep their low bytes\n\tprivate writeBigLittleEndian(value: bigint, size: number): this {\n\t\tthis.ensureSizeOrGrow(size);\n\t\tlet remaining = value > 0n ? value : 0n;\n\t\tfor (let offset = 0; offset < size; offset += 8) {\n\t\t\tthis.dataView.setBigUint64(this.bytePosition + offset, BigInt.asUintN(64, remaining), true);\n\t\t\tremaining >>= 64n;\n\t\t}\n\n\t\treturn this.shift(size);\n\t}\n\t/**\n\t * Write a ULEB value into a buffer and shift cursor position by number of bytes\n\t * written.\n\t * @param {Number} value Value to write.\n\t * @returns {this}\n\t */\n\twriteULEB(value: number): this {\n\t\tif (value >= 0 && Number.isSafeInteger(value)) {\n\t\t\tlet remaining = value;\n\t\t\twhile (remaining >= 0x80) {\n\t\t\t\tthis.write8((remaining % 0x80) | 0x80);\n\t\t\t\tremaining = Math.floor(remaining / 0x80);\n\t\t\t}\n\t\t\treturn this.write8(remaining);\n\t\t}\n\n\t\tulebEncode(value).forEach((el) => this.write8(el));\n\t\treturn this;\n\t}\n\t/**\n\t * Write a vector into a buffer by first writing the vector length and then calling\n\t * a callback on each passed value.\n\t *\n\t * @param {Array<Any>} vector Array of elements to write.\n\t * @param {WriteVecCb} cb Callback to call on each element of the vector.\n\t * @returns {this}\n\t */\n\twriteVec(vector: any[], cb: (writer: BcsWriter, el: any, i: number, len: number) => void): this {\n\t\tthis.writeULEB(vector.length);\n\t\tArray.from(vector).forEach((el, i) => cb(this, el, i, vector.length));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Adds support for iterations over the object.\n\t * @returns {Uint8Array}\n\t */\n\t// oxlint-disable-next-line require-yields\n\t*[Symbol.iterator](): Iterator<number, Iterable<number>> {\n\t\tfor (let i = 0; i < this.bytePosition; i++) {\n\t\t\tyield this.dataView.getUint8(i);\n\t\t}\n\t\treturn this.toBytes();\n\t}\n\n\t/**\n\t * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).\n\t * @returns {Uint8Array} Resulting bcs.\n\t */\n\ttoBytes(): Uint8Array<ArrayBuffer> {\n\t\treturn new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));\n\t}\n\n\t/**\n\t * Represent data as 'hex' or 'base64'\n\t * @param encoding Encoding to use: 'base64' or 'hex'\n\t */\n\ttoString(encoding: Encoding): string {\n\t\treturn encodeStr(this.toBytes(), encoding);\n\t}\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haneullabs/bcs",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "BCS - Canonical Binary Serialization implementation for JavaScript",
   "license": "Apache-2.0",
   "author": "Haneul Labs <build@haneul-labs.com>",
@@ -51,7 +51,7 @@
   },
   "dependencies": {
     "@scure/base": "^2.3.0",
-    "@haneullabs/utils": "^0.4.1"
+    "@haneullabs/utils": "^0.4.2"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",

package/src/bcs-type.ts

@@ -22,6 +22,12 @@ export class BcsType<T, Input = T, const Name extends string = string> {
 	validate: (value: Input) => void;
 	#write: (value: Input, writer: BcsWriter) => void;
 	#serialize: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;
+	// Set by transform: validates and writes while converting the input only once. Only used
+	// while validate is still the one transform created, so a reassigned validate is honoured.
+	#validatedWrite: ((value: Input, writer: BcsWriter) => void) | null = null;
+	#validatedSerialize:
+		((value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>) | null = null;
+	#transformValidate: ((value: Input) => void) | null = null;
 
 	constructor(
 		options: {
@@ -52,11 +58,18 @@ export class BcsType<T, Input = T, const Name extends string = string> {
 	}
 
 	write(value: Input, writer: BcsWriter) {
+		if (this.#validatedWrite && this.validate === this.#transformValidate) {
+			this.#validatedWrite(value, writer);
+			return;
+		}
 		this.validate(value);
 		this.#write(value, writer);
 	}
 
 	serialize(value: Input, options?: BcsWriterOptions) {
+		if (this.#validatedSerialize && this.validate === this.#transformValidate) {
+			return new SerializedBcs(this, this.#validatedSerialize(value, options));
+		}
 		this.validate(value);
 		return new SerializedBcs(this, this.#serialize(value, options));
 	}
@@ -87,7 +100,7 @@ export class BcsType<T, Input = T, const Name extends string = string> {
 		input?: (val: Input2) => Input;
 		output?: (value: T) => T2;
 	} & BcsTypeOptions<T2, Input2, NewName>) {
-		return new BcsType<T2, Input2, NewName>({
+		const type = new BcsType<T2, Input2, NewName>({
 			name: (name ?? this.name) as NewName,
 			read: (reader) => (output ? output(this.read(reader)) : (this.read(reader) as never)),
 			write: (value, writer) => this.#write(input ? input(value) : (value as never), writer),
@@ -99,6 +112,23 @@ export class BcsType<T, Input = T, const Name extends string = string> {
 				this.validate(input ? input(value) : (value as never));
 			},
 		});
+
+		// Equivalent to validate() followed by the write above, but calls input() once instead of twice
+		type.#transformValidate = type.validate;
+		type.#validatedWrite = (value, writer) => {
+			validate?.(value);
+			const converted = input ? input(value) : (value as never);
+			this.validate(converted);
+			this.#write(converted, writer);
+		};
+		type.#validatedSerialize = (value, options) => {
+			validate?.(value);
+			const converted = input ? input(value) : (value as never);
+			this.validate(converted);
+			return this.#serialize(converted, options);
+		};
+
+		return type;
 	}
 }
 
@@ -253,9 +283,7 @@ export function stringLikeBcsType<const Name extends string = string>({
 		write: (hex, writer) => {
 			const bytes = toBytes(hex);
 			writer.writeULEB(bytes.length);
-			for (let i = 0; i < bytes.length; i++) {
-				writer.write8(bytes[i]);
-			}
+			writer.writeBytes(bytes);
 		},
 		serialize: (value) => {
 			const bytes = toBytes(value);
@@ -325,14 +353,16 @@ export class BcsStruct<
 	Name
 > {
 	constructor({ name, fields, ...options }: BcsStructOptions<T, Name>) {
-		const canonicalOrder = Object.entries(fields);
+		const fieldNames = Object.keys(fields);
+		const fieldTypes = fieldNames.map((field) => fields[field]);
+		const fieldCount = fieldNames.length;
 
 		super({
 			name,
 			serializedSize: (values) => {
 				let total = 0;
-				for (const [field, type] of canonicalOrder) {
-					const size = type.serializedSize(values[field]);
+				for (let i = 0; i < fieldCount; i++) {
+					const size = fieldTypes[i].serializedSize(values[fieldNames[i]]);
 					if (size == null) {
 						return null;
 					}
@@ -344,15 +374,15 @@ export class BcsStruct<
 			},
 			read: (reader) => {
 				const result: Record<string, unknown> = {};
-				for (const [field, type] of canonicalOrder) {
-					result[field] = type.read(reader);
+				for (let i = 0; i < fieldCount; i++) {
+					result[fieldNames[i]] = fieldTypes[i].read(reader);
 				}
 
 				return result as never;
 			},
 			write: (value, writer) => {
-				for (const [field, type] of canonicalOrder) {
-					type.write(value[field], writer);
+				for (let i = 0; i < fieldCount; i++) {
+					fieldTypes[i].write(value[fieldNames[i]], writer);
 				}
 			},
 			...options,
@@ -399,6 +429,7 @@ export class BcsEnum<
 > {
 	constructor({ fields, ...options }: BcsEnumOptions<T, Name>) {
 		const canonicalOrder = Object.entries(fields as object);
+		const variantIndex = new Map(canonicalOrder.map(([name], i) => [name, i]));
 		super({
 			read: (reader) => {
 				const index = reader.readULEB();
@@ -410,21 +441,26 @@ export class BcsEnum<
 
 				const [kind, type] = enumEntry;
 
-				return {
-					[kind]: type?.read(reader) ?? true,
-					$kind: kind,
-				} as never;
+				const value = type?.read(reader) ?? true;
+				// Assigning to __proto__ would set the prototype rather than add a property
+				if (kind === '__proto__') {
+					return { [kind]: value, $kind: kind } as never;
+				}
+
+				// Avoid a computed-key object literal, which V8 builds through a slow runtime path
+				const result: Record<string, unknown> = {};
+				result[kind] = value;
+				result.$kind = kind;
+
+				return result as never;
 			},
 			write: (value, writer) => {
-				const [name, val] = Object.entries(value).filter(([name]) =>
-					Object.hasOwn(fields, name),
-				)[0];
-
-				for (let i = 0; i < canonicalOrder.length; i++) {
-					const [optionName, optionType] = canonicalOrder[i];
-					if (optionName === name) {
-						writer.writeULEB(i);
-						optionType?.write(val, writer);
+				// The first own key that names a variant selects it
+				for (const name of Object.keys(value)) {
+					const index = variantIndex.get(name);
+					if (index !== undefined) {
+						writer.writeULEB(index);
+						canonicalOrder[index][1]?.write(value[name], writer);
 						return;
 					}
 				}
@@ -436,21 +472,18 @@ export class BcsEnum<
 					throw new TypeError(`Expected object, found ${typeof value}`);
 				}
 
-				const keys = Object.keys(value).filter(
-					(k) => value[k] !== undefined && Object.hasOwn(fields, k),
-				);
+				let variantCount = 0;
+				for (const key of Object.keys(value)) {
+					if (value[key] !== undefined && variantIndex.has(key)) {
+						variantCount++;
+					}
+				}
 
-				if (keys.length !== 1) {
+				if (variantCount !== 1) {
 					throw new TypeError(
-						`Expected object with one key, but found ${keys.length} for type ${options.name}}`,
+						`Expected object with one key, but found ${variantCount} for type ${options.name}}`,
 					);
 				}
-
-				const [variant] = keys;
-
-				if (!Object.hasOwn(fields, variant)) {
-					throw new TypeError(`Invalid enum variant ${variant}`);
-				}
 			},
 		});
 	}

package/src/bcs.ts

@@ -82,27 +82,34 @@ function option<T, Input, Name extends string = string>(
 function option<T extends BcsType<any>>(
 	type: T,
 ): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`> {
-	return bcs
-		.enum(`Option<${type.name}>`, {
-			None: null,
-			Some: type,
-		})
-		.transform({
-			input: (value: InferBcsInput<T> | null | undefined) => {
-				if (value == null) {
-					return { None: true };
-				}
-
-				return { Some: value };
-			},
-			output: (value) => {
-				if (value.$kind === 'Some') {
-					return value.Some as InferBcsType<T>;
-				}
-
+	// Encoded like enum Option { None, Some(T) }, but read and written directly rather than
+	// through an intermediate { None } / { Some } enum object
+	const name = `Option<${type.name}>` as const;
+	return new BcsType<
+		InferBcsType<T> | null,
+		InferBcsInput<T> | null | undefined,
+		`Option<${T['name']}>`
+	>({
+		name,
+		read: (reader) => {
+			const index = reader.readULEB();
+			if (index === 0) {
 				return null;
-			},
-		});
+			}
+			if (index === 1) {
+				return type.read(reader);
+			}
+			throw new TypeError(`Unknown value ${index} for enum ${name}`);
+		},
+		write: (value, writer) => {
+			if (value == null) {
+				writer.write8(0);
+				return;
+			}
+			writer.write8(1);
+			type.write(value, writer);
+		},
+	});
 }
 
 function vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(
@@ -211,6 +218,32 @@ function map<K extends BcsType<any>, V extends BcsType<any>>(
 	});
 }
 
+// Created on first use, so importing the package doesn't require TextEncoder/TextDecoder
+let utf8Encoder: TextEncoder | undefined;
+let utf8Decoder: TextDecoder | undefined;
+function decoder() {
+	return (utf8Decoder ??= new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }));
+}
+
+// Most strings in Haneul data (module, function and type names) are short ASCII. Decoding those
+// directly avoids the fixed cost of a TextDecoder call; anything else goes through the decoder.
+const ASCII_FAST_PATH_MAX_LENGTH = 64;
+function decodeUtf8(bytes: Uint8Array): string {
+	if (bytes.length <= ASCII_FAST_PATH_MAX_LENGTH) {
+		let result = '';
+		for (let i = 0; i < bytes.length; i++) {
+			const byte = bytes[i];
+			if (byte >= 0x80) {
+				return decoder().decode(bytes);
+			}
+			result += String.fromCharCode(byte);
+		}
+		return result;
+	}
+
+	return decoder().decode(bytes);
+}
+
 export const bcs = {
 	/**
 	 * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
@@ -362,7 +395,7 @@ export const bcs = {
 			size,
 			read: (reader) => reader.readBytes(size),
 			write: (value, writer) => {
-				writer.writeBytes(new Uint8Array(value));
+				writer.writeBytes(value instanceof Uint8Array ? value : new Uint8Array(value));
 			},
 			...options,
 			name: (options?.name ?? `bytes[${size}]`) as `bytes[${T}]`,
@@ -392,7 +425,7 @@ export const bcs = {
 				return reader.readBytes(length);
 			},
 			write: (value, writer) => {
-				const array = new Uint8Array(value);
+				const array = value instanceof Uint8Array ? value : new Uint8Array(value);
 				writer.writeULEB(array.length);
 				writer.writeBytes(array);
 			},
@@ -418,9 +451,8 @@ export const bcs = {
 	 */
 	string(options?: BcsTypeOptions<string>) {
 		return stringLikeBcsType({
-			toBytes: (value) => new TextEncoder().encode(value),
-			fromBytes: (bytes) =>
-				new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes),
+			toBytes: (value) => (utf8Encoder ??= new TextEncoder()).encode(value),
+			fromBytes: decodeUtf8,
 			...options,
 			name: (options?.name ?? 'string') as 'string',
 		});

package/src/reader.ts

@@ -1,8 +1,6 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { ulebDecode } from './uleb.js';
-
 /**
  * Class used for reading BCS data chunk by chunk. Meant to be used
  * by some wrapper, which will make sure that data is valid and is
@@ -35,6 +33,7 @@ import { ulebDecode } from './uleb.js';
  */
 export class BcsReader {
 	private dataView: DataView;
+	private bytes: Uint8Array;
 	private bytePosition: number = 0;
 
 	/**
@@ -42,6 +41,7 @@ export class BcsReader {
 	 */
 	constructor(data: Uint8Array) {
 		this.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+		this.bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 	}
 	/**
 	 * Shift current cursor position by `bytes`.
@@ -58,9 +58,12 @@ export class BcsReader {
 	 * @returns
 	 */
 	read8(): number {
-		const value = this.dataView.getUint8(this.bytePosition);
-		this.shift(1);
-		return value;
+		const position = this.bytePosition;
+		if (position >= this.bytes.length) {
+			throw new RangeError('Offset is outside the bounds of the DataView');
+		}
+		this.bytePosition = position + 1;
+		return this.bytes[position];
 	}
 	/**
 	 * Read U16 value from the buffer and shift cursor by 2.
@@ -85,12 +88,9 @@ export class BcsReader {
 	 * @returns
 	 */
 	read64(): string {
-		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);
+		const value = this.dataView.getBigUint64(this.bytePosition, true);
+		this.shift(8);
+		return value.toString(10);
 	}
 	/**
 	 * Read U128 value from the buffer and shift cursor by 16.
@@ -118,6 +118,10 @@ export class BcsReader {
 	 * @param num Number of bytes to read.
 	 */
 	readBytes(num: number): Uint8Array {
+		// The underlying buffer may extend past this view, so check against the view's own length
+		if (this.bytePosition + num > this.bytes.length) {
+			throw new RangeError('Offset is outside the bounds of the DataView');
+		}
 		const start = this.bytePosition + this.dataView.byteOffset;
 		const value = new Uint8Array(this.dataView.buffer, start, num);
 
@@ -131,12 +135,31 @@ export class BcsReader {
 	 * @returns {Number} The ULEB value.
 	 */
 	readULEB(): number {
-		const start = this.bytePosition + this.dataView.byteOffset;
-		const buffer = new Uint8Array(this.dataView.buffer, start);
-		const { value, length } = ulebDecode(buffer);
-
-		this.shift(length);
+		const bytes = this.bytes;
+		let position = this.bytePosition;
+		let value = 0;
+		let multiplier = 1;
+		while (true) {
+			if (position >= bytes.length) {
+				throw new Error('ULEB decode error: buffer overflow');
+			}
+			const byte = bytes[position++];
+			value += (byte & 0x7f) * multiplier;
+			if ((byte & 0x80) === 0) {
+				// A trailing zero group adds no value, so the encoding is not minimal
+				if (byte === 0 && position - this.bytePosition > 1) {
+					throw new Error('ULEB decode error: non-canonical encoding');
+				}
+				break;
+			}
+			multiplier *= 128;
+		}
 
+		// Also rejects NaN, from very long encodings where multiplier overflows to Infinity
+		if (!(value <= Number.MAX_SAFE_INTEGER)) {
+			throw new Error('ULEB decode error: value exceeds MAX_SAFE_INTEGER');
+		}
+		this.bytePosition = position;
 		return value;
 	}
 	/**