@atomiqlabs/chain-starknet 8.0.13 → 8.1.10

package/dist/utils/Utils.js

@@ -1,303 +1,304 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUint256 = isUint256;
-exports.timeoutPromise = timeoutPromise;
-exports.onceAsync = onceAsync;
-exports.getLogger = getLogger;
-exports.tryWithRetries = tryWithRetries;
-exports.toHex = toHex;
-exports.calculateHash = calculateHash;
-exports.u32ArrayToBuffer = u32ArrayToBuffer;
-exports.bufferToU32Array = bufferToU32Array;
-exports.u32ReverseEndianness = u32ReverseEndianness;
-exports.bigNumberishToBuffer = bigNumberishToBuffer;
-exports.toBigInt = toBigInt;
-exports.bytes31SpanToBuffer = bytes31SpanToBuffer;
-exports.bufferToBytes31Span = bufferToBytes31Span;
-exports.bufferToByteArray = bufferToByteArray;
-exports.poseidonHashRange = poseidonHashRange;
-exports.findLastIndex = findLastIndex;
-exports.bigIntMax = bigIntMax;
-exports.serializeSignature = serializeSignature;
-exports.deserializeSignature = deserializeSignature;
-exports.serializeResourceBounds = serializeResourceBounds;
-exports.deserializeResourceBounds = deserializeResourceBounds;
-const starknet_1 = require("starknet");
-const buffer_1 = require("buffer");
-function isUint256(val) {
-    return val.low != null && val.high != null;
-}
-function timeoutPromise(timeoutMillis, abortSignal) {
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(resolve, timeoutMillis);
-        if (abortSignal != null)
-            abortSignal.addEventListener("abort", () => {
-                clearTimeout(timeout);
-                reject(new Error("Aborted"));
-            });
-    });
-}
-function onceAsync(executor) {
-    let promise;
-    return () => {
-        if (promise == null) {
-            promise = executor();
-            return promise;
-        }
-        else {
-            return promise.catch(() => promise = executor());
-        }
-    };
-}
-function getLogger(prefix) {
-    return {
-        // @ts-ignore
-        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
-        // @ts-ignore
-        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
-        // @ts-ignore
-        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
-        // @ts-ignore
-        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
-    };
-}
-const logger = getLogger("Utils: ");
-async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
-    retryPolicy = retryPolicy || {};
-    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
-    retryPolicy.delay = retryPolicy.delay || 500;
-    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
-    let err = null;
-    for (let i = 0; i < retryPolicy.maxRetries; i++) {
-        try {
-            const resp = await func();
-            return resp;
-        }
-        catch (e) {
-            if (errorAllowed != null && errorAllowed(e))
-                throw e;
-            err = e;
-            logger.error("tryWithRetries(): error on try number: " + i, e);
-        }
-        if (abortSignal != null && abortSignal.aborted)
-            throw new Error("Aborted");
-        if (i !== retryPolicy.maxRetries - 1) {
-            await timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
-        }
-    }
-    throw err;
-}
-function toHex(value, length = 64) {
-    if (value == null)
-        return null;
-    if (typeof (value) === "string")
-        value = BigInt(value);
-    switch (typeof (value)) {
-        case "number":
-        case "bigint":
-            return "0x" + value.toString(16).padStart(length, "0");
-    }
-    return "0x" + value.toString("hex").padStart(length, "0");
-}
-function calculateHash(tx) {
-    if (tx.signed == null)
-        throw new Error("Cannot calculate hash for an unsigned transaction!");
-    const commonData = {
-        version: tx.details.version,
-        maxFee: tx.details.maxFee,
-        chainId: tx.details.chainId,
-        nonce: tx.details.nonce,
-        accountDeploymentData: tx.details.accountDeploymentData,
-        nonceDataAvailabilityMode: starknet_1.EDAMode[tx.details.nonceDataAvailabilityMode],
-        feeDataAvailabilityMode: starknet_1.EDAMode[tx.details.feeDataAvailabilityMode],
-        resourceBounds: tx.details.resourceBounds,
-        tip: tx.details.tip,
-        paymasterData: tx.details.paymasterData
-    };
-    switch (tx.type) {
-        case "INVOKE":
-            if (tx.signed.calldata == null ||
-                tx.details.walletAddress == null)
-                throw new Error("TX not enough data to compute hash!");
-            const invokeData = starknet_1.CallData.compile(tx.signed.calldata);
-            return tx.txId = starknet_1.hash.calculateInvokeTransactionHash({
-                senderAddress: tx.details.walletAddress,
-                compiledCalldata: invokeData,
-                ...commonData
-            });
-        case "DEPLOY_ACCOUNT":
-            if (tx.signed.constructorCalldata == null ||
-                tx.signed.addressSalt == null ||
-                tx.tx.contractAddress == null)
-                throw new Error("TX not enough data to compute hash!");
-            const deployAccountData = starknet_1.CallData.compile(tx.signed.constructorCalldata);
-            return tx.txId = starknet_1.hash.calculateDeployAccountTransactionHash({
-                contractAddress: tx.tx.contractAddress,
-                classHash: tx.signed.classHash,
-                compiledConstructorCalldata: deployAccountData,
-                salt: tx.signed.addressSalt,
-                ...commonData
-            });
-        default:
-            throw new Error("Unsupported tx type!");
-    }
-}
-function u32ArrayToBuffer(arr) {
-    const buffer = buffer_1.Buffer.alloc(4 * arr.length);
-    for (let i = 0; i < arr.length; i++) {
-        buffer.writeUInt32BE(Number(arr[i]), i * 4);
-    }
-    return buffer;
-}
-function bufferToU32Array(buffer) {
-    const result = [];
-    for (let i = 0; i < buffer.length; i += 4) {
-        result.push(buffer.readUInt32BE(i));
-    }
-    return result;
-}
-function u32ReverseEndianness(value) {
-    const valueBN = BigInt(value);
-    return Number(((valueBN & 0xffn) << 24n) |
-        ((valueBN & 0xff00n) << 8n) |
-        ((valueBN >> 8n) & 0xff00n) |
-        ((valueBN >> 24n) & 0xffn));
-}
-function bigNumberishToBuffer(value, length) {
-    if (isUint256(value)) {
-        return buffer_1.Buffer.concat([bigNumberishToBuffer(value.high, 16), bigNumberishToBuffer(value.low, 16)]);
-    }
-    if (typeof (value) === "string") {
-        if (value.startsWith("0x")) {
-            value = value.slice(2);
-        }
-        else {
-            value = BigInt(value).toString(16);
-        }
-    }
-    else {
-        value = value.toString(16);
-    }
-    if (length != null)
-        value = value.padStart(length * 2, "0");
-    const buff = buffer_1.Buffer.from(value, "hex");
-    if (length != null && buff.length > length)
-        return buff.slice(buff.length - length);
-    return buff;
-}
-function toBigInt(value) {
-    if (value == null)
-        return null;
-    if (isUint256(value)) {
-        return (toBigInt(value.high) << 128n) | toBigInt(value.low);
-    }
-    if (typeof (value) === "string") {
-        if (!value.startsWith("0x"))
-            value = "0x" + value;
-        return BigInt(value);
-    }
-    if (typeof (value) === "bigint") {
-        return value;
-    }
-    return BigInt(value);
-}
-function bytes31SpanToBuffer(span, length) {
-    const buffers = [];
-    const numFullBytes31 = Math.floor(length / 31);
-    const additionalBytes = length - (numFullBytes31 * 31);
-    const requiredSpanLength = numFullBytes31 + (additionalBytes === 0 ? 0 : 1);
-    if (span.length < requiredSpanLength)
-        throw new Error("Not enough bytes in the felt array!");
-    let i = 0;
-    for (; i < numFullBytes31; i++) {
-        buffers.push(bigNumberishToBuffer(span[i], 31));
-    }
-    if (additionalBytes !== 0)
-        buffers.push(bigNumberishToBuffer(span[i], additionalBytes));
-    return buffer_1.Buffer.concat(buffers);
-}
-function bufferToBytes31Span(buffer, startIndex = 0, endIndex = buffer.length) {
-    const values = [];
-    for (let i = startIndex + 31; i < endIndex; i += 31) {
-        values.push(BigInt("0x" + buffer.slice(i - 31, i).toString("hex")));
-    }
-    if (endIndex > startIndex + (values.length * 31))
-        values.push(BigInt("0x" + buffer.slice(startIndex + (values.length * 31), endIndex).toString("hex")));
-    return values;
-}
-function bufferToByteArray(buffer, startIndex = 0, endIndex = buffer.length) {
-    const values = [];
-    for (let i = startIndex + 31; i < endIndex; i += 31) {
-        values.push(BigInt("0x" + buffer.slice(i - 31, i).toString("hex")));
-    }
-    let pendingWord = BigInt(0);
-    let pendingWordLen = BigInt(endIndex - (startIndex + (values.length * 31)));
-    if (pendingWordLen !== BigInt(0)) {
-        pendingWord = BigInt("0x" + buffer.slice(startIndex + (values.length * 31), endIndex).toString("hex"));
-    }
-    return [
-        BigInt(values.length),
-        ...values,
-        pendingWord,
-        pendingWordLen
-    ];
-}
-function poseidonHashRange(buffer, startIndex = 0, endIndex = buffer.length) {
-    return starknet_1.hash.computePoseidonHashOnElements(bufferToBytes31Span(buffer, startIndex, endIndex));
-}
-function findLastIndex(array, callback) {
-    for (let i = array.length - 1; i >= 0; i--) {
-        if (callback(array[i], i))
-            return i;
-    }
-    return -1;
-}
-function bigIntMax(a, b) {
-    return a > b ? a : b;
-}
-function serializeSignature(signature) {
-    return signature == null
-        ? undefined
-        : Array.isArray(signature)
-            ? signature
-            : [toHex(signature.r), toHex(signature.s)];
-}
-function deserializeSignature(signature) {
-    return signature == null
-        ? undefined
-        : Array.isArray(signature)
-            ? signature
-            : [signature.r, signature.s];
-}
-function serializeResourceBounds(resourceBounds) {
-    return {
-        l2_gas: {
-            max_amount: toHex(resourceBounds.l2_gas.max_amount),
-            max_price_per_unit: toHex(resourceBounds.l2_gas.max_price_per_unit),
-        },
-        l1_gas: {
-            max_amount: toHex(resourceBounds.l1_gas.max_amount),
-            max_price_per_unit: toHex(resourceBounds.l1_gas.max_price_per_unit),
-        },
-        l1_data_gas: {
-            max_amount: toHex(resourceBounds.l1_data_gas.max_amount),
-            max_price_per_unit: toHex(resourceBounds.l1_data_gas.max_price_per_unit),
-        }
-    };
-}
-function deserializeResourceBounds(resourceBounds) {
-    return {
-        l2_gas: {
-            max_amount: BigInt(resourceBounds.l2_gas.max_amount),
-            max_price_per_unit: BigInt(resourceBounds.l2_gas.max_price_per_unit),
-        },
-        l1_gas: {
-            max_amount: BigInt(resourceBounds.l1_gas.max_amount),
-            max_price_per_unit: BigInt(resourceBounds.l1_gas.max_price_per_unit),
-        },
-        l1_data_gas: {
-            max_amount: BigInt(resourceBounds.l1_data_gas.max_amount),
-            max_price_per_unit: BigInt(resourceBounds.l1_data_gas.max_price_per_unit),
-        }
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeResourceBounds = exports.serializeResourceBounds = exports.deserializeSignature = exports.serializeSignature = exports.bigIntMax = exports.findLastIndex = exports.poseidonHashRange = exports.bufferToByteArray = exports.bufferToBytes31Span = exports.bytes31SpanToBuffer = exports.toBigInt = exports.bigNumberishToBuffer = exports.u32ReverseEndianness = exports.bufferToU32Array = exports.u32ArrayToBuffer = exports.calculateHash = exports.toHex = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = exports.isUint256 = void 0;
+const starknet_1 = require("starknet");
+const buffer_1 = require("buffer");
+function isUint256(val) {
+    return val.low != null && val.high != null;
+}
+exports.isUint256 = isUint256;
+function timeoutPromise(timeoutMillis, abortSignal) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, timeoutMillis);
+        if (abortSignal != null)
+            abortSignal.addEventListener("abort", () => {
+                clearTimeout(timeout);
+                reject(new Error("Aborted"));
+            });
+    });
+}
+exports.timeoutPromise = timeoutPromise;
+function onceAsync(executor) {
+    let promise;
+    return () => {
+        if (promise == null) {
+            promise = executor();
+            return promise;
+        }
+        else {
+            return promise.catch(() => promise = executor());
+        }
+    };
+}
+exports.onceAsync = onceAsync;
+function getLogger(prefix) {
+    return {
+        // @ts-ignore
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        // @ts-ignore
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        // @ts-ignore
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        // @ts-ignore
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;
+const logger = getLogger("Utils: ");
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            const resp = await func();
+            return resp;
+        }
+        catch (e) {
+            if (errorAllowed != null && errorAllowed(e))
+                throw e;
+            err = e;
+            logger.error("tryWithRetries(): error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw new Error("Aborted");
+        if (i !== retryPolicy.maxRetries - 1) {
+            await timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
+}
+exports.tryWithRetries = tryWithRetries;
+function toHex(value, length = 64) {
+    if (value == null)
+        return null;
+    if (typeof (value) === "string")
+        value = BigInt(value);
+    switch (typeof (value)) {
+        case "number":
+        case "bigint":
+            return "0x" + value.toString(16).padStart(length, "0");
+    }
+    return "0x" + value.toString("hex").padStart(length, "0");
+}
+exports.toHex = toHex;
+function calculateHash(tx) {
+    if (tx.signed == null)
+        throw new Error("Cannot calculate hash for an unsigned transaction!");
+    const commonData = {
+        version: tx.details.version,
+        maxFee: tx.details.maxFee,
+        chainId: tx.details.chainId,
+        nonce: tx.details.nonce,
+        accountDeploymentData: tx.details.accountDeploymentData,
+        nonceDataAvailabilityMode: starknet_1.EDAMode[tx.details.nonceDataAvailabilityMode],
+        feeDataAvailabilityMode: starknet_1.EDAMode[tx.details.feeDataAvailabilityMode],
+        resourceBounds: tx.details.resourceBounds,
+        tip: tx.details.tip,
+        paymasterData: tx.details.paymasterData
+    };
+    switch (tx.type) {
+        case "INVOKE":
+            if (tx.signed.calldata == null ||
+                tx.details.walletAddress == null)
+                throw new Error("TX not enough data to compute hash!");
+            const invokeData = starknet_1.CallData.compile(tx.signed.calldata);
+            return tx.txId = starknet_1.hash.calculateInvokeTransactionHash({
+                senderAddress: tx.details.walletAddress,
+                compiledCalldata: invokeData,
+                ...commonData
+            });
+        case "DEPLOY_ACCOUNT":
+            if (tx.signed.constructorCalldata == null ||
+                tx.signed.addressSalt == null ||
+                tx.tx.contractAddress == null)
+                throw new Error("TX not enough data to compute hash!");
+            const deployAccountData = starknet_1.CallData.compile(tx.signed.constructorCalldata);
+            return tx.txId = starknet_1.hash.calculateDeployAccountTransactionHash({
+                contractAddress: tx.tx.contractAddress,
+                classHash: tx.signed.classHash,
+                compiledConstructorCalldata: deployAccountData,
+                salt: tx.signed.addressSalt,
+                ...commonData
+            });
+        default:
+            throw new Error("Unsupported tx type!");
+    }
+}
+exports.calculateHash = calculateHash;
+function u32ArrayToBuffer(arr) {
+    const buffer = buffer_1.Buffer.alloc(4 * arr.length);
+    for (let i = 0; i < arr.length; i++) {
+        buffer.writeUInt32BE(Number(arr[i]), i * 4);
+    }
+    return buffer;
+}
+exports.u32ArrayToBuffer = u32ArrayToBuffer;
+function bufferToU32Array(buffer) {
+    const result = [];
+    for (let i = 0; i < buffer.length; i += 4) {
+        result.push(buffer.readUInt32BE(i));
+    }
+    return result;
+}
+exports.bufferToU32Array = bufferToU32Array;
+function u32ReverseEndianness(value) {
+    const valueBN = BigInt(value);
+    return Number(((valueBN & 0xffn) << 24n) |
+        ((valueBN & 0xff00n) << 8n) |
+        ((valueBN >> 8n) & 0xff00n) |
+        ((valueBN >> 24n) & 0xffn));
+}
+exports.u32ReverseEndianness = u32ReverseEndianness;
+function bigNumberishToBuffer(value, length) {
+    if (isUint256(value)) {
+        return buffer_1.Buffer.concat([bigNumberishToBuffer(value.high, 16), bigNumberishToBuffer(value.low, 16)]);
+    }
+    if (typeof (value) === "string") {
+        if (value.startsWith("0x")) {
+            value = value.slice(2);
+        }
+        else {
+            value = BigInt(value).toString(16);
+        }
+    }
+    else {
+        value = value.toString(16);
+    }
+    if (length != null)
+        value = value.padStart(length * 2, "0");
+    const buff = buffer_1.Buffer.from(value, "hex");
+    if (length != null && buff.length > length)
+        return buff.slice(buff.length - length);
+    return buff;
+}
+exports.bigNumberishToBuffer = bigNumberishToBuffer;
+function toBigInt(value) {
+    if (value == null)
+        return null;
+    if (isUint256(value)) {
+        return (toBigInt(value.high) << 128n) | toBigInt(value.low);
+    }
+    if (typeof (value) === "string") {
+        if (!value.startsWith("0x"))
+            value = "0x" + value;
+        return BigInt(value);
+    }
+    if (typeof (value) === "bigint") {
+        return value;
+    }
+    return BigInt(value);
+}
+exports.toBigInt = toBigInt;
+function bytes31SpanToBuffer(span, length) {
+    const buffers = [];
+    const numFullBytes31 = Math.floor(length / 31);
+    const additionalBytes = length - (numFullBytes31 * 31);
+    const requiredSpanLength = numFullBytes31 + (additionalBytes === 0 ? 0 : 1);
+    if (span.length < requiredSpanLength)
+        throw new Error("Not enough bytes in the felt array!");
+    let i = 0;
+    for (; i < numFullBytes31; i++) {
+        buffers.push(bigNumberishToBuffer(span[i], 31));
+    }
+    if (additionalBytes !== 0)
+        buffers.push(bigNumberishToBuffer(span[i], additionalBytes));
+    return buffer_1.Buffer.concat(buffers);
+}
+exports.bytes31SpanToBuffer = bytes31SpanToBuffer;
+function bufferToBytes31Span(buffer, startIndex = 0, endIndex = buffer.length) {
+    const values = [];
+    for (let i = startIndex + 31; i < endIndex; i += 31) {
+        values.push(BigInt("0x" + buffer.slice(i - 31, i).toString("hex")));
+    }
+    if (endIndex > startIndex + (values.length * 31))
+        values.push(BigInt("0x" + buffer.slice(startIndex + (values.length * 31), endIndex).toString("hex")));
+    return values;
+}
+exports.bufferToBytes31Span = bufferToBytes31Span;
+function bufferToByteArray(buffer, startIndex = 0, endIndex = buffer.length) {
+    const values = [];
+    for (let i = startIndex + 31; i < endIndex; i += 31) {
+        values.push(BigInt("0x" + buffer.slice(i - 31, i).toString("hex")));
+    }
+    let pendingWord = BigInt(0);
+    let pendingWordLen = BigInt(endIndex - (startIndex + (values.length * 31)));
+    if (pendingWordLen !== BigInt(0)) {
+        pendingWord = BigInt("0x" + buffer.slice(startIndex + (values.length * 31), endIndex).toString("hex"));
+    }
+    return [
+        BigInt(values.length),
+        ...values,
+        pendingWord,
+        pendingWordLen
+    ];
+}
+exports.bufferToByteArray = bufferToByteArray;
+function poseidonHashRange(buffer, startIndex = 0, endIndex = buffer.length) {
+    return starknet_1.hash.computePoseidonHashOnElements(bufferToBytes31Span(buffer, startIndex, endIndex));
+}
+exports.poseidonHashRange = poseidonHashRange;
+function findLastIndex(array, callback) {
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (callback(array[i], i))
+            return i;
+    }
+    return -1;
+}
+exports.findLastIndex = findLastIndex;
+function bigIntMax(a, b) {
+    return a > b ? a : b;
+}
+exports.bigIntMax = bigIntMax;
+function serializeSignature(signature) {
+    return signature == null
+        ? undefined
+        : Array.isArray(signature)
+            ? signature
+            : [toHex(signature.r), toHex(signature.s)];
+}
+exports.serializeSignature = serializeSignature;
+function deserializeSignature(signature) {
+    return signature == null
+        ? undefined
+        : Array.isArray(signature)
+            ? signature
+            : [signature.r, signature.s];
+}
+exports.deserializeSignature = deserializeSignature;
+function serializeResourceBounds(resourceBounds) {
+    return {
+        l2_gas: {
+            max_amount: toHex(resourceBounds.l2_gas.max_amount),
+            max_price_per_unit: toHex(resourceBounds.l2_gas.max_price_per_unit),
+        },
+        l1_gas: {
+            max_amount: toHex(resourceBounds.l1_gas.max_amount),
+            max_price_per_unit: toHex(resourceBounds.l1_gas.max_price_per_unit),
+        },
+        l1_data_gas: {
+            max_amount: toHex(resourceBounds.l1_data_gas.max_amount),
+            max_price_per_unit: toHex(resourceBounds.l1_data_gas.max_price_per_unit),
+        }
+    };
+}
+exports.serializeResourceBounds = serializeResourceBounds;
+function deserializeResourceBounds(resourceBounds) {
+    return {
+        l2_gas: {
+            max_amount: BigInt(resourceBounds.l2_gas.max_amount),
+            max_price_per_unit: BigInt(resourceBounds.l2_gas.max_price_per_unit),
+        },
+        l1_gas: {
+            max_amount: BigInt(resourceBounds.l1_gas.max_amount),
+            max_price_per_unit: BigInt(resourceBounds.l1_gas.max_price_per_unit),
+        },
+        l1_data_gas: {
+            max_amount: BigInt(resourceBounds.l1_data_gas.max_amount),
+            max_price_per_unit: BigInt(resourceBounds.l1_data_gas.max_price_per_unit),
+        }
+    };
+}
+exports.deserializeResourceBounds = deserializeResourceBounds;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "8.0.13",
+  "version": "8.1.10",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -30,7 +30,7 @@
     "url": "git+https://github.com/atomiqlabs/atomiq-chain-starknet.git"
   },
   "dependencies": {
-    "@atomiqlabs/base": "^13.0.4",
+    "@atomiqlabs/base": "^13.1.9",
     "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "^1.6.0",
     "abi-wan-kanabi": "2.2.4",