@xchainjs/xchain-solana 0.0.4 → 0.0.6

package/lib/index.esm.js

@@ -1,12 +1,12 @@
-import { mplTokenMetadata, fetchAllDigitalAsset, fetchDigitalAsset } from '@metaplex-foundation/mpl-token-metadata';
+import { mplTokenMetadata, fetchDigitalAsset, fetchAllDigitalAsset } from '@metaplex-foundation/mpl-token-metadata';
 import { publicKey } from '@metaplex-foundation/umi';
 import { createUmi } from '@metaplex-foundation/umi-bundle-defaults';
 import { isAddress } from '@solana/addresses';
 import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, getAccount, createTransferInstruction, TokenAccountNotFoundError, TokenInvalidAccountOwnerError, getOrCreateAssociatedTokenAccount } from '@solana/spl-token';
 import { Connection, clusterApiUrl, Keypair, PublicKey, Transaction, SystemProgram, TransactionInstruction, ComputeBudgetProgram, SendTransactionError } from '@solana/web3.js';
-import { ExplorerProvider, Network, BaseXChainClient, FeeType, FeeOption, TxType } from '@xchainjs/xchain-client';
+import { ExplorerProvider, Network, BaseXChainClient, TxType, FeeType, FeeOption } from '@xchainjs/xchain-client';
 import { getSeed } from '@xchainjs/xchain-crypto';
-import { AssetType, baseAmount, assetFromStringEx, eqAsset, getContractAddressFromAsset, assetToBase, assetAmount } from '@xchainjs/xchain-util';
+import { AssetType, baseAmount, assetToBase, assetAmount, assetFromStringEx, eqAsset, getContractAddressFromAsset } from '@xchainjs/xchain-util';
 import bs58 from 'bs58';
 import { HDKey } from 'micro-ed25519-hdkey';
 
