@atomiqlabs/chain-solana 12.0.11 → 12.0.13

package/src/solana/chain/SolanaAction.ts

@@ -1,109 +1,109 @@
-import {PublicKey, Signer, Transaction, TransactionInstruction} from "@solana/web3.js";
-import {SolanaTx} from "./modules/SolanaTransactions";
-import {SolanaChainInterface} from "./SolanaChainInterface";
-
-
-export class SolanaAction {
-
-    computeBudget: number;
-    readonly mainSigner: PublicKey;
-    private readonly root: SolanaChainInterface;
-    private readonly instructions: TransactionInstruction[];
-    private feeRate: string;
-    private readonly signers: Signer[];
-    private firstIxBeforeComputeBudget: boolean = false;
-
-    constructor(
-        mainSigner: PublicKey,
-        root: SolanaChainInterface,
-        instructions: TransactionInstruction[] | TransactionInstruction = [],
-        computeBudget: number = 0,
-        feeRate?: string,
-        signers?: Signer[],
-        firstIxBeforeComputeBudget?: boolean
-    ) {
-        this.mainSigner = mainSigner;
-        this.root = root;
-        this.instructions = Array.isArray(instructions) ? instructions : [instructions];
-        this.computeBudget = computeBudget;
-        this.feeRate = feeRate;
-        this.signers = signers || [];
-        if(firstIxBeforeComputeBudget!=null) this.firstIxBeforeComputeBudget = firstIxBeforeComputeBudget;
-    }
-
-    private estimateFee(): Promise<string> {
-        const mutableAccounts: PublicKey[] = [];
-        this.instructions.forEach(
-            ix => ix.keys.forEach(
-                key => key.isWritable && mutableAccounts.push(key.pubkey)
-            )
-        );
-        return this.root.Fees.getFeeRate(mutableAccounts);
-    }
-
-    public addIx(instruction: TransactionInstruction, computeBudget?: number, signers?: Signer[]) {
-        this.instructions.push(instruction);
-        if(this.computeBudget==null) {
-            this.computeBudget = computeBudget;
-        } else {
-            if(computeBudget!=null) this.computeBudget+=computeBudget;
-        }
-    }
-
-    public add(action: SolanaAction): this {
-        return this.addAction(action);
-    }
-
-    public addAction(action: SolanaAction, index: number = this.instructions.length): this {
-        if(action.firstIxBeforeComputeBudget) {
-            if(this.instructions.length>0)
-                throw new Error("Tried to add firstIxBeforeComputeBudget action to existing action with instructions");
-            this.firstIxBeforeComputeBudget = true;
-        }
-        if(this.firstIxBeforeComputeBudget && this.instructions.length>0 && index===0)
-            throw new Error("Tried adding to firstIxBeforeComputeBudget action on 0th index");
-        if(!action.mainSigner.equals(this.mainSigner)) throw new Error("Actions need to have the same signer!");
-        if(this.computeBudget==null && action.computeBudget!=null) this.computeBudget = action.computeBudget;
-        if(this.computeBudget!=null && action.computeBudget!=null) this.computeBudget += action.computeBudget;
-        this.instructions.splice(index, 0, ...action.instructions);
-        this.signers.push(...action.signers);
-        if(this.feeRate==null) this.feeRate = action.feeRate;
-        return this;
-    }
-
-    public async tx(feeRate?: string, block?: {blockhash: string, blockHeight: number}): Promise<SolanaTx> {
-        const tx = new Transaction();
-        tx.feePayer = this.mainSigner;
-
-        if(feeRate==null) feeRate = this.feeRate;
-        if(feeRate==null) feeRate = await this.estimateFee();
-
-        let instructions = this.instructions;
-        if(instructions.length>0 && this.firstIxBeforeComputeBudget) {
-            tx.add(this.instructions[0]);
-            instructions = this.instructions.slice(1);
-        }
-        this.root.Fees.applyFeeRateBegin(tx, this.computeBudget, feeRate);
-        instructions.forEach(ix => tx.add(ix));
-        this.root.Fees.applyFeeRateEnd(tx, this.computeBudget, feeRate);
-
-        if(block!=null) {
-            tx.recentBlockhash = block.blockhash;
-            tx.lastValidBlockHeight = block.blockHeight + this.root.TX_SLOT_VALIDITY;
-        }
-
-        return {
-            tx,
-            signers: this.signers
-        };
-    }
-
-    public async addToTxs(txs: SolanaTx[], feeRate?: string, block?: {blockhash: string, blockHeight: number}): Promise<void> {
-        txs.push(await this.tx(feeRate, block));
-    }
-
-    public ixsLength(): number {
-        return this.instructions.length;
-    }
-
+import {PublicKey, Signer, Transaction, TransactionInstruction} from "@solana/web3.js";
+import {SolanaTx} from "./modules/SolanaTransactions";
+import {SolanaChainInterface} from "./SolanaChainInterface";
+
+
+export class SolanaAction {
+
+    computeBudget: number;
+    readonly mainSigner: PublicKey;
+    private readonly root: SolanaChainInterface;
+    private readonly instructions: TransactionInstruction[];
+    private feeRate: string;
+    private readonly signers: Signer[];
+    private firstIxBeforeComputeBudget: boolean = false;
+
+    constructor(
+        mainSigner: PublicKey,
+        root: SolanaChainInterface,
+        instructions: TransactionInstruction[] | TransactionInstruction = [],
+        computeBudget: number = 0,
+        feeRate?: string,
+        signers?: Signer[],
+        firstIxBeforeComputeBudget?: boolean
+    ) {
+        this.mainSigner = mainSigner;
+        this.root = root;
+        this.instructions = Array.isArray(instructions) ? instructions : [instructions];
+        this.computeBudget = computeBudget;
+        this.feeRate = feeRate;
+        this.signers = signers || [];
+        if(firstIxBeforeComputeBudget!=null) this.firstIxBeforeComputeBudget = firstIxBeforeComputeBudget;
+    }
+
+    private estimateFee(): Promise<string> {
+        const mutableAccounts: PublicKey[] = [];
+        this.instructions.forEach(
+            ix => ix.keys.forEach(
+                key => key.isWritable && mutableAccounts.push(key.pubkey)
+            )
+        );
+        return this.root.Fees.getFeeRate(mutableAccounts);
+    }
+
+    public addIx(instruction: TransactionInstruction, computeBudget?: number, signers?: Signer[]) {
+        this.instructions.push(instruction);
+        if(this.computeBudget==null) {
+            this.computeBudget = computeBudget;
+        } else {
+            if(computeBudget!=null) this.computeBudget+=computeBudget;
+        }
+    }
+
+    public add(action: SolanaAction): this {
+        return this.addAction(action);
+    }
+
+    public addAction(action: SolanaAction, index: number = this.instructions.length): this {
+        if(action.firstIxBeforeComputeBudget) {
+            if(this.instructions.length>0)
+                throw new Error("Tried to add firstIxBeforeComputeBudget action to existing action with instructions");
+            this.firstIxBeforeComputeBudget = true;
+        }
+        if(this.firstIxBeforeComputeBudget && this.instructions.length>0 && index===0)
+            throw new Error("Tried adding to firstIxBeforeComputeBudget action on 0th index");
+        if(!action.mainSigner.equals(this.mainSigner)) throw new Error("Actions need to have the same signer!");
+        if(this.computeBudget==null && action.computeBudget!=null) this.computeBudget = action.computeBudget;
+        if(this.computeBudget!=null && action.computeBudget!=null) this.computeBudget += action.computeBudget;
+        this.instructions.splice(index, 0, ...action.instructions);
+        this.signers.push(...action.signers);
+        if(this.feeRate==null) this.feeRate = action.feeRate;
+        return this;
+    }
+
+    public async tx(feeRate?: string, block?: {blockhash: string, blockHeight: number}): Promise<SolanaTx> {
+        const tx = new Transaction();
+        tx.feePayer = this.mainSigner;
+
+        if(feeRate==null) feeRate = this.feeRate;
+        if(feeRate==null) feeRate = await this.estimateFee();
+
+        let instructions = this.instructions;
+        if(instructions.length>0 && this.firstIxBeforeComputeBudget) {
+            tx.add(this.instructions[0]);
+            instructions = this.instructions.slice(1);
+        }
+        this.root.Fees.applyFeeRateBegin(tx, this.computeBudget, feeRate);
+        instructions.forEach(ix => tx.add(ix));
+        this.root.Fees.applyFeeRateEnd(tx, this.computeBudget, feeRate);
+
+        if(block!=null) {
+            tx.recentBlockhash = block.blockhash;
+            tx.lastValidBlockHeight = block.blockHeight + this.root.TX_SLOT_VALIDITY;
+        }
+
+        return {
+            tx,
+            signers: this.signers
+        };
+    }
+
+    public async addToTxs(txs: SolanaTx[], feeRate?: string, block?: {blockhash: string, blockHeight: number}): Promise<void> {
+        txs.push(await this.tx(feeRate, block));
+    }
+
+    public ixsLength(): number {
+        return this.instructions.length;
+    }
+
 }

package/src/solana/chain/SolanaChainInterface.ts

@@ -1,193 +1,193 @@
-import {Connection, Keypair, PublicKey, SendOptions} from "@solana/web3.js";
-import {SolanaFees} from "./modules/SolanaFees";
-import {SolanaBlocks} from "./modules/SolanaBlocks";
-import {SolanaSlots} from "./modules/SolanaSlots";
-import {SolanaTokens} from "./modules/SolanaTokens";
-import {SolanaTransactions, SolanaTx} from "./modules/SolanaTransactions";
-import {SolanaSignatures} from "./modules/SolanaSignatures";
-import {SolanaEvents} from "./modules/SolanaEvents";
-import {getLogger} from "../../utils/Utils";
-import {ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
-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,
-    delay?: number,
-    exponential?: boolean,
-    transactionResendInterval?: number
-}
-
-export class SolanaChainInterface implements ChainInterface<
-    SolanaTx,
-    SolanaSigner,
-    "SOLANA",
-    Wallet
-> {
-    readonly chainId = "SOLANA";
-
-    public readonly SLOT_TIME = 400;
-    public readonly TX_SLOT_VALIDITY = 151;
-
-    readonly connection: Connection;
-    readonly retryPolicy: SolanaRetryPolicy;
-
-    public readonly Blocks: SolanaBlocks;
-    public Fees: SolanaFees;
-    public readonly Slots: SolanaSlots;
-    public readonly Tokens: SolanaTokens;
-    public readonly Transactions: SolanaTransactions;
-    public readonly Signatures: SolanaSignatures;
-    public readonly Events: SolanaEvents;
-
-    protected readonly logger = getLogger(this.constructor.name+": ");
-
-    constructor(
-        connection: Connection,
-        retryPolicy?: SolanaRetryPolicy,
-        solanaFeeEstimator: SolanaFees = new SolanaFees(connection)
-    ) {
-        this.connection = connection;
-        this.retryPolicy = retryPolicy;
-
-        this.Blocks = new SolanaBlocks(this);
-        this.Fees = solanaFeeEstimator;
-        this.Slots = new SolanaSlots(this);
-        this.Tokens = new SolanaTokens(this);
-        this.Transactions = new SolanaTransactions(this);
-        this.Signatures = new SolanaSignatures(this);
-        this.Events = new SolanaEvents(this);
-    }
-
-    async getBalance(signer: string, tokenAddress: string): Promise<bigint> {
-        const token = new PublicKey(tokenAddress);
-        const publicKey = new PublicKey(signer);
-
-        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;
-    }
-
-    isValidAddress(address: string): boolean {
-        return SolanaAddresses.isValidAddress(address);
-    }
-
-    normalizeAddress(address: string): string {
-        return address;
-    }
-
-    getNativeCurrencyAddress(): string {
-        return this.Tokens.getNativeCurrencyAddress().toString();
-    }
-
-    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);
-    }
-
-    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);
-        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);
-    }
-
-    async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
-        const {block} = await this.Blocks.findLatestParsedBlock("finalized");
-        return {
-            height: block.blockHeight,
-            blockHash: block.blockhash
-        };
-    }
-
-
-    ///////////////////////////////////
-    //// 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);
-    }
-
-    wrapSigner(signer: Wallet): Promise<SolanaSigner> {
-        return Promise.resolve(new SolanaSigner(signer));
-    }
-
+import {Connection, Keypair, PublicKey, SendOptions} from "@solana/web3.js";
+import {SolanaFees} from "./modules/SolanaFees";
+import {SolanaBlocks} from "./modules/SolanaBlocks";
+import {SolanaSlots} from "./modules/SolanaSlots";
+import {SolanaTokens} from "./modules/SolanaTokens";
+import {SolanaTransactions, SolanaTx} from "./modules/SolanaTransactions";
+import {SolanaSignatures} from "./modules/SolanaSignatures";
+import {SolanaEvents} from "./modules/SolanaEvents";
+import {getLogger} from "../../utils/Utils";
+import {ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
+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,
+    delay?: number,
+    exponential?: boolean,
+    transactionResendInterval?: number
+}
+
+export class SolanaChainInterface implements ChainInterface<
+    SolanaTx,
+    SolanaSigner,
+    "SOLANA",
+    Wallet
+> {
+    readonly chainId = "SOLANA";
+
+    public readonly SLOT_TIME = 400;
+    public readonly TX_SLOT_VALIDITY = 151;
+
+    readonly connection: Connection;
+    readonly retryPolicy: SolanaRetryPolicy;
+
+    public readonly Blocks: SolanaBlocks;
+    public Fees: SolanaFees;
+    public readonly Slots: SolanaSlots;
+    public readonly Tokens: SolanaTokens;
+    public readonly Transactions: SolanaTransactions;
+    public readonly Signatures: SolanaSignatures;
+    public readonly Events: SolanaEvents;
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    constructor(
+        connection: Connection,
+        retryPolicy?: SolanaRetryPolicy,
+        solanaFeeEstimator: SolanaFees = new SolanaFees(connection)
+    ) {
+        this.connection = connection;
+        this.retryPolicy = retryPolicy;
+
+        this.Blocks = new SolanaBlocks(this);
+        this.Fees = solanaFeeEstimator;
+        this.Slots = new SolanaSlots(this);
+        this.Tokens = new SolanaTokens(this);
+        this.Transactions = new SolanaTransactions(this);
+        this.Signatures = new SolanaSignatures(this);
+        this.Events = new SolanaEvents(this);
+    }
+
+    async getBalance(signer: string, tokenAddress: string): Promise<bigint> {
+        const token = new PublicKey(tokenAddress);
+        const publicKey = new PublicKey(signer);
+
+        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;
+    }
+
+    isValidAddress(address: string): boolean {
+        return SolanaAddresses.isValidAddress(address);
+    }
+
+    normalizeAddress(address: string): string {
+        return address;
+    }
+
+    getNativeCurrencyAddress(): string {
+        return this.Tokens.getNativeCurrencyAddress().toString();
+    }
+
+    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);
+    }
+
+    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);
+        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);
+    }
+
+    async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
+        const {block} = await this.Blocks.findLatestParsedBlock("finalized");
+        return {
+            height: block.blockHeight,
+            blockHash: block.blockhash
+        };
+    }
+
+
+    ///////////////////////////////////
+    //// 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);
+    }
+
+    wrapSigner(signer: Wallet): Promise<SolanaSigner> {
+        return Promise.resolve(new SolanaSigner(signer));
+    }
+
 }

