@atomiqlabs/chain-starknet 4.0.0-dev.8 → 5.0.0

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

@@ -22,7 +22,7 @@ class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
      * @private
      */
     Refund(signer, swapData, witness, handlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, 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
@@ -118,11 +118,11 @@ class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
      */
     async getRefundFee(swapData, feeRate) {
         feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, feeRate);
+        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT.l1 : StarknetSwapRefund.GasCosts.REFUND.l1, feeRate);
     }
 }
 exports.StarknetSwapRefund = StarknetSwapRefund;
 StarknetSwapRefund.GasCosts = {
-    REFUND: { l1DataGas: 750, l2Gas: 4000000, l1Gas: 0 },
-    REFUND_PAY_OUT: { l1DataGas: 900, l2Gas: 6000000, l1Gas: 0 }
+    REFUND: { l1: 750, l2: 0 },
+    REFUND_PAY_OUT: { l1: 1250, l2: 0 }
 };

package/dist/utils/Utils.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findLastIndex = exports.parseInitFunctionCalldata = exports.poseidonHashRange = exports.bufferToByteArray = exports.bufferToBytes31Span = exports.bytes31SpanToBuffer = exports.toBigInt = exports.bigNumberishToBuffer = exports.u32ReverseEndianness = exports.bufferToU32Array = exports.u32ArrayToBuffer = exports.calculateHash = exports.toHex = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = exports.isUint256 = void 0;
-const starknet_types_08_1 = require("@starknet-io/starknet-types-08");
+const starknet_types_07_1 = require("starknet-types-07");
 const starknet_1 = require("starknet");
 const buffer_1 = require("buffer");
 const StarknetSwapData_1 = require("../starknet/swaps/StarknetSwapData");
