@atomiqlabs/chain-solana 12.0.0 → 12.0.7

package/dist/solana/swaps/SolanaSwapProgram.js

@@ -195,7 +195,7 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
             return { type: base_1.SwapCommitStateType.NOT_COMMITED };
         }
         //Check if paid or what
-        const status = await this.Events.findInEvents(escrowStateKey, async (event, info) => {
+        const status = await this.Events.findInEvents(escrowStateKey, async (event, tx) => {
             if (event.name === "ClaimEvent") {
                 const paymentHash = buffer_1.Buffer.from(event.data.hash).toString("hex");
                 if (paymentHash !== data.paymentHash)
@@ -204,14 +204,12 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
                     return null;
                 return {
                     type: base_1.SwapCommitStateType.PAID,
-                    getClaimTxId: () => Promise.resolve(info.signature),
+                    getClaimTxId: () => Promise.resolve(tx.transaction.signatures[0]),
                     getClaimResult: () => Promise.resolve(buffer_1.Buffer.from(event.data.secret).toString("hex")),
-                    getTxBlock: async () => {
-                        return {
-                            blockHeight: (await this.Chain.Blocks.getParsedBlock(info.slot)).blockHeight,
-                            blockTime: info.blockTime
-                        };
-                    }
+                    getTxBlock: () => Promise.resolve({
+                        blockHeight: tx.slot,
+                        blockTime: tx.blockTime
+                    })
                 };
             }
             if (event.name === "RefundEvent") {
@@ -222,13 +220,11 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
                     return null;
                 return {
                     type: isExpired ? base_1.SwapCommitStateType.EXPIRED : base_1.SwapCommitStateType.NOT_COMMITED,
-                    getRefundTxId: () => Promise.resolve(info.signature),
-                    getTxBlock: async () => {
-                        return {
-                            blockHeight: (await this.Chain.Blocks.getParsedBlock(info.slot)).blockHeight,
-                            blockTime: info.blockTime
-                        };
-                    }
+                    getRefundTxId: () => Promise.resolve(tx.transaction.signatures[0]),
+                    getTxBlock: () => Promise.resolve({
+                        blockHeight: tx.slot,
+                        blockTime: tx.blockTime
+                    })
                 };
             }
         });
@@ -299,6 +295,91 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
             return null;
         return SolanaSwapData_1.SolanaSwapData.fromEscrowState(account);
     }
+    async getHistoricalSwaps(signer, startBlockheight) {
+        let latestBlockheight;
+        const events = [];
+        await this.Events.findInEvents(new web3_js_1.PublicKey(signer), async (event, tx) => {
+            if (latestBlockheight == null)
+                latestBlockheight = tx.slot;
+            events.push({ event, tx });
+        }, undefined, undefined, startBlockheight);
+        const swapsOpened = {};
+        const resultingSwaps = {};
+        events.reverse();
+        for (let { event, tx } of events) {
+            const txSignature = tx.transaction.signatures[0];
+            const paymentHash = buffer_1.Buffer.from(event.data.hash).toString("hex");
+            const escrowHash = (0, Utils_1.toEscrowHash)(paymentHash, event.data.sequence);
+            if (event.name === "InitializeEvent") {
+                //Parse swap data from initialize event
+                const txoHash = buffer_1.Buffer.from(event.data.txoHash).toString("hex");
+                const instructions = this.Events.decodeInstructions(tx.transaction.message);
+                if (instructions == null) {
+                    this.logger.warn(`getHistoricalSwaps(): Skipping tx ${txSignature} because cannot parse instructions!`);
+                    continue;
+                }
+                const initIx = instructions.find(ix => ix != null && (ix.name === "offererInitializePayIn" || ix.name === "offererInitialize"));
+                if (initIx == null) {
+                    this.logger.warn(`getHistoricalSwaps(): Skipping tx ${txSignature} because cannot init instruction not found!`);
+                    continue;
+                }
+                swapsOpened[escrowHash] = {
+                    data: SolanaSwapData_1.SolanaSwapData.fromInstruction(initIx, txoHash),
+                    getInitTxId: () => Promise.resolve(txSignature),
+                    getTxBlock: () => Promise.resolve({
+                        blockHeight: tx.slot,
+                        blockTime: tx.blockTime
+                    })
+                };
+            }
+            if (event.name === "ClaimEvent") {
+                const foundSwapData = swapsOpened[escrowHash];
+                delete swapsOpened[escrowHash];
+                resultingSwaps[escrowHash] = {
+                    init: foundSwapData,
+                    state: {
+                        type: base_1.SwapCommitStateType.PAID,
+                        getClaimTxId: () => Promise.resolve(txSignature),
+                        getClaimResult: () => Promise.resolve(buffer_1.Buffer.from(event.data.secret).toString("hex")),
+                        getTxBlock: () => Promise.resolve({
+                            blockHeight: tx.slot,
+                            blockTime: tx.blockTime
+                        })
+                    }
+                };
+            }
+            if (event.name === "RefundEvent") {
+                const foundSwapData = swapsOpened[escrowHash];
+                delete swapsOpened[escrowHash];
+                const isExpired = foundSwapData != null && await this.isExpired(signer, foundSwapData.data);
+                resultingSwaps[escrowHash] = {
+                    init: foundSwapData,
+                    state: {
+                        type: isExpired ? base_1.SwapCommitStateType.EXPIRED : base_1.SwapCommitStateType.NOT_COMMITED,
+                        getRefundTxId: () => Promise.resolve(txSignature),
+                        getTxBlock: () => Promise.resolve({
+                            blockHeight: tx.slot,
+                            blockTime: tx.blockTime
+                        })
+                    }
+                };
+            }
+        }
+        for (let escrowHash in swapsOpened) {
+            const foundSwapData = swapsOpened[escrowHash];
+            const isExpired = await this.isExpired(signer, foundSwapData.data);
+            resultingSwaps[escrowHash] = {
+                init: foundSwapData,
+                state: foundSwapData.data.isOfferer(signer) && isExpired
+                    ? { type: base_1.SwapCommitStateType.REFUNDABLE }
+                    : { type: base_1.SwapCommitStateType.COMMITED }
+            };
+        }
+        return {
+            swaps: resultingSwaps,
+            latestBlockheight
+        };
+    }
     ////////////////////////////////////////////
     //// Swap data initializer
     createSwapData(type, offerer, claimer, token, amount, claimHash, sequence, expiry, payIn, payOut, securityDeposit, claimerBounty, depositToken) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-solana",
-  "version": "12.0.0",
+  "version": "12.0.7",
   "description": "Solana specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^12.0.0",
+    "@atomiqlabs/base": "^12.0.3",
     "@noble/hashes": "^1.7.1",
     "bn.js": "5.2.1",
     "bs58": "4.0.1",

package/src/solana/chain/modules/SolanaEvents.ts

@@ -1,10 +1,14 @@
 import {SolanaModule} from "../SolanaModule";
-import {ConfirmedSignatureInfo, PublicKey} from "@solana/web3.js";
+import {ConfirmedSignatureInfo, ParsedTransactionWithMeta, PublicKey} from "@solana/web3.js";
+import {sign} from "tweetnacl";
+import {ProgramEvent} from "../../program/modules/SolanaProgramEvents";
 
 export class SolanaEvents extends SolanaModule {
 
     public readonly LOG_FETCH_LIMIT = 500;
 
+    private usingHeliusTFA: "yes" | "no" | "auto" = "auto";
+
     /**
      * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
      *  the signatures before this signature
@@ -27,6 +31,169 @@ export class SolanaEvents extends SolanaModule {
         }
     }
 
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    async 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
+    }> {
+        //Try to use getPriorityFeeEstimate api of Helius
+        const response = await (this.connection as any)._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, //slot, blockTime, version
+                    meta: val.meta==null ? undefined : {
+                        //ParsedTransactionMeta
+                        ...val.meta,
+                        innerInstructions: val.meta.innerInstructions==null ? undefined : val.meta.innerInstructions.map(innerIx => ({
+                            //ParsedInnerInstruction
+                            ...innerIx, //index
+                            instructions: innerIx.instructions.map(ix => {
+                                if(ix.program!=null && ix.programId!=null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new PublicKey(ix.programId)
+                                    }
+                                } else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new PublicKey(pubkey))
+                                    }
+                                }
+                            })
+                        })),
+                        loadedAddresses: val.meta.loadedAddresses==null ? undefined : {
+                            writable: val.meta.loadedAddresses.writable.map(pubkey => new PublicKey(pubkey)),
+                            readonly: val.meta.loadedAddresses.readonly.map(pubkey => new PublicKey(pubkey)),
+                        }
+                    },
+                    transaction: {
+                        //ParsedTransaction
+                        ...val.transaction, //signatures
+                        message: {
+                            //ParsedMessage
+                            ...val.transaction.message, //recentBlockhash
+                            accountKeys: val.transaction.message.accountKeys.map(accountKey => ({
+                                //ParsedMessageAccount
+                                ...accountKey,
+                                pubkey: new PublicKey(accountKey.pubkey)
+                            })),
+                            instructions: val.transaction.message.instructions.map(ix => {
+                                if(ix.program!=null && ix.programId!=null) {
+                                    return {
+                                        //ParsedInstruction
+                                        ...ix,
+                                        programId: new PublicKey(ix.programId)
+                                    }
+                                } else {
+                                    return {
+                                        //PartiallyDecodedInstruction
+                                        data: ix.data,
+                                        programId: new PublicKey(ix.programId),
+                                        accounts: ix.accounts.map(pubkey => new PublicKey(pubkey))
+                                    }
+                                }
+                            }),
+                            addressTableLookups: val.transaction.message.addressTableLookups==null ? undefined : val.transaction.message.addressTableLookups.map(addressTableLookup => ({
+                                //ParsedAddressTableLookup
+                                ...addressTableLookup,
+                                accountKey: new PublicKey(addressTableLookup.accountKey)
+                            }))
+                        }
+                    }
+                }
+            }),
+            paginationToken: response.result.paginationToken
+        };
+    }
+
+    private async _findInTxsTFA<T>(
+      topicKey: PublicKey,
+      processor: (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => Promise<T>,
+      abortSignal?: AbortSignal,
+      startBlockheight?: number
+    ): Promise<T> {
+        let paginationToken: string;
+        let txs: ParsedTransactionWithMeta[] = 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: T = 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
      *
@@ -35,23 +202,50 @@ export class SolanaEvents extends SolanaModule {
      *  was found, or null if the search should continue
      * @param abortSignal
      * @param logFetchLimit
+     * @param startBlockheight
      */
-    public async findInSignatures<T>(
+    private async _findInSignatures<T>(
         topicKey: PublicKey,
-        processor: (signatures: ConfirmedSignatureInfo[]) => Promise<T>,
+        processor: (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => Promise<T>,
         abortSignal?: AbortSignal,
-        logFetchLimit?: number
+        logFetchLimit?: number,
+        startBlockheight?: number
     ): Promise<T> {
         if(logFetchLimit==null || logFetchLimit>this.LOG_FETCH_LIMIT) logFetchLimit = this.LOG_FETCH_LIMIT;
         let signatures: ConfirmedSignatureInfo[] = 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: T = await processor(signatures);
+            const result: T = await processor({signatures});
             if(result!=null) return result;
             if(signatures.length<logFetchLimit) break;
         }
         return null;
     }
 
+    public async findInSignatures<T>(
+        topicKey: PublicKey,
+        processor: (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => Promise<T>,
+        abortSignal?: AbortSignal,
+        logFetchLimit?: number,
+        startBlockheight?: number
+    ) {
+        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);
+    }
+
 }

package/src/solana/events/SolanaChainEventsBrowser.ts

@@ -1,18 +1,16 @@
 import {ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SwapEvent} from "@atomiqlabs/base";
-import {SolanaSwapData} from "../swaps/SolanaSwapData";
+import {InitInstruction, SolanaSwapData} from "../swaps/SolanaSwapData";
 import {IdlEvents} from "@coral-xyz/anchor";
 import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
 import {
     getLogger,
     onceAsync, toEscrowHash, tryWithRetries
 } from "../../utils/Utils";
-import {Connection, ParsedTransactionWithMeta, PublicKey} from "@solana/web3.js";
-import * as BN from "bn.js";
+import {Connection, ParsedTransactionWithMeta} from "@solana/web3.js";
 import {SwapTypeEnum} from "../swaps/SwapTypeEnum";
 import {
     InstructionWithAccounts,
-    ProgramEvent,
-    SingleInstructionWithAccounts
+    ProgramEvent
 } from "../program/modules/SolanaProgramEvents";
 import {SwapProgram} from "../swaps/programTypes";
 import {Buffer} from "buffer";
@@ -24,8 +22,6 @@ export type EventObject = {
     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
@@ -64,49 +60,6 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
         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
-     */
-    private instructionToSwapData(
-        initIx: InitInstruction,
-        txoHash: string
-    ): SolanaSwapData {
-        const paymentHash: Buffer = Buffer.from(initIx.data.swapData.hash);
-        let securityDeposit: BN = new BN(0);
-        let claimerBounty: BN = new BN(0);
-        let payIn: boolean = 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.toNumber(initIx.data.swapData.kind),
-            payIn,
-            initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : PublicKey.default,
-            initIx.data.swapData.payOut ? initIx.accounts.claimerAta : PublicKey.default,
-            securityDeposit,
-            claimerBounty,
-            txoHash
-        );
-    }
-
     /**
      * Returns async getter for fetching on-demand initialize event swap data
      *
@@ -125,7 +78,7 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
             ) as InitInstruction;
             if(initIx == null) return null;
 
-            return this.instructionToSwapData(initIx, txoHash);
+            return SolanaSwapData.fromInstruction(initIx, txoHash);
         }
     }
 

package/src/solana/program/modules/SolanaProgramEvents.ts

@@ -1,7 +1,13 @@
 import {SolanaEvents} from "../../chain/modules/SolanaEvents";
 import {BorshCoder, DecodeType, Event, EventParser, Idl, IdlTypes, Instruction} from "@coral-xyz/anchor";
 import {IdlField, IdlInstruction} from "@coral-xyz/anchor/dist/cjs/idl";
-import {ConfirmedSignatureInfo, ParsedMessage, PartiallyDecodedInstruction, PublicKey} from "@solana/web3.js";
+import {
+    ConfirmedSignatureInfo,
+    ParsedMessage, ParsedTransactionWithMeta,
+    PartiallyDecodedInstruction,
+    PublicKey,
+    VersionedTransaction, VersionedTransactionResponse
+} from "@solana/web3.js";
 import {SolanaProgramBase} from "../SolanaProgramBase";
 import {SolanaChainInterface} from "../../chain/SolanaChainInterface";
 
@@ -40,25 +46,6 @@ export class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
         }
     }
 
-    /**
-     * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
-     *
-     * @param signature
-     * @private
-     */
-    private async getEvents(signature: string): Promise<ProgramEvent<IDL>[]> {
-        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
      *
@@ -67,22 +54,50 @@ export 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
      */
     public findInEvents<T>(
         topicKey: PublicKey,
-        processor: (event: ProgramEvent<IDL>, info: ConfirmedSignatureInfo) => Promise<T>,
+        processor: (event: ProgramEvent<IDL>, tx: ParsedTransactionWithMeta) => Promise<T>,
         abortSignal?: AbortSignal,
-        logBatchSize?: number
+        logBatchSize?: number,
+        startBlockheight?: number
     ): Promise<T> {
-        return this.findInSignatures<T>(topicKey, async (signatures: ConfirmedSignatureInfo[]) => {
-            for(let data of signatures) {
-                for(let event of await this.getEvents(data.signature)) {
-                    if(abortSignal!=null) abortSignal.throwIfAborted();
-                    const result: T = await processor(event, data);
-                    if(result!=null) return result;
+        return this.findInSignatures<T>(topicKey, async (data: {signatures?: ConfirmedSignatureInfo[], txs?: ParsedTransactionWithMeta[]}) => {
+            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: T = 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: T = await processor(event, tx);
+                        if(result!=null) return result;
+                    }
                 }
             }
-        }, abortSignal, logBatchSize);
+        }, abortSignal, logBatchSize, startBlockheight);
     }
 
     /**

package/src/solana/swaps/SolanaSwapData.ts

@@ -1,6 +1,6 @@
 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 {SwapTypeEnum} from "./SwapTypeEnum";
@@ -8,6 +8,9 @@ import {Buffer} from "buffer";
 import {getAssociatedTokenAddressSync} from "@solana/spl-token";
 import {toBigInt, toClaimHash, toEscrowHash} from "../../utils/Utils";
 import {SolanaTokens} from "../chain/modules/SolanaTokens";
+import {SingleInstructionWithAccounts} from "../program/modules/SolanaProgramEvents";
+
+export type InitInstruction = SingleInstructionWithAccounts<SwapProgram["instructions"][2 | 3], SwapProgram>;
 
 const EXPIRY_BLOCKHEIGHT_THRESHOLD = new BN("1000000000");
 
@@ -217,6 +220,11 @@ export class SolanaSwapData extends SwapData {
         return this.txoHash;
     }
 
+    getHTLCHashHint(): string {
+        if(this.getType()===ChainSwapType.HTLC) return this.paymentHash;
+        return null;
+    }
+
     getExtraData(): string {
         return this.txoHash;
     }
@@ -300,6 +308,49 @@ export class SolanaSwapData extends SwapData {
             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: InitInstruction,
+        txoHash: string
+    ): SolanaSwapData {
+        const paymentHash: Buffer = Buffer.from(initIx.data.swapData.hash);
+        let securityDeposit: BN = new BN(0);
+        let claimerBounty: BN = new BN(0);
+        let payIn: boolean = 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.toNumber(initIx.data.swapData.kind),
+            payIn,
+            initIx.name === "offererInitializePayIn" ? initIx.accounts.offererAta : PublicKey.default,
+            initIx.data.swapData.payOut ? initIx.accounts.claimerAta : PublicKey.default,
+            securityDeposit,
+            claimerBounty,
+            txoHash
+        );
+    }
+
     static fromEscrowState(account: IdlAccounts<SwapProgram>["escrowState"]) {
         const data: IdlTypes<SwapProgram>["SwapData"] = account.data;