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

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>"
             }
         ]
     },

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -14,7 +14,7 @@ import {EscrowManagerAbi} from "./EscrowManagerAbi";
 import {StarknetContractBase} from "../contract/StarknetContractBase";
 import {StarknetTx} from "../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../wallet/StarknetSigner";
-import {BigNumberish, constants} from "starknet";
+import {BigNumberish, constants, logger} from "starknet";
 import {StarknetChainInterface} from "../chain/StarknetChainInterface";
 import {StarknetBtcRelay} from "../btcrelay/StarknetBtcRelay";
 import {StarknetSwapData} from "./StarknetSwapData";
@@ -34,8 +34,8 @@ const ESCROW_STATE_CLAIMED = 2;
 const ESCROW_STATE_REFUNDED = 3;
 
 const swapContractAddreses = {
-    [constants.StarknetChainId.SN_SEPOLIA]: "0x030ae7fc7bbce9b8c888b1117f5573c786dd8e1541c722227b8673ac7dda70c0",
-    [constants.StarknetChainId.SN_MAIN]: "0x02e1070519f27ec94dde395c8d72a5fcb144d40a786cf60b9b45395d36cc2f69"
+    [constants.StarknetChainId.SN_SEPOLIA]: "0x06874044dae5bbe712775cdb576d6aef45fc87a22ce629f2b101a7d591d4e7ca",
+    [constants.StarknetChainId.SN_MAIN]: "0x04fb26d02d2cf612566cd86cab299716d926272e9f49514670233952ecaf8f0c"
 };
 
 const defaultClaimAddresses = {
@@ -73,8 +73,6 @@ export class StarknetSwapContract
         "STARKNET"
     > {
 
-    readonly supportsInitWithoutClaimer = true;
-
     ////////////////////////
     //// Constants
     readonly chainId: "STARKNET" = "STARKNET";
@@ -134,7 +132,7 @@ export class StarknetSwapContract
 
         claimHandlersList.forEach(handlerCtor => {
             const handler = new handlerCtor(handlerAddresses.claim[handlerCtor.type]);
-            this.claimHandlersByAddress[toHex(handler.address)] = handler;
+            this.claimHandlersByAddress[handler.address] = handler;
             this.claimHandlersBySwapType[handlerCtor.type] = handler;
         });
 
@@ -329,6 +327,23 @@ export class StarknetSwapContract
                             blockHeight, blockHeight
                         );
                         return events.length===0 ? null : events[0].txHash;
+                    },
+                    getClaimResult: async () => {
+                        const events = await this.Events.getContractBlockEvents(
+                            ["escrow_manager::events::Claim"],
+                            [null, null, null, "0x"+escrowHash],
+                            blockHeight, blockHeight
+                        );
+                        if(events.length===0) return null;
+                        const event = events[0];
+                        const claimHandlerHex = toHex(event.params.claim_handler);
+                        const claimHandler = this.claimHandlersByAddress[claimHandlerHex];
+                        if(claimHandler==null) {
+                            logger.warn("getCommitStatus(): getClaimResult("+escrowHash+"): Unknown claim handler with claim: "+claimHandlerHex);
+                            return null;
+                        }
+                        const witnessResult = claimHandler.parseWitnessResult(event.params.witness_result);
+                        return witnessResult;
                     }
                 };
             default:
