@atomiqlabs/chain-starknet 8.0.13 → 8.1.7

package/dist/starknet/StarknetInitializer.d.ts

@@ -30,8 +30,11 @@ export type StarknetOptions = {
     };
     chainId?: constants.StarknetChainId;
     swapContract?: string;
+    swapContractDeploymentHeight?: number;
     btcRelayContract?: string;
+    btcRelayContractDeploymentHeight?: number;
     spvVaultContract?: string;
+    spvVaultContractDeploymentHeight?: number;
     handlerContracts?: {
         refund?: {
             timelock?: string;

package/dist/starknet/StarknetInitializer.js

@@ -71,9 +71,9 @@ function initializeStarknet(options, bitcoinRpc, network) {
     const chainId = options.chainId ??
         (network === base_1.BitcoinNetwork.MAINNET ? starknet_1.constants.StarknetChainId.SN_MAIN : starknet_1.constants.StarknetChainId.SN_SEPOLIA);
     const chainInterface = new StarknetChainInterface_1.StarknetChainInterface(chainId, provider, wsChannel, Fees, options.starknetConfig);
-    const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract);
-    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract, options.handlerContracts);
-    const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract);
+    const btcRelay = new StarknetBtcRelay_1.StarknetBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract, options.btcRelayContractDeploymentHeight);
+    const swapContract = new StarknetSwapContract_1.StarknetSwapContract(chainInterface, btcRelay, options.swapContract, options.handlerContracts, options.swapContractDeploymentHeight);
+    const spvVaultContract = new StarknetSpvVaultContract_1.StarknetSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract, options.spvVaultContractDeploymentHeight);
     const chainEvents = new StarknetChainEventsBrowser_1.StarknetChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "STARKNET",

package/dist/starknet/btcrelay/StarknetBtcRelay.d.ts

@@ -47,7 +47,7 @@ export declare class StarknetBtcRelay<B extends BtcBlock> extends StarknetContra
     readonly maxHeadersPerTx: number;
     readonly maxForkHeadersPerTx: number;
     readonly maxShortForkHeadersPerTx: number;
-    constructor(chainInterface: StarknetChainInterface, bitcoinRpc: BitcoinRpc<B>, bitcoinNetwork: BitcoinNetwork, contractAddress?: string | undefined);
+    constructor(chainInterface: StarknetChainInterface, bitcoinRpc: BitcoinRpc<B>, bitcoinNetwork: BitcoinNetwork, contractAddress?: string | undefined, contractDeploymentHeight?: number);
     /**
      * Computes subsequent commited headers as they will appear on the blockchain when transactions
      *  are submitted & confirmed

package/dist/starknet/btcrelay/StarknetBtcRelay.js

@@ -29,6 +29,11 @@ const btcRelayAddreses = {
     [base_1.BitcoinNetwork.TESTNET]: "0x068601c79da2231d21e015ccfd59c243861156fa523a12c9f987ec28eb8dbc8c",
     [base_1.BitcoinNetwork.MAINNET]: "0x057b14a4231b82f1e525ff35a722d893ca3dd2bde0baa6cee97937c5be861dbc"
 };
+const btcRelayDeploymentHeights = {
+    [base_1.BitcoinNetwork.TESTNET4]: 760719,
+    [base_1.BitcoinNetwork.TESTNET]: 633915,
+    [base_1.BitcoinNetwork.MAINNET]: 1278562
+};
 function serializeCalldata(headers, storedHeader, span) {
     span.push((0, Utils_1.toHex)(headers.length));
     headers.forEach(header => {
@@ -91,10 +96,13 @@ class StarknetBtcRelay extends StarknetContractBase_1.StarknetContractBase {
             calldata: serializeCalldata(forkHeaders, storedHeader, [(0, Utils_1.toHex)(forkId)])
         }, (0, StarknetFees_1.starknetGasAdd)((0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER, forkHeaders.length), (0, StarknetFees_1.starknetGasMul)(GAS_PER_BLOCKHEADER_FORK, totalForkHeaders)));
     }
-    constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress = btcRelayAddreses[bitcoinNetwork]) {
+    constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress = btcRelayAddreses[bitcoinNetwork], contractDeploymentHeight) {
         if (contractAddress == null)
             throw new Error("No BtcRelay address specified!");
-        super(chainInterface, contractAddress, BtcRelayAbi_1.BtcRelayAbi);
+        super(chainInterface, contractAddress, BtcRelayAbi_1.BtcRelayAbi, contractDeploymentHeight ??
+            (btcRelayAddreses[bitcoinNetwork] === contractAddress
+                ? btcRelayDeploymentHeights[bitcoinNetwork]
+                : undefined));
         this.maxHeadersPerTx = 40;
         this.maxForkHeadersPerTx = 30;
         this.maxShortForkHeadersPerTx = 40;

package/dist/starknet/chain/modules/StarknetTransactions.d.ts

@@ -21,6 +21,12 @@ export type StarknetTxDeployAccount = StarknetTxBase & {
 export declare function isStarknetTxDeployAccount(obj: any): obj is StarknetTxDeployAccount;
 export type StarknetTx = StarknetTxInvoke | StarknetTxDeployAccount;
 export type SignedStarknetTx = StarknetTx;
+export type StarknetTraceCall = {
+    calldata: string[];
+    contract_address: string;
+    entry_point_selector: string;
+    calls: StarknetTraceCall[];
+};
 export declare class StarknetTransactions extends StarknetModule {
     private readonly latestConfirmedNonces;
     private readonly latestPendingNonces;
@@ -108,6 +114,7 @@ export declare class StarknetTransactions extends StarknetModule {
      * @param txId
      */
     getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted">;
