@xchainjs/xchain-thorchain-amm 1.1.17 → 2.0.0

package/lib/index.esm.js

@@ -9,9 +9,9 @@ import { DOGEChain, Client as Client$6, defaultDogeParams } from '@xchainjs/xcha
 import { AssetETH, ETHChain, Client as Client$5, defaultEthParams } from '@xchainjs/xchain-ethereum';
 import { abi, MAX_APPROVAL } from '@xchainjs/xchain-evm';
 import { LTCChain, Client as Client$7, defaultLtcParams } from '@xchainjs/xchain-litecoin';
-import { THORChain, Client, defaultClientConfig, RUNE_DECIMAL, AssetRuneNative } from '@xchainjs/xchain-thorchain';
+import { THORChain, Client, defaultClientConfig, AssetRuneNative, RUNE_DECIMAL } from '@xchainjs/xchain-thorchain';
 import { ThorchainQuery, ThorchainCache, Thornode } from '@xchainjs/xchain-thorchain-query';
-import { eqAsset, getContractAddressFromAsset, baseAmount, CryptoAmount } from '@xchainjs/xchain-util';
+import { eqAsset, isSynthAsset, getContractAddressFromAsset, baseAmount, isTradeAsset, assetToString, AssetCryptoAmount, CryptoAmount } from '@xchainjs/xchain-util';
 import { Wallet } from '@xchainjs/xchain-wallet';
 import { ethers } from 'ethers';
 
