@atomiqlabs/chain-solana 12.0.0 → 12.0.7

package/dist/solana/chain/modules/SolanaEvents.d.ts

@@ -1,7 +1,8 @@
 import { SolanaModule } from "../SolanaModule";
-import { ConfirmedSignatureInfo, PublicKey } from "@solana/web3.js";
+import { ConfirmedSignatureInfo, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
 export declare class SolanaEvents extends SolanaModule {
     readonly LOG_FETCH_LIMIT = 500;
+    private usingHeliusTFA;
     /**
      * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
      *  the signatures before this signature
@@ -12,6 +13,43 @@ export declare class SolanaEvents extends SolanaModule {
      * @private
      */
     private getSignatures;
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    getTransactionsForAddress(account: PublicKey, options?: {
+        paginationToken?: string;
+        filters?: {
+            slot?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+            };
+            blockTime?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+                eq?: number;
+            };
+            signature?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+                eq?: number;
+            };
+            status?: "succeeded" | "failed" | "any";
+        };
+    }, commitment?: "finalized" | "confirmed" | "processed"): Promise<{
+        data: ParsedTransactionWithMeta[];
+        paginationToken?: string;
+    }>;
+    private _findInTxsTFA;
     /**
      * Runs a search backwards in time, processing transaction signatures for a specific topic public key
      *
@@ -20,6 +58,11 @@ export declare class SolanaEvents extends SolanaModule {
      *  was found, or null if the search should continue
      * @param abortSignal
      * @param logFetchLimit
+     * @param startBlockheight
      */
