@atomiqlabs/chain-solana 7.3.8 → 8.0.0-beta.0

package/src/solana/base/modules/SolanaFees.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import {
     ComputeBudgetProgram,
     Connection,
@@ -16,26 +15,26 @@ const MAX_FEE_AGE = 5000;
 export type FeeBribeData = {
     address: string,
     endpoint: string,
-    getBribeFee?: (original: BN) => BN
+    getBribeFee?: (original: bigint) => bigint
 };
 
 export class SolanaFees {
 
     private readonly connection: Connection;
-    private readonly maxFeeMicroLamports: BN;
+    private readonly maxFeeMicroLamports: bigint;
     private readonly numSamples: number;
     private readonly period: number;
     private useHeliusApi: "yes" | "no" | "auto";
     private heliusApiSupported: boolean = true;
     private readonly heliusFeeLevel: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax";
     private readonly bribeData?: FeeBribeData;
-    private readonly getStaticFee?: (original: BN) => BN;
+    private readonly getStaticFee?: (original: bigint) => bigint;
 
     private readonly logger = getLogger("SolanaFees: ");
 
     private blockFeeCache: {
         timestamp: number,
-        feeRate: Promise<BN>
+        feeRate: Promise<bigint>
     } = null;
 
     constructor(
@@ -45,11 +44,11 @@ export class SolanaFees {
         period: number = 150,
         useHeliusApi: "yes" | "no" | "auto" = "auto",
         heliusFeeLevel: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax" = "veryHigh",
-        getStaticFee?: (feeRate: BN) => BN,
+        getStaticFee?: (feeRate: bigint) => bigint,
         bribeData?: FeeBribeData,
     ) {
         this.connection = connection;
-        this.maxFeeMicroLamports = new BN(maxFeeMicroLamports);
+        this.maxFeeMicroLamports = BigInt(maxFeeMicroLamports);
         this.numSamples = numSamples;
         this.period = period;
         this.useHeliusApi = useHeliusApi;
@@ -172,7 +171,7 @@ export class SolanaFees {
      * @param parsedTx
      * @private
      */
-    private getJitoTxFee(parsedTx: Transaction): BN | null {
+    private getJitoTxFee(parsedTx: Transaction): bigint | null {
         const lastIx = parsedTx.instructions[parsedTx.instructions.length-1];
 
         if(!lastIx.programId.equals(SystemProgram.programId)) return null;
@@ -180,7 +179,7 @@ export class SolanaFees {
 
         const decodedIxData = SystemInstruction.decodeTransfer(lastIx);
         if(decodedIxData.toPubkey.toBase58()!==this.bribeData?.address) return null;
-        return new BN(decodedIxData.lamports.toString(10));
+        return decodedIxData.lamports;
     }
 
     /**
@@ -189,21 +188,21 @@ export class SolanaFees {
      * @param slot
      * @private
      */
-    private async getBlockMeanFeeRate(slot: number): Promise<BN | null> {
+    private async getBlockMeanFeeRate(slot: number): Promise<bigint | null> {
         const block = await this.getBlockWithSignature(slot);
         if(block==null) return null;
 
         const blockComission = block.rewards.find(e => e.rewardType==="Fee");
-        const totalBlockFees = new BN(blockComission.lamports).mul(new BN(2));
+        const totalBlockFees: bigint = BigInt(blockComission.lamports) * 2n;
 
         //Subtract per-signature fees to get pure compute fees
-        const totalTransactionBaseFees = new BN(block.signatures.length).mul(new BN(5000));
-        const computeFees = totalBlockFees.sub(totalTransactionBaseFees);
+        const totalTransactionBaseFees = BigInt(block.signatures.length) * 5000n;
+        const computeFees = totalBlockFees - totalTransactionBaseFees;
 
         //Total compute fees in micro lamports
-        const computeFeesMicroLamports = computeFees.mul(new BN(1000000));
+        const computeFeesMicroLamports = computeFees * 1000000n;
         //micro lamports per CU considering block was full (48M compute units)
-        const perCUMicroLamports = computeFeesMicroLamports.div(new BN(48000000));
+        const perCUMicroLamports = computeFeesMicroLamports / 48000000n;
 
         this.logger.debug("getBlockMeanFeeRate(): slot: "+slot+" total reward: "+totalBlockFees.toString(10)+
             " total transactions: "+block.signatures.length+" computed fee: "+perCUMicroLamports);
@@ -217,7 +216,7 @@ export class SolanaFees {
      * @private
      * @returns {Promise<BN>} sampled mean microLamports/CU fee over the last period
      */
-    private async _getGlobalFeeRate(): Promise<BN> {
+    private async _getGlobalFeeRate(): Promise<bigint> {
         let slot = await this.connection.getSlot();
 
         const slots: number[] = [];
@@ -226,10 +225,10 @@ export class SolanaFees {
             slots.push(slot-i);
         }
 
-        const promises: Promise<BN>[] = [];
+        const promises: Promise<bigint>[] = [];
         for(let i=0;i<this.numSamples;i++) {
             promises.push((async () => {
-                let feeRate: BN = null;
+                let feeRate: bigint = null;
                 while(feeRate==null) {
                     if(slots.length===0) throw new Error("Ran out of slots to check!");
                     const index = Math.floor(Math.random()*slots.length);
@@ -244,7 +243,7 @@ export class SolanaFees {
         const meanFees = await Promise.all(promises);
 
         let min = null;
-        meanFees.forEach(e => min==null ? min = e : min = BN.min(min, e));
+        meanFees.forEach(e => min==null || min > e ? min = e : 0);
 
         if(min!=null) this.logger.debug("_getGlobalFeeRate(): slot: "+slot+" global fee minimum: "+min.toString(10));
 
@@ -257,13 +256,15 @@ export class SolanaFees {
      * @param mutableAccounts
      * @private
      */
-    private async _getFeeRate(mutableAccounts: PublicKey[]): Promise<BN> {
+    private async _getFeeRate(mutableAccounts: PublicKey[]): Promise<bigint> {
         if(this.useHeliusApi==="yes" || (this.useHeliusApi==="auto" && this.heliusApiSupported)) {
             //Try to use getPriorityFeeEstimate api of Helius
             const fees = await this.getPriorityFeeEstimate(mutableAccounts);
             if(fees!=null) {
-                const calculatedFee = BN.max(new BN(8000), new BN(fees[this.heliusFeeLevel]));
-                return BN.min(calculatedFee, this.maxFeeMicroLamports);
+                let calculatedFee = BigInt(fees[this.heliusFeeLevel]);
+                if(calculatedFee < 8000n) calculatedFee = 8000n;
+                if(calculatedFee > this.maxFeeMicroLamports) calculatedFee = this.maxFeeMicroLamports;
+                return calculatedFee;
             }
             this.logger.warn("_getFeeRate(): tried fetching fees from Helius API, not supported," +
                 " falling back to client-side fee estimation");
@@ -280,13 +281,16 @@ export class SolanaFees {
                     const data = resp[resp.length-i-1];
                     if(data!=null) lamports = Math.min(lamports, data.prioritizationFee);
                 }
-                return new BN(lamports);
+                return BigInt(lamports);
             })
         ]);
 
-        const fee =  BN.max(BN.max(globalFeeRate, localFeeRate), new BN(8000));
+        let fee = globalFeeRate;
+        if(fee < localFeeRate) fee = localFeeRate;
+        if(fee < 8000n) fee = 8000n;
+        if(fee > this.maxFeeMicroLamports) fee = this.maxFeeMicroLamports;
 
-        return BN.min(fee, this.maxFeeMicroLamports);
+        return fee;
     }
 
     /**
@@ -294,7 +298,7 @@ export class SolanaFees {
      *
      * @returns {Promise<BN>} global fee rate microLamports/CU
      */
-    public getGlobalFeeRate(): Promise<BN> {
+    public getGlobalFeeRate(): Promise<bigint> {
         if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > MAX_FEE_AGE) {
             let obj = {
                 timestamp: Date.now(),
@@ -344,8 +348,8 @@ export class SolanaFees {
      * @param feeRate
      * @param includeStaticFee whether the include the static/base part of the fee rate
      */
-    public getPriorityFee(computeUnits: number, feeRate: string, includeStaticFee: boolean = true): BN {
-        if(feeRate==null) return new BN(0);
+    public getPriorityFee(computeUnits: number, feeRate: string, includeStaticFee: boolean = true): bigint {
+        if(feeRate==null) return 0n;
 
         const hashArr = feeRate.split("#");
         if(hashArr.length>1) {
@@ -353,10 +357,10 @@ export class SolanaFees {
         }
 
         const arr = feeRate.split(";");
-        const cuPrice = new BN(arr[0]);
-        const staticFee = includeStaticFee ? new BN(arr[1]) : new BN(0);
+        const cuPrice = BigInt(arr[0]);
+        const staticFee = includeStaticFee ? BigInt(arr[1]) : 0n;
 
-        return staticFee.add(cuPrice.mul(new BN(computeUnits)).div(new BN(1000000)));
+        return staticFee + (cuPrice * BigInt(computeUnits) / 1000000n);
     }
 
     /**

package/src/solana/base/modules/SolanaTokens.ts

@@ -6,7 +6,6 @@ import {
     getAccount, getAssociatedTokenAddressSync,
     TokenAccountNotFoundError
 } from "@solana/spl-token";
-import * as BN from "bn.js";
 import {SolanaTx} from "./SolanaTransactions";
 import {SolanaAction} from "../SolanaAction";
 import {tryWithRetries} from "../../../utils/Utils";
@@ -55,18 +54,18 @@ export class SolanaTokens extends SolanaModule {
      * @param initAta whether we should also initialize the ATA before depositing SOL
      * @constructor
      */
-    public Wrap(publicKey: PublicKey, amount: BN, initAta: boolean): SolanaAction {
-        const ata = getAssociatedTokenAddressSync(this.WSOL_ADDRESS, publicKey, true);
+    public Wrap(publicKey: PublicKey, amount: bigint, initAta: boolean): SolanaAction {
+        const ata = getAssociatedTokenAddressSync(SolanaTokens.WSOL_ADDRESS, publicKey, true);
         const action = new SolanaAction(publicKey, this.root);
         if(initAta) action.addIx(
-            createAssociatedTokenAccountInstruction(publicKey, ata, publicKey, this.WSOL_ADDRESS),
+            createAssociatedTokenAccountInstruction(publicKey, ata, publicKey, SolanaTokens.WSOL_ADDRESS),
             SolanaTokens.CUCosts.ATA_INIT
         );
         action.addIx(
             SystemProgram.transfer({
                 fromPubkey: publicKey,
                 toPubkey: ata,
-                lamports: BigInt(amount.toString(10))
+                lamports: amount
             }),
             SolanaTokens.CUCosts.WRAP_SOL
         );
@@ -81,7 +80,7 @@ export class SolanaTokens extends SolanaModule {
      * @constructor
      */
     public Unwrap(publicKey: PublicKey): SolanaAction {
-        const ata = getAssociatedTokenAddressSync(this.WSOL_ADDRESS, publicKey, true);
+        const ata = getAssociatedTokenAddressSync(SolanaTokens.WSOL_ADDRESS, publicKey, true);
         return new SolanaAction(
             publicKey,
             this.root,
@@ -90,8 +89,8 @@ export class SolanaTokens extends SolanaModule {
         );
     }
 
-    public readonly WSOL_ADDRESS = new PublicKey("So11111111111111111111111111111111111111112");
-    public readonly SPL_ATA_RENT_EXEMPT = 2039280;
+    public static readonly WSOL_ADDRESS = new PublicKey("So11111111111111111111111111111111111111112");
+    public static readonly SPL_ATA_RENT_EXEMPT = 2039280;
 
     /**
      * Action for transferring the native SOL token, uses provider's public key as a sender
@@ -102,12 +101,12 @@ export class SolanaTokens extends SolanaModule {
      * @constructor
      * @private
      */
-    private SolTransfer(signer: PublicKey, recipient: PublicKey, amount: BN): SolanaAction {
+    private SolTransfer(signer: PublicKey, recipient: PublicKey, amount: bigint): SolanaAction {
         return new SolanaAction(signer, this.root,
             SystemProgram.transfer({
                 fromPubkey: signer,
                 toPubkey: recipient,
-                lamports: BigInt(amount.toString(10))
+                lamports: amount
             }),
             SolanaTokens.CUCosts.TRANSFER_SOL
         );
@@ -123,7 +122,7 @@ export class SolanaTokens extends SolanaModule {
      * @constructor
      * @private
      */
-    private Transfer(signer: PublicKey, recipient: PublicKey, token: PublicKey, amount: BN): SolanaAction {
+    private Transfer(signer: PublicKey, recipient: PublicKey, token: PublicKey, amount: bigint): SolanaAction {
         const srcAta = getAssociatedTokenAddressSync(token, signer, true)
         const dstAta = getAssociatedTokenAddressSync(token, recipient, true);
         return new SolanaAction(signer, this.root,
@@ -131,7 +130,7 @@ export class SolanaTokens extends SolanaModule {
                 srcAta,
                 dstAta,
                 signer,
-                BigInt(amount.toString(10))
+                amount
             ),
             SolanaTokens.CUCosts.TRANSFER
         );
@@ -146,8 +145,8 @@ export class SolanaTokens extends SolanaModule {
      * @param feeRate fee rate to use for the transactions
      * @private
      */
-    private async txsTransferSol(signer: PublicKey, amount: BN, recipient: PublicKey, feeRate?: string): Promise<SolanaTx[]> {
-        const wsolAta = getAssociatedTokenAddressSync(this.WSOL_ADDRESS, signer, true);
+    private async txsTransferSol(signer: PublicKey, amount: bigint, recipient: PublicKey, feeRate?: string): Promise<SolanaTx[]> {
+        const wsolAta = getAssociatedTokenAddressSync(SolanaTokens.WSOL_ADDRESS, signer, true);
 
         const shouldUnwrap = await this.ataExists(wsolAta);
         const action = new SolanaAction(signer, this.root);
@@ -175,7 +174,7 @@ export class SolanaTokens extends SolanaModule {
      * @param feeRate fee rate to use for the transactions
      * @private
      */
-    private async txsTransferTokens(signer: PublicKey, token: PublicKey, amount: BN, recipient: PublicKey, feeRate?: string) {
+    private async txsTransferTokens(signer: PublicKey, token: PublicKey, amount: bigint, recipient: PublicKey, feeRate?: string) {
         const srcAta = getAssociatedTokenAddressSync(token, signer, true);
         const dstAta = getAssociatedTokenAddressSync(token, recipient, true);
 
@@ -238,8 +237,8 @@ export class SolanaTokens extends SolanaModule {
     /**
      * Returns the rent exempt deposit required to initiate the ATA
      */
-    public getATARentExemptLamports(): Promise<BN> {
-        return Promise.resolve(new BN(this.SPL_ATA_RENT_EXEMPT));
+    public getATARentExemptLamports(): Promise<bigint> {
+        return Promise.resolve(BigInt(SolanaTokens.SPL_ATA_RENT_EXEMPT));
     }
 
     /**
@@ -248,23 +247,23 @@ export class SolanaTokens extends SolanaModule {
      * @param publicKey
      * @param token
      */
-    public async getTokenBalance(publicKey: PublicKey, token: PublicKey): Promise<{balance: BN, ataExists: boolean}> {
+    public async getTokenBalance(publicKey: PublicKey, token: PublicKey): Promise<{balance: bigint, ataExists: boolean}> {
         const ata: PublicKey = getAssociatedTokenAddressSync(token, publicKey, true);
         const [ataAccount, balance] = await Promise.all<[Promise<Account>, Promise<number>]>([
             this.getATAOrNull(ata),
-            (token!=null && token.equals(this.WSOL_ADDRESS)) ? this.connection.getBalance(publicKey) : Promise.resolve(null)
+            (token!=null && token.equals(SolanaTokens.WSOL_ADDRESS)) ? this.connection.getBalance(publicKey) : Promise.resolve(null)
         ]);
 
         let ataExists: boolean = ataAccount!=null;
-        let sum: BN = new BN(0);
+        let sum: bigint = 0n;
         if(ataExists) {
-            sum = sum.add(new BN(ataAccount.amount.toString()));
+            sum += ataAccount.amount;
         }
 
         if(balance!=null) {
-            let balanceLamports: BN = new BN(balance);
-            if(!ataExists) balanceLamports = balanceLamports.sub(await this.getATARentExemptLamports());
-            if(!balanceLamports.isNeg()) sum = sum.add(balanceLamports);
+            let balanceLamports: bigint = BigInt(balance);
+            if(!ataExists) balanceLamports = balanceLamports - await this.getATARentExemptLamports();
+            if(balanceLamports >= 0n) sum += balanceLamports;
         }
 
         this.logger.debug("getTokenBalance(): token balance fetched, token: "+token.toString()+
@@ -277,7 +276,7 @@ export class SolanaTokens extends SolanaModule {
      * Returns the native currency address, we use WSOL address as placeholder for SOL
      */
     public getNativeCurrencyAddress(): PublicKey {
-        return this.WSOL_ADDRESS;
+        return SolanaTokens.WSOL_ADDRESS;
     }
 
     /**
@@ -299,8 +298,8 @@ export class SolanaTokens extends SolanaModule {
      * @param dstAddress destination address of the recipient
      * @param feeRate fee rate to use for the transaction
      */
-    public txsTransfer(signer:PublicKey, token: PublicKey, amount: BN, dstAddress: PublicKey, feeRate?: string): Promise<SolanaTx[]> {
-        if(this.WSOL_ADDRESS.equals(token)) {
+    public txsTransfer(signer:PublicKey, token: PublicKey, amount: bigint, dstAddress: PublicKey, feeRate?: string): Promise<SolanaTx[]> {
+        if(SolanaTokens.WSOL_ADDRESS.equals(token)) {
             return this.txsTransferSol(signer, amount, dstAddress, feeRate);
         }
         return this.txsTransferTokens(signer, token, amount, dstAddress, feeRate);

package/src/solana/base/modules/SolanaTransactions.ts

@@ -223,7 +223,7 @@ export class SolanaTransactions extends SolanaModule {
      *  optionally waits for confirmation of a batch of solana transactions
      *
      * @param signer
-     * @param txs transactions to send
+     * @param _txs
      * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
      *  are re-sent at regular intervals)
      * @param abortSignal abort signal to abort waiting for transaction confirmations
@@ -231,43 +231,48 @@ export class SolanaTransactions extends SolanaModule {
      *  are executed in order)
      * @param onBeforePublish a callback called before every transaction is published
      */
-    public async sendAndConfirm(signer: SolanaSigner, txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
-        await this.prepareTransactions(signer, txs)
-        const signedTxs = await signer.wallet.signAllTransactions(txs.map(e => e.tx));
-        signedTxs.forEach((tx, index) => {
-            const solTx = txs[index];
-            tx.lastValidBlockHeight = solTx.tx.lastValidBlockHeight;
-            solTx.tx = tx
-        });
-
+    public async sendAndConfirm(signer: SolanaSigner, _txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
         const options = {
             skipPreflight: true
         };
 
-        this.logger.debug("sendAndConfirm(): sending transactions, count: "+txs.length+
+        this.logger.debug("sendAndConfirm(): sending transactions, count: "+_txs.length+
             " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
 
         const signatures: string[] = [];
-        if(parallel) {
-            const promises: Promise<void>[] = [];
-            for(let solTx of txs) {
-                const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
-                if(waitForConfirmation) promises.push(this.confirmTransaction(solTx, abortSignal, "confirmed"));
-                signatures.push(signature);
-            }
-            if(promises.length>0) await Promise.all(promises);
-        } else {
-            for(let i=0;i<txs.length;i++) {
-                const solTx = txs[i];
-                const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
-                const confirmPromise = this.confirmTransaction(solTx, abortSignal, "confirmed");
-                //Don't await the last promise when !waitForConfirmation
-                if(i<txs.length-1 || waitForConfirmation) await confirmPromise;
-                signatures.push(signature);
+        for(let e=0;e<_txs.length;e+=50) {
+            const txs = _txs.slice(e, e+50);
+
+            await this.prepareTransactions(signer, txs)
+            const signedTxs = await signer.wallet.signAllTransactions(txs.map(e => e.tx));
+            signedTxs.forEach((tx, index) => {
+                const solTx = txs[index];
+                tx.lastValidBlockHeight = solTx.tx.lastValidBlockHeight;
+                solTx.tx = tx
+            });
+            this.logger.debug("sendAndConfirm(): sending transaction batch ("+e+".."+(e+50)+"), count: "+txs.length);
+
+            if(parallel) {
+                const promises: Promise<void>[] = [];
+                for(let solTx of txs) {
+                    const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
+                    if(waitForConfirmation) promises.push(this.confirmTransaction(solTx, abortSignal, "confirmed"));
+                    signatures.push(signature);
+                }
+                if(promises.length>0) await Promise.all(promises);
+            } else {
+                for(let i=0;i<txs.length;i++) {
+                    const solTx = txs[i];
+                    const signature = await this.sendSignedTransaction(solTx, options, onBeforePublish);
+                    const confirmPromise = this.confirmTransaction(solTx, abortSignal, "confirmed");
+                    //Don't await the last promise when !waitForConfirmation
+                    if(i<txs.length-1 || e+50<_txs.length || waitForConfirmation) await confirmPromise;
+                    signatures.push(signature);
+                }
             }
         }
 
-        this.logger.info("sendAndConfirm(): sent transactions, count: "+txs.length+
+        this.logger.info("sendAndConfirm(): sent transactions, count: "+_txs.length+
             " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
 
         return signatures;

package/src/solana/btcrelay/SolanaBtcRelay.ts

@@ -1,4 +1,3 @@
-import {AnchorProvider} from "@coral-xyz/anchor";
 import {
     Connection,
     PublicKey,
@@ -12,15 +11,12 @@ import * as programIdl from "./program/programIdl.json";
 import {BitcoinRpc, BtcBlock, BtcRelay, StatePredictorUtils} from "@atomiqlabs/base";
 import {MethodsBuilder} from "@coral-xyz/anchor/dist/cjs/program/namespace/methods";
 import {SolanaProgramBase} from "../program/SolanaProgramBase";
-import * as BN from "bn.js";
 import {SolanaAction} from "../base/SolanaAction";
 import {Buffer} from "buffer";
 import {SolanaFees} from "../base/modules/SolanaFees";
 import {SolanaTx} from "../base/modules/SolanaTransactions";
 import {SolanaSigner} from "../wallet/SolanaSigner";
-import {sign} from "tweetnacl";
-
-const BASE_FEE_SOL_PER_BLOCKHEADER = new BN(5000);
+import * as BN from "bn.js";
 
 const MAX_CLOSE_IX_PER_TX = 10;
 
@@ -540,15 +536,15 @@ export class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBase<any> i
      * @param requiredBlockheight
      * @param feeRate
      */
-    public async estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<BN> {
+    public async estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint> {
         const tipData = await this.getTipData();
         const currBlockheight = tipData.blockheight;
 
         const blockheightDelta = requiredBlockheight-currBlockheight;
 
-        if(blockheightDelta<=0) return new BN(0);
+        if(blockheightDelta<=0) return 0n;
 
-        const synchronizationFee = new BN(blockheightDelta).mul(await this.getFeePerBlock(feeRate));
+        const synchronizationFee = BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate);
         this.logger.debug("estimateSynchronizeFee(): required blockheight: "+requiredBlockheight+
             " blockheight delta: "+blockheightDelta+" fee: "+synchronizationFee.toString(10));
 
@@ -560,10 +556,10 @@ export class SolanaBtcRelay<B extends BtcBlock> extends SolanaProgramBase<any> i
      *
      * @param feeRate
      */
-    public async getFeePerBlock(feeRate?: string): Promise<BN> {
+    public async getFeePerBlock(feeRate?: string): Promise<bigint> {
         // feeRate = feeRate || await this.getMainFeeRate(null);
         // return BASE_FEE_SOL_PER_BLOCKHEADER.add(this.Fees.getPriorityFee(200000, feeRate, false));
-        return new BN(50000);
+        return 50000n;
     }
 
     /**

package/src/solana/events/SolanaChainEventsBrowser.ts

@@ -1,10 +1,10 @@
 import {ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SwapEvent} from "@atomiqlabs/base";
 import {SolanaSwapData} from "../swaps/SolanaSwapData";
-import {AnchorProvider, IdlEvents} from "@coral-xyz/anchor";
+import {IdlEvents} from "@coral-xyz/anchor";
 import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
 import {
     getLogger,
-    onceAsync, tryWithRetries
+    onceAsync, toEscrowHash, tryWithRetries
 } from "../../utils/Utils";
 import {Connection, ParsedTransactionWithMeta, PublicKey} from "@solana/web3.js";
 import * as BN from "bn.js";
@@ -132,11 +132,11 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
     protected parseInitializeEvent(data: IdlEvents<SwapProgram>["InitializeEvent"], eventObject: EventObject): InitializeEvent<SolanaSwapData> {
         const paymentHash: string = Buffer.from(data.hash).toString("hex");
         const txoHash: string = Buffer.from(data.txoHash).toString("hex");
-        this.logger.debug("InitializeEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+" txoHash: "+txoHash);
+        const escrowHash = toEscrowHash(paymentHash, data.sequence);
+        this.logger.debug("InitializeEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
+            " txoHash: "+txoHash+" escrowHash: "+escrowHash);
         return new InitializeEvent<SolanaSwapData>(
-            paymentHash,
-            data.sequence,
-            txoHash,
+            escrowHash,
             SwapTypeEnum.toChainSwapType(data.kind),
             onceAsync<SolanaSwapData>(this.getSwapDataGetter(eventObject, txoHash))
         );
@@ -144,15 +144,19 @@ export class SolanaChainEventsBrowser implements ChainEvents<SolanaSwapData> {
 
     protected parseRefundEvent(data: IdlEvents<SwapProgram>["RefundEvent"]): RefundEvent<SolanaSwapData> {
         const paymentHash: string = Buffer.from(data.hash).toString("hex");
-        this.logger.debug("RefundEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10));
-        return new RefundEvent<SolanaSwapData>(paymentHash, data.sequence);
+        const escrowHash = toEscrowHash(paymentHash, data.sequence);
+        this.logger.debug("RefundEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
+            " escrowHash: "+escrowHash);
+        return new RefundEvent<SolanaSwapData>(escrowHash);
     }
 
     protected parseClaimEvent(data: IdlEvents<SwapProgram>["ClaimEvent"]): ClaimEvent<SolanaSwapData> {
         const secret: string = Buffer.from(data.secret).toString("hex");
         const paymentHash: string = Buffer.from(data.hash).toString("hex");
-        this.logger.debug("ClaimEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+" secret: "+secret);
-        return new ClaimEvent<SolanaSwapData>(paymentHash, data.sequence, secret);
+        const escrowHash = toEscrowHash(paymentHash, data.sequence);
+        this.logger.debug("ClaimEvent paymentHash: "+paymentHash+" sequence: "+data.sequence.toString(10)+
+            " secret: "+secret+" escrowHash: "+escrowHash);
+        return new ClaimEvent<SolanaSwapData>(escrowHash, secret);
     }
 
     /**

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

@@ -1,5 +1,5 @@
 import {SolanaEvents} from "../../base/modules/SolanaEvents";
-import {BorshCoder, DecodeType, Event, EventParser, Idl, IdlEvents, IdlTypes, Instruction} from "@coral-xyz/anchor";
+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 {SolanaProgramBase} from "../SolanaProgramBase";