@atomiqlabs/chain-solana 11.0.0 → 12.0.6

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

@@ -118,6 +118,12 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
      * @param data
      */
     getCommitStatus(signer: string, data: SolanaSwapData): Promise<SwapCommitState>;
+    getCommitStatuses(request: {
+        signer: string;
+        swapData: SolanaSwapData;
+    }[]): Promise<{
+        [p: string]: SwapCommitState;
+    }>;
     /**
      * Checks the status of the specific payment hash
      *
@@ -131,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<{
@@ -185,18 +207,18 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     /**
      * 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>;
     /**
      * 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>;
     /**
      * 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>;
     /**
      * 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>;
     getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
 }

package/dist/solana/swaps/SolanaSwapProgram.js

@@ -20,6 +20,7 @@ const BN = require("bn.js");
 function toPublicKeyOrNull(str) {
     return str == null ? null : new web3_js_1.PublicKey(str);
 }
+const MAX_PARALLEL_COMMIT_STATUS_CHECKS = 5;
 class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     constructor(chainInterface, btcRelay, storage, programAddress) {
         super(chainInterface, programIdl, programAddress);
@@ -194,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)
@@ -203,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") {
@@ -221,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
+                    })
                 };
             }
         });
@@ -237,6 +234,21 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
             return { type: base_1.SwapCommitStateType.EXPIRED };
         return { type: base_1.SwapCommitStateType.NOT_COMMITED };
     }
+    async getCommitStatuses(request) {
+        const result = {};
+        let promises = [];
+        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
      *
@@ -283,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) {
@@ -439,25 +536,25 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     /**
      * Get the estimated solana fee of the commit transaction
      */
-    getCommitFee(swapData, feeRate) {
+    getCommitFee(signer, swapData, feeRate) {
         return this.Init.getInitFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana fee of the commit transaction, without any deposits
      */
-    getRawCommitFee(swapData, feeRate) {
+    getRawCommitFee(signer, swapData, feeRate) {
         return this.Init.getRawInitFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRefundFee(swapData, feeRate) {
+    getRefundFee(signer, swapData, feeRate) {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
     /**
      * Get the estimated solana transaction fee of the refund transaction
      */
-    getRawRefundFee(swapData, feeRate) {
+    getRawRefundFee(signer, swapData, feeRate) {
         return this.Refund.getRawRefundFee(swapData, feeRate);
     }
     getExtraData(outputScript, amount, confirmations, nonce) {

package/dist/solana/wallet/SolanaSigner.d.ts

@@ -2,6 +2,7 @@ import { Wallet } from "@coral-xyz/anchor/dist/cjs/provider";
 import { AbstractSigner } from "@atomiqlabs/base";
 import { PublicKey, Signer } from "@solana/web3.js";
 export declare class SolanaSigner implements AbstractSigner {
+    type: "AtomiqAbstractSigner";
     wallet: Wallet;
     keypair?: Signer;
     constructor(wallet: Wallet, keypair?: Signer);

package/dist/solana/wallet/SolanaSigner.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaSigner = void 0;
 class SolanaSigner {
     constructor(wallet, keypair) {
+        this.type = "AtomiqAbstractSigner";
         this.wallet = wallet;
         this.keypair = keypair;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-solana",
-  "version": "11.0.0",
+  "version": "12.0.6",
   "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": "^11.0.0",
+    "@atomiqlabs/base": "^12.0.3",
     "@noble/hashes": "^1.7.1",
     "bn.js": "5.2.1",
     "bs58": "4.0.1",

package/src/solana/SolanaChainType.ts

@@ -7,6 +7,7 @@ import {SolanaSwapData} from "./swaps/SolanaSwapData";
 import {SolanaChainEventsBrowser} from "./events/SolanaChainEventsBrowser";
 import {SolanaBtcRelay} from "./btcrelay/SolanaBtcRelay";
 import {SolanaChainInterface} from "./chain/SolanaChainInterface";
+import {Wallet} from "@coral-xyz/anchor/dist/cjs/provider";
 
 export type SolanaChainType = ChainType<
     "SOLANA",
@@ -14,6 +15,7 @@ export type SolanaChainType = ChainType<
     SolanaPreFetchVerification,
     SolanaTx,
     SolanaSigner,
+    Wallet,
     SolanaSwapData,
     SolanaSwapProgram,
     SolanaChainInterface,

package/src/solana/chain/SolanaChainInterface.ts

@@ -12,6 +12,7 @@ import {SolanaAddresses} from "./modules/SolanaAddresses";
 import {SolanaSigner} from "../wallet/SolanaSigner";
 import {Buffer} from "buffer";
 import {SolanaKeypairWallet} from "../wallet/SolanaKeypairWallet";
+import {Wallet} from "@coral-xyz/anchor/dist/cjs/provider";
 
 export type SolanaRetryPolicy = {
     maxRetries?: number,
@@ -23,7 +24,8 @@ export type SolanaRetryPolicy = {
 export class SolanaChainInterface implements ChainInterface<
     SolanaTx,
     SolanaSigner,
-    "SOLANA"
+    "SOLANA",
+    Wallet
 > {
     readonly chainId = "SOLANA";
 
@@ -78,6 +80,10 @@ export class SolanaChainInterface implements ChainInterface<
         return SolanaAddresses.isValidAddress(address);
     }
 
+    normalizeAddress(address: string): string {
+        return address;
+    }
+
     getNativeCurrencyAddress(): string {
         return this.Tokens.getNativeCurrencyAddress().toString();
     }
@@ -128,6 +134,14 @@ export class SolanaChainInterface implements ChainInterface<
         return this.Transactions.getTxStatus(tx);
     }
 
+    async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
+        const {block} = await this.Blocks.findLatestParsedBlock("finalized");
+        return {
+            height: block.blockHeight,
+            blockHash: block.blockhash
+        };
+    }
+
 
     ///////////////////////////////////
     //// Callbacks & handlers
@@ -172,4 +186,8 @@ export class SolanaChainInterface implements ChainInterface<
         return new SolanaSigner(wallet, keypair);
     }
 
+    wrapSigner(signer: Wallet): Promise<SolanaSigner> {
+        return Promise.resolve(new SolanaSigner(signer));
+    }
+
 }