@atomiqlabs/chain-starknet 8.0.13 → 8.1.10

package/dist/starknet/wallet/StarknetSigner.d.ts

@@ -1,72 +1,72 @@
-import { AbstractSigner } from "@atomiqlabs/base";
-import { Account, DeployAccountContractPayload, Invocation, DeployAccountContractTransaction } from "starknet";
-import { StarknetTx, StarknetTxDeployAccount, StarknetTxInvoke } from "../chain/modules/StarknetTransactions";
-/**
- * Starknet signer implementation wrapping a starknet.js {@link Account}, for browser
- *  based wallet use {@link StarknetBrowserSigner}
- *
- * @category Wallets
- */
-export declare class StarknetSigner implements AbstractSigner {
-    type: "AtomiqAbstractSigner";
-    readonly isManagingNoncesInternally: boolean;
-    readonly account: Account;
-    /**
-     * Constructs a signer wrapping a starknet.js {@link Account}
-     *
-     * @param account
-     */
-    constructor(account: Account);
-    constructor(account: Account, isManagingNoncesInternally?: boolean);
-    /**
-     * @inheritDoc
-     */
-    getAddress(): string;
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    protected _signTransaction(tx: StarknetTx): Promise<StarknetTx>;
-    /**
-     * Signs the provided starknet transaction and returns its signed version
-     *
-     * @param tx A starknet transaction to sign
-     */
-    signTransaction?(tx: StarknetTx): Promise<StarknetTx>;
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    protected signInvoke(tx: StarknetTxInvoke): Promise<Invocation>;
-    /**
-     * @param tx
-     * @protected
-     */
-    protected signDeployAccount(tx: StarknetTxDeployAccount): Promise<DeployAccountContractTransaction>;
-    /**
-     * Signs and sends the provided starknet transaction. Note that onBeforePublish is not really called before the
-     *  tx is sent out in this default case, since this is not supported by the starknet web based wallets
-     *
-     * @param tx A transaction to sign and send
-     * @param onBeforePublish A callback called after the transaction has been sent
-     */
-    sendTransaction(tx: StarknetTx, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string>;
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    protected sendInvoke(tx: StarknetTxInvoke): Promise<string>;
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    protected sendDeployAccount(tx: StarknetTxDeployAccount): Promise<string>;
-    /**
-     * Returns the payload for deploying the signer account's contract on Starknet
-     */
-    getDeployPayload(): Promise<DeployAccountContractPayload | null>;
-}
+import { AbstractSigner } from "@atomiqlabs/base";
+import { Account, DeployAccountContractPayload, Invocation, DeployAccountContractTransaction } from "starknet";
+import { StarknetTx, StarknetTxDeployAccount, StarknetTxInvoke } from "../chain/modules/StarknetTransactions";
+/**
+ * Starknet signer implementation wrapping a starknet.js {@link Account}, for browser
+ *  based wallet use {@link StarknetBrowserSigner}
+ *
+ * @category Wallets
+ */
+export declare class StarknetSigner implements AbstractSigner {
+    type: "AtomiqAbstractSigner";
+    readonly isManagingNoncesInternally: boolean;
+    readonly account: Account;
+    /**
+     * Constructs a signer wrapping a starknet.js {@link Account}
+     *
+     * @param account
+     */
+    constructor(account: Account);
+    constructor(account: Account, isManagingNoncesInternally?: boolean);
+    /**
+     * @inheritDoc
+     */
+    getAddress(): string;
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    protected _signTransaction(tx: StarknetTx): Promise<StarknetTx>;
+    /**
+     * Signs the provided starknet transaction and returns its signed version
+     *
+     * @param tx A starknet transaction to sign
+     */
+    signTransaction?(tx: StarknetTx): Promise<StarknetTx>;
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    protected signInvoke(tx: StarknetTxInvoke): Promise<Invocation>;
+    /**
+     * @param tx
+     * @protected
+     */
+    protected signDeployAccount(tx: StarknetTxDeployAccount): Promise<DeployAccountContractTransaction>;
+    /**
+     * Signs and sends the provided starknet transaction. Note that onBeforePublish is not really called before the
+     *  tx is sent out in this default case, since this is not supported by the starknet web based wallets
+     *
+     * @param tx A transaction to sign and send
+     * @param onBeforePublish A callback called after the transaction has been sent
+     */
+    sendTransaction(tx: StarknetTx, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string>;
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    protected sendInvoke(tx: StarknetTxInvoke): Promise<string>;
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    protected sendDeployAccount(tx: StarknetTxDeployAccount): Promise<string>;
+    /**
+     * Returns the payload for deploying the signer account's contract on Starknet
+     */
+    getDeployPayload(): Promise<DeployAccountContractPayload | null>;
+}

package/dist/starknet/wallet/StarknetSigner.js

@@ -1,114 +1,114 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetSigner = void 0;
-const Utils_1 = require("../../utils/Utils");
-const StarknetTransactions_1 = require("../chain/modules/StarknetTransactions");
-/**
- * Starknet signer implementation wrapping a starknet.js {@link Account}, for browser
- *  based wallet use {@link StarknetBrowserSigner}
- *
- * @category Wallets
- */
-class StarknetSigner {
-    constructor(account, isManagingNoncesInternally = false) {
-        this.type = "AtomiqAbstractSigner";
-        this.account = account;
-        this.isManagingNoncesInternally = isManagingNoncesInternally;
-    }
-    /**
-     * @inheritDoc
-     */
-    getAddress() {
-        return (0, Utils_1.toHex)(this.account.address);
-    }
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    async _signTransaction(tx) {
-        if ((0, StarknetTransactions_1.isStarknetTxInvoke)(tx)) {
-            tx.signed = await this.signInvoke(tx);
-        }
-        else if ((0, StarknetTransactions_1.isStarknetTxDeployAccount)(tx)) {
-            tx.signed = await this.signDeployAccount(tx);
-        }
-        else {
-            throw new Error("Unsupported transaction type!");
-        }
-        (0, Utils_1.calculateHash)(tx);
-        return tx;
-    }
-    /**
-     * Signs the provided starknet transaction and returns its signed version
-     *
-     * @param tx A starknet transaction to sign
-     */
-    signTransaction(tx) {
-        return this._signTransaction(tx);
-    }
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    signInvoke(tx) {
-        return this.account.buildInvocation(tx.tx, tx.details);
-    }
-    /**
-     * @param tx
-     * @protected
-     */
-    signDeployAccount(tx) {
-        return this.account.buildAccountDeployPayload(tx.tx, tx.details);
-    }
-    /**
-     * Signs and sends the provided starknet transaction. Note that onBeforePublish is not really called before the
-     *  tx is sent out in this default case, since this is not supported by the starknet web based wallets
-     *
-     * @param tx A transaction to sign and send
-     * @param onBeforePublish A callback called after the transaction has been sent
-     */
-    async sendTransaction(tx, onBeforePublish) {
-        if ((0, StarknetTransactions_1.isStarknetTxInvoke)(tx)) {
-            tx.txId = await this.sendInvoke(tx);
-        }
-        else if ((0, StarknetTransactions_1.isStarknetTxDeployAccount)(tx)) {
-            tx.txId = await this.sendDeployAccount(tx);
-        }
-        else {
-            throw new Error("Unsupported transaction type!");
-        }
-        if (onBeforePublish != null)
-            await onBeforePublish(tx.txId, StarknetTransactions_1.StarknetTransactions.serializeTx(tx));
-        return tx.txId;
-    }
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    async sendInvoke(tx) {
-        const result = await this.account.execute(tx.tx, tx.details);
-        return result.transaction_hash;
-    }
-    /**
-     *
-     * @param tx
-     * @protected
-     */
-    async sendDeployAccount(tx) {
-        const result = await this.account.deployAccount(tx.tx, tx.details);
-        return result.transaction_hash;
-    }
-    /**
-     * Returns the payload for deploying the signer account's contract on Starknet
-     */
-    async getDeployPayload() {
-        const _account = this.account;
-        if (_account.getDeploymentData == null)
-            return null;
-        return _account.getDeploymentData();
-    }
-}
-exports.StarknetSigner = StarknetSigner;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSigner = void 0;
+const Utils_1 = require("../../utils/Utils");
+const StarknetTransactions_1 = require("../chain/modules/StarknetTransactions");
+/**
+ * Starknet signer implementation wrapping a starknet.js {@link Account}, for browser
+ *  based wallet use {@link StarknetBrowserSigner}
+ *
+ * @category Wallets
+ */
+class StarknetSigner {
+    constructor(account, isManagingNoncesInternally = false) {
+        this.type = "AtomiqAbstractSigner";
+        this.account = account;
+        this.isManagingNoncesInternally = isManagingNoncesInternally;
+    }
+    /**
+     * @inheritDoc
+     */
+    getAddress() {
+        return (0, Utils_1.toHex)(this.account.address);
+    }
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    async _signTransaction(tx) {
+        if ((0, StarknetTransactions_1.isStarknetTxInvoke)(tx)) {
+            tx.signed = await this.signInvoke(tx);
+        }
+        else if ((0, StarknetTransactions_1.isStarknetTxDeployAccount)(tx)) {
+            tx.signed = await this.signDeployAccount(tx);
+        }
+        else {
+            throw new Error("Unsupported transaction type!");
+        }
+        (0, Utils_1.calculateHash)(tx);
+        return tx;
+    }
+    /**
+     * Signs the provided starknet transaction and returns its signed version
+     *
+     * @param tx A starknet transaction to sign
+     */
+    signTransaction(tx) {
+        return this._signTransaction(tx);
+    }
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    signInvoke(tx) {
+        return this.account.buildInvocation(tx.tx, tx.details);
+    }
+    /**
+     * @param tx
+     * @protected
+     */
+    signDeployAccount(tx) {
+        return this.account.buildAccountDeployPayload(tx.tx, tx.details);
+    }
+    /**
+     * Signs and sends the provided starknet transaction. Note that onBeforePublish is not really called before the
+     *  tx is sent out in this default case, since this is not supported by the starknet web based wallets
+     *
+     * @param tx A transaction to sign and send
+     * @param onBeforePublish A callback called after the transaction has been sent
+     */
+    async sendTransaction(tx, onBeforePublish) {
+        if ((0, StarknetTransactions_1.isStarknetTxInvoke)(tx)) {
+            tx.txId = await this.sendInvoke(tx);
+        }
+        else if ((0, StarknetTransactions_1.isStarknetTxDeployAccount)(tx)) {
+            tx.txId = await this.sendDeployAccount(tx);
+        }
+        else {
+            throw new Error("Unsupported transaction type!");
+        }
+        if (onBeforePublish != null)
+            await onBeforePublish(tx.txId, StarknetTransactions_1.StarknetTransactions.serializeTx(tx));
+        return tx.txId;
+    }
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    async sendInvoke(tx) {
+        const result = await this.account.execute(tx.tx, tx.details);
+        return result.transaction_hash;
+    }
+    /**
+     *
+     * @param tx
+     * @protected
+     */
+    async sendDeployAccount(tx) {
+        const result = await this.account.deployAccount(tx.tx, tx.details);
+        return result.transaction_hash;
+    }
+    /**
+     * Returns the payload for deploying the signer account's contract on Starknet
+     */
+    async getDeployPayload() {
+        const _account = this.account;
+        if (_account.getDeploymentData == null)
+            return null;
+        return _account.getDeploymentData();
+    }
+}
+exports.StarknetSigner = StarknetSigner;

package/dist/starknet/wallet/accounts/StarknetKeypairWallet.d.ts

@@ -1,18 +1,18 @@
-import { Account, DeployAccountContractPayload, Provider } from "starknet";
-/**
- * Keypair-based wallet implementation using OpenZeppelin Account
- *
- * @category Wallets
- */
-export declare class StarknetKeypairWallet extends Account {
-    readonly publicKey: string;
-    constructor(provider: Provider, privateKey: string);
-    /**
-     * @inheritDoc
-     */
-    getDeploymentData(): DeployAccountContractPayload;
-    /**
-     * Generates a random Stark Curve private key for the OZ account
-     */
-    static generateRandomPrivateKey(): string;
-}
+import { Account, DeployAccountContractPayload, Provider } from "starknet";
+/**
+ * Keypair-based wallet implementation using OpenZeppelin Account
+ *
+ * @category Wallets
+ */
+export declare class StarknetKeypairWallet extends Account {
+    readonly publicKey: string;
+    constructor(provider: Provider, privateKey: string);
+    /**
+     * @inheritDoc
+     */
+    getDeploymentData(): DeployAccountContractPayload;
+    /**
+     * Generates a random Stark Curve private key for the OZ account
+     */
+    static generateRandomPrivateKey(): string;
+}

package/dist/starknet/wallet/accounts/StarknetKeypairWallet.js

@@ -1,45 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetKeypairWallet = void 0;
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../../utils/Utils");
-const buffer_1 = require("buffer");
-const OZaccountClassHash = '0x00261c293c8084cd79086214176b33e5911677cec55104fddc8d25b0b736dcad';
-/**
- * Keypair-based wallet implementation using OpenZeppelin Account
- *
- * @category Wallets
- */
-class StarknetKeypairWallet extends starknet_1.Account {
-    constructor(provider, privateKey) {
-        const publicKey = starknet_1.ec.starkCurve.getStarkKey((0, Utils_1.toHex)(privateKey));
-        // Calculate future address of the account
-        const OZaccountConstructorCallData = starknet_1.CallData.compile({ publicKey });
-        const OZcontractAddress = starknet_1.hash.calculateContractAddressFromHash(publicKey, OZaccountClassHash, OZaccountConstructorCallData, 0);
-        super({
-            provider,
-            address: OZcontractAddress,
-            signer: privateKey,
-            cairoVersion: "1"
-        });
-        this.publicKey = publicKey;
-    }
-    /**
-     * @inheritDoc
-     */
-    getDeploymentData() {
-        return {
-            classHash: OZaccountClassHash,
-            constructorCalldata: starknet_1.CallData.compile({ publicKey: this.publicKey }),
-            addressSalt: this.publicKey,
-            contractAddress: this.address
-        };
-    }
-    /**
-     * Generates a random Stark Curve private key for the OZ account
-     */
-    static generateRandomPrivateKey() {
-        return "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
-    }
-}
-exports.StarknetKeypairWallet = StarknetKeypairWallet;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetKeypairWallet = void 0;
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+const buffer_1 = require("buffer");
+const OZaccountClassHash = '0x00261c293c8084cd79086214176b33e5911677cec55104fddc8d25b0b736dcad';
+/**
+ * Keypair-based wallet implementation using OpenZeppelin Account
+ *
+ * @category Wallets
+ */
+class StarknetKeypairWallet extends starknet_1.Account {
+    constructor(provider, privateKey) {
+        const publicKey = starknet_1.ec.starkCurve.getStarkKey((0, Utils_1.toHex)(privateKey));
+        // Calculate future address of the account
+        const OZaccountConstructorCallData = starknet_1.CallData.compile({ publicKey });
+        const OZcontractAddress = starknet_1.hash.calculateContractAddressFromHash(publicKey, OZaccountClassHash, OZaccountConstructorCallData, 0);
+        super({
+            provider,
+            address: OZcontractAddress,
+            signer: privateKey,
+            cairoVersion: "1"
+        });
+        this.publicKey = publicKey;
+    }
+    /**
+     * @inheritDoc
+     */
+    getDeploymentData() {
+        return {
+            classHash: OZaccountClassHash,
+            constructorCalldata: starknet_1.CallData.compile({ publicKey: this.publicKey }),
+            addressSalt: this.publicKey,
+            contractAddress: this.address
+        };
+    }
+    /**
+     * Generates a random Stark Curve private key for the OZ account
+     */
+    static generateRandomPrivateKey() {
+        return "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
+    }
+}
+exports.StarknetKeypairWallet = StarknetKeypairWallet;

package/dist/utils/Utils.d.ts

@@ -1,77 +1,77 @@
-import { BigNumberish, Signature, Uint256, ResourceBounds, ResourceBoundsBN } from "starknet";
-import { StarknetTx } from "../starknet/chain/modules/StarknetTransactions";
-import { Buffer } from "buffer";
-export type ReplaceBigInt<T> = T extends bigint ? string : T extends (infer U)[] ? ReplaceBigInt<U>[] : T extends readonly (infer U)[] ? readonly ReplaceBigInt<U>[] : T extends object ? {
-    [K in keyof T]: ReplaceBigInt<T[K]>;
-} : T;
-export type NoBigInt = number | string | boolean | NoBigIntObject | NoBigIntArray;
-type NoBigIntArray = NoBigInt[];
-interface NoBigIntObject {
-    [key: string]: NoBigInt;
-}
-export type Serialized<T> = {
-    [K in keyof T as T[K] extends Function ? never : K]: T[K] extends infer U ? U extends bigint ? string : U extends object ? Serialized<U> : U : never;
-};
-export declare function isUint256(val: any): val is Uint256;
-export declare function timeoutPromise(timeoutMillis: number, abortSignal?: AbortSignal): Promise<void>;
-export declare function onceAsync<T>(executor: () => Promise<T>): () => Promise<T>;
-export type LoggerType = {
-    debug: (msg: string, ...args: any[]) => void;
-    info: (msg: string, ...args: any[]) => void;
-    warn: (msg: string, ...args: any[]) => void;
-    error: (msg: string, ...args: any[]) => void;
-};
-export declare function getLogger(prefix: string): LoggerType;
-export declare function tryWithRetries<T>(func: () => Promise<T>, retryPolicy?: {
-    maxRetries?: number;
-    delay?: number;
-    exponential?: boolean;
-}, errorAllowed?: (e: any) => boolean, abortSignal?: AbortSignal): Promise<T>;
-export declare function toHex(value: number | bigint | string | Buffer, length?: number): string;
-export declare function toHex(value: undefined | null, length?: number): null;
-export declare function toHex(value: number | bigint | string | Buffer | undefined | null, length?: number): string | null;
-export declare function calculateHash(tx: StarknetTx): string;
-export declare function u32ArrayToBuffer(arr: BigNumberish[]): Buffer;
-export declare function bufferToU32Array(buffer: Buffer): number[];
-export declare function u32ReverseEndianness(value: number): number;
-export declare function bigNumberishToBuffer(value: BigNumberish | Uint256, length?: number): Buffer;
-export declare function toBigInt(value: BigNumberish | Uint256): bigint;
-export declare function toBigInt(value: null | undefined): null;
-export declare function toBigInt(value: BigNumberish | Uint256 | null | undefined): bigint | null;
-export declare function bytes31SpanToBuffer(span: BigNumberish[], length: number): Buffer;
-export declare function bufferToBytes31Span(buffer: Buffer, startIndex?: number, endIndex?: number): bigint[];
-export declare function bufferToByteArray(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish[];
-export declare function poseidonHashRange(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish;
-export declare function findLastIndex<T>(array: T[], callback: (value: T, index: number) => boolean): number;
-export declare function bigIntMax(a: bigint, b: bigint): bigint;
-export declare function serializeSignature(signature?: Signature): ReplaceBigInt<Signature> | undefined;
-export declare function deserializeSignature(signature?: ReplaceBigInt<Signature>): Signature | undefined;
-export declare function serializeResourceBounds(resourceBounds: {
-    l2_gas: {
-        max_amount: BigNumberish;
-        max_price_per_unit: BigNumberish;
-    };
-    l1_gas: {
-        max_amount: BigNumberish;
-        max_price_per_unit: BigNumberish;
-    };
-    l1_data_gas: {
-        max_amount: BigNumberish;
-        max_price_per_unit: BigNumberish;
-    };
-}): {
-    l2_gas: {
-        max_amount: string;
-        max_price_per_unit: string;
-    };
-    l1_gas: {
-        max_amount: string;
-        max_price_per_unit: string;
-    };
-    l1_data_gas: {
-        max_amount: string;
-        max_price_per_unit: string;
-    };
-};
-export declare function deserializeResourceBounds(resourceBounds: ResourceBounds): ResourceBoundsBN;
-export {};
+import { BigNumberish, Signature, Uint256, ResourceBounds, ResourceBoundsBN } from "starknet";
+import { StarknetTx } from "../starknet/chain/modules/StarknetTransactions";
+import { Buffer } from "buffer";
+export type ReplaceBigInt<T> = T extends bigint ? string : T extends (infer U)[] ? ReplaceBigInt<U>[] : T extends readonly (infer U)[] ? readonly ReplaceBigInt<U>[] : T extends object ? {
+    [K in keyof T]: ReplaceBigInt<T[K]>;
+} : T;
+export type NoBigInt = number | string | boolean | NoBigIntObject | NoBigIntArray;
+type NoBigIntArray = NoBigInt[];
+interface NoBigIntObject {
+    [key: string]: NoBigInt;
+}
+export type Serialized<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]: T[K] extends infer U ? U extends bigint ? string : U extends object ? Serialized<U> : U : never;
+};
+export declare function isUint256(val: any): val is Uint256;
+export declare function timeoutPromise(timeoutMillis: number, abortSignal?: AbortSignal): Promise<void>;
+export declare function onceAsync<T>(executor: () => Promise<T>): () => Promise<T>;
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void;
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
+};
+export declare function getLogger(prefix: string): LoggerType;
+export declare function tryWithRetries<T>(func: () => Promise<T>, retryPolicy?: {
+    maxRetries?: number;
+    delay?: number;
+    exponential?: boolean;
+}, errorAllowed?: (e: any) => boolean, abortSignal?: AbortSignal): Promise<T>;
+export declare function toHex(value: number | bigint | string | Buffer, length?: number): string;
+export declare function toHex(value: undefined | null, length?: number): null;
+export declare function toHex(value: number | bigint | string | Buffer | undefined | null, length?: number): string | null;
+export declare function calculateHash(tx: StarknetTx): string;
+export declare function u32ArrayToBuffer(arr: BigNumberish[]): Buffer;
+export declare function bufferToU32Array(buffer: Buffer): number[];
+export declare function u32ReverseEndianness(value: number): number;
+export declare function bigNumberishToBuffer(value: BigNumberish | Uint256, length?: number): Buffer;
+export declare function toBigInt(value: BigNumberish | Uint256): bigint;
+export declare function toBigInt(value: null | undefined): null;
+export declare function toBigInt(value: BigNumberish | Uint256 | null | undefined): bigint | null;
+export declare function bytes31SpanToBuffer(span: BigNumberish[], length: number): Buffer;
+export declare function bufferToBytes31Span(buffer: Buffer, startIndex?: number, endIndex?: number): bigint[];
+export declare function bufferToByteArray(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish[];
+export declare function poseidonHashRange(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish;
+export declare function findLastIndex<T>(array: T[], callback: (value: T, index: number) => boolean): number;
+export declare function bigIntMax(a: bigint, b: bigint): bigint;
+export declare function serializeSignature(signature?: Signature): ReplaceBigInt<Signature> | undefined;
+export declare function deserializeSignature(signature?: ReplaceBigInt<Signature>): Signature | undefined;
+export declare function serializeResourceBounds(resourceBounds: {
+    l2_gas: {
+        max_amount: BigNumberish;
+        max_price_per_unit: BigNumberish;
+    };
+    l1_gas: {
+        max_amount: BigNumberish;
+        max_price_per_unit: BigNumberish;
+    };
+    l1_data_gas: {
+        max_amount: BigNumberish;
+        max_price_per_unit: BigNumberish;
+    };
+}): {
+    l2_gas: {
+        max_amount: string;
+        max_price_per_unit: string;
+    };
+    l1_gas: {
+        max_amount: string;
+        max_price_per_unit: string;
+    };
+    l1_data_gas: {
+        max_amount: string;
+        max_price_per_unit: string;
+    };
+};
+export declare function deserializeResourceBounds(resourceBounds: ResourceBounds): ResourceBoundsBN;
+export {};