@xchainjs/xchain-thorchain-amm 0.1.0-beta5 → 0.3.0

package/README.md

@@ -27,12 +27,13 @@ Following peer dependencies have to be installed into your project. These are no
     "@xchainjs/xchain-doge": "^0.5.0",
     "@xchainjs/xchain-ethereum": "^0.27.0",
     "@xchainjs/xchain-evm": "^0.1.0-alpha2",
-    "@xchainjs/xchain-avax": "^0.1.0-alpha2",
+    "@xchainjs/xchain-avax": "^0.1.0-alpha3",
     "@xchainjs/xchain-litecoin": "^0.10.0",
-    "@xchainjs/xchain-midgard": "0.1.0-alpha2",
+    "@xchainjs/xchain-midgard": "^0.1.0",
     "@xchainjs/xchain-terra": "^0.3.0",
     "@xchainjs/xchain-thorchain": "^0.26.0",
-    "@xchainjs/xchain-thorchain-query": "^0.1.0-beta",
+    "@xchainjs/xchain-thorchain-query": "^0.1.0",
+    "@xchainjs/xchain-thornode": "^0.1.0",
     "@xchainjs/xchain-util": "^0.9.0",
     "axios": "^0.27.2",
     "axios-retry": "^3.3.1",

package/lib/index.esm.js

@@ -1,14 +1,13 @@
-import { Client as Client$9, defaultAvaxParams } from '@xchainjs/xchain-avax';
-import { Client as Client$7 } from '@xchainjs/xchain-binance';
+import { Client as Client$8, defaultAvaxParams } from '@xchainjs/xchain-avax';
+import { Client as Client$6 } from '@xchainjs/xchain-binance';
 import { Client as Client$1 } from '@xchainjs/xchain-bitcoin';
 import { Client } from '@xchainjs/xchain-bitcoincash';
 import { Network, FeeOption } from '@xchainjs/xchain-client';
-import { Client as Client$8 } from '@xchainjs/xchain-cosmos';
+import { Client as Client$7 } from '@xchainjs/xchain-cosmos';
 import { Client as Client$2 } from '@xchainjs/xchain-doge';
-import { MAX_APPROVAL, ETH_DECIMAL, Client as Client$4 } from '@xchainjs/xchain-ethereum';
-import { Client as Client$6 } from '@xchainjs/xchain-litecoin';
-import { Client as Client$3 } from '@xchainjs/xchain-terra';
-import { Client as Client$5 } from '@xchainjs/xchain-thorchain';
+import { MAX_APPROVAL, ETH_DECIMAL, Client as Client$3 } from '@xchainjs/xchain-ethereum';
+import { Client as Client$5 } from '@xchainjs/xchain-litecoin';
+import { Client as Client$4 } from '@xchainjs/xchain-thorchain';
 import { eqAsset, AssetETH, getContractAddressFromAsset, baseAmount, Chain, assetToString, AssetBTC } from '@xchainjs/xchain-util';
 import { ethers } from 'ethers';
 import { MAX_APPROVAL as MAX_APPROVAL$1 } from '@xchainjs/xchain-evm';
