@fhevm/sdk 0.0.1 → 1.0.0-alpha.1

package/_cjs/core/base/trustedValue.js

@@ -0,0 +1,50 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TrustedValueImpl_value, _TrustedValueImpl_originToken;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrustedValue = createTrustedValue;
+exports.verifyTrustedValue = verifyTrustedValue;
+class TrustedValueImpl {
+    constructor(value, originToken) {
+        _TrustedValueImpl_value.set(this, void 0);
+        _TrustedValueImpl_originToken.set(this, void 0);
+        __classPrivateFieldSet(this, _TrustedValueImpl_value, value, "f");
+        __classPrivateFieldSet(this, _TrustedValueImpl_originToken, originToken, "f");
+        Object.freeze(this);
+    }
+    static verify(trustedValue, token) {
+        if (!(trustedValue instanceof TrustedValueImpl)) {
+            throw new Error('Invalid TrustedValue');
+        }
+        if (token !== __classPrivateFieldGet(trustedValue, _TrustedValueImpl_originToken, "f")) {
+            throw new Error('Token mismatch');
+        }
+        return __classPrivateFieldGet(trustedValue, _TrustedValueImpl_value, "f");
+    }
+    toString() {
+        return 'TrustedValue';
+    }
+    toJSON() {
+        return 'TrustedValue';
+    }
+}
+_TrustedValueImpl_value = new WeakMap(), _TrustedValueImpl_originToken = new WeakMap();
+Object.freeze(TrustedValueImpl.prototype);
+Object.freeze(TrustedValueImpl);
+function createTrustedValue(value, token) {
+    return new TrustedValueImpl(value, token);
+}
+function verifyTrustedValue(trustedValue, token) {
+    return TrustedValueImpl.verify(trustedValue, token);
+}
+//# sourceMappingURL=trustedValue.js.map

package/_cjs/core/base/trustedValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trustedValue.js","sourceRoot":"","sources":["../../../core/base/trustedValue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AA2FA,gDAGC;AAaD,gDAEC;AApED,MAAM,gBAAgB;IAMpB,YAAY,KAAc,EAAE,WAAmB;QAHtC,0CAAgB;QAChB,gDAAqB;QAG5B,uBAAA,IAAI,2BAAU,KAAK,MAAA,CAAC;QACpB,uBAAA,IAAI,iCAAgB,WAAW,MAAA,CAAC;QAChC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACtB,CAAC;IAEM,MAAM,CAAC,MAAM,CAAI,YAA6B,EAAE,KAAa;QAClE,IAAI,CAAC,CAAC,YAAY,YAAY,gBAAgB,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,KAAK,KAAK,uBAAA,YAAY,qCAAa,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACpC,CAAC;QACD,OAAO,uBAAA,YAAY,+BAAY,CAAC;IAClC,CAAC;IAKM,QAAQ;QACb,OAAO,cAAc,CAAC;IACxB,CAAC;IAKM,MAAM;QACX,OAAO,cAAc,CAAC;IACxB,CAAC;CACF;;AAED,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;AAC1C,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAYhC,SAAgB,kBAAkB,CAAI,KAAQ,EAAE,KAAa;IAE3D,OAAO,IAAI,gBAAgB,CAAI,KAAK,EAAE,KAAK,CAAC,CAAC;AAC/C,CAAC;AAaD,SAAgB,kBAAkB,CAAI,YAA6B,EAAE,KAAa;IAChF,OAAO,gBAAgB,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;AACtD,CAAC"}

package/_cjs/core/base/typedValue.js