@@ -56,7 +56,18 @@ const isProtocolEVMChain = (chain) => {
 const isProtocolERC20Asset = (asset) => {
     return isProtocolEVMChain(asset.chain)
         ? [AssetETH, AssetAVAX, AssetBSC].findIndex((nativeEVMAsset) => eqAsset(nativeEVMAsset, asset)) === -1 &&
-            !asset.synth
+            !isSynthAsset(asset)
+        : false;
+};
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+const isTokenCryptoAmount = (amount) => {
+    return isProtocolEVMChain(amount.asset.chain)
+        ? [AssetETH, AssetAVAX, AssetBSC].findIndex((nativeEVMAsset) => eqAsset(nativeEVMAsset, amount.asset)) === -1 &&
+            !isSynthAsset(amount.asset)
         : false;
 };
 /**
@@ -182,12 +193,16 @@ class ThorchainAction {
         });
     }
     static isNonProtocolParams(params) {
-        if ((params.assetAmount.asset.chain === THORChain || params.assetAmount.asset.synth) &&
+        if ((params.assetAmount.asset.chain === THORChain ||
+            isSynthAsset(params.assetAmount.asset) ||
+            isTradeAsset(params.assetAmount.asset)) &&
             'address' in params &&
             !!params.address) {
             throw Error('Inconsistent params. Native actions do not support recipient');
         }
-        return params.assetAmount.asset.chain !== THORChain && !params.assetAmount.asset.synth;
+        return (params.assetAmount.asset.chain !== THORChain &&
+            !isSynthAsset(params.assetAmount.asset) &&
+            !isTradeAsset(params.assetAmount.asset));
     }
 }
 
@@ -262,9 +277,15 @@ class ThorchainAMM {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
             if (destinationAddress &&
-                !validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, destinationAsset.synth ? THORChain : destinationAsset.chain, destinationAddress)) {
+                !validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, isSynthAsset(destinationAsset) || isTradeAsset(destinationAsset) ? THORChain : destinationAsset.chain, destinationAddress)) {
                 errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
             }
+            if (!isTradeAsset(fromAsset) && !eqAsset(fromAsset, AssetRuneNative) && isTradeAsset(destinationAsset)) {
+                errors.push('Can not make swap from non trade asset or non Rune asset to trade asset. Use addToTrade (TRADE+) operation');
+            }
+            if (isTradeAsset(fromAsset) && !isTradeAsset(destinationAsset) && !eqAsset(destinationAsset, AssetRuneNative)) {
+                errors.push('Can not make swap from trade asset to non trade asset or non Rune asset. Use withdrawFromTrade (TRADE-) operation');
+            }
             if (affiliateAddress) {
                 const isThorAddress = validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, THORChain, affiliateAddress);
                 const isThorname = !!(yield this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.getTHORNameDetails(affiliateAddress));
@@ -281,12 +302,17 @@ class ThorchainAMM {
                 errors.push(`streamingQuantity ${streamingQuantity} can not be lower than zero`);
             }
             if (isProtocolERC20Asset(fromAsset) && fromAddress) {
-                const approveErrors = yield this.isRouterApprovedToSpend({
-                    asset: fromAsset,
-                    address: fromAddress,
-                    amount,
-                });
-                errors.push(...approveErrors);
+                if (!isTokenCryptoAmount(amount)) {
+                    errors.push(`${assetToString(amount.asset)} is not Token asset amount`);
+                }
+                else {
+                    const approveErrors = yield this.isRouterApprovedToSpend({
+                        asset: fromAsset,
+                        address: fromAddress,
+                        amount,
+                    });
+                    errors.push(...approveErrors);
+                }
             }
             return errors;
         });
@@ -653,7 +679,7 @@ class ThorchainAMM {
                 return {
                     memo: '',
                     errors,
-                    value: new CryptoAmount(baseAmount(0, RUNE_DECIMAL), AssetRuneNative),
+                    value: new AssetCryptoAmount(baseAmount(0, RUNE_DECIMAL), AssetRuneNative),
                     allowed: false,
                 };
             }
@@ -666,7 +692,7 @@ class ThorchainAMM {
                 return {
                     memo: '',
                     errors: ['message' in e ? e.message : `Unknown error: ${e}`],
-                    value: new CryptoAmount(baseAmount(0, RUNE_DECIMAL), AssetRuneNative),
+                    value: new AssetCryptoAmount(baseAmount(0, RUNE_DECIMAL), AssetRuneNative),
                     allowed: false,
                 };
             }
@@ -696,7 +722,7 @@ class ThorchainAMM {
                 return {
                     memo: '',
                     errors,
-                    value: new CryptoAmount(baseAmount(0, RUNE_DECIMAL), AssetRuneNative),
+                    value: new AssetCryptoAmount(baseAmount(0, RUNE_DECIMAL), AssetRuneNative),
                     allowed: false,
                 };
             }
@@ -749,6 +775,197 @@ class ThorchainAMM {
             });
         });
     }
+    /**
+     * Estimate adding trade amount to account
+     * @param {AddToTradeAccountParams} param Add to trade account params
+     * @returns {AddToTradeAccount} Estimation to add amount to trade account
+     */
+    estimateAddToTradeAccount({ amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (!validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, THORChain, address)) {
+                errors.push('Invalid trade account address');
+            }
+            let inboundDetails;
+            try {
+                inboundDetails = yield this.thorchainQuery.getChainInboundDetails(amount.asset.chain);
+            }
+            catch (_a) {
+                errors.push(`Can not get inbound address for ${amount.asset.chain}`);
+            }
+            if (errors.length) {
+                return {
+                    allowed: false,
+                    errors,
+                    value: new CryptoAmount(baseAmount(0, amount.assetAmount.decimal), amount.asset),
+                    memo: '',
+                    toAddress: '',
+                };
+            }
+            return {
+                toAddress: inboundDetails ? inboundDetails.address : '',
+                memo: `TRADE+:${address}`,
+                value: amount,
+                allowed: true,
+                errors,
+            };
+        });
+    }
+    /**
+     * Add trade amount to account
+     * @param {AddToTradeAccountParams} param Add to trade account params
+     * @returns {TxSubmitted} Transaction made to add the trade amount
+     */
+    addToTradeAccount({ amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateAddToTradeAccount({ amount, address });
+            if (!quote.allowed)
+                throw Error(`Can not add to trade account. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
+                recipient: quote.toAddress,
+            });
+        });
+    }
+    /**
+     * Estimate withdrawing trade amount from account
+     * @param {WithdrawFromTradeAccountParams} param Withdraw from trade account params
+     * @returns {WithdrawFromTradeAccount} Estimation to withdraw amount from trade account
+     */
+    estimateWithdrawFromTradeAccount({ amount, address, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (!validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, amount.asset.chain, address)) {
+                errors.push('Invalid address to send the withdraw');
+            }
+            if (errors.length) {
+                return {
+                    allowed: false,
+                    errors,
+                    value: new CryptoAmount(baseAmount(0, amount.assetAmount.decimal), amount.asset),
+                    memo: '',
+                };
+            }
+            return {
+                memo: `TRADE-:${address}`,
+                value: amount,
+                allowed: true,
+                errors,
+            };
+        });
+    }
+    /**
+     * Withdraw trade amount from account
+     * @param {WithdrawFromTradeAccountParams} param Withdraw from trade account params
+     * @returns {TxSubmitted} Estimation to withdraw amount from trade account
+     */
+    withdrawFromTradeAccount({ amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateWithdrawFromTradeAccount({ amount, address });
+            if (!quote.allowed)
+                throw Error(`Can not withdraw from trade account. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
+            });
+        });
+    }
+    /**
+     * Estimate Rune pool deposit
+     * @param {DepositToRunePoolParams} params Deposit to Rune pool params
+     * @returns {EstimateDepositToRunePool} Estimation to make the deposit
+     */
+    estimateDepositToRunePool({ amount }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const constants = yield this.thorchainQuery.thorchainCache.thornode.getTcConstants();
+            return {
+                allowed: true,
+                maturityBlocks: Number(constants['RUNEPoolDepositMaturityBlocks']),
+                amount,
+                errors: [],
+                memo: 'POOL+',
+            };
+        });
+    }
+    /**
+     * Deposit amount to Rune pool
+     * @param {DepositToRunePoolParams} amount Amount to deposit to Rune pool
+     * @returns {TxSubmitted} Transaction made to deposit to Rune pool
+     */
+    depositToRunePool(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateDepositToRunePool(params);
+            if (!quote.allowed)
+                throw Error(`Can not deposit to Rune pool. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.amount,
+                memo: quote.memo,
+            });
+        });
+    }
+    /**
+     * Estimate Rune pool withdraw
+     * @param {WithdrawFromRunePoolParams} params Withdraw from Rune pool params
+     * @returns {EstimateWithdrawFromRunePool} Estimation to make a withdraw from Rune pool
+     */
+    estimateWithdrawFromRunePool({ withdrawBps, affiliate, feeBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (withdrawBps <= 0 || withdrawBps > 10000) {
+                errors.push('withdrawBps out of range. Range 0-10000');
+            }
+            if (affiliate) {
+                if (!validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, THORChain, affiliate) &&
+                    !(yield this.isTHORName(affiliate))) {
+                    errors.push('Invalid affiliate. Affiliate must be a THORName or THOR address');
+                }
+                if (!feeBps || feeBps <= 0 || feeBps > 1000) {
+                    errors.push('feeBps out of range. Range 0-1000');
+                }
+            }
+            if (errors.length) {
+                return {
+                    amount: new AssetCryptoAmount(baseAmount(0), AssetRuneNative),
+                    memo: '',
+                    allowed: false,
+                    errors,
+                };
+            }
+            return {
+                amount: new AssetCryptoAmount(baseAmount(0), AssetRuneNative),
+                memo: `POOL-:${withdrawBps}:${affiliate || ''}:${affiliate ? feeBps : ''}`,
+                allowed: true,
+                errors,
+            };
+        });
+    }
+    /**
+     * Withdraw amount from Rune pool
+     * @param {WithdrawFromRunePoolParams} params Withdraw from Rune pool params
+     * @returns {TxSubmitted} Transaction made to withdraw from Rune pool
+     */
+    withdrawFromRunePool(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateWithdrawFromRunePool(params);
+            if (!quote.allowed)
+                throw Error(`Can not withdraw from Rune pool. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.amount,
+                memo: quote.memo,
+            });
+        });
+    }
+    isTHORName(thorname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const details = yield this.thorchainQuery.getThornameDetails(thorname);
+            return details.owner !== '';
+        });
+    }
 }
 
 export { ThorchainAMM };

