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

package/dist/starknet/spv_swap/StarknetSpvWithdrawalData.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSpvWithdrawalData = void 0;
+const base_1 = require("@atomiqlabs/base");
+const buffer_1 = require("buffer");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../utils/Utils");
+const StarknetSpvVaultContract_1 = require("./StarknetSpvVaultContract");
+class StarknetSpvWithdrawalData extends base_1.SpvWithdrawalTransactionData {
+    fromOpReturnData(data) {
+        return StarknetSpvVaultContract_1.StarknetSpvVaultContract.fromOpReturnData(data);
+    }
+    isRecipient(address) {
+        return this.getRecipient().toLowerCase() === address.toLowerCase();
+    }
+    getTxHash() {
+        return BigInt("0x" + buffer_1.Buffer.from(this.btcTx.txid, "hex").reverse().toString("hex"));
+    }
+    getFrontingAmount() {
+        return [this.rawAmounts[0] + this.getExecutionFee()[0], this.rawAmounts[1]];
+    }
+    serialize() {
+        return {
+            type: "STARKNET",
+            ...super.serialize()
+        };
+    }
+    serializeToStruct() {
+        const callerFee = this.getCallerFee();
+        const frontingFee = this.getFrontingFee();
+        const executionFee = this.getExecutionFee();
+        return {
+            recipient: this.recipient,
+            amount: starknet_1.cairo.tuple(this.rawAmounts[0], this.rawAmounts[1]),
+            caller_fee: starknet_1.cairo.tuple(callerFee[0], callerFee[1]),
+            fronting_fee: starknet_1.cairo.tuple(frontingFee[0], frontingFee[1]),
+            execution_handler_fee_amount_0: executionFee[0],
+            execution_hash: (0, Utils_1.toBigInt)(this.executionHash) ?? 0n,
+            execution_expiry: BigInt(this.executionExpiry)
+        };
+    }
+    serializeToFelts() {
+        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],
+            (0, Utils_1.toBigInt)(this.executionHash) ?? 0n,
+            BigInt(this.executionExpiry)
+        ];
+    }
+}
+exports.StarknetSpvWithdrawalData = StarknetSpvWithdrawalData;
+base_1.SpvWithdrawalTransactionData.deserializers["STARKNET"] = StarknetSpvWithdrawalData;

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

@@ -2,11 +2,9 @@ import { ChainSwapType, IntermediaryReputationType, RelaySynchronizer, Signature
 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 { constants, Provider } from "starknet";
-import { StarknetRetryPolicy } from "../base/StarknetBase";
-import { StarknetFees } from "../base/modules/StarknetFees";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
 import { StarknetBtcRelay } from "../btcrelay/StarknetBtcRelay";
 import { StarknetSwapData } from "./StarknetSwapData";
 import { StarknetLpVault } from "./modules/StarknetLpVault";
@@ -39,7 +37,7 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
     };
     readonly timelockRefundHandler: IHandler<any, any>;
     readonly btcRelay: StarknetBtcRelay<any>;
