@xchainjs/xchain-thorchain-amm 0.8.21 → 1.0.0

package/lib/index.js

@@ -12,12 +12,12 @@ var xchainCosmos = require('@xchainjs/xchain-cosmos');
 var xchainDoge = require('@xchainjs/xchain-doge');
 var xchainEthereum = require('@xchainjs/xchain-ethereum');
 var xchainLitecoin = require('@xchainjs/xchain-litecoin');
-var xchainMayachain = require('@xchainjs/xchain-mayachain');
 var xchainThorchain = require('@xchainjs/xchain-thorchain');
-var xchainUtil = require('@xchainjs/xchain-util');
+var xchainThorchainQuery = require('@xchainjs/xchain-thorchain-query');
+var xchainWallet = require('@xchainjs/xchain-wallet');
 var xchainEvm = require('@xchainjs/xchain-evm');
+var xchainUtil = require('@xchainjs/xchain-util');
 var ethers = require('ethers');
-var xchainThorchainQuery = require('@xchainjs/xchain-thorchain-query');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -44,803 +44,128 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-const FIFTEEN_MIN_IN_SECS = 15 * 60;
-class EvmHelper {
-    constructor(client, thorchainCache) {
-        this.evmClient = client;
-        this.client = client;
-        this.thorchainCache = thorchainCache;
-    }
-    /**
-     * Transaction to THORChain inbound address.
-     *
-     * @param {DepositParams} params The transaction options.
-     * @returns {TxHash} The transaction hash.
-     *
-     * @throws {"halted chain"} Thrown if chain is halted.
-     * @throws {"halted trading"} Thrown if trading is halted.
-     * @throws {"amount is not approved"} Thrown if the amount is not allowed to spend
-     * @throws {"router address is not defined"} Thrown if router address is not defined
-     */
-    sendDeposit(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.thorchainCache.getInboundDetails())[params.asset.chain];
-            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
-                throw new Error('router address is not defined');
-            }
-            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address)) {
-                throw new Error('Vault address is not defined');
-            }
-            const address = yield this.client.getAddressAsync(params.walletIndex);
-            const gasPrice = yield this.evmClient.estimateGasPrices(xchainClient.Protocol.THORCHAIN);
-            if (xchainUtil.eqAsset(params.asset, this.evmClient.config.gasAsset)) {
-                // simple transfer
-                return yield this.evmClient.transfer({
-                    walletIndex: params.walletIndex || 0,
-                    asset: params.asset,
-                    amount: params.amount,
-                    recipient: inboundAsgard.address,
-                    memo: params.memo,
-                    gasPrice: gasPrice.fast,
-                });
-            }
-            else {
-                //erc-20 must be depsited to the router
-                const isApprovedResult = yield this.isTCRouterApprovedToSpend(params.asset, params.amount, params.walletIndex);
-                if (!isApprovedResult) {
-                    throw new Error('The amount is not allowed to spend');
-                }
-                const contractAddress = xchainUtil.getContractAddressFromAsset(params.asset);
-                const checkSummedContractAddress = ethers.ethers.utils.getAddress(contractAddress);
-                const latestBlockTimeUnixSecs = (yield this.evmClient.getProvider().getBlock('latest')).timestamp;
-                const expiry = latestBlockTimeUnixSecs + FIFTEEN_MIN_IN_SECS;
-                const depositParams = [
-                    inboundAsgard.address,
-                    checkSummedContractAddress,
-                    params.amount.amount().toFixed(),
-                    params.memo,
-                    expiry,
-                ];
-                const routerContract = new ethers.ethers.Contract(inboundAsgard.router, xchainEvm.abi.router);
-                const gasLimit = '160000';
-                const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams, {
-                    from: address,
-                    value: 0,
-                    gasPrice: gasPrice.fast.amount().toFixed(),
-                    gasLimit: gasLimit,
-                });
-                const { hash } = yield this.evmClient.getWallet(params.walletIndex).sendTransaction(unsignedTx);
-                return hash;
-            }
-        });
-    }
-    isTCRouterApprovedToSpend(asset, amount, walletIndex = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const router = yield this.thorchainCache.getRouterAddressForChain(asset.chain);
-            const contractAddress = xchainUtil.getContractAddressFromAsset(asset);
-            return yield this.evmClient.isApproved({
-                amount: amount,
-                spenderAddress: router,
-                contractAddress,
-                walletIndex: walletIndex,
-            });
-        });
-    }
-    approveTCRouterToSpend(asset, amount = xchainEvm.MAX_APPROVAL, walletIndex = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const contractAddress = xchainUtil.getContractAddressFromAsset(asset);
-            const router = yield this.thorchainCache.getRouterAddressForChain(asset.chain);
-            const decimals = yield this.thorchainCache.midgardQuery.getDecimalForAsset(asset);
-            const approveParams = {
-                contractAddress,
-                spenderAddress: router,
-                amount: xchainUtil.baseAmount(amount.toString(), decimals),
-                walletIndex,
-            };
-            return yield this.evmClient.approve(approveParams);
-        });
-    }
-}
-
 /**
- * Wallet Class for managing all xchain-* wallets with a mnemonic seed.
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
  */
