@atomiqlabs/chain-starknet 2.0.0-beta.8 → 2.0.0

package/dist/starknet/swaps/modules/StarknetSwapRefund.js

@@ -1,128 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetSwapRefund = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Utils_1 = require("../../../utils/Utils");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetAction_1 = require("../../chain/StarknetAction");
-const StarknetFees_1 = require("../../chain/modules/StarknetFees");
-const Refund = [
-    { name: 'Swap hash', type: 'felt' },
-    { name: 'Timeout', type: 'timestamp' }
-];
-class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * Action for generic Refund instruction
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param handlerGas
-     * @constructor
-     * @private
-     */
-    Refund(signer, swapData, witness, handlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetAction_1.sumStarknetGas)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
-    }
-    /**
-     * Action for cooperative refunding with signature
-     *
-     * @param sender
-     * @param swapData
-     * @param timeout
-     * @param signature
-     * @constructor
-     * @private
-     */
-    RefundWithSignature(sender, swapData, timeout, signature) {
-        return new StarknetAction_1.StarknetAction(sender, this.root, this.swapContract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)), swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND);
-    }
-    async signSwapRefund(signer, swapData, authorizationTimeout) {
-        const authPrefix = "refund";
-        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
-        const signature = await this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
-            "Swap hash": "0x" + swapData.getEscrowHash(),
-            "Timeout": (0, Utils_1.toHex)(authTimeout)
-        });
-        return {
-            prefix: authPrefix,
-            timeout: authTimeout.toString(10),
-            signature: signature
-        };
-    }
-    async isSignatureValid(swapData, timeout, prefix, signature) {
-        if (prefix !== "refund")
-            throw new base_1.SignatureVerificationError("Invalid prefix");
-        const expiryTimestamp = BigInt(timeout);
-        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
-        if (isExpired)
-            throw new base_1.SignatureVerificationError("Authorization expired!");
-        const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
-            "Swap hash": "0x" + swapData.getEscrowHash(),
-            "Timeout": (0, Utils_1.toHex)(expiryTimestamp)
-        });
-        if (!valid) {
-            throw new base_1.SignatureVerificationError("Invalid signature!");
-        }
-        return null;
-    }
-    /**
-     * Creates transactions required for refunding timed out swap
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param check whether to check if swap is already expired and refundable
-     * @param feeRate fee rate to be used for the transactions
-     * @param witnessData
-     */
-    async txsRefund(signer, swapData, check, feeRate, witnessData) {
-        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
-        if (refundHandler == null)
-            throw new Error("Invalid refund handler");
-        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
-            throw new base_1.SwapDataVerificationError("Not refundable yet!");
-        }
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
-        const action = this.Refund(signer, swapData, witness, refundHandler.getGas(swapData));
-        await action.addToTxs(initialTxns, feeRate);
-        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
-        return initialTxns;
-    }
-    /**
-     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
-     *
-     * @param signer
-     * @param swapData swap data to refund
-     * @param timeout signature timeout
-     * @param prefix signature prefix of the counterparty
-     * @param signature signature of the counterparty
-     * @param check whether to check if swap is committed before attempting refund
-     * @param feeRate fee rate to be used for the transactions
-     */
-    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
-        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
-            throw new base_1.SwapDataVerificationError("Not correctly committed");
-        }
-        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
-        const action = this.RefundWithSignature(signer, swapData, timeout, JSON.parse(signature));
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
-            " auth expiry: " + timeout + " signature: " + signature);
-        return [await action.tx(feeRate)];
-    }
-    /**
-     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
-     */
-    async getRefundFee(swapData, feeRate) {
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT.l1 : StarknetSwapRefund.GasCosts.REFUND.l1, feeRate);
-    }
-}
-exports.StarknetSwapRefund = StarknetSwapRefund;
-StarknetSwapRefund.GasCosts = {
-    REFUND: { l1: 750, l2: 0 },
-    REFUND_PAY_OUT: { l1: 1250, l2: 0 }
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapRefund = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../utils/Utils");
+const StarknetSwapModule_1 = require("../StarknetSwapModule");
+const StarknetAction_1 = require("../../chain/StarknetAction");
+const StarknetFees_1 = require("../../chain/modules/StarknetFees");
+const Refund = [
+    { name: 'Swap hash', type: 'felt' },
+    { name: 'Timeout', type: 'timestamp' }
+];
+class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param handlerGas
+     * @constructor
+     * @private
+     */
+    Refund(signer, swapData, witness, handlerGas) {
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetAction_1.sumStarknetGas)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
+    }
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @constructor
+     * @private
+     */
+    RefundWithSignature(sender, swapData, timeout, signature) {
+        return new StarknetAction_1.StarknetAction(sender, this.root, this.swapContract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)), swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND);
+    }
+    async signSwapRefund(signer, swapData, authorizationTimeout) {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const signature = await this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(authTimeout)
+        });
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+    async isSignatureValid(swapData, timeout, prefix, signature) {
+        if (prefix !== "refund")
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(expiryTimestamp)
+        });
+        if (!valid) {
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        }
+        return null;
+    }
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    async txsRefund(signer, swapData, check, feeRate, witnessData) {
+        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if (refundHandler == null)
+            throw new Error("Invalid refund handler");
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not refundable yet!");
+        }
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+        const action = this.Refund(signer, swapData, witness, refundHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
+        return initialTxns;
+    }
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        const action = this.RefundWithSignature(signer, swapData, timeout, JSON.parse(signature));
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
+            " auth expiry: " + timeout + " signature: " + signature);
+        return [await action.tx(feeRate)];
+    }
+    /**
+     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
+     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     */
+    async getRefundFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT.l1 : StarknetSwapRefund.GasCosts.REFUND.l1, feeRate);
+    }
+}
+exports.StarknetSwapRefund = StarknetSwapRefund;
+StarknetSwapRefund.GasCosts = {
+    REFUND: { l1: 750, l2: 0 },
+    REFUND_PAY_OUT: { l1: 1250, l2: 0 }
+};

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