@@ -423,10 +422,13 @@ class EthHelper {
      */
     sendDeposit(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.asset.chain];
+            const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[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 = this.client.getAddress(params.walletIndex);
             const gasPrice = yield this.ethClient.estimateGasPrices();
             if (eqAsset(params.asset, AssetETH)) {
@@ -515,10 +517,13 @@ class EvmHelper {
      */
     sendDeposit(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.asset.chain];
+            const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[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 = this.client.getAddress(params.walletIndex);
             const gasPrice = yield this.evmClient.estimateGasPrices();
             if (eqAsset(params.asset, this.evmClient.config.gasAsset)) {
@@ -588,7 +593,21 @@ class EvmHelper {
 const chainIds = {
     [Network.Mainnet]: 'thorchain-mainnet-v1',
     [Network.Stagenet]: 'chain-id-stagenet',
-    [Network.Testnet]: 'thorchain-testnet-v2',
+    [Network.Testnet]: 'deprecated',
+};
+const clientUrl = {
+    [Network.Stagenet]: {
+        node: 'https://stagenet-thornode.ninerealms.com',
+        rpc: 'https://stagenet-rpc.ninerealms.com',
+    },
+    [Network.Mainnet]: {
+        node: 'https://thornode.ninerealms.com',
+        rpc: 'https://rpc.ninerealms.com',
+    },
+    [Network.Testnet]: {
+        node: 'deprecated',
+        rpc: 'deprecated',
+    },
 };
 /**
  * Wallet Class for managing all xchain-* wallets with a mnemonic seed.
@@ -608,13 +627,12 @@ class Wallet {
             BCH: new Client(settings),
             BTC: new Client$1(settings),
             DOGE: new Client$2(settings),
-            TERRA: new Client$3(settings),
-            ETH: new Client$4(settings),
-            THOR: new Client$5(Object.assign(Object.assign({}, settings), { chainIds })),
-            LTC: new Client$6(settings),
-            BNB: new Client$7(settings),
-            GAIA: new Client$8(settings),
-            AVAX: new Client$9(Object.assign(Object.assign({}, defaultAvaxParams), { network: settings.network, phrase })),
+            ETH: new Client$3(settings),
+            THOR: new Client$4(Object.assign(Object.assign({}, settings), { chainIds, clientUrl })),
+            LTC: new Client$5(settings),
+            BNB: new Client$6(settings),
+            GAIA: new Client$7(settings),
+            AVAX: new Client$8(Object.assign(Object.assign({}, defaultAvaxParams), { network: settings.network, phrase })),
         };
         this.ethHelper = new EthHelper(this.clients.ETH, this.thorchainQuery.thorchainCache);
     }
@@ -704,7 +722,9 @@ class Wallet {
         return __awaiter(this, void 0, void 0, function* () {
             const client = this.clients[swap.input.asset.chain];
             const waitTimeSeconds = swap.waitTimeSeconds;
-            const inboundAsgard = (yield this.thorchainQuery.thorchainCache.getInboundAddressesItems())[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 (swap.input.asset.chain === Chain.Ethereum) {
                 const params = {
                     walletIndex: 0,
@@ -733,7 +753,7 @@ class Wallet {
                     walletIndex: 0,
                     asset: swap.input.asset,
                     amount: swap.input.baseAmount,
-                    recipient: (inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address) || '',
+                    recipient: inbound.address,
                     memo: this.constructSwapMemo(swap),
                 };
                 const hash = yield client.transfer(params);
@@ -741,6 +761,156 @@ class Wallet {
             }
         });
     }
+    /** 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 = thorchainClient.getAddress();
+            const addressAsset = assetClient.getAddress();
+            const waitTimeSeconds = params.waitTimeSeconds;
+            let constructedMemo = '';
+            const txSubmitted = [];
+            // symmetrical add
+            if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.gt(0)) {
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}:${addressRune}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard));
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}:${addressAsset}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+            else if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.eq(0)) {
+                // asymmetrical asset only
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard));
+                return txSubmitted;
+            }
+            else {
+                // asymmetrical rune only
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+        });
+    }
+    /**
+     *
+     * @param params - parameters required for liquidity position
+     * @returns object with tx response, url and wait time in seconds
+     */
+    removeLiquidity(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];
+            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address)) {
+                throw new Error('Vault address is not defined');
+            }
+            const waitTimeSeconds = params.waitTimeSeconds;
+            const thorchainClient = this.clients[params.rune.asset.chain];
+            const basisPoints = (params.percentage * 100).toFixed(); // convert to basis points
+            let constructedMemo = '';
+            const txSubmitted = [];
+            if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.gt(0)) {
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard.address));
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+            else if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.eq(0)) {
+                // asymmetrical asset only
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard.address));
+                return txSubmitted;
+            }
+            else {
+                // asymmetrical rune only
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+        });
+    }
+    /**
+     *
+     * @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
+     */
+    addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.asset.asset.chain === Chain.Ethereum) {
+                const addParams = {
+                    wallIndex: 0,
+                    asset: params.asset.asset,
+                    amount: params.asset.baseAmount,
+                    feeOption: FeeOption.Fast,
+                    memo: constructedMemo,
+                };
+                console.log(addParams.amount.amount().toNumber());
+                const hash = yield this.ethHelper.sendDeposit(addParams);
+                return { hash, url: assetClient.getExplorerTxUrl(hash), waitTimeSeconds };
+            }
+            else if (params.asset.asset.chain === Chain.Avalanche) {
+                const addParams = {
+                    wallIndex: 0,
+                    asset: params.asset.asset,
+                    amount: params.asset.baseAmount,
+                    feeOption: FeeOption.Fast,
+                    memo: constructedMemo,
+                };
+                const evmHelper = new EvmHelper(this.clients.AVAX, this.thorchainQuery.thorchainCache);
+                const hash = yield evmHelper.sendDeposit(addParams);
+                return { hash, url: assetClient.getExplorerTxUrl(hash), waitTimeSeconds };
+            }
+            else {
+                const addParams = {
+                    wallIndex: 0,
+                    asset: params.asset.asset,
+                    amount: params.asset.baseAmount,
+                    recipient: inboundAsgard,
+                    memo: constructedMemo,
+                };
+                try {
+                    console.log(addParams);
+                    const hash = yield assetClient.transfer(addParams);
+                    return { hash, url: assetClient.getExplorerTxUrl(hash), waitTimeSeconds };
+                }
+                catch (err) {
+                    const hash = JSON.stringify(err);
+                    return { hash, url: assetClient.getExplorerAddressUrl(assetClient.getAddress()), waitTimeSeconds };
+                }
+            }
+        });
+    }
+    /**
+     *
+     * @param params - deposit parameters
+     * @param memo - memo needed to withdraw lp
+     * @returns - tx object
+     */
+    addOrRemoveRuneLP(params, memo, thorchainClient, waitTimeSeconds) {
+        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,
+            };
+            console.log(addParams);
+            const hash = yield thorClient.deposit(addParams);
+            return { hash, url: thorchainClient.getExplorerTxUrl(hash), waitTimeSeconds };
+        });
+    }
 }
 
 const BN_1 = new BigNumber(1);
