phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/cjs/types/carbon/blockchain/vm/vm-dynamic-variable.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmDynamicVariable = void 0;
+const vm_type_js_1 = require("./vm-type.js");
+const vm_struct_schema_js_1 = require("./vm-struct-schema.js");
+const vm_dynamic_struct_js_1 = require("./vm-dynamic-struct.js");
+const vm_struct_array_js_1 = require("./vm-struct-array.js");
+const bytes16_js_1 = require("../../bytes16.js");
+const bytes32_js_1 = require("../../bytes32.js");
+const bytes64_js_1 = require("../../bytes64.js");
+class VmDynamicVariable {
+    constructor() {
+        this.type = vm_type_js_1.VmType.Dynamic;
+        this.data = null;
+    }
+    static fromType(t) {
+        const v = new VmDynamicVariable();
+        v.type = t;
+        switch (t) {
+            case vm_type_js_1.VmType.Dynamic:
+                v.data = null;
+                break;
+            case vm_type_js_1.VmType.Bytes:
+                v.data = new Uint8Array();
+                break;
+            case vm_type_js_1.VmType.Struct:
+                v.data = new vm_dynamic_struct_js_1.VmDynamicStruct();
+                break;
+            case vm_type_js_1.VmType.Int8:
+                v.data = 0;
+                break;
+            case vm_type_js_1.VmType.Int16:
+                v.data = 0;
+                break;
+            case vm_type_js_1.VmType.Int32:
+                v.data = 0;
+                break;
+            case vm_type_js_1.VmType.Int64:
+                v.data = 0n;
+                break;
+            case vm_type_js_1.VmType.Int256:
+                v.data = 0n;
+                break;
+            case vm_type_js_1.VmType.Bytes16:
+                v.data = new bytes16_js_1.Bytes16();
+                break;
+            case vm_type_js_1.VmType.Bytes32:
+                v.data = new bytes32_js_1.Bytes32();
+                break;
+            case vm_type_js_1.VmType.Bytes64:
+                v.data = new bytes64_js_1.Bytes64();
+                break;
+            case vm_type_js_1.VmType.String:
+                v.data = '';
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Dynamic:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Struct:
+                v.data = new vm_struct_array_js_1.VmStructArray();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int8:
+                v.data = new Uint8Array();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int16:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int32:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int64:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int256:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes16:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes32:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes64:
+                v.data = [];
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.String:
+                v.data = [];
+                break;
+            default:
+                throw new Error('Unknown VmDynamicVariable type');
+        }
+        return v;
+    }
+    write(w) {
+        w.write1(this.type & 0xff);
+        VmDynamicVariable.writeStatic(this.type, this, null, w);
+    }
+    writeWithSchema(schema, w) {
+        return VmDynamicVariable.writeStatic(schema.type, this, schema.structure, w);
+    }
+    read(r) {
+        this.type = r.read1();
+        VmDynamicVariable.readStatic(this.type, this, null, r);
+    }
+    readWithSchema(schema, r) {
+        this.type = schema.type;
+        VmDynamicVariable.readStatic(schema.type, this, null, r);
+    }
+    static readStatic(type, outVar, schema, r) {
+        switch (type) {
+            case vm_type_js_1.VmType.Dynamic: {
+                const inner = new VmDynamicVariable();
+                inner.read(r);
+                outVar.type = vm_type_js_1.VmType.Dynamic;
+                outVar.data = inner;
+                break;
+            }
+            case vm_type_js_1.VmType.Bytes:
+                outVar.type = type;
+                outVar.data = r.readArray();
+                break;
+            case vm_type_js_1.VmType.Struct: {
+                const s = new vm_dynamic_struct_js_1.VmDynamicStruct();
+                if (schema)
+                    s.readWithSchema(schema, r);
+                else
+                    s.read(r);
+                outVar.type = type;
+                outVar.data = s;
+                break;
+            }
+            case vm_type_js_1.VmType.Int8:
+                outVar.type = type;
+                outVar.data = r.read1();
+                break;
+            case vm_type_js_1.VmType.Int16:
+                outVar.type = type;
+                outVar.data = r.read2();
+                break;
+            case vm_type_js_1.VmType.Int32:
+                outVar.type = type;
+                outVar.data = r.read4();
+                break;
+            case vm_type_js_1.VmType.Int64:
+                outVar.type = type;
+                outVar.data = r.read8u();
+                break;
+            case vm_type_js_1.VmType.Int256:
+                outVar.type = type;
+                outVar.data = r.readBigInt();
+                break;
+            case vm_type_js_1.VmType.Bytes16:
+                outVar.type = type;
+                outVar.data = bytes16_js_1.Bytes16.read(r);
+                break;
+            case vm_type_js_1.VmType.Bytes32:
+                outVar.type = type;
+                outVar.data = bytes32_js_1.Bytes32.read(r);
+                break;
+            case vm_type_js_1.VmType.Bytes64:
+                outVar.type = type;
+                outVar.data = bytes64_js_1.Bytes64.read(r);
+                break;
+            case vm_type_js_1.VmType.String:
+                outVar.type = type;
+                outVar.data = r.readSz();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Dynamic:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(VmDynamicVariable);
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes:
+                outVar.type = type;
+                outVar.data = r.readArrayOfArrays();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Struct: {
+                const length = r.read4();
+                let usedSchema = schema ?? null;
+                const sa = new vm_struct_array_js_1.VmStructArray();
+                if (!usedSchema) {
+                    const readSchema = r.readBlob(vm_struct_schema_js_1.VmStructSchema);
+                    sa.schema = readSchema;
+                    if (readSchema.fields.length > 0)
+                        usedSchema = readSchema;
+                }
+                else {
+                    sa.schema = usedSchema;
+                }
+                const arr = new Array(length);
+                for (let i = 0; i < length; i++) {
+                    const s = new vm_dynamic_struct_js_1.VmDynamicStruct();
+                    if (usedSchema) {
+                        s.readWithSchema(usedSchema, r);
+                    }
+                    else {
+                        s.read(r);
+                    }
+                    arr[i] = s;
+                }
+                sa.structs = arr;
+                outVar.type = type;
+                outVar.data = sa;
+                break;
+            }
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int8:
+                outVar.type = type;
+                outVar.data = r.readArray8();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int16:
+                outVar.type = type;
+                outVar.data = r.readArray16();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int32:
+                outVar.type = type;
+                outVar.data = r.readArray32();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int64:
+                outVar.type = type;
+                outVar.data = r.readArray64();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int256:
+                outVar.type = type;
+                outVar.data = r.readArrayBigInt();
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes16:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(bytes16_js_1.Bytes16);
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes32:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(bytes32_js_1.Bytes32);
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes64:
+                outVar.type = type;
+                outVar.data = r.readArrayBlob(bytes64_js_1.Bytes64);
+                break;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.String:
+                outVar.type = type;
+                outVar.data = r.readArraySz();
+                break;
+            default:
+                throw new Error('Unknown VmDynamicVariable type');
+        }
+    }
+    static writeStatic(type, v, schema, w) {
+        if (v.type !== type) {
+            const err = VmDynamicVariable.fromType(type);
+            return VmDynamicVariable.writeStatic(type, err, schema, w);
+        }
+        if (type === vm_type_js_1.VmType.Dynamic) {
+            if (v.data == null) {
+                w.write1((vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Dynamic) & 0xff);
+                w.write4u(0);
+                return true;
+            }
+            v.data.write(w);
+            return true;
+        }
+        if (v.data == null)
+            throw new Error('invalid object');
+        switch (type) {
+            case vm_type_js_1.VmType.Bytes:
+                w.writeArray(v.data);
+                return true;
+            case vm_type_js_1.VmType.Struct: {
+                const s = v.data;
+                if (schema)
+                    return s.writeWithSchema(schema, w);
+                else {
+                    s.write(w);
+                    return true;
+                }
+            }
+            case vm_type_js_1.VmType.Int8:
+                w.write1(v.data);
+                return true;
+            case vm_type_js_1.VmType.Int16:
+                w.write2(v.data);
+                return true;
+            case vm_type_js_1.VmType.Int32:
+                w.write4(v.data);
+                return true;
+            case vm_type_js_1.VmType.Int64:
+                w.write8u(v.data);
+                return true;
+            case vm_type_js_1.VmType.Int256:
+                w.writeBigInt(v.data);
+                return true;
+            case vm_type_js_1.VmType.Bytes16:
+                v.data.write(w);
+                return true;
+            case vm_type_js_1.VmType.Bytes32:
+                v.data.write(w);
+                return true;
+            case vm_type_js_1.VmType.Bytes64:
+                v.data.write(w);
+                return true;
+            case vm_type_js_1.VmType.String:
+                w.writeSz(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Dynamic:
+                w.writeArrayBlob(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes:
+                w.writeArrayOfArrays(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Struct: {
+                const sa = v.data;
+                w.write4u(sa.structs.length);
+                let used = schema;
+                if (!used) {
+                    sa.schema.write(w);
+                    if (sa.schema.fields.length > 0)
+                        used = sa.schema;
+                }
+                let ok = true;
+                for (const s of sa.structs) {
+                    if (used)
+                        ok = ok && s.writeWithSchema(used, w);
+                    else
+                        s.write(w);
+                }
+                return ok;
+            }
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int8:
+                w.writeArray(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int16:
+                w.writeArray16(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int32:
+                w.writeArray32(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int64:
+                w.writeArray64(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Int256:
+                w.writeArrayBigInt(v.data);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes16:
+                v.data.write(w);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes32:
+                v.data.write(w);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.Bytes64:
+                v.data.write(w);
+                return true;
+            case vm_type_js_1.VmType.Array | vm_type_js_1.VmType.String:
+                w.writeArraySz(v.data);
+                return true;
+            default:
+                throw new Error('invalid VmDynamicVariable');
+        }
+    }
+}
+exports.VmDynamicVariable = VmDynamicVariable;

package/dist/cjs/types/carbon/blockchain/vm/vm-named-dynamic-variable.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmNamedDynamicVariable = void 0;
+const index_js_1 = require("../../../../utils/index.js");
+const small_string_js_1 = require("../../small-string.js");
+const vm_dynamic_variable_js_1 = require("./vm-dynamic-variable.js");
+const vm_type_js_1 = require("./vm-type.js");
+class VmNamedDynamicVariable {
+    static from(name, type, value) {
+        const nv = new VmNamedDynamicVariable();
+        nv.name = name instanceof small_string_js_1.SmallString ? name : new small_string_js_1.SmallString(name);
+        const dyn = vm_dynamic_variable_js_1.VmDynamicVariable.fromType(type);
+        if (type === vm_type_js_1.VmType.Bytes && typeof value === 'string') {
+            dyn.data = (0, index_js_1.hexToBytes)(value);
+        }
+        else {
+            dyn.data = value;
+        }
+        nv.value = dyn;
+        return nv;
+    }
+    write(w) {
+        this.name.write(w);
+        this.value.write(w);
+    }
+    read(r) {
+        this.name = r.readBlob(small_string_js_1.SmallString);
+        this.value = r.readBlob(vm_dynamic_variable_js_1.VmDynamicVariable);
+    }
+    static read(r) {
+        const v = new VmNamedDynamicVariable();
+        v.read(r);
+        return v;
+    }
+}
+exports.VmNamedDynamicVariable = VmNamedDynamicVariable;

package/dist/cjs/types/carbon/blockchain/vm/vm-named-variable-schema.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmNamedVariableSchema = void 0;
+const small_string_js_1 = require("../../small-string.js");
+const vm_variable_schema_js_1 = require("./vm-variable-schema.js");
+class VmNamedVariableSchema {
+    constructor(name, schema) {
+        if (name) {
+            if (name instanceof small_string_js_1.SmallString) {
+                this.name = name;
+            }
+            else {
+                this.name = new small_string_js_1.SmallString(name);
+            }
+        }
+        if (schema) {
+            if (schema instanceof vm_variable_schema_js_1.VmVariableSchema) {
+                this.schema = schema;
+            }
+            else {
+                this.schema = new vm_variable_schema_js_1.VmVariableSchema(schema);
+            }
+        }
+    }
+    write(w) {
+        this.name.write(w);
+        this.schema.write(w);
+    }
+    read(r) {
+        this.name = r.readBlob(small_string_js_1.SmallString);
+        this.schema = r.readBlob(vm_variable_schema_js_1.VmVariableSchema);
+    }
+    static read(r) {
+        const v = new VmNamedVariableSchema();
+        v.read(r);
+        return v;
+    }
+}
+exports.VmNamedVariableSchema = VmNamedVariableSchema;

package/dist/cjs/types/carbon/blockchain/vm/vm-struct-array.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmStructArray = void 0;
+const vm_struct_schema_js_1 = require("./vm-struct-schema.js");
+class VmStructArray {
+    constructor() {
+        this.schema = new vm_struct_schema_js_1.VmStructSchema();
+        this.structs = [];
+    }
+}
+exports.VmStructArray = VmStructArray;

package/dist/cjs/types/carbon/blockchain/vm/vm-struct-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmStructFlags = void 0;
+var VmStructFlags;
+(function (VmStructFlags) {
+    VmStructFlags[VmStructFlags["None"] = 0] = "None";
+    VmStructFlags[VmStructFlags["DynamicExtras"] = 1] = "DynamicExtras";
+})(VmStructFlags || (exports.VmStructFlags = VmStructFlags = {}));

package/dist/cjs/types/carbon/blockchain/vm/vm-struct-schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmStructSchema = void 0;
+const vm_named_variable_schema_js_1 = require("./vm-named-variable-schema.js");
+class VmStructSchema {
+    constructor(fields, flags) {
+        this.fields = [];
+        this.flags = VmStructSchema.Flags.None;
+        if (fields) {
+            this.fields = fields;
+        }
+        if (flags) {
+            this.flags = flags;
+        }
+    }
+    write(w) {
+        w.writeArrayBlob(this.fields);
+        w.write1(this.flags & 0xff);
+    }
+    read(r) {
+        this.fields = r.readArrayBlob(vm_named_variable_schema_js_1.VmNamedVariableSchema);
+        this.flags = r.read1();
+    }
+    static read(r) {
+        const v = new VmStructSchema();
+        v.read(r);
+        return v;
+    }
+}
+exports.VmStructSchema = VmStructSchema;
+VmStructSchema.Flags = {
+    None: 0,
+    DynamicExtras: 1 << 0,
+    IsSorted: 1 << 1,
+};

package/dist/cjs/types/carbon/blockchain/vm/vm-type.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmType = void 0;
+exports.vmTypeFromString = vmTypeFromString;
+var VmType;
+(function (VmType) {
+    VmType[VmType["Dynamic"] = 0] = "Dynamic";
+    VmType[VmType["Array"] = 1] = "Array";
+    VmType[VmType["Bytes"] = 2] = "Bytes";
+    VmType[VmType["Struct"] = 4] = "Struct";
+    VmType[VmType["Int8"] = 6] = "Int8";
+    VmType[VmType["Int16"] = 8] = "Int16";
+    VmType[VmType["Int32"] = 10] = "Int32";
+    VmType[VmType["Int64"] = 12] = "Int64";
+    VmType[VmType["Int256"] = 14] = "Int256";
+    VmType[VmType["Bytes16"] = 16] = "Bytes16";
+    VmType[VmType["Bytes32"] = 18] = "Bytes32";
+    VmType[VmType["Bytes64"] = 20] = "Bytes64";
+    VmType[VmType["String"] = 22] = "String";
+    VmType[VmType["Array_Dynamic"] = 1] = "Array_Dynamic";
+    VmType[VmType["Array_Bytes"] = 3] = "Array_Bytes";
+    VmType[VmType["Array_Struct"] = 5] = "Array_Struct";
+    VmType[VmType["Array_Int8"] = 7] = "Array_Int8";
+    VmType[VmType["Array_Int16"] = 9] = "Array_Int16";
+    VmType[VmType["Array_Int32"] = 11] = "Array_Int32";
+    VmType[VmType["Array_Int64"] = 13] = "Array_Int64";
+    VmType[VmType["Array_Int256"] = 15] = "Array_Int256";
+    VmType[VmType["Array_Bytes16"] = 17] = "Array_Bytes16";
+    VmType[VmType["Array_Bytes32"] = 19] = "Array_Bytes32";
+    VmType[VmType["Array_Bytes64"] = 21] = "Array_Bytes64";
+    VmType[VmType["Array_String"] = 23] = "Array_String";
+})(VmType || (exports.VmType = VmType = {}));
+function vmTypeFromString(type) {
+    const map = {
+        Dynamic: VmType.Dynamic,
+        Array: VmType.Array,
+        Bytes: VmType.Bytes,
+        Struct: VmType.Struct,
+        Int8: VmType.Int8,
+        Int16: VmType.Int16,
+        Int32: VmType.Int32,
+        Int64: VmType.Int64,
+        Int256: VmType.Int256,
+        Bytes16: VmType.Bytes16,
+        Bytes32: VmType.Bytes32,
+        Bytes64: VmType.Bytes64,
+        String: VmType.String,
+        Array_Dynamic: VmType.Array_Dynamic,
+        Array_Bytes: VmType.Array_Bytes,
+        Array_Struct: VmType.Array_Struct,
+        Array_Int8: VmType.Array_Int8,
+        Array_Int16: VmType.Array_Int16,
+        Array_Int32: VmType.Array_Int32,
+        Array_Int64: VmType.Array_Int64,
+        Array_Int256: VmType.Array_Int256,
+        Array_Bytes16: VmType.Array_Bytes16,
+        Array_Bytes32: VmType.Array_Bytes32,
+        Array_Bytes64: VmType.Array_Bytes64,
+        Array_String: VmType.Array_String,
+    };
+    const value = map[type.trim()];
+    if (value === undefined) {
+        throw new Error(`Unknown VmType: ${type}`);
+    }
+    return value;
+}

package/dist/cjs/types/carbon/blockchain/vm/vm-variable-schema.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VmVariableSchema = void 0;
+const vm_type_js_1 = require("./vm-type.js");
+const vm_struct_schema_js_1 = require("./vm-struct-schema.js");
+class VmVariableSchema {
+    constructor(type, structure) {
+        if (type)
+            this.type = type;
+        if (structure)
+            this.structure = structure;
+    }
+    write(w) {
+        w.write1(this.type & 0xff);
+        if (this.type === vm_type_js_1.VmType.Struct || this.type === (vm_type_js_1.VmType.Struct | vm_type_js_1.VmType.Array)) {
+            this.structure.write(w);
+        }
+    }
+    read(r) {
+        this.type = r.read1();
+        if (this.type === vm_type_js_1.VmType.Struct || this.type === (vm_type_js_1.VmType.Struct | vm_type_js_1.VmType.Array)) {
+            this.structure = r.readBlob(vm_struct_schema_js_1.VmStructSchema);
+        }
+    }
+    static read(r) {
+        const v = new VmVariableSchema();
+        v.read(r);
+        return v;
+    }
+}
+exports.VmVariableSchema = VmVariableSchema;

package/dist/cjs/types/carbon/bytes16.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bytes16 = void 0;
+const hex_js_1 = require("../../utils/hex.js");
+class Bytes16 {
+    constructor(bytes = new Uint8Array(16)) {
+        this.bytes = bytes;
+        if (bytes.length !== 16)
+            throw new Error('Bytes16 length must be 16');
+        this.bytes = new Uint8Array(bytes);
+    }
+    write(w) {
+        w.write16(this.bytes);
+    }
+    read(r) {
+        this.bytes = r.read16();
+    }
+    static read(r) {
+        const v = new Bytes16();
+        v.read(r);
+        return v;
+    }
+    equals(other) {
+        const a = this.bytes, b = other.bytes;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    toHex() {
+        return (0, hex_js_1.bytesToHex)(this.bytes);
+    }
+    /** @deprecated Use `toHex` instead. This alias will be removed in v1.0. */
+    ToHex() {
+        return this.toHex();
+    }
+    // Used by console.log / util.inspect
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        // Return a pretty, concise representation
+        return `Bytes16(${this.toHex()})`;
+    }
+}
+exports.Bytes16 = Bytes16;
+Bytes16.Empty = new Bytes16(new Uint8Array(16));

package/dist/cjs/types/carbon/bytes32.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bytes32 = void 0;
+const hex_js_1 = require("../../utils/hex.js");
+class Bytes32 {
+    constructor(bytes = new Uint8Array(32)) {
+        this.bytes = bytes;
+        if (bytes.length !== 32)
+            throw new Error('Bytes32 length must be 32');
+        this.bytes = new Uint8Array(bytes);
+    }
+    write(w) {
+        w.write32(this.bytes);
+    }
+    read(r) {
+        this.bytes = r.read32();
+    }
+    static read(r) {
+        const v = new Bytes32();
+        v.read(r);
+        return v;
+    }
+    equals(other) {
+        const a = this.bytes, b = other.bytes;
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    toHex() {
+        return (0, hex_js_1.bytesToHex)(this.bytes);
+    }
+    /** @deprecated Use `toHex` instead. This alias will be removed in v1.0. */
+    ToHex() {
+        return this.toHex();
+    }
+    // Used by console.log / util.inspect
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        // Return a pretty, concise representation
+        return `Bytes32(${this.toHex()})`;
+    }
+}
+exports.Bytes32 = Bytes32;
+Bytes32.Empty = new Bytes32(new Uint8Array(32));