-    findInSignatures<T>(topicKey: PublicKey, processor: (signatures: ConfirmedSignatureInfo[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
+    private _findInSignatures;
+    findInSignatures<T>(topicKey: PublicKey, processor: (data: {
+        signatures?: ConfirmedSignatureInfo[];
+        txs?: ParsedTransactionWithMeta[];
+    }) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number, startBlockheight?: number): Promise<T>;
 }

package/dist/solana/chain/modules/SolanaEvents.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaEvents = void 0;
 const SolanaModule_1 = require("../SolanaModule");
+const web3_js_1 = require("@solana/web3.js");
 class SolanaEvents extends SolanaModule_1.SolanaModule {
     constructor() {
         super(...arguments);
         this.LOG_FETCH_LIMIT = 500;
+        this.usingHeliusTFA = "auto";
     }
     /**
      * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
@@ -29,6 +31,147 @@ class SolanaEvents extends SolanaModule_1.SolanaModule {
             }, "confirmed");
         }
     }
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    async getTransactionsForAddress(account, options, commitment) {
+        //Try to use getPriorityFeeEstimate api of Helius
+        const response = await this.connection._rpcRequest("getTransactionsForAddress", [
+            account.toString(),
+            {
+                ...options,
+                transactionDetails: "full",
+                sortOrder: "desc",
+                limit: 100,
+                commitment: commitment ?? "confirmed",
+                encoding: "jsonParsed",
+                maxSupportedTransactionVersion: 0
+            }
+        ]).catch(e => {
+            //Catching not supported errors
+            if (e.message != null && (e.message.includes("-32601") || e.message.includes("-32600") || e.message.includes("-32403"))) {
+                return {
+                    error: {
+                        code: -32601,
+                        message: e.message
+                    }
+                };
+            }
+            throw e;
+        });
+        if (response.error != null) {
+            //Catching not supported errors
+            if (response.error.code !== -32601 && response.error.code !== -32600 && response.error.code !== -32403)
+                throw new Error(response.error.message);
+            return null;
+        }
+        return {
+            data: response.result.data.map(val => {
+                return {
+                    ...val,
+                    meta: val.meta == null ? undefined : {
+                        //ParsedTransactionMeta
+                        ...val.meta,
+                        innerInstructions: val.meta.innerInstructions == null ? undefined : val.meta.innerInstructions.map(innerIx => ({
+                            //ParsedInnerInstruction
+                            ...innerIx,
+                            instructions: innerIx.instructions.map(ix => {
+                                if (ix.program != null && ix.programId != null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new web3_js_1.PublicKey(ix.programId)
+                                    };
+                                }
+                                else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new web3_js_1.PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new web3_js_1.PublicKey(pubkey))
+                                    };
+                                }
+                            })
+                        })),
+                        loadedAddresses: val.meta.loadedAddresses == null ? undefined : {
+                            writable: val.meta.loadedAddresses.writable.map(pubkey => new web3_js_1.PublicKey(pubkey)),
+                            readonly: val.meta.loadedAddresses.readonly.map(pubkey => new web3_js_1.PublicKey(pubkey)),
+                        }
+                    },
+                    transaction: {
+                        //ParsedTransaction
+                        ...val.transaction,
+                        message: {
+                            //ParsedMessage
+                            ...val.transaction.message,
+                            accountKeys: val.transaction.message.accountKeys.map(accountKey => ({
+                                //ParsedMessageAccount
+                                ...accountKey,
+                                pubkey: new web3_js_1.PublicKey(accountKey.pubkey)
+                            })),
+                            instructions: val.transaction.message.instructions.map(ix => {
+                                if (ix.program != null && ix.programId != null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new web3_js_1.PublicKey(ix.programId)
+                                    };
+                                }
+                                else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new web3_js_1.PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new web3_js_1.PublicKey(pubkey))
+                                    };
+                                }
+                            }),
+                            addressTableLookups: val.transaction.message.addressTableLookups == null ? undefined : val.transaction.message.addressTableLookups.map(addressTableLookup => ({
+                                //ParsedAddressTableLookup
+                                ...addressTableLookup,
+                                accountKey: new web3_js_1.PublicKey(addressTableLookup.accountKey)
+                            }))
+                        }
+                    }
+                };
+            }),
+            paginationToken: response.result.paginationToken
+        };
+    }
+    async _findInTxsTFA(topicKey, processor, abortSignal, startBlockheight) {
+        let paginationToken;
+        let txs = null;
+        while (txs == null || txs.length > 0) {
+            let filters = startBlockheight != null ? {
+                slot: { gte: startBlockheight }
+            } : {};
+            const tfaResult = await this.getTransactionsForAddress(topicKey, {
+                paginationToken,
+                filters: {
+                    ...filters,
+                    status: "succeeded"
+                }
+            }, "confirmed");
+            if (tfaResult == null) {
+                //Not supported
+                return undefined;
+            }
+            txs = tfaResult.data;
+            paginationToken = tfaResult.paginationToken;
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            const result = await processor({ txs });
+            if (result != null)
+                return result;
+            if (paginationToken == null)
+                break;
+        }
+        return null;
+    }
     /**
      * Runs a search backwards in time, processing transaction signatures for a specific topic public key
      *
@@ -37,16 +180,24 @@ class SolanaEvents extends SolanaModule_1.SolanaModule {
      *  was found, or null if the search should continue
      * @param abortSignal
      * @param logFetchLimit
+     * @param startBlockheight
      */
-    async findInSignatures(topicKey, processor, abortSignal, logFetchLimit) {
+    async _findInSignatures(topicKey, processor, abortSignal, logFetchLimit, startBlockheight) {
         if (logFetchLimit == null || logFetchLimit > this.LOG_FETCH_LIMIT)
             logFetchLimit = this.LOG_FETCH_LIMIT;
         let signatures = null;
         while (signatures == null || signatures.length > 0) {
             signatures = await this.getSignatures(topicKey, logFetchLimit, signatures != null ? signatures[signatures.length - 1].signature : null);
+            if (startBlockheight != null) {
+                const endIndex = signatures.findIndex(val => val.slot < startBlockheight);
+                if (endIndex === 0)
+                    return null;
+                if (endIndex !== -1)
+                    signatures = signatures.slice(0, endIndex - 1);
+            }
             if (abortSignal != null)
                 abortSignal.throwIfAborted();
-            const result = await processor(signatures);
+            const result = await processor({ signatures });
             if (result != null)
                 return result;
             if (signatures.length < logFetchLimit)
@@ -54,5 +205,19 @@ class SolanaEvents extends SolanaModule_1.SolanaModule {
         }
         return null;
     }
+    async findInSignatures(topicKey, processor, abortSignal, logFetchLimit, startBlockheight) {
+        if (this.usingHeliusTFA !== "no") {
+            //Attempt to use Helius's gTFA
+            const result = await this._findInTxsTFA(topicKey, processor, abortSignal, startBlockheight);
+            if (result !== undefined)
+                return result;
+            //Not supported
+            if (this.usingHeliusTFA === "yes")
+                throw new Error("Helius gTFA is not supported with current provider!");
+            //If set to auto, we can manually set to "no"
+            this.usingHeliusTFA = "no";
+        }
+        return await this._findInSignatures(topicKey, processor, abortSignal, logFetchLimit, startBlockheight);
+    }
 }
 exports.SolanaEvents = SolanaEvents;

package/dist/solana/events/SolanaChainEventsBrowser.d.ts

@@ -3,7 +3,7 @@ import { SolanaSwapData } from "../swaps/SolanaSwapData";
 import { IdlEvents } from "@coral-xyz/anchor";
 import { SolanaSwapProgram } from "../swaps/SolanaSwapProgram";
 import { Connection } from "@solana/web3.js";
-import { InstructionWithAccounts, ProgramEvent, SingleInstructionWithAccounts } from "../program/modules/SolanaProgramEvents";
+import { InstructionWithAccounts, ProgramEvent } from "../program/modules/SolanaProgramEvents";
 import { SwapProgram } from "../swaps/programTypes";
 export type EventObject = {
     events: ProgramEvent<SwapProgram>[];
@@ -11,7 +11,6 @@ export type EventObject = {
     blockTime: number;
     signature: string;
 };
-export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3], SwapProgram>;
 /**
  * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
  *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
@@ -36,15 +35,6 @@ export declare class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapD
      * @returns {Promise<InstructionWithAccounts<SwapProgram>[]>} array of parsed instructions
      */
     private getTransactionInstructions;
-    /**
-     * Converts initialize instruction data into {SolanaSwapData}
-     *
-     * @param initIx
-     * @param txoHash
-     * @private
-     * @returns {SolanaSwapData} converted and parsed swap data
-     */
-    private instructionToSwapData;
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *

package/dist/solana/events/SolanaChainEventsBrowser.js

@@ -4,8 +4,6 @@ exports.SolanaChainEventsBrowser = void 0;
 const base_1 = require("@atomiqlabs/base");
 const SolanaSwapData_1 = require("../swaps/SolanaSwapData");
 const Utils_1 = require("../../utils/Utils");
-const web3_js_1 = require("@solana/web3.js");
-const BN = require("bn.js");
 const SwapTypeEnum_1 = require("../swaps/SwapTypeEnum");
 const buffer_1 = require("buffer");
 /**
@@ -43,26 +41,6 @@ class SolanaChainEventsBrowser {
             return null;
         return this.solanaSwapProgram.Events.decodeInstructions(transaction.transaction.message);
     }
-    /**
-     * Converts initialize instruction data into {SolanaSwapData}
-     *
-     * @param initIx
-     * @param txoHash
-     * @private
-     * @returns {SolanaSwapData} converted and parsed swap data
-     */
-    instructionToSwapData(initIx, txoHash) {
-        const paymentHash = buffer_1.Buffer.from(initIx.data.swapData.hash);
-        let securityDeposit = new BN(0);
-        let claimerBounty = new BN(0);
-        let payIn = true;
-        if (initIx.name === "offererInitialize") {
-            payIn = false;
-            securityDeposit = initIx.data.securityDeposit;
-            claimerBounty = initIx.data.claimerBounty;
-        }
-        return new SolanaSwapData_1.SolanaSwapData(initIx.accounts.offerer, initIx.accounts.claimer, initIx.accounts.mint, initIx.data.swapData.amount, paymentHash.toString("hex"), initIx.data.swapData.sequence, initIx.data.swapData.expiry, initIx.data.swapData.nonce, initIx.data.swapData.confirmations, initIx.data.swapData.payOut, SwapTypeEnum_1.SwapTypeEnum.toNumber(initIx.data.swapData.kind), payIn, initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : web3_js_1.PublicKey.default, initIx.data.swapData.payOut ? initIx.accounts.claimerAta : web3_js_1.PublicKey.default, securityDeposit, claimerBounty, txoHash);
-    }
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *
@@ -80,7 +58,7 @@ class SolanaChainEventsBrowser {
             const initIx = eventObject.instructions.find(ix => ix != null && (ix.name === "offererInitializePayIn" || ix.name === "offererInitialize"));
             if (initIx == null)
                 return null;
-            return this.instructionToSwapData(initIx, txoHash);
+            return SolanaSwapData_1.SolanaSwapData.fromInstruction(initIx, txoHash);
         };
     }
     parseInitializeEvent(data, eventObject) {

package/dist/solana/program/modules/SolanaProgramEvents.d.ts

@@ -1,7 +1,7 @@
 import { SolanaEvents } from "../../chain/modules/SolanaEvents";
 import { DecodeType, Event, Idl, IdlTypes } from "@coral-xyz/anchor";
 import { IdlField, IdlInstruction } from "@coral-xyz/anchor/dist/cjs/idl";
-import { ConfirmedSignatureInfo, ParsedMessage, PublicKey } from "@solana/web3.js";
+import { ParsedMessage, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
 import { SolanaProgramBase } from "../SolanaProgramBase";
 import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
 type DecodedFieldOrNull<D, Defined> = D extends IdlField ? DecodeType<D["type"], Defined> : unknown;
@@ -25,13 +25,6 @@ export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
     private readonly program;
     private readonly nameMappedInstructions;
     constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>);
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    private getEvents;
     /**
      * Runs a search backwards in time, processing the events for a specific topic public key
      *
@@ -40,8 +33,9 @@ export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
      *  if the search should continue
      * @param abortSignal
      * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
+     * @param startBlockheight
      */
-    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>, abortSignal?: AbortSignal, logBatchSize?: number): Promise<T>;
+    findInEvents<T>(topicKey: PublicKey, processor: (event: ProgramEvent<IDL>, tx: ParsedTransactionWithMeta) => Promise<T>, abortSignal?: AbortSignal, logBatchSize?: number, startBlockheight?: number): Promise<T>;
     /**
      * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array
      *  for every instruction that doesn't correspond to this program (as those are impossible to parse)

package/dist/solana/program/modules/SolanaProgramEvents.js

@@ -14,23 +14,6 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
             this.nameMappedInstructions[ix.name] = ix;
         }
     }
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    async getEvents(signature) {
-        const tx = await this.connection.getTransaction(signature, {
-            commitment: "confirmed",
-            maxSupportedTransactionVersion: 0
-        });
-        if (tx.meta.err)
-            return [];
-        const events = this.parseLogs(tx.meta.logMessages);
-        events.reverse();
-        return events;
-    }
     /**
      * Runs a search backwards in time, processing the events for a specific topic public key
      *
@@ -39,19 +22,47 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
      *  if the search should continue
      * @param abortSignal
      * @param logBatchSize how many signatures should be fetched in one getSignaturesForAddress call
+     * @param startBlockheight
      */
-    findInEvents(topicKey, processor, abortSignal, logBatchSize) {
-        return this.findInSignatures(topicKey, async (signatures) => {
-            for (let data of signatures) {
-                for (let event of await this.getEvents(data.signature)) {
-                    if (abortSignal != null)
-                        abortSignal.throwIfAborted();
-                    const result = await processor(event, data);
-                    if (result != null)
-                        return result;
+    findInEvents(topicKey, processor, abortSignal, logBatchSize, startBlockheight) {
+        return this.findInSignatures(topicKey, async (data) => {
+            if (data.signatures) {
+                for (let info of data.signatures) {
+                    if (info.err == null)
+                        continue;
+                    const tx = await this.connection.getParsedTransaction(info.signature, {
+                        commitment: "confirmed",
+                        maxSupportedTransactionVersion: 0
+                    });
+                    if (tx.meta.err)
+                        continue;
+                    const events = this.parseLogs(tx.meta.logMessages);
+                    events.reverse();
+                    for (let event of events) {
+                        if (abortSignal != null)
+                            abortSignal.throwIfAborted();
+                        const result = await processor(event, tx);
+                        if (result != null)
+                            return result;
+                    }
+                }
+            }
+            else {
+                for (let tx of data.txs) {
+                    if (tx.meta.err)
+                        continue;
+                    const events = this.parseLogs(tx.meta.logMessages);
+                    events.reverse();
+                    for (let event of events) {
+                        if (abortSignal != null)
+                            abortSignal.throwIfAborted();
+                        const result = await processor(event, tx);
+                        if (result != null)
+                            return result;
+                    }
                 }
             }
-        }, abortSignal, logBatchSize);
+        }, abortSignal, logBatchSize, startBlockheight);
     }
     /**
      * Decodes the instructions for this program from the transaction, leaves null in the returned instructions array

package/dist/solana/swaps/SolanaSwapData.d.ts

@@ -1,8 +1,10 @@
 import { PublicKey } from "@solana/web3.js";
 import * as BN from "bn.js";
-import { SwapData, ChainSwapType } from "@atomiqlabs/base";
+import { ChainSwapType, SwapData } from "@atomiqlabs/base";
 import { SwapProgram } from "./programTypes";
 import { IdlAccounts, IdlTypes } from "@coral-xyz/anchor";
+import { SingleInstructionWithAccounts } from "../program/modules/SolanaProgramEvents";
+export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3], SwapProgram>;
 export declare class SolanaSwapData extends SwapData {
     offerer: PublicKey;
     claimer: PublicKey;
@@ -41,6 +43,7 @@ export declare class SolanaSwapData extends SwapData {
     getEscrowHash(): string;
     getSequence(): bigint;
     getTxoHashHint(): string;
+    getHTLCHashHint(): string;
     getExtraData(): string;
     setExtraData(txoHash: string): void;
     getSecurityDeposit(): bigint;
@@ -49,6 +52,15 @@ export declare class SolanaSwapData extends SwapData {
     toSwapDataStruct(): IdlTypes<SwapProgram>["SwapData"];
     correctPDA(account: IdlAccounts<SwapProgram>["escrowState"]): boolean;
     equals(other: SolanaSwapData): boolean;
+    /**
+     * Converts initialize instruction data into {SolanaSwapData}
+     *
+     * @param initIx
+     * @param txoHash
+     * @private
+     * @returns {SolanaSwapData} converted and parsed swap data
+     */
+    static fromInstruction(initIx: InitInstruction, txoHash: string): SolanaSwapData;
     static fromEscrowState(account: IdlAccounts<SwapProgram>["escrowState"]): SolanaSwapData;
     static typeToKind(type: ChainSwapType): number;
     static kindToType(value: number): ChainSwapType;

package/dist/solana/swaps/SolanaSwapData.js

@@ -135,6 +135,11 @@ class SolanaSwapData extends base_1.SwapData {
             return null; //Txo hash opt-out flag
         return this.txoHash;
     }
+    getHTLCHashHint() {
+        if (this.getType() === base_1.ChainSwapType.HTLC)
+            return this.paymentHash;
+        return null;
+    }
     getExtraData() {
         return this.txoHash;
     }
@@ -213,6 +218,26 @@ class SolanaSwapData extends base_1.SwapData {
             other.claimerBounty.eq(this.claimerBounty) &&
             other.token.equals(this.token);
     }
+    /**
+     * Converts initialize instruction data into {SolanaSwapData}
+     *
+     * @param initIx
+     * @param txoHash
+     * @private
+     * @returns {SolanaSwapData} converted and parsed swap data
+     */
+    static fromInstruction(initIx, txoHash) {
+        const paymentHash = buffer_1.Buffer.from(initIx.data.swapData.hash);
+        let securityDeposit = new BN(0);
+        let claimerBounty = new BN(0);
+        let payIn = true;
+        if (initIx.name === "offererInitialize") {
+            payIn = false;
+            securityDeposit = initIx.data.securityDeposit;
+            claimerBounty = initIx.data.claimerBounty;
+        }
+        return new SolanaSwapData(initIx.accounts.offerer, initIx.accounts.claimer, initIx.accounts.mint, initIx.data.swapData.amount, paymentHash.toString("hex"), initIx.data.swapData.sequence, initIx.data.swapData.expiry, initIx.data.swapData.nonce, initIx.data.swapData.confirmations, initIx.data.swapData.payOut, SwapTypeEnum_1.SwapTypeEnum.toNumber(initIx.data.swapData.kind), payIn, initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : web3_js_1.PublicKey.default, initIx.data.swapData.payOut ? initIx.accounts.claimerAta : web3_js_1.PublicKey.default, securityDeposit, claimerBounty, txoHash);
+    }
     static fromEscrowState(account) {
         const data = account.data;
         return new SolanaSwapData(account.offerer, account.claimer, account.mint, data.amount, buffer_1.Buffer.from(data.hash).toString("hex"), data.sequence, data.expiry, data.nonce, data.confirmations, data.payOut, SwapTypeEnum_1.SwapTypeEnum.toNumber(data.kind), data.payIn, account.offererAta, account.claimerAta, account.securityDeposit, account.claimerBounty, null);

package/dist/solana/swaps/SolanaSwapProgram.d.ts

@@ -137,6 +137,22 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
      * @param claimHashHex
      */
     getCommitedData(claimHashHex: string): Promise<SolanaSwapData>;
+    getHistoricalSwaps(signer: string, startBlockheight?: number): Promise<{
+        swaps: {
+            [escrowHash: string]: {
+                init?: {
+                    data: SolanaSwapData;
+                    getInitTxId: () => Promise<string>;
+                    getTxBlock: () => Promise<{
+                        blockTime: number;
+                        blockHeight: number;
+                    }>;
+                };
+                state: SwapCommitState;
+            };
+        };
+        latestBlockheight: number;
+    }>;
     createSwapData(type: ChainSwapType, offerer: string, claimer: string, token: string, amount: bigint, claimHash: string, sequence: bigint, expiry: bigint, payIn: boolean, payOut: boolean, securityDeposit: bigint, claimerBounty: bigint, depositToken?: string): Promise<SolanaSwapData>;
     getBalance(signer: string, tokenAddress: string, inContract: boolean): Promise<bigint>;
     getIntermediaryData(address: string, token: string): Promise<{