@atomiqlabs/chain-starknet 4.0.0-dev.9 → 5.0.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, ChainSwapType } from "@atomiqlabs/base";
+import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer } from "@atomiqlabs/base";
 import { StarknetChainType } from "./StarknetChainType";
 export type StarknetAssetsType = BaseTokenType<"ETH" | "STRK" | "WBTC">;
 export declare const StarknetAssets: StarknetAssetsType;
@@ -12,14 +12,6 @@ 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,23 +27,18 @@ 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);
+    const Fees = options.fees ?? new StarknetFees_1.StarknetFees(provider, "STRK");
     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, options.handlerContracts);
+    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract);
     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 = { l1DataGas: 600, l2Gas: 40000000, l1Gas: 0 };
-const GAS_PER_BLOCKHEADER_FORK = { l1DataGas: 1000, l2Gas: 60000000, l1Gas: 0 };
+const GAS_PER_BLOCKHEADER = 850;
+const GAS_PER_BLOCKHEADER_FORK = 1000;
 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, [])
-        }, (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, mainHeaders.length));
+        }, { l1: GAS_PER_BLOCKHEADER * mainHeaders.length, l2: 0 });
     }
     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, [])
-        }, (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length));
+        }, { l1: GAS_PER_BLOCKHEADER * forkHeaders.length, l2: 0 });
     }
     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)])