@@ -35,14 +35,10 @@ function onceAsync(executor) {
 exports.onceAsync = onceAsync;
 function getLogger(prefix) {
     return {
-        // @ts-ignore
-        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
-        // @ts-ignore
-        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
-        // @ts-ignore
-        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
-        // @ts-ignore
-        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+        debug: (msg, ...args) => console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => console.error(prefix + msg, ...args)
     };
 }
 exports.getLogger = getLogger;
@@ -79,7 +75,7 @@ function toHex(value, length = 64) {
     switch (typeof (value)) {
         case "string":
             if (value.startsWith("0x")) {
-                return "0x" + value.slice(2).padStart(length, "0").toLowerCase();
+                return "0x" + value.slice(2).padStart(length, "0");
             }
             else {
                 return "0x" + BigInt(value).toString(16).padStart(length, "0");
@@ -98,8 +94,8 @@ function calculateHash(tx) {
         chainId: tx.details.chainId,
         nonce: tx.details.nonce,
         accountDeploymentData: tx.details.version === "0x3" ? tx.details.accountDeploymentData : null,
-        nonceDataAvailabilityMode: tx.details.version === "0x3" ? starknet_types_08_1.EDAMode[tx.details.nonceDataAvailabilityMode] : null,
-        feeDataAvailabilityMode: tx.details.version === "0x3" ? starknet_types_08_1.EDAMode[tx.details.feeDataAvailabilityMode] : null,
+        nonceDataAvailabilityMode: tx.details.version === "0x3" ? starknet_types_07_1.EDAMode[tx.details.nonceDataAvailabilityMode] : null,
+        feeDataAvailabilityMode: tx.details.version === "0x3" ? starknet_types_07_1.EDAMode[tx.details.feeDataAvailabilityMode] : null,
         resourceBounds: tx.details.version === "0x3" ? tx.details.resourceBounds : null,
         tip: tx.details.version === "0x3" ? tx.details.tip : null,
         paymasterData: tx.details.version === "0x3" ? tx.details.paymasterData : null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-starknet",
-  "version": "4.0.0-dev.8",
+  "version": "5.0.0",
   "description": "Starknet specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,14 +22,14 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^10.0.0-dev.8",
+    "@atomiqlabs/base": "^11.0.0",
     "@noble/hashes": "^1.7.1",
     "@scure/btc-signer": "1.6.0",
     "abi-wan-kanabi": "2.2.4",
     "buffer": "6.0.3"
   },
   "peerDependencies": {
-    "starknet": "^7.5.0"
+    "starknet": "^6.11.0"
   },
   "devDependencies": {
     "typescript": "4.9.5"

package/src/starknet/StarknetInitializer.ts

@@ -4,7 +4,7 @@ import {StarknetChainInterface, StarknetRetryPolicy} from "./chain/StarknetChain
 import {StarknetBtcRelay} from "./btcrelay/StarknetBtcRelay";
 import {StarknetSwapContract} from "./swaps/StarknetSwapContract";
 import {StarknetChainEventsBrowser} from "./events/StarknetChainEventsBrowser";
-import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType} from "@atomiqlabs/base";
+import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer} from "@atomiqlabs/base";
 import {StarknetChainType} from "./StarknetChainType";
 import {StarknetSwapData} from "./swaps/StarknetSwapData";
 import {StarknetSpvVaultContract} from "./spv_swap/StarknetSpvVaultContract";
@@ -27,12 +27,7 @@ export const StarknetAssets: StarknetAssetsType = {
     WBTC: {
         address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
         decimals: 8
-    },
-    // TBTC: {
-    //     address: "0x04daa17763b286d1e59b97c283C0b8C949994C361e426A28F743c67bDfE9a32f",
-    //     decimals: 18,
-    //     displayDecimals: 8
-    // }
+    }
 } as const;
 
 export type StarknetOptions = {
@@ -43,14 +38,6 @@ export type StarknetOptions = {
     swapContract?: string,
     btcRelayContract?: string,
     spvVaultContract?: string,
-    handlerContracts?: {
-        refund?: {
-            timelock?: string
-        },
-        claim?: {
-            [type in ChainSwapType]?: string
-        }
-    }
 
     fees?: StarknetFees
 }
@@ -64,7 +51,7 @@ export function initializeStarknet(
         new RpcProviderWithRetries({nodeUrl: options.rpcUrl}) :
         options.rpcUrl;
 
-    const Fees = options.fees ?? new StarknetFees(provider);
+    const Fees = options.fees ?? new StarknetFees(provider, "STRK");
 
     const chainId = options.chainId ??
         (network===BitcoinNetwork.MAINNET ? constants.StarknetChainId.SN_MAIN : constants.StarknetChainId.SN_SEPOLIA);
@@ -76,7 +63,7 @@ export function initializeStarknet(
     );
 
     const swapContract = new StarknetSwapContract(
-        chainInterface, btcRelay, options.swapContract, options.handlerContracts
+        chainInterface, btcRelay, options.swapContract
     );
 
     const spvVaultContract = new StarknetSpvVaultContract(

package/src/starknet/btcrelay/StarknetBtcRelay.ts

@@ -13,7 +13,7 @@ import {StarknetTx} from "../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../wallet/StarknetSigner";
 import {BtcRelayAbi} from "./BtcRelayAbi";
 import {BigNumberish, hash} from "starknet";
-import {StarknetFees, starknetGasAdd, starknetGasMul} from "../chain/modules/StarknetFees";
+import {StarknetFees} from "../chain/modules/StarknetFees";
 import {StarknetChainInterface} from "../chain/StarknetChainInterface";
 import {StarknetAction} from "../chain/StarknetAction";
 
@@ -29,8 +29,8 @@ function serializeBlockHeader(e: BtcBlock): StarknetBtcHeader {
     });
 }
 
-const GAS_PER_BLOCKHEADER = {l1DataGas: 600, l2Gas: 40_000_000, l1Gas: 0};
-const GAS_PER_BLOCKHEADER_FORK = {l1DataGas: 1000, l2Gas: 60_000_000, l1Gas: 0};
+const GAS_PER_BLOCKHEADER = 850;
+const GAS_PER_BLOCKHEADER_FORK = 1000;
 
 const btcRelayAddreses = {
     [BitcoinNetwork.TESTNET4]: "0x0099b63f39f0cabb767361de3d8d3e97212351a51540e2687c2571f4da490dbe",
@@ -62,7 +62,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
                 entrypoint: "submit_main_blockheaders",
                 calldata: serializeCalldata(mainHeaders, storedHeader, [])
             },
-            starknetGasMul(GAS_PER_BLOCKHEADER, mainHeaders.length)
+            {l1: GAS_PER_BLOCKHEADER * mainHeaders.length, l2: 0}
         )
     }
 
@@ -73,7 +73,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
                 entrypoint: "submit_short_fork_blockheaders",
                 calldata: serializeCalldata(forkHeaders, storedHeader, [])
             },
