@xchainjs/xchain-solana 0.0.4 → 0.0.6

package/lib/index.js

@@ -12,6 +12,10 @@ var xchainUtil = require('@xchainjs/xchain-util');
 var bs58 = require('bs58');
 var microEd25519Hdkey = require('micro-ed25519-hdkey');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -26,7 +30,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) {
@@ -89,8 +93,55 @@ class Client extends xchainClient.BaseXChainClient {
     constructor(params = defaultSolanaParams) {
         super(SOLChain, Object.assign(Object.assign({}, defaultSolanaParams), params));
         this.explorerProviders = params.explorerProviders;
-        this.connection = new web3_js.Connection(web3_js.clusterApiUrl(getSolanaNetwork(this.getNetwork())));
-        this.umi = umiBundleDefaults.createUmi(this.connection).use(mplTokenMetadata.mplTokenMetadata());
+        this.clientUrls = params.clientUrls;
+        if (!this.clientUrls) {
+            const solanaProvider = new web3_js.Connection(web3_js.clusterApiUrl(getSolanaNetwork(this.getNetwork())));
+            const umiProvider = umiBundleDefaults.createUmi(solanaProvider).use(mplTokenMetadata.mplTokenMetadata());
+            this.providers = [
+                {
+                    solanaProvider,
+                    umiProvider,
+                },
+            ];
+        }
+        else {
+            this.providers = this.clientUrls[this.getNetwork()].map((url) => {
+                const solanaProvider = new web3_js.Connection(url);
+                const umiProvider = umiBundleDefaults.createUmi(solanaProvider).use(mplTokenMetadata.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 web3_js.Connection(web3_js.clusterApiUrl(getSolanaNetwork(this.getNetwork())));
+            const umiProvider = umiBundleDefaults.createUmi(solanaProvider).use(mplTokenMetadata.mplTokenMetadata());
+            this.providers = [
+                {
+                    solanaProvider,
+                    umiProvider,
+                },
+            ];
+        }
+        else {
+            this.providers = this.clientUrls[this.getNetwork()].map((url) => {
+                const solanaProvider = new web3_js.Connection(url);
+                const umiProvider = umiBundleDefaults.createUmi(solanaProvider).use(mplTokenMetadata.mplTokenMetadata());
+                return {
+                    solanaProvider,
+                    umiProvider,
+                };
+            });
+        }
     }
     /**
      * Get information about the native asset of the Solana.
@@ -175,39 +226,7 @@ class Client extends xchainClient.BaseXChainClient {
      */
     getBalance(address, assets) {
         return __awaiter(this, void 0, void 0, function* () {
-            const balances = [];
-            const nativeBalance = yield this.connection.getBalance(new web3_js.PublicKey(address));
-            balances.push({
-                asset: SOLAsset,
-                amount: xchainUtil.baseAmount(nativeBalance, SOL_DECIMALS),
-            });
-            const tokenBalances = yield this.connection.getParsedTokenAccountsByOwner(new web3_js.PublicKey(address), {
-                programId: splToken.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 umi.publicKey(tokenData.info.mint);
-            });
-            const assetsData = yield mplTokenMetadata.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: xchainUtil.baseAmount(parsedData.info.tokenAmount.amount, parsedData.info.tokenAmount.decimals),
-                        asset: xchainUtil.assetFromStringEx(`SOL.${assetData.metadata.symbol.trim()}-${parsedData.info.mint}`),
-                    });
-                }
-            });
-            return balances;
+            return this.roundRobinGetBalance(address, assets);
         });
     }
     /**
@@ -221,64 +240,7 @@ class Client extends xchainClient.BaseXChainClient {
         return __awaiter(this, void 0, void 0, function* () {
             if (!params)
                 throw new Error('Params need to be passed');
-            const sender = web3_js.Keypair.generate();
-            const toPubkey = new web3_js.PublicKey(params.recipient);
-            const transaction = new web3_js.Transaction();
-            transaction.recentBlockhash = yield this.connection.getLatestBlockhash().then((block) => block.blockhash);
-            transaction.feePayer = sender.publicKey;
-            let createAccountTxFee = 0;
-            if (!params.asset || xchainUtil.eqAsset(params.asset, this.getAssetInfo().asset)) {
-                // Native transfer
-                transaction.add(web3_js.SystemProgram.transfer({
-                    fromPubkey: sender.publicKey,
-                    toPubkey,
-                    lamports: params.amount.amount().toNumber(),
-                }));
-            }
-            else {
-                // Token transfer
-                const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(params.asset));
-                const associatedTokenAddress = splToken.getAssociatedTokenAddressSync(mintAddress, toPubkey);
-                try {
-                    yield splToken.getAccount(this.connection, associatedTokenAddress, undefined, splToken.TOKEN_PROGRAM_ID);
-                    transaction.add(splToken.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 splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
-                        // recipient token account has to be created
-                        const dataLength = 165; // Normally used for Token accounts
-                        createAccountTxFee = yield this.connection.getMinimumBalanceForRentExemption(dataLength);
-                        transaction.add(splToken.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 web3_js.TransactionInstruction({
-                    keys: [{ pubkey: sender.publicKey, isSigner: true, isWritable: true }],
-                    data: Buffer.from(params.memo, 'utf-8'),
-                    programId: new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
-                }));
-            }
-            if (params.priorityFee) {
-                transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: params.priorityFee.amount().toNumber() / Math.pow(10, 3),
-                }));
-            }
-            if (params.limit) {
-                transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: params.limit,
-                }));
-            }
-            const fee = (yield transaction.getEstimatedFee(this.connection)) || 0;
-            return {
-                type: xchainClient.FeeType.FlatFee,
-                [xchainClient.FeeOption.Average]: xchainUtil.baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
-                [xchainClient.FeeOption.Fast]: xchainUtil.baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
-                [xchainClient.FeeOption.Fastest]: xchainUtil.baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
-            };
+            return this.roundRobinGetFees(params);
         });
     }
     /**
@@ -289,29 +251,21 @@ class Client extends xchainClient.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 web3_js.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);
         });
     }
     /**
@@ -322,14 +276,8 @@ class Client extends xchainClient.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 && !xchainUtil.eqAsset(asset, this.getAssetInfo().asset)) {
-                // Check if receipt token account is created, otherwise, create it
-                const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(asset));
-                yield splToken.getOrCreateAssociatedTokenAccount(this.connection, senderKeyPair, mintAddress, new web3_js.PublicKey(recipient));
-            }
-            const { rawUnsignedTx } = yield this.prepareTx({
-                sender: senderKeyPair.publicKey.toBase58(),
+            return this.roundRobinTransfer({
+                walletIndex,
                 recipient,
                 asset,
                 amount,
@@ -337,9 +285,6 @@ class Client extends xchainClient.BaseXChainClient {
                 limit,
                 priorityFee,
             });
-            const transaction = web3_js.Transaction.from(bs58.decode(rawUnsignedTx));
-            transaction.sign(senderKeyPair);
-            return this.broadcastTx(bs58.encode(transaction.serialize()));
         });
     }
     /**
@@ -349,16 +294,7 @@ class Client extends xchainClient.BaseXChainClient {
      */
     broadcastTx(txHex) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const transaction = web3_js.Transaction.from(bs58.decode(txHex));