@@ -616,14 +631,14 @@ export class StarknetSwapContract
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(signer: string, swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
+    getCommitFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
         return this.Init.getInitFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRefundFee(signer: string, swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
+    getRefundFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
 

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, CairoOption, CairoOptionVariant, hash} from "starknet";
+import {BigNumberish, cairo, hash} from "starknet";
 import {toBigInt, toHex} from "../../utils/Utils";
 import {
     StringToPrimitiveType
@@ -14,21 +14,6 @@ const FLAG_REPUTATION: bigint = 0x04n;
 
 export type StarknetSwapDataType = StringToPrimitiveType<typeof EscrowManagerAbi, "escrow_manager::structs::escrow::EscrowData">;
 
-export type StarknetSuccessAction = {
-    executionHash: string,
-    executionExpiry: bigint,
-    executionFee: bigint
-}
-
-function successActionEquals(a: StarknetSuccessAction, b: StarknetSuccessAction): boolean {
-    if(a!=null && b!=null) {
-        return a.executionHash.toLowerCase()===b.executionHash.toLowerCase() &&
-            a.executionExpiry === b.executionExpiry &&
-            a.executionFee === b.executionFee;
-    }
-    return a === b;
-}
-
 export class StarknetSwapData extends SwapData {
 
     static toFlags(value: number | bigint | string): {payOut: boolean, payIn: boolean, reputation: boolean, sequence: bigint} {
@@ -72,8 +57,6 @@ export class StarknetSwapData extends SwapData {
 
     extraData: string;
 
-    successAction?: StarknetSuccessAction;
-
     kind: ChainSwapType;
 
     constructor(
@@ -93,8 +76,7 @@ export class StarknetSwapData extends SwapData {
         securityDeposit: bigint,
         claimerBounty: bigint,
         kind: ChainSwapType,
-        extraData: string,
-        successAction?: StarknetSuccessAction
+        extraData: string
     );
 
     constructor(data: any);
@@ -116,8 +98,7 @@ export class StarknetSwapData extends SwapData {
         securityDeposit?: bigint,
         claimerBounty?: bigint,
         kind?: ChainSwapType,
-        extraData?: string,
-        successAction?: StarknetSuccessAction
+        extraData?: string
     ) {
         super();
         if(claimer!=null || token!=null || refundHandler!=null || claimHandler!=null ||
@@ -140,7 +121,6 @@ export class StarknetSwapData extends SwapData {
             this.claimerBounty = claimerBounty;
             this.kind = kind;
             this.extraData = extraData;
-            this.successAction = successAction;
         } else {
             this.offerer = offererOrData.offerer;
             this.claimer = offererOrData.claimer;
@@ -159,11 +139,6 @@ export class StarknetSwapData extends SwapData {
             this.claimerBounty = offererOrData.claimerBounty==null ? null : BigInt(offererOrData.claimerBounty);
             this.kind = offererOrData.kind;
             this.extraData = offererOrData.extraData;
-            this.successAction = offererOrData.successAction==null ? null : {
-                executionHash: offererOrData.successAction.executionHash,
-                executionExpiry: BigInt(offererOrData.successAction.executionExpiry),
-                executionFee: BigInt(offererOrData.successAction.executionFee),
-            }
         }
     }
 
@@ -206,12 +181,7 @@ export class StarknetSwapData extends SwapData {
             securityDeposit: this.securityDeposit==null ? null : this.securityDeposit.toString(10),
             claimerBounty: this.claimerBounty==null ? null : this.claimerBounty.toString(10),
             kind: this.kind,
-            extraData: this.extraData,
-            successAction: this.successAction==null ? null : {
-                executionHash: this.successAction.executionHash,
-                executionExpiry: this.successAction.executionExpiry.toString(10),
-                executionFee: this.successAction.executionFee.toString(10)
-            }
+            extraData: this.extraData
         }
     }
 
@@ -247,7 +217,7 @@ export class StarknetSwapData extends SwapData {
         const amountValue = cairo.uint256("0x"+this.amount.toString(16));
         const securityDepositValue = cairo.uint256("0x"+this.securityDeposit.toString(16));
         const claimerBountyValue = cairo.uint256("0x"+this.claimerBounty.toString(16));
-        const elements = [
+        let escrowHash = hash.computePoseidonHashOnElements([
             this.offerer,
             this.claimer,
             this.token,
@@ -263,15 +233,7 @@ export class StarknetSwapData extends SwapData {
             securityDepositValue.high,
             claimerBountyValue.low,
             claimerBountyValue.high
-        ];
-        if(this.successAction!=null) {
-            elements.push(this.successAction.executionHash);
-            elements.push(this.successAction.executionExpiry);
-            const feeValue = cairo.uint256("0x"+this.successAction.executionFee.toString(16));
-            elements.push(feeValue.low, feeValue.high);
-        }
-
-        let escrowHash = hash.computePoseidonHashOnElements(elements);
+        ]);
         if(escrowHash.startsWith("0x")) escrowHash = escrowHash.slice(2);
         return escrowHash.padStart(64, "0");
     }
@@ -372,8 +334,7 @@ export class StarknetSwapData extends SwapData {
             other.refundData.toLowerCase()===this.refundData.toLowerCase() &&
             other.amount === this.amount &&
             other.securityDeposit === this.securityDeposit &&
-            other.claimerBounty === this.claimerBounty &&
-            successActionEquals(other.successAction, this.successAction)
+            other.claimerBounty === this.claimerBounty
     }
 
     toEscrowStruct(): StarknetSwapDataType {
@@ -389,15 +350,7 @@ 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)),
-            success_action: new CairoOption(
-                this.successAction==null ? CairoOptionVariant.None : CairoOptionVariant.Some,
-                this.successAction==null ? undefined : {
-                    hash: this.successAction.executionHash,
-                    expiry: this.successAction.executionExpiry,
-                    fee: cairo.uint256(this.successAction.executionFee)
-                }
-            ) as StarknetSwapDataType["success_action"]
+            claimer_bounty: cairo.uint256(toBigInt(this.claimerBounty))
         }
     }
 
@@ -414,15 +367,6 @@ 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;
-        let successAction: StarknetSuccessAction = null;
-        if(hasSuccessAction) {
-            successAction = {
-                executionHash: toHex(span.shift()),
-                executionExpiry: toBigInt(span.shift()),
-                executionFee: toBigInt({low: span.shift(), high: span.shift()})
-            }
-        }
 
         return new StarknetSwapData(
             offerer,
@@ -441,15 +385,10 @@ export class StarknetSwapData extends SwapData {
             securityDeposit,
             claimerBounty,
             claimHandlerImpl.getType(),
-            null,
-            successAction
+            null
         );
     }
 
-    hasSuccessAction(): boolean {
-        return this.successAction != null;
-    }
-
 }
 
 SwapData.deserializers["strk"] = StarknetSwapData;

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 = {l1DataGas: 0, l2Gas: 800*40_000, l1Gas: 0};
+    public static readonly gas: StarknetGas = {l1: 750};
 
     constructor(address: string) {
         this.address = address;

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

@@ -1,4 +1,5 @@
 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,7 +8,6 @@ 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 = {l1DataGas: 0, l2Gas: 20_000*40_000, l1Gas: 0};
+    public static readonly gas: StarknetGas = {l1: 20000};
 
     protected serializeCommitment(data: BitcoinNoncedOutputCommitmentData & BitcoinCommitmentData): BigNumberish[] {
         return [

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

@@ -1,4 +1,5 @@
 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";
@@ -6,7 +7,6 @@ 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 = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
+    public static readonly gas: StarknetGas = {l1: 20000};
 
     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 = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
+    public static readonly gas: StarknetGas = {l1: 20000};
 
     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 = {l1DataGas: 0, l2Gas: 20_000 * 40_000, l1Gas: 0};
+    public static readonly gas: StarknetGas = {l1: 20000};
 
     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} from "../../../../utils/Utils";
+import {bigNumberishToBuffer, toBigInt} from "../../../../utils/Utils";
 import {BigNumberish} from "starknet";
 import {IHandler} from "../IHandler";
-import {StarknetGas} from "../../../chain/modules/StarknetFees";
+import {StarknetGas} from "../../../chain/StarknetAction";
 
 export class TimelockRefundHandler implements IHandler<bigint, never> {
 
     public readonly address: string;
-    public static readonly gas: StarknetGas = {l1DataGas: 0, l2Gas: 4_000_000, l1Gas: 0};
+    public static readonly gas: StarknetGas = {l1: 500};
 
     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: {l1DataGas: 500, l2Gas: 3_200_000, l1Gas: 0},
-        DEPOSIT: {l1: 500, l2Gas: 4_000_000, l1Gas: 0}
+        WITHDRAW: {l1: 750, l2: 0},
+        DEPOSIT: {l1: 750, l2: 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} from "../../chain/StarknetAction";
+import {StarknetAction, StarknetGas, sumStarknetGas} from "../../chain/StarknetAction";
 import {BigNumberish} from "starknet";
 import {IClaimHandler} from "../handlers/claim/ClaimHandlers";
 import {StarknetTx} from "../../chain/modules/StarknetTransactions";
-import {StarknetFees, StarknetGas, starknetGasAdd} from "../../chain/modules/StarknetFees";
+import {StarknetFees} 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: {l1DataGas: 750, l2Gas: 4_000_000, l1Gas: 0},
-        CLAIM_PAY_OUT: {l1DataGas: 900, l2Gas: 6_000_000, l1Gas: 0}
+        CLAIM: {l1: 500, l2: 0},
+        CLAIM_PAY_OUT: {l1: 1000, l2: 0}
     };
 
     /**
@@ -37,7 +37,7 @@ export class StarknetSwapClaim extends StarknetSwapModule {
     ): StarknetAction {
         return new StarknetAction(signer, this.root,
             this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness),
-            starknetGasAdd(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas)
+            sumStarknetGas(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[toHex(swapData.claimHandler)];
+        const claimHandler: IClaimHandler<Buffer, string> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         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[toHex(swapData.claimHandler)];
+        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         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[toHex(swapData.claimHandler)];
-        if(claimHandler!=null) gasRequired = starknetGasAdd(gasRequired, claimHandler.getGas(swapData));
+        const claimHandler: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler!=null) gasRequired = sumStarknetGas(gasRequired, claimHandler.getGas(swapData));
 
-        return StarknetFees.getGasFee(gasRequired, feeRate);
+        return StarknetFees.getGasFee(gasRequired.l1, feeRate);
     }
 
 }