@atomiqlabs/chain-starknet 5.0.2 → 5.1.1

package/dist/starknet/StarknetInitializer.d.ts

@@ -1,7 +1,7 @@
 import { constants, Provider } from "starknet";
 import { StarknetFees } from "./chain/modules/StarknetFees";
 import { StarknetRetryPolicy } from "./chain/StarknetChainInterface";
-import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer } from "@atomiqlabs/base";
+import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType } from "@atomiqlabs/base";
 import { StarknetChainType } from "./StarknetChainType";
 export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC">;
 export declare const StarknetAssets: StarknetAssetsType;
@@ -12,6 +12,14 @@ export type StarknetOptions = {
     swapContract?: string;
     btcRelayContract?: string;
     spvVaultContract?: string;
+    handlerContracts?: {
+        refund?: {
+            timelock?: string;
+        };
+        claim?: {
+            [type in ChainSwapType]?: string;
+        };
+    };
     fees?: StarknetFees;
 };
 export declare function initializeStarknet(options: StarknetOptions, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork): ChainData<StarknetChainType>;

package/dist/starknet/StarknetInitializer.js

@@ -27,18 +27,23 @@ exports.StarknetAssets = {
     WBTC: {
         address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
         decimals: 8
-    }
+    },
+    // TBTC: {
+    //     address: "0x04daa17763b286d1e59b97c283C0b8C949994C361e426A28F743c67bDfE9a32f",
+    //     decimals: 18,
+    //     displayDecimals: 8
+    // }
 };
 function initializeStarknet(options, bitcoinRpc, network) {
     const provider = typeof (options.rpcUrl) === "string" ?
         new RpcProviderWithRetries_1.RpcProviderWithRetries({ nodeUrl: options.rpcUrl }) :
         options.rpcUrl;
-    const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider, "STRK");
+    const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider);
     const chainId = options.chainId ??
         (network === base_1.BitcoinNetwork.MAINNET ? starknet_1.constants.StarknetChainId.SN_MAIN : starknet_1.constants.StarknetChainId.SN_SEPOLIA);
     const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, options.retryPolicy, Fees);
     const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract);
-    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract);
+    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract, options.handlerContracts);
     const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract);
     const chainEvents = new StarknetChainEventsBrowser_1.StarknetChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {

package/dist/starknet/btcrelay/StarknetBtcRelay.js

@@ -22,8 +22,8 @@ function serializeBlockHeader(e) {
         hash: buffer_1.Buffer.from(e.getHash(), "hex").reverse()
     });
 }