-                return yield this.connection.sendRawTransaction(transaction.serialize());
-            }
-            catch (e) {
-                if (e instanceof web3_js.SendTransactionError) {
-                    console.log(yield e.getLogs(this.connection));
-                }
-                throw Error('Can not broadcast transaction. Unknown error');
-            }
+            return this.roundRobinBroadcastTx(txHex);
         });
     }
     /**
@@ -369,64 +305,15 @@ class Client extends xchainClient.BaseXChainClient {
      */
     prepareTx({ sender, recipient, asset, amount, memo, limit, priorityFee, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const transaction = new web3_js.Transaction();
-            const fromPubkey = new web3_js.PublicKey(sender);
-            const toPubkey = new web3_js.PublicKey(recipient);
-            transaction.recentBlockhash = yield this.connection.getLatestBlockhash().then((block) => block.blockhash);
-            transaction.feePayer = new web3_js.PublicKey(sender);
-            if (!asset || xchainUtil.eqAsset(asset, this.getAssetInfo().asset)) {
-                // Native transfer
-                transaction.add(web3_js.SystemProgram.transfer({
-                    fromPubkey,
-                    toPubkey,
-                    lamports: amount.amount().toNumber(),
-                }));
-            }
-            else {
-                // Token transfer
-                const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(asset));
-                const fromAssociatedAccount = splToken.getAssociatedTokenAddressSync(mintAddress, fromPubkey);
-                let fromTokenAccount;
-                try {
-                    fromTokenAccount = yield splToken.getAccount(this.connection, fromAssociatedAccount);
-                }
-                catch (error) {
-                    if (error instanceof splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
-                        throw Error('Can not find sender Token account');
-                    }
-                    throw error;
-                }
-                const toAssociatedAccount = splToken.getAssociatedTokenAddressSync(mintAddress, toPubkey);
-                let toTokenAccount;
-                try {
-                    toTokenAccount = yield splToken.getAccount(this.connection, toAssociatedAccount);
-                }
-                catch (error) {
-                    if (error instanceof splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
-                        throw Error('Can not find recipient Token account. Create it first');
-                    }
-                    throw error;
-                }
-                transaction.add(splToken.createTransferInstruction(fromTokenAccount.address, toTokenAccount.address, fromPubkey, amount.amount().toNumber()));
-            }
-            if (memo) {
-                transaction.add(new web3_js.TransactionInstruction({
-                    keys: [{ pubkey: fromPubkey, isSigner: true, isWritable: true }],
-                    data: Buffer.from(memo, 'utf-8'),
-                    programId: new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
-                }));
-            }
-            if (priorityFee) {
-                transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitPrice({
-                    microLamports: priorityFee.amount().toNumber() / Math.pow(10, 3),
-                }));
-            }
-            if (limit) {
-                transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitLimit({
-                    units: limit,
-                }));
-            }
-            return { rawUnsignedTx: bs58.encode(transaction.serialize({ verifySignatures: false })) };
+            return this.roundRobinPrepareTx({
+                sender,
+                recipient,
+                asset,
+                amount,
+                memo,
+                limit,
+                priorityFee,
+            });
         });
     }
     getPrivateKeyPair(index) {
@@ -475,23 +362,28 @@ class Client extends xchainClient.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 mplTokenMetadata.fetchDigitalAsset(this.umi, umi.publicKey(mintAddress));
-                        if (owner) {
-                            if (postBalanceAmount > preBalanceAmount) {
-                                to.push({
-                                    amount: xchainUtil.assetToBase(xchainUtil.assetAmount(postBalanceAmount - preBalanceAmount, assetDecimals)),
-                                    asset: xchainUtil.assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
-                                    to: owner,
-                                });
-                            }
-                            else if (preBalanceAmount > postBalanceAmount) {
-                                from.push({
-                                    amount: xchainUtil.assetToBase(xchainUtil.assetAmount(preBalanceAmount - postBalanceAmount, assetDecimals)),
-                                    asset: xchainUtil.assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
-                                    from: owner,
-                                });
+                        try {
+                            for (const provider of this.providers) {
+                                const tokenMetadata = yield mplTokenMetadata.fetchDigitalAsset(provider.umiProvider, umi.publicKey(mintAddress));
+                                if (owner) {
+                                    if (postBalanceAmount > preBalanceAmount) {
+                                        to.push({
+                                            amount: xchainUtil.assetToBase(xchainUtil.assetAmount(postBalanceAmount - preBalanceAmount, assetDecimals)),
+                                            asset: xchainUtil.assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
+                                            to: owner,
+                                        });
+                                    }
+                                    else if (preBalanceAmount > postBalanceAmount) {
+                                        from.push({
+                                            amount: xchainUtil.assetToBase(xchainUtil.assetAmount(preBalanceAmount - postBalanceAmount, assetDecimals)),
+                                            asset: xchainUtil.assetFromStringEx(`SOL.${tokenMetadata.metadata.symbol.trim()}-${mintAddress}`),
+                                            from: owner,
+                                        });
+                                    }
+                                }
                             }
                         }
+                        catch (_d) { }
                     }
                 }
             }