-class Wallet {
-    /**
-     * Contructor to create a Wallet
-     *
-     * @param phrase - mnemonic phrase
-     * @param thorchainCache - an instance of the ThorchainCache (could be pointing to stagenet,testnet,mainnet)
-     * @param chainConfigs - Config by chain
-     * @returns Wallet
-     */
-    constructor(phrase, thorchainQuery, chainConfigs = {}) {
-        this.thorchainQuery = thorchainQuery;
-        const settings = { network: this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, phrase };
-        this.clients = {
-            BCH: new xchainBitcoincash.Client(Object.assign(Object.assign(Object.assign({}, xchainBitcoincash.defaultBchParams), chainConfigs[xchainBitcoincash.BCHChain]), settings)),
-            BTC: new xchainBitcoin.Client(Object.assign(Object.assign(Object.assign({}, xchainBitcoin.defaultBTCParams), chainConfigs[xchainBitcoin.BTCChain]), settings)),
-            DOGE: new xchainDoge.Client(Object.assign(Object.assign(Object.assign({}, xchainDoge.defaultDogeParams), chainConfigs[xchainDoge.DOGEChain]), settings)),
-            LTC: new xchainLitecoin.Client(Object.assign(Object.assign(Object.assign({}, xchainLitecoin.defaultLtcParams), chainConfigs[xchainLitecoin.LTCChain]), settings)),
-            THOR: new xchainThorchain.Client(Object.assign(Object.assign({}, chainConfigs[xchainThorchain.THORChain]), settings)),
-            BNB: new xchainBinance.Client(Object.assign(Object.assign({}, chainConfigs[xchainBinance.BNBChain]), settings)),
-            GAIA: new xchainCosmos.Client(Object.assign(Object.assign({}, chainConfigs[xchainCosmos.GAIAChain]), settings)),
-            MAYA: new xchainMayachain.Client(Object.assign(Object.assign({}, chainConfigs[xchainMayachain.MAYAChain]), settings)),
-            ETH: new xchainEthereum.Client(Object.assign(Object.assign(Object.assign({}, xchainEthereum.defaultEthParams), chainConfigs[xchainEthereum.ETHChain]), settings)),
-            AVAX: new xchainAvax.Client(Object.assign(Object.assign(Object.assign({}, xchainAvax.defaultAvaxParams), chainConfigs[xchainAvax.AVAXChain]), settings)),
-            BSC: new xchainBsc.Client(Object.assign(Object.assign(Object.assign({}, xchainBsc.defaultBscParams), chainConfigs[xchainBsc.BSCChain]), settings)),
-        };
-        this.evmHelpers = {
-            ETH: new EvmHelper(this.clients.ETH, this.thorchainQuery.thorchainCache),
-            BSC: new EvmHelper(this.clients.BSC, this.thorchainQuery.thorchainCache),
-            AVAX: new EvmHelper(this.clients.AVAX, this.thorchainQuery.thorchainCache),
-        };
-    }
-    /**
-     * Fetch balances for all wallets
-     *
-     * @returns AllBalances[]
-     */
-    getAllBalances() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allBalances = [];
-            for (const [chain, client] of Object.entries(this.clients)) {
-                const address = yield client.getAddressAsync(0);
-                try {
-                    const balances = yield client.getBalance(address);
-                    allBalances.push({ chain, address, balances });
-                }
-                catch (err) {
-                    allBalances.push({ chain, address, balances: err.message });
-                }
-            }
-            return allBalances;
-        });
-    }
-    /**
-     * Executes a Swap from THORChainAMM.doSwap()
-     *
-     * @param swap object with all the required details for a swap.
-     * @returns transaction details and explorer url
-     * @see ThorchainAMM.doSwap()
-     */
-    executeSwap(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.validateSwap(swap);
-            if (swap.input.asset.chain === xchainThorchain.THORChain || swap.input.asset.synth) {
-                return yield this.swapRuneTo(swap);
-            }
-            else {
-                return yield this.swapNonRune(swap);
-            }
-        });
-    }
-    /** Validate swap object
-     *
-     * @param swap  - swap parameters
-     */
-    validateSwap(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const errors = [];
-            const isThorchainDestinationAsset = swap.destinationAsset.synth || swap.destinationAsset.chain === xchainThorchain.THORChain;
-            const chain = isThorchainDestinationAsset ? xchainThorchain.THORChain : swap.destinationAsset.chain;
-            // check address
-            if (swap.destinationAddress && !this.clients[chain].validateAddress(swap.destinationAddress)) {
-                errors.push(`destinationAddress ${swap.destinationAddress} is not a valid address`);
-            }
-            // Affiliate address should be THORName or THORAddress
-            const checkAffiliateAddress = swap.memo.split(':');
-            if (checkAffiliateAddress.length > 4) {
-                const affiliateAddress = checkAffiliateAddress[4];
-                if (affiliateAddress.length > 0) {
-                    const isValidThorchainAddress = this.clients[xchainThorchain.THORChain].validateAddress(affiliateAddress);
-                    const isValidThorname = this.isThorname(affiliateAddress);
-                    if (!(isValidThorchainAddress || isValidThorname))
-                        errors.push(`affiliateAddress ${affiliateAddress} is not a valid THOR address`);
-                }
-            }
-            // if input == synth return errors.
-            if (swap.input.asset.synth)
-                return errors;
-            if (this.isERC20Asset(swap.input.asset)) {
-                const isApprovedResult = yield this.evmHelpers[swap.input.asset.chain].isTCRouterApprovedToSpend(swap.input.asset, swap.input.baseAmount, swap.walletIndex);
-                if (!isApprovedResult) {
-                    errors.push('TC router has not been approved to spend this amount');
-                }
-            }
-            return errors;
-        });
-    }
-    isThorname(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const thornameDetails = yield this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.getTHORNameDetails(name); // Update when thorchainCache expose getTHORNameDetails method
-            return thornameDetails !== undefined;
-        });
-    }
-    /** Function handles all swaps from Rune to asset
-     *
-     * @param swap - swap parameters
-     * @returns - tx submitted object
-     */
-    swapRuneTo(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const thorClient = this.clients.THOR;
-            const hash = yield thorClient.deposit({
-                amount: swap.input.baseAmount,
-                asset: swap.input.asset,
-                memo: swap.memo,
-            });
-            return { hash, url: this.clients.THOR.getExplorerTxUrl(hash) };
-        });
-    }
-    /** Function handles all swaps from Non Rune
-     *
-     * @param swap - swap object
-     * @returns - TxSubmitted object
-     */
-    swapNonRune(swap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const client = this.clients[swap.input.asset.chain];
-            const inbound = (yield this.thorchainQuery.thorchainCache.getInboundDetails())[swap.input.asset.chain];
-            if (!(inbound === null || inbound === void 0 ? void 0 : inbound.address))
-                throw Error(`no asgard address found for ${swap.input.asset.chain}`);
-            if (this.isEVMChain(swap.input.asset)) {
-                const params = {
-                    walletIndex: 0,
-                    asset: swap.input.asset,
-                    amount: swap.input.baseAmount,
-                    feeOption: swap.feeOption || xchainClient.FeeOption.Fast,
-                    memo: swap.memo,
-                };
-                const hash = yield this.evmHelpers[swap.input.asset.chain].sendDeposit(params);
-                return { hash, url: client.getExplorerTxUrl(hash) };
-            }
-            else {
-                const params = {
-                    walletIndex: 0,
-                    asset: swap.input.asset,
-                    amount: swap.input.baseAmount,
-                    recipient: inbound.address,
-                    memo: swap.memo,
-                };
-                const hash = yield client.transfer(params);
-                return { hash, url: client.getExplorerTxUrl(hash) };
-            }
-        });
-    }
-    /** Function handles liquidity Add
-     * BASED OFF https://dev.thorchain.or›g/thorchain-dev/network/memos
-     * @param params input parameters needed to add liquidity
-     * @returns transaction details submitted
-     */
-    addLiquidity(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assetClient = this.clients[params.asset.asset.chain];
-            const inboundAsgard = (yield this.thorchainQuery.thorchainCache.getInboundDetails())[params.asset.asset.chain]
-                .address;
-            const thorchainClient = this.clients[params.rune.asset.chain];
-            const addressRune = yield thorchainClient.getAddressAsync();
-            const addressAsset = yield assetClient.getAddressAsync();
-            // const waitTimeSeconds = params.waitTimeSeconds
-            let constructedMemo = '';
-            const txSubmitted = [];
-            // symmetrical add
-            if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.gt(0)) {
-                constructedMemo = `+:${params.assetPool}:${addressRune}`;
-                txSubmitted.push(yield this.addAssetLP(params, constructedMemo, assetClient, inboundAsgard));
-                constructedMemo = `+:${params.assetPool}:${addressAsset}`;
-                txSubmitted.push(yield this.addRuneLP(params, constructedMemo, thorchainClient));
-                return txSubmitted;
-            }
-            else if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.eq(0)) {
-                // asymmetrical asset only
-                constructedMemo = `+:${params.assetPool}`;
-                txSubmitted.push(yield this.addAssetLP(params, constructedMemo, assetClient, inboundAsgard));
-                return txSubmitted;
-            }
-            else {
-                // asymmetrical rune only
-                constructedMemo = `+:${params.assetPool}`;
-                txSubmitted.push(yield this.addRuneLP(params, constructedMemo, thorchainClient));
-                return txSubmitted;
-            }
-        });
-    }
-    /** Function handles liquidity Withdraw
-     *
-     * @param params - parameters required for liquidity position
-     * @returns object with tx response, url and wait time in seconds
-     */
-    withdrawLiquidity(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assetClient = this.clients[params.assetFee.asset.chain];
-            const inboundAsgard = (yield this.thorchainQuery.thorchainCache.getInboundDetails())[params.assetFee.asset.chain]
-                .address;
-            // const waitTimeSeconds = params.waitTimeSeconds
-            const thorchainClient = this.clients[params.runeFee.asset.chain];
-            const basisPoints = (params.percentage * 100).toFixed(); // convert to basis points
-            let constructedMemo = '';
-            const txSubmitted = [];
-            if (params.assetAddress && params.runeAddress) {
-                constructedMemo = `-:${params.assetPool}:${basisPoints}`;
-                txSubmitted.push(yield this.withdrawAssetLP(params, constructedMemo, assetClient, inboundAsgard));
-                constructedMemo = `-:${params.assetPool}:${basisPoints}`;
-                txSubmitted.push(yield this.withdrawRuneLP(params, constructedMemo, thorchainClient));
-                return txSubmitted;
-            }
-            else if (params.assetAddress && !params.runeAddress) {
-                // asymmetrical asset only
-                constructedMemo = `-:${params.assetPool}:${basisPoints}`;
-                txSubmitted.push(yield this.withdrawAssetLP(params, constructedMemo, assetClient, inboundAsgard));
-                return txSubmitted;
-            }
-            else {
-                // asymmetrical rune only
-                constructedMemo = `-:${params.assetPool}:${basisPoints}`;
-                txSubmitted.push(yield this.withdrawRuneLP(params, constructedMemo, thorchainClient));
-                return txSubmitted;
-            }
-        });
-    }
-    /**
-     *
-     * @param assetAmount - amount to add
-     * @param memo - memo required
-     * @param waitTimeSeconds - expected wait for the transaction to be processed
-     * @returns
-     */
-    addSavers(assetAmount, memo, toAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assetClient = this.clients[assetAmount.asset.chain];
-            if (this.isEVMChain(assetAmount.asset)) {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: assetAmount.asset,
-                    amount: assetAmount.baseAmount,
-                    feeOption: xchainClient.FeeOption.Fast,
-                    memo: memo,
-                };
-                const evmHelper = new EvmHelper(assetClient, this.thorchainQuery.thorchainCache);
-                const hash = yield evmHelper.sendDeposit(addParams);
-                return { hash, url: assetClient.getExplorerTxUrl(hash) };
-            }
-            else if (this.isUTXOChain(assetAmount.asset)) {
-                const feeRates = yield assetClient.getFeeRates(xchainClient.Protocol.THORCHAIN);
-                const addParams = {
-                    wallIndex: 0,
-                    asset: assetAmount.asset,
-                    amount: assetAmount.baseAmount,
-                    recipient: toAddress,
-                    memo: memo,
-                    feeRate: feeRates.fast,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(assetClient.getAddress()) };
-                }
-            }
-            else {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: assetAmount.asset,
-                    amount: assetAmount.baseAmount,
-                    recipient: toAddress,
-                    memo: memo,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(assetClient.getAddress()) };
-                }
-            }
-        });
-    }
-    /**
-     *
-     * @param assetAmount - amount to withdraw
-     * @param memo - memo required
-     * @param waitTimeSeconds - expected wait for the transaction to be processed
-     * @returns
-     */
-    withdrawSavers(assetAmount, memo, toAddress) {
+const isProtocolEVMChain = (chain) => {
+    return [xchainEthereum.AssetETH.chain, xchainBsc.AssetBSC.chain, xchainAvax.AssetAVAX.chain].includes(chain);
+};
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+const isProtocolERC20Asset = (asset) => {
+    return isProtocolEVMChain(asset.chain)
+        ? ![xchainEthereum.AssetETH.symbol, xchainAvax.AssetAVAX.symbol, xchainBsc.AssetBSC.symbol].includes(asset.symbol)
+        : false;
+};
+/**
+ * Check if a chain is EVM and supported by the protocol
+ * @param {Chain} chain to check
+ * @returns true if chain is EVM, otherwise, false
+ */
+const isProtocolBFTChain = (chain) => {
+    return [xchainBinance.AssetBNB.chain, xchainCosmos.AssetATOM.chain].includes(chain);
+};
+
+class ThorchainAction {
+    static makeAction(actionParams) {
         return __awaiter(this, void 0, void 0, function* () {
-            const assetClient = this.clients[assetAmount.asset.chain];
-            if (this.isEVMChain(assetAmount.asset)) {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: assetAmount.asset,
-                    amount: assetAmount.baseAmount,
-                    feeOption: xchainClient.FeeOption.Fast,
-                    memo: memo,
-                };
-                const evmHelper = new EvmHelper(assetClient, this.thorchainQuery.thorchainCache);
-                const hash = yield evmHelper.sendDeposit(addParams);
-                return { hash, url: assetClient.getExplorerTxUrl(hash) };
-            }
-            else if (this.isUTXOChain(assetAmount.asset)) {
-                const feeRates = yield assetClient.getFeeRates(xchainClient.Protocol.THORCHAIN);
-                const addParams = {
-                    wallIndex: 0,
-                    asset: assetAmount.asset,
-                    amount: assetAmount.baseAmount,
-                    recipient: toAddress,
-                    memo: memo,
-                    feeRate: feeRates.fast,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: yield assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-            else {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: assetAmount.asset,
-                    amount: assetAmount.baseAmount,
-                    recipient: toAddress,
-                    memo: memo,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: yield assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
+            return this.isNonProtocolParams(actionParams)
+                ? this.makeNonProtocolAction(actionParams)
+                : this.makeProtocolAction(actionParams);
         });
     }
-    loanOpen(params) {
+    static makeProtocolAction({ wallet, assetAmount, memo }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const assetClient = this.clients[params.amount.asset.chain];
-            if (this.isEVMChain(params.amount.asset)) {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.amount.asset,
-                    amount: params.amount.baseAmount,
-                    feeOption: xchainClient.FeeOption.Fast,
-                    memo: params.memo,
-                };
-                const evmHelper = new EvmHelper(assetClient, this.thorchainQuery.thorchainCache);
-                const hash = yield evmHelper.sendDeposit(addParams);
-                return { hash, url: assetClient.getExplorerTxUrl(hash) };
-            }
-            else if (this.isUTXOChain(params.amount.asset)) {
-                const feeRates = yield assetClient.getFeeRates(xchainClient.Protocol.THORCHAIN);
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.amount.asset,
-                    amount: params.amount.baseAmount,
-                    recipient: params.toAddress,
-                    memo: params.memo,
-                    feeRate: feeRates.fast,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-            else {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.amount.asset,
-                    amount: params.amount.baseAmount,
-                    recipient: params.toAddress,
-                    memo: params.memo,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
+            const hash = yield wallet.deposit({ asset: assetAmount.asset, amount: assetAmount.baseAmount, memo });
+            return {
+                hash,
+                url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+            };
         });
     }
-    loanClose(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const assetClient = this.clients[params.amount.asset.chain];
-            if (this.isEVMChain(params.amount.asset)) {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.amount.asset,
-                    amount: params.amount.baseAmount,
-                    feeOption: xchainClient.FeeOption.Fast,
-                    memo: params.memo,
-                };
-                const evmHelper = new EvmHelper(assetClient, this.thorchainQuery.thorchainCache);
-                const hash = yield evmHelper.sendDeposit(addParams);
-                return { hash, url: assetClient.getExplorerTxUrl(hash) };
-            }
-            else if (this.isUTXOChain(params.amount.asset)) {
-                const feeRates = yield assetClient.getFeeRates(xchainClient.Protocol.THORCHAIN);
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.amount.asset,
-                    amount: params.amount.baseAmount,
-                    recipient: params.toAddress,
-                    memo: params.memo,
-                    feeRate: feeRates.average,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
+    static makeNonProtocolAction({ wallet, assetAmount, recipient, memo, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Non ERC20 swaps
+            if (!isProtocolERC20Asset(assetAmount.asset)) {
+                if (isProtocolBFTChain(assetAmount.asset.chain)) {
+                    const hash = yield wallet.transfer({
+                        asset: assetAmount.asset,
+                        amount: assetAmount.baseAmount,
+                        recipient,
+                        memo,
+                    });
+                    return {
+                        hash,
+                        url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
+                    };
                 }
-            }
-            else {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.amount.asset,
-                    amount: params.amount.baseAmount,
-                    recipient: params.toAddress,
-                    memo: params.memo,
+                const feeRates = yield wallet.getFeeRates(assetAmount.asset.chain, xchainClient.Protocol.THORCHAIN);
+                const hash = yield wallet.transfer(isProtocolEVMChain(assetAmount.asset.chain)
+                    ? {
+                        asset: assetAmount.asset,
+                        amount: assetAmount.baseAmount,
+                        recipient,
+                        memo,
+                        gasPrice: feeRates.fast,
+                    }
+                    : {
+                        asset: assetAmount.asset,
+                        amount: assetAmount.baseAmount,
+                        recipient,
+                        memo,
+                        feeRate: feeRates.fast,
+                    });
+                return {
+                    hash,
+                    url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
                 };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-        });
-    }
-    /**
-     * Register a THORName with a default expirity of one year. By default chain and chainAddress is getting from wallet instance and is BTC.
-     * By default owner is getting from wallet
-     * @param thorname - Name to register
-     * @param chain - Chain to add alias
-     * @param chainAddress - Address to add to chain alias
-     * @param owner - Owner address (rune address)
-     * @param preferredAsset - referred asset
-     * @param expirity - expirity of the domain in MILLISECONDS
-     * @param isUpdate - true only if the domain is already register and you want to update its data
-     * @returns memo and value of deposit
-     */
-    registerThorname(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const chainClient = this.clients[params.chain || xchainBitcoin.BTCChain];
-            const thorClient = this.clients.THOR;
-            if (!chainClient || !thorClient) {
-                throw Error('Can not find a wallet client');
             }
-            const thornameEstimation = yield this.thorchainQuery.estimateThorname(Object.assign(Object.assign({}, params), { chain: params.chain || xchainBitcoin.BTCChain, chainAddress: params.chainAddress || (yield chainClient.getAddressAsync()), owner: params.owner || (yield thorClient.getAddressAsync()) }));
-            const castedThorClient = thorClient;
-            const result = yield castedThorClient.deposit({
-                asset: thornameEstimation.value.asset,
-                amount: thornameEstimation.value.baseAmount,
-                memo: thornameEstimation.memo,
+            // ERC20 swaps
+            const thorchainQuery = new xchainThorchainQuery.ThorchainQuery(new xchainThorchainQuery.ThorchainCache(new xchainThorchainQuery.Thornode(wallet.getNetwork())));
+            const inboundDetails = yield thorchainQuery.getChainInboundDetails(assetAmount.asset.chain);
+            if (!inboundDetails.router)
+                throw Error(`Unknown router for ${assetAmount.asset.chain} chain`);
+            const contractAddress = xchainUtil.getContractAddressFromAsset(assetAmount.asset);
+            const checkSummedContractAddress = ethers.ethers.utils.getAddress(contractAddress);
+            const expiration = Math.floor(new Date(new Date().getTime() + 15 * 60000).getTime() / 1000);
+            const depositParams = [
+                recipient,
+                checkSummedContractAddress,
+                assetAmount.baseAmount.amount().toFixed(),
+                memo,
+                expiration,
+            ];
+            const routerContract = new ethers.ethers.Contract(inboundDetails.router, xchainEvm.abi.router);
+            const chainWallet = wallet.getChainWallet(assetAmount.asset.chain);
+            const gasPrices = yield wallet.getFeeRates(assetAmount.asset.chain);
+            const unsignedTx = yield routerContract.populateTransaction.depositWithExpiry(...depositParams, {
+                from: wallet.getAddress(assetAmount.asset.chain),
+                value: 0,
+                gasPrice: gasPrices.fast.amount().toFixed(),
+                gasLimit: '160000',
             });
-            return result;
-        });
-    }
-    /**
-     * Register a THORName with a default expirity of one year. By default chain and chainAddress is getting from wallet instance and is BTC.
-     * By default owner is getting from wallet
-     * @param thorname - Name to register
-     * @param chain - Chain to add alias
-     * @param chainAddress - Address to add to chain alias
-     * @param owner - Owner address (rune address)
-     * @param preferredAsset - referred asset
-     * @param expirity - expirity of the domain in MILLISECONDS
-     * @returns memo and value of deposit
-     */
-    updateThorname(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const chainClient = this.clients[params.chain || xchainBitcoin.BTCChain];
-            const thorClient = this.clients.THOR;
-            if (!chainClient || !thorClient) {
-                throw Error('Can not find a wallet client');
-            }
-            const thornameDetail = yield this.thorchainQuery.getThornameDetails(params.thorname);
-            if ((thornameDetail === null || thornameDetail === void 0 ? void 0 : thornameDetail.owner) !== (yield thorClient.getAddressAsync())) {
-                throw Error('You cannot update a domain that is not yours');
-            }
-            const thornameEstimation = yield this.thorchainQuery.estimateThorname(Object.assign(Object.assign({}, params), { chain: params.chain || xchainBitcoin.BTCChain, isUpdate: true, preferredAsset: params.preferredAsset || xchainUtil.assetFromString(thornameDetail.preferredAsset), chainAddress: params.chainAddress || (yield chainClient.getAddressAsync()) }));
-            const castedThorClient = thorClient;
-            const result = yield castedThorClient.deposit({
-                asset: thornameEstimation.value.asset,
-                amount: thornameEstimation.value.baseAmount,
-                memo: thornameEstimation.memo,
-            });
-            return result;
-        });
-    }
-    /** Function handles liquidity add for all non rune assets
-     *
-     * @param params - parameters for add liquidity
-     * @param constructedMemo - memo needed for thorchain
-     * @param waitTimeSeconds - wait time for the tx to be confirmed
-     * @param assetClient - passing XchainClient
-     * @param inboundAsgard - inbound Asgard address for the LP
-     * @returns - tx object
-     */
-    addAssetLP(params, constructedMemo, assetClient, inboundAsgard) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isEVMChain(params.asset.asset)) {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.asset.asset,
-                    amount: params.asset.baseAmount,
-                    feeOption: xchainClient.FeeOption.Fast,
-                    memo: constructedMemo,
-                };
-                const evmHelper = new EvmHelper(assetClient, this.thorchainQuery.thorchainCache);
-                const hash = yield evmHelper.sendDeposit(addParams);
-                return { hash, url: assetClient.getExplorerTxUrl(hash) };
-            }
-            else if (this.isUTXOChain(params.asset.asset)) {
-                const feeRates = yield assetClient.getFeeRates(xchainClient.Protocol.THORCHAIN);
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.asset.asset,
-                    amount: params.asset.baseAmount,
-                    recipient: inboundAsgard,
-                    memo: constructedMemo,
-                    feeRate: feeRates.fast,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-            else {
-                const addParams = {
-                    wallIndex: 0,
-                    asset: params.asset.asset,
-                    amount: params.asset.baseAmount,
-                    recipient: inboundAsgard,
-                    memo: constructedMemo,
-                };
-                try {
-                    const hash = yield assetClient.transfer(addParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-        });
-    }
-    /** Function handles liquidity Withdraw for Non rune assets
-     *
-     * @param params - parameters for withdraw liquidity
-     * @param constructedMemo - memo needed for thorchain execution
-     * @param assetClient - asset client to call transfer
-     * @param waitTimeSeconds - return back estimated wait
-     * @param inboundAsgard - destination address
-     * @returns - tx object
-     */
-    withdrawAssetLP(params, constructedMemo, assetClient, inboundAsgard) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isEVMChain(params.assetFee.asset)) {
-                const withdrawParams = {
-                    wallIndex: 0,
-                    asset: params.assetFee.asset,
-                    amount: params.assetFee.baseAmount,
-                    feeOption: xchainClient.FeeOption.Fast,
-                    memo: constructedMemo,
-                };
-                const evmHelper = new EvmHelper(assetClient, this.thorchainQuery.thorchainCache);
-                const hash = yield evmHelper.sendDeposit(withdrawParams);
-                return { hash, url: assetClient.getExplorerTxUrl(hash) };
-            }
-            else if (this.isUTXOChain(params.assetFee.asset)) {
-                const feeRates = yield assetClient.getFeeRates(xchainClient.Protocol.THORCHAIN);
-                const withdrawParams = {
-                    wallIndex: 0,
-                    asset: params.assetFee.asset,
-                    amount: params.assetFee.baseAmount,
-                    recipient: inboundAsgard,
-                    memo: constructedMemo,
-                    feeRate: feeRates.fast,
-                };
-                try {
-                    const hash = yield assetClient.transfer(withdrawParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-            else {
-                const withdrawParams = {
-                    wallIndex: 0,
-                    asset: params.assetFee.asset,
-                    amount: params.assetFee.baseAmount,
-                    recipient: inboundAsgard,
-                    memo: constructedMemo,
-                };
-                try {
-                    const hash = yield assetClient.transfer(withdrawParams);
-                    return { hash, url: assetClient.getExplorerTxUrl(hash) };
-                }
-                catch (err) {
-                    const hash = JSON.stringify(err);
-                    return { hash, url: assetClient.getExplorerAddressUrl(yield assetClient.getAddressAsync()) };
-                }
-            }
-        });
-    }
-    /** Function handles liquidity Add for Rune only
-     *
-     * @param params - deposit parameters
-     * @param memo - memo needed to withdraw lp
-     * @returns - tx object
-     */
-    addRuneLP(params, memo, thorchainClient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const thorClient = this.clients.THOR;
-            const addParams = {
-                asset: params.rune.asset,
-                amount: params.rune.baseAmount,
-                memo: memo,
-            };
-            const hash = yield thorClient.deposit(addParams);
-            return { hash, url: thorchainClient.getExplorerTxUrl(hash) };
-        });
-    }
-    /** Function handles liquidity Withdraw for Rune only
-     *
-     * @param params - withdraw parameters
-     * @param memo - memo needed to withdraw lp
-     * @returns - tx object
-     */
-    withdrawRuneLP(params, memo, thorchainClient) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const thorClient = this.clients.THOR;
-            const addParams = {
-                asset: params.runeFee.asset,
-                amount: params.runeFee.baseAmount,
-                memo: memo,
+            const { hash } = yield chainWallet.sendTransaction(unsignedTx);
+            return {
+                hash,
+                url: yield wallet.getExplorerTxUrl(assetAmount.asset.chain, hash),
             };
-            const hash = yield thorClient.deposit(addParams);
-            return { hash, url: thorchainClient.getExplorerTxUrl(hash) };
         });
     }
