@xchainjs/xchain-thorchain-query 0.2.2 → 0.2.4

package/lib/index.esm.js

@@ -1,18 +1,9 @@
-import { BNBChain, AssetBNB } from '@xchainjs/xchain-binance';
-import { BTCChain, AssetBTC } from '@xchainjs/xchain-bitcoin';
-import { GAIAChain, AssetATOM } from '@xchainjs/xchain-cosmos';
-import { AssetRuneNative, THORChain, isAssetRuneNative } from '@xchainjs/xchain-thorchain';
 import { assetToBase, formatAssetAmountCurrency, baseToAsset, eqAsset, assetToString, assetFromString, baseAmount, assetFromStringEx, assetAmount, getContractAddressFromAsset } from '@xchainjs/xchain-util';
 import { BigNumber } from 'bignumber.js';
 import { Network } from '@xchainjs/xchain-client';
 import { MidgardApi, Configuration } from '@xchainjs/xchain-midgard';
 import axios from 'axios';
 import axiosRetry from 'axios-retry';
-import { AVAXChain, AssetAVAX } from '@xchainjs/xchain-avax';
-import { BCHChain, AssetBCH } from '@xchainjs/xchain-bitcoincash';
-import { DOGEChain, AssetDOGE } from '@xchainjs/xchain-doge';
-import { ETHChain, AssetETH } from '@xchainjs/xchain-ethereum';
-import { LTCChain, AssetLTC } from '@xchainjs/xchain-litecoin';
 import { TransactionsApi, Configuration as Configuration$1, QueueApi, NetworkApi, PoolsApi, LiquidityProvidersApi, SaversApi, QuoteApi, MimirApi } from '@xchainjs/xchain-thornode';
 
 /*! *****************************************************************************
@@ -77,6 +68,14 @@ const DefaultChainAttributes = {
         blockReward: 0,
         avgBlockTimeInSecs: 6,
     },
+    BSC: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 3,
+    },
+    MAYA: {
+        blockReward: 0,
+        avgBlockTimeInSecs: 6,
+    },
 };
 
 /**
@@ -196,148 +195,29 @@ class LiquidityPool {
     }
 }
 
-const defaultMidgardConfig = {
-    mainnet: {
-        apiRetries: 3,
-        midgardBaseUrls: ['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 = Network.Mainnet, config) {
-        this.network = network;
-        this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig[this.network];
-        axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
-        this.midgardApis = this.config.midgardBaseUrls.map((url) => new MidgardApi(new Configuration({ basePath: url })));
-    }
-    /**
-     *
-     * @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 new Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * 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`);
-        });
-    }
-    /**
-     * Gets actions object for any of the parameters
-     * @param txHash transaction id
-     * @returns Type Action array of objects
-     */
-    getActions(address, txid, asset, type, affiliate, limit, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
-                    return actions;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return member details based on valid liquidity position
-     * @param address - needed to query for Lp details
-     * @returns - object type of Member Detail
-     */
-    getMember(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const memberDetail = (yield api.getMemberDetail(address)).data;
-                    return memberDetail;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return pool statistics for a particular asset
-     * @param asset - asset string to query its pool stats
-     * @returns - type object poolstatsDetail
-     */
-    getPoolStats(asset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const poolDetail = (yield api.getPoolStats(asset)).data;
-                    return poolDetail;
-                }
-                catch (e) {
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-    /**
-     * Function to return THORNameDetails for a particular name
-     * @param name - thorname string to query
-     * @returns - type object THORNameDetails
-     */
-    getTHORNameDetails(name) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const api of this.midgardApis) {
-                try {
-                    const resp = yield api.getTHORNameDetail(name);
-                    if (resp.status == 404) {
-                        return undefined;
-                    }
-                    else if (resp.status == 200) {
-                        return resp.data;
-                    }
-                }
-                catch (e) {
-                    // if (resp.status == 404) {
-                    //   return undefined
-                    // }
-                    //console.error(e)
-                }
-            }
-            throw Error(`Midgard not responding`);
-        });
-    }
-}
+const AssetBNB = assetFromStringEx('BNB.BNB');
+const AssetAVAX = assetFromStringEx('AVAX.AVAX');
+const AssetBTC = assetFromStringEx('BTC.BTC');
+const AssetBCH = assetFromStringEx('BCH.BHC');
+const AssetETH = assetFromStringEx('ETH.ETH');
+const AssetDOGE = assetFromStringEx('DOGE.DOGE');
+const AssetLTC = assetFromStringEx('LTC.LTC');
+const AssetATOM = assetFromStringEx('GAIA.ATOM');
+const AssetMAYA = assetFromStringEx('MAYA.CACAO');
+const AssetBSC = assetFromStringEx('BSC.BNB');
+const AssetRuneNative = assetFromStringEx('THOR.RUNE');
+const BNBChain = 'BNB';
+const BTCChain = 'BTC';
+const BCHChain = 'BCH';
+const ETHChain = 'ETH';
+const GAIAChain = 'GAIA';
+const DOGEChain = 'DOGE';
+const LTCChain = 'LTC';
+const AVAXChain = 'AVAX';
+const MAYAChain = 'MAYA';
+const BSCChain = 'BSC';
+const THORChain = 'THOR';
+const isAssetRuneNative = (asset) => assetToString(asset) === assetToString(AssetRuneNative);
 
 const getBaseAmountWithDiffDecimals = (inputAmount, outDecimals) => {
     const inDecimals = inputAmount.baseAmount.decimal;
@@ -491,6 +371,10 @@ const getChainAsset = (chain) => {
             return AssetDOGE;
         case AVAXChain:
             return AssetAVAX;
+        case BSCChain:
+            return AssetBSC;
+        case MAYAChain:
+            return AssetMAYA;
         default:
             throw Error('Unknown chain');
     }
@@ -553,6 +437,10 @@ const calcNetworkFee = (asset, inbound) => {
             return new CryptoAmount(baseAmount(inbound.gasRate), AssetATOM);
         case THORChain:
             return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+        case BSCChain:
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetBSC);
+        case MAYAChain:
+            return new CryptoAmount(baseAmount(inbound.gasRate), AssetMAYA);
     }
     throw new Error(`could not calculate inbound fee for ${asset.chain}`);
 };
