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

package/dist/solana/program/SolanaProgramModule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaProgramModule = void 0;
+const SolanaModule_1 = require("../chain/SolanaModule");
+class SolanaProgramModule extends SolanaModule_1.SolanaModule {
+    constructor(chainInterface, program) {
+        super(chainInterface);
+        this.program = program;
+    }
+}
+exports.SolanaProgramModule = SolanaProgramModule;

package/dist/solana/program/modules/SolanaProgramEvents.d.ts

@@ -1,8 +1,9 @@
-import { SolanaEvents } from "../../base/modules/SolanaEvents";
+import { SolanaEvents } from "../../chain/modules/SolanaEvents";
 import { DecodeType, Event, Idl, IdlTypes } from "@coral-xyz/anchor";
 import { IdlField, IdlInstruction } from "@coral-xyz/anchor/dist/cjs/idl";
 import { ParsedMessage, PublicKey } from "@solana/web3.js";
 import { SolanaProgramBase } from "../SolanaProgramBase";
+import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
 type DecodedFieldOrNull<D, Defined> = D extends IdlField ? DecodeType<D["type"], Defined> : unknown;
 type ArgsTuple<A extends IdlField[], Defined> = {
     [K in A[number]["name"]]: DecodedFieldOrNull<Extract<A[number], {
@@ -21,9 +22,9 @@ export type ProgramEvent<IDL extends Idl> = Event<IDL["events"][number], Record<
 export declare class SolanaProgramEvents<IDL extends Idl> extends SolanaEvents {
     private readonly programCoder;
     private readonly eventParser;
-    readonly root: SolanaProgramBase<any>;
+    private readonly program;
     private readonly nameMappedInstructions;
-    constructor(root: SolanaProgramBase<IDL>);
+    constructor(chain: SolanaChainInterface, program: SolanaProgramBase<IDL>);
     /**
      * Gets events from specific transaction as specified by signature, events are ordered from newest to oldest
      *

package/dist/solana/program/modules/SolanaProgramEvents.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaProgramEvents = void 0;
-const SolanaEvents_1 = require("../../base/modules/SolanaEvents");
+const SolanaEvents_1 = require("../../chain/modules/SolanaEvents");
 const anchor_1 = require("@coral-xyz/anchor");
 class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
-    constructor(root) {
-        super(root);
-        this.root = root;
-        this.programCoder = new anchor_1.BorshCoder(root.program.idl);
-        this.eventParser = new anchor_1.EventParser(root.program.programId, this.programCoder);
+    constructor(chain, program) {
+        super(chain);
+        this.program = program;
+        this.programCoder = new anchor_1.BorshCoder(program.program.idl);
+        this.eventParser = new anchor_1.EventParser(program.program.programId, this.programCoder);
         this.nameMappedInstructions = {};
-        for (let ix of root.program.idl.instructions) {
+        for (let ix of program.program.idl.instructions) {
             this.nameMappedInstructions[ix.name] = ix;
         }
     }
@@ -62,7 +62,7 @@ class SolanaProgramEvents extends SolanaEvents_1.SolanaEvents {
     decodeInstructions(transactionMessage) {
         const instructions = [];
         for (let _ix of transactionMessage.instructions) {
-            if (!_ix.programId.equals(this.root.program.programId)) {
+            if (!_ix.programId.equals(this.program.program.programId)) {
                 instructions.push(null);
                 continue;
             }

package/dist/solana/swaps/SolanaSwapData.js

@@ -8,7 +8,7 @@ const SwapTypeEnum_1 = require("./SwapTypeEnum");
 const buffer_1 = require("buffer");
 const spl_token_1 = require("@solana/spl-token");
 const Utils_1 = require("../../utils/Utils");
-const SolanaTokens_1 = require("../base/modules/SolanaTokens");
+const SolanaTokens_1 = require("../chain/modules/SolanaTokens");
 const EXPIRY_BLOCKHEIGHT_THRESHOLD = new BN("1000000000");
 class SolanaSwapData extends base_1.SwapData {
     constructor(offererOrData, claimer, token, amount, paymentHash, sequence, expiry, nonce, confirmations, payOut, kind, payIn, offererAta, claimerAta, securityDeposit, claimerBounty, txoHash) {

package/dist/solana/swaps/SolanaSwapModule.d.ts

@@ -1,9 +1,10 @@
-import { SolanaModule } from "../base/SolanaModule";
 import { SolanaSwapProgram } from "./SolanaSwapProgram";
 import { Program } from "@coral-xyz/anchor";
 import { SwapProgram } from "./programTypes";
-export declare class SolanaSwapModule extends SolanaModule {
-    readonly root: SolanaSwapProgram;
-    readonly program: Program<SwapProgram>;
-    constructor(root: SolanaSwapProgram);
+import { SolanaProgramModule } from "../program/SolanaProgramModule";
+import { SolanaChainInterface } from "../chain/SolanaChainInterface";
+export declare class SolanaSwapModule extends SolanaProgramModule<SwapProgram> {
+    protected readonly program: SolanaSwapProgram;
+    protected readonly swapProgram: Program<SwapProgram>;
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram);
 }

package/dist/solana/swaps/SolanaSwapModule.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaSwapModule = void 0;
-const SolanaModule_1 = require("../base/SolanaModule");
-class SolanaSwapModule extends SolanaModule_1.SolanaModule {
-    constructor(root) {
-        super(root);
-        this.root = root;
-        this.program = root.program;
+const SolanaProgramModule_1 = require("../program/SolanaProgramModule");
+class SolanaSwapModule extends SolanaProgramModule_1.SolanaProgramModule {
+    constructor(chainInterface, program) {
+        super(chainInterface, program);
+        this.swapProgram = program.program;
     }
 }
 exports.SolanaSwapModule = SolanaSwapModule;

package/dist/solana/swaps/SolanaSwapProgram.d.ts

@@ -1,14 +1,13 @@
 /// <reference types="node" />
 import { SolanaSwapData } from "./SolanaSwapData";
-import { Connection, PublicKey, SendOptions } from "@solana/web3.js";
+import { PublicKey } from "@solana/web3.js";
 import { SolanaBtcRelay } from "../btcrelay/SolanaBtcRelay";
 import { IStorageManager, SwapContract, ChainSwapType, IntermediaryReputationType, SwapCommitStatus, TransactionConfirmationOptions, SignatureData, RelaySynchronizer } from "@atomiqlabs/base";
 import { SolanaBtcStoredHeader } from "../btcrelay/headers/SolanaBtcStoredHeader";
-import { SolanaFees } from "../base/modules/SolanaFees";
 import { SwapProgram } from "./programTypes";
-import { SolanaRetryPolicy } from "../base/SolanaBase";
+import { SolanaChainInterface } 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";
@@ -34,7 +33,7 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     readonly Claim: SwapClaim;
     readonly DataAccount: SolanaDataAccount;
     readonly LpVault: SolanaLpVault;
-    constructor(connection: Connection, btcRelay: SolanaBtcRelay<any>, storage: IStorageManager<StoredDataAccount>, programAddress?: string, retryPolicy?: SolanaRetryPolicy, solanaFeeEstimator?: SolanaFees);
+    constructor(chainInterface: SolanaChainInterface, btcRelay: SolanaBtcRelay<any>, storage: IStorageManager<StoredDataAccount>, programAddress?: string);
     start(): Promise<void>;
     getClaimableDeposits(signer: string): Promise<{
         count: number;
@@ -140,8 +139,6 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     }>;
     getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
     getIntermediaryBalance(address: PublicKey, token: PublicKey): Promise<bigint>;
-    isValidAddress(address: string): boolean;
-    getNativeCurrencyAddress(): string;
     txsClaimWithSecret(signer: string | SolanaSigner, swapData: SolanaSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, feeRate?: string, skipAtaCheck?: boolean): Promise<SolanaTx[]>;
     txsClaimWithTxData(signer: string | SolanaSigner, swapData: SolanaSwapData, tx: {
         blockhash: string;
@@ -165,7 +162,6 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     }, skipChecks?: boolean, feeRate?: string): Promise<SolanaTx[]>;
     txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<SolanaTx[]>;
     txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<SolanaTx[]>;
-    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<SolanaTx[]>;
     claimWithSecret(signer: SolanaSigner, swapData: SolanaSwapData, secret: string, checkExpiry?: boolean, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
     claimWithTxData(signer: SolanaSigner, swapData: SolanaSwapData, tx: {
         blockhash: string;
@@ -180,12 +176,6 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
     initAndClaimWithSecret(signer: SolanaSigner, swapData: SolanaSwapData, signature: SignatureData, secret: string, skipChecks?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string[]>;
     withdraw(signer: SolanaSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
     deposit(signer: SolanaSigner, token: string, amount: bigint, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    transfer(signer: SolanaSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    sendAndConfirm(signer: SolanaSigner, txs: SolanaTx[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
-    serializeTx(tx: SolanaTx): Promise<string>;
-    deserializeTx(txData: string): Promise<SolanaTx>;
-    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
     getInitPayInFeeRate(offerer?: string, claimer?: string, token?: string, claimHash?: string): Promise<string>;
     getInitFeeRate(offerer?: string, claimer?: string, token?: string, claimHash?: string): Promise<string>;
     getRefundFeeRate(swapData: SolanaSwapData): Promise<string>;
@@ -208,14 +198,5 @@ export declare class SolanaSwapProgram extends SolanaProgramBase<SwapProgram> im
      * Get the estimated solana transaction fee of the refund transaction
      */
     getRawRefundFee(swapData: SolanaSwapData, feeRate?: string): Promise<bigint>;
-    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
-    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
-    onBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): void;
-    offBeforeTxSigned(callback: (tx: SolanaTx) => Promise<void>): boolean;
-    onSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): void;
-    offSendTransaction(callback: (tx: Buffer, options?: SendOptions) => Promise<string>): boolean;
-    isValidToken(tokenIdentifier: string): boolean;
-    randomAddress(): string;
-    randomSigner(): SolanaSigner;
     getExtraData(outputScript: Buffer, amount: bigint, confirmations: number, nonce?: bigint): Buffer;
 }