-    isERC20Asset(asset) {
-        const isGasAsset = ['ETH', 'BSC', 'AVAX'].includes(asset.symbol);
-        return this.isEVMChain(asset) && !isGasAsset;
-    }
-    isEVMChain(asset) {
-        const isEvmChain = ['ETH', 'BSC', 'AVAX'].includes(asset.chain);
-        return isEvmChain;
-    }
-    isUTXOChain(asset) {
-        return ['BTC', 'BCH', 'DOGE'].includes(asset.chain);
+    static isNonProtocolParams(params) {
+        if ((params.assetAmount.asset.chain === xchainThorchain.THORChain || params.assetAmount.asset.synth) &&
+            'address' in params &&
+            !!params.address) {
+            throw Error('Inconsistent params. Native actions do not support recipient');
+        }
+        return params.assetAmount.asset.chain !== xchainThorchain.THORChain && !params.assetAmount.asset.synth;
     }
 }
 
-const defaultQuery = new xchainThorchainQuery.ThorchainQuery();
 /**
  * THORChain Class for interacting with THORChain.
  * Recommended main class to use for swapping with THORChain
@@ -848,79 +173,144 @@ const defaultQuery = new xchainThorchainQuery.ThorchainQuery();
  */
 class ThorchainAMM {
     /**
-     * Contructor to create a ThorchainAMM
+     * Constructor to create a ThorchainAMM instance
      *
      * @param thorchainQuery - an instance of the ThorchainQuery
      * @returns ThorchainAMM
      */
-    constructor(thorchainQuery = defaultQuery) {
+    constructor(thorchainQuery = new xchainThorchainQuery.ThorchainQuery(), wallet = new xchainWallet.Wallet({
+        BTC: new xchainBitcoin.Client(Object.assign(Object.assign({}, xchainBitcoin.defaultBTCParams), { network: xchainClient.Network.Mainnet })),
+        BCH: new xchainBitcoincash.Client(Object.assign(Object.assign({}, xchainBitcoincash.defaultBchParams), { network: xchainClient.Network.Mainnet })),
+        LTC: new xchainLitecoin.Client(Object.assign(Object.assign({}, xchainLitecoin.defaultLtcParams), { network: xchainClient.Network.Mainnet })),
+        DOGE: new xchainDoge.Client(Object.assign(Object.assign({}, xchainDoge.defaultDogeParams), { network: xchainClient.Network.Mainnet })),
+        ETH: new xchainEthereum.Client(Object.assign(Object.assign({}, xchainEthereum.defaultEthParams), { network: xchainClient.Network.Mainnet })),
+        AVAX: new xchainAvax.Client(Object.assign(Object.assign({}, xchainAvax.defaultAvaxParams), { network: xchainClient.Network.Mainnet })),
+        BSC: new xchainBsc.Client(Object.assign(Object.assign({}, xchainBsc.defaultBscParams), { network: xchainClient.Network.Mainnet })),
+        GAIA: new xchainCosmos.Client({ network: xchainClient.Network.Mainnet }),
+        BNB: new xchainBinance.Client({ network: xchainClient.Network.Mainnet }),
+        THOR: new xchainThorchain.Client(Object.assign(Object.assign({}, xchainThorchain.defaultClientConfig), { network: xchainClient.Network.Mainnet })),
+    })) {
         this.thorchainQuery = thorchainQuery;
+        this.wallet = wallet;
     }
     /**
-     * Provides a swap estimate for the given swap detail. Will check the params for errors before trying to get the estimate.
-     * Uses current pool data, works out inbound and outboud fee, affiliate fees and works out the expected wait time for the swap (in and out)
-     *
-     * @param params - amount to swap
+     * * Provides an estimate for a swap based on the given swap details.
+     * Checks the parameters for errors before attempting to retrieve the estimate.
+     * Utilizes current pool data to calculate inbound and outbound fees, affiliate fees,
+     * and the expected wait time for the swap (inbound and outbound).
+     * @param params Parameters for the swap, including the amount to swap.
   
-     * @returns The SwapEstimate
+     * @returns The estimated swap details.
      */
-    estimateSwap({ fromAsset, amount, destinationAsset, destinationAddress, affiliateAddress = '', interfaceID = `555`, affiliateBps = 0, toleranceBps, wallet, walletIndex, }) {
+    estimateSwap({ fromAddress, fromAsset, amount, destinationAsset, destinationAddress, affiliateAddress = '', affiliateBps = 0, toleranceBps, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            let errors = [];
-            if (wallet) {
-                const params = {
-                    input: amount,
-                    destinationAsset,
-                    destinationAddress,
-                    memo: '',
-                    waitTimeSeconds: 100,
-                    walletIndex,
-                };
-                errors = yield wallet.validateSwap(params);
-            }
+            const errors = yield this.validateSwap({
+                fromAddress,
+                fromAsset,
+                amount,
+                destinationAsset,
+                destinationAddress,
+            });
             const estimate = yield this.thorchainQuery.quoteSwap({
                 fromAsset,
                 amount,
                 destinationAsset,
                 destinationAddress,
                 affiliateAddress,
-                interfaceID,
                 affiliateBps,
                 toleranceBps,
             });
+            // Add any validation errors to the estimate
             estimate.txEstimate.errors.push(...errors);
-            estimate.txEstimate.canSwap = errors.length == 0;
+            estimate.txEstimate.canSwap = estimate.txEstimate.errors.length === 0;
             return estimate;
         });
     }
     /**
-     * Conducts a swap with the given inputs. Should be called after estimateSwap() to ensure the swap is valid
+     * Validate swap params
+     * @param {QuoteSwapParams} quoteSwapParams Swap params
+     * @returns {string[]} the reasons the swap can not be done. If it is empty there are no reason to avoid the swap
+     */
+    validateSwap({ fromAsset, fromAddress, destinationAsset, destinationAddress, amount, affiliateAddress, affiliateBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (destinationAddress && !this.wallet.validateAddress(destinationAsset.chain, destinationAddress)) {
+                errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
+            }
+            if (affiliateAddress) {
+                const isThorAddress = this.wallet.validateAddress(xchainThorchain.THORChain, affiliateAddress);
+                const isThorname = !!(yield this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.getTHORNameDetails(affiliateAddress));
+                if (!(isThorAddress || isThorname))
+                    errors.push(`affiliateAddress ${affiliateAddress} is not a valid THOR address`);
+            }
+            if (affiliateBps && (affiliateBps < 0 || affiliateBps > 10000)) {
+                errors.push(`affiliateBps ${affiliateBps} out of range [0 - 10000]`);
+            }
+            if (isProtocolERC20Asset(fromAsset) && fromAddress) {
+                const approveErrors = yield this.isRouterApprovedToSpend({
+                    asset: fromAsset,
+                    address: fromAddress,
+                    amount,
+                });
+                errors.push(...approveErrors);
+            }
+            return errors;
+        });
+    }
+    /**
+     * Conducts a swap with the given inputs. This method should be called after estimateSwap() to ensure the swap is valid.
      *
-     * @param wallet - wallet to use
-     * @param params - swap params
-     * @returns {SwapSubmitted} - Tx Hash, URL of BlockExplorer and expected wait time.
+     * @param wallet - The wallet to use for the swap.
+     * @param params - The swap parameters.
+     * @returns {SwapSubmitted} - The transaction hash, URL of BlockExplorer, and expected wait time.
      */
-    doSwap(wallet, params) {
+    doSwap({ fromAsset, fromAddress, amount, destinationAsset, destinationAddress, affiliateAddress, affiliateBps, toleranceBps, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Thorchain-query call satisfies the data needed for executeSwap to be called.
-            const txDetails = yield this.thorchainQuery.quoteSwap(params);
+            // Retrieve swap details from ThorchainQuery to ensure validity
+            const txDetails = yield this.thorchainQuery.quoteSwap({
+                fromAsset,
+                fromAddress,
+                amount,
+                destinationAsset,
+                destinationAddress,
+                affiliateAddress,
+                affiliateBps,
+                toleranceBps,
+            });
             if (!txDetails.txEstimate.canSwap) {
                 throw Error(txDetails.txEstimate.errors.join('\n'));
             }
-            return yield wallet.executeSwap({
-                input: params.amount,
-                destinationAsset: params.destinationAsset,
-                destinationAddress: params.destinationAddress,
+            // Execute the swap using Thorchain action
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: amount,
                 memo: txDetails.memo,
-                walletIndex: params.walletIndex,
-                feeOption: params.feeOption,
+                recipient: txDetails.toAddress,
             });
         });
     }
     /**
-     * Wraps estimate from thorchain query
-     * @param params - estimate add liquidity
-     * @returns - Estimate add lp object
+     * Validate if the asset router is allowed to spend the asset amount in name of the address
+     * @param {IsApprovedParams} isApprovedParams contains the asset and the amount the router is supposed to spend
+     * int name of address
+     * @returns {string[]} the reasons the router of the asset is not allowed to spend the amount. If it is empty, the asset router is allowed to spend the amount
+     */
+    isRouterApprovedToSpend({ asset, amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            const inboundDetails = yield this.thorchainQuery.getChainInboundDetails(asset.chain);
+            if (!inboundDetails.router)
+                throw Error(`Unknown router address for ${asset.chain}`);
+            const isApprovedResult = yield this.wallet.isApproved(asset, amount.baseAmount, address, inboundDetails.router);
+            if (!isApprovedResult)
+                errors.push('Thorchain router has not been approved to spend this amount');
+            return errors;
+        });
+    }
+    /**
+     * Wraps the estimate from ThorchainQuery for adding liquidity.
+     * @param params - The parameters for estimating adding liquidity.
+     * @returns - The estimated liquidity addition object.
      */
     estimateAddLiquidity(params) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -928,9 +318,9 @@ class ThorchainAMM {
         });
     }
     /**
-     * Wraps estimate withdraw from thorchain query
-     * @param params - estimate withdraw liquidity
-     * @returns - Estimate withdraw lp object
+     * Wraps the estimate from ThorchainQuery for withdrawing liquidity.
+     * @param params - The parameters for estimating withdrawing liquidity.
+     * @returns - The estimated liquidity withdrawal object.
      */
     estimateWithdrawLiquidity(params) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -938,36 +328,75 @@ class ThorchainAMM {
         });
     }
     /**
-     *
-     * @param wallet - wallet class
-     * @param params - liquidity parameters
+     * If there is no existing liquidity position, it is created automatically.
+     * @param wallet - Wallet class
+     * @param params - Liquidity parameter
      * @returns
      */