@@ -0,0 +1,184 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TypedValueImpl_type, _TypedValueImpl_value, _TypedValueArrayBuilder_instances, _TypedValueArrayBuilder_arr, _TypedValueArrayBuilder_push;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedValueArrayBuilder = void 0;
+exports.isTypedValue = isTypedValue;
+exports.assertIsTypedValue = assertIsTypedValue;
+exports.assertIsTypedValueArray = assertIsTypedValueArray;
+exports.createTypedValue = createTypedValue;
+exports.createTypedValueArray = createTypedValueArray;
+exports.isTypedValueArray = isTypedValueArray;
+const address_js_1 = require("./address.js");
+const boolean_js_1 = require("./boolean.js");
+const InvalidTypeError_js_1 = require("./errors/InvalidTypeError.js");
+const uint_js_1 = require("./uint.js");
+class TypedValueImpl {
+    constructor(value, type) {
+        _TypedValueImpl_type.set(this, void 0);
+        _TypedValueImpl_value.set(this, void 0);
+        __classPrivateFieldSet(this, _TypedValueImpl_value, value, "f");
+        __classPrivateFieldSet(this, _TypedValueImpl_type, type, "f");
+    }
+    get type() {
+        return __classPrivateFieldGet(this, _TypedValueImpl_type, "f");
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _TypedValueImpl_value, "f");
+    }
+    toString() {
+        return `TypedValue<${__classPrivateFieldGet(this, _TypedValueImpl_type, "f")}>`;
+    }
+    toJSON() {
+        return { type: __classPrivateFieldGet(this, _TypedValueImpl_type, "f") };
+    }
+}
+_TypedValueImpl_type = new WeakMap(), _TypedValueImpl_value = new WeakMap();
+Object.freeze(TypedValueImpl.prototype);
+function isTypedValue(value, options) {
+    if (!(value instanceof TypedValueImpl)) {
+        return false;
+    }
+    if (options?.type !== undefined) {
+        return value.type === options.type;
+    }
+    return true;
+}
+function assertIsTypedValue(value, options) {
+    const expectedType = options.type !== undefined ? `TypedValue<${options.type}>` : 'TypedValue';
+    const isValid = options.type !== undefined ? isTypedValue(value, { type: options.type }) : isTypedValue(value);
+    if (!isValid) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType,
+        }, options);
+    }
+}
+function assertIsTypedValueArray(values, options) {
+    if (!Array.isArray(values)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof values,
+            expectedType: 'TypedValue[]',
+        }, options);
+    }
+    for (let i = 0; i < values.length; ++i) {
+        if (!isTypedValue(values[i])) {
+            throw new InvalidTypeError_js_1.InvalidTypeError({
+                subject: options.subject,
+                index: i,
+                type: typeof values[i],
+                expectedType: 'TypedValue',
+            }, options);
+        }
+    }
+}
+function createTypedValue(input) {
+    if (input == null || typeof input !== 'object') {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: 'input',
+            type: typeof input,
+            expectedType: 'InputTypedValue ({ type, value })',
+        }, {});
+    }
+    if (isTypedValue(input)) {
+        return input;
+    }
+    const expectedType = input.type;
+    let validatedValue;
+    if (expectedType === 'bool') {
+        validatedValue = (0, boolean_js_1.toBoolean)(input.value, {});
+    }
+    else if (expectedType === 'address') {
+        validatedValue = (0, address_js_1.asAddress)(input.value);
+    }
+    else {
+        validatedValue = (0, uint_js_1.normalizeUintForType)((0, uint_js_1.asUintForType)(input.value, expectedType, {}), expectedType);
+    }
+    const v = new TypedValueImpl(validatedValue, expectedType);
+    Object.freeze(v);
+    return v;
+}
+function createTypedValueArray(inputs) {
+    return inputs.map(createTypedValue);
+}
+function isTypedValueArray(arr) {
+    return arr.every((v) => isTypedValue(v));
+}
+class TypedValueArrayBuilder {
+    constructor() {
+        _TypedValueArrayBuilder_instances.add(this);
+        _TypedValueArrayBuilder_arr.set(this, []);
+    }
+    addBool(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'bool', value);
+    }
+    addUint8(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'uint8', value);
+    }
+    addUint16(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'uint16', value);
+    }
+    addUint32(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'uint32', value);
+    }
+    addUint64(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'uint64', value);
+    }
+    addUint128(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'uint128', value);
+    }
+    addUint256(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'uint256', value);
+    }
+    addAddress(value) {
+        return __classPrivateFieldGet(this, _TypedValueArrayBuilder_instances, "m", _TypedValueArrayBuilder_push).call(this, 'address', value);
+    }
+    addTypedValue(typedValue) {
+        if (!isTypedValue(typedValue)) {
+            throw new InvalidTypeError_js_1.InvalidTypeError({
+                subject: 'typedValue',
+                type: typeof typedValue,
+                expectedType: 'TypedValue',
+            }, {});
+        }
+        __classPrivateFieldGet(this, _TypedValueArrayBuilder_arr, "f").push(typedValue);
+        return this;
+    }
+    build() {
+        return Object.freeze([...__classPrivateFieldGet(this, _TypedValueArrayBuilder_arr, "f")]);
+    }
+}
+exports.TypedValueArrayBuilder = TypedValueArrayBuilder;
+_TypedValueArrayBuilder_arr = new WeakMap(), _TypedValueArrayBuilder_instances = new WeakSet(), _TypedValueArrayBuilder_push = function _TypedValueArrayBuilder_push(typeName, value) {
+    if (isTypedValue(value, { type: typeName })) {
+        __classPrivateFieldGet(this, _TypedValueArrayBuilder_arr, "f").push(value);
+    }
+    else if (typeof value === 'object' && value !== null) {
+        const tv = value;
+        if (tv.type !== typeName) {
+            throw new InvalidTypeError_js_1.InvalidTypeError({
+                subject: 'value',
+                type: tv.type,
+                expectedType: typeName,
+            }, {});
+        }
+        __classPrivateFieldGet(this, _TypedValueArrayBuilder_arr, "f").push(createTypedValue({ type: typeName, value: tv.value }));
+    }
+    else {
+        __classPrivateFieldGet(this, _TypedValueArrayBuilder_arr, "f").push(createTypedValue({ type: typeName, value }));
+    }
+    return this;
+};
+//# sourceMappingURL=typedValue.js.map