package/dist/solana/swaps/SolanaSwapProgram.js

@@ -7,7 +7,6 @@ const sha2_1 = require("@noble/hashes/sha2");
 const programIdl = require("./programIdl.json");
 const base_1 = require("@atomiqlabs/base");
 const spl_token_1 = require("@solana/spl-token");
-const SolanaFees_1 = require("../base/modules/SolanaFees");
 const SolanaProgramBase_1 = require("../program/SolanaProgramBase");
 const SwapInit_1 = require("./modules/SwapInit");
 const SolanaDataAccount_1 = require("./modules/SolanaDataAccount");
@@ -15,17 +14,15 @@ const SwapRefund_1 = require("./modules/SwapRefund");
 const SwapClaim_1 = require("./modules/SwapClaim");
 const SolanaLpVault_1 = require("./modules/SolanaLpVault");
 const buffer_1 = require("buffer");
-const SolanaSigner_1 = require("../wallet/SolanaSigner");
-const SolanaKeypairWallet_1 = require("../wallet/SolanaKeypairWallet");
 const Utils_1 = require("../../utils/Utils");
-const SolanaTokens_1 = require("../base/modules/SolanaTokens");
+const SolanaTokens_1 = require("../chain/modules/SolanaTokens");
 const BN = require("bn.js");
 function toPublicKeyOrNull(str) {
     return str == null ? null : new web3_js_1.PublicKey(str);
 }
 class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