-    constructor(chainId: constants.StarknetChainId, provider: Provider, btcRelay: StarknetBtcRelay<any>, contractAddress?: string, retryPolicy?: StarknetRetryPolicy, solanaFeeEstimator?: StarknetFees, handlerAddresses?: {
+    constructor(chainInterface: StarknetChainInterface, btcRelay: StarknetBtcRelay<any>, contractAddress?: string, handlerAddresses?: {
         refund?: {
             timelock?: string;
         };
@@ -141,15 +139,13 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
      */
     getCommitedData(paymentHashHex: string): Promise<StarknetSwapData>;
     createSwapData(type: ChainSwapType, offerer: string, claimer: string, token: string, amount: bigint, paymentHash: string, sequence: bigint, expiry: bigint, payIn: boolean, payOut: boolean, securityDeposit: bigint, claimerBounty: bigint, depositToken?: string): Promise<StarknetSwapData>;
-    getBalance(signer: string, tokenAddress: string, inContract: boolean): Promise<bigint>;
+    getBalance(signer: string, tokenAddress: string, inContract?: boolean): Promise<bigint>;
     getIntermediaryData(address: string, token: string): Promise<{
         balance: bigint;
         reputation: IntermediaryReputationType;
     }>;
     getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
     getIntermediaryBalance(address: string, token: string): Promise<bigint>;
-    isValidAddress(address: string): boolean;
-    getNativeCurrencyAddress(): string;
     txsClaimWithSecret(signer: string | StarknetSigner, swapData: StarknetSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<StarknetTx[]>;
     txsClaimWithTxData(signer: string | StarknetSigner, swapData: StarknetSwapData, tx: {
         blockhash: string;
@@ -171,7 +167,6 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
     }, skipChecks?: boolean, feeRate?: string): Promise<StarknetTx[]>;
     txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
     txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
-    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<StarknetTx[]>;
     claimWithSecret(signer: StarknetSigner, swapData: StarknetSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
     claimWithTxData(signer: StarknetSigner, swapData: StarknetSwapData, tx: {
         blockhash: string;
@@ -185,12 +180,6 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
     init(signer: StarknetSigner, swapData: StarknetSwapData, signature: SignatureData, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
     withdraw(signer: StarknetSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
     deposit(signer: StarknetSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    transfer(signer: StarknetSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    sendAndConfirm(signer: StarknetSigner, txs: StarknetTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
-    serializeTx(tx: StarknetTx): Promise<string>;
-    deserializeTx(txData: string): Promise<StarknetTx>;
-    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
     getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
     getInitFeeRate(offerer?: string, claimer?: string, token?: string, paymentHash?: string): Promise<string>;
     getRefundFeeRate(swapData: StarknetSwapData): Promise<string>;
@@ -204,11 +193,4 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
      * Get the estimated solana transaction fee of the refund transaction
      */
     getRefundFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint>;
-    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
-    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
-    onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void;
-    offBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): boolean;
-    isValidToken(tokenIdentifier: string): boolean;
-    randomAddress(): string;
-    randomSigner(): StarknetSigner;
 }

package/dist/starknet/swaps/StarknetSwapContract.js

@@ -5,13 +5,10 @@ const base_1 = require("@atomiqlabs/base");
 const buffer_1 = require("buffer");
 const EscrowManagerAbi_1 = require("./EscrowManagerAbi");
 const StarknetContractBase_1 = require("../contract/StarknetContractBase");
-const StarknetSigner_1 = require("../wallet/StarknetSigner");
 const starknet_1 = require("starknet");
-const StarknetFees_1 = require("../base/modules/StarknetFees");
 const StarknetSwapData_1 = require("./StarknetSwapData");
 const Utils_1 = require("../../utils/Utils");
 const TimelockRefundHandler_1 = require("./handlers/refund/TimelockRefundHandler");
-const StarknetKeypairWallet_1 = require("../wallet/StarknetKeypairWallet");
 const StarknetLpVault_1 = require("./modules/StarknetLpVault");
 const StarknetSwapInit_1 = require("./modules/StarknetSwapInit");
 const StarknetSwapRefund_1 = require("./modules/StarknetSwapRefund");
@@ -48,8 +45,8 @@ const defaultRefundAddresses = {
     }
 };
 class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
-    constructor(chainId, provider, btcRelay, contractAddress = swapContractAddreses[chainId], retryPolicy, solanaFeeEstimator = new StarknetFees_1.StarknetFees(provider), handlerAddresses) {
-        super(chainId, provider, contractAddress, EscrowManagerAbi_1.EscrowManagerAbi, retryPolicy, solanaFeeEstimator);
+    constructor(chainInterface, btcRelay, contractAddress = swapContractAddreses[chainInterface.starknetChainId], handlerAddresses) {
+        super(chainInterface, contractAddress, EscrowManagerAbi_1.EscrowManagerAbi);
         ////////////////////////
         //// Constants
         this.chainId = "STARKNET";
@@ -66,16 +63,16 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
         this.claimHandlersByAddress = {};
         this.claimHandlersBySwapType = {};
         this.refundHandlersByAddress = {};
-        this.Init = new StarknetSwapInit_1.StarknetSwapInit(this);
-        this.Refund = new StarknetSwapRefund_1.StarknetSwapRefund(this);
-        this.Claim = new StarknetSwapClaim_1.StarknetSwapClaim(this);
-        this.LpVault = new StarknetLpVault_1.StarknetLpVault(this);
+        this.Init = new StarknetSwapInit_1.StarknetSwapInit(chainInterface, this);
+        this.Refund = new StarknetSwapRefund_1.StarknetSwapRefund(chainInterface, this);
+        this.Claim = new StarknetSwapClaim_1.StarknetSwapClaim(chainInterface, this);
+        this.LpVault = new StarknetLpVault_1.StarknetLpVault(chainInterface, this);
         this.btcRelay = btcRelay;
         handlerAddresses ?? (handlerAddresses = {});
         handlerAddresses.refund ?? (handlerAddresses.refund = {});
-        handlerAddresses.refund = { ...defaultRefundAddresses[chainId], ...handlerAddresses.refund };
+        handlerAddresses.refund = { ...defaultRefundAddresses[chainInterface.starknetChainId], ...handlerAddresses.refund };
         handlerAddresses.claim ?? (handlerAddresses.claim = {});
-        handlerAddresses.claim = { ...defaultClaimAddresses[chainId], ...handlerAddresses.claim };
+        handlerAddresses.claim = { ...defaultClaimAddresses[chainInterface.starknetChainId], ...handlerAddresses.claim };
         ClaimHandlers_1.claimHandlersList.forEach(handlerCtor => {
             const handler = new handlerCtor(handlerAddresses.claim[handlerCtor.type]);
             this.claimHandlersByAddress[handler.address] = handler;
@@ -110,10 +107,10 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
         return this.Refund.isSignatureValid(swapData, timeout, prefix, signature);
     }
     getDataSignature(signer, data) {
-        return this.Signatures.getDataSignature(signer, data);
+        return this.Chain.Signatures.getDataSignature(signer, data);
     }
     isValidDataSignature(data, signature, publicKey) {
-        return this.Signatures.isValidDataSignature(data, signature, publicKey);
+        return this.Chain.Signatures.isValidDataSignature(data, signature, publicKey);
     }
     ////////////////////////////////////////////
     //// Swap data utils
@@ -273,7 +270,7 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
     }
     ////////////////////////////////////////////
     //// Swap data initializer
-    createSwapData(type, offerer, claimer, token, amount, paymentHash, sequence, expiry, payIn, payOut, securityDeposit, claimerBounty, depositToken = this.Tokens.getNativeCurrencyAddress()) {
+    createSwapData(type, offerer, claimer, token, amount, paymentHash, sequence, expiry, payIn, payOut, securityDeposit, claimerBounty, depositToken = this.Chain.Tokens.getNativeCurrencyAddress()) {
         return Promise.resolve(new StarknetSwapData_1.StarknetSwapData(offerer, claimer, token, this.timelockRefundHandler.address, this.claimHandlersBySwapType?.[type]?.address, payOut, payIn, payIn, //For now track reputation for all payIn swaps
         sequence, "0x" + paymentHash, (0, Utils_1.toHex)(expiry), amount, depositToken, securityDeposit, claimerBounty, type, null));
     }
@@ -283,7 +280,7 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
         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, token) {
         return this.LpVault.getIntermediaryData(address, token);
@@ -294,12 +291,6 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
     getIntermediaryBalance(address, token) {
         return this.LpVault.getIntermediaryBalance(address, token);
     }
-    isValidAddress(address) {
-        return this.Addresses.isValidAddress(address);
-    }
-    getNativeCurrencyAddress() {
-        return this.Tokens.getNativeCurrencyAddress();
-    }
     ////////////////////////////////////////////
     //// Transaction initializers
     async txsClaimWithSecret(signer, swapData, secret, checkExpiry, initAta, feeRate, skipAtaCheck) {
@@ -323,14 +314,11 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
     txsDeposit(signer, token, amount, feeRate) {
         return this.LpVault.txsDeposit(signer, token, amount, feeRate);
     }
-    txsTransfer(signer, token, amount, dstAddress, feeRate) {
-        return this.Tokens.txsTransfer(signer, token, amount, dstAddress, feeRate);
-    }
     ////////////////////////////////////////////
     //// Executors
     async claimWithSecret(signer, swapData, secret, checkExpiry, initAta, txOptions) {
         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;
     }
     async claimWithTxData(signer, swapData, tx, requiredConfirmations, vout, commitedHeader, synchronizer, initAta, txOptions) {
@@ -338,17 +326,17 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
         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;
     }
     async refund(signer, swapData, check, initAta, txOptions) {
         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;
     }
     async refundWithAuthorization(signer, swapData, signature, check, initAta, txOptions) {
         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;
     }
     async init(signer, swapData, signature, skipChecks, txOptions) {
@@ -361,54 +349,32 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
                 throw new Error("Invalid signer provided!");
         }
         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;
     }
     async withdraw(signer, token, amount, txOptions) {
         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;
     }
     async deposit(signer, token, amount, txOptions) {
         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, token, amount, dstAddress, txOptions) {
-        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, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
-        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
-    }
-    serializeTx(tx) {
-        return this.Transactions.serializeTx(tx);
-    }
-    deserializeTx(txData) {
-        return this.Transactions.deserializeTx(txData);
-    }
-    getTxIdStatus(txId) {
-        return this.Transactions.getTxIdStatus(txId);
-    }
-    getTxStatus(tx) {
-        return this.Transactions.getTxStatus(tx);
-    }
-    ////////////////////////////////////////////
     //// Fees
     getInitPayInFeeRate(offerer, claimer, token, paymentHash) {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
     getInitFeeRate(offerer, claimer, token, paymentHash) {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
     getRefundFeeRate(swapData) {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
     getClaimFeeRate(signer, swapData) {
-        return this.Fees.getFeeRate();
+        return this.Chain.Fees.getFeeRate();
     }
     getClaimFee(signer, swapData, feeRate) {
         return this.Claim.getClaimFee(swapData, feeRate);
@@ -425,28 +391,5 @@ class StarknetSwapContract extends StarknetContractBase_1.StarknetContractBase {
     getRefundFee(swapData, feeRate) {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
-    ///////////////////////////////////
-    //// Callbacks & handlers
-    offBeforeTxReplace(callback) {
-        return true;
-    }
-    onBeforeTxReplace(callback) { }
-    onBeforeTxSigned(callback) {
-        this.Transactions.onBeforeTxSigned(callback);
-    }
-    offBeforeTxSigned(callback) {
-        return this.Transactions.offBeforeTxSigned(callback);
-    }
-    isValidToken(tokenIdentifier) {
-        return this.Tokens.isValidToken(tokenIdentifier);
-    }
-    randomAddress() {
-        return starknet_1.stark.randomAddress();
-    }
-    randomSigner() {
-        const privateKey = "0x" + buffer_1.Buffer.from(starknet_1.ec.starkCurve.utils.randomPrivateKey()).toString("hex");
-        const wallet = new StarknetKeypairWallet_1.StarknetKeypairWallet(this.provider, privateKey);
-        return new StarknetSigner_1.StarknetSigner(wallet);
-    }
 }
 exports.StarknetSwapContract = StarknetSwapContract;

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

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

package/dist/starknet/swaps/StarknetSwapModule.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetSwapModule = void 0;
-const StarknetModule_1 = require("../base/StarknetModule");
-class StarknetSwapModule extends StarknetModule_1.StarknetModule {
-    constructor(root) {
-        super(root);
-        this.root = root;
-        this.contract = root.contract;
+const StarknetContractModule_1 = require("../contract/StarknetContractModule");
+class StarknetSwapModule extends StarknetContractModule_1.StarknetContractModule {
+    constructor(chainInterface, contract) {
+        super(chainInterface, contract);
+        this.swapContract = contract.contract;
     }
 }
 exports.StarknetSwapModule = StarknetSwapModule;

package/dist/starknet/swaps/handlers/IHandler.d.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> {
     readonly address: string;
     getCommitment(data: TCommitmentData): BigNumberish;

package/dist/starknet/swaps/handlers/claim/ClaimHandlers.d.ts

@@ -1,5 +1,5 @@
 import { ChainSwapType } from "@atomiqlabs/base";
-import { StarknetGas } from "../../../base/StarknetAction";
+import { StarknetGas } from "../../../chain/StarknetAction";
 import { IHandler } from "../IHandler";
 import { BigNumberish } from "starknet";
 export interface IClaimHandler<C, W> extends IHandler<C, W> {

package/dist/starknet/swaps/handlers/claim/HashlockClaimHandler.d.ts

@@ -1,9 +1,9 @@
 import { StarknetSwapData } from "../../StarknetSwapData";
 import { BigNumberish } from "starknet";
 import { ChainSwapType } from "@atomiqlabs/base";
-import { StarknetGas } from "../../../base/StarknetAction";
+import { StarknetGas } from "../../../chain/StarknetAction";
 import { Buffer } from "buffer";
-import { StarknetTx } from "../../../base/modules/StarknetTransactions";
+import { StarknetTx } from "../../../chain/modules/StarknetTransactions";
 import { IClaimHandler } from "./ClaimHandlers";
 export declare class HashlockClaimHandler implements IClaimHandler<Buffer, string> {
     readonly address: string;

package/dist/starknet/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler.d.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 { BitcoinCommitmentData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
 import { BitcoinOutputWitnessData } from "./BitcoinOutputClaimHandler";
 import { Buffer } from "buffer";

package/dist/starknet/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.d.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 { BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
 import { Buffer } from "buffer";
 export type BitcoinOutputCommitmentData = {

package/dist/starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler.d.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 { BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
 export type BitcoinTxIdCommitmentData = {
     txId: string;

package/dist/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.d.ts

@@ -1,10 +1,10 @@
 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 } 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";
 export type BitcoinCommitmentData = {
     btcRelay: StarknetBtcRelay<any>;
@@ -26,25 +26,6 @@ export type BitcoinWitnessData = {
 export declare abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
     readonly address: string;
     constructor(address: string);
-    /**
-     * 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 getCommitedHeaderAndSynchronize(signer: string, btcRelay: StarknetBtcRelay<any>, txBlockheight: number, requiredConfirmations: number, blockhash: string, txs: StarknetTx[], synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, feeRate?: string): Promise<StarknetBtcStoredHeader>;
     static readonly address = "";
     static readonly type: ChainSwapType;
     static readonly gas: StarknetGas;

package/dist/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.js

@@ -3,49 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IBitcoinClaimHandler = void 0;
 const base_1 = require("@atomiqlabs/base");
 const starknet_1 = require("starknet");
+const StarknetBtcRelay_1 = require("../../../../btcrelay/StarknetBtcRelay");
 const Utils_1 = require("../../../../../utils/Utils");
 const logger = (0, Utils_1.getLogger)("IBitcoinClaimHandler: ");
 class IBitcoinClaimHandler {
     constructor(address) {
         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
-     */
-    async getCommitedHeaderAndSynchronize(signer, btcRelay, txBlockheight, requiredConfirmations, blockhash, txs, synchronizer, feeRate) {
-        const requiredBlockheight = txBlockheight + requiredConfirmations - 1;
-        const result = await (0, Utils_1.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];
-    }
     serializeCommitment(data) {
         return [
             data.confirmations,
@@ -67,10 +31,12 @@ class IBitcoinClaimHandler {
         const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
         logger.debug("getWitness(): merkle proof computed: ", merkleProof);
         const txs = [];
-        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_1.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(Utils_1.bufferToU32Array).flat());
         serializedData.push(merkleProof.pos);

package/dist/starknet/swaps/handlers/refund/TimelockRefundHandler.d.ts

@@ -1,8 +1,8 @@
-import { StarknetTx } from "../../../base/modules/StarknetTransactions";
+import { StarknetTx } from "../../../chain/modules/StarknetTransactions";
 import { StarknetSwapData } from "../../StarknetSwapData";
 import { BigNumberish } from "starknet";
 import { IHandler } from "../IHandler";
-import { StarknetGas } from "../../../base/StarknetAction";
+import { StarknetGas } from "../../../chain/StarknetAction";
 export declare class TimelockRefundHandler implements IHandler<bigint, never> {
     readonly address: string;
     static readonly gas: StarknetGas;

package/dist/starknet/swaps/modules/StarknetLpVault.d.ts

@@ -1,6 +1,6 @@
 import { IntermediaryReputationType } from "@atomiqlabs/base";
 import { StarknetSwapModule } from "../StarknetSwapModule";
-import { StarknetTx } from "../../base/modules/StarknetTransactions";
+import { StarknetTx } from "../../chain/modules/StarknetTransactions";
 export declare class StarknetLpVault extends StarknetSwapModule {
     private static readonly GasCosts;
     /**