-            starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length)
+            {l1: GAS_PER_BLOCKHEADER * forkHeaders.length, l2: 0}
         )
     }
 
@@ -84,10 +84,7 @@ export class StarknetBtcRelay<B extends BtcBlock>
                 entrypoint: "submit_fork_blockheaders",
                 calldata: serializeCalldata(forkHeaders, storedHeader, [toHex(forkId)])
             },
-            starknetGasAdd(
-                starknetGasMul(GAS_PER_BLOCKHEADER, forkHeaders.length),
-                starknetGasMul(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)
-            )
+            {l1: (GAS_PER_BLOCKHEADER * forkHeaders.length) + (GAS_PER_BLOCKHEADER_FORK * totalForkHeaders), l2: 0}
         )
     }
 

package/src/starknet/chain/StarknetAction.ts

@@ -1,11 +1,20 @@
 import {Call} from "starknet";
 import {StarknetChainInterface} from "./StarknetChainInterface";
 import {StarknetTx} from "./modules/StarknetTransactions";
-import {StarknetGas, starknetGasAdd} from "./modules/StarknetFees";
+
+export type StarknetGas = {l1?: number, l2?: number};
+
+export function sumStarknetGas(a: StarknetGas, b: StarknetGas) {
+    return {
+        l1: (a?.l1 ?? 0) + (b?.l1 ?? 0),
+        l2: (a?.l2 ?? 0) + (b?.l2 ?? 0)
+    }
+}
 
 export class StarknetAction {
 
-    gas: StarknetGas;
+    L1GasLimit: number;
+    L2GasLimit: number;
     readonly mainSigner: string;
     private readonly root: StarknetChainInterface;
     private readonly instructions: Call[];
@@ -21,11 +30,8 @@ export class StarknetAction {
         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;
     }
 
@@ -35,7 +41,8 @@ export class StarknetAction {
 
     public addIx(instruction: Call, gasLimit?: StarknetGas) {
         this.instructions.push(instruction);
-        this.gas = starknetGasAdd(this.gas, gasLimit);
+        this.L1GasLimit += gasLimit?.l1 ?? 0;
+        this.L2GasLimit += gasLimit?.l2 ?? 0;
     }
 
     public add(action: StarknetAction): this {
@@ -44,12 +51,10 @@ export class StarknetAction {
 
     public addAction(action: StarknetAction, index: number = this.instructions.length): this {
         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;
         return this;
@@ -63,7 +68,7 @@ export 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/src/starknet/chain/modules/StarknetAccounts.ts

@@ -6,7 +6,7 @@ import {DeployAccountContractPayload} from "starknet";
 export class StarknetAccounts extends StarknetModule {
 
     public async getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx> {
-        const feeDetails = this.root.Fees.getFeeDetails({l1DataGas: 500, l2Gas: 5_000*40_000, 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/src/starknet/chain/modules/StarknetFees.ts

@@ -4,26 +4,6 @@ import {StarknetTokens} from "./StarknetTokens";
 
 const MAX_FEE_AGE = 5000;
 
-export type StarknetFeeRate = {
-    l1GasCost: bigint;
-    l2GasCost: bigint;
-    l1DataGasCost: bigint;
-};
-
-export type StarknetGas = {
-    l1Gas: number,
-    l2Gas: number,
-    l1DataGas: number
-};
-
-export function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas {
-    return {l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar};
-}
-
-export function starknetGasAdd(a: StarknetGas, b: StarknetGas): StarknetGas {
-    return {l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas};
-}
-
 export class StarknetFees {
 
     private readonly logger = getLogger("StarknetFees: ");
@@ -31,22 +11,25 @@ export class StarknetFees {
     private readonly feeDA: "L1" | "L2";
     private readonly nonceDA: "L1" | "L2";
     private readonly provider: Provider;
-    private readonly maxFeeRate: StarknetFeeRate;
+    private readonly gasToken: "ETH" | "STRK";
+    private readonly maxFeeRate: bigint;
     private readonly feeMultiplierPPM: bigint;
 
     private blockFeeCache: {
         timestamp: number,
-        feeRate: Promise<StarknetFeeRate>
+        feeRate: Promise<bigint>
     } = null;
 
     constructor(
         provider: Provider,
-        maxFeeRate: StarknetFeeRate = {l1GasCost: 1_000_000_000_000_000n, l2GasCost: 1_000_000_000_000_000n, l1DataGasCost: 1_000_000_000_000_000n} /*100 * 10000 GWei*/,
+        gasToken: "ETH" | "STRK" = "STRK",
+        maxFeeRate: number = gasToken==="ETH" ? 100_000_000_000 /*100 GWei*/ : 1_000_000_000_000_000 /*100 * 10000 GWei*/,
         feeMultiplier: number = 1.25,
         da?: {fee?: "L1" | "L2", nonce?: "L1" | "L2"}
     ) {
         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));
@@ -56,20 +39,16 @@ export 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 async _getFeeRate(): Promise<StarknetFeeRate> {
-        const block = await this.provider.getBlock("latest");
-
-        let l1GasCost = toBigInt(block.l1_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
-        let l1DataGasCost = toBigInt(block.l1_data_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
-        let l2GasCost = toBigInt(block.l2_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+    private async _getFeeRate(): Promise<bigint> {
+        const block = await this.provider.getBlockWithTxHashes("latest");
+        let l1GasCost = 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), l1DataGasCost.toString(10), l2GasCost.toString(10)]);
+        this.logger.debug("_getFeeRate(): L1 fee rate: "+l1GasCost.toString(10));
 
-        return {
-            l1GasCost, l2GasCost, l1DataGasCost
-        };
+        return l1GasCost;
     }
 
     /**
@@ -90,12 +69,10 @@ export 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;
+        let feeRate = await this.blockFeeCache.feeRate;
+        if(feeRate>this.maxFeeRate) feeRate = this.maxFeeRate;
 
-        const fee = l1GasCost.toString(10)+","+l2GasCost.toString(10)+","+l1DataGasCost.toString(10)+";v3";
+        const fee = feeRate.toString(10)+";"+(this.gasToken === "ETH" ? "v1" : "v3");
 
         this.logger.debug("getFeeRate(): calculated fee: "+fee);
 
@@ -103,24 +80,22 @@ export class StarknetFees {
     }
 
     public getDefaultGasToken(): string {
-        return StarknetTokens.ERC20_STRK;
+        return this.gasToken==="ETH" ? StarknetTokens.ERC20_ETH : 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
      */
-    public static getGasFee(gas: {l1DataGas: number, l2Gas: number, l1Gas: number}, feeRate: string): bigint {
+    public static getGasFee(gas: number, feeRate: string): bigint {
         if(feeRate==null) return 0n;
 
         const arr = feeRate.split(";");
-        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
+        const gasPrice = BigInt(arr[0]);
 
-        return (BigInt(gas.l1Gas) * BigInt(l1GasCostStr)) +
-            (BigInt(gas.l2Gas) * BigInt(l2GasCostStr)) +
-            (BigInt(gas.l1DataGas) * BigInt(l1DataGasCostStr));
+        return gasPrice * BigInt(gas);
     }
 
     public static getGasToken(feeRate: string): string {
@@ -132,18 +107,21 @@ export class StarknetFees {
         return txVersion==="v1" ? StarknetTokens.ERC20_ETH : StarknetTokens.ERC20_STRK;
     }
 
-    getFeeDetails(gas: {l1DataGas: number, l2Gas: number, l1Gas: number}, feeRate: string) {
+    getFeeDetails(L1GasLimit: number, L2GasLimit: number, feeRate: string) {
         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] as "v1" | "v3";
+
+        const maxFee = toHex(BigInt(L1GasLimit) * gasPrice, 16);
 
         return {
-            version: "0x3" as const,
+            maxFee: maxFee,
+            version: version==="v1" ? "0x1" : "0x3" as "0x1" | "0x3",
             resourceBounds: {
-                l1_gas: {max_amount: toHex(gas.l1Gas, 16), max_price_per_unit: toHex(BigInt(l1GasCostStr), 16)},
-                l2_gas: {max_amount: toHex(gas.l2Gas, 16), max_price_per_unit: toHex(BigInt(l2GasCostStr), 16)},
-                l1_data_gas: {max_amount: toHex(gas.l1DataGas, 16), max_price_per_unit: toHex(BigInt(l1DataGasCostStr), 16)}
+                l1_gas: {max_amount: toHex(L1GasLimit, 16), max_price_per_unit: toHex(gasPrice, 16)},
+                l2_gas: {max_amount: "0x0", max_price_per_unit: "0x0"}
             },
             tip: "0x0",
             paymasterData: [],

package/src/starknet/chain/modules/StarknetSignatures.ts

@@ -54,12 +54,11 @@ export class StarknetSignatures extends StarknetModule {
         return JSON.stringify(stark.formatSignature(signature));
     }
 
-    public async isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object): Promise<boolean> {
-        return this.provider.verifyMessageInStarknet(
+    public async isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object) {
+        return new Account(this.provider, address, null).verifyMessage(
             this.getTypedMessage(type, typeName, message),
-            JSON.parse(signature),
-            address
-        );
+            JSON.parse(signature)
+        )
     }
 
     ///////////////////

package/src/starknet/chain/modules/StarknetTokens.ts

@@ -12,8 +12,8 @@ export class StarknetTokens extends StarknetModule {
     public static readonly ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
 
     public static readonly GasCosts = {
-        TRANSFER: {l1DataGas: 400, l2Gas: 4_000_000, l1Gas: 0},
-        APPROVE: {l1DataGas: 400, l2Gas: 4_000_000, l1Gas: 0}
+        TRANSFER: {l1: 400, l2: 0},
+        APPROVE: {l1: 400, l2: 0}
     };
 
     private getContract(address: string) {

package/src/starknet/chain/modules/StarknetTransactions.ts

@@ -42,7 +42,7 @@ export class StarknetTransactions extends StarknetModule {
             state = await this._getTxIdStatus(tx.txId);
             if(state==="not_found" && tx.signed!=null) 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") throw new Error("Transaction rejected!");
@@ -65,7 +65,7 @@ export class StarknetTransactions extends StarknetModule {
         let nonce: bigint = 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/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -34,7 +34,7 @@ export type 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
  */
@@ -44,6 +44,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
     protected readonly provider: Provider;
     protected readonly starknetSwapContract: StarknetSwapContract;
     protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
+    protected eventListeners: number[] = [];
     protected readonly logger = getLogger("StarknetChainEventsBrowser: ");
 
     protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType> = "initialize";
@@ -393,6 +394,7 @@ export class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData>
     async stop(): Promise<void> {
         this.stopped = true;
         if(this.timeout!=null) clearTimeout(this.timeout);
+        this.eventListeners = [];
     }
 
     registerListener(cbk: EventListener<StarknetSwapData>): void {

package/src/starknet/spv_swap/StarknetSpvVaultContract.ts

@@ -51,10 +51,10 @@ export class StarknetSpvVaultContract
     >
 {
     private static readonly GasCosts = {
-        DEPOSIT: {l1DataGas: 400, l2Gas: 4_000_000, l1Gas: 0},
-        OPEN: {l1DataGas: 1200, l2Gas: 3_200_000, l1Gas: 0},
-        FRONT: {l1DataGas: 800, l2Gas: 12_000_000, l1Gas: 0},
-        CLAIM: {l1DataGas: 1000, l2Gas: 400_000_000, l1Gas: 0}
+        DEPOSIT: {l1: 750, l2: 0},
+        OPEN: {l1: 1500, l2: 0},
+        FRONT: {l1: 750, l2: 0},
+        CLAIM: {l1: 10000, l2: 0}
     };
 
     readonly chainId = "STARKNET";
@@ -192,12 +192,6 @@ export class StarknetSpvVaultContract
         return vaults;
     }
 
-    async getFronterAddress(owner: string, vaultId: bigint, withdrawal: StarknetSpvWithdrawalData): Promise<string | null> {
-        const fronterAddress = await this.contract.get_fronter_address_by_id(owner, vaultId, "0x"+withdrawal.getFrontingId());
-        if(toHex(fronterAddress, 64)==="0x0000000000000000000000000000000000000000000000000000000000000000") return null;
-        return fronterAddress;
-    }
-
     async getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState> {
         const txHash = Buffer.from(btcTxId, "hex").reverse();
         const txHashU256 = cairo.uint256("0x"+txHash.toString("hex"));
@@ -470,14 +464,14 @@ export class StarknetSpvVaultContract
         return [await action.tx(feeRate)];
     }
 
-    async getClaimFee(signer: string, vault: StarknetSpvVaultData, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint> {
+    async getClaimFee(signer: string, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
-        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM, feeRate);
+        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM.l1, feeRate);
     }
 
-    async getFrontFee(signer: string, vault: StarknetSpvVaultData, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint> {
+    async getFrontFee(signer: string, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
-        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT, feeRate);
+        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT.l1, feeRate);
     }
 
 }

package/src/starknet/spv_swap/StarknetSpvVaultData.ts

@@ -148,7 +148,6 @@ export class StarknetSpvVaultData extends SpvVaultData<StarknetSpvWithdrawalData
             utxo: this.utxo,
             confirmations: this.confirmations,
             withdrawCount: this.withdrawCount,
-            depositCount: this.depositCount,
             initialUtxo: this.initialUtxo
         }
     }

package/src/starknet/spv_swap/StarknetSpvWithdrawalData.ts

@@ -1,6 +1,6 @@
-import {BigIntBufferUtils, SpvWithdrawalTransactionData} from "@atomiqlabs/base";
+import {SpvWithdrawalTransactionData} from "@atomiqlabs/base";
 import {Buffer} from "buffer";
-import {BigNumberish, cairo, hash} from "starknet";
+import {BigNumberish, cairo} from "starknet";
 import {toBigInt} from "../../utils/Utils";
 import {StarknetSpvVaultContract} from "./StarknetSpvVaultContract";
 
@@ -63,17 +63,6 @@ export class StarknetSpvWithdrawalData extends SpvWithdrawalTransactionData {
         ]
     }
 
-    getFrontingId(): string {
-        const txHashU256 = cairo.uint256(BigIntBufferUtils.fromBuffer(Buffer.from(this.btcTx.txid), "le"));
-        let frontingId = hash.computePoseidonHashOnElements([
-            txHashU256.low,
-            txHashU256.high,
-            ...this.serializeToFelts()
-        ]);
-        if(frontingId.startsWith("0x")) frontingId = frontingId.slice(2);
-        return frontingId.padStart(64, "0");
-    }
-
 }
 
 SpvWithdrawalTransactionData.deserializers["STARKNET"] = StarknetSpvWithdrawalData;

package/src/starknet/swaps/EscrowManagerAbi.ts

@@ -18,38 +18,6 @@ export const 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",
@@ -101,10 +69,6 @@ export const EscrowManagerAbi = [
             {
                 "name": "claimer_bounty",
                 "type": "core::integer::u256"
-            },
-            {
-                "name": "success_action",
-                "type": "core::option::Option::<escrow_manager::structs::escrow::EscrowExecution>"
             }
         ]
     },