@@ -813,6 +983,41 @@ class ThorchainAMM {
             });
         });
     }
+    /**
+     *
+     * @param wallet - wallet class
+     * @param params - liquidity parameters
+     * @returns
+     */
+    addLiquidityPosition(wallet, 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);
+            return wallet.addLiquidity({
+                asset: params.asset,
+                rune: params.rune,
+                waitTimeSeconds: checkLPAdd.estimatedWaitSeconds,
+            });
+        });
+    }
+    /**
+     *
+     * @param params - liquidity parameters
+     * @param wallet - wallet needed to perform tx
+     * @return
+     */
+    removeLiquidityPosition(wallet, 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.
+            const estimateWithrawLp = yield this.thorchainQuery.estimateWithdrawLP(params);
+            return wallet.removeLiquidity({
+                asset: estimateWithrawLp.transactionFee.assetFee,
+                rune: estimateWithrawLp.transactionFee.runeFee,
+                percentage: params.percentage,
+                waitTimeSeconds: estimateWithrawLp.estimatedWaitSeconds,
+            });
+        });
+    }
 }
 
 export { ThorchainAMM, Wallet };

package/lib/index.js

@@ -11,7 +11,6 @@ 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 xchainTerra = require('@xchainjs/xchain-terra');
 var xchainThorchain = require('@xchainjs/xchain-thorchain');
 var xchainUtil = require('@xchainjs/xchain-util');
 var ethers = require('ethers');