-        }, (0, StarknetFees_1.starknetGasAdd)((0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length), (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)));
+        }, { l1: (GAS_PER_BLOCKHEADER * forkHeaders.length) + (GAS_PER_BLOCKHEADER_FORK * totalForkHeaders), l2: 0 });
     }
     constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress = btcRelayAddreses[bitcoinNetwork]) {
         super(chainInterface, contractAddress, BtcRelayAbi_1.BtcRelayAbi);

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

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

package/dist/starknet/chain/StarknetAction.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetAction = void 0;
-const StarknetFees_1 = require("./modules/StarknetFees");
+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;
 class StarknetAction {
     constructor(mainSigner, root, instructions = [], gasLimit, feeRate) {
         this.mainSigner = mainSigner;
         this.root = root;
         this.instructions = Array.isArray(instructions) ? instructions : [instructions];
-        this.gas = {
-            l1Gas: gasLimit?.l1Gas ?? 0,
-            l2Gas: gasLimit?.l2Gas ?? 0,
-            l1DataGas: gasLimit?.l1DataGas ?? 0,
-        };
+        this.L1GasLimit = gasLimit?.l1 ?? 0;
+        this.L2GasLimit = gasLimit?.l2 ?? 0;
         this.feeRate = feeRate;
     }
     estimateFeeRate() {
@@ -19,7 +22,8 @@ class StarknetAction {
     }
     addIx(instruction, gasLimit) {
         this.instructions.push(instruction);
-        this.gas = (0, StarknetFees_1.starknetGasAdd)(this.gas, gasLimit);
+        this.L1GasLimit += gasLimit?.l1 ?? 0;
+        this.L2GasLimit += gasLimit?.l2 ?? 0;
     }
     add(action) {
         return this.addAction(action);
@@ -27,18 +31,14 @@ 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.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;
+        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;
         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.gas, feeRate),
+                ...this.root.Fees.getFeeDetails(this.L1GasLimit, this.L2GasLimit, 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({ l1DataGas: 500, l2Gas: 5000 * 40000, l1Gas: 0 }, await this.root.Fees.getFeeRate());
+        const feeDetails = this.root.Fees.getFeeDetails(5000, 0, await this.root.Fees.getFeeRate());
         const details = {
             ...feeDetails,
             walletAddress: deploymentData.contractAddress,

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

@@ -1,25 +1,14 @@
 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, maxFeeRate?: StarknetFeeRate, feeMultiplier?: number, da?: {
+    constructor(provider: Provider, gasToken?: "ETH" | "STRK", maxFeeRate?: number, feeMultiplier?: number, da?: {
         fee?: "L1" | "L2";
         nonce?: "L1" | "L2";
     });
@@ -27,7 +16,7 @@ export declare class StarknetFees {
      * Gets starknet fee rate
      *
      * @private
-     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
+     * @returns {Promise<BN>} L1 gas price denominated in Wei
      */
     private _getFeeRate;
     /**
@@ -38,23 +27,16 @@ export declare class StarknetFees {
     getFeeRate(): Promise<string>;
     getDefaultGasToken(): string;
     /**
-     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     * Calculates the total gas fee fee paid for a given gas limit at a given fee rate
      *
      * @param gas
      * @param feeRate
      */
-    static getGasFee(gas: {
-        l1DataGas: number;
-        l2Gas: number;
-        l1Gas: number;
-    }, feeRate: string): bigint;
+    static getGasFee(gas: number, feeRate: string): bigint;
     static getGasToken(feeRate: string): string;
-    getFeeDetails(gas: {
-        l1DataGas: number;
-        l2Gas: number;
-        l1Gas: number;
-    }, feeRate: string): {
-        version: "0x3";
+    getFeeDetails(L1GasLimit: number, L2GasLimit: number, feeRate: string): {
+        maxFee: string;
+        version: "0x3" | "0x1";
         resourceBounds: {
             l1_gas: {
                 max_amount: string;
@@ -64,10 +46,6 @@ 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,23 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetFees = exports.starknetGasAdd = exports.starknetGasMul = void 0;
+exports.StarknetFees = 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, maxFeeRate = { l1GasCost: 1000000000000000n, l2GasCost: 1000000000000000n, l1DataGasCost: 1000000000000000n } /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
+    constructor(provider, gasToken = "STRK", maxFeeRate = gasToken === "ETH" ? 100000000000 /*100 GWei*/ : 1000000000000000 /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
         this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
         this.blockFeeCache = null;
         this.provider = provider;
-        this.maxFeeRate = maxFeeRate;
+        this.gasToken = gasToken;
+        this.maxFeeRate = BigInt(maxFeeRate);
         this.feeDA = da?.fee ?? "L1";
         this.nonceDA = da?.nonce ?? "L1";
         this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1000000));
@@ -26,17 +19,14 @@ class StarknetFees {
      * Gets starknet fee rate
      *
      * @private
-     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
+     * @returns {Promise<BN>} L1 gas price denominated in Wei
      */
     async _getFeeRate() {
-        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
-        };
+        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;
     }
     /**
      * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
@@ -56,22 +46,18 @@ class StarknetFees {
             });
             this.blockFeeCache = obj;
         }
-        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";
+        let feeRate = await this.blockFeeCache.feeRate;
+        if (feeRate > this.maxFeeRate)
+            feeRate = this.maxFeeRate;
+        const fee = feeRate.toString(10) + ";" + (this.gasToken === "ETH" ? "v1" : "v3");
         this.logger.debug("getFeeRate(): calculated fee: " + fee);
         return fee;
     }
     getDefaultGasToken() {
-        return StarknetTokens_1.StarknetTokens.ERC20_STRK;
+        return this.gasToken === "ETH" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
     }
     /**
-     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     * Calculates the total gas fee fee paid for a given gas limit at a given fee rate
      *
      * @param gas
      * @param feeRate
@@ -80,10 +66,8 @@ class StarknetFees {
         if (feeRate == null)
             return 0n;
         const arr = feeRate.split(";");
-        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
-        return (BigInt(gas.l1Gas) * BigInt(l1GasCostStr)) +
-            (BigInt(gas.l2Gas) * BigInt(l2GasCostStr)) +
-            (BigInt(gas.l1DataGas) * BigInt(l1DataGasCostStr));
+        const gasPrice = BigInt(arr[0]);
+        return gasPrice * BigInt(gas);
     }
     static getGasToken(feeRate) {
         if (feeRate == null)
@@ -92,17 +76,19 @@ class StarknetFees {
         const txVersion = arr[1];
         return txVersion === "v1" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
     }
-    getFeeDetails(gas, feeRate) {
+    getFeeDetails(L1GasLimit, L2GasLimit, feeRate) {
         if (feeRate == null)
             return null;
         const arr = feeRate.split(";");
-        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
+        const gasPrice = BigInt(arr[0]);
+        const version = arr[1];
+        const maxFee = (0, Utils_1.toHex)(BigInt(L1GasLimit) * gasPrice, 16);
         return {
-            version: "0x3",
+            maxFee: maxFee,
+            version: version === "v1" ? "0x1" : "0x3",
             resourceBounds: {
-                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) }
+                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" }
             },
             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 this.provider.verifyMessageInStarknet(this.getTypedMessage(type, typeName, message), JSON.parse(signature), address);
+        return new starknet_1.Account(this.provider, address, null).verifyMessage(this.getTypedMessage(type, typeName, message), JSON.parse(signature));
     }
     ///////////////////
     //// Data signatures

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

@@ -5,14 +5,12 @@ export declare class StarknetTokens extends StarknetModule {
     static readonly ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
     static readonly GasCosts: {
         TRANSFER: {
-            l1DataGas: number;
-            l2Gas: number;
-            l1Gas: number;
+            l1: number;
+            l2: number;
         };
         APPROVE: {
-            l1DataGas: number;
-            l2Gas: number;
-            l1Gas: number;
+            l1: number;
+            l2: 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: { l1DataGas: 400, l2Gas: 4000000, l1Gas: 0 },
-    APPROVE: { l1DataGas: 400, l2Gas: 4000000, l1Gas: 0 }
+    TRANSFER: { l1: 400, l2: 0 },
+    APPROVE: { l1: 400, l2: 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
-                    this.logger.error("confirmTransaction(): Error on transaction re-send: ", e);
+                    console.error("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) {
-            this.logger.debug("prepareTransactions(): Using nonce from local cache!");
+            console.debug("StarknetTransactions: 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[];
 };
 /**
- * Starknet on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
+ * Solana on-chain event handler for front-end systems without access to fs, uses pure WS 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,6 +25,7 @@ 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,13 +5,14 @@ const base_1 = require("@atomiqlabs/base");
 const Utils_1 = require("../../utils/Utils");
 const starknet_1 = require("starknet");
 /**
- * Starknet on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
+ * Solana on-chain event handler for front-end systems without access to fs, uses pure WS 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));
@@ -186,6 +187,8 @@ class StarknetChainEventsBrowser {
                     parsedEvent = this.parseSpvCloseEvent(event);
                     break;
             }
+            if (parsedEvent == null)
+                continue;
             const timestamp = event.blockNumber == null ? pendingEventTime : await getBlockTimestamp(event.blockNumber);
             parsedEvent.meta = {
                 blockTime: timestamp,
@@ -276,6 +279,7 @@ 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.d.ts

@@ -32,7 +32,6 @@ export declare class StarknetSpvVaultContract extends StarknetContractBase<typeo
     createVaultData(owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]): Promise<StarknetSpvVaultData>;
     getVaultData(owner: string, vaultId: bigint): Promise<StarknetSpvVaultData>;
     getAllVaults(owner?: string): Promise<StarknetSpvVaultData[]>;
-    getFronterAddress(owner: string, vaultId: bigint, withdrawal: StarknetSpvWithdrawalData): Promise<string | null>;
     getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
     getWithdrawalData(btcTx: BtcTx): Promise<StarknetSpvWithdrawalData>;
     fromOpReturnData(data: Buffer): {
@@ -61,6 +60,6 @@ export declare class StarknetSpvVaultContract extends StarknetContractBase<typeo
     txsDeposit(signer: string, vault: StarknetSpvVaultData, rawAmounts: bigint[], feeRate?: string): Promise<StarknetTx[]>;
     txsFrontLiquidity(signer: string, vault: StarknetSpvVaultData, realWithdrawalTx: StarknetSpvWithdrawalData, withdrawSequence: number, feeRate?: string): Promise<StarknetTx[]>;
     txsOpen(signer: string, vault: StarknetSpvVaultData, feeRate?: string): Promise<StarknetTx[]>;
-    getClaimFee(signer: string, vault: StarknetSpvVaultData, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint>;
-    getFrontFee(signer: string, vault: StarknetSpvVaultData, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+    getClaimFee(signer: string, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+    getFrontFee(signer: string, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint>;
 }

package/dist/starknet/spv_swap/StarknetSpvVaultContract.js

@@ -120,12 +120,6 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
         }
         return vaults;
     }
-    async getFronterAddress(owner, vaultId, withdrawal) {
-        const fronterAddress = await this.contract.get_fronter_address_by_id(owner, vaultId, "0x" + withdrawal.getFrontingId());
-        if ((0, Utils_1.toHex)(fronterAddress, 64) === "0x0000000000000000000000000000000000000000000000000000000000000000")
-            return null;
-        return fronterAddress;
-    }
     async getWithdrawalState(btcTxId) {
         const txHash = buffer_1.Buffer.from(btcTxId, "hex").reverse();
         const txHashU256 = starknet_1.cairo.uint256("0x" + txHash.toString("hex"));
@@ -364,19 +358,19 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
             " vaultId: " + vault.getVaultId().toString(10));
         return [await action.tx(feeRate)];
     }
-    async getClaimFee(signer, vault, withdrawalData, feeRate) {
+    async getClaimFee(signer, withdrawalData, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM, feeRate);
+        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM.l1, feeRate);
     }
-    async getFrontFee(signer, vault, withdrawalData, feeRate) {
+    async getFrontFee(signer, withdrawalData, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT, feeRate);
+        return StarknetFees_1.StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT.l1, feeRate);
     }
 }
 exports.StarknetSpvVaultContract = StarknetSpvVaultContract;
 StarknetSpvVaultContract.GasCosts = {
-    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 }
+    DEPOSIT: { l1: 750, l2: 0 },
+    OPEN: { l1: 1500, l2: 0 },
+    FRONT: { l1: 750, l2: 0 },
+    CLAIM: { l1: 10000, l2: 0 }
 };

package/dist/starknet/spv_swap/StarknetSpvVaultData.js

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

package/dist/starknet/spv_swap/StarknetSpvWithdrawalData.d.ts

@@ -21,5 +21,4 @@ export declare class StarknetSpvWithdrawalData extends SpvWithdrawalTransactionD
         execution_expiry: bigint;
     };
     serializeToFelts(): BigNumberish[];
-    getFrontingId(): string;
 }

package/dist/starknet/spv_swap/StarknetSpvWithdrawalData.js

@@ -56,17 +56,6 @@ class StarknetSpvWithdrawalData extends base_1.SpvWithdrawalTransactionData {
             BigInt(this.executionExpiry)
         ];
     }
-    getFrontingId() {
-        const txHashU256 = starknet_1.cairo.uint256(base_1.BigIntBufferUtils.fromBuffer(buffer_1.Buffer.from(this.btcTx.txid), "le"));
-        let frontingId = starknet_1.hash.computePoseidonHashOnElements([
-            txHashU256.low,
-            txHashU256.high,
-            ...this.serializeToFelts()
-        ]);
-        if (frontingId.startsWith("0x"))
-            frontingId = frontingId.slice(2);
-        return frontingId.padStart(64, "0");
-    }
 }
 exports.StarknetSpvWithdrawalData = StarknetSpvWithdrawalData;
 base_1.SpvWithdrawalTransactionData.deserializers["STARKNET"] = StarknetSpvWithdrawalData;

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

@@ -12,29 +12,6 @@ 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";
@@ -74,9 +51,6 @@ 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";