@@ -1,7 +1,7 @@
-import { Account, DeployAccountContractPayload, Provider } from "starknet";
-export declare class StarknetKeypairWallet extends Account {
-    readonly publicKey: string;
-    constructor(provider: Provider, privateKey: string);
-    getDeploymentData(): DeployAccountContractPayload;
-    static generateRandomPrivateKey(): string;
-}
+import { Account, DeployAccountContractPayload, Provider } from "starknet";
+export declare class StarknetKeypairWallet extends Account {
+    readonly publicKey: string;
+    constructor(provider: Provider, privateKey: string);
+    getDeploymentData(): DeployAccountContractPayload;
+    static generateRandomPrivateKey(): string;
+}

package/dist/starknet/wallet/StarknetKeypairWallet.js

@@ -1,30 +1,30 @@
-"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';
-//Openzeppelin Account wallet
-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, OZcontractAddress, privateKey, "1");
-        this.publicKey = publicKey;
-    }
-    getDeploymentData() {
-        return {
-            classHash: OZaccountClassHash,
-            constructorCalldata: starknet_1.CallData.compile({ publicKey: this.publicKey }),
-            addressSalt: this.publicKey,
-            contractAddress: this.address
-        };
-    }
-    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';
+//Openzeppelin Account wallet
+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, OZcontractAddress, privateKey, "1");
+        this.publicKey = publicKey;
+    }
+    getDeploymentData() {
+        return {
+            classHash: OZaccountClassHash,
+            constructorCalldata: starknet_1.CallData.compile({ publicKey: this.publicKey }),
+            addressSalt: this.publicKey,
+            contractAddress: this.address
+        };
+    }
+    static generateRandomPrivateKey() {
+        return "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
+    }
+}
+exports.StarknetKeypairWallet = StarknetKeypairWallet;

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

@@ -1,12 +1,12 @@
-import { AbstractSigner } from "@atomiqlabs/base";
-import { Account, DeployAccountContractPayload } from "starknet";
-export declare class StarknetSigner implements AbstractSigner {
-    account: Account;
-    isDeployed: boolean;
-    constructor(account: Account);
-    getPublicKey(): Promise<string>;
-    getAddress(): string;
-    isWalletAccount(): boolean;
-    getNonce(): Promise<bigint>;
-    checkAndGetDeployPayload(nonce?: bigint): Promise<DeployAccountContractPayload | null>;
-}
+import { AbstractSigner } from "@atomiqlabs/base";
+import { Account, DeployAccountContractPayload } from "starknet";
+export declare class StarknetSigner implements AbstractSigner {
+    account: Account;
+    isDeployed: boolean;
+    constructor(account: Account);
+    getPublicKey(): Promise<string>;
+    getAddress(): string;
+    isWalletAccount(): boolean;
+    getNonce(): Promise<bigint>;
+    checkAndGetDeployPayload(nonce?: bigint): Promise<DeployAccountContractPayload | null>;
+}

package/dist/starknet/wallet/StarknetSigner.js