@@ -427,10 +426,13 @@ class EthHelper {
      */
     sendDeposit(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.asset.chain];
+            const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[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 = this.client.getAddress(params.walletIndex);
             const gasPrice = yield this.ethClient.estimateGasPrices();
             if (xchainUtil.eqAsset(params.asset, xchainUtil.AssetETH)) {
@@ -519,10 +521,13 @@ class EvmHelper {
      */
     sendDeposit(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const inboundAsgard = (yield this.thorchainCache.getInboundAddressesItems())[params.asset.chain];
+            const inboundAsgard = (yield this.thorchainCache.getInboundAddresses())[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 = this.client.getAddress(params.walletIndex);
             const gasPrice = yield this.evmClient.estimateGasPrices();
             if (xchainUtil.eqAsset(params.asset, this.evmClient.config.gasAsset)) {
@@ -592,7 +597,21 @@ class EvmHelper {
 const chainIds = {
     [xchainClient.Network.Mainnet]: 'thorchain-mainnet-v1',
     [xchainClient.Network.Stagenet]: 'chain-id-stagenet',
-    [xchainClient.Network.Testnet]: 'thorchain-testnet-v2',
+    [xchainClient.Network.Testnet]: 'deprecated',
+};
+const clientUrl = {
+    [xchainClient.Network.Stagenet]: {
+        node: 'https://stagenet-thornode.ninerealms.com',
+        rpc: 'https://stagenet-rpc.ninerealms.com',
+    },
+    [xchainClient.Network.Mainnet]: {
+        node: 'https://thornode.ninerealms.com',
+        rpc: 'https://rpc.ninerealms.com',
+    },
+    [xchainClient.Network.Testnet]: {
+        node: 'deprecated',
+        rpc: 'deprecated',
+    },
 };
 /**
  * Wallet Class for managing all xchain-* wallets with a mnemonic seed.
@@ -612,9 +631,8 @@ class Wallet {
             BCH: new xchainBitcoincash.Client(settings),
             BTC: new xchainBitcoin.Client(settings),
             DOGE: new xchainDoge.Client(settings),
-            TERRA: new xchainTerra.Client(settings),
             ETH: new xchainEthereum.Client(settings),
-            THOR: new xchainThorchain.Client(Object.assign(Object.assign({}, settings), { chainIds })),
+            THOR: new xchainThorchain.Client(Object.assign(Object.assign({}, settings), { chainIds, clientUrl })),
             LTC: new xchainLitecoin.Client(settings),
             BNB: new xchainBinance.Client(settings),
             GAIA: new xchainCosmos.Client(settings),
@@ -708,7 +726,9 @@ class Wallet {
         return __awaiter(this, void 0, void 0, function* () {
             const client = this.clients[swap.input.asset.chain];
             const waitTimeSeconds = swap.waitTimeSeconds;
-            const inboundAsgard = (yield this.thorchainQuery.thorchainCache.getInboundAddressesItems())[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 (swap.input.asset.chain === xchainUtil.Chain.Ethereum) {
                 const params = {
                     walletIndex: 0,
@@ -737,7 +757,7 @@ class Wallet {
                     walletIndex: 0,
                     asset: swap.input.asset,
                     amount: swap.input.baseAmount,
-                    recipient: (inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address) || '',
+                    recipient: inbound.address,
                     memo: this.constructSwapMemo(swap),
                 };
                 const hash = yield client.transfer(params);
@@ -745,6 +765,156 @@ class Wallet {
             }
         });
     }
+    /** 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 = thorchainClient.getAddress();
+            const addressAsset = assetClient.getAddress();
+            const waitTimeSeconds = params.waitTimeSeconds;
+            let constructedMemo = '';
+            const txSubmitted = [];
+            // symmetrical add
+            if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.gt(0)) {
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}:${addressRune}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard));
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}:${addressAsset}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+            else if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.eq(0)) {
+                // asymmetrical asset only
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard));
+                return txSubmitted;
+            }
+            else {
+                // asymmetrical rune only
+                constructedMemo = `+:${params.asset.asset.chain}.${params.asset.asset.symbol}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+        });
+    }
+    /**
+     *
+     * @param params - parameters required for liquidity position
+     * @returns object with tx response, url and wait time in seconds
+     */
+    removeLiquidity(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];
+            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address)) {
+                throw new Error('Vault address is not defined');
+            }
+            const waitTimeSeconds = params.waitTimeSeconds;
+            const thorchainClient = this.clients[params.rune.asset.chain];
+            const basisPoints = (params.percentage * 100).toFixed(); // convert to basis points
+            let constructedMemo = '';
+            const txSubmitted = [];
+            if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.gt(0)) {
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard.address));
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+            else if (params.asset.assetAmount.gt(0) && params.rune.assetAmount.eq(0)) {
+                // asymmetrical asset only
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard.address));
+                return txSubmitted;
+            }
+            else {
+                // asymmetrical rune only
+                constructedMemo = `-:${params.asset.asset.chain}.${params.asset.asset.symbol}:${basisPoints}`;
+                txSubmitted.push(yield this.addOrRemoveRuneLP(params, constructedMemo, thorchainClient, waitTimeSeconds));
+                return txSubmitted;
+            }
+        });
+    }
+    /**
+     *
+     * @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
+     */
+    addOrRemoveAssetLP(params, constructedMemo, assetClient, waitTimeSeconds, inboundAsgard) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.asset.asset.chain === xchainUtil.Chain.Ethereum) {
+                const addParams = {
+                    wallIndex: 0,
+                    asset: params.asset.asset,
+                    amount: params.asset.baseAmount,
+                    feeOption: xchainClient.FeeOption.Fast,
+                    memo: constructedMemo,
+                };
+                console.log(addParams.amount.amount().toNumber());
+                const hash = yield this.ethHelper.sendDeposit(addParams);
+                return { hash, url: assetClient.getExplorerTxUrl(hash), waitTimeSeconds };
+            }
+            else if (params.asset.asset.chain === xchainUtil.Chain.Avalanche) {
+                const addParams = {
+                    wallIndex: 0,
+                    asset: params.asset.asset,
+                    amount: params.asset.baseAmount,
+                    feeOption: xchainClient.FeeOption.Fast,
+                    memo: constructedMemo,
+                };
+                const evmHelper = new EvmHelper(this.clients.AVAX, this.thorchainQuery.thorchainCache);
+                const hash = yield evmHelper.sendDeposit(addParams);
+                return { hash, url: assetClient.getExplorerTxUrl(hash), waitTimeSeconds };
+            }
+            else {
+                const addParams = {
+                    wallIndex: 0,
+                    asset: params.asset.asset,
+                    amount: params.asset.baseAmount,
+                    recipient: inboundAsgard,
+                    memo: constructedMemo,
+                };
+                try {
+                    console.log(addParams);
+                    const hash = yield assetClient.transfer(addParams);
+                    return { hash, url: assetClient.getExplorerTxUrl(hash), waitTimeSeconds };
+                }
+                catch (err) {
+                    const hash = JSON.stringify(err);
+                    return { hash, url: assetClient.getExplorerAddressUrl(assetClient.getAddress()), waitTimeSeconds };
+                }
+            }
+        });
+    }
+    /**
+     *
+     * @param params - deposit parameters
+     * @param memo - memo needed to withdraw lp
+     * @returns - tx object
+     */
+    addOrRemoveRuneLP(params, memo, thorchainClient, waitTimeSeconds) {
+        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,
+            };
+            console.log(addParams);
+            const hash = yield thorClient.deposit(addParams);
+            return { hash, url: thorchainClient.getExplorerTxUrl(hash), waitTimeSeconds };
+        });
+    }
 }
 
 const BN_1 = new bignumber_js.BigNumber(1);