@@ -24,7 +24,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -87,8 +87,55 @@ class Client extends BaseXChainClient {
     constructor(params = defaultSolanaParams) {
         super(SOLChain, Object.assign(Object.assign({}, defaultSolanaParams), params));
         this.explorerProviders = params.explorerProviders;
-        this.connection = new Connection(clusterApiUrl(getSolanaNetwork(this.getNetwork())));
-        this.umi = createUmi(this.connection).use(mplTokenMetadata());
+        this.clientUrls = params.clientUrls;
+        if (!this.clientUrls) {
+            const solanaProvider = new Connection(clusterApiUrl(getSolanaNetwork(this.getNetwork())));
+            const umiProvider = createUmi(solanaProvider).use(mplTokenMetadata());
+            this.providers = [
+                {
+                    solanaProvider,
+                    umiProvider,
+                },
+            ];
+        }
+        else {
+            this.providers = this.clientUrls[this.getNetwork()].map((url) => {
+                const solanaProvider = new Connection(url);
+                const umiProvider = createUmi(solanaProvider).use(mplTokenMetadata());
+                return {
+                    solanaProvider,
+                    umiProvider,
+                };
+            });
+        }
+    }
+    /**
+     * Set or update the current network.
+     * @param {Network} network The network to set
+     * @returns {void}
+     */
+    setNetwork(network) {
+        super.setNetwork(network);
+        if (!this.clientUrls) {
+            const solanaProvider = new Connection(clusterApiUrl(getSolanaNetwork(this.getNetwork())));
+            const umiProvider = createUmi(solanaProvider).use(mplTokenMetadata());
+            this.providers = [
+                {
+                    solanaProvider,
+                    umiProvider,
+                },
+            ];
+        }
+        else {
+            this.providers = this.clientUrls[this.getNetwork()].map((url) => {
+                const solanaProvider = new Connection(url);
+                const umiProvider = createUmi(solanaProvider).use(mplTokenMetadata());
+                return {
+                    solanaProvider,
+                    umiProvider,
+                };
+            });
+        }
     }
     /**
      * Get information about the native asset of the Solana.
@@ -173,39 +220,7 @@ class Client extends BaseXChainClient {
      */
     getBalance(address, assets) {
         return __awaiter(this, void 0, void 0, function* () {
-            const balances = [];
-            const nativeBalance = yield this.connection.getBalance(new PublicKey(address));
-            balances.push({
-                asset: SOLAsset,
-                amount: baseAmount(nativeBalance, SOL_DECIMALS),
-            });
-            const tokenBalances = yield this.connection.getParsedTokenAccountsByOwner(new PublicKey(address), {
-                programId: TOKEN_PROGRAM_ID,
-            });
-            const tokensToRequest = !assets
-                ? tokenBalances.value
-                : tokenBalances.value.filter((tokenBalance) => {
-                    const tokenData = tokenBalance.account.data.parsed;
-                    return (assets.findIndex((asset) => {
-                        return asset.symbol.toLowerCase().includes(tokenData.info.mint.toLowerCase());
-                    }) !== -1);
-                });
-            const mintPublicKeys = tokensToRequest.map((tokenBalance) => {
-                const tokenData = tokenBalance.account.data.parsed;
-                return publicKey(tokenData.info.mint);
-            });
-            const assetsData = yield fetchAllDigitalAsset(this.umi, mintPublicKeys);
-            tokenBalances.value.forEach((balance) => {
-                const parsedData = balance.account.data.parsed;
-                const assetData = assetsData.find((assetData) => assetData.publicKey.toString() === parsedData.info.mint);
-                if (assetData) {
-                    balances.push({
-                        amount: baseAmount(parsedData.info.tokenAmount.amount, parsedData.info.tokenAmount.decimals),
-                        asset: assetFromStringEx(`SOL.${assetData.metadata.symbol.trim()}-${parsedData.info.mint}`),
-                    });
-                }
-            });
-            return balances;
+            return this.roundRobinGetBalance(address, assets);
         });
     }
     /**
@@ -219,64 +234,7 @@ class Client extends BaseXChainClient {
         return __awaiter(this, void 0, void 0, function* () {
             if (!params)
                 throw new Error('Params need to be passed');
-            const sender = Keypair.generate();
-            const toPubkey = new PublicKey(params.recipient);
-            const transaction = new Transaction();
-            transaction.recentBlockhash = yield this.connection.getLatestBlockhash().then((block) => block.blockhash);
-            transaction.feePayer = sender.publicKey;
-            let createAccountTxFee = 0;
-            if (!params.asset || eqAsset(params.asset, this.getAssetInfo().asset)) {
-                // Native transfer
-                transaction.add(SystemProgram.transfer({
-                    fromPubkey: sender.publicKey,
-                    toPubkey,
-                    lamports: params.amount.amount().toNumber(),
-                }));
-            }
-            else {
-                // Token transfer
-                const mintAddress = new PublicKey(getContractAddressFromAsset(params.asset));
-                const associatedTokenAddress = getAssociatedTokenAddressSync(mintAddress, toPubkey);
-                try {
-                    yield getAccount(this.connection, associatedTokenAddress, undefined, TOKEN_PROGRAM_ID);
-                    transaction.add(createTransferInstruction(sender.publicKey, // Should be Token account, but as it new KeyPair for estimation, sender public key
-                    associatedTokenAddress, sender.publicKey, params.amount.amount().toNumber()));
-                }
-                catch (error) {
-                    if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
-                        // recipient token account has to be created
-                        const dataLength = 165; // Normally used for Token accounts
-                        createAccountTxFee = yield this.connection.getMinimumBalanceForRentExemption(dataLength);
-                        transaction.add(createTransferInstruction(sender.publicKey, // Should be Token account, but as it new KeyPair for estimation, sender public key
-                        toPubkey, // Should be Token account, but as recipient token account should be created, recipient public key
-                        sender.publicKey, params.amount.amount().toNumber()));
-                    }
-                }
-            }
-            if (params.memo) {
-                transaction.add(new TransactionInstruction({
-                    keys: [{ pubkey: sender.publicKey, isSigner: true, isWritable: true }],
-                    data: Buffer.from(params.memo, 'utf-8'),
-                    programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
-                }));
-            }
-            if (params.priorityFee) {
-                transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: params.priorityFee.amount().toNumber() / Math.pow(10, 3),
-                }));
-            }
-            if (params.limit) {
-                transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
-                    units: params.limit,
-                }));
-            }
-            const fee = (yield transaction.getEstimatedFee(this.connection)) || 0;
-            return {
-                type: FeeType.FlatFee,
-                [FeeOption.Average]: baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
-                [FeeOption.Fast]: baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
-                [FeeOption.Fastest]: baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
-            };
+            return this.roundRobinGetFees(params);
         });
     }
     /**
@@ -287,29 +245,21 @@ class Client extends BaseXChainClient {
      */
     getTransactionData(txId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const transaction = yield this.connection.getParsedTransaction(txId);
+            const transaction = yield this.roundRobinGetTransactionData(txId);
             if (!transaction)
                 throw Error('Can not find transaction');
             return this.parseTransaction(transaction);
         });
     }