-const GAS_PER_BLOCKHEADER = 850;
-const GAS_PER_BLOCKHEADER_FORK = 1000;
+const GAS_PER_BLOCKHEADER = { l1DataGas: 600, l2Gas: 40000000, l1Gas: 0 };
+const GAS_PER_BLOCKHEADER_FORK = { l1DataGas: 1000, l2Gas: 60000000, l1Gas: 0 };
 const btcRelayAddreses = {
     [base_1.BitcoinNetwork.TESTNET4]: "0x0099b63f39f0cabb767361de3d8d3e97212351a51540e2687c2571f4da490dbe",
     [base_1.BitcoinNetwork.TESTNET]: "0x068601c79da2231d21e015ccfd59c243861156fa523a12c9f987ec28eb8dbc8c",
@@ -44,21 +44,21 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             contractAddress: this.contract.address,
             entrypoint: "submit_main_blockheaders",
             calldata: serializeCalldata(mainHeaders, storedHeader, [])
-        }, { l1: GAS_PER_BLOCKHEADER * mainHeaders.length, l2: 0 });
+        }, (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, mainHeaders.length));
     }
     SaveShortForkHeaders(signer, forkHeaders, storedHeader) {
         return new StarknetAction_1.StarknetAction(signer, this.Chain, {
             contractAddress: this.contract.address,
             entrypoint: "submit_short_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [])
-        }, { l1: GAS_PER_BLOCKHEADER * forkHeaders.length, l2: 0 });
+        }, (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length));
     }
     SaveLongForkHeaders(signer, forkId, forkHeaders, storedHeader, totalForkHeaders = 100) {
         return new StarknetAction_1.StarknetAction(signer, this.Chain, {
             contractAddress: this.contract.address,
             entrypoint: "submit_fork_blockheaders",
             calldata: serializeCalldata(forkHeaders, storedHeader, [(0, Utils_1.toHex)(forkId)])
-        }, { l1: (GAS_PER_BLOCKHEADER * forkHeaders.length) + (GAS_PER_BLOCKHEADER_FORK * totalForkHeaders), l2: 0 });
+        }, (0, StarknetFees_1.starknetGasAdd)((0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length), (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)));
     }
     constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress = btcRelayAddreses[bitcoinNetwork]) {
         super(chainInterface, contractAddress, BtcRelayAbi_1.BtcRelayAbi);

package/dist/starknet/chain/StarknetAction.d.ts

@@ -1,17 +1,9 @@
 import { Call } from "starknet";
 import { StarknetChainInterface } from "./StarknetChainInterface";
 import { StarknetTx } from "./modules/StarknetTransactions";
-export type StarknetGas = {
-    l1?: number;
-    l2?: number;
-};
-export declare function sumStarknetGas(a: StarknetGas, b: StarknetGas): {
-    l1: number;
-    l2: number;
-};
+import { StarknetGas } from "./modules/StarknetFees";
 export declare class StarknetAction {
-    L1GasLimit: number;
-    L2GasLimit: number;
+    gas: StarknetGas;
     readonly mainSigner: string;
     private readonly root;
     private readonly instructions;

package/dist/starknet/chain/StarknetAction.js

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetAction = exports.sumStarknetGas = void 0;
-function sumStarknetGas(a, b) {
-    return {
-        l1: (a?.l1 ?? 0) + (b?.l1 ?? 0),
-        l2: (a?.l2 ?? 0) + (b?.l2 ?? 0)
-    };
-}
-exports.sumStarknetGas = sumStarknetGas;
+exports.StarknetAction = void 0;
+const StarknetFees_1 = require("./modules/StarknetFees");
 class StarknetAction {
     constructor(mainSigner, root, instructions = [], gasLimit, feeRate) {
         this.mainSigner = mainSigner;
         this.root = root;
         this.instructions = Array.isArray(instructions) ? instructions : [instructions];
-        this.L1GasLimit = gasLimit?.l1 ?? 0;
-        this.L2GasLimit = gasLimit?.l2 ?? 0;
+        this.gas = {
+            l1Gas: gasLimit?.l1Gas ?? 0,
+            l2Gas: gasLimit?.l2Gas ?? 0,
+            l1DataGas: gasLimit?.l1DataGas ?? 0,
+        };
         this.feeRate = feeRate;
     }
     estimateFeeRate() {
@@ -22,8 +19,7 @@ class StarknetAction {
     }
     addIx(instruction, gasLimit) {
         this.instructions.push(instruction);
-        this.L1GasLimit += gasLimit?.l1 ?? 0;
-        this.L2GasLimit += gasLimit?.l2 ?? 0;
+        this.gas = (0, StarknetFees_1.starknetGasAdd)(this.gas, gasLimit);
     }
     add(action) {
         return this.addAction(action);
@@ -31,14 +27,18 @@ class StarknetAction {
     addAction(action, index = this.instructions.length) {
         if (action.mainSigner !== this.mainSigner)
             throw new Error("Actions need to have the same signer!");
-        if (this.L1GasLimit == null && action.L1GasLimit != null)
-            this.L1GasLimit = action.L1GasLimit;
-        if (this.L2GasLimit == null && action.L2GasLimit != null)
-            this.L2GasLimit = action.L2GasLimit;
-        if (this.L1GasLimit != null && action.L1GasLimit != null)
-            this.L1GasLimit += action.L1GasLimit;
-        if (this.L2GasLimit != null && action.L2GasLimit != null)
-            this.L2GasLimit += action.L2GasLimit;
+        if (this.gas.l1Gas == null && action.gas.l1Gas != null)
+            this.gas.l1Gas = action.gas.l1Gas;
+        if (this.gas.l2Gas == null && action.gas.l2Gas != null)
+            this.gas.l2Gas = action.gas.l2Gas;
+        if (this.gas.l1DataGas == null && action.gas.l1DataGas != null)
+            this.gas.l1DataGas = action.gas.l1DataGas;
+        if (this.gas.l1Gas != null && action.gas.l1Gas != null)
+            this.gas.l1Gas += action.gas.l1Gas;
+        if (this.gas.l2Gas != null && action.gas.l2Gas != null)
+            this.gas.l2Gas += action.gas.l2Gas;
+        if (this.gas.l1DataGas != null && action.gas.l1DataGas != null)
+            this.gas.l1DataGas += action.gas.l1DataGas;
         this.instructions.splice(index, 0, ...action.instructions);
         if (this.feeRate == null)
             this.feeRate = action.feeRate;
@@ -53,7 +53,7 @@ class StarknetAction {
             type: "INVOKE",
             tx: this.instructions,
             details: {
-                ...this.root.Fees.getFeeDetails(this.L1GasLimit, this.L2GasLimit, feeRate),
+                ...this.root.Fees.getFeeDetails(this.gas, feeRate),
                 walletAddress: this.mainSigner,
                 cairoVersion: "1",
                 chainId: this.root.starknetChainId,

package/dist/starknet/chain/modules/StarknetAccounts.js

@@ -4,7 +4,7 @@ exports.StarknetAccounts = void 0;
 const StarknetModule_1 = require("../StarknetModule");
 class StarknetAccounts extends StarknetModule_1.StarknetModule {
     async getAccountDeployTransaction(deploymentData) {
-        const feeDetails = this.root.Fees.getFeeDetails(5000, 0, await this.root.Fees.getFeeRate());
+        const feeDetails = this.root.Fees.getFeeDetails({ l1DataGas: 500, l2Gas: 5000 * 40000, l1Gas: 0 }, await this.root.Fees.getFeeRate());
         const details = {
             ...feeDetails,
             walletAddress: deploymentData.contractAddress,

package/dist/starknet/chain/modules/StarknetFees.d.ts

@@ -1,14 +1,25 @@
 import { Provider } from "starknet";
+export type StarknetFeeRate = {
+    l1GasCost: bigint;
+    l2GasCost: bigint;
+    l1DataGasCost: bigint;
+};
+export type StarknetGas = {
+    l1Gas: number;
+    l2Gas: number;
+    l1DataGas: number;
+};
+export declare function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas;
+export declare function starknetGasAdd(a: StarknetGas, b: StarknetGas): StarknetGas;
 export declare class StarknetFees {
     private readonly logger;
     private readonly feeDA;
     private readonly nonceDA;
     private readonly provider;
-    private readonly gasToken;
     private readonly maxFeeRate;
     private readonly feeMultiplierPPM;
     private blockFeeCache;
-    constructor(provider: Provider, gasToken?: "ETH" | "STRK", maxFeeRate?: number, feeMultiplier?: number, da?: {
+    constructor(provider: Provider, maxFeeRate?: StarknetFeeRate, feeMultiplier?: number, da?: {
         fee?: "L1" | "L2";
         nonce?: "L1" | "L2";
     });
@@ -16,7 +27,7 @@ export declare class StarknetFees {
      * Gets starknet fee rate
      *
      * @private
-     * @returns {Promise<BN>} L1 gas price denominated in Wei
+     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
      */
     private _getFeeRate;
     /**
@@ -27,16 +38,23 @@ export declare class StarknetFees {
     getFeeRate(): Promise<string>;
     getDefaultGasToken(): string;
     /**
-     * Calculates the total gas fee fee paid for a given gas limit at a given fee rate
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
      *
      * @param gas
      * @param feeRate
      */
-    static getGasFee(gas: number, feeRate: string): bigint;
+    static getGasFee(gas: {
+        l1DataGas: number;
+        l2Gas: number;
+        l1Gas: number;
+    }, feeRate: string): bigint;
     static getGasToken(feeRate: string): string;
-    getFeeDetails(L1GasLimit: number, L2GasLimit: number, feeRate: string): {
-        maxFee: string;
-        version: "0x3" | "0x1";
+    getFeeDetails(gas: {
+        l1DataGas: number;
+        l2Gas: number;
+        l1Gas: number;
+    }, feeRate: string): {
+        version: "0x3";
         resourceBounds: {
             l1_gas: {
                 max_amount: string;
@@ -46,6 +64,10 @@ export declare class StarknetFees {
                 max_amount: string;
                 max_price_per_unit: string;
             };
+            l1_data_gas: {
+                max_amount: string;
+                max_price_per_unit: string;
+            };
         };
         tip: string;
         paymasterData: any[];

package/dist/starknet/chain/modules/StarknetFees.js

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetFees = void 0;
+exports.StarknetFees = exports.starknetGasAdd = exports.starknetGasMul = void 0;
 const Utils_1 = require("../../../utils/Utils");
 const StarknetTokens_1 = require("./StarknetTokens");
 const MAX_FEE_AGE = 5000;
+function starknetGasMul(gas, scalar) {
+    return { l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar };
+}
+exports.starknetGasMul = starknetGasMul;
+function starknetGasAdd(a, b) {
+    return { l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas };
+}
+exports.starknetGasAdd = starknetGasAdd;
 class StarknetFees {
-    constructor(provider, gasToken = "STRK", maxFeeRate = gasToken === "ETH" ? 100000000000 /*100 GWei*/ : 1000000000000000 /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
+    constructor(provider, maxFeeRate = { l1GasCost: 1000000000000000n, l2GasCost: 1000000000000000n, l1DataGasCost: 1000000000000000n } /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
         this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
         this.blockFeeCache = null;
         this.provider = provider;
-        this.gasToken = gasToken;
-        this.maxFeeRate = BigInt(maxFeeRate);
+        this.maxFeeRate = maxFeeRate;
         this.feeDA = da?.fee ?? "L1";
         this.nonceDA = da?.nonce ?? "L1";
         this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1000000));
@@ -19,14 +26,17 @@ class StarknetFees {
      * Gets starknet fee rate
      *
      * @private
-     * @returns {Promise<BN>} L1 gas price denominated in Wei
+     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
      */
     async _getFeeRate() {
-        const block = await this.provider.getBlockWithTxHashes("latest");
-        let l1GasCost = (0, Utils_1.toBigInt)(this.gasToken === "ETH" ? block.l1_gas_price.price_in_wei : block.l1_gas_price.price_in_fri);
-        l1GasCost = l1GasCost * this.feeMultiplierPPM / 1000000n;
-        this.logger.debug("_getFeeRate(): L1 fee rate: " + l1GasCost.toString(10));
-        return l1GasCost;
+        const block = await this.provider.getBlock("latest");
+        let l1GasCost = (0, Utils_1.toBigInt)(block.l1_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        let l1DataGasCost = (0, Utils_1.toBigInt)(block.l1_data_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        let l2GasCost = (0, Utils_1.toBigInt)(block.l2_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        this.logger.debug("_getFeeRate(): L1 fee rate: ", [l1GasCost.toString(10), l1DataGasCost.toString(10), l2GasCost.toString(10)]);
+        return {
+            l1GasCost, l2GasCost, l1DataGasCost
+        };
     }
     /**
      * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
@@ -46,18 +56,22 @@ class StarknetFees {
             });
             this.blockFeeCache = obj;
         }
-        let feeRate = await this.blockFeeCache.feeRate;
-        if (feeRate > this.maxFeeRate)
-            feeRate = this.maxFeeRate;
-        const fee = feeRate.toString(10) + ";" + (this.gasToken === "ETH" ? "v1" : "v3");
+        let { l1GasCost, l2GasCost, l1DataGasCost } = await this.blockFeeCache.feeRate;
+        if (l1GasCost > this.maxFeeRate.l1GasCost)
+            l1GasCost = this.maxFeeRate.l1GasCost;
+        if (l2GasCost > this.maxFeeRate.l2GasCost)
+            l2GasCost = this.maxFeeRate.l2GasCost;
+        if (l1DataGasCost > this.maxFeeRate.l1DataGasCost)
+            l1DataGasCost = this.maxFeeRate.l1DataGasCost;
+        const fee = l1GasCost.toString(10) + "," + l2GasCost.toString(10) + "," + l1DataGasCost.toString(10) + ";v3";
         this.logger.debug("getFeeRate(): calculated fee: " + fee);
         return fee;
     }
     getDefaultGasToken() {
-        return this.gasToken === "ETH" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
+        return StarknetTokens_1.StarknetTokens.ERC20_STRK;
     }
     /**
-     * Calculates the total gas fee fee paid for a given gas limit at a given fee rate
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
      *
      * @param gas
      * @param feeRate
@@ -66,8 +80,10 @@ class StarknetFees {
         if (feeRate == null)
             return 0n;
         const arr = feeRate.split(";");
-        const gasPrice = BigInt(arr[0]);
-        return gasPrice * BigInt(gas);
+        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
+        return (BigInt(gas.l1Gas) * BigInt(l1GasCostStr)) +
+            (BigInt(gas.l2Gas) * BigInt(l2GasCostStr)) +
+            (BigInt(gas.l1DataGas) * BigInt(l1DataGasCostStr));
     }
     static getGasToken(feeRate) {
         if (feeRate == null)
@@ -76,19 +92,17 @@ class StarknetFees {
         const txVersion = arr[1];
         return txVersion === "v1" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
     }
-    getFeeDetails(L1GasLimit, L2GasLimit, feeRate) {
+    getFeeDetails(gas, feeRate) {
         if (feeRate == null)
             return null;
         const arr = feeRate.split(";");
-        const gasPrice = BigInt(arr[0]);
-        const version = arr[1];
-        const maxFee = (0, Utils_1.toHex)(BigInt(L1GasLimit) * gasPrice, 16);
+        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
         return {
-            maxFee: maxFee,
-            version: version === "v1" ? "0x1" : "0x3",
+            version: "0x3",
             resourceBounds: {
-                l1_gas: { max_amount: (0, Utils_1.toHex)(L1GasLimit, 16), max_price_per_unit: (0, Utils_1.toHex)(gasPrice, 16) },
-                l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" }
+                l1_gas: { max_amount: (0, Utils_1.toHex)(gas.l1Gas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l1GasCostStr), 16) },
+                l2_gas: { max_amount: (0, Utils_1.toHex)(gas.l2Gas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l2GasCostStr), 16) },
+                l1_data_gas: { max_amount: (0, Utils_1.toHex)(gas.l1DataGas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l1DataGasCostStr), 16) }
             },
             tip: "0x0",
             paymasterData: [],

package/dist/starknet/chain/modules/StarknetSignatures.js

@@ -41,7 +41,7 @@ class StarknetSignatures extends StarknetModule_1.StarknetModule {
         return JSON.stringify(starknet_1.stark.formatSignature(signature));
     }
     async isValidSignature(signature, address, type, typeName, message) {
-        return new starknet_1.Account(this.provider, address, null).verifyMessage(this.getTypedMessage(type, typeName, message), JSON.parse(signature));
+        return this.provider.verifyMessageInStarknet(this.getTypedMessage(type, typeName, message), JSON.parse(signature), address);
     }
     ///////////////////
     //// Data signatures

package/dist/starknet/chain/modules/StarknetTokens.d.ts

@@ -5,12 +5,14 @@ export declare class StarknetTokens extends StarknetModule {
     static readonly ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
     static readonly GasCosts: {
         TRANSFER: {
-            l1: number;
-            l2: number;
+            l1DataGas: number;
+            l2Gas: number;
+            l1Gas: number;
         };
         APPROVE: {
-            l1: number;
-            l2: number;
+            l1DataGas: number;
+            l2Gas: number;
+            l1Gas: number;
         };
     };
     private getContract;

package/dist/starknet/chain/modules/StarknetTokens.js

@@ -93,6 +93,6 @@ exports.StarknetTokens = StarknetTokens;
 StarknetTokens.ERC20_ETH = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
 StarknetTokens.ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
 StarknetTokens.GasCosts = {
-    TRANSFER: { l1: 400, l2: 0 },
-    APPROVE: { l1: 400, l2: 0 }
+    TRANSFER: { l1DataGas: 400, l2Gas: 4000000, l1Gas: 0 },
+    APPROVE: { l1DataGas: 400, l2Gas: 4000000, l1Gas: 0 }
 };

package/dist/starknet/chain/modules/StarknetTransactions.js

@@ -25,7 +25,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
                 await this.sendSignedTransaction(tx).catch(e => {
                     if (e.baseError?.code === 59)
                         return; //Transaction already in the mempool
-                    console.error("Error on transaction re-send: ", e);
+                    this.logger.error("confirmTransaction(): Error on transaction re-send: ", e);
                 });
         }
         if (state === "rejected")
@@ -49,7 +49,7 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
         let nonce = await signer.getNonce();
         const latestConfirmedNonce = this.latestConfirmedNonces[signer.getAddress()];
         if (latestConfirmedNonce != null && latestConfirmedNonce > nonce) {
-            console.debug("StarknetTransactions: prepareTransactions(): Using nonce from local cache!");
+            this.logger.debug("prepareTransactions(): Using nonce from local cache!");
             nonce = latestConfirmedNonce;
         }
         if (nonce === BigInt(0) && signer.isWalletAccount()) {

package/dist/starknet/events/StarknetChainEventsBrowser.d.ts

@@ -16,7 +16,7 @@ export type StarknetTraceCall = {
     calls: StarknetTraceCall[];
 };
 /**
- * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
+ * Starknet on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
  *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
  *  rely purely on events
  */
@@ -25,7 +25,6 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
     protected readonly provider: Provider;
     protected readonly starknetSwapContract: StarknetSwapContract;
     protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
-    protected eventListeners: number[];
     protected readonly logger: {
         debug: (msg: any, ...args: any[]) => void;
         info: (msg: any, ...args: any[]) => void;

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -5,14 +5,13 @@ const base_1 = require("@atomiqlabs/base");
 const Utils_1 = require("../../utils/Utils");
 const starknet_1 = require("starknet");
 /**
- * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
+ * Starknet on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
  *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
  *  rely purely on events
  */
 class StarknetChainEventsBrowser {
     constructor(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds = 5) {
         this.listeners = [];
-        this.eventListeners = [];
         this.logger = (0, Utils_1.getLogger)("StarknetChainEventsBrowser: ");
         this.initFunctionName = "initialize";
         this.initEntryPointSelector = BigInt(starknet_1.hash.starknetKeccak(this.initFunctionName));
@@ -279,7 +278,6 @@ class StarknetChainEventsBrowser {
         this.stopped = true;
         if (this.timeout != null)
             clearTimeout(this.timeout);
-        this.eventListeners = [];
     }
     registerListener(cbk) {
         this.listeners.push(cbk);

package/dist/starknet/spv_swap/StarknetSpvVaultContract.js

@@ -14,8 +14,8 @@ const Utils_1 = require("../../utils/Utils");
 const StarknetAddresses_1 = require("../chain/modules/StarknetAddresses");
 const StarknetFees_1 = require("../chain/modules/StarknetFees");
 const spvVaultContractAddreses = {
-    [starknet_1.constants.StarknetChainId.SN_SEPOLIA]: "0x047961ea0687a2e3207478d386779bd5ec22aa8abc234319ccd723e2d7191a0c",
-    [starknet_1.constants.StarknetChainId.SN_MAIN]: "0x06ee5228af01baa443657ccda27b80637a609d43a97ed2f8fd478313e10abf4e"
+    [starknet_1.constants.StarknetChainId.SN_SEPOLIA]: "0x02d581ea838cd5ca46ba08660eddd064d50a0392f618e95310432147928d572e",
+    [starknet_1.constants.StarknetChainId.SN_MAIN]: "0x01932042992647771f3d0aa6ee526e65359c891fe05a285faaf4d3ffa373e132"
 };
 const STARK_PRIME_MOD = 2n ** 251n + 17n * 2n ** 192n + 1n;
 function decodeUtxo(utxo) {
@@ -360,17 +360,17 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
     }
     async getClaimFee(signer, withdrawalData, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM.l1, feeRate);
+        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM, feeRate);
     }
     async getFrontFee(signer, withdrawalData, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT.l1, feeRate);
+        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT, feeRate);
     }
 }
 exports.StarknetSpvVaultContract = StarknetSpvVaultContract;
 StarknetSpvVaultContract.GasCosts = {
-    DEPOSIT: { l1: 750, l2: 0 },
-    OPEN: { l1: 1500, l2: 0 },
-    FRONT: { l1: 750, l2: 0 },
-    CLAIM: { l1: 10000, l2: 0 }
+    DEPOSIT: { l1DataGas: 400, l2Gas: 4000000, l1Gas: 0 },
+    OPEN: { l1DataGas: 1200, l2Gas: 3200000, l1Gas: 0 },
+    FRONT: { l1DataGas: 800, l2Gas: 12000000, l1Gas: 0 },
+    CLAIM: { l1DataGas: 1000, l2Gas: 400000000, l1Gas: 0 }
 };

package/dist/starknet/spv_swap/StarknetSpvVaultData.js

@@ -97,6 +97,7 @@ class StarknetSpvVaultData extends base_1.SpvVaultData {
             utxo: this.utxo,
             confirmations: this.confirmations,
             withdrawCount: this.withdrawCount,
+            depositCount: this.depositCount,
             initialUtxo: this.initialUtxo
         };
     }

package/dist/starknet/swaps/EscrowManagerAbi.d.ts

@@ -12,6 +12,29 @@ export declare const EscrowManagerAbi: readonly [{
         readonly name: "high";
         readonly type: "core::integer::u128";
     }];
+}, {
+    readonly type: "struct";
+    readonly name: "escrow_manager::structs::escrow::EscrowExecution";
+    readonly members: readonly [{
+        readonly name: "hash";
+        readonly type: "core::felt252";
+    }, {
+        readonly name: "expiry";
+        readonly type: "core::integer::u64";
+    }, {
+        readonly name: "fee";
+        readonly type: "core::integer::u256";
+    }];
+}, {
+    readonly type: "enum";
+    readonly name: "core::option::Option::<escrow_manager::structs::escrow::EscrowExecution>";
+    readonly variants: readonly [{
+        readonly name: "Some";
+        readonly type: "escrow_manager::structs::escrow::EscrowExecution";
+    }, {
+        readonly name: "None";
+        readonly type: "()";
+    }];
 }, {
     readonly type: "struct";
     readonly name: "escrow_manager::structs::escrow::EscrowData";
@@ -51,6 +74,9 @@ export declare const EscrowManagerAbi: readonly [{
     }, {
         readonly name: "claimer_bounty";
         readonly type: "core::integer::u256";
+    }, {
+        readonly name: "success_action";
+        readonly type: "core::option::Option::<escrow_manager::structs::escrow::EscrowExecution>";
     }];
 }, {
     readonly type: "struct";

package/dist/starknet/swaps/EscrowManagerAbi.js

@@ -21,6 +21,38 @@ exports.EscrowManagerAbi = [
             }
         ]
     },
+    {
+        "type": "struct",
+        "name": "escrow_manager::structs::escrow::EscrowExecution",
+        "members": [
+            {
+                "name": "hash",
+                "type": "core::felt252"
+            },
+            {
+                "name": "expiry",
+                "type": "core::integer::u64"
+            },
+            {
+                "name": "fee",
+                "type": "core::integer::u256"
+            }
+        ]
+    },
+    {
+        "type": "enum",
+        "name": "core::option::Option::<escrow_manager::structs::escrow::EscrowExecution>",
+        "variants": [
+            {
+                "name": "Some",
+                "type": "escrow_manager::structs::escrow::EscrowExecution"
+            },
+            {
+                "name": "None",
+                "type": "()"
+            }
+        ]
+    },
     {
         "type": "struct",
         "name": "escrow_manager::structs::escrow::EscrowData",
@@ -72,6 +104,10 @@ exports.EscrowManagerAbi = [
             {
                 "name": "claimer_bounty",
                 "type": "core::integer::u256"
+            },
+            {
+                "name": "success_action",
+                "type": "core::option::Option::<escrow_manager::structs::escrow::EscrowExecution>"
             }
         ]
     },

package/dist/starknet/swaps/StarknetSwapContract.d.ts

@@ -147,7 +147,7 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
         txid: string;
         hex: string;
         height: number;
-    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, initAta?: boolean, feeRate?: string): Promise<StarknetTx[] | null>;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, initAta?: boolean, feeRate?: string): Promise<StarknetTx[]>;
     txsRefund(signer: string, swapData: StarknetSwapData, check?: boolean, initAta?: boolean, feeRate?: string): Promise<StarknetTx[]>;
     txsRefundWithAuthorization(signer: string, swapData: StarknetSwapData, { timeout, prefix, signature }: {
         timeout: any;