@atomiqlabs/chain-solana 8.0.3 → 9.0.0-beta.0

package/src/solana/swaps/SolanaSwapProgram.ts

@@ -1,9 +1,8 @@
 import {SolanaSwapData} from "./SolanaSwapData";
 import {IdlAccounts} from "@coral-xyz/anchor";
 import {
-    Connection, Keypair,
+    Connection,
     PublicKey,
-    SendOptions
 } from "@solana/web3.js";
 import {sha256} from "@noble/hashes/sha2";
 import {SolanaBtcRelay} from "../btcrelay/SolanaBtcRelay";
@@ -16,11 +15,11 @@ import {SolanaBtcStoredHeader} from "../btcrelay/headers/SolanaBtcStoredHeader";
 import {
     getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
-import {SolanaFees} from "../base/modules/SolanaFees";
+import {SolanaFees} from "../chain/modules/SolanaFees";
 import {SwapProgram} from "./programTypes";
-import {SolanaRetryPolicy} from "../base/SolanaBase";
+import {SolanaChainInterface, SolanaRetryPolicy} from "../chain/SolanaChainInterface";
 import {SolanaProgramBase} from "../program/SolanaProgramBase";
-import {SolanaTx} from "../base/modules/SolanaTransactions";
+import {SolanaTx} from "../chain/modules/SolanaTransactions";
 import {SwapInit, SolanaPreFetchData, SolanaPreFetchVerification} from "./modules/SwapInit";
 import {SolanaDataAccount, StoredDataAccount} from "./modules/SolanaDataAccount";
 import {SwapRefund} from "./modules/SwapRefund";
@@ -28,9 +27,8 @@ import {SwapClaim} from "./modules/SwapClaim";
 import {SolanaLpVault} from "./modules/SolanaLpVault";
 import {Buffer} from "buffer";
 import {SolanaSigner} from "../wallet/SolanaSigner";
-import {SolanaKeypairWallet} from "../wallet/SolanaKeypairWallet";
 import {fromClaimHash, toBN, toClaimHash} from "../../utils/Utils";
-import {SolanaTokens} from "../base/modules/SolanaTokens";
+import {SolanaTokens} from "../chain/modules/SolanaTokens";
 import * as BN from "bn.js";
 
 function toPublicKeyOrNull(str: string | null): PublicKey | null {
@@ -80,20 +78,18 @@ export class SolanaSwapProgram
     readonly LpVault: SolanaLpVault;
 
     constructor(
-        connection: Connection,
+        chainInterface: SolanaChainInterface,
         btcRelay: SolanaBtcRelay<any>,
         storage: IStorageManager<StoredDataAccount>,
-        programAddress?: string,
-        retryPolicy?: SolanaRetryPolicy,
-        solanaFeeEstimator: SolanaFees = btcRelay.Fees || new SolanaFees(connection)
+        programAddress?: string
     ) {
-        super(connection, programIdl, programAddress, retryPolicy, solanaFeeEstimator);
+        super(chainInterface, programIdl, programAddress);
 
-        this.Init = new SwapInit(this);
-        this.Refund = new SwapRefund(this);
-        this.Claim = new SwapClaim(this, btcRelay);
-        this.DataAccount = new SolanaDataAccount(this, storage);
-        this.LpVault = new SolanaLpVault(this);
+        this.Init = new SwapInit(chainInterface, this);
+        this.Refund = new SwapRefund(chainInterface, this);
+        this.Claim = new SwapClaim(chainInterface, this, btcRelay);
+        this.DataAccount = new SolanaDataAccount(chainInterface, this, storage);
+        this.LpVault = new SolanaLpVault(chainInterface, this);
     }
 
     async start(): Promise<void> {
@@ -143,11 +139,11 @@ export class SolanaSwapProgram
     }
 
     getDataSignature(signer: SolanaSigner, data: Buffer): Promise<string> {
-        return this.Signatures.getDataSignature(signer, data);
+        return this.Chain.Signatures.getDataSignature(signer, data);
     }
 
     isValidDataSignature(data: Buffer, signature: string, publicKey: string): Promise<boolean> {
-        return this.Signatures.isValidDataSignature(data, signature, publicKey);
+        return this.Chain.Signatures.isValidDataSignature(data, signature, publicKey);
     }
 
     ////////////////////////////////////////////
@@ -384,19 +380,14 @@ export class SolanaSwapProgram
     ////////////////////////////////////////////
     //// Utils
     async getBalance(signer: string, tokenAddress: string, inContract: boolean): Promise<bigint> {
+        if(!inContract) {
+            return await this.Chain.getBalance(signer, tokenAddress);
+        }
+
         const token = new PublicKey(tokenAddress);
         const publicKey = new PublicKey(signer);
 
-        if(inContract) return await this.getIntermediaryBalance(publicKey, token);
-
-        let { balance } = await this.Tokens.getTokenBalance(publicKey, token);
-        if(token.equals(SolanaTokens.WSOL_ADDRESS)) {
-            const accountRentExemptCost = 1000000n;
-            balance = balance - accountRentExemptCost;
-            if(balance < 0n) balance = 0n;
-        }
-        this.logger.debug("getBalance(): token balance, token: "+token.toBase58()+" balance: "+balance.toString(10));
-        return balance;
+        return await this.getIntermediaryBalance(publicKey, token);
     }
 
     getIntermediaryData(address: string, token: string): Promise<{
@@ -414,14 +405,6 @@ export class SolanaSwapProgram
         return this.LpVault.getIntermediaryBalance(address, token);
     }
 
-    isValidAddress(address: string): boolean {
-        return this.Addresses.isValidAddress(address);
-    }
-
-    getNativeCurrencyAddress(): string {
-        return this.Tokens.getNativeCurrencyAddress().toString();
-    }
-
     ////////////////////////////////////////////
     //// Transaction initializers
     async txsClaimWithSecret(
@@ -478,10 +461,6 @@ export class SolanaSwapProgram
         return this.LpVault.txsDeposit(new PublicKey(signer), new PublicKey(token), amount, feeRate);
     }
 
-    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<SolanaTx[]> {
-        return this.Tokens.txsTransfer(new PublicKey(signer), new PublicKey(token), amount, new PublicKey(dstAddress), feeRate);
-    }
-
     ////////////////////////////////////////////
     //// Executors
     async claimWithSecret(
@@ -493,7 +472,7 @@ export class SolanaSwapProgram
         txOptions?: TransactionConfirmationOptions
     ): Promise<string> {
         const result = await this.Claim.txsClaimWithSecret(signer.getPublicKey(), swapData, secret, checkExpiry, initAta, txOptions?.feeRate);
-        const [signature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         return signature;
     }
 
@@ -521,7 +500,7 @@ export class SolanaSwapProgram
         if(txs===null) throw new Error("Btc relay not synchronized to required blockheight!");
 
         //TODO: This doesn't return proper tx signature
-        const [signature] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [signature] = await this.Chain.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal);
         await this.DataAccount.removeDataAccount(data.storageAcc);
 
         return signature;
@@ -536,7 +515,7 @@ export class SolanaSwapProgram
     ): Promise<string> {
         let result = await this.txsRefund(signer.getAddress(), swapData, check, initAta, txOptions?.feeRate);
 
-        const [signature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [signature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return signature;
     }
@@ -551,7 +530,7 @@ export class SolanaSwapProgram
     ): Promise<string> {
         let result = await this.txsRefundWithAuthorization(signer.getAddress(), swapData, signature, check, initAta, txOptions?.feeRate);
 
-        const [txSignature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [txSignature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return txSignature;
     }
@@ -571,7 +550,7 @@ export class SolanaSwapProgram
 
         const result = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
 
-        const [txSignature] = await this.Transactions.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        const [txSignature] = await this.Chain.sendAndConfirm(signer, result, txOptions?.waitForConfirmation, txOptions?.abortSignal);
 
         return txSignature;
     }
@@ -589,7 +568,7 @@ export class SolanaSwapProgram
         const txsCommit = await this.txsInit(swapData, signature, skipChecks, txOptions?.feeRate);
         const txsClaim = await this.Claim.txsClaimWithSecret(signer.getPublicKey(), swapData, secret, true, false, txOptions?.feeRate, true);
 
-        return await this.Transactions.sendAndConfirm(signer, txsCommit.concat(txsClaim), txOptions?.waitForConfirmation, txOptions?.abortSignal);
+        return await this.Chain.sendAndConfirm(signer, txsCommit.concat(txsClaim), txOptions?.waitForConfirmation, txOptions?.abortSignal);
     }
 
     async withdraw(
@@ -599,7 +578,7 @@ export class SolanaSwapProgram
         txOptions?: TransactionConfirmationOptions
     ): Promise<string> {
         const txs = await this.LpVault.txsWithdraw(signer.getPublicKey(), new PublicKey(token), amount, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        const [txId] = await this.Chain.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
         return txId;
     }
 
@@ -610,51 +589,10 @@ export class SolanaSwapProgram
         txOptions?: TransactionConfirmationOptions
     ): Promise<string> {
         const txs = await this.LpVault.txsDeposit(signer.getPublicKey(), new PublicKey(token), amount, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
-        return txId;
-    }
-
-    async transfer(
-        signer: SolanaSigner,
-        token: string,
-        amount: bigint,
-        dstAddress: string,
-        txOptions?: TransactionConfirmationOptions
-    ): Promise<string> {
-        const txs = await this.Tokens.txsTransfer(signer.getPublicKey(), new PublicKey(token), amount, new PublicKey(dstAddress), txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        const [txId] = await this.Chain.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
         return txId;
     }
 
-    ////////////////////////////////////////////
-    //// Transactions
-    sendAndConfirm(
-        signer: SolanaSigner,
-        txs: SolanaTx[],
-        waitForConfirmation?: boolean,
-        abortSignal?: AbortSignal,
-        parallel?: boolean,
-        onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
-    ): Promise<string[]> {
-        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
-    }
-
-    serializeTx(tx: SolanaTx): Promise<string> {
-        return this.Transactions.serializeTx(tx);
-    }
-
-    deserializeTx(txData: string): Promise<SolanaTx> {
-        return this.Transactions.deserializeTx(txData);
-    }
-
-    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
-        return this.Transactions.getTxIdStatus(txId);
-    }
-
-    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
-        return this.Transactions.getTxStatus(tx);
-    }
-
     ////////////////////////////////////////////
     //// Fees
     getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, claimHash?: string): Promise<string> {
@@ -721,49 +659,6 @@ export class SolanaSwapProgram
         return this.Refund.getRawRefundFee(swapData, feeRate);
     }
 
-    ///////////////////////////////////
-    //// Callbacks & handlers
-    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
-        return true;
-    }
-
-    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {}
-
-    onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void {
-        this.Transactions.onBeforeTxSigned(callback);
-    }
-
-    offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean {
-        return this.Transactions.offBeforeTxSigned(callback);
-    }
-
-    onSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): void {
-        this.Transactions.onSendTransaction(callback);
-    }
-
-    offSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): boolean {
-        return this.Transactions.offSendTransaction(callback);
-    }
-
-    isValidToken(tokenIdentifier: string): boolean {
-        try {
-            new PublicKey(tokenIdentifier);
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }
-
-    randomAddress(): string {
-        return Keypair.generate().publicKey.toString();
-    }
-
-    randomSigner(): SolanaSigner {
-        const keypair = Keypair.generate();
-        const wallet = new SolanaKeypairWallet(keypair);
-        return new SolanaSigner(wallet, keypair);
-    }
-
     getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer {
         return Buffer.from(sha256(Buffer.concat([
             BigIntBufferUtils.toBuffer(amount, "le", 8),

package/src/solana/swaps/modules/SolanaDataAccount.ts

@@ -2,11 +2,12 @@ import {SolanaSwapModule} from "../SolanaSwapModule";
 import {AccountInfo, PublicKey, Signer, SystemProgram} from "@solana/web3.js";
 import {IStorageManager, StorageObject} from "@atomiqlabs/base";
 import {SolanaSwapProgram} from "../SolanaSwapProgram";
-import {SolanaAction} from "../../base/SolanaAction";
-import {SolanaTx} from "../../base/modules/SolanaTransactions";
+import {SolanaAction} from "../../chain/SolanaAction";
+import {SolanaTx} from "../../chain/modules/SolanaTransactions";
 import {tryWithRetries} from "../../../utils/Utils";
 import {SolanaSigner} from "../../wallet/SolanaSigner";
 import {randomBytes} from "@noble/hashes/utils";
+import {SolanaChainInterface} from "../../chain/SolanaChainInterface";
 
 export class StoredDataAccount implements StorageObject {
 
@@ -37,10 +38,10 @@ export class StoredDataAccount implements StorageObject {
 
 export class SolanaDataAccount extends SolanaSwapModule {
 
-    readonly SwapTxDataAlt = this.root.keypair(
+    readonly SwapTxDataAlt = this.program.keypair(
         (reversedTxId: Buffer, signer: Signer) => [Buffer.from(signer.secretKey), reversedTxId]
     );
-    readonly SwapTxDataAltBuffer = this.root.keypair((reversedTxId: Buffer, secret: Buffer) => [secret, reversedTxId]);
+    readonly SwapTxDataAltBuffer = this.program.keypair((reversedTxId: Buffer, secret: Buffer) => [secret, reversedTxId]);
 
     readonly storage: IStorageManager<StoredDataAccount>;
 
@@ -76,9 +77,9 @@ export class SolanaDataAccount extends SolanaSwapModule {
                 newAccountPubkey: accountKey.publicKey,
                 lamports: lamportsDeposit,
                 space: accountSize,
-                programId: this.program.programId
+                programId: this.swapProgram.programId
             }),
-            await this.program.methods
+            await this.swapProgram.methods
                 .initData()
                 .accounts({
                     signer,
@@ -98,7 +99,7 @@ export class SolanaDataAccount extends SolanaSwapModule {
         return new SolanaAction(
             signer,
             this.root,
-            await this.program.methods
+            await this.swapProgram.methods
                 .closeData()
                 .accounts({
                     signer,
@@ -134,7 +135,7 @@ export class SolanaDataAccount extends SolanaSwapModule {
         return {
             bytesWritten: writeLen,
             action: new SolanaAction(signer, this.root,
-                await this.program.methods
+                await this.swapProgram.methods
                     .writeData(offset, writeData.slice(offset, offset+writeLen))
                     .accounts({
                         signer,
@@ -146,8 +147,8 @@ export class SolanaDataAccount extends SolanaSwapModule {
         };
     }
 
-    constructor(root: SolanaSwapProgram, storage: IStorageManager<StoredDataAccount>) {
-        super(root);
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, storage: IStorageManager<StoredDataAccount>) {
+        super(chainInterface, program);
         this.storage = storage;
     }
 

package/src/solana/swaps/modules/SolanaLpVault.ts

@@ -1,5 +1,5 @@
 import {SolanaSwapModule} from "../SolanaSwapModule";
-import {SolanaAction} from "../../base/SolanaAction";
+import {SolanaAction} from "../../chain/SolanaAction";
 import {PublicKey, SystemProgram} from "@solana/web3.js";
 import {
     Account,
@@ -7,12 +7,12 @@ import {
     getAssociatedTokenAddressSync,
     TOKEN_PROGRAM_ID
 } from "@solana/spl-token";
-import {SolanaTx} from "../../base/modules/SolanaTransactions";
+import {SolanaTx} from "../../chain/modules/SolanaTransactions";
 import {toBigInt, toBN, tryWithRetries} from "../../../utils/Utils";
 import {SwapProgram} from "../programTypes";
 import { IntermediaryReputationType } from "@atomiqlabs/base";
 import { IdlAccounts } from "@coral-xyz/anchor";
-import {SolanaTokens} from "../../base/modules/SolanaTokens";
+import {SolanaTokens} from "../../chain/modules/SolanaTokens";
 
 export class SolanaLpVault extends SolanaSwapModule {
 
@@ -33,14 +33,14 @@ export class SolanaLpVault extends SolanaSwapModule {
     private async Withdraw(signer: PublicKey, token: PublicKey, amount: bigint): Promise<SolanaAction> {
         const ata = getAssociatedTokenAddressSync(token, signer);
         return new SolanaAction(signer, this.root,
-            await this.program.methods
+            await this.swapProgram.methods
                 .withdraw(toBN(amount))
                 .accounts({
                     signer,
                     signerAta: ata,
-                    userData: this.root.SwapUserVault(signer, token),
-                    vault: this.root.SwapVault(token),
-                    vaultAuthority: this.root.SwapVaultAuthority,
+                    userData: this.program.SwapUserVault(signer, token),
+                    vault: this.program.SwapVault(token),
+                    vaultAuthority: this.program.SwapVaultAuthority,
                     mint: token,
                     tokenProgram: TOKEN_PROGRAM_ID
                 })
@@ -61,14 +61,14 @@ export class SolanaLpVault extends SolanaSwapModule {
     private async Deposit(signer: PublicKey, token: PublicKey, amount: bigint): Promise<SolanaAction> {
         const ata = getAssociatedTokenAddressSync(token, signer);
         return new SolanaAction(signer, this.root,
-            await this.program.methods
+            await this.swapProgram.methods
                 .deposit(toBN(amount))
                 .accounts({
                     signer,
                     signerAta: ata,
-                    userData: this.root.SwapUserVault(signer, token),
-                    vault: this.root.SwapVault(token),
-                    vaultAuthority: this.root.SwapVaultAuthority,
+                    userData: this.program.SwapUserVault(signer, token),
+                    vault: this.program.SwapVault(token),
+                    vaultAuthority: this.program.SwapVaultAuthority,
                     mint: token,
                     systemProgram: SystemProgram.programId,
                     tokenProgram: TOKEN_PROGRAM_ID
@@ -88,8 +88,8 @@ export class SolanaLpVault extends SolanaSwapModule {
         balance: bigint,
         reputation: IntermediaryReputationType
     }> {
-        const data: IdlAccounts<SwapProgram>["userAccount"] = await this.program.account.userAccount.fetchNullable(
-            this.root.SwapUserVault(address, token)
+        const data: IdlAccounts<SwapProgram>["userAccount"] = await this.swapProgram.account.userAccount.fetchNullable(
+            this.program.SwapUserVault(address, token)
         );
 
         if(data==null) return null;
@@ -208,8 +208,8 @@ export class SolanaLpVault extends SolanaSwapModule {
         return this.root.Fees.getFeeRate([
             signer,
             ata,
-            this.root.SwapUserVault(signer, token),
-            this.root.SwapVault(token)
+            this.program.SwapUserVault(signer, token),
+            this.program.SwapVault(token)
         ])
     }
 

package/src/solana/swaps/modules/SwapClaim.ts

@@ -1,17 +1,18 @@
 import {SolanaSwapModule} from "../SolanaSwapModule";
 import {SolanaSwapData} from "../SolanaSwapData";
-import {SolanaAction} from "../../base/SolanaAction";
+import {SolanaAction} from "../../chain/SolanaAction";
 import {TOKEN_PROGRAM_ID} from "@solana/spl-token";
 import {ChainSwapType, RelaySynchronizer, SwapDataVerificationError} from "@atomiqlabs/base";
 import {PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY} from "@solana/web3.js";
-import {SolanaTx} from "../../base/modules/SolanaTransactions";
+import {SolanaTx} from "../../chain/modules/SolanaTransactions";
 import {SolanaBtcStoredHeader} from "../../btcrelay/headers/SolanaBtcStoredHeader";
 import {tryWithRetries} from "../../../utils/Utils";
 import {SolanaBtcRelay} from "../../btcrelay/SolanaBtcRelay";
 import {SolanaSwapProgram} from "../SolanaSwapProgram";
 import {SolanaSigner} from "../../wallet/SolanaSigner";
-import {SolanaTokens} from "../../base/modules/SolanaTokens";
+import {SolanaTokens} from "../../chain/modules/SolanaTokens";
 import * as BN from "bn.js";
+import {SolanaChainInterface} from "../../chain/SolanaChainInterface";
 
 export class SwapClaim extends SolanaSwapModule {
 
@@ -54,7 +55,7 @@ export class SwapClaim extends SolanaSwapModule {
         const accounts = {
             signer,
             initializer: swapData.isPayIn() ? swapData.offerer : swapData.claimer,
-            escrowState: this.root.SwapEscrowState(Buffer.from(swapData.paymentHash, "hex")),
+            escrowState: this.program.SwapEscrowState(Buffer.from(swapData.paymentHash, "hex")),
             ixSysvar: SYSVAR_INSTRUCTIONS_PUBKEY,
             data: isDataKey ? secretOrDataKey : null,
         };
@@ -64,13 +65,13 @@ export class SwapClaim extends SolanaSwapModule {
 
         if(swapData.isPayOut()) {
             return new SolanaAction(signer, this.root,
-                await this.program.methods
+                await this.swapProgram.methods
                     .claimerClaimPayOut(secretBuffer)
                     .accounts({
                         ...accounts,
                         claimerAta: swapData.claimerAta,
-                        vault: this.root.SwapVault(swapData.token),
-                        vaultAuthority: this.root.SwapVaultAuthority,
+                        vault: this.program.SwapVault(swapData.token),
+                        vaultAuthority: this.program.SwapVaultAuthority,
                         tokenProgram: TOKEN_PROGRAM_ID
                     })
                     .instruction(),
@@ -78,11 +79,11 @@ export class SwapClaim extends SolanaSwapModule {
             );
         } else {
             return new SolanaAction(signer, this.root,
-                await this.program.methods
+                await this.swapProgram.methods
                     .claimerClaim(secretBuffer)
                     .accounts({
                         ...accounts,
-                        claimerUserData: this.root.SwapUserVault(swapData.claimer, swapData.token)
+                        claimerUserData: this.program.SwapUserVault(swapData.claimer, swapData.token)
                     })
                     .instruction(),
                 this.getComputeBudget(swapData)
@@ -123,8 +124,8 @@ export class SwapClaim extends SolanaSwapModule {
         return action;
     }
 
-    constructor(root: SolanaSwapProgram, btcRelay: SolanaBtcRelay<any>) {
-        super(root);
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, btcRelay: SolanaBtcRelay<any>) {
+        super(chainInterface, program);
         this.btcRelay = btcRelay;
     }
 
@@ -216,7 +217,7 @@ export class SwapClaim extends SolanaSwapModule {
         ]);
         this.logger.debug("addTxsWriteTransactionData(): writing transaction data: ", writeData.toString("hex"));
 
-        return this.root.DataAccount.addTxsWriteData(signer, reversedTxId, writeData, txs, feeRate);
+        return this.program.DataAccount.addTxsWriteData(signer, reversedTxId, writeData, txs, feeRate);
     }
 
     /**
@@ -255,7 +256,7 @@ export class SwapClaim extends SolanaSwapModule {
     ): Promise<SolanaTx[]> {
         //We need to be sure that this transaction confirms in time, otherwise we reveal the secret to the counterparty
         // and won't claim the funds
-        if(checkExpiry && await this.root.isExpired(swapData.claimer.toString(), swapData)) {
+        if(checkExpiry && await this.program.isExpired(swapData.claimer.toString(), swapData)) {
             throw new SwapDataVerificationError("Not enough time to reliably pay the invoice");
         }
         const shouldInitAta = !skipAtaCheck && swapData.isPayOut() && !await this.root.Tokens.ataExists(swapData.claimerAta);
@@ -343,7 +344,7 @@ export class SwapClaim extends SolanaSwapModule {
     public getClaimFeeRate(signer: PublicKey, swapData: SolanaSwapData): Promise<string> {
         const accounts: PublicKey[] = [signer];
         if(swapData.payOut) {
-            if(swapData.token!=null) accounts.push(this.root.SwapVault(swapData.token));
+            if(swapData.token!=null) accounts.push(this.program.SwapVault(swapData.token));
             if(swapData.payIn) {
                 if(swapData.offerer!=null) accounts.push(swapData.offerer);
             } else {
@@ -351,7 +352,7 @@ export class SwapClaim extends SolanaSwapModule {
             }
             if(swapData.claimerAta!=null && !swapData.claimerAta.equals(PublicKey.default)) accounts.push(swapData.claimerAta);
         } else {
-            if(swapData.claimer!=null && swapData.token!=null) accounts.push(this.root.SwapUserVault(swapData.claimer, swapData.token));
+            if(swapData.claimer!=null && swapData.token!=null) accounts.push(this.program.SwapUserVault(swapData.claimer, swapData.token));
 
             if(swapData.payIn) {
                 if(swapData.offerer!=null) accounts.push(swapData.offerer);
@@ -360,7 +361,7 @@ export class SwapClaim extends SolanaSwapModule {
             }
         }
 
-        if(swapData.paymentHash!=null) accounts.push(this.root.SwapEscrowState(Buffer.from(swapData.paymentHash, "hex")));
+        if(swapData.paymentHash!=null) accounts.push(this.program.SwapEscrowState(Buffer.from(swapData.paymentHash, "hex")));
 
         return this.root.Fees.getFeeRate(accounts);
     }