-    addLiquidityPosition(wallet, params) {
+    addLiquidityPosition(params) {
         return __awaiter(this, void 0, void 0, function* () {
             // Check amounts are greater than fees and use return estimated wait
             const checkLPAdd = yield this.thorchainQuery.estimateAddLP(params);
             if (!checkLPAdd.canAdd)
                 throw Error(`${checkLPAdd.errors}`);
-            return yield wallet.addLiquidity({
+            const inboundAsgard = (yield this.thorchainQuery.thorchainCache.getInboundDetails())[params.asset.asset.chain]
+                .address;
+            const addressRune = yield this.wallet.getAddress(xchainThorchain.THORChain);
+            const addressAsset = yield this.wallet.getAddress(params.asset.asset.chain);
+            // const waitTimeSeconds = params.waitTimeSeconds
+            const txSubmitted = [];
+            const addLiquidity = {
                 asset: params.asset,
                 rune: params.rune,
                 waitTimeSeconds: checkLPAdd.estimatedWaitSeconds,
                 assetPool: checkLPAdd.assetPool,
-            });
+            };
+            // symmetrical add
+            if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.gt(0)) {
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `+:${checkLPAdd.assetPool}:${addressRune}`,
+                    assetAmount: addLiquidity.asset,
+                    recipient: inboundAsgard,
+                }));
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `+:${checkLPAdd.assetPool}:${addressAsset}`,
+                    assetAmount: addLiquidity.rune,
+                }));
+                return txSubmitted;
+            }
+            else if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.eq(0)) {
+                // asymmetrical asset only
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `+:${checkLPAdd.assetPool}`,
+                    assetAmount: addLiquidity.asset,
+                    recipient: inboundAsgard,
+                }));
+                return txSubmitted;
+            }
+            else {
+                // asymmetrical rune only
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `+:${checkLPAdd.assetPool}`,
+                    assetAmount: addLiquidity.asset,
+                }));
+                return txSubmitted;
+            }
         });
     }
     /**
-     *
-     * @param params - liquidity parameters
-     * @param wallet - wallet needed to perform tx
-     * @return
+     * Withdraws liquidity from a position.
+     * @param params - The wallet to perform the transaction.
+     * @return - The array of transaction submissions.
      */