+    traceTransaction(txId: string, blockHash?: string): Promise<StarknetTraceCall | null>;
     onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
     offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
     onBeforeTxSigned(callback: (tx: StarknetTx) => Promise<void>): void;

package/dist/starknet/chain/modules/StarknetTransactions.js

@@ -588,6 +588,27 @@ class StarknetTransactions extends StarknetModule_1.StarknetModule {
             return "reverted";
         return status;
     }
+    async traceTransaction(txId, blockHash) {
+        let trace;
+        try {
+            trace = await this.provider.getTransactionTrace(txId);
+        }
+        catch (e) {
+            this.logger.warn("getSwapDataGetter(): getter: starknet_traceTransaction not supported by the RPC: ", e);
+            if (blockHash == null)
+                throw e;
+            const blockTraces = await this.provider.getBlockTransactionsTraces(blockHash);
+            const foundTrace = blockTraces.find(val => (0, Utils_1.toHex)(val.transaction_hash) === (0, Utils_1.toHex)(txId));
+            if (foundTrace == null)
+                throw new Error(`Cannot find ${txId} in the block traces, block: ${blockHash}`);
+            trace = foundTrace.trace_root;
+        }
+        if (trace == null)
+            return null;
+        if (trace.execute_invocation.revert_reason != null)
+            return null;
+        return trace.execute_invocation;
+    }
     onBeforeTxReplace(callback) {
         this._cbksBeforeTxReplace.push(callback);
     }

package/dist/starknet/contract/StarknetContractBase.d.ts

@@ -9,5 +9,6 @@ export declare class StarknetContractBase<T extends Abi> {
     contract: TypedContractV2<T>;
     readonly Events: StarknetContractEvents<T>;
     readonly Chain: StarknetChainInterface;
-    constructor(chainInterface: StarknetChainInterface, contractAddress: string, contractAbi: T);
+    readonly contractDeploymentHeight?: number;
+    constructor(chainInterface: StarknetChainInterface, contractAddress: string, contractAbi: T, contractDeploymentHeight?: number);
 }

package/dist/starknet/contract/StarknetContractBase.js

@@ -7,7 +7,7 @@ const StarknetContractEvents_1 = require("./modules/StarknetContractEvents");
  * Base class providing program specific utilities
  */
 class StarknetContractBase {
-    constructor(chainInterface, contractAddress, contractAbi) {
+    constructor(chainInterface, contractAddress, contractAbi, contractDeploymentHeight) {
         this.Chain = chainInterface;
         this.contract = new starknet_1.Contract({
             abi: contractAbi,
@@ -15,6 +15,7 @@ class StarknetContractBase {
             providerOrAccount: chainInterface.provider
         }).typedv2(contractAbi);
         this.Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
+        this.contractDeploymentHeight = contractDeploymentHeight;
     }
 }
 exports.StarknetContractBase = StarknetContractBase;

package/dist/starknet/contract/modules/StarknetContractEvents.js

@@ -105,7 +105,7 @@ class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
                     return result;
             }
             return null;
-        }, startHeight, abortSignal);
+        }, Math.max(startHeight ?? 0, this.contract.contractDeploymentHeight ?? 0), abortSignal);
     }
 }
 exports.StarknetContractEvents = StarknetContractEvents;

