@atomiqlabs/chain-solana 11.0.0 → 12.0.6

package/src/solana/swaps/SolanaSwapProgram.ts

@@ -1,6 +1,7 @@
-import {SolanaSwapData} from "./SolanaSwapData";
+import {SolanaSwapData, InitInstruction} from "./SolanaSwapData";
 import {IdlAccounts} from "@coral-xyz/anchor";
 import {
+    ParsedTransactionWithMeta,
     PublicKey,
 } from "@solana/web3.js";
 import {sha256} from "@noble/hashes/sha2";
@@ -36,11 +37,14 @@ import {SolanaSigner} from "../wallet/SolanaSigner";
 import {fromClaimHash, toBN, toClaimHash, toEscrowHash} from "../../utils/Utils";
 import {SolanaTokens} from "../chain/modules/SolanaTokens";
 import * as BN from "bn.js";
+import {ProgramEvent} from "../program/modules/SolanaProgramEvents";
 
 function toPublicKeyOrNull(str: string | null): PublicKey | null {
     return str==null ? null : new PublicKey(str);
 }
 
+const MAX_PARALLEL_COMMIT_STATUS_CHECKS = 5;
+
 export class SolanaSwapProgram
     extends SolanaProgramBase<SwapProgram>
     implements SwapContract<
@@ -269,21 +273,19 @@ export class SolanaSwapProgram
         }
 
         //Check if paid or what
-        const status: SwapNotCommitedState | SwapExpiredState | SwapPaidState = await this.Events.findInEvents(escrowStateKey, async (event, info) => {
+        const status: SwapNotCommitedState | SwapExpiredState | SwapPaidState = await this.Events.findInEvents(escrowStateKey, async (event, tx) => {
             if(event.name==="ClaimEvent") {
                 const paymentHash = Buffer.from(event.data.hash).toString("hex");
                 if(paymentHash!==data.paymentHash) return null;
                 if(!event.data.sequence.eq(data.sequence)) return null;
                 return {
                     type: SwapCommitStateType.PAID,
-                    getClaimTxId: () => Promise.resolve(info.signature),
+                    getClaimTxId: () => Promise.resolve(tx.transaction.signatures[0]),
                     getClaimResult: () => Promise.resolve(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") {
@@ -292,13 +294,11 @@ export class SolanaSwapProgram
                 if(!event.data.sequence.eq(data.sequence)) return null;
                 return {
                     type: isExpired ? SwapCommitStateType.EXPIRED : 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
+                    })
                 };
             }
         });
@@ -308,6 +308,26 @@ export class SolanaSwapProgram
         return {type: SwapCommitStateType.NOT_COMMITED};
     }
 
+    async getCommitStatuses(request: { signer: string; swapData: SolanaSwapData }[]): Promise<{
+        [p: string]: SwapCommitState
+    }> {
+        const result: {
+            [p: string]: SwapCommitState
+        } = {};
+        let promises: Promise<void>[] = [];
+        for(let {signer, swapData} of request) {
+            promises.push(this.getCommitStatus(signer, swapData).then(val => {
+                result[swapData.getEscrowHash()] = val;
+            }));
+            if(promises.length>=MAX_PARALLEL_COMMIT_STATUS_CHECKS) {
+                await Promise.all(promises);
+                promises = [];
+            }
+        }
+        await Promise.all(promises);
+        return result;
+    }
+
     /**
      * Checks the status of the specific payment hash
      *
@@ -358,6 +378,138 @@ export class SolanaSwapProgram
         return SolanaSwapData.fromEscrowState(account);
     }
 
+    async 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
+    }> {
+        let latestBlockheight: number;
+
+        const events: {event: ProgramEvent<SwapProgram>, tx: ParsedTransactionWithMeta}[] = [];
+
+        await this.Events.findInEvents(new PublicKey(signer), async (event, tx) => {
+            if(latestBlockheight==null) latestBlockheight = tx.slot;
+            events.push({event, tx});
+        }, undefined, undefined, startBlockheight);
+
+        const swapsOpened: {[escrowHash: string]: {
+            data: SolanaSwapData,
+            getInitTxId: () => Promise<string>,
+            getTxBlock: () => Promise<{
+                blockTime: number,
+                blockHeight: number
+            }>
+        }} = {};
+        const resultingSwaps: {
+            [escrowHash: string]: {
+                init?: {
+                    data: SolanaSwapData,
+                    getInitTxId: () => Promise<string>,
+                    getTxBlock: () => Promise<{
+                        blockTime: number,
+                        blockHeight: number
+                    }>
+                },
+                state: SwapCommitState
+            }
+        } = {};
+
+        events.reverse();
+        for(let {event, tx} of events) {
+            const txSignature = tx.transaction.signatures[0];
+            const paymentHash: string = Buffer.from(event.data.hash).toString("hex");
+            const escrowHash = toEscrowHash(paymentHash, event.data.sequence);
+
+            if(event.name==="InitializeEvent") {
+                //Parse swap data from initialize event
+                const txoHash: string = 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")
+                ) as InitInstruction;
+                if(initIx == null) {
+                    this.logger.warn(`getHistoricalSwaps(): Skipping tx ${txSignature} because cannot init instruction not found!`);
+                    continue;
+                }
+
+                swapsOpened[escrowHash] = {
+                    data: 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: SwapCommitStateType.PAID,
+                        getClaimTxId: () => Promise.resolve(txSignature),
+                        getClaimResult: () => Promise.resolve(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 ? SwapCommitStateType.EXPIRED : 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: SwapCommitStateType.REFUNDABLE}
+                  : {type: SwapCommitStateType.COMMITED}
+            }
+        }
+
+        return {
+            swaps: resultingSwaps,
+            latestBlockheight
+        }
+    }
+
     ////////////////////////////////////////////
     //// Swap data initializer
     createSwapData(
@@ -662,28 +814,28 @@ export class SolanaSwapProgram
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getCommitFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Init.getInitFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana fee of the commit transaction, without any deposits
      */
-    getRawCommitFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getRawCommitFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Init.getRawInitFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getRefundFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
 
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
+    getRawRefundFee(signer: string, swapData: SolanaSwapData, feeRate?: string): Promise<bigint> {
         return this.Refund.getRawRefundFee(swapData, feeRate);
     }
 

package/src/solana/wallet/SolanaSigner.ts

@@ -3,6 +3,7 @@ import {AbstractSigner} from "@atomiqlabs/base";
 import {PublicKey, Signer} from "@solana/web3.js";
 
 export class SolanaSigner implements AbstractSigner {
+    type = "AtomiqAbstractSigner" as const;
 
     wallet: Wallet;
     keypair?: Signer;