package/lib/index.js

@@ -60,7 +60,18 @@ const isProtocolEVMChain = (chain) => {
 const isProtocolERC20Asset = (asset) => {
     return isProtocolEVMChain(asset.chain)
         ? [xchainEthereum.AssetETH, xchainAvax.AssetAVAX, xchainBsc.AssetBSC].findIndex((nativeEVMAsset) => xchainUtil.eqAsset(nativeEVMAsset, asset)) === -1 &&
-            !asset.synth
+            !xchainUtil.isSynthAsset(asset)
+        : false;
+};
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+const isTokenCryptoAmount = (amount) => {
+    return isProtocolEVMChain(amount.asset.chain)
+        ? [xchainEthereum.AssetETH, xchainAvax.AssetAVAX, xchainBsc.AssetBSC].findIndex((nativeEVMAsset) => xchainUtil.eqAsset(nativeEVMAsset, amount.asset)) === -1 &&
+            !xchainUtil.isSynthAsset(amount.asset)
         : false;
 };
 /**
@@ -186,12 +197,16 @@ class ThorchainAction {
         });
     }
     static isNonProtocolParams(params) {
-        if ((params.assetAmount.asset.chain === xchainThorchain.THORChain || params.assetAmount.asset.synth) &&
+        if ((params.assetAmount.asset.chain === xchainThorchain.THORChain ||
+            xchainUtil.isSynthAsset(params.assetAmount.asset) ||
+            xchainUtil.isTradeAsset(params.assetAmount.asset)) &&
             '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;
+        return (params.assetAmount.asset.chain !== xchainThorchain.THORChain &&
+            !xchainUtil.isSynthAsset(params.assetAmount.asset) &&
+            !xchainUtil.isTradeAsset(params.assetAmount.asset));
     }
 }
 
@@ -266,9 +281,15 @@ class ThorchainAMM {
         return __awaiter(this, void 0, void 0, function* () {
             const errors = [];
             if (destinationAddress &&
-                !validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, destinationAsset.synth ? xchainThorchain.THORChain : destinationAsset.chain, destinationAddress)) {
+                !validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, xchainUtil.isSynthAsset(destinationAsset) || xchainUtil.isTradeAsset(destinationAsset) ? xchainThorchain.THORChain : destinationAsset.chain, destinationAddress)) {
                 errors.push(`destinationAddress ${destinationAddress} is not a valid address`);
             }
+            if (!xchainUtil.isTradeAsset(fromAsset) && !xchainUtil.eqAsset(fromAsset, xchainThorchain.AssetRuneNative) && xchainUtil.isTradeAsset(destinationAsset)) {
+                errors.push('Can not make swap from non trade asset or non Rune asset to trade asset. Use addToTrade (TRADE+) operation');
+            }
+            if (xchainUtil.isTradeAsset(fromAsset) && !xchainUtil.isTradeAsset(destinationAsset) && !xchainUtil.eqAsset(destinationAsset, xchainThorchain.AssetRuneNative)) {
+                errors.push('Can not make swap from trade asset to non trade asset or non Rune asset. Use withdrawFromTrade (TRADE-) operation');
+            }
             if (affiliateAddress) {
                 const isThorAddress = validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, xchainThorchain.THORChain, affiliateAddress);
                 const isThorname = !!(yield this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.getTHORNameDetails(affiliateAddress));
@@ -285,12 +306,17 @@ class ThorchainAMM {
                 errors.push(`streamingQuantity ${streamingQuantity} can not be lower than zero`);
             }
             if (isProtocolERC20Asset(fromAsset) && fromAddress) {
-                const approveErrors = yield this.isRouterApprovedToSpend({
-                    asset: fromAsset,
-                    address: fromAddress,
-                    amount,
-                });
-                errors.push(...approveErrors);
+                if (!isTokenCryptoAmount(amount)) {
+                    errors.push(`${xchainUtil.assetToString(amount.asset)} is not Token asset amount`);
+                }
+                else {
+                    const approveErrors = yield this.isRouterApprovedToSpend({
+                        asset: fromAsset,
+                        address: fromAddress,
+                        amount,
+                    });
+                    errors.push(...approveErrors);
+                }
             }
             return errors;
         });
@@ -657,7 +683,7 @@ class ThorchainAMM {
                 return {
                     memo: '',
                     errors,
-                    value: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0, xchainThorchain.RUNE_DECIMAL), xchainThorchain.AssetRuneNative),
+                    value: new xchainUtil.AssetCryptoAmount(xchainUtil.baseAmount(0, xchainThorchain.RUNE_DECIMAL), xchainThorchain.AssetRuneNative),
                     allowed: false,
                 };
             }
@@ -670,7 +696,7 @@ class ThorchainAMM {
                 return {
                     memo: '',
                     errors: ['message' in e ? e.message : `Unknown error: ${e}`],
-                    value: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0, xchainThorchain.RUNE_DECIMAL), xchainThorchain.AssetRuneNative),
+                    value: new xchainUtil.AssetCryptoAmount(xchainUtil.baseAmount(0, xchainThorchain.RUNE_DECIMAL), xchainThorchain.AssetRuneNative),
                     allowed: false,
                 };
             }
@@ -700,7 +726,7 @@ class ThorchainAMM {
                 return {
                     memo: '',
                     errors,
-                    value: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0, xchainThorchain.RUNE_DECIMAL), xchainThorchain.AssetRuneNative),
+                    value: new xchainUtil.AssetCryptoAmount(xchainUtil.baseAmount(0, xchainThorchain.RUNE_DECIMAL), xchainThorchain.AssetRuneNative),
                     allowed: false,
                 };
             }
@@ -753,6 +779,197 @@ class ThorchainAMM {
             });
         });
     }
+    /**
+     * Estimate adding trade amount to account
+     * @param {AddToTradeAccountParams} param Add to trade account params
+     * @returns {AddToTradeAccount} Estimation to add amount to trade account
+     */
+    estimateAddToTradeAccount({ amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (!validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, xchainThorchain.THORChain, address)) {
+                errors.push('Invalid trade account address');
+            }
+            let inboundDetails;
+            try {
+                inboundDetails = yield this.thorchainQuery.getChainInboundDetails(amount.asset.chain);
+            }
+            catch (_a) {
+                errors.push(`Can not get inbound address for ${amount.asset.chain}`);
+            }
+            if (errors.length) {
+                return {
+                    allowed: false,
+                    errors,
+                    value: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0, amount.assetAmount.decimal), amount.asset),
+                    memo: '',
+                    toAddress: '',
+                };
+            }
+            return {
+                toAddress: inboundDetails ? inboundDetails.address : '',
+                memo: `TRADE+:${address}`,
+                value: amount,
+                allowed: true,
+                errors,
+            };
+        });
+    }
+    /**
+     * Add trade amount to account
+     * @param {AddToTradeAccountParams} param Add to trade account params
+     * @returns {TxSubmitted} Transaction made to add the trade amount
+     */
+    addToTradeAccount({ amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateAddToTradeAccount({ amount, address });
+            if (!quote.allowed)
+                throw Error(`Can not add to trade account. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
+                recipient: quote.toAddress,
+            });
+        });
+    }
+    /**
+     * Estimate withdrawing trade amount from account
+     * @param {WithdrawFromTradeAccountParams} param Withdraw from trade account params
+     * @returns {WithdrawFromTradeAccount} Estimation to withdraw amount from trade account
+     */
+    estimateWithdrawFromTradeAccount({ amount, address, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (!validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, amount.asset.chain, address)) {
+                errors.push('Invalid address to send the withdraw');
+            }
+            if (errors.length) {
+                return {
+                    allowed: false,
+                    errors,
+                    value: new xchainUtil.CryptoAmount(xchainUtil.baseAmount(0, amount.assetAmount.decimal), amount.asset),
+                    memo: '',
+                };
+            }
+            return {
+                memo: `TRADE-:${address}`,
+                value: amount,
+                allowed: true,
+                errors,
+            };
+        });
+    }
+    /**
+     * Withdraw trade amount from account
+     * @param {WithdrawFromTradeAccountParams} param Withdraw from trade account params
+     * @returns {TxSubmitted} Estimation to withdraw amount from trade account
+     */
+    withdrawFromTradeAccount({ amount, address }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateWithdrawFromTradeAccount({ amount, address });
+            if (!quote.allowed)
+                throw Error(`Can not withdraw from trade account. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.value,
+                memo: quote.memo,
+            });
+        });
+    }
+    /**
+     * Estimate Rune pool deposit
+     * @param {DepositToRunePoolParams} params Deposit to Rune pool params
+     * @returns {EstimateDepositToRunePool} Estimation to make the deposit
+     */
+    estimateDepositToRunePool({ amount }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const constants = yield this.thorchainQuery.thorchainCache.thornode.getTcConstants();
+            return {
+                allowed: true,
+                maturityBlocks: Number(constants['RUNEPoolDepositMaturityBlocks']),
+                amount,
+                errors: [],
+                memo: 'POOL+',
+            };
+        });
+    }
+    /**
+     * Deposit amount to Rune pool
+     * @param {DepositToRunePoolParams} amount Amount to deposit to Rune pool
+     * @returns {TxSubmitted} Transaction made to deposit to Rune pool
+     */
+    depositToRunePool(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateDepositToRunePool(params);
+            if (!quote.allowed)
+                throw Error(`Can not deposit to Rune pool. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.amount,
+                memo: quote.memo,
+            });
+        });
+    }
+    /**
+     * Estimate Rune pool withdraw
+     * @param {WithdrawFromRunePoolParams} params Withdraw from Rune pool params
+     * @returns {EstimateWithdrawFromRunePool} Estimation to make a withdraw from Rune pool
+     */
+    estimateWithdrawFromRunePool({ withdrawBps, affiliate, feeBps, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            if (withdrawBps <= 0 || withdrawBps > 10000) {
+                errors.push('withdrawBps out of range. Range 0-10000');
+            }
+            if (affiliate) {
+                if (!validateAddress(this.thorchainQuery.thorchainCache.midgardQuery.midgardCache.midgard.network, xchainThorchain.THORChain, affiliate) &&
+                    !(yield this.isTHORName(affiliate))) {
+                    errors.push('Invalid affiliate. Affiliate must be a THORName or THOR address');
+                }
+                if (!feeBps || feeBps <= 0 || feeBps > 1000) {
+                    errors.push('feeBps out of range. Range 0-1000');
+                }
+            }
+            if (errors.length) {
+                return {
+                    amount: new xchainUtil.AssetCryptoAmount(xchainUtil.baseAmount(0), xchainThorchain.AssetRuneNative),
+                    memo: '',
+                    allowed: false,
+                    errors,
+                };
+            }
+            return {
+                amount: new xchainUtil.AssetCryptoAmount(xchainUtil.baseAmount(0), xchainThorchain.AssetRuneNative),
+                memo: `POOL-:${withdrawBps}:${affiliate || ''}:${affiliate ? feeBps : ''}`,
+                allowed: true,
+                errors,
+            };
+        });
+    }
+    /**
+     * Withdraw amount from Rune pool
+     * @param {WithdrawFromRunePoolParams} params Withdraw from Rune pool params
+     * @returns {TxSubmitted} Transaction made to withdraw from Rune pool
+     */
+    withdrawFromRunePool(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const quote = yield this.estimateWithdrawFromRunePool(params);
+            if (!quote.allowed)
+                throw Error(`Can not withdraw from Rune pool. ${quote.errors.join(' ')}`);
+            return ThorchainAction.makeAction({
+                wallet: this.wallet,
+                assetAmount: quote.amount,
+                memo: quote.memo,
+            });
+        });
+    }
+    isTHORName(thorname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const details = yield this.thorchainQuery.getThornameDetails(thorname);
+            return details.owner !== '';
+        });
+    }
 }
 
 exports.ThorchainAMM = ThorchainAMM;

package/lib/thorchain-action.d.ts

@@ -1,15 +1,16 @@
-import { Address, CryptoAmount } from '@xchainjs/xchain-util';
+import { CompatibleAsset } from '@xchainjs/xchain-thorchain-query';
+import { Address, Asset, CryptoAmount, TokenAsset } from '@xchainjs/xchain-util';
 import { Wallet } from '@xchainjs/xchain-wallet';
 import { TxSubmitted } from './types';
 export type NonProtocolActionParams = {
     wallet: Wallet;
-    assetAmount: CryptoAmount;
+    assetAmount: CryptoAmount<Asset | TokenAsset>;
     recipient: Address;
     memo: string;
 };
 export type ProtocolActionParams = {
     wallet: Wallet;
-    assetAmount: CryptoAmount;
+    assetAmount: CryptoAmount<CompatibleAsset>;
     memo: string;
 };
 export type ActionParams = ProtocolActionParams | NonProtocolActionParams;

package/lib/thorchain-amm.d.ts

@@ -1,7 +1,7 @@
 import { AddliquidityPosition, EstimateAddLP, EstimateAddSaver, EstimateWithdrawLP, EstimateWithdrawSaver, LoanCloseParams, LoanCloseQuote, LoanOpenParams, LoanOpenQuote, QuoteSwapParams, RegisterTHORName, SaversPosition, SaversWithdraw, ThorchainQuery, TxDetails, UpdateTHORName, WithdrawLiquidityPosition, getSaver } from '@xchainjs/xchain-thorchain-query';
-import { CryptoAmount } from '@xchainjs/xchain-util';
+import { Asset, CryptoAmount, TokenAsset } from '@xchainjs/xchain-util';
 import { Wallet } from '@xchainjs/xchain-wallet';
-import { ApproveParams, IsApprovedParams, QuoteTHORName, TxSubmitted } from './types';
+import { AddToTradeAccount, AddToTradeAccountParams, ApproveParams, DepositToRunePoolParams, EstimateDepositToRunePool, EstimateWithdrawFromRunePool, IsApprovedParams, QuoteTHORName, TxSubmitted, WithdrawFromRunePoolParams, WithdrawFromTradeAccount, WithdrawFromTradeAccountParams } from './types';
 /**
  * THORChain Class for interacting with THORChain.
  * Recommended main class to use for swapping with THORChain
@@ -84,7 +84,7 @@ export declare class ThorchainAMM {
      * @param addAssetAmount The amount to add to the saver.
      * @returns The estimated addition to the saver object.
      */
-    estimateAddSaver(addAssetAmount: CryptoAmount): Promise<EstimateAddSaver>;
+    estimateAddSaver(addAssetAmount: CryptoAmount<Asset | TokenAsset>): Promise<EstimateAddSaver>;
     /**
      * Estimates withdrawing from a saver.
      * @param withdrawParams The parameters for withdrawing from the saver.
@@ -103,7 +103,7 @@ export declare class ThorchainAMM {
      * @param addAssetAmount - The amount to add to the saver.
      * @returns - The submitted transaction.
      */
-    addSaver(addAssetAmount: CryptoAmount): Promise<TxSubmitted>;
+    addSaver(addAssetAmount: CryptoAmount<Asset | TokenAsset>): Promise<TxSubmitted>;
     /**
      * Withdraws assets from a saver.
      * @param withdrawParams - The parameters for withdrawing from the saver.
@@ -164,4 +164,53 @@ export declare class ThorchainAMM {
      * @returns {TxSubmitted} Transaction made to update the THORName
      */
     updateTHORName(params: UpdateTHORName): Promise<TxSubmitted>;
+    /**
+     * Estimate adding trade amount to account
+     * @param {AddToTradeAccountParams} param Add to trade account params
+     * @returns {AddToTradeAccount} Estimation to add amount to trade account
+     */
+    estimateAddToTradeAccount({ amount, address }: AddToTradeAccountParams): Promise<AddToTradeAccount>;
+    /**
+     * Add trade amount to account
+     * @param {AddToTradeAccountParams} param Add to trade account params
+     * @returns {TxSubmitted} Transaction made to add the trade amount
+     */
+    addToTradeAccount({ amount, address }: AddToTradeAccountParams): Promise<TxSubmitted>;
+    /**
+     * Estimate withdrawing trade amount from account
+     * @param {WithdrawFromTradeAccountParams} param Withdraw from trade account params
+     * @returns {WithdrawFromTradeAccount} Estimation to withdraw amount from trade account
+     */
+    estimateWithdrawFromTradeAccount({ amount, address, }: WithdrawFromTradeAccountParams): Promise<WithdrawFromTradeAccount>;
+    /**
+     * Withdraw trade amount from account
+     * @param {WithdrawFromTradeAccountParams} param Withdraw from trade account params
+     * @returns {TxSubmitted} Estimation to withdraw amount from trade account
+     */
+    withdrawFromTradeAccount({ amount, address }: WithdrawFromTradeAccountParams): Promise<TxSubmitted>;
+    /**
+     * Estimate Rune pool deposit
+     * @param {DepositToRunePoolParams} params Deposit to Rune pool params
+     * @returns {EstimateDepositToRunePool} Estimation to make the deposit
+     */
+    estimateDepositToRunePool({ amount }: DepositToRunePoolParams): Promise<EstimateDepositToRunePool>;
+    /**
+     * Deposit amount to Rune pool
+     * @param {DepositToRunePoolParams} amount Amount to deposit to Rune pool
+     * @returns {TxSubmitted} Transaction made to deposit to Rune pool
+     */
+    depositToRunePool(params: DepositToRunePoolParams): Promise<TxSubmitted>;
+    /**
+     * Estimate Rune pool withdraw
+     * @param {WithdrawFromRunePoolParams} params Withdraw from Rune pool params
+     * @returns {EstimateWithdrawFromRunePool} Estimation to make a withdraw from Rune pool
+     */
+    estimateWithdrawFromRunePool({ withdrawBps, affiliate, feeBps, }: WithdrawFromRunePoolParams): Promise<EstimateWithdrawFromRunePool>;
+    /**
+     * Withdraw amount from Rune pool
+     * @param {WithdrawFromRunePoolParams} params Withdraw from Rune pool params
+     * @returns {TxSubmitted} Transaction made to withdraw from Rune pool
+     */
+    withdrawFromRunePool(params: WithdrawFromRunePoolParams): Promise<TxSubmitted>;
+    private isTHORName;
 }

package/lib/types.d.ts

@@ -1,6 +1,6 @@
 import { Balance, FeeOption } from '@xchainjs/xchain-client';
 import { LiquidityPool, QuoteTHORName as BaseQuoteTHORName } from '@xchainjs/xchain-thorchain-query';
-import { Address, Asset, BaseAmount, Chain, CryptoAmount } from '@xchainjs/xchain-util';
+import { Address, Asset, AssetCryptoAmount, BaseAmount, Chain, CryptoAmount, SynthAsset, TokenAsset, TradeCryptoAmount } from '@xchainjs/xchain-util';
 /**
  * Represents the balance information for all assets on a particular chain.
  */
@@ -13,8 +13,8 @@ export type AllBalances = {
  * Represents the parameters for executing a swap transaction.
  */
 export type ExecuteSwap = {
-    input: CryptoAmount;
-    destinationAsset: Asset;
+    input: CryptoAmount<Asset | TokenAsset | SynthAsset>;
+    destinationAsset: Asset | TokenAsset | SynthAsset;
     destinationAddress?: Address;
     memo: string;
     feeOption?: FeeOption;
@@ -32,16 +32,16 @@ export type TxSubmitted = {
  */
 export type LiquidityPosition = {
     assetPool: LiquidityPool;
-    assetAmount: CryptoAmount;
-    runeAmount: CryptoAmount;
+    assetAmount: CryptoAmount<Asset | TokenAsset>;
+    runeAmount: AssetCryptoAmount;
     impermanentLossProtection: number;
 };
 /**
  * Represents the parameters for adding liquidity to a pool.
  */
 export type AddLiquidity = {
-    asset: CryptoAmount;
-    rune: CryptoAmount;
+    asset: CryptoAmount<Asset | TokenAsset>;
+    rune: AssetCryptoAmount;
     waitTimeSeconds: number;
     assetPool: string;
 };
@@ -49,8 +49,8 @@ export type AddLiquidity = {
  * Represents the parameters for withdrawing liquidity from a pool.
  */
 export type WithdrawLiquidity = {
-    assetFee: CryptoAmount;
-    runeFee: CryptoAmount;
+    assetFee: CryptoAmount<Asset | TokenAsset>;
+    runeFee: AssetCryptoAmount;
     waitTimeSeconds: number;
     percentage: number;
     assetPool: string;
@@ -106,13 +106,13 @@ export type UpdateThornameParams = {
     expirity?: Date;
 };
 export type IsApprovedParams = {
-    asset: Asset;
-    amount: CryptoAmount;
+    asset: TokenAsset;
+    amount: CryptoAmount<TokenAsset>;
     address: Address;
 };
 export type ApproveParams = {
-    asset: Asset;
-    amount: CryptoAmount | undefined;
+    asset: TokenAsset;
+    amount?: CryptoAmount<TokenAsset>;
 };
 /**
  * Estimation quote to register or update a THORName
@@ -127,3 +127,147 @@ export type QuoteTHORName = BaseQuoteTHORName & {
      */
     errors: string[];
 };
+/**
+ * Add to trade account params
+ */
+export type AddToTradeAccountParams = {
+    /**
+     * Amount to add to the account
+     */
+    amount: CryptoAmount<Asset | TokenAsset>;
+    /**
+     * Trade account address
+     */
+    address: Address;
+};
+/**
+ * Estimation to add amount to trade account
+ */
+export type AddToTradeAccount = {
+    /**
+     * Address to send transaction
+     */
+    toAddress: string;
+    /**
+     * Memo to add to the transaction to add the trade amount
+     */
+    memo: string;
+    /**
+     * Amount to send to the address
+     */
+    value: CryptoAmount<Asset | TokenAsset>;
+    /**
+     * If the action can be or not can be done
+     */
+    allowed: boolean;
+    /**
+     * If any, list of errors with the reason the operation is not allowed
+     */
+    errors: string[];
+};
+/**
+ * Withdraw from trade account params
+ */
+export type WithdrawFromTradeAccountParams = {
+    /**
+     * Amount to withdraw from the account
+     */
+    amount: TradeCryptoAmount;
+    /**
+     * Address to make to the withdraw to
+     */
+    address: Address;
+};
+/**
+ * Estimation to add amount to trade account
+ */
+export type WithdrawFromTradeAccount = {
+    /**
+     * Memo to add to the transaction to add the trade amount
+     */
+    memo: string;
+    /**
+     * Amount to send to the address
+     */
+    value: TradeCryptoAmount;
+    /**
+     * If the action can be or not can be done
+     */
+    allowed: boolean;
+    /**
+     * If any, list of errors with the reason the operation is not allowed
+     */
+    errors: string[];
+};
+/**
+ * Estimation to quote to deposit to Rune pool
+ */
+export type EstimateDepositToRunePool = {
+    /**
+     * Amount to send in the transaction to make the deposit
+     */
+    amount: AssetCryptoAmount;
+    /**
+     * Memo to send in the transaction to make the deposit
+     */
+    memo: string;
+    /**
+     * Number of blocks from the last deposit that a withdraw is allowed
+     */
+    maturityBlocks: number;
+    /**
+     * If the action can be or not can be done
+     */
+    allowed: boolean;
+    /**
+     * If any, list of errors with the reason the operation is not allowed
+     */
+    errors: string[];
+};
+/**
+ * Deposit to Rune pool params
+ */
+export type DepositToRunePoolParams = {
+    /**
+     * Rune amount to deposit to the Rune pool
+     */
+    amount: AssetCryptoAmount;
+};
+/**
+ * Estimation to quote to withdraw from Rune pool
+ */
+export type EstimateWithdrawFromRunePool = {
+    /**
+     * Amount to send in the transaction to make the withdraw
+     */
+    amount: AssetCryptoAmount;
+    /**
+     * Memo to send in the transaction to make the withdraw
+     */
+    memo: string;
+    /**
+     * If the action can be or not can be done
+     */
+    allowed: boolean;
+    /**
+     * If any, list of errors with the reason the operation is not allowed
+     */
+    errors: string[];
+};
+/**
+ * Withdraw from Rune pool params
+ */
+export type WithdrawFromRunePoolParams = {
+    /**
+     * Basis points to retrieve from the Rune pool position. Range 0-10000, where 10000 = 100%.
+     */
+    withdrawBps: number;
+    /**
+     * Affiliate address
+     */
+    affiliate?: Address;
+    /**
+     * Basis points to send to the affiliate address. Ranges from 0 to 1000 Basis Points.
+     */
+    feeBps?: number;
+};

package/lib/utils.d.ts

@@ -1,5 +1,6 @@
 import { Network } from '@xchainjs/xchain-client';
-import { Address, Asset, Chain } from '@xchainjs/xchain-util';
+import { CompatibleAsset } from '@xchainjs/xchain-thorchain-query';
+import { Address, Chain, CryptoAmount, TokenAsset, TokenCryptoAmount } from '@xchainjs/xchain-util';
 /**
  * Check if a chain is EVM and supported by the protocol
  * @param {Chain} chain to check
@@ -11,7 +12,13 @@ export declare const isProtocolEVMChain: (chain: Chain) => boolean;
  * @param {Asset} asset to check
  * @returns true if asset is ERC20, otherwise, false
  */
-export declare const isProtocolERC20Asset: (asset: Asset) => boolean;
+export declare const isProtocolERC20Asset: (asset: CompatibleAsset) => asset is TokenAsset;
+/**
+ * Check if asset is ERC20
+ * @param {Asset} asset to check
+ * @returns true if asset is ERC20, otherwise, false
+ */
+export declare const isTokenCryptoAmount: (amount: CryptoAmount) => amount is TokenCryptoAmount;
 /**
  * Check if a chain is EVM and supported by the protocol
  * @param {Chain} chain to check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-amm",
-  "version": "1.1.17",
+  "version": "2.0.0",
   "description": "module that exposes estimating & swappping cryptocurrency assets on thorchain",
   "keywords": [
     "THORChain",
@@ -36,21 +36,21 @@
     "url": "https://github.com/xchainjs/xchainjs-lib/issues"
   },
   "dependencies": {
-    "@xchainjs/xchain-avax": "0.5.6",
-    "@xchainjs/xchain-binance": "5.7.17",
-    "@xchainjs/xchain-bitcoin": "0.23.19",
-    "@xchainjs/xchain-bitcoincash": "0.17.17",
-    "@xchainjs/xchain-bsc": "0.5.6",
-    "@xchainjs/xchain-client": "0.16.8",
-    "@xchainjs/xchain-cosmos": "1.1.6",
-    "@xchainjs/xchain-doge": "0.7.20",
-    "@xchainjs/xchain-ethereum": "0.32.6",
-    "@xchainjs/xchain-evm": "0.6.4",
-    "@xchainjs/xchain-litecoin": "0.14.6",
-    "@xchainjs/xchain-thorchain": "1.1.1",
-    "@xchainjs/xchain-thorchain-query": "0.7.16",
-    "@xchainjs/xchain-util": "0.13.7",
-    "@xchainjs/xchain-wallet": "0.1.19",
+    "@xchainjs/xchain-avax": "1.0.0",
+    "@xchainjs/xchain-binance": "6.0.0",
+    "@xchainjs/xchain-bitcoin": "1.0.0",
+    "@xchainjs/xchain-bitcoincash": "1.0.0",
+    "@xchainjs/xchain-bsc": "1.0.0",
+    "@xchainjs/xchain-client": "1.0.0",
+    "@xchainjs/xchain-cosmos": "2.0.0",
+    "@xchainjs/xchain-doge": "1.0.0",
+    "@xchainjs/xchain-ethereum": "1.0.0",
+    "@xchainjs/xchain-evm": "1.0.0",
+    "@xchainjs/xchain-litecoin": "1.0.0",
+    "@xchainjs/xchain-thorchain": "2.0.0",
+    "@xchainjs/xchain-thorchain-query": "1.0.0",
+    "@xchainjs/xchain-util": "1.0.0",
+    "@xchainjs/xchain-wallet": "1.0.0",
     "ethers": "5.7.2"
   },
   "devDependencies": {