@@ -817,6 +987,41 @@ class ThorchainAMM {
             });
         });
     }
+    /**
+     *
+     * @param wallet - wallet class
+     * @param params - liquidity parameters
+     * @returns
+     */
+    addLiquidityPosition(wallet, 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);
+            return wallet.addLiquidity({
+                asset: params.asset,
+                rune: params.rune,
+                waitTimeSeconds: checkLPAdd.estimatedWaitSeconds,
+            });
+        });
+    }
+    /**
+     *
+     * @param params - liquidity parameters
+     * @param wallet - wallet needed to perform tx
+     * @return
+     */
+    removeLiquidityPosition(wallet, 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.
+            const estimateWithrawLp = yield this.thorchainQuery.estimateWithdrawLP(params);
+            return wallet.removeLiquidity({
+                asset: estimateWithrawLp.transactionFee.assetFee,
+                rune: estimateWithrawLp.transactionFee.runeFee,
+                percentage: params.percentage,
+                waitTimeSeconds: estimateWithrawLp.estimatedWaitSeconds,
+            });
+        });
+    }
 }
 
 exports.ThorchainAMM = ThorchainAMM;

package/lib/thorchain-amm.d.ts

@@ -1,5 +1,5 @@
-import { EstimateSwapParams, ThorchainQuery, TxDetails } from '@xchainjs/xchain-thorchain-query';
-import { SwapSubmitted } from './types';
+import { AddliquidityPosition, EstimateSwapParams, RemoveLiquidityPosition, ThorchainQuery, TxDetails } from '@xchainjs/xchain-thorchain-query';
+import { TxSubmitted } from './types';
 import { Wallet } from './wallet';
 /**
  * THORChain Class for interacting with THORChain.
@@ -31,5 +31,19 @@ export declare class ThorchainAMM {
      * @param params - swap params
      * @returns {SwapSubmitted} - Tx Hash, URL of BlockExplorer and expected wait time.
      */