@@ -1,46 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetSigner = void 0;
-const Utils_1 = require("../../utils/Utils");
-class StarknetSigner {
-    constructor(account) {
-        this.isDeployed = null;
-        this.account = account;
-    }
-    getPublicKey() {
-        return this.account.signer.getPubKey();
-    }
-    getAddress() {
-        return (0, Utils_1.toHex)(this.account.address);
-    }
-    isWalletAccount() {
-        return this.account.walletProvider != null;
-    }
-    //TODO: Introduce proper nonce management!
-    async getNonce() {
-        try {
-            return BigInt(await this.account.getNonceForAddress(this.getAddress(), "pending"));
-        }
-        catch (e) {
-            if (e.message != null && e.message.includes("20: Contract not found")) {
-                return BigInt(0);
-            }
-            throw e;
-        }
-    }
-    async checkAndGetDeployPayload(nonce) {
-        if (this.isDeployed)
-            return null;
-        const _account = this.account;
-        if (_account.getDeploymentData != null) {
-            //Check if deployed
-            nonce ?? (nonce = BigInt(await this.getNonce()));
-            this.isDeployed = nonce != BigInt(0);
-            if (!this.isDeployed) {
-                return _account.getDeploymentData();
-            }
-        }
-        return null;
-    }
-}
-exports.StarknetSigner = StarknetSigner;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSigner = void 0;
+const Utils_1 = require("../../utils/Utils");
+class StarknetSigner {
+    constructor(account) {
+        this.isDeployed = null;
+        this.account = account;
+    }
+    getPublicKey() {
+        return this.account.signer.getPubKey();
+    }
+    getAddress() {
+        return (0, Utils_1.toHex)(this.account.address);
+    }
+    isWalletAccount() {
+        return this.account.walletProvider != null;
+    }
+    //TODO: Introduce proper nonce management!
+    async getNonce() {
+        try {
+            return BigInt(await this.account.getNonceForAddress(this.getAddress(), "pending"));
+        }
+        catch (e) {
+            if (e.message != null && e.message.includes("20: Contract not found")) {
+                return BigInt(0);
+            }
+            throw e;
+        }
+    }
+    async checkAndGetDeployPayload(nonce) {
+        if (this.isDeployed)
+            return null;
+        const _account = this.account;
+        if (_account.getDeploymentData != null) {
+            //Check if deployed
+            nonce ?? (nonce = BigInt(await this.getNonce()));
+            this.isDeployed = nonce != BigInt(0);
+            if (!this.isDeployed) {
+                return _account.getDeploymentData();
+            }
+        }
+        return null;
+    }
+}
+exports.StarknetSigner = StarknetSigner;

package/dist/utils/Utils.d.ts

@@ -1,37 +1,37 @@
-import { BigNumberish, Uint256 } from "starknet";
-import { StarknetTx } from "../starknet/chain/modules/StarknetTransactions";
-import { Buffer } from "buffer";
-import { StarknetSwapData } from "../starknet/swaps/StarknetSwapData";
-import { IClaimHandler } from "../starknet/swaps/handlers/claim/ClaimHandlers";
-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 declare function getLogger(prefix: string): {
-    debug: (msg: any, ...args: any[]) => void;
-    info: (msg: any, ...args: any[]) => void;
-    warn: (msg: any, ...args: any[]) => void;
-    error: (msg: any, ...args: any[]) => void;
-};
-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 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 bytes31SpanToBuffer(span: BigNumberish[], length: number): Buffer;
-export declare function bufferToBytes31Span(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish[];
-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 parseInitFunctionCalldata(calldata: BigNumberish[], claimHandler: IClaimHandler<any, any>): {
-    escrow: StarknetSwapData;
-    signature: BigNumberish[];
-    timeout: bigint;
-    extraData: BigNumberish[];
-};
-export declare function findLastIndex<T>(array: T[], callback: (value: T, index: number) => boolean): number;
+import { BigNumberish, Uint256 } from "starknet";
+import { StarknetTx } from "../starknet/chain/modules/StarknetTransactions";
+import { Buffer } from "buffer";
+import { StarknetSwapData } from "../starknet/swaps/StarknetSwapData";
+import { IClaimHandler } from "../starknet/swaps/handlers/claim/ClaimHandlers";
+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 declare function getLogger(prefix: string): {
+    debug: (msg: any, ...args: any[]) => void;
+    info: (msg: any, ...args: any[]) => void;
+    warn: (msg: any, ...args: any[]) => void;
+    error: (msg: any, ...args: any[]) => void;
+};
+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 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 bytes31SpanToBuffer(span: BigNumberish[], length: number): Buffer;
+export declare function bufferToBytes31Span(buffer: Buffer, startIndex?: number, endIndex?: number): BigNumberish[];
+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 parseInitFunctionCalldata(calldata: BigNumberish[], claimHandler: IClaimHandler<any, any>): {
+    escrow: StarknetSwapData;
+    signature: BigNumberish[];
+    timeout: bigint;
+    extraData: BigNumberish[];
+};
+export declare function findLastIndex<T>(array: T[], callback: (value: T, index: number) => boolean): number;