@atomiqlabs/chain-starknet 5.0.2 → 5.1.1

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

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

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

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

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: {l1: 400, l2: 0},
-        APPROVE: {l1: 400, l2: 0}
+        TRANSFER: {l1DataGas: 400, l2Gas: 4_000_000, l1Gas: 0},
+        APPROVE: {l1DataGas: 400, l2Gas: 4_000_000, l1Gas: 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
-                console.error("Error on transaction re-send: ", e);
+                this.logger.error("confirmTransaction(): 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) {
-            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/src/starknet/events/StarknetChainEventsBrowser.ts

@@ -34,7 +34,7 @@ export type 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
  */
@@ -44,7 +44,6 @@ 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";
@@ -395,7 +394,6 @@ 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

@@ -26,8 +26,8 @@ import {StarknetAddresses} from "../chain/modules/StarknetAddresses";
 import {StarknetFees} from "../chain/modules/StarknetFees";
 
 const spvVaultContractAddreses = {
-    [constants.StarknetChainId.SN_SEPOLIA]: "0x047961ea0687a2e3207478d386779bd5ec22aa8abc234319ccd723e2d7191a0c",
-    [constants.StarknetChainId.SN_MAIN]: "0x06ee5228af01baa443657ccda27b80637a609d43a97ed2f8fd478313e10abf4e"
+    [constants.StarknetChainId.SN_SEPOLIA]: "0x02d581ea838cd5ca46ba08660eddd064d50a0392f618e95310432147928d572e",
+    [constants.StarknetChainId.SN_MAIN]: "0x01932042992647771f3d0aa6ee526e65359c891fe05a285faaf4d3ffa373e132"
 };
 
 const STARK_PRIME_MOD: bigint = 2n**251n + 17n * 2n**192n + 1n;
@@ -51,10 +51,10 @@ export class StarknetSpvVaultContract
     >
 {
     private static readonly 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: 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}
     };
 
     readonly chainId = "STARKNET";
@@ -466,12 +466,12 @@ export class StarknetSpvVaultContract
 
     async getClaimFee(signer: string, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
-        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM.l1, feeRate);
+        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.CLAIM, feeRate);
     }
 
     async getFrontFee(signer: string, withdrawalData: StarknetSpvWithdrawalData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
-        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT.l1, feeRate);
+        return StarknetFees.getGasFee(StarknetSpvVaultContract.GasCosts.FRONT, feeRate);
     }
 
 }

package/src/starknet/spv_swap/StarknetSpvVaultData.ts

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

