@xchainjs/xchain-solana 0.0.5 → 0.0.7

package/lib/index.js

@@ -93,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.
@@ -179,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);
         });
     }
     /**
@@ -225,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);
         });
     }
     /**
@@ -293,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);
         });
     }
     /**
@@ -326,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,
@@ -341,9 +285,6 @@ class Client extends xchainClient.BaseXChainClient {
                 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()));
         });
     }
     /**
@@ -353,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__default.default.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);
         });
     }
     /**
@@ -373,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__default.default.encode(transaction.serialize({ verifySignatures: false })) };
+            return this.roundRobinPrepareTx({
+                sender,
+                recipient,
+                asset,
+                amount,
+                memo,
+                limit,
+                priorityFee,
+            });
         });
     }
     getPrivateKeyPair(index) {
@@ -479,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) { }
                     }
                 }
             }
@@ -509,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;