package/_cjs/core/base/typedValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedValue.js","sourceRoot":"","sources":["../../../core/base/typedValue.ts"],"names":[],"mappings":"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"}

package/_cjs/core/base/uid.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uid = uid;
+const size = 256;
+let index = size;
+let buffer;
+function uid(length = 11) {
+    if (!buffer || index + length > size * 2) {
+        buffer = '';
+        index = 0;
+        for (let i = 0; i < size; i++) {
+            buffer += ((256 + Math.random() * 256) | 0).toString(16).substring(1);
+        }
+    }
+    const start = index;
+    index += length;
+    return buffer.substring(start, start + length);
+}
+//# sourceMappingURL=uid.js.map

package/_cjs/core/base/uid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid.js","sourceRoot":"","sources":["../../../core/base/uid.ts"],"names":[],"mappings":";;AAIA,kBAYC;AAhBD,MAAM,IAAI,GAAG,GAAG,CAAC;AACjB,IAAI,KAAK,GAAG,IAAI,CAAC;AACjB,IAAI,MAAc,CAAC;AAEnB,SAAgB,GAAG,CAAC,MAAM,GAAG,EAAE;IAE7B,IAAI,CAAC,MAAM,IAAI,KAAK,GAAG,MAAM,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,GAAG,EAAE,CAAC;QACZ,KAAK,GAAG,CAAC,CAAC;QACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IACD,MAAM,KAAK,GAAG,KAAK,CAAC;IACpB,KAAK,IAAI,MAAM,CAAC;IAChB,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC;AACjD,CAAC"}

