@atomiqlabs/chain-starknet 1.0.8 → 2.0.0-beta.0

package/src/starknet/spv_swap/StarknetSpvWithdrawalData.ts

@@ -0,0 +1,68 @@
+import {SpvWithdrawalTransactionData} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import {BigNumberish, cairo} from "starknet";
+import {toBigInt} from "../../utils/Utils";
+import {StarknetSpvVaultContract} from "./StarknetSpvVaultContract";
+
+
+export class StarknetSpvWithdrawalData extends SpvWithdrawalTransactionData {
+
+    protected fromOpReturnData(data: Buffer): { recipient: string; rawAmounts: bigint[]; executionHash: string } {
+        return StarknetSpvVaultContract.fromOpReturnData(data);
+    }
+
+    isRecipient(address: string): boolean {
+        return this.getRecipient().toLowerCase()===address.toLowerCase();
+    }
+
+    getTxHash(): bigint {
+        return BigInt("0x"+Buffer.from(this.btcTx.txid, "hex").reverse().toString("hex"));
+    }
+
+    getFrontingAmount(): bigint[] {
+        return [this.rawAmounts[0] + this.getExecutionFee()[0], this.rawAmounts[1]];
+    }
+
+    serialize(): any {
+        return {
+            type: "STARKNET",
+            ...super.serialize()
+        };
+    }
+
+    serializeToStruct() {
+        const callerFee = this.getCallerFee();
+        const frontingFee = this.getFrontingFee();
+        const executionFee = this.getExecutionFee();
+        return {
+            recipient: this.recipient,
+            amount: cairo.tuple(this.rawAmounts[0], this.rawAmounts[1]),
+            caller_fee: cairo.tuple(callerFee[0], callerFee[1]),
+            fronting_fee: cairo.tuple(frontingFee[0], frontingFee[1]),
+            execution_handler_fee_amount_0: executionFee[0],
+            execution_hash: toBigInt(this.executionHash) ?? 0n,
+            execution_expiry: BigInt(this.executionExpiry)
+        }
+    }
+
+    serializeToFelts(): BigNumberish[] {
+        const callerFee = this.getCallerFee();
+        const frontingFee = this.getFrontingFee();
+        const executionFee = this.getExecutionFee();
+        return [
+            this.recipient,
+            this.rawAmounts[0],
+            this.rawAmounts[1],
+            callerFee[0],
+            callerFee[1],
+            frontingFee[0],
+            frontingFee[1],
+            executionFee[0],
+            toBigInt(this.executionHash) ?? 0n,
+            BigInt(this.executionExpiry)
+        ]
+    }
+
+}
+
+SpvWithdrawalTransactionData.deserializers["STARKNET"] = StarknetSpvWithdrawalData;

package/src/starknet/swaps/StarknetSwapContract.ts