-    doSwap(wallet: Wallet, params: EstimateSwapParams): Promise<SwapSubmitted>;
+    doSwap(wallet: Wallet, params: EstimateSwapParams): Promise<TxSubmitted>;
+    /**
+     *
+     * @param wallet - wallet class
+     * @param params - liquidity parameters
+     * @returns
+     */
+    addLiquidityPosition(wallet: Wallet, params: AddliquidityPosition): Promise<TxSubmitted[]>;
+    /**
+     *
+     * @param params - liquidity parameters
+     * @param wallet - wallet needed to perform tx
+     * @return
+     */
+    removeLiquidityPosition(wallet: Wallet, params: RemoveLiquidityPosition): Promise<TxSubmitted[]>;
 }

package/lib/types.d.ts

@@ -1,5 +1,5 @@
 import { FeeOption } from '@xchainjs/xchain-client';
-import { CryptoAmount } from '@xchainjs/xchain-thorchain-query';
+import { CryptoAmount, LiquidityPool } from '@xchainjs/xchain-thorchain-query';
 import { Address, Asset, BaseAmount } from '@xchainjs/xchain-util';
 import { BigNumber } from 'bignumber.js';
 export declare type MidgardConfig = {
@@ -17,11 +17,29 @@ export declare type ExecuteSwap = {
     interfaceID: number;
     waitTimeSeconds: number;
 };
-export declare type SwapSubmitted = {
+export declare type TxSubmitted = {
     hash: string;
     url: string;
     waitTimeSeconds: number;
 };
+export declare type AddLiquidity = {
+    asset: CryptoAmount;
+    rune: CryptoAmount;
+    waitTimeSeconds: number;
+};
+export declare type LiquidityPosition = {
+    assetPool: LiquidityPool;
+    assetAmount: CryptoAmount;
+    runeAmount: CryptoAmount;
+    impermanentLossProtection: number;
+};
+export declare type RemoveLiquidity = {
+    asset: CryptoAmount;
+    rune: CryptoAmount;
+    percentage: number;
+    waitTimeSeconds: number;
+    asymmetricalWithdraw?: Asset;
+};
 export declare type DepositParams = {
     walletIndex?: number;
     asset: Asset;
@@ -35,10 +53,6 @@ export declare type SwapOutput = {
     slip: BigNumber;
 };
 export declare type UnitData = {
-    liquidityUnits: BaseAmount;
-    totalUnits: BaseAmount;
-};
-export declare type LiquidityData = {
-    rune: BaseAmount;
-    asset: BaseAmount;
+    liquidityUnits: BigNumber;
+    totalUnits: BigNumber;
 };

package/lib/wallet.d.ts

@@ -1,7 +1,7 @@
 import { Balance, XChainClient } from '@xchainjs/xchain-client';
 import { ThorchainQuery } from '@xchainjs/xchain-thorchain-query';
 import { Chain } from '@xchainjs/xchain-util';
-import { ExecuteSwap, SwapSubmitted } from './types';
+import { AddLiquidity, ExecuteSwap, RemoveLiquidity, TxSubmitted } from './types';
 declare type AllBalances = {
     chain: Chain;
     address: string;
@@ -35,10 +35,39 @@ export declare class Wallet {
      * @returns transaction details and explorer url
      * @see ThorchainAMM.doSwap()
      */
-    executeSwap(swap: ExecuteSwap): Promise<SwapSubmitted>;
+    executeSwap(swap: ExecuteSwap): Promise<TxSubmitted>;
     private constructSwapMemo;
     private validateSwap;
     private swapRuneTo;
     private swapNonRune;
+    /** 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: AddLiquidity): Promise<TxSubmitted[]>;
+    /**
+     *
+     * @param params - parameters required for liquidity position
+     * @returns object with tx response, url and wait time in seconds
+     */
+    removeLiquidity(params: RemoveLiquidity): Promise<TxSubmitted[]>;
+    /**
+     *
+     * @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
+     */
+    private addOrRemoveAssetLP;
+    /**
+     *
+     * @param params - deposit parameters
+     * @param memo - memo needed to withdraw lp
+     * @returns - tx object
+     */
+    private addOrRemoveRuneLP;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-thorchain-amm",
-  "version": "0.1.0-beta5",
+  "version": "0.3.0",
   "description": "module that exposes estimating & swappping cryptocurrency assets on thorchain",
   "keywords": [
     "THORChain",
@@ -43,19 +43,19 @@
     "@xchainjs/xchain-binance": "^5.6.0",
     "@xchainjs/xchain-bitcoin": "^0.20.0",
     "@xchainjs/xchain-bitcoincash": "^0.15.0",
-    "@xchainjs/xchain-client": "^0.13.1",
+    "@xchainjs/xchain-client": "^0.13.2",
     "@xchainjs/xchain-cosmos": "^0.20.0",
     "@xchainjs/xchain-crypto": "^0.2.6",
     "@xchainjs/xchain-doge": "^0.5.0",
     "@xchainjs/xchain-ethereum": "^0.27.0",
     "@xchainjs/xchain-evm": "^0.1.0-alpha2",
-    "@xchainjs/xchain-avax": "^0.1.0-alpha2",
+    "@xchainjs/xchain-avax": "^0.1.0-alpha3",
     "@xchainjs/xchain-litecoin": "^0.10.0",
-    "@xchainjs/xchain-midgard": "0.1.0-alpha2",
-    "@xchainjs/xchain-terra": "^0.3.0",
-    "@xchainjs/xchain-thorchain": "^0.26.0",
-    "@xchainjs/xchain-thorchain-query": "^0.1.0-beta",
-    "@xchainjs/xchain-util": "^0.10.0",
+    "@xchainjs/xchain-midgard": "0.1.0",
+    "@xchainjs/xchain-thorchain": "^0.27.0",
+    "@xchainjs/xchain-thorchain-query": "^0.1.0",
+    "@xchainjs/xchain-thornode": "^0.1.0",
+    "@xchainjs/xchain-util": "^0.11.0",
     "axios": "^0.25.0",
     "axios-retry": "^3.2.5",
     "bchaddrjs": "^0.5.2",
@@ -77,19 +77,19 @@
     "@xchainjs/xchain-binance": "^5.6.0",
     "@xchainjs/xchain-bitcoin": "^0.20.0",
     "@xchainjs/xchain-bitcoincash": "^0.15.0",
-    "@xchainjs/xchain-client": "^0.13.1",
+    "@xchainjs/xchain-client": "^0.13.2",
     "@xchainjs/xchain-cosmos": "^0.20.0",
     "@xchainjs/xchain-crypto": "^0.2.6",
     "@xchainjs/xchain-doge": "^0.5.0",
     "@xchainjs/xchain-ethereum": "^0.27.0",
     "@xchainjs/xchain-evm": "^0.1.0-alpha2",
-    "@xchainjs/xchain-avax": "^0.1.0-alpha2",
+    "@xchainjs/xchain-avax": "^0.1.0-alpha3",
     "@xchainjs/xchain-litecoin": "^0.10.0",
-    "@xchainjs/xchain-midgard": "0.1.0-alpha2",
-    "@xchainjs/xchain-terra": "^0.3.0",
+    "@xchainjs/xchain-midgard": "0.1.0",
+    "@xchainjs/xchain-thornode": "^0.1.0",
     "@xchainjs/xchain-thorchain": "^0.26.0",
-    "@xchainjs/xchain-thorchain-query": "^0.1.0-alpha1",
-    "@xchainjs/xchain-util": "^0.10.0",
+    "@xchainjs/xchain-thorchain-query": "^0.1.0",
+    "@xchainjs/xchain-util": "^0.11.0",
     "axios": "^0.25.0",
     "axios-retry": "^3.2.5",
     "bchaddrjs": "^0.5.2",