package/dist/starknet/events/StarknetChainEventsBrowser.d.ts

@@ -2,8 +2,6 @@ import { ChainEvents, EventListener } from "@atomiqlabs/base";
 import { StarknetSwapData } from "../swaps/StarknetSwapData";
 import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
 import { Provider, SubscriptionStarknetEventsEvent, WebSocketChannel } from "starknet";
-import { EscrowManagerAbiType } from "../swaps/EscrowManagerAbi";
-import { ExtractAbiFunctionNames } from "abi-wan-kanabi/dist/kanabi";
 import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
 import { StarknetChainInterface } from "../chain/StarknetChainInterface";
 /**
@@ -35,8 +33,6 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
     protected readonly logger: import("../../utils/Utils").LoggerType;
     protected escrowContractSubscription?: SubscriptionStarknetEventsEvent;
     protected spvVaultContractSubscription?: SubscriptionStarknetEventsEvent;
-    protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType>;
-    protected initEntryPointSelector: bigint;
     protected stopped: boolean;
     protected pollIntervalSeconds: number;
     private timeout;
@@ -59,14 +55,6 @@ export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetS
      * @private
      */
     private isEventProcessed;
-    /**
-     *
-     * @param call
-     * @param escrowHash
-     * @param claimHandler
-     * @private
-     */
-    private findInitSwapData;
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *

package/dist/starknet/events/StarknetChainEventsBrowser.js

@@ -2,30 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StarknetChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
-const StarknetSwapData_1 = require("../swaps/StarknetSwapData");
 const Utils_1 = require("../../utils/Utils");
 const starknet_1 = require("starknet");
 const sha2_1 = require("@noble/hashes/sha2");
 const buffer_1 = require("buffer");
 const PROCESSED_EVENTS_BACKLOG = 5000;
 const LOGS_SLIDING_WINDOW = 60;
