@shapeshiftoss/swapper 14.2.3 → 14.3.0

package/dist/swappers/thorchain/ThorchainSwapper.d.ts

@@ -1,6 +1,8 @@
 import { Asset } from '@shapeshiftoss/asset-service';
 import { AssetId, ChainId } from '@shapeshiftoss/caip';
+import { ChainAdapterManager } from '@shapeshiftoss/chain-adapters';
 import { KnownChainIds } from '@shapeshiftoss/types';
+import Web3 from 'web3';
 import type { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
 import { SwapperName, SwapperType } from '../../api';
 import { ThorchainSwapperDeps } from './types';
@@ -12,10 +14,14 @@ export declare class ThorchainSwapper implements Swapper<ChainId> {
     private supportedSellAssetIds;
     private supportedBuyAssetIds;
     deps: ThorchainSwapperDeps;
+    daemonUrl: string;
+    midgardUrl: string;
+    adapterManager: ChainAdapterManager;
+    web3: Web3;
     constructor(deps: ThorchainSwapperDeps);
     initialize(): Promise<void>;
     getType(): SwapperType;
-    getUsdRate(input: Pick<Asset, 'symbol' | 'assetId'>): Promise<string>;
+    getUsdRate({ assetId }: Pick<Asset, 'assetId'>): Promise<string>;
     approvalNeeded(input: ApprovalNeededInput<KnownChainIds.EthereumMainnet>): Promise<ApprovalNeededOutput>;
     approveInfinite(input: ApproveInfiniteInput<KnownChainIds.EthereumMainnet>): Promise<string>;
     approveAmount(): Promise<string>;

package/dist/swappers/thorchain/ThorchainSwapper.js

@@ -46,30 +46,26 @@ class ThorchainSwapper {
             [types_1.KnownChainIds.CosmosMainnet]: true,
             [types_1.KnownChainIds.ThorchainMainnet]: true,
         };
-        this.supportedSellAssetIds = [];
-        this.supportedBuyAssetIds = [];
+        this.supportedSellAssetIds = [caip_1.thorchainAssetId];
+        this.supportedBuyAssetIds = [caip_1.thorchainAssetId];
         this.deps = deps;
+        this.daemonUrl = deps.daemonUrl;
+        this.midgardUrl = deps.midgardUrl;
+        this.adapterManager = deps.adapterManager;
+        this.web3 = deps.web3;
     }
     async initialize() {
         try {
             const { data: allPools } = await thorService_1.thorService.get(`${this.deps.daemonUrl}/lcd/thorchain/pools`);
             const availablePools = allPools.filter((pool) => pool.status === 'Available');
-            this.supportedSellAssetIds = availablePools.reduce((acc, pool) => {
+            availablePools.forEach((pool) => {
                 const assetId = caip_1.adapters.poolAssetIdToAssetId(pool.asset);
-                if (!assetId || !this.sellSupportedChainIds[(0, caip_1.fromAssetId)(assetId).chainId])
-                    return acc;
-                acc.push(assetId);
-                return acc;
-            }, []);
-            this.supportedSellAssetIds.push(caip_1.thorchainAssetId);
-            this.supportedBuyAssetIds = availablePools.reduce((acc, pool) => {
-                const assetId = caip_1.adapters.poolAssetIdToAssetId(pool.asset);
-                if (!assetId || !this.buySupportedChainIds[(0, caip_1.fromAssetId)(assetId).chainId])
-                    return acc;
-                acc.push(assetId);
-                return acc;
-            }, []);
-            this.supportedBuyAssetIds.push(caip_1.thorchainAssetId);
+                if (!assetId)
+                    return;
+                const { chainId } = (0, caip_1.fromAssetId)(assetId);
+                this.sellSupportedChainIds[chainId] && this.supportedSellAssetIds.push(assetId);
+                this.buySupportedChainIds[chainId] && this.supportedBuyAssetIds.push(assetId);
+            });
         }
         catch (e) {
             throw new api_1.SwapError('[thorchainInitialize]: initialize failed to set supportedAssetIds', {
@@ -81,8 +77,8 @@ class ThorchainSwapper {
     getType() {
         return api_1.SwapperType.Thorchain;
     }
-    getUsdRate(input) {
-        return (0, getUsdRate_1.getUsdRate)({ deps: this.deps, input });
+    async getUsdRate({ assetId }) {
+        return (0, getUsdRate_1.getUsdRate)(this.daemonUrl, assetId);
     }
     async approvalNeeded(input) {
         return (0, thorTradeApprovalNeeded_1.thorTradeApprovalNeeded)({ deps: this.deps, input });

package/dist/swappers/thorchain/getThorTradeQuote/getTradeQuote.js

@@ -36,11 +36,8 @@ const getThorTradeQuote = async ({ deps, input }) => {
             ? constants_2.RUNE_OUTBOUND_TRANSACTION_FEE_CRYPTO_HUMAN.toString()
             : (0, bignumber_1.fromBaseUnit)((0, bignumber_1.bnOrZero)(buyAssetAddressData === null || buyAssetAddressData === void 0 ? void 0 : buyAssetAddressData.outbound_fee), constants_3.THORCHAIN_FIXED_PRECISION);
         const buyAssetChainFeeAssetId = buyAdapter.getFeeAssetId();
-        const sellAssetUsdRate = await (0, getUsdRate_1.getUsdRate)({ deps, input: { assetId: sellAsset.assetId } });
-        const buyFeeAssetUsdRate = await (0, getUsdRate_1.getUsdRate)({
-            deps,
-            input: { assetId: buyAssetChainFeeAssetId },
-        });
+        const sellAssetUsdRate = await (0, getUsdRate_1.getUsdRate)(deps.daemonUrl, sellAsset.assetId);
+        const buyFeeAssetUsdRate = await (0, getUsdRate_1.getUsdRate)(deps.daemonUrl, buyAssetChainFeeAssetId);
         const buyAssetTradeFeeUsd = (0, bignumber_1.bn)(buyFeeAssetUsdRate)
             .times(estimatedBuyAssetTradeFeeFeeAssetCryptoHuman)
             .toString();

package/dist/swappers/thorchain/types.d.ts

@@ -4,20 +4,6 @@ import type { BTCSignTx, CosmosSignTx, ETHSignTx } from '@shapeshiftoss/hdwallet
 import { KnownChainIds } from '@shapeshiftoss/types';
 import type Web3 from 'web3';
 import type { Trade, UtxoSupportedChainIds } from '../../api';
-export declare type MidgardPoolResponse = {
-    asset: string;
-    assetDepth: string;
-    assetPrice: string;
-    assetPriceUSD: string;
-    liquidityUnits: string;
-    poolAPY: string;
-    runeDepth: string;
-    status: string;
-    synthSupply: string;
-    synthUnits: string;
-    units: string;
-    volume24h: string;
-};
 export declare type ThornodePoolResponse = {
     LP_units: string;
     asset: string;

package/dist/swappers/thorchain/utils/getLimit/getLimit.js

@@ -26,11 +26,8 @@ const getLimit = async ({ sellAsset, buyAssetId, sellAmountCryptoPrecision, deps
             details: { sellAssetChainFeeAssetId, buyAssetChainFeeAssetId },
         });
     }
-    const sellFeeAssetUsdRate = await (0, getUsdRate_1.getUsdRate)({
-        deps,
-        input: { assetId: sellAssetChainFeeAssetId },
-    });
-    const buyAssetUsdRate = await (0, getUsdRate_1.getUsdRate)({ deps, input: { assetId: buyAssetId } });
+    const sellFeeAssetUsdRate = await (0, getUsdRate_1.getUsdRate)(deps.daemonUrl, sellAssetChainFeeAssetId);
+    const buyAssetUsdRate = await (0, getUsdRate_1.getUsdRate)(deps.daemonUrl, buyAssetId);
     const expectedBuyAmountCryptoPrecision8 = (0, bignumber_1.toBaseUnit)((0, bignumber_1.fromBaseUnit)((0, bignumber_1.bnOrZero)(sellAmountCryptoPrecision).times(tradeRate), sellAsset.precision), constants_2.THORCHAIN_FIXED_PRECISION);
     const isValidSlippageRange = (0, bignumber_1.bnOrZero)(slippageTolerance).gte(0) && (0, bignumber_1.bnOrZero)(slippageTolerance).lte(1);
     if ((0, bignumber_1.bnOrZero)(expectedBuyAmountCryptoPrecision8).lt(0) || !isValidSlippageRange)

package/dist/swappers/thorchain/utils/getUsdRate/getUsdRate.d.ts

@@ -1,6 +1,2 @@
-import { Asset } from '@shapeshiftoss/asset-service';
-import { ThorchainSwapperDeps } from '../../types';
-export declare const getUsdRate: ({ deps, input, }: {
-    deps: ThorchainSwapperDeps;
-    input: Pick<Asset, 'assetId'>;
-}) => Promise<string>;
+import { AssetId } from '@shapeshiftoss/caip';
+export declare const getUsdRate: (daemonUrl: string, assetId: AssetId) => Promise<string>;

package/dist/swappers/thorchain/utils/getUsdRate/getUsdRate.js

@@ -6,42 +6,66 @@ const api_1 = require("../../../../api");
 const bignumber_1 = require("../../../utils/bignumber");
 const isRune_1 = require("../isRune/isRune");
 const thorService_1 = require("../thorService");
-const THOR_PRECISION = 8;
-// not sure what to do for rune usd rate - inverting USDC pool rate for now
-const usdcPool = 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48';
-const getUsdRate = async ({ deps, input, }) => {
-    const { assetId } = input;
+const PRECISION = 18;
+const USD_POOLS = Object.freeze([
+    'AVAX.USDC-0XB97EF9EF8734C71904D8002F8B6BC66DD9C48A6E',
+    'BNB.BUSD-BD1',
+    'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48',
+    'ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7',
+]);
+// calculate rune usd price from a usd pool (ex. USDC_POOL)
+const getRuneUsdPrice = async (daemonUrl) => {
+    const { data } = await thorService_1.thorService.get(`${daemonUrl}/lcd/thorchain/pools`);
+    const availableUsdPools = data.filter((pool) => pool.status === 'Available' && USD_POOLS.includes(pool.asset));
+    const { aggregatedRuneUsdPrice, numPools } = availableUsdPools.reduce((prev, pool) => {
+        const usdBalance = (0, bignumber_1.bnOrZero)(pool.balance_asset);
+        const runeBalance = (0, bignumber_1.bnOrZero)(pool.balance_rune);
+        if (usdBalance.isZero() || runeBalance.isZero())
+            return prev;
+        // usdBalance / runeBalance = runeUsdPrice
+        const runeUsdPrice = usdBalance.div(runeBalance);
+        prev.aggregatedRuneUsdPrice = prev.aggregatedRuneUsdPrice.plus(runeUsdPrice);
+        prev.numPools++;
+        return prev;
+    }, { aggregatedRuneUsdPrice: (0, bignumber_1.bn)(0), numPools: 0 });
+    if (!numPools) {
+        throw new api_1.SwapError('[getUsdRate]: no available usd pools', {
+            code: api_1.SwapErrorTypes.USD_RATE_FAILED,
+        });
+    }
+    // aggregatedRuneUsdPrice / numPools = averageRuneUsdPrice
+    return aggregatedRuneUsdPrice.div(numPools);
+};
+const getUsdRate = async (daemonUrl, assetId) => {
     try {
-        const thorchainPoolId = (() => {
-            if ((0, isRune_1.isRune)(assetId)) {
-                return usdcPool;
-            }
-            return caip_1.adapters.assetIdToPoolAssetId({ assetId });
-        })();
-        if (!thorchainPoolId) {
-            throw new api_1.SwapError(`[getUsdRate]: No thorchainPoolId found for assetId: ${assetId}`, {
+        if ((0, isRune_1.isRune)(assetId)) {
+            const runeUsdPrice = await getRuneUsdPrice(daemonUrl);
+            return runeUsdPrice.toFixed(PRECISION);
+        }
+        const poolId = caip_1.adapters.assetIdToPoolAssetId({ assetId });
+        if (!poolId) {
+            throw new api_1.SwapError(`[getUsdRate]: no pool found for assetId: ${assetId}`, {
                 code: api_1.SwapErrorTypes.USD_RATE_FAILED,
             });
         }
-        const { data: responseData } = await thorService_1.thorService.get(`${deps.midgardUrl}/pool/${thorchainPoolId}`);
-        const rate = (() => {
-            if ((0, isRune_1.isRune)(assetId)) {
-                const bnRate = (0, bignumber_1.bnOrZero)(responseData === null || responseData === void 0 ? void 0 : responseData.assetPrice);
-                if (bnRate.isZero()) {
-                    throw new api_1.SwapError('[getUsdRate]: cannot invert rate zero', {
-                        code: api_1.SwapErrorTypes.USD_RATE_FAILED,
-                    });
-                }
-                const inverseRate = (0, bignumber_1.bn)(1).div(bnRate);
-                return inverseRate.toFixed(THOR_PRECISION);
-            }
-            return responseData === null || responseData === void 0 ? void 0 : responseData.assetPriceUSD;
-        })();
-        if (!rate)
-            throw new api_1.SwapError(`[getUsdRate]: No rate for ${assetId}`, {
+        const { data } = await thorService_1.thorService.get(`${daemonUrl}/lcd/thorchain/pool/${poolId}`);
+        if (data.status !== 'Available') {
+            throw new api_1.SwapError('[getUsdRate]: pool is no longer available', {
                 code: api_1.SwapErrorTypes.USD_RATE_FAILED,
             });
-        return rate;
+        }
+        const assetBalance = (0, bignumber_1.bnOrZero)(data.balance_asset);
+        const runeBalance = (0, bignumber_1.bnOrZero)(data.balance_rune);
+        if (assetBalance.isZero() || runeBalance.isZero()) {
+            throw new api_1.SwapError('[getUsdRate]: pool has a zero balance', {
+                code: api_1.SwapErrorTypes.USD_RATE_FAILED,
+            });
+        }
+        const runeUsdPrice = await getRuneUsdPrice(daemonUrl);
+        // runeBalance / assetBalance = assetPriceInRune
+        const assetPriceInRune = runeBalance.div(assetBalance);
+        // runeUsdPrice * assetPriceInRune = assetUsdPrice
+        return runeUsdPrice.times(assetPriceInRune).toFixed(PRECISION);
     }
     catch (e) {
         if (e instanceof api_1.SwapError)

package/dist/swappers/thorchain/utils/test-data/responses.d.ts

@@ -1,8 +1,6 @@
-import { InboundAddressResponse, MidgardPoolResponse, ThornodePoolResponse } from '../../types';
-export declare const btcMidgardPool: MidgardPoolResponse;
+import { InboundAddressResponse, ThornodePoolResponse } from '../../types';
 export declare const btcThornodePool: ThornodePoolResponse;
-export declare const ethMidgardPool: MidgardPoolResponse;
 export declare const ethThornodePool: ThornodePoolResponse;
-export declare const foxMidgardPool: MidgardPoolResponse;
 export declare const foxThornodePool: ThornodePoolResponse;
+export declare const usdcThornodePool: ThornodePoolResponse;
 export declare const mockInboundAddresses: InboundAddressResponse[];

package/dist/swappers/thorchain/utils/test-data/responses.js

@@ -1,20 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockInboundAddresses = exports.foxThornodePool = exports.foxMidgardPool = exports.ethThornodePool = exports.ethMidgardPool = exports.btcThornodePool = exports.btcMidgardPool = void 0;
-exports.btcMidgardPool = {
-    asset: 'BTC.BTC',
-    assetDepth: '91027798705',
-    assetPrice: '10280.68095465986',
-    assetPriceUSD: '29850.505131750208',
-    liquidityUnits: '536055974608843',
-    poolAPY: '0.09305294391574037',
-    runeDepth: '935827756491105',
-    status: 'available',
-    synthSupply: '3281284823',
-    synthUnits: '9838954536080',
-    units: '545894929144923',
-    volume24h: '15031085906495',
-};
+exports.mockInboundAddresses = exports.usdcThornodePool = exports.foxThornodePool = exports.ethThornodePool = exports.btcThornodePool = void 0;
 exports.btcThornodePool = {
     LP_units: '536055974608843',
     asset: 'BTC.BTC',
@@ -27,20 +13,6 @@ exports.btcThornodePool = {
     synth_supply: '3281284823',
     synth_units: '9838954536080',
 };
-exports.ethMidgardPool = {
-    asset: 'ETH.ETH',
-    assetDepth: '915018987646',
-    assetPrice: '676.2118757936507',
-    assetPriceUSD: '1595',
-    liquidityUnits: '273709963437801',
-    poolAPY: '0.10532151323548256',
-    runeDepth: '618746706022909',
-    status: 'available',
-    synthSupply: '3572065751',
-    synthUnits: '535301524652',
-    units: '274245264962453',
-    volume24h: '9890096673763',
-};
 exports.ethThornodePool = {
     LP_units: '273709963437801',
     asset: 'ETH.ETH',
@@ -53,20 +25,6 @@ exports.ethThornodePool = {
     synth_supply: '3572065751',
     synth_units: '535301524652',
 };
-exports.foxMidgardPool = {
-    asset: 'ETH.FOX-0XC770EEFAD204B5180DF6A14EE197D99D808EE52D',
-    assetDepth: '166650912393467',
-    assetPrice: '0.05303710198887871',
-    assetPriceUSD: '0.15399605260336216',
-    liquidityUnits: '10015457121887',
-    poolAPY: '0.2597568967423438',
-    runeDepth: '8838681437152',
-    status: 'available',
-    synthSupply: '17428372569375',
-    synthUnits: '552604585625',
-    units: '10568061707512',
-    volume24h: '251596933033',
-};
 exports.foxThornodePool = {
     LP_units: '10015457121887',
     asset: 'ETH.FOX-0XC770EEFAD204B5180DF6A14EE197D99D808EE52D',
@@ -79,6 +37,18 @@ exports.foxThornodePool = {
     synth_supply: '17428372569375',
     synth_units: '552604585625',
 };
+exports.usdcThornodePool = {
+    LP_units: '30018075345020',
+    asset: 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48',
+    balance_asset: '290355330190652994811',
+    balance_rune: '100000000000000000000',
+    pending_inbound_asset: '22020062300',
+    pending_inbound_rune: '0',
+    pool_units: '31954495292990',
+    status: 'Available',
+    synth_supply: '25598723155460',
+    synth_units: '1936419947970',
+};
 exports.mockInboundAddresses = [
     {
         chain: 'BCH',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "14.2.3",
+  "version": "14.3.0",
   "description": "An interface and implementations to trade coins via various protocols",
   "repository": "https://github.com/shapeshift/lib",
   "license": "MIT",