package/_cjs/core/base/uint.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_UINT_FOR_TYPE = exports.MAX_UINT256 = exports.MAX_UINT160 = exports.MAX_UINT128 = exports.MAX_UINT64 = exports.MAX_UINT32 = exports.MAX_UINT16 = exports.MAX_UINT8 = void 0;
+exports.bigIntToNumber = bigIntToNumber;
+exports.isUintNumber = isUintNumber;
+exports.isUintBigInt = isUintBigInt;
+exports.isUintForType = isUintForType;
+exports.isUintForByteLength = isUintForByteLength;
+exports.isUint = isUint;
+exports.isUint8 = isUint8;
+exports.isUint16 = isUint16;
+exports.isUint32 = isUint32;
+exports.isUint64 = isUint64;
+exports.isUint128 = isUint128;
+exports.isUint256 = isUint256;
+exports.isUint64BigInt = isUint64BigInt;
+exports.numberToBytesHexNo0x = numberToBytesHexNo0x;
+exports.numberToBytesHex = numberToBytesHex;
+exports.numberToBytes32 = numberToBytes32;
+exports.numberToBytes8 = numberToBytes8;
+exports.uintToHex0x = uintToHex0x;
+exports.uintToBytesHex = uintToBytesHex;
+exports.uintToBytesHexNo0x = uintToBytesHexNo0x;
+exports.uint256ToBytes32 = uint256ToBytes32;
+exports.uint32ToBytes32 = uint32ToBytes32;
+exports.uint64ToBytes32 = uint64ToBytes32;
+exports.assertIsUint = assertIsUint;
+exports.assertIsUintForType = assertIsUintForType;
+exports.assertIsUintNumber = assertIsUintNumber;
+exports.assertIsUintBigInt = assertIsUintBigInt;
+exports.assertIsUint8 = assertIsUint8;
+exports.assertIsUint16 = assertIsUint16;
+exports.assertIsUint32 = assertIsUint32;
+exports.assertIsUint64 = assertIsUint64;
+exports.assertIsUint128 = assertIsUint128;
+exports.assertIsUint256 = assertIsUint256;
+exports.normalizeUintForType = normalizeUintForType;
+exports.asUintForType = asUintForType;
+exports.asUint = asUint;
+exports.asUint8 = asUint8;
+exports.asUint16 = asUint16;
+exports.asUint32 = asUint32;
+exports.asUint64 = asUint64;
+exports.asUint128 = asUint128;
+exports.asUint256 = asUint256;
+exports.asUint8Number = asUint8Number;
+exports.asUint32Number = asUint32Number;
+exports.asUint32BigInt = asUint32BigInt;
+exports.asUint64BigInt = asUint64BigInt;
+exports.asUint256BigInt = asUint256BigInt;
+exports.isRecordUintProperty = isRecordUintProperty;
+exports.assertRecordUintProperty = assertRecordUintProperty;
+exports.isRecordUint256Property = isRecordUint256Property;
+exports.assertRecordUint256Property = assertRecordUint256Property;
+exports.assertRecordUintNumberProperty = assertRecordUintNumberProperty;
+exports.assertRecordUintBigIntProperty = assertRecordUintBigIntProperty;
+const record_js_1 = require("./record.js");
+const InvalidPropertyError_js_1 = require("./errors/InvalidPropertyError.js");
+const InvalidTypeError_js_1 = require("./errors/InvalidTypeError.js");
+exports.MAX_UINT8 = 0xff;
+exports.MAX_UINT16 = 0xffff;
+exports.MAX_UINT32 = 0xffffffff;
+exports.MAX_UINT64 = 0xffffffffffffffffn;
+exports.MAX_UINT128 = 0xffffffffffffffffffffffffffffffffn;
+exports.MAX_UINT160 = 0xffffffffffffffffffffffffffffffffffffffffn;
+exports.MAX_UINT256 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+exports.MAX_UINT_FOR_TYPE = {
+    bool: 1,
+    uint8: exports.MAX_UINT8,
+    uint16: exports.MAX_UINT16,
+    uint32: exports.MAX_UINT32,
+    uint64: exports.MAX_UINT64,
+    uint128: exports.MAX_UINT128,
+    uint160: exports.MAX_UINT160,
+    uint256: exports.MAX_UINT256,
+    address: exports.MAX_UINT160,
+};
+Object.freeze(exports.MAX_UINT_FOR_TYPE);
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+function bigIntToNumber(value, options) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (value > MAX_SAFE_INTEGER_BIGINT) {
+        const subject = options?.subject !== undefined ? ` (${options.subject})` : '';
+        throw new Error(`Value${subject} ${value} exceeds Number.MAX_SAFE_INTEGER`);
+    }
+    return Number(value);
+}
+const MAX_UINT_FOR_BYTE_LENGTH = {
+    1: exports.MAX_UINT8,
+    2: exports.MAX_UINT16,
+    4: exports.MAX_UINT32,
+    8: exports.MAX_UINT64,
+    16: exports.MAX_UINT128,
+    20: exports.MAX_UINT160,
+    32: exports.MAX_UINT256,
+};
+Object.freeze(MAX_UINT_FOR_BYTE_LENGTH);
+function isUintNumber(value, max) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 && (max === undefined || value <= max);
+}
+function isUintBigInt(value, max) {
+    return typeof value === 'bigint' && value >= 0 && (max === undefined || value <= max);
+}
+function isUintForType(value, typeName) {
+    return isUint(value, typeName !== undefined ? exports.MAX_UINT_FOR_TYPE[typeName] : undefined);
+}
+function isUintForByteLength(value, byteLength) {
+    return isUint(value, byteLength !== undefined ? MAX_UINT_FOR_BYTE_LENGTH[byteLength] : undefined);
+}
+function isUint(value, max) {
+    return isUintNumber(value, max) || isUintBigInt(value, max);
+}
+function isUint8(value) {
+    return isUint(value, exports.MAX_UINT8);
+}
+function isUint16(value) {
+    return isUint(value, exports.MAX_UINT16);
+}
+function isUint32(value) {
+    return isUint(value, exports.MAX_UINT32);
+}
+function isUint64(value) {
+    return isUint(value, exports.MAX_UINT64);
+}
+function isUint128(value) {
+    return isUint(value, exports.MAX_UINT128);
+}
+function isUint256(value) {
+    return isUint(value, exports.MAX_UINT256);
+}
+function isUint64BigInt(value) {
+    if (typeof value !== 'bigint')
+        return false;
+    return isUint(value, exports.MAX_UINT64);
+}
+function numberToBytesHexNo0x(num) {
+    const hex = num.toString(16);
+    return (hex.length % 2 !== 0 ? '0' + hex : hex);
+}
+function numberToBytesHex(num) {
+    return `0x${numberToBytesHexNo0x(num)}`;
+}
+function numberToBytes32(num) {
+    if (!isUintNumber(num)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({ expectedType: 'uintNumber' }, {});
+    }
+    const buffer = new ArrayBuffer(32);
+    const view = new DataView(buffer);
+    view.setBigUint64(24, BigInt(num), false);
+    return new Uint8Array(buffer);
+}
+function numberToBytes8(num) {
+    if (!isUintNumber(num)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({ expectedType: 'uintNumber' }, {});
+    }
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setBigUint64(0, BigInt(num), false);
+    return new Uint8Array(buffer);
+}
+function uintToHex0x(uint) {
+    return `0x${uint.toString(16)}`;
+}
+function uintToBytesHex(uint) {
+    const hex = uint.toString(16);
+    return (hex.length % 2 !== 0 ? `0x0${hex}` : `0x${hex}`);
+}
+function uintToBytesHexNo0x(uint) {
+    const hex = uint.toString(16);
+    return (hex.length % 2 !== 0 ? `0${hex}` : hex);
+}
+function uint256ToBytes32(value) {
+    if (!isUint256(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({ expectedType: 'uint256' }, {});
+    }
+    const buffer = new ArrayBuffer(32);
+    const view = new DataView(buffer);
+    const v = BigInt(value);
+    view.setBigUint64(24, v & 0xffffffffffffffffn, false);
+    view.setBigUint64(16, (v >> 64n) & 0xffffffffffffffffn, false);
+    view.setBigUint64(8, (v >> 128n) & 0xffffffffffffffffn, false);
+    view.setBigUint64(0, (v >> 192n) & 0xffffffffffffffffn, false);
+    return new Uint8Array(buffer);
+}
+function uint32ToBytes32(value) {
+    if (!isUint32(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({ expectedType: 'uint32' }, {});
+    }
+    const buffer = new ArrayBuffer(32);
+    const view = new DataView(buffer);
+    const v = Number(value);
+    view.setUint32(28, v, false);
+    return new Uint8Array(buffer);
+}
+function uint64ToBytes32(value) {
+    if (!isUint64(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({ expectedType: 'uint64' }, {});
+    }
+    const buffer = new ArrayBuffer(32);
+    const view = new DataView(buffer);
+    const v = BigInt(value);
+    view.setBigUint64(24, v, false);
+    return new Uint8Array(buffer);
+}
+function assertIsUint(value, options) {
+    if (!isUint(value, options.max)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint',
+        }, options);
+    }
+}
+function assertIsUintForType(value, typeName, options) {
+    if (!isUintForType(value, typeName)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: typeName,
+        }, options);
+    }
+}
+function assertIsUintNumber(value, options) {
+    if (!isUintNumber(value, options.max)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uintNumber',
+        }, options);
+    }
+}
+function assertIsUintBigInt(value, options) {
+    if (!isUintBigInt(value, options.max)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uintBigInt',
+        }, options);
+    }
+}
+function assertIsUint8(value, options) {
+    if (!isUint8(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint8',
+        }, options);
+    }
+}
+function assertIsUint16(value, options) {
+    if (!isUint16(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint16',
+        }, options);
+    }
+}
+function assertIsUint32(value, options) {
+    if (!isUint32(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint32',
+        }, options);
+    }
+}
+function assertIsUint64(value, options) {
+    if (!isUint64(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint64',
+        }, options);
+    }
+}
+function assertIsUint128(value, options) {
+    if (!isUint256(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint128',
+        }, options);
+    }
+}
+function assertIsUint256(value, options) {
+    if (!isUint256(value)) {
+        throw new InvalidTypeError_js_1.InvalidTypeError({
+            subject: options.subject,
+            type: typeof value,
+            expectedType: 'uint256',
+        }, options);
+    }
+}
+function normalizeUintForType(value, typeName) {
+    switch (typeName) {
+        case 'uint8':
+        case 'uint16':
+        case 'uint32':
+            return Number(value);
+        case 'uint64':
+        case 'uint128':
+        case 'uint160':
+        case 'uint256':
+            return BigInt(value);
+    }
+}
+function asUintForType(value, typeName, options) {
+    assertIsUintForType(value, typeName, options);
+    return value;
+}
+function asUint(value, options) {
+    assertIsUint(value, options ?? {});
+    return value;
+}
+function asUint8(value, options) {
+    assertIsUint8(value, options ?? {});
+    return value;
+}
+function asUint16(value, options) {
+    assertIsUint16(value, options ?? {});
+    return value;
+}
+function asUint32(value, options) {
+    assertIsUint32(value, options ?? {});
+    return value;
+}
+function asUint64(value, options) {
+    assertIsUint64(value, options ?? {});
+    return value;
+}
+function asUint128(value, options) {
+    assertIsUint128(value, options ?? {});
+    return value;
+}
+function asUint256(value, options) {
+    assertIsUint256(value, options ?? {});
+    return value;
+}
+function asUint8Number(value, options) {
+    assertIsUintNumber(value, { max: exports.MAX_UINT8, ...options });
+    return value;
+}
+function asUint32Number(value, options) {
+    assertIsUintNumber(value, { max: exports.MAX_UINT32, ...options });
+    return value;
+}
+function asUint32BigInt(value, options) {
+    assertIsUintBigInt(value, { max: exports.MAX_UINT32, ...options });
+    return value;
+}
+function asUint64BigInt(value, options) {
+    assertIsUintBigInt(value, { max: exports.MAX_UINT64, ...options });
+    return value;
+}
+function asUint256BigInt(value, options) {
+    assertIsUintBigInt(value, { max: exports.MAX_UINT256, ...options });
+    return value;
+}
+function isRecordUintProperty(record, property) {
+    if (!(0, record_js_1.isRecordNonNullableProperty)(record, property)) {
+        return false;
+    }
+    return isUint(record[property]);
+}
+function assertRecordUintProperty(record, property, recordName, options) {
+    if (!isRecordUintProperty(record, property)) {
+        throw new InvalidPropertyError_js_1.InvalidPropertyError({
+            subject: recordName,
+            property,
+            type: (0, record_js_1.typeofProperty)(record, property),
+            expectedType: 'uint',
+        }, options);
+    }
+}
+function isRecordUint256Property(record, property) {
+    if (!(0, record_js_1.isRecordNonNullableProperty)(record, property)) {
+        return false;
+    }
+    return isUint256(record[property]);
+}
+function assertRecordUint256Property(record, property, recordName, options) {
+    if (!isRecordUint256Property(record, property)) {
+        throw new InvalidPropertyError_js_1.InvalidPropertyError({
+            subject: recordName,
+            property,
+            type: (0, record_js_1.typeofProperty)(record, property),
+            expectedType: 'uint256',
+        }, options);
+    }
+}
+function assertRecordUintNumberProperty(record, property, recordName, options) {
+    if ((0, record_js_1.typeofProperty)(record, property) !== 'number' || !isUintNumber(record[property])) {
+        throw new InvalidPropertyError_js_1.InvalidPropertyError({
+            subject: recordName,
+            property,
+            type: (0, record_js_1.typeofProperty)(record, property),
+            expectedType: 'uintNumber',
+        }, options);
+    }
+}
+function assertRecordUintBigIntProperty(record, property, recordName, options) {
+    if ((0, record_js_1.typeofProperty)(record, property) !== 'bigint' || !isUintBigInt(record[property])) {
+        throw new InvalidPropertyError_js_1.InvalidPropertyError({
+            subject: recordName,
+            property,
+            type: (0, record_js_1.typeofProperty)(record, property),
+            expectedType: 'uintBigInt',
+        }, options);
+    }
+}
+//# sourceMappingURL=uint.js.map