-    withdrawLiquidityPosition(wallet, params) {
+    withdrawLiquidityPosition(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Caution Dust Limits: BTC,BCH,LTC chains 10k sats; DOGE 1m Sats; ETH 0 wei; THOR 0 RUNE.
+            // Caution Dust Limits: BTC, BCH, LTC chains: 10k sats; DOGE: 1m Sats; ETH: 0 wei; THOR: 0 RUNE.
             const withdrawParams = yield this.thorchainQuery.estimateWithdrawLP(params);
-            return yield wallet.withdrawLiquidity({
+            const withdrawLiquidity = {
                 assetFee: withdrawParams.inbound.fees.asset,
                 runeFee: withdrawParams.inbound.fees.rune,
                 waitTimeSeconds: withdrawParams.estimatedWaitSeconds,
@@ -975,13 +404,50 @@ class ThorchainAMM {
                 assetPool: withdrawParams.assetPool,
                 assetAddress: withdrawParams.assetAddress,
                 runeAddress: withdrawParams.runeAddress,
-            });
+            };
+            const inboundAsgard = (yield this.thorchainQuery.thorchainCache.getInboundDetails())[withdrawLiquidity.assetFee.asset.chain].address;
+            // const waitTimeSeconds = params.waitTimeSeconds
+            const basisPoints = (withdrawLiquidity.percentage * 100).toFixed(); // convert to basis points
+            const txSubmitted = [];
+            if (withdrawLiquidity.assetAddress && withdrawLiquidity.runeAddress) {
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `-:${withdrawLiquidity.assetPool}:${basisPoints}`,
+                    assetAmount: withdrawLiquidity.assetFee,
+                    recipient: inboundAsgard,
+                }));
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `-:${withdrawLiquidity.assetPool}:${basisPoints}`,
+                    assetAmount: withdrawLiquidity.runeFee,
+                }));
+                return txSubmitted;
+            }
+            else if (withdrawLiquidity.assetAddress && !withdrawLiquidity.runeAddress) {
+                // asymmetrical asset only
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `-:${withdrawLiquidity.assetPool}:${basisPoints}`,
+                    assetAmount: withdrawLiquidity.assetFee,
+                    recipient: inboundAsgard,
+                }));
+                return txSubmitted;
+            }
+            else {
+                // asymmetrical rune only
+                txSubmitted.push(yield ThorchainAction.makeAction({
+                    wallet: this.wallet,
+                    memo: `-:${withdrawLiquidity.assetPool}:${basisPoints}`,
+                    assetAmount: withdrawLiquidity.runeFee,
+                }));
+                return txSubmitted;
+            }
         });
     }
     /**
-     *
-     * @param addAssetAmount
-     * @returns
+     * Estimates adding to a saver.
+     * @param addAssetAmount The amount to add to the saver.
+     * @returns The estimated addition to the saver object.
      */
     estimateAddSaver(addAssetAmount) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -989,9 +455,9 @@ class ThorchainAMM {
         });
     }
     /**
-     *
-     * @param withdrawParams
-     * @returns
+     * Estimates withdrawing from a saver.
+     * @param withdrawParams The parameters for withdrawing from the saver.
+     * @returns The estimated withdrawal from the saver object.
      */
     estimateWithdrawSaver(withdrawParams) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -999,9 +465,9 @@ class ThorchainAMM {
         });
     }
     /**
-     *
-     * @param getsaver
-     * @returns
+     * Retrieves the position of a saver.
+     * @param getsaver The parameters to retrieve the saver position.
+     * @returns The saver position object.
      */
     getSaverPosition(getsaver) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1009,37 +475,46 @@ class ThorchainAMM {
         });
     }
     /**
-     *
+     * Adds assets to a saver.
      * @param wallet - wallet needed to execute tx
-     * @param addAssetAmount - asset amount being added to savers
-     * @returns - submitted tx
+     * @param addAssetAmount - The amount to add to the saver.
+     * @returns - The submitted transaction.
      */