@@ -587,12 +475,250 @@ const calcOutboundFee = (asset, inbound) => {
             return new CryptoAmount(baseAmount(inbound.outboundFee.multipliedBy(Math.pow(10, 9)), 18), AssetAVAX);
         case GAIAChain:
             return new CryptoAmount(baseAmount(inbound.outboundFee), AssetATOM);
+        case BSCChain:
+            return new CryptoAmount(baseAmount(inbound.outboundFee), AssetBSC);
         case THORChain:
             return new CryptoAmount(baseAmount(2000000), AssetRuneNative);
+        case MAYAChain:
+            return new CryptoAmount(baseAmount(2000000), AssetMAYA);
     }
     throw new Error(`could not calculate outbound fee for ${asset.chain}`);
 };
 
+/**
+ * https://dev.thorchain.org/thorchain-dev/interface-guide/math#lp-units-add
+ * @param liquidity - asset amount added
+ * @param pool  - pool depths
+ * @returns liquidity units - ownership of pool
+ */
+const getLiquidityUnits = (liquidity, pool) => {
+    const baseAmount8decimals = getBaseAmountWithDiffDecimals(liquidity.asset, 8);
+    const P = new BigNumber(pool.pool.liquidityUnits);
+    const r = liquidity.rune.baseAmount.amount();
+    const a = baseAmount8decimals;
+    const R = pool.runeBalance.amount();
+    const A = pool.assetBalance.amount();
+    const part1 = R.times(a);
+    const part2 = r.times(A);
+    const numerator = P.times(part1.plus(part2));
+    const denominator = R.times(A).times(2);
+    const result = numerator.div(denominator);
+    return result;
+};
+/**
+ *
+ * @param unitData - units for both asset and rune
+ * @param pool - pool that the asset is bound to
+ * @returns - pool share of both asset and rune in percentage
+ */
+const getPoolShare = (unitData, pool) => {
+    // formula: (rune * part) / total; (asset * part) / total
+    const units = unitData.liquidityUnits;
+    const total = unitData.totalUnits;
+    const R = pool.runeBalance.amount();
+    const T = pool.assetBalance.amount();
+    const asset = T.times(units).div(total);
+    const rune = R.times(units).div(total);
+    const poolShareDetail = {
+        assetShare: new CryptoAmount(baseAmount(asset), pool.asset),
+        runeShare: new CryptoAmount(baseAmount(rune), AssetRuneNative),
+    };
+    return poolShareDetail;
+};
+/**
+ *
+ * @param poolShare - the share of asset and rune added to the pool
+ * @param pool - Pool that the asset is attached to
+ * @returns - returns bignumber representing a slip percentage
+ */
+const getSlipOnLiquidity = (stake, pool) => {
+    const baseAmount8decimals = getBaseAmountWithDiffDecimals(stake.asset, 8);
+    // formula: (t * R - T * r)/ (T*r + R*T)
+    const r = stake.rune.baseAmount.amount();
+    const t = baseAmount8decimals;
+    const R = pool.runeBalance.amount();
+    const T = pool.assetBalance.amount();
+    const numerator = t.times(R).minus(T.times(r));
+    const denominator = T.times(r).plus(R.times(T));
+    const result = numerator.div(denominator).abs();
+    return result;
+};
+/**
+ * https://docs.thorchain.org/thorchain-finance/continuous-liquidity-pools#impermanent-loss-protection
+ * @param poolShare - the share of asset and rune added to the pool
+ * @param pool - Pool that the asset is attached to
+ * @param block - blockl object with current, last added and the constant blocksforlossProtection
+ * @returns
+ */
+// Blocks for full protection 1440000 // 100 days
+const getLiquidityProtectionData = (depositValue, poolShare, block) => {
+    //Coverage formula coverage=((A0∗P1)+R0)−((A1∗P1)+R1)=>((A0∗R1/A1)+R0)−(R1+R1)
+    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
+    const R0 = depositValue.rune.amount(); // rune deposit value
+    const A0 = depositValue.asset.amount(); // asset deposit value
+    const R1 = poolShare.runeShare.baseAmount.amount(); // rune amount to redeem
+    const A1 = poolShare.assetShare.baseAmount.amount(); // asset amount to redeem
+    const P1 = R1.div(A1); // Pool ratio at withdrawal
+    const part1 = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1)); // start position minus end position
+    const part2 = A0.times(R1.div(A1)).plus(R0).minus(R1.plus(R1)); // different way to check position
+    const coverage = part1 >= part2 ? part1 : part2; // Coverage represents how much ILP a LP is entitled to
+    const currentHeight = block.current;
+    const heightLastAdded = block.lastAdded || 0; //default to zero if undefined
+    const blocksforfullprotection = block.fullProtection;
+    const fractionOfFullILPProtection = (currentHeight - heightLastAdded) / blocksforfullprotection;
+    const protectionProgress = Math.min(fractionOfFullILPProtection, 1); // percentage of entitlement, max 100%
+    const result = coverage.times(protectionProgress); // impermanent loss protection result
+    const maxILP = result.lt(0) ? new BigNumber(0) : result; // max negative ILP to 0
+    const ILProtection = {
+        ILProtection: new CryptoAmount(baseAmount(maxILP), AssetRuneNative),
+        totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
+    };
+    return ILProtection;
+};
+
+const defaultMidgardConfig = {
+    mainnet: {
+        apiRetries: 3,
+        midgardBaseUrls: ['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 = Network.Mainnet, config) {
+        this.network = network;
+        this.config = config !== null && config !== void 0 ? config : defaultMidgardConfig[this.network];
+        axiosRetry(axios, { retries: this.config.apiRetries, retryDelay: axiosRetry.exponentialDelay });
+        this.midgardApis = this.config.midgardBaseUrls.map((url) => new MidgardApi(new Configuration({ basePath: url })));
+    }
+    /**
+     *
+     * @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 new Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * 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`);
+        });
+    }
+    /**
+     * Gets actions object for any of the parameters
+     * @param txHash transaction id
+     * @returns Type Action array of objects
+     */
+    getActions(address, txid, asset, type, affiliate, limit, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const actions = (yield api.getActions(address, txid, asset, type, affiliate, limit, offset)).data.actions;
+                    return actions;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return member details based on valid liquidity position
+     * @param address - needed to query for Lp details
+     * @returns - object type of Member Detail
+     */
+    getMember(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const memberDetail = (yield api.getMemberDetail(address)).data;
+                    return memberDetail;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return pool statistics for a particular asset
+     * @param asset - asset string to query its pool stats
+     * @returns - type object poolstatsDetail
+     */
+    getPoolStats(asset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const poolDetail = (yield api.getPoolStats(asset)).data;
+                    return poolDetail;
+                }
+                catch (e) {
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+    /**
+     * Function to return THORNameDetails for a particular name
+     * @param name - thorname string to query
+     * @returns - type object THORNameDetails
+     */
+    getTHORNameDetails(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const api of this.midgardApis) {
+                try {
+                    const resp = yield api.getTHORNameDetail(name);
+                    if (resp.status == 404) {
+                        return undefined;
+                    }
+                    else if (resp.status == 200) {
+                        return resp.data;
+                    }
+                }
+                catch (e) {
+                    // if (resp.status == 404) {
+                    //   return undefined
+                    // }
+                    //console.error(e)
+                }
+            }
+            throw Error(`Midgard not responding`);
+        });
+    }
+}
+
 const defaultThornodeConfig = {
     mainnet: {
         apiRetries: 3,
@@ -1356,97 +1482,6 @@ class ThorchainCache {
     }
 }
 
-/**
- * https://dev.thorchain.org/thorchain-dev/interface-guide/math#lp-units-add
- * @param liquidity - asset amount added
- * @param pool  - pool depths
- * @returns liquidity units - ownership of pool
- */
-const getLiquidityUnits = (liquidity, pool) => {
-    const baseAmount8decimals = getBaseAmountWithDiffDecimals(liquidity.asset, 8);
-    const P = new BigNumber(pool.pool.liquidityUnits);
-    const r = liquidity.rune.baseAmount.amount();
-    const a = baseAmount8decimals;
-    const R = pool.runeBalance.amount();
-    const A = pool.assetBalance.amount();
-    const part1 = R.times(a);
-    const part2 = r.times(A);
-    const numerator = P.times(part1.plus(part2));
-    const denominator = R.times(A).times(2);
-    const result = numerator.div(denominator);
-    return result;
-};
-/**
- *
- * @param unitData - units for both asset and rune
- * @param pool - pool that the asset is bound to
- * @returns - pool share of both asset and rune in percentage
- */
-const getPoolShare = (unitData, pool) => {
-    // formula: (rune * part) / total; (asset * part) / total
-    const units = unitData.liquidityUnits;
-    const total = unitData.totalUnits;
-    const R = pool.runeBalance.amount();
-    const T = pool.assetBalance.amount();
-    const asset = T.times(units).div(total);
-    const rune = R.times(units).div(total);
-    const poolShareDetail = {
-        assetShare: new CryptoAmount(baseAmount(asset), pool.asset),
-        runeShare: new CryptoAmount(baseAmount(rune), AssetRuneNative),
-    };
-    return poolShareDetail;
-};
-/**
- *
- * @param poolShare - the share of asset and rune added to the pool
- * @param pool - Pool that the asset is attached to
- * @returns - returns bignumber representing a slip percentage
- */
-const getSlipOnLiquidity = (stake, pool) => {
-    const baseAmount8decimals = getBaseAmountWithDiffDecimals(stake.asset, 8);
-    // formula: (t * R - T * r)/ (T*r + R*T)
-    const r = stake.rune.baseAmount.amount();
-    const t = baseAmount8decimals;
-    const R = pool.runeBalance.amount();
-    const T = pool.assetBalance.amount();
-    const numerator = t.times(R).minus(T.times(r));
-    const denominator = T.times(r).plus(R.times(T));
-    const result = numerator.div(denominator).abs();
-    return result;
-};
-/**
- * https://docs.thorchain.org/thorchain-finance/continuous-liquidity-pools#impermanent-loss-protection
- * @param poolShare - the share of asset and rune added to the pool
- * @param pool - Pool that the asset is attached to
- * @param block - blockl object with current, last added and the constant blocksforlossProtection
- * @returns
- */
-// Blocks for full protection 1440000 // 100 days
-const getLiquidityProtectionData = (depositValue, poolShare, block) => {
-    //Coverage formula coverage=((A0∗P1)+R0)−((A1∗P1)+R1)=>((A0∗R1/A1)+R0)−(R1+R1)
-    //formula: protectionProgress (currentHeight-heightLastAdded)/blocksforfullprotection
-    const R0 = depositValue.rune.amount(); // rune deposit value
-    const A0 = depositValue.asset.amount(); // asset deposit value
-    const R1 = poolShare.runeShare.baseAmount.amount(); // rune amount to redeem
-    const A1 = poolShare.assetShare.baseAmount.amount(); // asset amount to redeem
-    const P1 = R1.div(A1); // Pool ratio at withdrawal
-    const part1 = A0.times(P1).plus(R0).minus(A1.times(P1).plus(R1)); // start position minus end position
-    const part2 = A0.times(R1.div(A1)).plus(R0).minus(R1.plus(R1)); // different way to check position
-    const coverage = part1 >= part2 ? part1 : part2; // Coverage represents how much ILP a LP is entitled to
-    const currentHeight = block.current;
-    const heightLastAdded = block.lastAdded || 0; //default to zero if undefined
-    const blocksforfullprotection = block.fullProtection;
-    const fractionOfFullILPProtection = (currentHeight - heightLastAdded) / blocksforfullprotection;
-    const protectionProgress = Math.min(fractionOfFullILPProtection, 1); // percentage of entitlement, max 100%
-    const result = coverage.times(protectionProgress); // impermanent loss protection result
-    const maxILP = result.lt(0) ? new BigNumber(0) : result; // max negative ILP to 0
-    const ILProtection = {
-        ILProtection: new CryptoAmount(baseAmount(maxILP), AssetRuneNative),
-        totalDays: (fractionOfFullILPProtection * 100).toFixed(2),
-    };
-    return ILProtection;
-};
-
 const BN_1 = new BigNumber(1);
 const defaultCache = new ThorchainCache();
 /**
@@ -2149,6 +2184,20 @@ class ThorchainQuery {
                         rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
                     };
                     return dustValues;
+                case 'BSC':
+                    // 0 BSC
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                    };
+                    return dustValues;
+                case 'MAYA':
+                    // 0 MAYA
+                    dustValues = {
+                        asset: new CryptoAmount(assetToBase(assetAmount(0)), asset),
+                        rune: new CryptoAmount(assetToBase(assetAmount(0)), AssetRuneNative),
+                    };
+                    return dustValues;
                 default:
                     throw Error('Unknown chain');
             }
@@ -2740,4 +2789,4 @@ class TransactionStage {
     }
 }
 
-export { AddLpStatus, AddSaverStatus, CryptoAmount, InboundStatus, LiquidityPool, Midgard, RefundStatus, SwapStatus, ThorchainCache, ThorchainQuery, Thornode, TransactionStage, TxType, WithdrawStatus, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity };
+export { AVAXChain, AddLpStatus, AddSaverStatus, AssetATOM, AssetAVAX, AssetBCH, AssetBNB, AssetBSC, AssetBTC, AssetDOGE, AssetETH, AssetLTC, AssetMAYA, AssetRuneNative, BCHChain, BNBChain, BSCChain, BTCChain, CryptoAmount, DOGEChain, ETHChain, GAIAChain, InboundStatus, LTCChain, LiquidityPool, MAYAChain, Midgard, RefundStatus, SwapStatus, THORChain, ThorchainCache, ThorchainQuery, Thornode, TransactionStage, TxType, WithdrawStatus, calcNetworkFee, getDoubleSwap, getLiquidityProtectionData, getLiquidityUnits, getPoolShare, getSingleSwap, getSlipOnLiquidity, isAssetRuneNative };