@shapeshiftoss/swapper 15.1.0 → 15.2.0

package/dist/api.d.ts

@@ -67,6 +67,9 @@ export declare type ByPairInput = {
     sellAssetId: AssetId;
     buyAssetId: AssetId;
 };
+export declare type GetBestSwapperArgs = GetTradeQuoteInput & {
+    feeAsset: Asset;
+};
 export declare type BuyAssetBySellIdInput = {
     sellAssetId: AssetId;
     assetIds: AssetId[];

package/dist/manager/SwapperManager.d.ts

@@ -1,5 +1,5 @@
 import { ChainId } from '@shapeshiftoss/caip';
-import { BuyAssetBySellIdInput, ByPairInput, SupportedSellAssetsInput, Swapper } from '..';
+import { BuyAssetBySellIdInput, ByPairInput, GetBestSwapperArgs, SupportedSellAssetsInput, Swapper } from '..';
 import { SwapperType } from '../api';
 export declare class SwapperManager {
     swappers: Map<SwapperType, Swapper<ChainId>>;
@@ -22,7 +22,12 @@ export declare class SwapperManager {
      * @returns {SwapperManager}
      */
     removeSwapper(swapperType: SwapperType): this;
-    getBestSwapper(args: ByPairInput): Promise<Swapper<ChainId> | undefined>;
+    /**
+     *
+     * @param args {GetBestSwapperArgs}
+     * @returns {Promise<Swapper<ChainId> | undefined>}
+     */
+    getBestSwapper(args: GetBestSwapperArgs): Promise<Swapper<ChainId> | undefined>;
     /**
      *
      * @param pair type {GetQuoteInput}

package/dist/manager/SwapperManager.js

@@ -4,8 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapperManager = void 0;
+const lodash_1 = require("lodash");
 const uniq_1 = __importDefault(require("lodash/uniq"));
 const api_1 = require("../api");
+const typeGuards_1 = require("../typeGuards");
+const utils_1 = require("./utils");
 function validateSwapper(swapper) {
     if (!(typeof swapper === 'object' && typeof swapper.getType === 'function'))
         throw new api_1.SwapError('[validateSwapper] - invalid swapper instance', {
@@ -57,10 +60,49 @@ class SwapperManager {
         this.swappers.delete(swapperType);
         return this;
     }
+    /**
+     *
+     * @param args {GetBestSwapperArgs}
+     * @returns {Promise<Swapper<ChainId> | undefined>}
+     */
     async getBestSwapper(args) {
-        // TODO: This will eventually have logic to determine the best swapper.
-        // For now we return the first swapper we get from getSwappersByPair
-        return this.getSwappersByPair(args)[0];
+        const { sellAsset, buyAsset, feeAsset } = args;
+        // Get all swappers that support the pair
+        const supportedSwappers = this.getSwappersByPair({
+            sellAssetId: sellAsset.assetId,
+            buyAssetId: buyAsset.assetId,
+        });
+        // Get quotes from all swappers that support the pair
+        const quotePromises = supportedSwappers.map(async (swapper) => [swapper, await swapper.getTradeQuote(args)]);
+        const settledQuoteRequests = await Promise.allSettled(quotePromises);
+        // For each swapper, get receive amount/(input amount + gas fee), where all values are in fiat
+        const fulfilledQuoteTuples = settledQuoteRequests
+            .filter(typeGuards_1.isFulfilled)
+            .map((quoteRequest) => quoteRequest.value);
+        // The best swapper is the one with the highest ratio
+        const bestQuoteTuple = await fulfilledQuoteTuples.reduce(async (acc, currentQuoteTuple) => {
+            const resolvedAcc = await acc;
+            const [currentSwapper, currentQuote] = currentQuoteTuple;
+            const currentRatio = await (0, utils_1.getRatioFromQuote)(currentQuote, currentSwapper, feeAsset);
+            // It's our first iteration, so we just return the current SwapperQuoteTuple
+            if (!resolvedAcc)
+                return Promise.resolve([currentSwapper, currentRatio]);
+            const [, bestRatio] = resolvedAcc;
+            const isCurrentSwapperBestSwapper = (() => {
+                // Happy path - no div by 0's in getRatioFromQuote evaluations so we have both ratios
+                if (!(0, lodash_1.isUndefined)(currentRatio) && !(0, lodash_1.isUndefined)(bestRatio))
+                    return currentRatio > bestRatio;
+                // We don't know, neither has a ratio, so we can't compare (big edge case div by 0 scenario)
+                if ((0, lodash_1.isUndefined)(currentRatio) && (0, lodash_1.isUndefined)(bestRatio))
+                    return false;
+                // We don't have a best, but we do have a current, so current is the new best
+                return !(0, lodash_1.isUndefined)(currentRatio);
+            })();
+            const currentSwapperRatioTuple = [currentSwapper, currentRatio];
+            return Promise.resolve(isCurrentSwapperBestSwapper ? currentSwapperRatioTuple : resolvedAcc);
+        }, undefined);
+        const bestSwapper = bestQuoteTuple === null || bestQuoteTuple === void 0 ? void 0 : bestQuoteTuple[0];
+        return bestSwapper;
     }
     /**
      *
@@ -69,7 +111,8 @@ class SwapperManager {
      */
     getSwappersByPair(pair) {
         const { sellAssetId, buyAssetId } = pair;
-        return Array.from(this.swappers.values()).filter((swapper) => swapper.filterBuyAssetsBySellAssetId({ sellAssetId, assetIds: [buyAssetId] }).length);
+        const availableSwappers = Array.from(this.swappers.values());
+        return availableSwappers.filter((swapper) => swapper.filterBuyAssetsBySellAssetId({ sellAssetId, assetIds: [buyAssetId] }).length);
     }
     getSupportedBuyAssetIdsFromSellId(args) {
         return (0, uniq_1.default)(Array.from(this.swappers.values()).flatMap((swapper) => swapper.filterBuyAssetsBySellAssetId(args)));

package/dist/manager/testData.d.ts

@@ -0,0 +1,10 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { TradeQuote } from '../api';
+import { CowSwapper, ThorchainSwapper, ZrxSwapper } from '../swappers';
+export declare const getZrxEthereumSwapper: () => ZrxSwapper<import("../api").EvmSupportedChainIds>;
+export declare const getZrxAvalancheSwapper: () => ZrxSwapper<import("../api").EvmSupportedChainIds>;
+export declare const getCowSwapper: () => CowSwapper;
+export declare const getThorchainSwapper: () => ThorchainSwapper;
+export declare const tradeQuote: TradeQuote<KnownChainIds.EthereumMainnet>;
+export declare const goodTradeQuote: TradeQuote<KnownChainIds.EthereumMainnet>;
+export declare const badTradeQuote: TradeQuote<KnownChainIds.EthereumMainnet>;

package/dist/manager/testData.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.badTradeQuote = exports.goodTradeQuote = exports.tradeQuote = exports.getThorchainSwapper = exports.getCowSwapper = exports.getZrxAvalancheSwapper = exports.getZrxEthereumSwapper = void 0;
+const types_1 = require("@shapeshiftoss/types");
+const api_1 = require("../api");
+const swappers_1 = require("../swappers");
+const assets_1 = require("../swappers/utils/test-data/assets");
+const zrxEthereumSwapperDeps = {
+    web3: {},
+    adapter: {
+        getChainId: () => types_1.KnownChainIds.EthereumMainnet,
+    },
+};
+const getZrxEthereumSwapper = () => new swappers_1.ZrxSwapper(zrxEthereumSwapperDeps);
+exports.getZrxEthereumSwapper = getZrxEthereumSwapper;
+const zrxAvalancheSwapperDeps = {
+    web3: {},
+    adapter: {
+        getChainId: () => types_1.KnownChainIds.AvalancheMainnet,
+    },
+};
+const getZrxAvalancheSwapper = () => new swappers_1.ZrxSwapper(zrxAvalancheSwapperDeps);
+exports.getZrxAvalancheSwapper = getZrxAvalancheSwapper;
+const cowSwapperDeps = {
+    apiUrl: 'https://api.cow.fi/mainnet/api/',
+    adapter: {
+        getChainId: () => types_1.KnownChainIds.EthereumMainnet,
+    },
+    web3: {},
+};
+const getCowSwapper = () => new swappers_1.CowSwapper(cowSwapperDeps);
+exports.getCowSwapper = getCowSwapper;
+const thorchainSwapperDeps = {
+    midgardUrl: '',
+    daemonUrl: '',
+    adapterManager: {},
+    web3: {},
+};
+const getThorchainSwapper = () => new swappers_1.ThorchainSwapper(thorchainSwapperDeps);
+exports.getThorchainSwapper = getThorchainSwapper;
+exports.tradeQuote = {
+    minimumCryptoHuman: '60',
+    maximum: '1000000000000000000000',
+    sellAmountBeforeFeesCryptoBaseUnit: '1000000000000000000000',
+    allowanceContract: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+    buyAmountCryptoBaseUnit: '23448326921811747',
+    feeData: {
+        chainSpecific: {
+            estimatedGas: '100000',
+            approvalFeeCryptoBaseUnit: '700000',
+            gasPriceCryptoBaseUnit: '7',
+        },
+        buyAssetTradeFeeUsd: '7.656',
+        sellAssetTradeFeeUsd: '0',
+        networkFeeCryptoBaseUnit: '3246750000000000',
+    },
+    rate: '0.00002509060972289251',
+    sources: [{ name: api_1.SwapperName.Thorchain, proportion: '1' }],
+    buyAsset: assets_1.ETH,
+    sellAsset: assets_1.FOX,
+    accountNumber: 0,
+};
+exports.goodTradeQuote = {
+    ...exports.tradeQuote,
+    buyAmountCryptoBaseUnit: '23000000000000000',
+    feeData: {
+        chainSpecific: {
+            estimatedGas: '100000',
+            approvalFeeCryptoBaseUnit: '700000',
+            gasPriceCryptoBaseUnit: '7',
+        },
+        buyAssetTradeFeeUsd: '7.656',
+        sellAssetTradeFeeUsd: '0',
+        networkFeeCryptoBaseUnit: '3246750000000000',
+    },
+    buyAsset: assets_1.WETH,
+};
+exports.badTradeQuote = {
+    ...exports.tradeQuote,
+    buyAmountCryptoBaseUnit: '21000000000000000',
+    feeData: {
+        chainSpecific: {
+            estimatedGas: '100000',
+            approvalFeeCryptoBaseUnit: '700000',
+            gasPriceCryptoBaseUnit: '7',
+        },
+        buyAssetTradeFeeUsd: '10.656',
+        sellAssetTradeFeeUsd: '4',
+        networkFeeCryptoBaseUnit: '3446750000000000',
+    },
+    buyAsset: assets_1.WETH,
+};

package/dist/manager/utils.d.ts

@@ -0,0 +1,4 @@
+import { Asset } from '@shapeshiftoss/asset-service';
+import { ChainId } from '@shapeshiftoss/caip';
+import { Swapper, TradeQuote } from '../api';
+export declare const getRatioFromQuote: (quote: TradeQuote<ChainId>, swapper: Swapper<ChainId>, feeAsset: Asset) => Promise<number | undefined>;

package/dist/manager/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRatioFromQuote = void 0;
+const bignumber_1 = require("../swappers/utils/bignumber");
+const typeGuards_1 = require("../typeGuards");
+/*
+  The ratio is calculated by dividing the total fiat value of the receive amount
+  by the total fiat value of the sell amount (including network fees).
+
+  Higher ratios are better.
+
+  E.g. if the fiat value of the sell amount is 100 and the fiat value of the receive amount is 90,
+  the ratio is 0.9.
+
+  Negative ratios are possible when the fees exceed the sell amount.
+  This is allowed to let us choose 'the best from a bad bunch'.
+*/
+const getRatioFromQuote = async (quote, swapper, feeAsset) => {
+    /*
+      We make an assumption here that swappers return comparable asset rates.
+      If a swapper were to undervalue the outbound asset and overvalue the inbound asset
+      then the ratio would be incorrectly in its favour.
+    */
+    const quoteAssets = [quote.sellAsset, quote.buyAsset, feeAsset];
+    const usdRatePromises = quoteAssets.map((asset) => swapper.getUsdRate(asset));
+    const [sellAssetUsdRate, buyAssetUsdRate, feeAssetUsdRate] = (await Promise.allSettled(usdRatePromises))
+        .filter(typeGuards_1.isFulfilled)
+        .map((p) => p.value);
+    const totalSellAmountFiat = (0, bignumber_1.bnOrZero)((0, bignumber_1.fromBaseUnit)(quote.sellAmountBeforeFeesCryptoBaseUnit, quote.sellAsset.precision))
+        .times(sellAssetUsdRate)
+        .plus((0, bignumber_1.bnOrZero)(quote.feeData.sellAssetTradeFeeUsd));
+    const totalReceiveAmountFiat = (0, bignumber_1.bnOrZero)((0, bignumber_1.fromBaseUnit)(quote.buyAmountCryptoBaseUnit, quote.buyAsset.precision))
+        .times(buyAssetUsdRate)
+        .minus((0, bignumber_1.bnOrZero)(quote.feeData.buyAssetTradeFeeUsd));
+    const networkFeeFiat = (0, bignumber_1.bnOrZero)((0, bignumber_1.fromBaseUnit)(quote.feeData.networkFeeCryptoBaseUnit, feeAsset.precision)).times(feeAssetUsdRate);
+    const totalSendAmountFiat = totalSellAmountFiat.plus(networkFeeFiat);
+    const ratio = totalReceiveAmountFiat.div(totalSendAmountFiat);
+    return ratio.isFinite() ? ratio.toNumber() : undefined;
+};
+exports.getRatioFromQuote = getRatioFromQuote;

package/dist/swappercli.js

@@ -15,6 +15,7 @@ const adapters_1 = require("./adapters");
 const manager_1 = require("./manager");
 const swappers_1 = require("./swappers");
 const bignumber_1 = require("./swappers/utils/bignumber");
+const setupSwapQuote_1 = require("./swappers/utils/test-data/setupSwapQuote");
 dotenv_1.default.config();
 const { ETH_NODE_URL = 'http://localhost:3000', MIDGARD_URL = 'https://dev-indexer.thorchain.shapeshift.com/v2', DEVICE_ID = 'device123', MNEMONIC = 'all all all all all all all all all all all all', } = process.env;
 const toBaseUnit = (amount, precision) => {
@@ -91,9 +92,22 @@ const main = async () => {
     const tc = new swappers_1.ThorchainSwapper(tcDeps);
     await tc.initialize();
     swapManager.addSwapper(tc);
+    const ethereumAsset = {
+        assetId: caip_1.ethAssetId,
+        chainId: caip_1.ethChainId,
+        symbol: 'ETH',
+        name: 'Ethereum',
+        precision: 18,
+        color: '#5C6BC0',
+        icon: 'https://assets.coincap.io/assets/icons/256/eth.png',
+        explorer: 'https://etherscan.io',
+        explorerAddressLink: 'https://etherscan.io/address/',
+        explorerTxLink: 'https://etherscan.io/tx/',
+    };
+    const { quoteInput } = (0, setupSwapQuote_1.setupQuote)();
     const swapper = await swapManager.getBestSwapper({
-        sellAssetId: sellAsset.assetId,
-        buyAssetId: buyAsset.assetId,
+        ...quoteInput,
+        feeAsset: ethereumAsset,
     });
     console.info(`using swapper ${swapper === null || swapper === void 0 ? void 0 : swapper.getType()}`);
     if (!swapper) {

package/dist/typeGuards.d.ts

@@ -0,0 +1,2 @@
+export declare const isFulfilled: <T>(promise: PromiseSettledResult<T>) => promise is PromiseFulfilledResult<T>;
+export declare const isRejected: <T>(promise: PromiseSettledResult<T>) => promise is PromiseRejectedResult;

package/dist/typeGuards.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRejected = exports.isFulfilled = void 0;
+const isFulfilled = (promise) => promise.status === 'fulfilled';
+exports.isFulfilled = isFulfilled;
+const isRejected = (promise) => promise.status === 'rejected';
+exports.isRejected = isRejected;

package/package.json

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