@@ -505,6 +397,324 @@ class Client extends xchainClient.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 web3_js.PublicKey(address));
+                    balances.push({
+                        asset: SOLAsset,
+                        amount: xchainUtil.baseAmount(nativeBalance, SOL_DECIMALS),
+                    });
+                    const tokenBalances = yield provider.solanaProvider.getParsedTokenAccountsByOwner(new web3_js.PublicKey(address), {
+                        programId: splToken.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 umi.publicKey(tokenData.info.mint);
+                    });
+                    const assetsData = yield mplTokenMetadata.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: xchainUtil.baseAmount(parsedData.info.tokenAmount.amount, parsedData.info.tokenAmount.decimals),
+                                asset: xchainUtil.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 = web3_js.Keypair.generate();
+                    const toPubkey = new web3_js.PublicKey(params.recipient);
+                    const transaction = new web3_js.Transaction();
+                    transaction.recentBlockhash = yield provider.solanaProvider
+                        .getLatestBlockhash()
+                        .then((block) => block.blockhash);
+                    transaction.feePayer = sender.publicKey;
+                    let createAccountTxFee = 0;
+                    if (!params.asset || xchainUtil.eqAsset(params.asset, this.getAssetInfo().asset)) {
+                        // Native transfer
+                        transaction.add(web3_js.SystemProgram.transfer({
+                            fromPubkey: sender.publicKey,
+                            toPubkey,
+                            lamports: params.amount.amount().toNumber(),
+                        }));
+                    }
+                    else {
+                        // Token transfer
+                        const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(params.asset));
+                        const associatedTokenAddress = splToken.getAssociatedTokenAddressSync(mintAddress, toPubkey);
+                        try {
+                            yield splToken.getAccount(provider.solanaProvider, associatedTokenAddress, undefined, splToken.TOKEN_PROGRAM_ID);
+                            transaction.add(splToken.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 splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
+                                // recipient token account has to be created
+                                const dataLength = 165; // Normally used for Token accounts
+                                createAccountTxFee = yield provider.solanaProvider.getMinimumBalanceForRentExemption(dataLength);
+                                transaction.add(splToken.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 web3_js.TransactionInstruction({
+                            keys: [{ pubkey: sender.publicKey, isSigner: true, isWritable: true }],
+                            data: Buffer.from(params.memo, 'utf-8'),
+                            programId: new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+                        }));
+                    }
+                    if (params.priorityFee) {
+                        transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: params.priorityFee.amount().toNumber() / Math.pow(10, 3),
+                        }));
+                    }
+                    if (params.limit) {
+                        transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+                            units: params.limit,
+                        }));
+                    }
+                    const fee = (yield transaction.getEstimatedFee(provider.solanaProvider)) || 0;
+                    return {
+                        type: xchainClient.FeeType.FlatFee,
+                        [xchainClient.FeeOption.Average]: xchainUtil.baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
+                        [xchainClient.FeeOption.Fast]: xchainUtil.baseAmount(fee + createAccountTxFee, SOL_DECIMALS),
+                        [xchainClient.FeeOption.Fastest]: xchainUtil.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 web3_js.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 && !xchainUtil.eqAsset(asset, this.getAssetInfo().asset)) {
+                        // Check if receipt token account is created, otherwise, create it
+                        const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(asset));
+                        yield splToken.getOrCreateAssociatedTokenAccount(provider.solanaProvider, senderKeyPair, mintAddress, new web3_js.PublicKey(recipient));
+                    }
+                    const { rawUnsignedTx } = yield this.prepareTx({
+                        sender: senderKeyPair.publicKey.toBase58(),
+                        recipient,
+                        asset,
+                        amount,
+                        memo,
+                        limit,
+                        priorityFee,
+                    });
+                    const transaction = web3_js.Transaction.from(bs58__default.default.decode(rawUnsignedTx));
+                    transaction.sign(senderKeyPair);
+                    return this.broadcastTx(bs58__default.default.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 = web3_js.Transaction.from(bs58__default.default.decode(txHex));
+                        return yield provider.solanaProvider.sendRawTransaction(transaction.serialize());
+                    }
+                    catch (e) {
+                        if (e instanceof web3_js.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 web3_js.Transaction();
+                    const fromPubkey = new web3_js.PublicKey(sender);
+                    const toPubkey = new web3_js.PublicKey(recipient);
+                    transaction.recentBlockhash = yield provider.solanaProvider
+                        .getLatestBlockhash()
+                        .then((block) => block.blockhash);
+                    transaction.feePayer = new web3_js.PublicKey(sender);
+                    if (!asset || xchainUtil.eqAsset(asset, this.getAssetInfo().asset)) {
+                        // Native transfer
+                        transaction.add(web3_js.SystemProgram.transfer({
+                            fromPubkey,
+                            toPubkey,
+                            lamports: amount.amount().toNumber(),
+                        }));
+                    }
+                    else {
+                        // Token transfer
+                        const mintAddress = new web3_js.PublicKey(xchainUtil.getContractAddressFromAsset(asset));
+                        const fromAssociatedAccount = splToken.getAssociatedTokenAddressSync(mintAddress, fromPubkey);
+                        let fromTokenAccount;
+                        try {
+                            fromTokenAccount = yield splToken.getAccount(provider.solanaProvider, fromAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find sender Token account');
+                            }
+                            throw error;
+                        }
+                        const toAssociatedAccount = splToken.getAssociatedTokenAddressSync(mintAddress, toPubkey);
+                        let toTokenAccount;
+                        try {
+                            toTokenAccount = yield splToken.getAccount(provider.solanaProvider, toAssociatedAccount);
+                        }
+                        catch (error) {
+                            if (error instanceof splToken.TokenAccountNotFoundError || error instanceof splToken.TokenInvalidAccountOwnerError) {
+                                throw Error('Can not find recipient Token account. Create it first');
+                            }
+                            throw error;
+                        }
+                        transaction.add(splToken.createTransferInstruction(fromTokenAccount.address, toTokenAccount.address, fromPubkey, amount.amount().toNumber()));
+                    }
+                    if (memo) {
+                        transaction.add(new web3_js.TransactionInstruction({
+                            keys: [{ pubkey: fromPubkey, isSigner: true, isWritable: true }],
+                            data: Buffer.from(memo, 'utf-8'),
+                            programId: new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
+                        }));
+                    }
+                    if (priorityFee) {
+                        transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitPrice({
+                            microLamports: priorityFee.amount().toNumber() / Math.pow(10, 3),
+                        }));
+                    }
+                    if (limit) {
+                        transaction.add(web3_js.ComputeBudgetProgram.setComputeUnitLimit({
+                            units: limit,
+                        }));
+                    }
+                    return { rawUnsignedTx: bs58__default.default.encode(transaction.serialize({ verifySignatures: false })) };
+                }
+            }
+            catch (_a) { }
+            throw Error('No provider able to prepare transaction');
+        });
+    }
 }
 
 exports.Client = Client;