-    addSaver(wallet, addAssetAmount) {
+    addSaver(addAssetAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             const addEstimate = yield this.thorchainQuery.estimateAddSaver(addAssetAmount);
             if (!addEstimate.canAddSaver)
                 throw Error(`Cannot add to savers`);
-            return yield wallet.addSavers(addAssetAmount, addEstimate.memo, addEstimate.toAddress);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                recipient: addEstimate.toAddress,
+                assetAmount: addAssetAmount,
+                memo: addEstimate.memo,
+            });
         });
     }
     /**
-     *
-     * @param wallet - wallet to execute the transaction
-     * @param withdrawParams - params needed for withdraw
-     * @returns
+     * Withdraws assets from a saver.
+     * @param withdrawParams - The parameters for withdrawing from the saver.
+     * @returns The submitted transaction.
      */
-    withdrawSaver(wallet, withdrawParams) {
+    withdrawSaver(withdrawParams) {
         return __awaiter(this, void 0, void 0, function* () {
             const withdrawEstimate = yield this.thorchainQuery.estimateWithdrawSaver(withdrawParams);
             if (withdrawEstimate.errors.length > 0)
                 throw Error(`${withdrawEstimate.errors}`);
-            return yield wallet.withdrawSavers(withdrawEstimate.dustAmount, withdrawEstimate.memo, withdrawEstimate.toAddress);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                recipient: withdrawEstimate.toAddress,
+                assetAmount: withdrawEstimate.dustAmount,
+                memo: withdrawEstimate.memo,
+            });
         });
     }
     /**
-     *
-     * @param loanOpenParams
-     * @returns
+     * Retrieves a quote for opening a loan.
+     * @param loanOpenParams The parameters for opening the loan.
+     * @returns The quote for opening the loan.
      */
     getLoanQuoteOpen(loanOpenParams) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1047,9 +522,9 @@ class ThorchainAMM {
         });
     }
     /**
-     *
-     * @param loanCloseParams
-     * @returns
+     * Retrieves a quote for closing a loan.
+     * @param loanCloseParams The parameters for closing the loan.
+     * @returns The quote for closing the loan.
      */
     getLoanQuoteClose(loanCloseParams) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1057,45 +532,46 @@ class ThorchainAMM {
         });
     }
     /**
-     *
-     * @param wallet - wallet needed to execute transaction
-     * @param loanOpenParams - params needed to open the loan
-     * @returns - submitted tx
+     * Opens a loan.
+     * @param loanOpenParams - The parameters for opening the loan.
+     * @returns - The submitted transaction.
      */
