@xchainjs/xchain-thorchain-amm 0.1.0-alpha

package/lib/index.js

@@ -0,0 +1,1746 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var xchainBinance = require('@xchainjs/xchain-binance');
+var xchainBitcoin = require('@xchainjs/xchain-bitcoin');
+var xchainBitcoincash = require('@xchainjs/xchain-bitcoincash');
+var xchainClient = require('@xchainjs/xchain-client');
+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');
+var xchainMidgard = require('@xchainjs/xchain-midgard');
+var axios = require('axios');
+var axiosRetry = require('axios-retry');
+var BigNumber = require('bignumber.js');
+var lib = require('@xchainjs/xchain-cosmos/lib');
+var lib$1 = require('@xchainjs/xchain-terra/lib');
+var lib$2 = require('@xchainjs/xchain-thorchain/lib');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var axiosRetry__default = /*#__PURE__*/_interopDefaultLegacy(axiosRetry);
+var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+var routerABI = [
+	{
+		inputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "Deposit",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "oldVault",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newVault",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "TransferAllowance",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "vault",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "TransferOut",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "oldVault",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "newVault",
+				type: "address"
+			},
+			{
+				components: [
+					{
+						internalType: "address",
+						name: "asset",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					}
+				],
+				indexed: false,
+				internalType: "struct Router.Coin[]",
+				name: "coins",
+				type: "tuple[]"
+			},
+			{
+				indexed: false,
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "VaultTransfer",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "RUNE",
+		outputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address[]",
+				name: "recipients",
+				type: "address[]"
+			},
+			{
+				components: [
+					{
+						internalType: "address",
+						name: "asset",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					}
+				],
+				internalType: "struct Router.Coin[]",
+				name: "coins",
+				type: "tuple[]"
+			},
+			{
+				internalType: "string[]",
+				name: "memos",
+				type: "string[]"
+			}
+		],
+		name: "batchTransferOut",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address payable",
+				name: "vault",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "deposit",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "router",
+				type: "address"
+			},
+			{
+				internalType: "address payable",
+				name: "asgard",
+				type: "address"
+			},
+			{
+				components: [
+					{
+						internalType: "address",
+						name: "asset",
+						type: "address"
+					},
+					{
+						internalType: "uint256",
+						name: "amount",
+						type: "uint256"
+					}
+				],
+				internalType: "struct Router.Coin[]",
+				name: "coins",
+				type: "tuple[]"
+			},
+			{
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "returnVaultAssets",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "router",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "newVault",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "transferAllowance",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address payable",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "asset",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "amount",
+				type: "uint256"
+			},
+			{
+				internalType: "string",
+				name: "memo",
+				type: "string"
+			}
+		],
+		name: "transferOut",
+		outputs: [
+		],
+		stateMutability: "payable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "",
+				type: "address"
+			}
+		],
+		name: "vaultAllowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+/**
+ * Utility Class to combine an amount (asset/base) with the Asset
+ *
+ */
+class CryptoAmount {
+    constructor(amount, asset) {
+        this.asset = asset;
+        this.baseAmount = amount;
+    }
+    plus(v) {
+        this.check(v);
+        const baseAmountResult = this.baseAmount.plus(v.baseAmount);
+        return new CryptoAmount(baseAmountResult, this.asset);
+    }
+    minus(v) {
+        this.check(v);
+        const baseAmountResult = this.baseAmount.minus(v.baseAmount);
+        return new CryptoAmount(baseAmountResult, this.asset);
+    }
+    times(v) {
+        this.check(v);
+        if (v instanceof CryptoAmount) {
+            const baseAmountResult = this.baseAmount.times(v.baseAmount);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+        else {
+            const baseAmountResult = this.baseAmount.times(v);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+    }
+    div(v) {
+        this.check(v);
+        if (v instanceof CryptoAmount) {
+            const baseAmountResult = this.baseAmount.div(v.baseAmount);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+        else {
+            const baseAmountResult = this.baseAmount.div(v);
+            return new CryptoAmount(baseAmountResult, this.asset);
+        }
+    }
+    lt(v) {
+        this.check(v);
+        return this.baseAmount.lt(v.baseAmount);
+    }
+    lte(v) {
+        this.check(v);
+        return this.baseAmount.lte(v.baseAmount);
+    }
+    gt(v) {
+        this.check(v);
+        return this.baseAmount.gt(v.baseAmount);
+    }
+    gte(v) {
+        this.check(v);
+        return this.baseAmount.gte(v.baseAmount);
+    }
+    eq(v) {
+        this.check(v);
+        return this.baseAmount.eq(v.baseAmount);
+    }
+    formatedAssetString() {
+        return xchainUtil.formatAssetAmountCurrency({
+            amount: this.assetAmount,
+            asset: this.asset,
+            trimZeros: true,
+        });
+    }
+    assetAmountFixedString() {
+        return this.assetAmount.amount().toFixed();
+    }
+    get assetAmount() {
+        return xchainUtil.baseToAsset(this.baseAmount);
+    }
+    /**
+     * This guard protects against trying to perform math with different assets
+     *
+     * Example.
+     * const x = new CryptoAmount(baseAmount(1),AssetBTC)
+     * const y = new CryptoAmount(baseAmount(1),AssetETH)
+     *
+     * x.plus(y) <- will throw error "cannot perform math on 2 diff assets BTC.BTC ETH.ETH
+     *
+     * @param v - CryptoNumeric
+     */
+    check(v) {
+        if (v instanceof CryptoAmount) {
+            if (!xchainUtil.eqAsset(this.asset, v.asset)) {
+                throw Error(`cannot perform math on 2 diff assets ${xchainUtil.assetToString(this.asset)} ${xchainUtil.assetToString(v.asset)}`);
+            }
+        }
+    }
+}
+
+const defaultMidgardConfig = {
+    mainnet: {
+        apiRetries: 3,
+        midgardBaseUrls: [
+            'https://midgard.thorchain.info/',
+            'https://midgard.thorswap.net/',
+            'https://midgard.ninerealms.com/',
+        ],
+    },
+    stagenet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://stagenet-midgard.ninerealms.com/'],
+    },
+    testnet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['https://testnet.midgard.thorchain.info/'],
+    },
+};
+class Midgard {
+    constructor(network = xchainClient.Network.Mainnet, config) {
+        this.network = network;
+        this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig[this.network];
+        axiosRetry__default['default'](axios__default['default'], { retries: this.config.apiRetries, retryDelay: axiosRetry__default['default'].exponentialDelay });
+        this.midgardApis = this.config.midgardBaseUrls.map((url) => new xchainMidgard.MidgardApi(new xchainMidgard.Configuration({ basePath: url })));
+    }
+    getMimirDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = '/v2/thorchain/mimir';
+            for (const baseUrl of this.config.midgardBaseUrls) {
+                try {
+                    const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
+                    return data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error('Midgard not responding');
+        });
+    }
+    /**
+     *
+     * @returns an array of Pools
+     */
+    getPools() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    return (yield api.getPools()).data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    getAllInboundAddresses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    return (yield api.getProxiedInboundAddresses()).data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Gets the Inbound Details for a given array of Chains.
+     * Will check if chain is THOR.
+     * @param chains - external chains
+     * @returns inbound details of given chains
+     */
+    getInboundDetails(chains) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [mimirDetails, allInboundDetails] = yield Promise.all([this.getMimirDetails(), this.getAllInboundAddresses()]);
+            const inboundDetails = [];
+            for (const chain of chains) {
+                if (chain != xchainUtil.Chain.THORChain) {
+                    const inboundDetail = allInboundDetails === null || allInboundDetails === void 0 ? void 0 : allInboundDetails.find((item) => item.chain === chain);
+                    if (inboundDetail) {
+                        if (!inboundDetail.gas_rate)
+                            throw new Error(`Could not get gas_rate for ${chain}`);
+                        const details = {
+                            vault: inboundDetail.address,
+                            gas_rate: new BigNumber__default['default'](inboundDetail.gas_rate),
+                            haltedChain: (inboundDetail === null || inboundDetail === void 0 ? void 0 : inboundDetail.halted) || !!mimirDetails[`HALT${chain}CHAIN`] || !!mimirDetails['HALTCHAINGLOBAL'],
+                            haltedTrading: !!mimirDetails['HALTTRADING'] || !!mimirDetails[`HALT${chain}TRADING`],
+                            haltedLP: !!mimirDetails['PAUSELP'] || !!mimirDetails[`PAUSELP${chain}`],
+                        };
+                        if (inboundDetail === null || inboundDetail === void 0 ? void 0 : inboundDetail.router)
+                            details.router = inboundDetail.router;
+                        inboundDetails.push(details);
+                    }
+                    else {
+                        throw new Error(`Could not get chain details for ${chain}`);
+                    }
+                }
+                else {
+                    const details = {
+                        vault: '',
+                        gas_rate: new BigNumber__default['default'](0),
+                        haltedChain: false,
+                        haltedTrading: !!mimirDetails['HALTTRADING'],
+                        haltedLP: false, //
+                    };
+                    inboundDetails.push(details);
+                }
+            }
+            return inboundDetails;
+        });
+    }
+    getConstantsDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = 'v2/thorchain/constants';
+            for (const baseUrl of this.config.midgardBaseUrls) {
+                try {
+                    const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
+                    return data;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error('Midgard not responding');
+        });
+    }
+    /**
+     *
+     * @returns the outbound Tx Value in RUNE (Basemount)
+     */
+    getScheduledOutboundValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = 'v2/thorchain/queue';
+            for (const baseUrl of this.config.midgardBaseUrls) {
+                try {
+                    const { data } = yield axios__default['default'].get(`${baseUrl}${path}`);
+                    const value = new CryptoAmount(xchainUtil.baseAmount(data['scheduled_outbound_value']), xchainUtil.AssetRuneNative);
+                    return value;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw new Error('Midgard not responding');
+        });
+    }
+    /**
+     * Function that wraps Mimir and Constants to return the value from a given constant name. Searchs Mimir first.
+     *
+     * @param networkValueName the network value to be used to search the contsants
+     * @returns the mimir or constants value
+     */
+    getNetworkValueByNames(networkValueNames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [mimirDetails, constantDetails] = yield Promise.all([this.getMimirDetails(), this.getConstantsDetails()]);
+            const retVal = {};
+            for (const networkValueName of networkValueNames) {
+                const mimirValue = mimirDetails[networkValueName.toUpperCase()];
+                const constantsValue = constantDetails['int_64_values'][networkValueName];
+                if (mimirValue != undefined) {
+                    retVal[networkValueName] = mimirValue;
+                }
+                else if (constantDetails != undefined) {
+                    retVal[networkValueName] = constantsValue;
+                }
+                else {
+                    throw Error(`Could not find network value name`);
+                }
+            }
+            console.log(retVal);
+            return retVal;
+        });
+    }
+    /**
+     * Gets the latest block using the Health endpoint within Midgard
+     *
+     * @returns
+     */
+    getLatestBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const data = (yield api.getHealth()).data;
+                    return +data.scannerHeight;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+}
+
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns
+ */
+const getSwapFee = (inputAmount, pool, toRune) => {
+    // formula: (x * x * Y) / (x + X) ^ 2
+    const x = inputAmount.amount();
+    const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
+    const Y = toRune ? pool.runeBalance.amount() : pool.assetBalance.amount(); // output is rune if toRune
+    const numerator = x.times(x).multipliedBy(Y);
+    const denominator = x.plus(X).pow(2);
+    const result = numerator.div(denominator);
+    return xchainUtil.baseAmount(result);
+};
+/**
+ * Works out the swap slip for a given swap.
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns The amount of slip. Needs to * 100 to get percentage.
+ */
+const getSwapSlip = (inputAmount, pool, toRune) => {
+    // formula: (x) / (x + X)
+    const x = inputAmount.amount();
+    const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
+    const result = x.div(x.plus(X));
+    return new BigNumber.BigNumber(result);
+};
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns The output amount
+ */
+const getSwapOutput = (inputAmount, pool, toRune) => {
+    // formula: (x * X * Y) / (x + X) ^ 2
+    const x = inputAmount.amount();
+    const X = toRune ? pool.assetBalance.amount() : pool.runeBalance.amount(); // input is asset if toRune
+    const Y = toRune ? pool.runeBalance.amount() : pool.assetBalance.amount(); // output is rune if toRune
+    const numerator = x.times(X).times(Y);
+    const denominator = x.plus(X).pow(2);
+    const result = numerator.div(denominator);
+    return xchainUtil.baseAmount(result);
+};
+const getDoubleSwapOutput = (inputAmount, pool1, pool2) => {
+    // formula: getSwapOutput(pool1) => getSwapOutput(pool2)
+    const r = getSwapOutput(inputAmount, pool1, true);
+    const output = getSwapOutput(r, pool2, false);
+    return output;
+};
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @returns swap output object - output - fee - slip
+ */
+const getSingleSwap = (inputAmount, pool, toRune) => {
+    const output = getSwapOutput(inputAmount, pool, toRune);
+    const fee = getSwapFee(inputAmount, pool, toRune);
+    const slip = getSwapSlip(inputAmount, pool, toRune);
+    const swapOutput = {
+        output: output,
+        swapFee: fee,
+        slip: slip,
+    };
+    return swapOutput;
+};
+const getDoubleSwapSlip = (inputAmount, pool1, pool2) => {
+    // formula: getSwapSlip1(input1) + getSwapSlip2(getSwapOutput1 => input2)
+    const swapOutput1 = getSingleSwap(inputAmount, pool1, true);
+    const swapOutput2 = getSingleSwap(swapOutput1.output, pool2, false);
+    const result = swapOutput2.slip.plus(swapOutput1.slip);
+    return result;
+};
+const getValueOfRuneInAsset = (inputRune, pool) => {
+    // formula: ((r * A) / R) => A per R ($perRune)
+    const r = inputRune.amount();
+    const R = pool.runeBalance.amount();
+    const A = pool.assetBalance.amount();
+    const result = r.times(A).div(R);
+    return xchainUtil.baseAmount(result);
+};
+const getDoubleSwapFee = (inputAmount, pool1, pool2) => {
+    // formula: getSwapFee1 + getSwapFee2
+    const fee1 = getSwapFee(inputAmount, pool1, true);
+    const r = getSwapOutput(inputAmount, pool1, true);
+    const fee2 = getSwapFee(r, pool2, false);
+    const fee1Asset = getValueOfRuneInAsset(fee1, pool2);
+    const result = fee2.amount().plus(fee1Asset.amount());
+    return xchainUtil.baseAmount(result);
+};
+/**
+ *
+ * @param inputAmount - amount to swap
+ * @param pool - Pool Data, RUNE and ASSET Depths
+ * @param toRune - Direction of Swap. True if swapping to RUNE.
+ * @returns swap output object - output - fee - slip
+ */
+const getDoubleSwap = (inputAmount, pool1, pool2) => {
+    const doubleOutput = getDoubleSwapOutput(inputAmount, pool1, pool2);
+    const doubleFee = getDoubleSwapFee(inputAmount, pool1, pool2);
+    const doubleSlip = getDoubleSwapSlip(inputAmount, pool1, pool2);
+    const SwapOutput = {
+        output: doubleOutput,
+        swapFee: doubleFee,
+        slip: doubleSlip,
+    };
+    return SwapOutput;
+};
+const getContractAddressFromAsset = (asset) => {
+    const assetAddress = asset.symbol.slice(asset.ticker.length + 1);
+    return xchainEthereum.strip0x(assetAddress);
+};
+/**
+ * Works out the required inbound or outbound fee based on the chain.
+ * Call getInboundDetails to get the current gasRate
+ *
+ * @param sourceAsset
+ * @param gasRate
+ * @see https://dev.thorchain.org/thorchain-dev/thorchain-and-fees#fee-calcuation-by-chain
+ * @returns
+ */
+const calcNetworkFee = (asset, gasRate) => {
+    if (asset.synth)
+        return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+    switch (asset.chain) {
+        case xchainUtil.Chain.Bitcoin:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetBTC);
+        case xchainUtil.Chain.BitcoinCash:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetBCH);
+        case xchainUtil.Chain.Litecoin:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetLTC);
+        case xchainUtil.Chain.Doge:
+            // NOTE: UTXO chains estimate fees with a 250 byte size
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(250)), xchainUtil.AssetDOGE);
+        case xchainUtil.Chain.Binance:
+            //flat fee
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate), xchainUtil.AssetBNB);
+        case xchainUtil.Chain.Ethereum:
+            if (xchainUtil.eqAsset(asset, xchainUtil.AssetETH)) {
+                return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(35000)), xchainUtil.AssetETH);
+            }
+            else {
+                return new CryptoAmount(xchainUtil.baseAmount(gasRate.multipliedBy(70000)), xchainUtil.AssetETH);
+            }
+        case xchainUtil.Chain.Terra:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate), lib$1.AssetLUNA);
+        case xchainUtil.Chain.Cosmos:
+            return new CryptoAmount(xchainUtil.baseAmount(gasRate), lib.AssetAtom);
+        case xchainUtil.Chain.THORChain:
+            return new CryptoAmount(xchainUtil.baseAmount(2000000), xchainUtil.AssetRuneNative);
+    }
+    throw new Error(`could not calculate inbound fee for ${asset.chain}`);
+};
+/**
+ * Return the chain for a given Asset This method should live somewhere else.
+ * @param chain
+ * @returns the gas asset type for the given chain
+ */
+const getChainAsset = (chain) => {
+    switch (chain) {
+        case xchainUtil.BNBChain:
+            return xchainUtil.AssetBNB;
+        case xchainUtil.BTCChain:
+            return xchainUtil.AssetBTC;
+        case xchainUtil.ETHChain:
+            return xchainUtil.AssetETH;
+        case xchainUtil.THORChain:
+            return xchainUtil.AssetRuneNative;
+        case xchainUtil.CosmosChain:
+            return lib.AssetAtom;
+        case xchainUtil.BCHChain:
+            return xchainUtil.AssetBCH;
+        case xchainUtil.LTCChain:
+            return xchainUtil.AssetLTC;
+        case xchainUtil.DOGEChain:
+            return xchainUtil.AssetDOGE;
+        case xchainUtil.TerraChain:
+            return lib$1.AssetLUNA;
+        case xchainUtil.PolkadotChain:
+            throw Error('Polkadot is not supported yet');
+        default:
+            throw Error('Unknown chain');
+    }
+};
+
+const chainIds = {
+    [xchainClient.Network.Mainnet]: 'thorchain-mainnet-v1',
+    [xchainClient.Network.Stagenet]: 'chain-id-stagenet',
+    [xchainClient.Network.Testnet]: 'thorchain-testnet-v2',
+};
+const APPROVE_GASLIMIT_FALLBACK = '200000';
+const ONE_HOUR = 60 * 60 * 1000;
+/**
+ * Wallet Class for managing all xchain-* wallets with a mnemonic seed.
+ */
+class Wallet {
+    /**
+     * Contructor to create a Wallet
+     *
+     * @param network - stagenet,testnet,mainnet
+     * @param phrase - mnemonic phrase
+     * @returns Wallet
+     */
+    constructor(network, phrase) {
+        this.asgardAssets = undefined;
+        this.network = network;
+        const settings = { network, phrase };
+        this.midgard = new Midgard(this.network);
+        this.clients = {
+            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 })),
+            LTC: new xchainLitecoin.Client(settings),
+            BNB: new xchainBinance.Client(settings),
+            GAIA: new xchainCosmos.Client(settings),
+        };
+        this.updateAsgardAddresses(ONE_HOUR);
+    }
+    /**
+     * Fetch balances for all wallets
+     *
+     * @returns AllBalances[]
+     */
+    getAllBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientArray = Object.entries(this.clients);
+            const allBalances = yield Promise.all(clientArray.map((entry) => __awaiter(this, void 0, void 0, function* () {
+                const chain = entry[0];
+                const address = entry[1].getAddress(0);
+                try {
+                    const balances = yield entry[1].getBalance(address);
+                    return { chain, address, balances };
+                }
+                catch (err) {
+                    return { 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* () {
+            this.validateSwap(swap);
+            if (swap.sourceAsset.chain === xchainUtil.Chain.THORChain || swap.sourceAsset.synth) {
+                return yield this.swapRuneTo(swap);
+            }
+            else {
+                return yield this.swapNonRune(swap);
+            }
+        });
+    }
+    constructSwapMemo(swap) {
+        const limstring = swap.limit.amount().toFixed();
+        // create LIM with interface ID
+        const lim = limstring.substring(0, limstring.length - 3).concat(swap.interfaceID.toString());
+        // create the full memo
+        let memo = `=:${xchainUtil.assetToString(swap.destinationAsset)}`;
+        // needs to be tested
+        if (swap.affiliateAddress != '' || swap.affiliateFee == undefined) {
+            memo = memo.concat(`:${swap.destinationAddress}:${lim}:${swap.affiliateAddress}:${swap.affiliateFee.amount().toFixed()}`);
+        }
+        else {
+            memo = memo.concat(`:${swap.destinationAddress}:${lim}`);
+        }
+        // If memo length is too long for BTC, trim it
+        if (xchainUtil.eqAsset(swap.sourceAsset, xchainUtil.AssetBTC) && memo.length > 80) {
+            memo = `=:${xchainUtil.assetToString(swap.destinationAsset)}:${swap.destinationAddress}`;
+        }
+        return memo;
+    }
+    validateSwap(swap) {
+        const errors = [];
+        const isThorchainDestinationAsset = swap.destinationAsset.synth || swap.destinationAsset.chain === xchainUtil.Chain.THORChain;
+        const chain = isThorchainDestinationAsset ? xchainUtil.Chain.THORChain : swap.destinationAsset.chain;
+        if (!this.clients[chain].validateAddress(swap.destinationAddress)) {
+            errors.push(`destinationAddress ${swap.destinationAddress} is not a valid address`);
+        }
+        if (swap.affiliateAddress && !this.clients[xchainUtil.Chain.THORChain].validateAddress(swap.affiliateAddress))
+            errors.push(`affiliateAddress ${swap.affiliateAddress} is not a valid address`);
+        if (errors.length > 0)
+            throw Error(errors.join('\n'));
+    }
+    swapRuneTo(swap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const thorClient = this.clients.THOR;
+            const waitTimeSeconds = swap.waitTimeSeconds;
+            const hash = yield thorClient.deposit({
+                amount: swap.fromBaseAmount,
+                asset: swap.sourceAsset,
+                memo: this.constructSwapMemo(swap),
+            });
+            return { hash, url: this.clients.THOR.getExplorerTxUrl(hash), waitTimeSeconds };
+        });
+    }
+    swapNonRune(swap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.clients[swap.sourceAsset.chain];
+            const waitTimeSeconds = swap.waitTimeSeconds;
+            const inboundAsgard = (yield this.getAsgardAssets()).find((item) => {
+                return item.chain === swap.sourceAsset.chain;
+            });
+            if (swap.sourceAsset.chain === xchainUtil.Chain.Ethereum) {
+                const params = {
+                    walletIndex: 0,
+                    asset: swap.sourceAsset,
+                    amount: swap.fromBaseAmount,
+                    feeOption: swap.feeOption || xchainClient.FeeOption.Fast,
+                    memo: this.constructSwapMemo(swap),
+                };
+                const hash = yield this.sendETHDeposit(params);
+                return { hash, url: client.getExplorerTxUrl(hash), waitTimeSeconds };
+            }
+            else {
+                const params = {
+                    walletIndex: 0,
+                    asset: swap.sourceAsset,
+                    amount: swap.fromBaseAmount,
+                    recipient: (inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.address) || '',
+                    memo: this.constructSwapMemo(swap),
+                };
+                const hash = yield client.transfer(params);
+                return { hash, url: client.getExplorerTxUrl(hash), waitTimeSeconds };
+            }
+        });
+    }
+    updateAsgardAddresses(checkTimeMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.asgardAssets = yield this.midgard.getAllInboundAddresses();
+            }
+            catch (error) {
+                console.error(error);
+            }
+            setTimeout(this.updateAsgardAddresses.bind(this), checkTimeMs);
+        });
+    }
+    /**
+     * 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
+     */
+    sendETHDeposit(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ethClient = this.clients.ETH;
+            const inboundAsgard = (yield this.getAsgardAssets()).find((item) => {
+                return item.chain === params.asset.chain;
+            });
+            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
+                throw new Error('router address is not defined');
+            }
+            const address = this.clients.ETH.getAddress(params.walletIndex);
+            const gasPrice = yield ethClient.estimateGasPrices();
+            if (xchainUtil.eqAsset(params.asset, xchainUtil.AssetETH)) {
+                //ETH is a simple transfer
+                return yield this.clients.ETH.transfer({
+                    walletIndex: params.walletIndex || 0,
+                    asset: params.asset,
+                    amount: params.amount,
+                    recipient: inboundAsgard.address,
+                    memo: params.memo,
+                });
+            }
+            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 = getContractAddressFromAsset(params.asset);
+                const checkSummedContractAddress = ethers.ethers.utils.getAddress(contractAddress);
+                const depositParams = [
+                    inboundAsgard.address,
+                    checkSummedContractAddress,
+                    params.amount.amount().toFixed(),
+                    params.memo,
+                ];
+                const routerContract = new ethers.ethers.Contract(inboundAsgard.router, routerABI);
+                const gasPriceInWei = gasPrice[params.feeOption];
+                const gasPriceInGwei = gasPriceInWei.div(Math.pow(10, 9)).amount();
+                // TODO should we change the calcInboundFee() to use gasRate in BaseAmount instead of BIgNumber?
+                // currently its hardto know the units to use, GWEI/WEI, etc
+                const gasLimitInWei = calcNetworkFee(params.asset, gasPriceInGwei);
+                const gasLimitInGWei = gasLimitInWei
+                    .div(Math.pow(10, 9))
+                    .baseAmount.amount()
+                    .toFixed();
+                const unsignedTx = yield routerContract.populateTransaction.deposit(...depositParams, {
+                    from: address,
+                    value: 0,
+                    gasPrice: gasPrice.fast.amount().toFixed(),
+                    gasLimit: gasLimitInGWei,
+                });
+                const { hash } = yield ethClient.getWallet(params.walletIndex).sendTransaction(unsignedTx);
+                return hash;
+            }
+        });
+    }
+    isTCRouterApprovedToSpend(asset, amount, walletIndex = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ethClient = this.clients.ETH;
+            const router = yield this.getRouterAddressForChain(asset.chain);
+            const contractAddress = getContractAddressFromAsset(asset);
+            return yield ethClient.isApproved({
+                amount: amount,
+                spenderAddress: router,
+                contractAddress,
+                walletIndex: walletIndex,
+            });
+        });
+    }
+    approveTCRouterToSpend(asset, amount = xchainEthereum.MAX_APPROVAL, walletIndex = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ethClient = this.clients.ETH;
+            const contractAddress = getContractAddressFromAsset(asset);
+            const router = yield this.getRouterAddressForChain(asset.chain);
+            // const gasPrice = await ethClient.estimateGasPrices()
+            // const gasLimit = calcInboundFee(asset, gasPrice.fast.amount())
+            const approveParams = {
+                contractAddress,
+                spenderAddress: router,
+                amount: xchainUtil.baseAmount(amount.toString(), xchainEthereum.ETH_DECIMAL),
+                walletIndex,
+                gasLimitFallback: APPROVE_GASLIMIT_FALLBACK,
+            };
+            return yield ethClient.approve(approveParams);
+        });
+    }
+    getRouterAddressForChain(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inboundAsgard = (yield this.getAsgardAssets()).find((item) => {
+                return item.chain === chain;
+            });
+            if (!(inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router)) {
+                throw new Error('router address is not defined');
+            }
+            return inboundAsgard === null || inboundAsgard === void 0 ? void 0 : inboundAsgard.router;
+        });
+    }
+    getAsgardAssets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.asgardAssets) {
+                this.asgardAssets = yield this.midgard.getAllInboundAddresses();
+            }
+            return this.asgardAssets;
+        });
+    }
+}
+
+const DefaultChainAttributes = {
+    BCH: {
+        blockReward: 6.25,
+        avgBlockTimeInSecs: 600,
+    },
+    BTC: {
+        blockReward: 6.25,
+        avgBlockTimeInSecs: 600,
+    },
+    ETH: {
+        blockReward: 2,
+        avgBlockTimeInSecs: 13,
+    },
+    LTC: {
+        blockReward: 12.5,
+        avgBlockTimeInSecs: 150,
+    },
+    DOGE: {
+        blockReward: 10000,
+        avgBlockTimeInSecs: 60,
+    },
+    GAIA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
+    TERRA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 0,
+    },
+    BNB: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
+    THOR: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
+    POLKA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 0,
+    },
+};
+
+/**
+ * Represent a Liquidity Pool in Thorchain
+ */
+class LiquidityPool {
+    constructor(pool) {
+        this.pool = pool;
+        const asset = xchainUtil.assetFromString(this.pool.asset);
+        if (!asset)
+            throw new Error(`could not parse ${this.pool.asset}`);
+        this.asset = asset;
+        this.assetString = this.pool.asset;
+        this.assetBalance = xchainUtil.baseAmount(this.pool.assetDepth);
+        this.runeBalance = xchainUtil.baseAmount(this.pool.runeDepth); //Rune is always 8 decimals
+        this.runeToAssetRatio = this.runeBalance.amount().div(this.assetBalance.amount());
+        this.assetToRuneRatio = this.assetBalance.amount().div(this.runeBalance.amount());
+    }
+    isAvailable() {
+        return this.pool.status.toLowerCase() === 'available';
+    }
+}
+
+const SAME_ASSET_EXCHANGE_RATE = new BigNumber.BigNumber(1);
+/**
+ * This class manages retrieving information from up to date Thorchain Liquidity Pools
+ */
+class LiquidityPoolCache {
+    /**
+     * Contrustor to create a LiquidityPoolCache
+     *
+     * @param midgard - an instance of the midgard API (could be pointing to stagenet,testnet,mainnet)
+     * @param expirePoolCacheMillis - how long should the pools be cached before expiry
+     * @returns LiquidityPoolCache
+     */
+    constructor(midgard, expirePoolCacheMillis = 6000) {
+        this.midgard = midgard;
+        this.expirePoolCacheMillis = expirePoolCacheMillis;
+        //initialize the cache
+        this.refereshPoolCache();
+    }
+    /**
+     * Gets the exchange rate of the from asset in terms on the to asset
+     *
+     * @param asset - cannot be RUNE.
+     * @returns Promise<BigNumber>
+     */
+    getExchangeRate(from, to) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let exchangeRate;
+            if (xchainUtil.eqAsset(from, to)) {
+                exchangeRate = SAME_ASSET_EXCHANGE_RATE;
+            }
+            else if (lib$2.isAssetRuneNative(from)) {
+                //  Runes per Asset
+                const lpTo = yield this.getPoolForAsset(to);
+                exchangeRate = lpTo.assetToRuneRatio;
+            }
+            else if (lib$2.isAssetRuneNative(to)) {
+                //  Asset per rune
+                const lpFrom = yield this.getPoolForAsset(from);
+                exchangeRate = lpFrom.runeToAssetRatio;
+            }
+            else {
+                //  AssetA per AssetB
+                const lpFrom = yield this.getPoolForAsset(from);
+                const lpTo = yield this.getPoolForAsset(to);
+                // from/R * R/to = from/to
+                exchangeRate = lpFrom.runeToAssetRatio.times(lpTo.assetToRuneRatio);
+            }
+            return exchangeRate;
+        });
+    }
+    /**
+     * Gets the Liquidity Pool for a given Asset
+     *
+     * @param asset - cannot be RUNE, since Rune is the other side of each pool.
+     * @returns Promise<LiquidityPool>
+     */
+    getPoolForAsset(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (lib$2.isAssetRuneNative(asset))
+                throw Error(`AssetRuneNative doesn't have a pool`);
+            const pools = yield this.getPools();
+            // Not: we use ticker, not asset string to get the same pool for both assets and synths
+            const pool = pools[asset.ticker];
+            if (pool) {
+                return pool;
+            }
+            throw Error(`Pool for ${xchainUtil.assetToString(asset)} not found`);
+        });
+    }
+    /**
+     * Get all the Liquidity Pools currently cached.
+     * if the cache is expired, the pools wioll be re-fetched from midgard
+     *
+     * @returns Promise<Record<string, LiquidityPool>>
+     */
+    getPools() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const millisSinceLastRefeshed = Date.now() - (((_a = this.poolCache) === null || _a === void 0 ? void 0 : _a.lastRefreshed) || 0);
+            if (millisSinceLastRefeshed > this.expirePoolCacheMillis) {
+                try {
+                    yield this.refereshPoolCache();
+                    console.log('updated pool cache');
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            if (this.poolCache) {
+                return (_b = this.poolCache) === null || _b === void 0 ? void 0 : _b.pools;
+            }
+            else {
+                throw Error(`Could not refresh Pools `);
+            }
+        });
+    }
+    /**
+     * Refreshes the Pool Cache
+     *
+     * NOTE: do not call refereshPoolCache() directly, call getPools() instead
+     * which will refresh the cache if it's expired
+     */
+    refereshPoolCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pools = yield this.midgard.getPools();
+            const poolMap = {};
+            if (pools) {
+                for (const pool of pools) {
+                    const lp = new LiquidityPool(pool);
+                    poolMap[lp.asset.ticker] = lp;
+                }
+                this.poolCache = {
+                    lastRefreshed: Date.now(),
+                    pools: poolMap,
+                };
+            }
+        });
+    }
+    /**
+     *
+     *  Calcuate the expected slip, output & swapFee given the current pool depths
+     *
+     *  swapFee - the amount of asset lost  according to slip calculations
+     *  slip - the percent (0-1) of original amount lost to slipfees
+     *  output - the amount of asset expected from the swap   *
+     *
+     * @param inputAmount - CryptoAmount amount to swap from
+     * @param destinationAsset - destimation Asset to swap to
+     * @returns SwapOutput - swap output object - output - fee - slip
+     */
+    getExpectedSwapOutput(inputAmount, destinationAsset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (lib$2.isAssetRuneNative(inputAmount.asset)) {
+                //singleswap from rune -> asset
+                const pool = yield this.getPoolForAsset(destinationAsset);
+                return getSingleSwap(inputAmount.baseAmount, pool, false);
+            }
+            else if (lib$2.isAssetRuneNative(destinationAsset)) {
+                //singleswap from  asset -> rune
+                const pool = yield this.getPoolForAsset(inputAmount.asset);
+                return getSingleSwap(inputAmount.baseAmount, pool, true);
+            }
+            else {
+                //doubleswap asset-> asset
+                const inPpool = yield this.getPoolForAsset(inputAmount.asset);
+                const destPool = yield this.getPoolForAsset(destinationAsset);
+                return getDoubleSwap(inputAmount.baseAmount, inPpool, destPool);
+            }
+        });
+    }
+    /**
+     * Returns the exchange of a CryptoAmount to a different Asset
+     *
+     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
+     *
+     * @param input - amount/asset to convert to outAsset
+     * @param ouAsset - the Asset you want to convert to
+     * @returns CryptoAmount of input
+     */
+    convert(input, outAsset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchangeRate = yield this.getExchangeRate(input.asset, outAsset);
+            const amt = input.assetAmount.times(exchangeRate);
+            const result = new CryptoAmount(xchainUtil.assetToBase(amt), outAsset);
+            return result;
+        });
+    }
+}
+
+const BN_1 = new BigNumber.BigNumber(1);
+/**
+ * THORChain Class for interacting with THORChain.
+ * Recommended main class to use for swapping with THORChain
+ * Has access to Midgard and THORNode data
+ */
+class ThorchainAMM {
+    /**
+     * Contructor to create a ThorchainAMM
+     *
+     * @param midgard - an instance of the midgard API (could be pointing to stagenet,testnet,mainnet)
+     * @param expirePoolCacheMillis - how long should the pools be cached before expiry
+     * @param chainAttributes - atrributes used to calculate waitTime & conf counting
+     * @returns ThorchainAMM
+     */
+    constructor(midgard, expirePoolCacheMillis = 6000, chainAttributes = DefaultChainAttributes) {
+        this.midgard = midgard;
+        this.allPools = new LiquidityPoolCache(midgard, expirePoolCacheMillis);
+        this.chainAttributes = chainAttributes;
+    }
+    /**
+     * 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
+  
+     * @returns The SwapEstimate
+     */
+    estimateSwap(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isValidSwap(params);
+            const [sourceInboundDetails, destinationInboundDetails] = yield this.midgard.getInboundDetails([
+                params.input.asset.chain,
+                params.destinationAsset.chain,
+            ]);
+            const swapEstimate = yield this.calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails);
+            const errors = yield this.getSwapEstimateErrors(params, swapEstimate, sourceInboundDetails, destinationInboundDetails);
+            if (errors.length > 0) {
+                swapEstimate.canSwap = false;
+                swapEstimate.errors = errors;
+            }
+            else {
+                swapEstimate.canSwap = true;
+                if (params.destinationAsset.chain !== xchainUtil.Chain.THORChain && !params.destinationAsset.synth) {
+                    //---------------- Work out total Wait Time for Swap ---------------------- /
+                    const inboundDelay = yield this.confCounting(params.input);
+                    const outboundDelay = yield this.outboundDelay(swapEstimate.netOutput);
+                    swapEstimate.waitTimeSeconds = inboundDelay + outboundDelay;
+                }
+            }
+            return swapEstimate;
+        });
+    }
+    /**
+     * Convinience method to convert TotalFees to a different CryptoAmount
+     *
+     * TotalFees are always calculated and returned in RUNE, this method can
+     * be used to show the equivalent fees in another Asset Type
+     *
+     * @param fees: TotalFees - the fees you want to convert
+     * @param asset: Asset - the asset you want the fees converted to
+     * @returns TotalFees in asset
+     */
+    getFeesIn(fees, asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                inboundFee: yield this.convert(fees.inboundFee, asset),
+                swapFee: yield this.convert(fees.swapFee, asset),
+                outboundFee: yield this.convert(fees.outboundFee, asset),
+                affiliateFee: yield this.convert(fees.affiliateFee, asset),
+            };
+        });
+    }
+    /**
+     * Returns the exchange of a CryptoAmount to a different Asset
+     *
+     * Ex. convert(input:100 BUSD, outAsset: BTC) -> 0.0001234 BTC
+     *
+     * @param input - amount/asset to convert to outAsset
+     * @param ouAsset - the Asset you want to convert to
+     * @returns CryptoAmount of input
+     */
+    convert(input, outAsset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.allPools.convert(input, outAsset);
+        });
+    }
+    /**
+     * Conducts a swap with the given inputs. Should be called after estimateSwap() to ensure the swap is valid
+     *
+     * @param wallet - wallet to use
+     * @param params - swap paraps
+     * @param destinationAddress - were to send the output of the swap
+     * @param affiliateAddress - were to send the affilate Address, should be a THOR address (optional)
+     * @param interfaceID - id if the calling interface (optional)
+     * @returns {SwapSubmitted} - Tx Hash, URL of BlockExplorer and expected wait time.
+     */
+    doSwap(wallet, params, destinationAddress, affiliateAddress = '', interfaceID = 999) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO validate all input fields
+            this.isValidSwap(params);
+            // remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
+            const affiliateFee = params.input.baseAmount.times(params.affiliateFeePercent || 0);
+            // Work out LIM from the slip percentage
+            let limPercentage = BN_1;
+            if (params.slipLimit) {
+                limPercentage = BN_1.minus(params.slipLimit || 1);
+            } // else allowed slip is 100%
+            // out min outbound asset based on limPercentage
+            const limAssetAmount = yield this.allPools.convert(params.input.times(limPercentage), params.destinationAsset);
+            let waitTimeSeconds = yield this.confCounting(params.input);
+            const outboundDelay = yield this.outboundDelay(limAssetAmount);
+            waitTimeSeconds = outboundDelay + waitTimeSeconds;
+            return yield wallet.executeSwap({
+                fromBaseAmount: params.input.baseAmount,
+                sourceAsset: params.input.asset,
+                destinationAsset: params.destinationAsset,
+                limit: limAssetAmount.baseAmount,
+                destinationAddress,
+                affiliateAddress,
+                affiliateFee,
+                interfaceID,
+                waitTimeSeconds,
+            });
+        });
+    }
+    /**
+     * Basic Checks for swap information
+     * @param params
+     */
+    isValidSwap(params) {
+        // TODO validate all input fields
+        if (xchainUtil.eqAsset(params.input.asset, params.destinationAsset))
+            throw Error(`sourceAsset and destinationAsset cannot be the same`);
+        if (params.input.baseAmount.lte(0))
+            throw Error('inputAmount must be greater than 0');
+        if (params.affiliateFeePercent && (params.affiliateFeePercent < 0 || params.affiliateFeePercent > 0.1))
+            throw Error(`affiliateFee must be between 0 and 1000`);
+    }
+    /**
+     * Does the calculations for the swap.
+     * Used by estimateSwap
+     *
+     * @param params
+     * @param sourceInboundDetails
+     * @param destinationInboundDetails
+     * @param sourcePool
+     * @param destinationPool
+     * @returns
+     */
+    calcSwapEstimate(params, sourceInboundDetails, destinationInboundDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const input = params.input;
+            const inputInRune = yield this.allPools.convert(input, xchainUtil.AssetRuneNative);
+            const inboundFeeInAsset = calcNetworkFee(input.asset, sourceInboundDetails.gas_rate);
+            let outboundFeeInAsset = calcNetworkFee(params.destinationAsset, destinationInboundDetails.gas_rate);
+            outboundFeeInAsset = outboundFeeInAsset.times(3);
+            const inboundFeeInRune = yield this.allPools.convert(inboundFeeInAsset, xchainUtil.AssetRuneNative);
+            const outboundFeeInRune = yield this.allPools.convert(outboundFeeInAsset, xchainUtil.AssetRuneNative);
+            // ---------- Remove Fees from inbound before doing the swap -----------
+            // TODO confirm with chris about this change
+            // const inputMinusInboundFeeInRune = inputInRune.minus(inboundFeeInRune)
+            const inputMinusInboundFeeInRune = inputInRune;
+            // remove any affiliateFee. netInput * affiliateFee (%age) of the destination asset type
+            const affiliateFeeInRune = inputMinusInboundFeeInRune.times(params.affiliateFeePercent || 0);
+            // remove the affiliate fee from the input.
+            const inputNetAmountInRune = inputMinusInboundFeeInRune.minus(affiliateFeeInRune);
+            // convert back to input asset
+            const inputNetInAsset = yield this.allPools.convert(inputNetAmountInRune, input.asset);
+            // now calculate swapfee based on inputNetAmount
+            const swapOutput = yield this.allPools.getExpectedSwapOutput(inputNetInAsset, params.destinationAsset);
+            const swapFeeInAsset = new CryptoAmount(swapOutput.swapFee, xchainUtil.AssetRuneNative);
+            const swapFeeInRune = yield this.allPools.convert(swapFeeInAsset, xchainUtil.AssetRuneNative);
+            const outputInAsset = new CryptoAmount(swapOutput.output, params.destinationAsset);
+            const outputInRune = yield this.allPools.convert(outputInAsset, xchainUtil.AssetRuneNative);
+            // ---------------- Remove Outbound Fee ---------------------- /
+            const netOutputInRune = outputInRune.minus(outboundFeeInRune);
+            const netOutputInAsset = yield this.allPools.convert(netOutputInRune, params.destinationAsset);
+            const totalFees = {
+                inboundFee: inboundFeeInRune,
+                swapFee: swapFeeInRune,
+                outboundFee: outboundFeeInRune,
+                affiliateFee: affiliateFeeInRune,
+            };
+            const swapEstimate = {
+                totalFees: totalFees,
+                slipPercentage: swapOutput.slip,
+                netOutput: netOutputInAsset,
+                waitTimeSeconds: 0,
+                canSwap: false, // assume false for now, the getSwapEstimateErrors() step will flip this flag if required
+            };
+            return swapEstimate;
+        });
+    }
+    /**
+     * Looks for errors or issues within swap prams before doing the swap.
+     *
+     *
+     * @param params
+     * @param estimate
+     * @param sourcePool
+     * @param sourceInboundDetails
+     * @param destinationPool
+     * @param destinationInboundDetails
+     * @returns
+     */
+    getSwapEstimateErrors(params, estimate, sourceInboundDetails, destinationInboundDetails) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const errors = [];
+            const sourceAsset = params.input.asset;
+            const destAsset = params.destinationAsset;
+            if (!lib$2.isAssetRuneNative(sourceAsset)) {
+                const sourcePool = yield this.allPools.getPoolForAsset(sourceAsset);
+                if (!sourcePool.isAvailable())
+                    errors.push(`sourceAsset ${sourceAsset.ticker} does not have a valid liquidity pool`);
+            }
+            if (!lib$2.isAssetRuneNative(destAsset)) {
+                const destPool = yield this.allPools.getPoolForAsset(destAsset);
+                if (!destPool.isAvailable())
+                    errors.push(`destinationAsset ${destAsset.ticker} does not have a valid liquidity pool`);
+            }
+            if (sourceInboundDetails.haltedChain)
+                errors.push(`source chain is halted`);
+            if (sourceInboundDetails.haltedTrading)
+                errors.push(`source pool is halted trading`);
+            if (destinationInboundDetails.haltedChain)
+                errors.push(`destination chain is halted`);
+            if (destinationInboundDetails.haltedTrading)
+                errors.push(`destination pool is halted trading`);
+            if (estimate.slipPercentage.gte(params.slipLimit || 1))
+                errors.push(`expected slip: ${estimate.slipPercentage.toFixed()} is greater than your slip limit:${(_a = params.slipLimit) === null || _a === void 0 ? void 0 : _a.toFixed()} `);
+            // only proceed to check fees if there are no errors so far
+            if (errors.length > 0)
+                return errors;
+            // Check if the inputAmount value is enough to cover all the fees.
+            const canCoverFeesError = yield this.checkCoverFees(params, estimate);
+            if (canCoverFeesError)
+                errors.push(canCoverFeesError);
+            return errors;
+        });
+    }
+    checkCoverFees(params, estimate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = undefined;
+            const input = yield this.allPools.convert(params.input, xchainUtil.AssetRuneNative);
+            const fees = yield this.getFeesIn(estimate.totalFees, xchainUtil.AssetRuneNative);
+            const totalSwapFeesInRune = fees.inboundFee.plus(fees.outboundFee).plus(fees.swapFee).plus(fees.affiliateFee);
+            if (totalSwapFeesInRune.gte(input))
+                result = `Input amount ${input.formatedAssetString()} is less than or equal to total swap fees`;
+            return result;
+        });
+    }
+    /**
+     * Works out how long an outbound Tx will be held by THORChain before sending.
+     *
+     * @param outboundAmount: CryptoAmount  being sent.
+     * @returns required delay in seconds
+     * @see https://gitlab.com/thorchain/thornode/-/blob/develop/x/thorchain/manager_txout_current.go#L548
+     */
+    outboundDelay(outboundAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const networkValues = yield this.midgard.getNetworkValueByNames([
+                'MinTxOutVolumeThreshold',
+                'MaxTxOutOffset',
+                'TXOUTDELAYRATE',
+            ]);
+            const minTxOutVolumeThreshold = new CryptoAmount(xchainUtil.baseAmount(networkValues['MinTxOutVolumeThreshold']), xchainUtil.AssetRuneNative);
+            const maxTxOutOffset = Number.parseInt(networkValues['MaxTxOutOffset']);
+            let txOutDelayRate = new CryptoAmount(xchainUtil.baseAmount(networkValues['TXOUTDELAYRATE']), xchainUtil.AssetRuneNative);
+            const getScheduledOutboundValue = yield this.midgard.getScheduledOutboundValue();
+            const thorChainblocktime = this.chainAttributes[xchainUtil.THORChain].avgBlockTimeInSecs; // blocks required to confirm tx
+            // If asset is equal to Rune set runeValue as outbound amount else set it to the asset's value in rune
+            const runeValue = yield this.allPools.convert(outboundAmount, xchainUtil.AssetRuneNative);
+            // Check rune value amount
+            if (runeValue.lt(minTxOutVolumeThreshold)) {
+                return thorChainblocktime;
+            }
+            // Rune value in the outbound queue
+            if (getScheduledOutboundValue == undefined) {
+                throw new Error(`Could not return Scheduled Outbound Value`);
+            }
+            // Add OutboundAmount in rune to the oubound queue
+            const outboundAmountTotal = runeValue.plus(getScheduledOutboundValue);
+            // calculate the if outboundAmountTotal is over the volume threshold
+            const volumeThreshold = outboundAmountTotal.div(minTxOutVolumeThreshold);
+            // check delay rate
+            txOutDelayRate = txOutDelayRate.minus(volumeThreshold).baseAmount.amount().lt(1)
+                ? new CryptoAmount(xchainUtil.baseAmount(1), xchainUtil.AssetRuneNative)
+                : txOutDelayRate;
+            // calculate the minimum number of blocks in the future the txn has to be
+            let minBlocks = runeValue.div(txOutDelayRate).baseAmount.amount().toNumber();
+            minBlocks = minBlocks > maxTxOutOffset ? maxTxOutOffset : minBlocks;
+            return minBlocks * thorChainblocktime;
+        });
+    }
+    /**
+     * Finds the required confCount required for an inbound or outbound Tx to THORChain. Estimate based on Midgard data only.
+     *
+     * Finds the gas asset of the given asset (e.g. BUSD is on BNB), finds the value of asset in Gas Asset then finds the required confirmation count.
+     * ConfCount is then times by 6 seconds.
+     *
+     * @param inbound: CryptoAmount - amount/asset of the outbound amount.
+     * @returns time in seconds before a Tx is confirmed by THORChain
+     * @see https://docs.thorchain.org/chain-clients/overview
+     */
+    confCounting(inbound) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // RUNE, BNB and Synths have near instant finality, so no conf counting required.
+            if (lib$2.isAssetRuneNative(inbound.asset) || xchainUtil.eqAsset(xchainUtil.AssetBNB, inbound.asset) || inbound.asset.synth) {
+                return this.chainAttributes[xchainUtil.Chain.THORChain].avgBlockTimeInSecs;
+            }
+            // Get the gas asset for the inbound.asset.chain
+            const chainGasAsset = getChainAsset(inbound.asset.chain);
+            // check for chain asset, else need to convert asset value to chain asset.
+            const amountInGasAsset = yield this.allPools.convert(inbound, chainGasAsset);
+            // Convert to Asset Amount
+            const amountInGasAssetInAsset = amountInGasAsset.assetAmount;
+            const confConfig = this.chainAttributes[inbound.asset.chain];
+            // find the requried confs
+            const requiredConfs = Math.ceil(amountInGasAssetInAsset.amount().div(confConfig.blockReward).toNumber());
+            // convert that into seconds
+            return requiredConfs * confConfig.avgBlockTimeInSecs;
+        });
+    }
+}
+
+exports.CryptoAmount = CryptoAmount;
+exports.LiquidityPool = LiquidityPool;
+exports.Midgard = Midgard;
+exports.ThorchainAMM = ThorchainAMM;
+exports.Wallet = Wallet;