+    /**
+     * Get the transaction history of a given address with pagination options.
+     *
+     * @param {TxHistoryParams} params The options to get transaction history.
+     * @returns {TxsPage} The transaction history.
+     */
     getTransactions(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const signatures = yield this.connection.getSignaturesForAddress(new PublicKey((params === null || params === void 0 ? void 0 : params.address) || (yield this.getAddressAsync())));
-            const transactions = yield this.connection.getParsedTransactions(signatures.map(({ signature }) => signature));
-            const results = yield Promise.allSettled(transactions
-                .filter((transaction) => !!transaction)
-                .map((transaction) => this.parseTransaction(transaction)));
-            const txs = [];
-            results.forEach((result) => {
-                if (result.status === 'fulfilled') {
-                    txs.push(result.value);
-                }
-            });
-            return {
-                txs,
-                total: txs.length,
-            };
+            return this.roundRobinGetTransactions(params);
         });
     }
     /**
@@ -320,14 +270,8 @@ class Client extends BaseXChainClient {
      */
     transfer({ walletIndex, recipient, asset, amount, memo, limit, priorityFee, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const senderKeyPair = this.getPrivateKeyPair(walletIndex || 0);
-            if (asset && !eqAsset(asset, this.getAssetInfo().asset)) {
-                // Check if receipt token account is created, otherwise, create it
-                const mintAddress = new PublicKey(getContractAddressFromAsset(asset));
-                yield getOrCreateAssociatedTokenAccount(this.connection, senderKeyPair, mintAddress, new PublicKey(recipient));
-            }
-            const { rawUnsignedTx } = yield this.prepareTx({
-                sender: senderKeyPair.publicKey.toBase58(),
+            return this.roundRobinTransfer({
+                walletIndex,
                 recipient,
                 asset,
                 amount,
@@ -335,9 +279,6 @@ class Client extends BaseXChainClient {
                 limit,
                 priorityFee,
             });
-            const transaction = Transaction.from(bs58.decode(rawUnsignedTx));
-            transaction.sign(senderKeyPair);
-            return this.broadcastTx(bs58.encode(transaction.serialize()));
         });
     }
     /**
@@ -347,16 +288,7 @@ class Client extends BaseXChainClient {
      */
     broadcastTx(txHex) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const transaction = Transaction.from(bs58.decode(txHex));
-                return yield this.connection.sendRawTransaction(transaction.serialize());
-            }
-            catch (e) {
-                if (e instanceof SendTransactionError) {
-                    console.log(yield e.getLogs(this.connection));
-                }
-                throw Error('Can not broadcast transaction. Unknown error');
-            }
+            return this.roundRobinBroadcastTx(txHex);
         });
     }
     /**
@@ -367,64 +299,15 @@ class Client extends BaseXChainClient {
      */
     prepareTx({ sender, recipient, asset, amount, memo, limit, priorityFee, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const transaction = new Transaction();
-            const fromPubkey = new PublicKey(sender);
-            const toPubkey = new PublicKey(recipient);
-            transaction.recentBlockhash = yield this.connection.getLatestBlockhash().then((block) => block.blockhash);
-            transaction.feePayer = new PublicKey(sender);
-            if (!asset || eqAsset(asset, this.getAssetInfo().asset)) {
-                // Native transfer
-                transaction.add(SystemProgram.transfer({
-                    fromPubkey,
-                    toPubkey,
-                    lamports: amount.amount().toNumber(),
-                }));
-            }
-            else {
-                // Token transfer
-                const mintAddress = new PublicKey(getContractAddressFromAsset(asset));
-                const fromAssociatedAccount = getAssociatedTokenAddressSync(mintAddress, fromPubkey);
-                let fromTokenAccount;
-                try {
-                    fromTokenAccount = yield getAccount(this.connection, fromAssociatedAccount);
-                }
-                catch (error) {
-                    if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
-                        throw Error('Can not find sender Token account');
-                    }
-                    throw error;
-                }
-                const toAssociatedAccount = getAssociatedTokenAddressSync(mintAddress, toPubkey);
-                let toTokenAccount;
-                try {
-                    toTokenAccount = yield getAccount(this.connection, toAssociatedAccount);
-                }
-                catch (error) {
-                    if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
-                        throw Error('Can not find recipient Token account. Create it first');
-                    }
-                    throw error;
-                }
-                transaction.add(createTransferInstruction(fromTokenAccount.address, toTokenAccount.address, fromPubkey, amount.amount().toNumber()));
-            }
-            if (memo) {
-                transaction.add(new TransactionInstruction({
-                    keys: [{ pubkey: fromPubkey, isSigner: true, isWritable: true }],
-                    data: Buffer.from(memo, 'utf-8'),
-                    programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
-                }));
-            }
-            if (priorityFee) {
-                transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: priorityFee.amount().toNumber() / Math.pow(10, 3),
-                }));
-            }
-            if (limit) {
-                transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
-                    units: limit,
-                }));
-            }
-            return { rawUnsignedTx: bs58.encode(transaction.serialize({ verifySignatures: false })) };
+            return this.roundRobinPrepareTx({
+                sender,
+                recipient,
+                asset,
+                amount,
+                memo,
+                limit,
+                priorityFee,
+            });
         });
     }
     getPrivateKeyPair(index) {
@@ -473,23 +356,28 @@ class Client extends BaseXChainClient {
                         const assetDecimals = tx.meta.postTokenBalances[i].uiTokenAmount.decimals;
                         const mintAddress = tx.meta.postTokenBalances[i].mint;
                         const owner = tx.meta.postTokenBalances[i].owner;
-                        const tokenMetadata = yield fetchDigitalAsset(this.umi, publicKey(mintAddress));
-                        if (owner) {
-                            if (postBalanceAmount > preBalanceAmount) {
-                                to.push({
-                                    amount: assetToBase(assetAmount(postBalanceAmount - preBalanceAmount, assetDecimals)),
-                                    asset: assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
-                                    to: owner,
-                                });
-                            }
-                            else if (preBalanceAmount > postBalanceAmount) {
-                                from.push({
-                                    amount: assetToBase(assetAmount(preBalanceAmount - postBalanceAmount, assetDecimals)),
-                                    asset: assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
-                                    from: owner,
-                                });
+                        try {
+                            for (const provider of this.providers) {
+                                const tokenMetadata = yield fetchDigitalAsset(provider.umiProvider, publicKey(mintAddress));
+                                if (owner) {
+                                    if (postBalanceAmount > preBalanceAmount) {
+                                        to.push({
+                                            amount: assetToBase(assetAmount(postBalanceAmount - preBalanceAmount, assetDecimals)),
+                                            asset: assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
+                                            to: owner,
+                                        });
+                                    }
+                                    else if (preBalanceAmount > postBalanceAmount) {
+                                        from.push({
+                                            amount: assetToBase(assetAmount(preBalanceAmount - postBalanceAmount, assetDecimals)),
+                                            asset: assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
+                                            from: owner,
+                                        });
+                                    }
+                                }
                             }
                         }
+                        catch (_d) { }
                     }
                 }
             }
@@ -503,6 +391,324 @@ class Client extends BaseXChainClient {
             };
         });
     }