package/src/solana/chain/SolanaModule.ts

@@ -1,21 +1,21 @@
-import {Connection} from "@solana/web3.js";
-import {SolanaChainInterface, SolanaRetryPolicy} from "./SolanaChainInterface";
-import {getLogger} from "../../utils/Utils";
-
-export class SolanaModule {
-
-    protected readonly connection: Connection;
-    protected readonly retryPolicy: SolanaRetryPolicy;
-    protected readonly root: SolanaChainInterface;
-
-    protected readonly logger = getLogger(this.constructor.name+": ");
-
-    constructor(
-        root: SolanaChainInterface
-    ) {
-        this.connection = root.connection;
-        this.retryPolicy = root.retryPolicy;
-        this.root = root;
-    }
-
+import {Connection} from "@solana/web3.js";
+import {SolanaChainInterface, SolanaRetryPolicy} from "./SolanaChainInterface";
+import {getLogger} from "../../utils/Utils";
+
+export class SolanaModule {
+
+    protected readonly connection: Connection;
+    protected readonly retryPolicy: SolanaRetryPolicy;
+    protected readonly root: SolanaChainInterface;
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    constructor(
+        root: SolanaChainInterface
+    ) {
+        this.connection = root.connection;
+        this.retryPolicy = root.retryPolicy;
+        this.root = root;
+    }
+
 }