package/src/starknet/swaps/EscrowManagerAbi.ts

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

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -34,8 +34,8 @@ const ESCROW_STATE_CLAIMED = 2;
 const ESCROW_STATE_REFUNDED = 3;
 
 const swapContractAddreses = {
-    [constants.StarknetChainId.SN_SEPOLIA]: "0x06874044dae5bbe712775cdb576d6aef45fc87a22ce629f2b101a7d591d4e7ca",
-    [constants.StarknetChainId.SN_MAIN]: "0x04fb26d02d2cf612566cd86cab299716d926272e9f49514670233952ecaf8f0c"
+    [constants.StarknetChainId.SN_SEPOLIA]: "0x017bf50dd28b6d823a231355bb25813d4396c8e19d2df03026038714a22f0413",
+    [constants.StarknetChainId.SN_MAIN]: "0x04f278e1f19e495c3b1dd35ef307c4f7510768ed95481958fbae588bd173f79a"
 };
 
 const defaultClaimAddresses = {
@@ -132,7 +132,7 @@ export class StarknetSwapContract
 
         claimHandlersList.forEach(handlerCtor => {
             const handler = new handlerCtor(handlerAddresses.claim[handlerCtor.type]);
-            this.claimHandlersByAddress[handler.address] = handler;
+            this.claimHandlersByAddress[toHex(handler.address)] = handler;
             this.claimHandlersBySwapType[handlerCtor.type] = handler;
         });
 
@@ -464,7 +464,7 @@ export class StarknetSwapContract
         synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
         initAta?: boolean,
         feeRate?: string
-    ): Promise<StarknetTx[] | null> {
+    ): Promise<StarknetTx[]> {
         return this.Claim.txsClaimWithTxData(
             typeof(signer)==="string" ? signer : signer.getAddress(),
             swapData,

package/src/starknet/swaps/StarknetSwapData.ts

@@ -1,6 +1,6 @@
 import {SwapData, ChainSwapType} from "@atomiqlabs/base";
 import {TimelockRefundHandler} from "./handlers/refund/TimelockRefundHandler";
-import {BigNumberish, cairo, hash} from "starknet";
+import {BigNumberish, cairo, CairoOption, CairoOptionVariant, hash} from "starknet";
 import {toBigInt, toHex} from "../../utils/Utils";
 import {
     StringToPrimitiveType
@@ -350,7 +350,8 @@ export class StarknetSwapData extends SwapData {
             amount: cairo.uint256(toBigInt(this.amount)),
             fee_token: this.feeToken,
             security_deposit: cairo.uint256(toBigInt(this.securityDeposit)),
-            claimer_bounty: cairo.uint256(toBigInt(this.claimerBounty))
+            claimer_bounty: cairo.uint256(toBigInt(this.claimerBounty)),
+            success_action: new CairoOption(CairoOptionVariant.None) //For now enforce no success action
         }
     }
 
@@ -367,6 +368,13 @@ export class StarknetSwapData extends SwapData {
         const feeToken = toHex(span.shift());
         const securityDeposit = toBigInt({low: span.shift(), high: span.shift()});
         const claimerBounty = toBigInt({low: span.shift(), high: span.shift()});
+        const hasSuccessAction = toBigInt(span.shift()) === 0n;
+        if(hasSuccessAction) {
+            const executionHash = toHex(span.shift());
+            const executionExpiry = toBigInt(span.shift());
+            const executionFee = toBigInt({low: span.shift(), high: span.shift()});
+            // throw new Error("Success action not allowed!");
+        }
 
         return new StarknetSwapData(
             offerer,

package/src/starknet/swaps/handlers/IHandler.ts

@@ -1,7 +1,7 @@
 import {StarknetSwapData} from "../StarknetSwapData";
 import {BigNumberish} from "starknet";
-import {StarknetGas} from "../../chain/StarknetAction";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
+import {StarknetGas} from "../../chain/modules/StarknetFees";
 
 
 export interface IHandler<TCommitmentData, TWitnessData> {

package/src/starknet/swaps/handlers/claim/ClaimHandlers.ts

@@ -1,11 +1,11 @@
 import {HashlockClaimHandler} from "./HashlockClaimHandler";
 import {ChainSwapType} from "@atomiqlabs/base";
-import {StarknetGas} from "../../../chain/StarknetAction";
 import {IHandler} from "../IHandler";
 import {BitcoinTxIdClaimHandler} from "./btc/BitcoinTxIdClaimHandler";
 import {BitcoinOutputClaimHandler} from "./btc/BitcoinOutputClaimHandler";
 import {BitcoinNoncedOutputClaimHandler} from "./btc/BitcoinNoncedOutputClaimHandler";
 import {BigNumberish} from "starknet";
+import {StarknetGas} from "../../../chain/modules/StarknetFees";
 
 export interface IClaimHandler<C, W> extends IHandler<C, W> {
     getType(): ChainSwapType;

package/src/starknet/swaps/handlers/claim/HashlockClaimHandler.ts

@@ -2,17 +2,17 @@ import {StarknetSwapData} from "../../StarknetSwapData";
 import {bufferToU32Array, toHex, u32ArrayToBuffer} from "../../../../utils/Utils";
 import {BigNumberish, hash} from "starknet";
 import {ChainSwapType} from "@atomiqlabs/base";
-import {StarknetGas} from "../../../chain/StarknetAction";
 import {Buffer} from "buffer";
 import {sha256} from "@noble/hashes/sha2";
 import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
 import {IClaimHandler} from "./ClaimHandlers";
+import {StarknetGas} from "../../../chain/modules/StarknetFees";
 
 export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
 
     public readonly address: string;
     public static readonly type: ChainSwapType = ChainSwapType.HTLC;
-    public static readonly gas: StarknetGas = {l1: 750};
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 800*40_000, l1Gas: 0};
 
     constructor(address: string) {
         this.address = address;

package/src/starknet/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler.ts

@@ -1,5 +1,4 @@
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {BigNumberish, hash} from "starknet";
 import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
@@ -8,6 +7,7 @@ import {BitcoinCommitmentData, IBitcoinClaimHandler} from "./IBitcoinClaimHandle
 import {BitcoinOutputWitnessData} from "./BitcoinOutputClaimHandler";
 import {Transaction} from "@scure/btc-signer";
 import {Buffer} from "buffer";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
 
 export type BitcoinNoncedOutputCommitmentData = {
     output: Buffer,
@@ -27,7 +27,7 @@ function getTransactionNonce(btcTx: Transaction): bigint {
 export class BitcoinNoncedOutputClaimHandler extends IBitcoinClaimHandler<BitcoinNoncedOutputCommitmentData, BitcoinOutputWitnessData> {
 
     public static readonly type: ChainSwapType = ChainSwapType.CHAIN_NONCED;
-    public static readonly gas: StarknetGas = {l1: 20000};
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000*40_000, l1Gas: 0};
 
     protected serializeCommitment(data: BitcoinNoncedOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
         return [

package/src/starknet/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.ts

@@ -1,5 +1,4 @@
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {BigNumberish, hash} from "starknet";
 import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
@@ -7,6 +6,7 @@ import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../.
 import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
 import {Transaction} from "@scure/btc-signer";
 import {Buffer} from "buffer";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
 
 export type BitcoinOutputCommitmentData = {
     output: Buffer,
@@ -22,7 +22,7 @@ const logger = getLogger("BitcoinOutputClaimHandler: ");
 export class BitcoinOutputClaimHandler extends IBitcoinClaimHandler<BitcoinOutputCommitmentData, BitcoinOutputWitnessData> {
 
     public static readonly type: ChainSwapType = ChainSwapType.CHAIN;
-    public static readonly gas: StarknetGas = {l1: 20000};
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
 
     protected serializeCommitment(data: BitcoinOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
         return [

package/src/starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler.ts

@@ -1,11 +1,11 @@
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {BigNumberish} from "starknet";
 import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
 import {bufferToU32Array, getLogger} from "../../../../../utils/Utils";
 import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
 import {Buffer} from "buffer";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
 
 export type BitcoinTxIdCommitmentData = {
     txId: string
@@ -16,7 +16,7 @@ const logger = getLogger("BitcoinTxIdClaimHandler: ");
 export class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
 
     public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
-    public static readonly gas: StarknetGas = {l1: 20000};
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
 
     protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): BigNumberish[] {
         return [

package/src/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.ts

@@ -1,12 +1,12 @@
 import {IClaimHandler} from "../ClaimHandlers";
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType, RelaySynchronizer} from "@atomiqlabs/base";
 import {BigNumberish, hash} from "starknet";
 import {StarknetBtcStoredHeader} from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
 import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
 import {StarknetBtcRelay} from "../../../../btcrelay/StarknetBtcRelay";
 import {bufferToU32Array, getLogger, u32ArrayToBuffer} from "../../../../../utils/Utils";
+import {StarknetGas} from "../../../../chain/modules/StarknetFees";
 
 export type BitcoinCommitmentData = {
     btcRelay: StarknetBtcRelay<any>,
@@ -33,7 +33,7 @@ export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> impl
 
     public static readonly address = "";
     public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
-    public static readonly gas: StarknetGas = {l1: 20000};
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
 
     protected serializeCommitment(data: BitcoinCommitmentData): BigNumberish[] {
         return [

package/src/starknet/swaps/handlers/refund/TimelockRefundHandler.ts

@@ -1,14 +1,14 @@
 import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
 import {StarknetSwapData} from "../../StarknetSwapData";
-import {bigNumberishToBuffer, toBigInt} from "../../../../utils/Utils";
+import {bigNumberishToBuffer} from "../../../../utils/Utils";
 import {BigNumberish} from "starknet";
 import {IHandler} from "../IHandler";
-import {StarknetGas} from "../../../chain/StarknetAction";
+import {StarknetGas} from "../../../chain/modules/StarknetFees";
 
 export class TimelockRefundHandler implements IHandler<bigint, never> {
 
     public readonly address: string;
-    public static readonly gas: StarknetGas = {l1: 500};
+    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 4_000_000, l1Gas: 0};
 
     constructor(address: string) {
         this.address = address;

package/src/starknet/swaps/modules/StarknetLpVault.ts

@@ -8,8 +8,8 @@ import {StarknetTx} from "../../chain/modules/StarknetTransactions";
 export class StarknetLpVault extends StarknetSwapModule {
 
     private static readonly GasCosts = {
-        WITHDRAW: {l1: 750, l2: 0},
-        DEPOSIT: {l1: 750, l2: 0}
+        WITHDRAW: {l1DataGas: 500, l2Gas: 3_200_000, l1Gas: 0},
+        DEPOSIT: {l1: 500, l2Gas: 4_000_000, l1Gas: 0}
     };
 
     /**

package/src/starknet/swaps/modules/StarknetSwapClaim.ts

@@ -2,11 +2,11 @@ import {ChainSwapType, RelaySynchronizer, SwapDataVerificationError} from "@atom
 import {toHex} from "../../../utils/Utils";
 import {StarknetSwapModule} from "../StarknetSwapModule";
 import {StarknetSwapData} from "../StarknetSwapData";
-import {StarknetAction, StarknetGas, sumStarknetGas} from "../../chain/StarknetAction";
+import {StarknetAction} from "../../chain/StarknetAction";
 import {BigNumberish} from "starknet";
 import {IClaimHandler} from "../handlers/claim/ClaimHandlers";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
-import {StarknetFees} from "../../chain/modules/StarknetFees";
+import {StarknetFees, StarknetGas, starknetGasAdd} from "../../chain/modules/StarknetFees";
 import {StarknetBtcStoredHeader} from "../../btcrelay/headers/StarknetBtcStoredHeader";
 import {BitcoinOutputWitnessData} from "../handlers/claim/btc/BitcoinOutputClaimHandler";
 import {BitcoinWitnessData} from "../handlers/claim/btc/IBitcoinClaimHandler";
@@ -15,8 +15,8 @@ import {Buffer} from "buffer";
 export class StarknetSwapClaim extends StarknetSwapModule {
 
     private static readonly GasCosts = {
-        CLAIM: {l1: 500, l2: 0},
-        CLAIM_PAY_OUT: {l1: 1000, l2: 0}
+        CLAIM: {l1DataGas: 750, l2Gas: 4_000_000, l1Gas: 0},
+        CLAIM_PAY_OUT: {l1DataGas: 900, l2Gas: 6_000_000, l1Gas: 0}
     };
 
     /**
@@ -37,7 +37,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
             this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness),
-            sumStarknetGas(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas)
+            starknetGasAdd(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas)
         );
     }
 
@@ -64,7 +64,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
             throw new SwapDataVerificationError("Not enough time to reliably pay the invoice");
         }
 
-        const claimHandler: IClaimHandler<Buffer, string> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        const claimHandler: IClaimHandler<Buffer, string> = this.contract.claimHandlersByAddress[toHex(swapData.claimHandler)];
         if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
         if(claimHandler.getType()!==ChainSwapType.HTLC) throw new SwapDataVerificationError("Invalid claim handler!");
 
@@ -101,7 +101,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
         synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
         feeRate?: string
     ): Promise<StarknetTx[] | null> {
-        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.contract.claimHandlersByAddress[toHex(swapData.claimHandler)];
         if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
         if(
             claimHandler.getType()!==ChainSwapType.CHAIN_NONCED &&
@@ -133,10 +133,10 @@ export class StarknetSwapClaim extends StarknetSwapModule {
 
         let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
 
-        const claimHandler: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-        if(claimHandler!=null) gasRequired = sumStarknetGas(gasRequired, claimHandler.getGas(swapData));
+        const claimHandler: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[toHex(swapData.claimHandler)];
+        if(claimHandler!=null) gasRequired = starknetGasAdd(gasRequired, claimHandler.getGas(swapData));
 
-        return StarknetFees.getGasFee(gasRequired.l1, feeRate);
+        return StarknetFees.getGasFee(gasRequired, feeRate);
     }
 
 }