-    addLoan(wallet, loanOpenParams) {
+    addLoan(loanOpenParams) {
         return __awaiter(this, void 0, void 0, function* () {
             const loanOpen = yield this.thorchainQuery.getLoanQuoteOpen(loanOpenParams);
             if (loanOpen.errors.length > 0)
                 throw Error(`${loanOpen.errors}`);
-            return yield wallet.loanOpen({
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
                 memo: `${loanOpen.memo}`,
-                amount: loanOpenParams.amount,
-                toAddress: `${loanOpen.inboundAddress}`,
+                recipient: `${loanOpen.inboundAddress}`,
+                assetAmount: loanOpenParams.amount,
             });
         });
     }
     /**
-     *
-     * @param wallet - wallet to execute the transaction
-     * @param loanCloseParams - params needed for withdrawing the loan
-     * @returns
+     * Withdraws assets from a loan.
+     * @param loanCloseParams - The parameters for withdrawing from the loan.
+     * @returns The submitted transaction.
      */
-    withdrawLoan(wallet, loanCloseParams) {
+    withdrawLoan(loanCloseParams) {
         return __awaiter(this, void 0, void 0, function* () {
             const withdrawLoan = yield this.thorchainQuery.getLoanQuoteClose(loanCloseParams);
+            // Checks if there are any errors in the quote
             if (withdrawLoan.errors.length > 0)
                 throw Error(`${withdrawLoan.errors}`);
-            return yield wallet.loanClose({
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
                 memo: `${withdrawLoan.memo}`,
-                amount: loanCloseParams.amount,
-                toAddress: `${withdrawLoan.inboundAddress}`,
+                recipient: `${withdrawLoan.inboundAddress}`,
+                assetAmount: loanCloseParams.amount,
             });
         });
     }
     /**
-     * Get all Thornames and its data associated owned by an address
-     * @param address - address
-     * @returns thornames data
+     * Retrieves all Thornames and their associated data owned by an address.
+     * @param address - The address to retrieve Thornames for.
+     * @returns The Thornames data.
      */
     getThornamesByAddress(address) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1105,4 +581,3 @@ class ThorchainAMM {
 }
 
 exports.ThorchainAMM = ThorchainAMM;
-exports.Wallet = Wallet;