-    constructor(connection, btcRelay, storage, programAddress, retryPolicy, solanaFeeEstimator = btcRelay.Fees || new SolanaFees_1.SolanaFees(connection)) {
-        super(connection, programIdl, programAddress, retryPolicy, solanaFeeEstimator);
+    constructor(chainInterface, btcRelay, storage, programAddress) {
+        super(chainInterface, programIdl, programAddress);
         ////////////////////////
         //// Constants
         this.ESCROW_STATE_RENT_EXEMPT = 2658720;
@@ -44,11 +41,11 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
         this.claimGracePeriod = 10 * 60;
         this.refundGracePeriod = 10 * 60;
         this.authGracePeriod = 5 * 60;
-        this.Init = new SwapInit_1.SwapInit(this);
-        this.Refund = new SwapRefund_1.SwapRefund(this);
-        this.Claim = new SwapClaim_1.SwapClaim(this, btcRelay);
-        this.DataAccount = new SolanaDataAccount_1.SolanaDataAccount(this, storage);
-        this.LpVault = new SolanaLpVault_1.SolanaLpVault(this);
+        this.Init = new SwapInit_1.SwapInit(chainInterface, this);
+        this.Refund = new SwapRefund_1.SwapRefund(chainInterface, this);
+        this.Claim = new SwapClaim_1.SwapClaim(chainInterface, this, btcRelay);
+        this.DataAccount = new SolanaDataAccount_1.SolanaDataAccount(chainInterface, this, storage);
+        this.LpVault = new SolanaLpVault_1.SolanaLpVault(chainInterface, this);
     }
     async start() {
         await this.DataAccount.init();
@@ -86,10 +83,10 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
         return this.Refund.isSignatureValid(swapData, timeout, prefix, signature);
     }
     getDataSignature(signer, data) {
-        return this.Signatures.getDataSignature(signer, data);
+        return this.Chain.Signatures.getDataSignature(signer, data);
     }
     isValidDataSignature(data, signature, publicKey) {
-        return this.Signatures.isValidDataSignature(data, signature, publicKey);
+        return this.Chain.Signatures.isValidDataSignature(data, signature, publicKey);
     }
     ////////////////////////////////////////////
     //// Swap data utils
@@ -280,19 +277,12 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     ////////////////////////////////////////////
     //// Utils
     async getBalance(signer, tokenAddress, inContract) {
+        if (!inContract) {
+            return await this.Chain.getBalance(signer, tokenAddress);
+        }
         const token = new web3_js_1.PublicKey(tokenAddress);
         const publicKey = new web3_js_1.PublicKey(signer);
-        if (inContract)
-            return await this.getIntermediaryBalance(publicKey, token);
-        let { balance } = await this.Tokens.getTokenBalance(publicKey, token);
-        if (token.equals(SolanaTokens_1.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, token) {
         return this.LpVault.getIntermediaryData(new web3_js_1.PublicKey(address), new web3_js_1.PublicKey(token));
@@ -303,12 +293,6 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     getIntermediaryBalance(address, token) {
         return this.LpVault.getIntermediaryBalance(address, token);
     }
-    isValidAddress(address) {
-        return this.Addresses.isValidAddress(address);
-    }
-    getNativeCurrencyAddress() {
-        return this.Tokens.getNativeCurrencyAddress().toString();
-    }
     ////////////////////////////////////////////
     //// Transaction initializers
     async txsClaimWithSecret(signer, swapData, secret, checkExpiry, initAta, feeRate, skipAtaCheck) {
@@ -343,14 +327,11 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     txsDeposit(signer, token, amount, feeRate) {
         return this.LpVault.txsDeposit(new web3_js_1.PublicKey(signer), new web3_js_1.PublicKey(token), amount, feeRate);
     }
-    txsTransfer(signer, token, amount, dstAddress, feeRate) {
-        return this.Tokens.txsTransfer(new web3_js_1.PublicKey(signer), new web3_js_1.PublicKey(token), amount, new web3_js_1.PublicKey(dstAddress), feeRate);
-    }
     ////////////////////////////////////////////
     //// Executors
     async claimWithSecret(signer, swapData, secret, checkExpiry, initAta, txOptions) {
         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;
     }
     async claimWithTxData(signer, swapData, tx, requiredConfirmations, vout, commitedHeader, synchronizer, initAta, txOptions) {
@@ -363,18 +344,18 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
         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;
     }
     async refund(signer, swapData, check, initAta, txOptions) {
         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;
     }
     async refundWithAuthorization(signer, swapData, signature, check, initAta, txOptions) {
         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;
     }
     async init(signer, swapData, signature, skipChecks, txOptions) {
@@ -387,7 +368,7 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
                 throw new Error("Invalid signer provided!");
         }
         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;
     }
     async initAndClaimWithSecret(signer, swapData, signature, secret, skipChecks, txOptions) {
@@ -395,41 +376,19 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
             throw new Error("Invalid signer provided!");
         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(signer, token, amount, txOptions) {
         const txs = await this.LpVault.txsWithdraw(signer.getPublicKey(), new web3_js_1.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;
     }
     async deposit(signer, token, amount, txOptions) {
         const txs = await this.LpVault.txsDeposit(signer.getPublicKey(), new web3_js_1.PublicKey(token), amount, txOptions?.feeRate);
-        const [txId] = await this.Transactions.sendAndConfirm(signer, txs, txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
-        return txId;
-    }
-    async transfer(signer, token, amount, dstAddress, txOptions) {
-        const txs = await this.Tokens.txsTransfer(signer.getPublicKey(), new web3_js_1.PublicKey(token), amount, new web3_js_1.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, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
-        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
-    }
-    serializeTx(tx) {
-        return this.Transactions.serializeTx(tx);
-    }
-    deserializeTx(txData) {
-        return this.Transactions.deserializeTx(txData);
-    }
-    getTxIdStatus(txId) {
-        return this.Transactions.getTxIdStatus(txId);
-    }
-    getTxStatus(tx) {
-        return this.Transactions.getTxStatus(tx);
-    }
-    ////////////////////////////////////////////
     //// Fees
     getInitPayInFeeRate(offerer, claimer, token, claimHash) {
         const paymentHash = claimHash == null ? null : (0, Utils_1.fromClaimHash)(claimHash).paymentHash;
@@ -475,41 +434,6 @@ class SolanaSwapProgram extends SolanaProgramBase_1.SolanaProgramBase {
     getRawRefundFee(swapData, feeRate) {
         return this.Refund.getRawRefundFee(swapData, feeRate);
     }
-    ///////////////////////////////////
-    //// Callbacks & handlers
-    offBeforeTxReplace(callback) {
-        return true;
-    }
-    onBeforeTxReplace(callback) { }
-    onBeforeTxSigned(callback) {
-        this.Transactions.onBeforeTxSigned(callback);
-    }
-    offBeforeTxSigned(callback) {
-        return this.Transactions.offBeforeTxSigned(callback);
-    }
-    onSendTransaction(callback) {
-        this.Transactions.onSendTransaction(callback);
-    }
-    offSendTransaction(callback) {
-        return this.Transactions.offSendTransaction(callback);
-    }
-    isValidToken(tokenIdentifier) {
-        try {
-            new web3_js_1.PublicKey(tokenIdentifier);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    randomAddress() {
-        return web3_js_1.Keypair.generate().publicKey.toString();
-    }
-    randomSigner() {
-        const keypair = web3_js_1.Keypair.generate();
-        const wallet = new SolanaKeypairWallet_1.SolanaKeypairWallet(keypair);
-        return new SolanaSigner_1.SolanaSigner(wallet, keypair);
-    }
     getExtraData(outputScript, amount, confirmations, nonce) {
         return buffer_1.Buffer.from((0, sha2_1.sha256)(buffer_1.Buffer.concat([
             base_1.BigIntBufferUtils.toBuffer(amount, "le", 8),

package/dist/solana/swaps/modules/SolanaDataAccount.d.ts

@@ -3,8 +3,9 @@ import { SolanaSwapModule } from "../SolanaSwapModule";
 import { PublicKey, Signer } from "@solana/web3.js";
 import { IStorageManager, StorageObject } from "@atomiqlabs/base";
 import { SolanaSwapProgram } from "../SolanaSwapProgram";
-import { SolanaTx } from "../../base/modules/SolanaTransactions";
+import { SolanaTx } from "../../chain/modules/SolanaTransactions";
 import { SolanaSigner } from "../../wallet/SolanaSigner";
+import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
 export declare class StoredDataAccount implements StorageObject {
     accountKey: PublicKey;
     owner: PublicKey;
@@ -46,7 +47,7 @@ export declare class SolanaDataAccount extends SolanaSwapModule {
      * @returns {Promise<{bytesWritten: number, action: SolanaAction}>} bytes written to the data account & action
      */
     private WriteData;
-    constructor(root: SolanaSwapProgram, storage: IStorageManager<StoredDataAccount>);
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, storage: IStorageManager<StoredDataAccount>);
     /**
      * Saves data account to the storage, the storage is required such that we are able to close the accounts later
      *  manually in case the claim doesn't happen (expires due to fees, etc.)

package/dist/solana/swaps/modules/SolanaDataAccount.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaDataAccount = exports.StoredDataAccount = void 0;
 const SolanaSwapModule_1 = require("../SolanaSwapModule");
 const web3_js_1 = require("@solana/web3.js");
-const SolanaAction_1 = require("../../base/SolanaAction");
+const SolanaAction_1 = require("../../chain/SolanaAction");
 const Utils_1 = require("../../../utils/Utils");
 const SolanaSigner_1 = require("../../wallet/SolanaSigner");
 const utils_1 = require("@noble/hashes/utils");
@@ -44,9 +44,9 @@ class SolanaDataAccount extends SolanaSwapModule_1.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,
@@ -62,7 +62,7 @@ class SolanaDataAccount extends SolanaSwapModule_1.SolanaSwapModule {
      * @param publicKey
      */
     async CloseDataAccount(signer, publicKey) {
-        return new SolanaAction_1.SolanaAction(signer, this.root, await this.program.methods
+        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
             .closeData()
             .accounts({
             signer,
@@ -86,7 +86,7 @@ class SolanaDataAccount extends SolanaSwapModule_1.SolanaSwapModule {
         const writeLen = Math.min(writeData.length - offset, sizeLimit);
         return {
             bytesWritten: writeLen,
-            action: new SolanaAction_1.SolanaAction(signer, this.root, await this.program.methods
+            action: new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
                 .writeData(offset, writeData.slice(offset, offset + writeLen))
                 .accounts({
                 signer,
@@ -95,10 +95,10 @@ class SolanaDataAccount extends SolanaSwapModule_1.SolanaSwapModule {
                 .instruction(), SolanaDataAccount.CUCosts.DATA_WRITE)
         };
     }
-    constructor(root, storage) {
-        super(root);
-        this.SwapTxDataAlt = this.root.keypair((reversedTxId, signer) => [Buffer.from(signer.secretKey), reversedTxId]);
-        this.SwapTxDataAltBuffer = this.root.keypair((reversedTxId, secret) => [secret, reversedTxId]);
+    constructor(chainInterface, program, storage) {
+        super(chainInterface, program);
+        this.SwapTxDataAlt = this.program.keypair((reversedTxId, signer) => [Buffer.from(signer.secretKey), reversedTxId]);
+        this.SwapTxDataAltBuffer = this.program.keypair((reversedTxId, secret) => [secret, reversedTxId]);
         this.storage = storage;
     }
     /**

package/dist/solana/swaps/modules/SolanaLpVault.d.ts

@@ -1,6 +1,6 @@
 import { SolanaSwapModule } from "../SolanaSwapModule";
 import { PublicKey } from "@solana/web3.js";
-import { SolanaTx } from "../../base/modules/SolanaTransactions";
+import { SolanaTx } from "../../chain/modules/SolanaTransactions";
 import { IntermediaryReputationType } from "@atomiqlabs/base";
 export declare class SolanaLpVault extends SolanaSwapModule {
     private static readonly CUCosts;

package/dist/solana/swaps/modules/SolanaLpVault.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaLpVault = void 0;
 const SolanaSwapModule_1 = require("../SolanaSwapModule");
-const SolanaAction_1 = require("../../base/SolanaAction");
+const SolanaAction_1 = require("../../chain/SolanaAction");
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const Utils_1 = require("../../../utils/Utils");
-const SolanaTokens_1 = require("../../base/modules/SolanaTokens");
+const SolanaTokens_1 = require("../../chain/modules/SolanaTokens");
 class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
     /**
      * Action for withdrawing funds from the LP vault
@@ -19,14 +19,14 @@ class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
      */
     async Withdraw(signer, token, amount) {
         const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
-        return new SolanaAction_1.SolanaAction(signer, this.root, await this.program.methods
+        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
             .withdraw((0, Utils_1.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: spl_token_1.TOKEN_PROGRAM_ID
         })
@@ -43,14 +43,14 @@ class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
      */
     async Deposit(signer, token, amount) {
         const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(token, signer);
-        return new SolanaAction_1.SolanaAction(signer, this.root, await this.program.methods
+        return new SolanaAction_1.SolanaAction(signer, this.root, await this.swapProgram.methods
             .deposit((0, Utils_1.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: web3_js_1.SystemProgram.programId,
             tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
@@ -64,7 +64,7 @@ class SolanaLpVault extends SolanaSwapModule_1.SolanaSwapModule {
      * @param token
      */
     async getIntermediaryData(address, token) {
-        const data = await this.program.account.userAccount.fetchNullable(this.root.SwapUserVault(address, token));
+        const data = await this.swapProgram.account.userAccount.fetchNullable(this.program.SwapUserVault(address, token));
         if (data == null)
             return null;
         const response = [];
@@ -161,8 +161,8 @@ class SolanaLpVault extends SolanaSwapModule_1.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/dist/solana/swaps/modules/SwapClaim.d.ts

@@ -2,11 +2,12 @@ import { SolanaSwapModule } from "../SolanaSwapModule";
 import { SolanaSwapData } from "../SolanaSwapData";
 import { RelaySynchronizer } from "@atomiqlabs/base";
 import { PublicKey } from "@solana/web3.js";
-import { SolanaTx } from "../../base/modules/SolanaTransactions";
+import { SolanaTx } from "../../chain/modules/SolanaTransactions";
 import { SolanaBtcStoredHeader } from "../../btcrelay/headers/SolanaBtcStoredHeader";
 import { SolanaBtcRelay } from "../../btcrelay/SolanaBtcRelay";
 import { SolanaSwapProgram } from "../SolanaSwapProgram";
 import { SolanaSigner } from "../../wallet/SolanaSigner";
+import { SolanaChainInterface } from "../../chain/SolanaChainInterface";
 export declare class SwapClaim extends SolanaSwapModule {
     private static readonly CUCosts;
     readonly btcRelay: SolanaBtcRelay<any>;
@@ -34,7 +35,7 @@ export declare class SwapClaim extends SolanaSwapModule {
      * @private
      */
     private VerifyAndClaim;
-    constructor(root: SolanaSwapProgram, btcRelay: SolanaBtcRelay<any>);
+    constructor(chainInterface: SolanaChainInterface, program: SolanaSwapProgram, btcRelay: SolanaBtcRelay<any>);
     /**
      * Gets the compute budget required for claiming the swap
      *