+    /**
+     * Retrieves the balance of a given address making a round robin over the providers.
+     *
+     * @param {Address} address - The address to retrieve the balance for.
+     * @param {TokenAsset[]} assets - Assets to retrieve the balance for (optional).
+     * @returns {Promise<Balance[]>} An array containing the balance of the address.
+     * @throws {Error} if there is no provider able to retrieve the balances
+     */
+    roundRobinGetBalance(address, assets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const provider of this.providers) {
+                    const balances = [];
+                    const nativeBalance = yield provider.solanaProvider.getBalance(new PublicKey(address));
+                    balances.push({
+                        asset: SOLAsset,
+                        amount: baseAmount(nativeBalance, SOL_DECIMALS),
+                    });
+                    const tokenBalances = yield provider.solanaProvider.getParsedTokenAccountsByOwner(new PublicKey(address), {
+                        programId: TOKEN_PROGRAM_ID,
+                    });
+                    const tokensToRequest = !assets
+                        ? tokenBalances.value
+                        : tokenBalances.value.filter((tokenBalance) => {
+                            const tokenData = tokenBalance.account.data.parsed;
+                            return (assets.findIndex((asset) => {
+                                return asset.symbol.toLowerCase().includes(tokenData.info.mint.toLowerCase());
+                            }) !== -1);
+                        });
+                    const mintPublicKeys = tokensToRequest.map((tokenBalance) => {
+                        const tokenData = tokenBalance.account.data.parsed;
+                        return publicKey(tokenData.info.mint);
+                    });
+                    const assetsData = yield fetchAllDigitalAsset(provider.umiProvider, mintPublicKeys);
+                    tokenBalances.value.forEach((balance) => {
+                        const parsedData = balance.account.data.parsed;
+                        const assetData = assetsData.find((assetData) => assetData.publicKey.toString() === parsedData.info.mint);
+                        if (assetData) {
+                            balances.push({
+                                amount: baseAmount(parsedData.info.tokenAmount.amount, parsedData.info.tokenAmount.decimals),
+                                asset: assetFromStringEx(`SOL.${assetData.metadata.symbol.trim()}-${parsedData.info.mint}`),
+                            });
+                        }
+                    });
+                    return balances;
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to get balances.');
+        });
+    }
+    /**
+     * Get transaction fees making a round robin over the providers.
+     *
+     * @param {TxParams} params - The transaction parameters.
+     * @returns {Fees} The average, fast, and fastest fees.
+     * @throws {Error} if there is no provider able to retrieve the fees
+     */
+    roundRobinGetFees(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const provider of this.providers) {
+                    const sender = Keypair.generate();
+                    const toPubkey = new PublicKey(params.recipient);
+                    const transaction = new Transaction();
+                    transaction.recentBlockhash = yield provider.solanaProvider
+                        .getLatestBlockhash()
+                        .then((block) => block.blockhash);
+                    transaction.feePayer = sender.publicKey;
+                    let createAccountTxFee = 0;
+                    if (!params.asset || eqAsset(params.asset, this.getAssetInfo().asset)) {
+                        // Native transfer
+                        transaction.add(SystemProgram.transfer({
+                            fromPubkey: sender.publicKey,
+                            toPubkey,
+                            lamports: params.amount.amount().toNumber(),
+                        }));
+                    }
+                    else {
+                        // Token transfer
+                        const mintAddress = new PublicKey(getContractAddressFromAsset(params.asset));
+                        const associatedTokenAddress = getAssociatedTokenAddressSync(mintAddress, toPubkey);
+                        try {
+                            yield getAccount(provider.solanaProvider, associatedTokenAddress, undefined, TOKEN_PROGRAM_ID);
+                            transaction.add(createTransferInstruction(sender.publicKey, // Should be Token account, but as it new KeyPair for estimation, sender public key
+                            associatedTokenAddress, sender.publicKey, params.amount.amount().toNumber()));
+                        }
+                        catch (error) {
+                            if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+                                // recipient token account has to be created
+                                const dataLength = 165; // Normally used for Token accounts
+                                createAccountTxFee = yield provider.solanaProvider.getMinimumBalanceForRentExemption(dataLength);
+                                transaction.add(createTransferInstruction(sender.publicKey, // Should be Token account, but as it new KeyPair for estimation, sender public key
+                                toPubkey, // Should be Token account, but as recipient token account should be created, recipient public key
+                                sender.publicKey, params.amount.amount().toNumber()));
+                            }
+                        }
+                    }
+                    if (params.memo) {
+                        transaction.add(new TransactionInstruction({
+                            keys: [{ pubkey: sender.publicKey, isSigner: true, isWritable: true }],
+                            data: Buffer.from(params.memo, 'utf-8'),
+                            programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+                        }));
+                    }
+                    if (params.priorityFee) {
+                        transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: params.priorityFee.amount().toNumber() / Math.pow(10, 3),
+                        }));
+                    }
+                    if (params.limit) {
+                        transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
+                            units: params.limit,
+                        }));
+                    }
+                    const fee = (yield transaction.getEstimatedFee(provider.solanaProvider)) || 0;
+                    return {
+                        type: FeeType.FlatFee,
+                        [FeeOption.Average]: baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
+                        [FeeOption.Fast]: baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
+                        [FeeOption.Fastest]: baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
+                    };
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to get fees.');
+        });
+    }
+    /**
+     * Get the transaction details of a given transaction ID making a round robin over the providers.
+     *
+     * @param {string} txId The transaction ID.
+     * @returns {Tx} The transaction details.
+     * @throws {Error} if there is no provider able to retrieve the transaction data
+     */
+    roundRobinGetTransactionData(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const provider of this.providers) {
+                    const transaction = yield provider.solanaProvider.getParsedTransaction(txId);
+                    return transaction;
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to get transaction data.');
+        });
+    }
+    /**
+     * Get the transaction history of a given address with pagination options making a round robin over the providers.
+     *
+     * @param {TxHistoryParams} params The options to get transaction history.
+     * @returns {TxsPage} The transaction history.
+     * @throws {Error} if there is no provider able to retrieve the transactions
+     */
+    roundRobinGetTransactions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const provider of this.providers) {
+                    const signatures = yield provider.solanaProvider.getSignaturesForAddress(new PublicKey((params === null || params === void 0 ? void 0 : params.address) || (yield this.getAddressAsync())));
+                    const transactions = yield provider.solanaProvider.getParsedTransactions(signatures.map(({ signature }) => signature));
+                    const results = yield Promise.allSettled(transactions
+                        .filter((transaction) => !!transaction)
+                        .map((transaction) => this.parseTransaction(transaction)));
+                    const txs = [];
+                    results.forEach((result) => {
+                        if (result.status === 'fulfilled') {
+                            txs.push(result.value);
+                        }
+                    });
+                    return {
+                        txs,
+                        total: txs.length,
+                    };
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to get transactions.');
+        });
+    }
+    /**
+     * Transfers SOL or Solana token making a round robin over the providers
+     *
+     * @param {TxParams} params The transfer options.
+     * @returns {TxHash} The transaction hash.
+     * @throws {Error} if there is no provider able to make the transfer
+     */
+    roundRobinTransfer({ walletIndex, recipient, asset, amount, memo, limit, priorityFee, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const senderKeyPair = this.getPrivateKeyPair(walletIndex || 0);
+                for (const provider of this.providers) {
+                    if (asset && !eqAsset(asset, this.getAssetInfo().asset)) {
+                        // Check if receipt token account is created, otherwise, create it
+                        const mintAddress = new PublicKey(getContractAddressFromAsset(asset));
+                        yield getOrCreateAssociatedTokenAccount(provider.solanaProvider, senderKeyPair, mintAddress, new PublicKey(recipient));
+                    }
+                    const { rawUnsignedTx } = yield this.prepareTx({
+                        sender: senderKeyPair.publicKey.toBase58(),
+                        recipient,
+                        asset,
+                        amount,
+                        memo,
+                        limit,
+                        priorityFee,
+                    });
+                    const transaction = Transaction.from(bs58.decode(rawUnsignedTx));
+                    transaction.sign(senderKeyPair);
+                    return this.broadcastTx(bs58.encode(transaction.serialize()));
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to transfer.');
+        });
+    }
+    /**
+     * Broadcast a transaction to the network making a round robin over the providers
+     *
+     * @param {string} txHex Raw transaction to broadcast
+     * @returns {TxHash} The hash of the transaction broadcasted
+     * @throws {Error} if there is no provider able to broadcast transaction
+     */
+    roundRobinBroadcastTx(txHex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const provider of this.providers) {
+                    try {
+                        const transaction = Transaction.from(bs58.decode(txHex));
+                        return yield provider.solanaProvider.sendRawTransaction(transaction.serialize());
+                    }
+                    catch (e) {
+                        if (e instanceof SendTransactionError) {
+                            console.log(yield e.getLogs(provider.solanaProvider));
+                        }
+                        throw Error('Can not broadcast transaction. Unknown error');
+                    }
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to broadcast transaction.');
+        });
+    }
+    /**
+     * Prepares a transaction for transfer making round robin over the providers.
+     *
+     * @param {TxParams&Address} params - The transfer options.
+     * @returns {Promise<PreparedTx>} The raw unsigned transaction.
+     * @throws {Error} if there is no provider able to prepare transaction
+     */
+    roundRobinPrepareTx({ sender, recipient, asset, amount, memo, limit, priorityFee, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                for (const provider of this.providers) {
+                    const transaction = new Transaction();
+                    const fromPubkey = new PublicKey(sender);
+                    const toPubkey = new PublicKey(recipient);
+                    transaction.recentBlockhash = yield provider.solanaProvider
+                        .getLatestBlockhash()
+                        .then((block) => block.blockhash);
+                    transaction.feePayer = new PublicKey(sender);
+                    if (!asset || eqAsset(asset, this.getAssetInfo().asset)) {
+                        // Native transfer
+                        transaction.add(SystemProgram.transfer({
+                            fromPubkey,
+                            toPubkey,
+                            lamports: amount.amount().toNumber(),
+                        }));
+                    }
+                    else {
+                        // Token transfer
+                        const mintAddress = new PublicKey(getContractAddressFromAsset(asset));
+                        const fromAssociatedAccount = getAssociatedTokenAddressSync(mintAddress, fromPubkey);
+                        let fromTokenAccount;
+                        try {
+                            fromTokenAccount = yield getAccount(provider.solanaProvider, fromAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find sender Token account');
+                            }
+                            throw error;
+                        }
+                        const toAssociatedAccount = getAssociatedTokenAddressSync(mintAddress, toPubkey);
+                        let toTokenAccount;
+                        try {
+                            toTokenAccount = yield getAccount(provider.solanaProvider, toAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find recipient Token account. Create it first');
+                            }
+                            throw error;
+                        }
+                        transaction.add(createTransferInstruction(fromTokenAccount.address, toTokenAccount.address, fromPubkey, amount.amount().toNumber()));
+                    }
+                    if (memo) {
+                        transaction.add(new TransactionInstruction({
+                            keys: [{ pubkey: fromPubkey, isSigner: true, isWritable: true }],
+                            data: Buffer.from(memo, 'utf-8'),
+                            programId: new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+                        }));
+                    }
+                    if (priorityFee) {
+                        transaction.add(ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: priorityFee.amount().toNumber() / Math.pow(10, 3),
+                        }));
+                    }
+                    if (limit) {
+                        transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
+                            units: limit,
+                        }));
+                    }
+                    return { rawUnsignedTx: bs58.encode(transaction.serialize({ verifySignatures: false })) };
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to prepare transaction');
+        });
+    }
 }
 
 export { Client, SOLAsset, SOLChain, SOL_DECIMALS, defaultSolanaParams };