-function parseInitFunctionCalldata(calldata, claimHandler) {
-    const escrow = StarknetSwapData_1.StarknetSwapData.fromSerializedFeltArray(calldata, claimHandler);
-    if (calldata.length < 1)
-        throw new Error("Calldata invalid length");
-    const signatureLen = Number((0, Utils_1.toBigInt)(calldata.shift()));
-    if (calldata.length < signatureLen + 2)
-        throw new Error("Calldata invalid length");
-    const signature = calldata.splice(0, signatureLen);
-    const timeout = (0, Utils_1.toBigInt)(calldata.shift());
-    const extraDataLen = Number((0, Utils_1.toBigInt)(calldata.shift()));
-    if (calldata.length < extraDataLen)
-        throw new Error("Calldata invalid length");
-    const extraData = calldata.splice(0, extraDataLen);
-    if (calldata.length !== 0)
-        throw new Error("Calldata not read fully!");
-    return { escrow, signature, timeout, extraData };
-}
 /**
  * Starknet on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
  *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
@@ -39,8 +21,6 @@ class StarknetChainEventsBrowser {
         this.processedEvents = new Set();
         this.listeners = [];
         this.logger = (0, Utils_1.getLogger)("StarknetChainEventsBrowser: ");
-        this.initFunctionName = "initialize";
-        this.initEntryPointSelector = BigInt(starknet_1.hash.starknetKeccak(this.initFunctionName));
         this.stopped = true;
         this.wsStarted = false;
         this.Chain = chainInterface;
@@ -82,32 +62,6 @@ class StarknetChainEventsBrowser {
         const eventFingerprint = typeof (eventOrFingerprint) === "string" ? eventOrFingerprint : this.getEventFingerprint(eventOrFingerprint);
         return this.processedEvents.has(eventFingerprint);
     }
-    /**
-     *
-     * @param call
-     * @param escrowHash
-     * @param claimHandler
-     * @private
-     */
-    findInitSwapData(call, escrowHash, claimHandler) {
-        if (BigInt(call.contract_address) === BigInt(this.starknetSwapContract.contract.address) &&
-            BigInt(call.entry_point_selector) === this.initEntryPointSelector) {
-            //Found, check correct escrow hash
-            const { escrow, extraData } = parseInitFunctionCalldata(call.calldata, claimHandler);
-            if ("0x" + escrow.getEscrowHash() === (0, Utils_1.toHex)(escrowHash)) {
-                if (extraData.length !== 0) {
-                    escrow.setExtraData((0, Utils_1.bytes31SpanToBuffer)(extraData, 42).toString("hex"));
-                }
-                return escrow;
-            }
-        }
-        for (let _call of call.calls) {
-            const found = this.findInitSwapData(_call, escrowHash, claimHandler);
-            if (found != null)
-                return found;
-        }
-        return null;
-    }
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *
@@ -118,23 +72,10 @@ class StarknetChainEventsBrowser {
      */
     getSwapDataGetter(event, claimHandler) {
         return async () => {
-            let trace;
-            try {
-                trace = await this.provider.getTransactionTrace(event.txHash);
-            }
-            catch (e) {
-                this.logger.warn("getSwapDataGetter(): getter: starknet_traceTransaction not supported by the RPC: ", e);
-                const blockTraces = await this.provider.getBlockTransactionsTraces(event.blockHash);
-                const foundTrace = blockTraces.find(val => (0, Utils_1.toHex)(val.transaction_hash) === (0, Utils_1.toHex)(event.txHash));
-                if (foundTrace == null)
-                    throw new Error(`Cannot find ${event.txHash} in the block traces, block: ${event.blockHash}`);
-                trace = foundTrace.trace_root;
-            }
+            const trace = await this.Chain.Transactions.traceTransaction(event.txHash, event.blockHash);
             if (trace == null)
                 return null;
-            if (trace.execute_invocation.revert_reason != null)
-                return null;
-            return this.findInitSwapData(trace.execute_invocation, event.params.escrow_hash, claimHandler);
+            return this.starknetSwapContract.findInitSwapData(trace, event.params.escrow_hash, claimHandler);
         };
     }
     /**

package/dist/starknet/spv_swap/StarknetSpvVaultContract.d.ts

@@ -1,4 +1,4 @@
-import { BitcoinRpc, BtcTx, RelaySynchronizer, SpvVaultContract, SpvVaultTokenData, SpvWithdrawalState, SpvWithdrawalTransactionData, TransactionConfirmationOptions } from "@atomiqlabs/base";
+import { BitcoinRpc, BtcTx, RelaySynchronizer, SpvVaultContract, SpvVaultTokenData, SpvWithdrawalClaimedState, SpvWithdrawalFrontedState, SpvWithdrawalState, SpvWithdrawalTransactionData, TransactionConfirmationOptions } from "@atomiqlabs/base";
 import { Buffer } from "buffer";
 import { StarknetTx } from "../chain/modules/StarknetTransactions";
 import { StarknetContractBase } from "../contract/StarknetContractBase";
@@ -23,7 +23,7 @@ export declare class StarknetSpvVaultContract extends StarknetContractBase<typeo
     readonly claimTimeout: number;
     readonly maxClaimsPerTx: number;
     readonly logger: import("../../utils/Utils").LoggerType;
-    constructor(chainInterface: StarknetChainInterface, btcRelay: StarknetBtcRelay<any>, bitcoinRpc: BitcoinRpc<any>, contractAddress?: string);
+    constructor(chainInterface: StarknetChainInterface, btcRelay: StarknetBtcRelay<any>, bitcoinRpc: BitcoinRpc<any>, contractAddress?: string, contractDeploymentHeight?: number);
     /**
      * Returns a {@link StarknetAction} that opens up the spv vault with the passed data
      *
@@ -136,6 +136,12 @@ export declare class StarknetSpvVaultContract extends StarknetContractBase<typeo
      * @inheritDoc
      */
     getWithdrawalState(withdrawalTx: StarknetSpvWithdrawalData, scStartBlockheight?: number): Promise<SpvWithdrawalState>;
+    getHistoricalWithdrawalStates(recipient: string, startBlockheight?: number): Promise<{
+        withdrawals: {
+            [btcTxId: string]: SpvWithdrawalClaimedState | SpvWithdrawalFrontedState;
+        };
+        latestBlockheight?: number;
+    }>;
     /**
      * @inheritDoc
      */

package/dist/starknet/spv_swap/StarknetSpvVaultContract.js

@@ -17,6 +17,10 @@ const spvVaultContractAddreses = {
     [starknet_1.constants.StarknetChainId.SN_SEPOLIA]: "0x02d581ea838cd5ca46ba08660eddd064d50a0392f618e95310432147928d572e",
     [starknet_1.constants.StarknetChainId.SN_MAIN]: "0x01932042992647771f3d0aa6ee526e65359c891fe05a285faaf4d3ffa373e132"
 };
+const spvVaultContractDeploymentHeights = {
+    [starknet_1.constants.StarknetChainId.SN_SEPOLIA]: 1118191,
+    [starknet_1.constants.StarknetChainId.SN_MAIN]: 1617295
+};
 const STARK_PRIME_MOD = 2n ** 251n + 17n * 2n ** 192n + 1n;
 function decodeUtxo(utxo) {
     const [txId, vout] = utxo.split(":");
@@ -31,8 +35,11 @@ function decodeUtxo(utxo) {
  * @category Swaps
  */
 class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBase {
-    constructor(chainInterface, btcRelay, bitcoinRpc, contractAddress = spvVaultContractAddreses[chainInterface.starknetChainId]) {
-        super(chainInterface, contractAddress, SpvVaultContractAbi_1.SpvVaultContractAbi);
+    constructor(chainInterface, btcRelay, bitcoinRpc, contractAddress = spvVaultContractAddreses[chainInterface.starknetChainId], contractDeploymentHeight) {
+        super(chainInterface, contractAddress, SpvVaultContractAbi_1.SpvVaultContractAbi, contractDeploymentHeight ??
+            (spvVaultContractAddreses[chainInterface.starknetChainId] === contractAddress
+                ? spvVaultContractDeploymentHeights[chainInterface.starknetChainId]
+                : undefined));
         this.chainId = "STARKNET";
         this.claimTimeout = 180;
         this.maxClaimsPerTx = 10;
@@ -265,29 +272,44 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
             case "spv_swap_vault::events::Fronted":
                 return {
                     type: base_1.SpvWithdrawalStateType.FRONTED,
-                    txId: event.txHash,
+                    btcTxId: (0, Utils_1.bigNumberishToBuffer)(event.params.btc_tx_hash, 32).reverse().toString("hex"),
                     owner: (0, Utils_1.toHex)(event.params.owner),
                     vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
                     recipient: (0, Utils_1.toHex)(event.params.recipient),
-                    fronter: (0, Utils_1.toHex)(event.params.fronting_address)
+                    fronter: (0, Utils_1.toHex)(event.params.caller),
+                    txId: event.txHash,
+                    getTxBlock: async () => ({
+                        blockHeight: event.blockNumber,
+                        blockTime: await this.Chain.Blocks.getBlockTime(event.blockNumber)
+                    })
                 };
             case "spv_swap_vault::events::Claimed":
                 return {
                     type: base_1.SpvWithdrawalStateType.CLAIMED,
-                    txId: event.txHash,
+                    btcTxId: (0, Utils_1.bigNumberishToBuffer)(event.params.btc_tx_hash, 32).reverse().toString("hex"),
                     owner: (0, Utils_1.toHex)(event.params.owner),
                     vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
                     recipient: (0, Utils_1.toHex)(event.params.recipient),
                     claimer: (0, Utils_1.toHex)(event.params.caller),
-                    fronter: (0, Utils_1.toHex)(event.params.fronting_address)
+                    fronter: (0, Utils_1.toHex)(event.params.fronting_address),
+                    txId: event.txHash,
+                    getTxBlock: async () => ({
+                        blockHeight: event.blockNumber,
+                        blockTime: await this.Chain.Blocks.getBlockTime(event.blockNumber)
+                    })
                 };
             case "spv_swap_vault::events::Closed":
                 return {
                     type: base_1.SpvWithdrawalStateType.CLOSED,
-                    txId: event.txHash,
+                    btcTxId: (0, Utils_1.bigNumberishToBuffer)(event.params.btc_tx_hash, 32).reverse().toString("hex"),
                     owner: (0, Utils_1.toHex)(event.params.owner),
                     vaultId: (0, Utils_1.toBigInt)(event.params.vault_id),
-                    error: (0, Utils_1.bigNumberishToBuffer)(event.params.error).toString()
+                    error: (0, Utils_1.bigNumberishToBuffer)(event.params.error).toString(),
+                    txId: event.txHash,
+                    getTxBlock: async () => ({
+                        blockHeight: event.blockNumber,
+                        blockTime: await this.Chain.Blocks.getBlockTime(event.blockNumber)
+                    })
                 };
             default:
                 return null;
@@ -354,6 +376,21 @@ class StarknetSpvVaultContract extends StarknetContractBase_1.StarknetContractBa
         }, scStartBlockheight);
         return result;
     }
+    async getHistoricalWithdrawalStates(recipient, startBlockheight) {
+        const { height: latestBlockheight } = await this.Chain.getFinalizedBlock();
+        const withdrawals = {};
+        const eventTypes = ["spv_swap_vault::events::Fronted", "spv_swap_vault::events::Claimed"];
+        await this.Events.findInContractEventsForward(eventTypes, [null, null, null, null, recipient], async (_event) => {
+            const eventResult = this.parseWithdrawalEvent(_event);
+            if (eventResult == null || eventResult.type === base_1.SpvWithdrawalStateType.CLOSED)
+                return null;
+            withdrawals[eventResult.btcTxId] = eventResult;
+        }, startBlockheight);
+        return {
+            withdrawals,
+            latestBlockheight
+        };
+    }
     /**
      * @inheritDoc
      */

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

@@ -1,9 +1,10 @@
 import { ChainSwapType, IntermediaryReputationType, RelaySynchronizer, SignatureData, SwapCommitState, SwapContract, TransactionConfirmationOptions } from "@atomiqlabs/base";
 import { Buffer } from "buffer";
-import { EscrowManagerAbi } from "./EscrowManagerAbi";
+import { EscrowManagerAbi, EscrowManagerAbiType } from "./EscrowManagerAbi";
 import { StarknetContractBase } from "../contract/StarknetContractBase";
-import { StarknetTx } from "../chain/modules/StarknetTransactions";
+import { StarknetTraceCall, StarknetTx } from "../chain/modules/StarknetTransactions";
 import { StarknetSigner } from "../wallet/StarknetSigner";
+import { BigNumberish } from "starknet";
 import { StarknetChainInterface } from "../chain/StarknetChainInterface";
 import { StarknetBtcRelay } from "../btcrelay/StarknetBtcRelay";
 import { StarknetSwapData } from "./StarknetSwapData";
@@ -14,6 +15,7 @@ import { IClaimHandler } from "./handlers/claim/ClaimHandlers";
 import { StarknetSwapClaim } from "./modules/StarknetSwapClaim";
 import { IHandler } from "./handlers/IHandler";
 import { StarknetBtcStoredHeader } from "../btcrelay/headers/StarknetBtcStoredHeader";
+import { ExtractAbiFunctionNames } from "abi-wan-kanabi/dist/kanabi";
 /**
  * Starknet swap contract (escrow manager) contract representation handling PrTLC (on-chain) and HTLC (lightning)
  *  based swaps
@@ -59,6 +61,8 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
     };
     readonly timelockRefundHandler: IHandler<any, any>;
     readonly btcRelay: StarknetBtcRelay<any>;
+    protected readonly initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType>;
+    protected readonly initEntryPointSelector: bigint;
     /**
      * Constructs the swap contract (escrow manager)
      *
@@ -66,6 +70,7 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
      * @param btcRelay Btc relay light client contract
      * @param contractAddress Optional underlying contract address (default is used otherwise)
      * @param _handlerAddresses Optional handler addresses (defaults are used otherwise)
+     * @param contractDeploymentHeight The height at which this contract was deployed (default is used otherwise)
      */
     constructor(chainInterface: StarknetChainInterface, btcRelay: StarknetBtcRelay<any>, contractAddress?: string, _handlerAddresses?: {
         refund?: {
@@ -74,7 +79,7 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
         claim?: {
             [type in ChainSwapType]?: string;
         };
-    });
+    }, contractDeploymentHeight?: number);
     /**
      * @inheritDoc
      */
@@ -160,10 +165,37 @@ export declare class StarknetSwapContract extends StarknetContractBase<typeof Es
     }[]): Promise<{
         [p: string]: SwapCommitState;
     }>;
+    /**
+     * @inheritDoc
+     */
+    getHistoricalSwaps(signer: string, startBlockheight?: number): Promise<{
+        swaps: {
+            [escrowHash: string]: {
+                init?: {
+                    data: StarknetSwapData;
+                    getInitTxId: () => Promise<string>;
+                    getTxBlock: () => Promise<{
+                        blockTime: number;
+                        blockHeight: number;
+                    }>;
+                };
+                state: SwapCommitState;
+            };
+        };
+        latestBlockheight?: number;
+    }>;
     /**
      * @inheritDoc
      */
     createSwapData(type: ChainSwapType, offerer: string, claimer: string, token: string, amount: bigint, claimData: string, sequence: bigint, expiry: bigint, payIn: boolean, payOut: boolean, securityDeposit: bigint, claimerBounty: bigint, depositToken?: string): Promise<StarknetSwapData>;
+    /**
+     *
+     * @param call
+     * @param escrowHash
+     * @param claimHandler
+     * @private
+     */
+    findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData | null;
     /**
      *
      * @param address