@@ -11,16 +11,14 @@ import {
 import {Buffer} from "buffer";
 import {EscrowManagerAbi} from "./EscrowManagerAbi";
 import {StarknetContractBase} from "../contract/StarknetContractBase";
-import {StarknetTx} from "../base/modules/StarknetTransactions";
+import {StarknetTx} from "../chain/modules/StarknetTransactions";
 import {StarknetSigner} from "../wallet/StarknetSigner";
-import {BigNumberish, constants, ec, Provider, stark} from "starknet";
-import {StarknetRetryPolicy} from "../base/StarknetBase";
-import {StarknetFees} from "../base/modules/StarknetFees";
+import {BigNumberish, constants} from "starknet";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
 import {StarknetBtcRelay} from "../btcrelay/StarknetBtcRelay";
 import {StarknetSwapData} from "./StarknetSwapData";
 import {bigNumberishToBuffer, toHex} from "../../utils/Utils";
 import {TimelockRefundHandler} from "./handlers/refund/TimelockRefundHandler";
-import {StarknetKeypairWallet} from "../wallet/StarknetKeypairWallet";
 import {StarknetLpVault} from "./modules/StarknetLpVault";
 import {StarknetPreFetchVerification, StarknetSwapInit} from "./modules/StarknetSwapInit";
 import {StarknetSwapRefund} from "./modules/StarknetSwapRefund";
@@ -105,12 +103,9 @@ export class StarknetSwapContract
     readonly btcRelay: StarknetBtcRelay<any>;
 
     constructor(
-        chainId: constants.StarknetChainId,
-        provider: Provider,
+        chainInterface: StarknetChainInterface,
         btcRelay: StarknetBtcRelay<any>,
-        contractAddress: string = swapContractAddreses[chainId],
-        retryPolicy?: StarknetRetryPolicy,
-        solanaFeeEstimator: StarknetFees = new StarknetFees(provider),
+        contractAddress: string = swapContractAddreses[chainInterface.starknetChainId],
         handlerAddresses?: {
             refund?: {
                 timelock?: string
@@ -120,19 +115,19 @@ export class StarknetSwapContract
             }
         }
     ) {
-        super(chainId, provider, contractAddress, EscrowManagerAbi, retryPolicy, solanaFeeEstimator);
-        this.Init = new StarknetSwapInit(this);
-        this.Refund = new StarknetSwapRefund(this);
-        this.Claim = new StarknetSwapClaim(this);
-        this.LpVault = new StarknetLpVault(this);
+        super(chainInterface, contractAddress, EscrowManagerAbi);
+        this.Init = new StarknetSwapInit(chainInterface, this);
+        this.Refund = new StarknetSwapRefund(chainInterface, this);
+        this.Claim = new StarknetSwapClaim(chainInterface, this);
+        this.LpVault = new StarknetLpVault(chainInterface, this);
 
         this.btcRelay = btcRelay;
 
         handlerAddresses ??= {};
         handlerAddresses.refund ??= {};
-        handlerAddresses.refund = {...defaultRefundAddresses[chainId], ...handlerAddresses.refund};
+        handlerAddresses.refund = {...defaultRefundAddresses[chainInterface.starknetChainId], ...handlerAddresses.refund};
         handlerAddresses.claim ??= {};
-        handlerAddresses.claim = {...defaultClaimAddresses[chainId], ...handlerAddresses.claim};
+        handlerAddresses.claim = {...defaultClaimAddresses[chainInterface.starknetChainId], ...handlerAddresses.claim};
 
         claimHandlersList.forEach(handlerCtor => {
             const handler = new handlerCtor(handlerAddresses.claim[handlerCtor.type]);
@@ -178,11 +173,11 @@ export class StarknetSwapContract
     }
 
     getDataSignature(signer: StarknetSigner, data: Buffer): Promise<string> {
-        return this.Signatures.getDataSignature(signer, data);
+        return this.Chain.Signatures.getDataSignature(signer, data);
     }
 
     isValidDataSignature(data: Buffer, signature: string, publicKey: string): Promise<boolean> {
-        return this.Signatures.isValidDataSignature(data, signature, publicKey);
+        return this.Chain.Signatures.isValidDataSignature(data, signature, publicKey);
     }
 
     ////////////////////////////////////////////
@@ -358,7 +353,7 @@ export class StarknetSwapContract
         payOut: boolean,
         securityDeposit: bigint,
         claimerBounty: bigint,
-        depositToken: string = this.Tokens.getNativeCurrencyAddress()
+        depositToken: string = this.Chain.Tokens.getNativeCurrencyAddress()
     ): Promise<StarknetSwapData> {
         return Promise.resolve(new StarknetSwapData(
             offerer,
@@ -383,11 +378,11 @@ export class StarknetSwapContract
 
     ////////////////////////////////////////////
     //// Utils
-    async getBalance(signer: string, tokenAddress: string, inContract: boolean): Promise<bigint> {
+    async getBalance(signer: string, tokenAddress: string, inContract?: boolean): Promise<bigint> {
         if(inContract) return await this.getIntermediaryBalance(signer, tokenAddress);
 
         //TODO: For native token we should discount the cost of deploying an account if it is not deployed yet
-        return await this.Tokens.getTokenBalance(signer, tokenAddress);
+        return await this.Chain.getBalance(signer, tokenAddress);
     }
 
     getIntermediaryData(address: string, token: string): Promise<{
@@ -405,14 +400,6 @@ export class StarknetSwapContract
         return this.LpVault.getIntermediaryBalance(address, token);
     }
 
-    isValidAddress(address: string): boolean {
-        return this.Addresses.isValidAddress(address);
-    }
-
-    getNativeCurrencyAddress(): string {
-        return this.Tokens.getNativeCurrencyAddress();
-    }
-
     ////////////////////////////////////////////
     //// Transaction initializers
     async txsClaimWithSecret(
@@ -470,10 +457,6 @@ export class StarknetSwapContract
         return this.LpVault.txsDeposit(signer, token, amount, feeRate);
     }
 
-    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]> {
-        return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
-    }
-
     ////////////////////////////////////////////
     //// Executors
     async claimWithSecret(
@@ -485,7 +468,7 @@ export class StarknetSwapContract
         txOptions?: TransactionConfirmationOptions
     ): Promise<string> {
         const result = await this.Claim.txsClaimWithSecret(signer.getAddress(), swapData, secret, checkExpiry, txOptions?.feeRate);
-        const [signature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return signature;
     }
 
@@ -507,7 +490,7 @@ export class StarknetSwapContract
         if(txs===null) throw new Error("Btc relay not synchronized to required blockheight!");
 
         //TODO: This doesn't return proper tx signature
-        const [signature] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [signature] = await this.Chain.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return signature;
     }
@@ -521,7 +504,7 @@ export class StarknetSwapContract
     ): Promise<string> {
         let result = await this.txsRefund(signer.getAddress(), swapData, check, initAta, txOptions?.feeRate);
 
-        const [signature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return signature;
     }
@@ -536,7 +519,7 @@ export class StarknetSwapContract
     ): Promise<string> {
         let result = await this.txsRefundWithAuthorization(signer.getAddress(), swapData, signature, check, initAta, txOptions?.feeRate);
 
-        const [txSignature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [txSignature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return txSignature;
     }
@@ -556,7 +539,7 @@ export class StarknetSwapContract
 
         let result = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
 
-        const [txSignature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [txSignature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return txSignature;
     }
@@ -568,7 +551,7 @@ export class StarknetSwapContract
         txOptions?: TransactionConfirmationOptions
     ): Promise<string> {
         const txs = await this.LpVault.txsWithdraw(signer.getAddress(), token, amount, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        const [txId] = await this.Chain.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
         return txId;
     }
 
@@ -579,67 +562,26 @@ export class StarknetSwapContract
         txOptions?: TransactionConfirmationOptions
     ): Promise<string> {
         const txs = await this.LpVault.txsDeposit(signer.getAddress(), token, amount, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
-        return txId;
-    }
-
-    async transfer(
-        signer: StarknetSigner,
-        token: string,
-        amount: bigint,
-        dstAddress: string,
-        txOptions?: TransactionConfirmationOptions
-    ): Promise<string> {
-        const txs = await this.Tokens.txsTransfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        const [txId] = await this.Chain.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
         return txId;
     }
 
-    ////////////////////////////////////////////
-    //// Transactions
-    sendAndConfirm(
-        signer: StarknetSigner,
-        txs: StarknetTx[],
-        waitForConfirmation?: boolean,
-        abortSignal?: AbortSignal,
-        parallel?: boolean,
-        onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
-    ): Promise<string[]> {
-        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
-    }
-
-    serializeTx(tx: StarknetTx): Promise<string> {
-        return this.Transactions.serializeTx(tx);
-    }
-
-    deserializeTx(txData: string): Promise<StarknetTx> {
-        return this.Transactions.deserializeTx(txData);
-    }
-
-    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
-        return this.Transactions.getTxIdStatus(txId);
-    }
-
-    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
-        return this.Transactions.getTxStatus(tx);
-    }
-
     ////////////////////////////////////////////
     //// Fees
     getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string> {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
 
     getInitFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string> {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
 
     getRefundFeeRate(swapData: StarknetSwapData): Promise<string> {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
 
     getClaimFeeRate(signer: string, swapData: StarknetSwapData): Promise<string> {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
 
     getClaimFee(signer: string, swapData: StarknetSwapData, feeRate?: string): Promise<bigint> {
@@ -660,34 +602,4 @@ export class StarknetSwapContract
         return this.Refund.getRefundFee(swapData, feeRate);
     }
 
-    ///////////////////////////////////
-    //// Callbacks & handlers
-    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
-        return true;
-    }
-
-    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {}
-
-    onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void {
-        this.Transactions.onBeforeTxSigned(callback);
-    }
-
-    offBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): boolean {
-        return this.Transactions.offBeforeTxSigned(callback);
-    }
-
-    isValidToken(tokenIdentifier: string): boolean {
-        return this.Tokens.isValidToken(tokenIdentifier);
-    }
-
-    randomAddress(): string {
-        return stark.randomAddress();
-    }
-
-    randomSigner(): StarknetSigner {
-        const privateKey = "0x"+Buffer.from(ec.starkCurve.utils.randomPrivateKey()).toString("hex");
-        const wallet = new StarknetKeypairWallet(this.provider, privateKey);
-        return new StarknetSigner(wallet);
-    }
-
 }

package/src/starknet/swaps/StarknetSwapModule.ts

@@ -1,17 +1,17 @@
-import {StarknetModule} from "../base/StarknetModule";
 import {StarknetSwapContract} from "./StarknetSwapContract";
 import {TypedContractV2} from "starknet";
 import {EscrowManagerAbi} from "./EscrowManagerAbi";
+import {StarknetChainInterface} from "../chain/StarknetChainInterface";
+import {StarknetContractModule} from "../contract/StarknetContractModule";
 
-export class StarknetSwapModule extends StarknetModule {
+export class StarknetSwapModule extends StarknetContractModule<typeof EscrowManagerAbi> {
 
-    readonly root: StarknetSwapContract;
-    readonly contract: TypedContractV2<typeof EscrowManagerAbi>;
+    readonly contract: StarknetSwapContract;
+    readonly swapContract: TypedContractV2<typeof EscrowManagerAbi>;
 
-    constructor(root: StarknetSwapContract) {
-        super(root);
-        this.root = root;
-        this.contract = root.contract;
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetSwapContract) {
+        super(chainInterface, contract);
+        this.swapContract = contract.contract;
     }
 
 }

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

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

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

@@ -1,6 +1,6 @@
 import {HashlockClaimHandler} from "./HashlockClaimHandler";
 import {ChainSwapType} from "@atomiqlabs/base";
-import {StarknetGas} from "../../../base/StarknetAction";
+import {StarknetGas} from "../../../chain/StarknetAction";
 import {IHandler} from "../IHandler";
 import {BitcoinTxIdClaimHandler} from "./btc/BitcoinTxIdClaimHandler";
 import {BitcoinOutputClaimHandler} from "./btc/BitcoinOutputClaimHandler";

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

@@ -2,10 +2,10 @@ import {StarknetSwapData} from "../../StarknetSwapData";
 import {bufferToU32Array, toHex, u32ArrayToBuffer} from "../../../../utils/Utils";
 import {BigNumberish, hash} from "starknet";
 import {ChainSwapType} from "@atomiqlabs/base";
-import {StarknetGas} from "../../../base/StarknetAction";
+import {StarknetGas} from "../../../chain/StarknetAction";
 import {Buffer} from "buffer";
 import {sha256} from "@noble/hashes/sha2";
-import {StarknetTx} from "../../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
 import {IClaimHandler} from "./ClaimHandlers";
 
 export class HashlockClaimHandler implements IClaimHandler<Buffer, string> {

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

@@ -1,8 +1,8 @@
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../base/StarknetAction";
+import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {BigNumberish, hash} from "starknet";
-import {StarknetTx} from "../../../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
 import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../../../../utils/Utils";
 import {BitcoinCommitmentData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
 import {BitcoinOutputWitnessData} from "./BitcoinOutputClaimHandler";

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

@@ -1,8 +1,8 @@
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../base/StarknetAction";
+import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {BigNumberish, hash} from "starknet";
-import {StarknetTx} from "../../../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
 import {bufferToByteArray, getLogger, poseidonHashRange, toBigInt} from "../../../../../utils/Utils";
 import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
 import {Transaction} from "@scure/btc-signer";

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

@@ -1,8 +1,8 @@
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../base/StarknetAction";
+import {StarknetGas} from "../../../../chain/StarknetAction";
 import {ChainSwapType} from "@atomiqlabs/base";
 import {BigNumberish} from "starknet";
-import {StarknetTx} from "../../../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
 import {bufferToU32Array, getLogger} from "../../../../../utils/Utils";
 import {BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler} from "./IBitcoinClaimHandler";
 import {Buffer} from "buffer";

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

@@ -1,12 +1,12 @@
 import {IClaimHandler} from "../ClaimHandlers";
 import {StarknetSwapData} from "../../../StarknetSwapData";
-import {StarknetGas} from "../../../../base/StarknetAction";
+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 "../../../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../../../chain/modules/StarknetTransactions";
 import {StarknetBtcRelay} from "../../../../btcrelay/StarknetBtcRelay";
-import {bufferToU32Array, getLogger, toHex, tryWithRetries, u32ArrayToBuffer} from "../../../../../utils/Utils";
+import {bufferToU32Array, getLogger, u32ArrayToBuffer} from "../../../../../utils/Utils";
 
 export type BitcoinCommitmentData = {
     btcRelay: StarknetBtcRelay<any>,
@@ -31,58 +31,6 @@ export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> impl
         this.address = address;
     }
 
-    /**
-     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
-     *  requiredConfirmations
-     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
-     *  current chain tip & adds them to the txs array
-     *
-     * @param signer
-     * @param btcRelay
-     * @param txBlockheight transaction blockheight
-     * @param requiredConfirmations required confirmation for the swap to be claimable with that TX
-     * @param blockhash blockhash of the block which includes the transaction
-     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
-     *  txns are added here
-     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
-     *  to the required blockheight
-     * @param feeRate Fee rate to use for synchronization transactions
-     * @private
-     */
-    protected async getCommitedHeaderAndSynchronize(
-        signer: string,
-        btcRelay: StarknetBtcRelay<any>,
-        txBlockheight: number,
-        requiredConfirmations: number,
-        blockhash: string,
-        txs: StarknetTx[],
-        synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>,
-        feeRate?: string
-    ): Promise<StarknetBtcStoredHeader> {
-        const requiredBlockheight = txBlockheight+requiredConfirmations-1;
-
-        const result = await tryWithRetries(
-            () => btcRelay.retrieveLogAndBlockheight({
-                blockhash: blockhash
-            }, requiredBlockheight)
-        );
-
-        if(result!=null) return result.header;
-
-        //Need to synchronize
-        if(synchronizer==null) return null;
-
-        //TODO: We don't have to synchronize to tip, only to our required blockheight
-        const resp = await synchronizer.syncToLatestTxs(signer.toString(), feeRate);
-        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, "+
-            "synchronizing ourselves in "+resp.txs.length+" txs");
-        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ",resp.computedHeaderMap);
-        resp.txs.forEach(tx => txs.push(tx));
-
-        //Retrieve computed header
-        return resp.computedHeaderMap[txBlockheight];
-    }
-
     public static readonly address = "";
     public static readonly type: ChainSwapType = ChainSwapType.CHAIN_TXID;
     public static readonly gas: StarknetGas = {l1: 20000};
@@ -121,12 +69,15 @@ export abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> impl
         logger.debug("getWitness(): merkle proof computed: ", merkleProof);
 
         const txs: StarknetTx[] = [];
-        if(commitedHeader==null) commitedHeader = await this.getCommitedHeaderAndSynchronize(
-            signer, btcRelay, tx.height, requiredConfirmations,
-            tx.blockhash, txs, synchronizer, feeRate
-        );
-
-        if(commitedHeader==null) throw new Error("Cannot fetch committed header!");
+        if(commitedHeader==null) {
+            const headers = await StarknetBtcRelay.getCommitedHeadersAndSynchronize(
+                signer, btcRelay,
+                [{blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash}],
+                txs, synchronizer, feeRate
+            );
+            if(headers==null) throw new Error("Cannot fetch committed header!");
+            commitedHeader = headers[tx.blockhash];
+        }
 
         serializedData.push(...commitedHeader.serialize());
         serializedData.push(merkleProof.merkle.length, ...merkleProof.merkle.map(bufferToU32Array).flat());

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

@@ -1,9 +1,9 @@
-import {StarknetTx} from "../../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../../chain/modules/StarknetTransactions";
 import {StarknetSwapData} from "../../StarknetSwapData";
 import {bigNumberishToBuffer, toBigInt} from "../../../../utils/Utils";
 import {BigNumberish} from "starknet";
 import {IHandler} from "../IHandler";
-import {StarknetGas} from "../../../base/StarknetAction";
+import {StarknetGas} from "../../../chain/StarknetAction";
 
 export class TimelockRefundHandler implements IHandler<bigint, never> {
 

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

@@ -1,9 +1,9 @@
 import {toBigInt} from "../../../utils/Utils";
 import { IntermediaryReputationType } from "@atomiqlabs/base";
 import {StarknetSwapModule} from "../StarknetSwapModule";
-import {StarknetAction} from "../../base/StarknetAction";
+import {StarknetAction} from "../../chain/StarknetAction";
 import {cairo} from "starknet";
-import {StarknetTx} from "../../base/modules/StarknetTransactions";
+import {StarknetTx} from "../../chain/modules/StarknetTransactions";
 
 export class StarknetLpVault extends StarknetSwapModule {
 
@@ -23,7 +23,7 @@ export class StarknetLpVault extends StarknetSwapModule {
      */
     private Withdraw(signer: string, token: string, amount: bigint): StarknetAction {
         return new StarknetAction(signer, this.root,
-            this.contract.populateTransaction.withdraw(token, cairo.uint256(amount), signer),
+            this.swapContract.populateTransaction.withdraw(token, cairo.uint256(amount), signer),
             StarknetLpVault.GasCosts.WITHDRAW
         );
     }
@@ -39,7 +39,7 @@ export class StarknetLpVault extends StarknetSwapModule {
      */
     private Deposit(signer: string, token: string, amount: bigint): StarknetAction {
         return new StarknetAction(signer, this.root,
-            this.contract.populateTransaction.deposit(token, cairo.uint256(amount)),
+            this.swapContract.populateTransaction.deposit(token, cairo.uint256(amount)),
             StarknetLpVault.GasCosts.WITHDRAW
         );
     }
@@ -69,14 +69,14 @@ export class StarknetLpVault extends StarknetSwapModule {
      * @param token
      */
     public async getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType> {
-        const filter = Object.keys(this.root.claimHandlersByAddress).map(claimHandler => cairo.tuple(address, token, claimHandler));
-        const rawReputation = await this.provider.callContract(this.contract.populateTransaction.get_reputation(filter));
+        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => cairo.tuple(address, token, claimHandler));
+        const rawReputation = await this.provider.callContract(this.swapContract.populateTransaction.get_reputation(filter));
         const length = toBigInt(rawReputation.shift());
         if(Number(length)!==filter.length) throw new Error("getIntermediaryReputation(): Invalid response length");
 
         const result: any = {};
-        Object.keys(this.root.claimHandlersByAddress).forEach((address) => {
-            const handler = this.root.claimHandlersByAddress[address];
+        Object.keys(this.contract.claimHandlersByAddress).forEach((address) => {
+            const handler = this.contract.claimHandlersByAddress[address];
             result[handler.getType()] = {
                 successVolume: toBigInt({low: rawReputation.shift(), high: rawReputation.shift()}),
                 successCount: toBigInt(rawReputation.shift()),
@@ -96,7 +96,7 @@ export class StarknetLpVault extends StarknetSwapModule {
      * @param token
      */
     public async getIntermediaryBalance(address: string, token: string): Promise<bigint> {
-        const balance = toBigInt((await this.contract.get_balance([cairo.tuple(address, token)]))[0]);
+        const balance = toBigInt((await this.swapContract.get_balance([cairo.tuple(address, token)]))[0]);
 
         this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: "+token.toString()+
             " address: "+address+" amount: "+(balance==null ? "null" : balance.toString()));
@@ -134,7 +134,7 @@ export class StarknetLpVault extends StarknetSwapModule {
      */
     public async txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]> {
         //Approve first
-        const action = await this.root.Tokens.Approve(signer, this.contract.address, token, amount);
+        const action = await this.root.Tokens.Approve(signer, this.swapContract.address, token, amount);
         action.add(this.Deposit(signer, token, amount));
 
         feeRate ??= await this.root.Fees.getFeeRate();