@shapeshiftoss/swapper 6.2.0 → 7.0.0

package/dist/api.d.ts

@@ -1,6 +1,6 @@
-import { AssetId } from '@shapeshiftoss/caip';
+import { AssetId, ChainId } from '@shapeshiftoss/caip';
 import { BTCSignTx, ETHSignTx, HDWallet } from '@shapeshiftoss/hdwallet-core';
-import { Asset, ChainSpecific, SupportedChainIds } from '@shapeshiftoss/types';
+import { Asset, ChainSpecific, KnownChainIds } from '@shapeshiftoss/types';
 export declare const SwapError: {
     new <V extends {
         cause?: unknown;
@@ -23,10 +23,7 @@ export declare const SwapError: {
     prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
     stackTraceLimit: number;
 };
-export declare type SupportedAssetInput = {
-    assetIds: AssetId[];
-};
-declare type ChainSpecificQuoteFeeData<T1> = ChainSpecific<T1, {
+declare type ChainSpecificQuoteFeeData<T extends ChainId> = ChainSpecific<T, {
     'eip155:1': {
         estimatedGas?: string;
         gasPrice?: string;
@@ -38,10 +35,10 @@ declare type ChainSpecificQuoteFeeData<T1> = ChainSpecific<T1, {
         satsPerByte: string;
     };
 }>;
-export declare type QuoteFeeData<T1 extends SupportedChainIds> = {
+export declare type QuoteFeeData<T extends ChainId> = {
     fee: string;
     tradeFee: string;
-} & ChainSpecificQuoteFeeData<T1>;
+} & ChainSpecificQuoteFeeData<T>;
 export declare type ByPairInput = {
     sellAssetId: AssetId;
     buyAssetId: AssetId;
@@ -58,15 +55,16 @@ export declare type CommonTradeInput = {
     buyAsset: Asset;
     sellAmount: string;
     sendMax: boolean;
-    sellAssetAccountId: string;
+    sellAssetAccountNumber: number;
+    wallet?: HDWallet;
 };
 export declare type GetTradeQuoteInput = CommonTradeInput;
 export declare type BuildTradeInput = CommonTradeInput & {
-    buyAssetAccountId: string;
+    buyAssetAccountNumber: number;
     slippage?: string;
     wallet: HDWallet;
 };
-interface TradeBase<C extends SupportedChainIds> {
+interface TradeBase<C extends ChainId> {
     buyAmount: string;
     sellAmount: string;
     feeData: QuoteFeeData<C>;
@@ -74,41 +72,41 @@ interface TradeBase<C extends SupportedChainIds> {
     sources: Array<SwapSource>;
     buyAsset: Asset;
     sellAsset: Asset;
-    sellAssetAccountId: string;
+    sellAssetAccountNumber: number;
 }
-export interface TradeQuote<C extends SupportedChainIds> extends TradeBase<C> {
+export interface TradeQuote<C extends ChainId> extends TradeBase<C> {
     allowanceContract: string;
     minimum: string;
     maximum: string;
 }
-export interface Trade<C extends SupportedChainIds> extends TradeBase<C> {
+export interface Trade<C extends ChainId> extends TradeBase<C> {
     receiveAddress: string;
 }
-export interface ZrxTrade<C extends SupportedChainIds> extends Trade<C> {
+export interface ZrxTrade extends Trade<'eip155:1'> {
     txData: string;
     depositAddress: string;
 }
-export interface BtcThorTrade<C extends SupportedChainIds> extends Trade<C> {
-    chainId: 'bip122:000000000019d6689c085ae165831e93';
+export interface BtcThorTrade<C extends ChainId> extends Trade<C> {
+    chainId: KnownChainIds.BitcoinMainnet;
     txData: BTCSignTx;
 }
-export interface EthThorTrade<C extends SupportedChainIds> extends Trade<C> {
-    chainId: 'eip155:1';
+export interface EthThorTrade<C extends ChainId> extends Trade<C> {
+    chainId: KnownChainIds.EthereumMainnet;
     txData: ETHSignTx;
 }
-export declare type ThorTrade<C extends SupportedChainIds> = BtcThorTrade<C> | EthThorTrade<C>;
-export declare type ExecuteTradeInput<C extends SupportedChainIds> = {
+export declare type ThorTrade<C extends ChainId> = BtcThorTrade<C> | EthThorTrade<C>;
+export declare type ExecuteTradeInput<C extends ChainId> = {
     trade: Trade<C>;
     wallet: HDWallet;
 };
 export declare type TradeResult = {
     tradeId: string;
 };
-export declare type ApproveInfiniteInput<C extends SupportedChainIds> = {
+export declare type ApproveInfiniteInput<C extends ChainId> = {
     quote: TradeQuote<C>;
     wallet: HDWallet;
 };
-export declare type ApprovalNeededInput<C extends SupportedChainIds> = {
+export declare type ApprovalNeededInput<C extends ChainId> = {
     quote: TradeQuote<C>;
     wallet: HDWallet;
 };
@@ -158,7 +156,7 @@ export declare enum SwapErrorTypes {
     PRICE_RATIO_FAILED = "PRICE_RATIO_FAILED",
     POOL_NOT_FOUND = "POOL_NOT_FOUND"
 }
-export interface Swapper {
+export interface Swapper<T extends ChainId, TxType = unknown> {
     /** perform any necessary async initialization */
     initialize(): Promise<void>;
     /** Returns the swapper type */
@@ -166,11 +164,11 @@ export interface Swapper {
     /**
      * Get builds a trade with definitive rate & txData that can be executed with executeTrade
      **/
-    buildTrade(args: BuildTradeInput): Promise<Trade<SupportedChainIds>>;
+    buildTrade(args: BuildTradeInput): Promise<Trade<T>>;
     /**
      * Get a trade quote
      */
-    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<SupportedChainIds>>;
+    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<T>>;
     /**
      * Get the usd rate from either the assets symbol or tokenId
      */
@@ -178,15 +176,15 @@ export interface Swapper {
     /**
      * Execute a trade built with buildTrade by signing and broadcasting
      */
-    executeTrade(args: ExecuteTradeInput<SupportedChainIds>): Promise<TradeResult>;
+    executeTrade(args: ExecuteTradeInput<T>): Promise<TradeResult>;
     /**
      * Get a boolean if a quote needs approval
      */
-    approvalNeeded(args: ApprovalNeededInput<SupportedChainIds>): Promise<ApprovalNeededOutput>;
+    approvalNeeded(args: ApprovalNeededInput<T>): Promise<ApprovalNeededOutput>;
     /**
      * Get the txid of an approve infinite transaction
      */
-    approveInfinite(args: ApproveInfiniteInput<SupportedChainIds>): Promise<string>;
+    approveInfinite(args: ApproveInfiniteInput<T>): Promise<string>;
     /**
      * Get supported buyAssetId's by sellAssetId
      */
@@ -195,6 +193,6 @@ export interface Swapper {
      * Get supported sell assetIds
      */
     filterAssetIdsBySellable(assetIds: AssetId[]): AssetId[];
-    getTradeTxs(tradeResult: TradeResult): Promise<TradeTxs>;
+    getTradeTxs(tradeResult: TradeResult): Promise<TxType>;
 }
 export {};

package/dist/manager/SwapperManager.d.ts

@@ -1,7 +1,8 @@
+import { ChainId } from '@shapeshiftoss/caip';
 import { BuyAssetBySellIdInput, ByPairInput, SupportedSellAssetsInput, Swapper } from '..';
 import { SwapperType } from '../api';
 export declare class SwapperManager {
-    swappers: Map<SwapperType, Swapper>;
+    swappers: Map<SwapperType, Swapper<ChainId>>;
     constructor();
     /**
      *
@@ -9,27 +10,27 @@ export declare class SwapperManager {
      * @param swapperInstance swapper instance {Swapper}
      * @returns {SwapperManager}
      */
-    addSwapper(swapperType: SwapperType, swapperInstance: Swapper): this;
+    addSwapper(swapperType: SwapperType, swapperInstance: Swapper<ChainId>): this;
     /**
      *
      * @param swapperType swapper type {SwapperType|string}
      * @returns {Swapper}
      * @deprecated this will be removed, currently used in swapper tests
      */
-    getSwapper(swapperType: SwapperType): Swapper;
+    getSwapper(swapperType: SwapperType): Swapper<ChainId>;
     /**
      *
      * @param swapperType swapper type {SwapperType|string}
      * @returns {SwapperManager}
      */
     removeSwapper(swapperType: SwapperType): this;
-    getBestSwapper(args: ByPairInput): Promise<Swapper | undefined>;
+    getBestSwapper(args: ByPairInput): Promise<Swapper<ChainId> | undefined>;
     /**
      *
      * @param pair type {GetQuoteInput}
      * @returns {SwapperType}
      */
-    getSwappersByPair(pair: ByPairInput): Swapper[];
-    getSupportedBuyAssetIdsFromSellId(args: BuyAssetBySellIdInput): string[];
-    getSupportedSellableAssetIds(args: SupportedSellAssetsInput): string[];
+    getSwappersByPair(pair: ByPairInput): Swapper<ChainId>[];
+    getSupportedBuyAssetIdsFromSellId(args: BuyAssetBySellIdInput): import("@shapeshiftoss/caip").AssetId[];
+    getSupportedSellableAssetIds(args: SupportedSellAssetsInput): import("@shapeshiftoss/caip").AssetId[];
 }

package/dist/swappercli.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,14 +29,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const asset_service_1 = require("@shapeshiftoss/asset-service");
 const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
 const hdwallet_native_1 = require("@shapeshiftoss/hdwallet-native");
-const types_1 = require("@shapeshiftoss/types");
+const unchained = __importStar(require("@shapeshiftoss/unchained-client"));
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const dotenv_1 = __importDefault(require("dotenv"));
 const readline_sync_1 = __importDefault(require("readline-sync"));
 const web3_1 = __importDefault(require("web3"));
 const api_1 = require("./api");
 const SwapperManager_1 = require("./manager/SwapperManager");
-const ThorchainSwapper_1 = require("./swappers/thorchain/ThorchainSwapper");
 const ZrxSwapper_1 = require("./swappers/zrx/ZrxSwapper");
 dotenv_1.default.config();
 const { UNCHAINED_HTTP_API = 'http://localhost:31300', UNCHAINED_WS_API = 'wss://localhost:31300', ETH_NODE_URL = 'http://localhost:3000', DEVICE_ID = 'device123', MNEMONIC = 'all all all all all all all all all all all all' } = process.env;
@@ -62,26 +84,21 @@ const main = async () => {
     }
     // Swapper Deps
     const wallet = await getWallet();
-    const unchainedUrls = {
-        [types_1.ChainTypes.Ethereum]: {
-            httpUrl: UNCHAINED_HTTP_API,
-            wsUrl: UNCHAINED_WS_API
-        }
-    };
-    const adapterManager = new chain_adapters_1.ChainAdapterManager(unchainedUrls);
+    const ethChainAdapter = new chain_adapters_1.ethereum.ChainAdapter({
+        providers: {
+            ws: new unchained.ws.Client(UNCHAINED_WS_API),
+            http: new unchained.ethereum.V1Api(new unchained.ethereum.Configuration({
+                basePath: UNCHAINED_HTTP_API
+            }))
+        },
+        rpcUrl: 'https://mainnet.infura.io/v3/d734c7eebcdf400185d7eb67322a7e57'
+    });
     const web3Provider = new web3_1.default.providers.HttpProvider(ETH_NODE_URL);
     const web3 = new web3_1.default(web3Provider);
-    const zrxSwapperDeps = { wallet, adapterManager, web3 };
-    const thorchainSwapperDeps = {
-        midgardUrl: 'https://midgard.thorchain.info/v2',
-        adapterManager: {}
-    };
+    const zrxSwapperDeps = { wallet, adapter: ethChainAdapter, web3 };
     const manager = new SwapperManager_1.SwapperManager();
     const zrxSwapper = new ZrxSwapper_1.ZrxSwapper(zrxSwapperDeps);
-    const thorchainSwapper = new ThorchainSwapper_1.ThorchainSwapper(thorchainSwapperDeps);
-    await thorchainSwapper.initialize();
     manager.addSwapper(api_1.SwapperType.Zrx, zrxSwapper);
-    manager.addSwapper(api_1.SwapperType.Thorchain, thorchainSwapper);
     const swapper = await manager.getBestSwapper({
         sellAssetId: 'eip155:1/slip44:60',
         buyAssetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d'
@@ -95,7 +112,8 @@ const main = async () => {
             sellAsset,
             buyAsset,
             sellAmount: sellAmountBase,
-            sellAssetAccountId: '0',
+            sellAssetAccountNumber: 0,
+            wallet,
             sendMax: false
         });
     }
@@ -115,8 +133,8 @@ const main = async () => {
             sendMax: false,
             sellAmount: sellAmountBase,
             sellAsset,
-            sellAssetAccountId: '0',
-            buyAssetAccountId: '0'
+            sellAssetAccountNumber: 0,
+            buyAssetAccountNumber: 0
         });
         const txid = await swapper.executeTrade({ trade, wallet });
         console.info('broadcast tx with id: ', txid);

package/dist/swappers/cow/CowSwapper.d.ts

@@ -1,21 +1,21 @@
-import { AssetId } from '@shapeshiftoss/caip';
-import { Asset, SupportedChainIds } from '@shapeshiftoss/types';
+import { AssetId, ChainId } from '@shapeshiftoss/caip';
+import { Asset } from '@shapeshiftoss/types';
 import { ApprovalNeededInput, ApprovalNeededOutput, ApproveInfiniteInput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
 export declare type CowSwapperDeps = {
     apiUrl: string;
 };
-export declare class CowSwapper implements Swapper {
+export declare class CowSwapper implements Swapper<ChainId> {
     static swapperName: string;
     deps: CowSwapperDeps;
     constructor(deps: CowSwapperDeps);
     initialize(): Promise<void>;
     getType(): SwapperType;
-    buildTrade(args: BuildTradeInput): Promise<Trade<SupportedChainIds>>;
-    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<SupportedChainIds>>;
+    buildTrade(args: BuildTradeInput): Promise<Trade<ChainId>>;
+    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<ChainId>>;
     getUsdRate(input: Asset): Promise<string>;
-    executeTrade(args: ExecuteTradeInput<SupportedChainIds>): Promise<TradeResult>;
-    approvalNeeded(args: ApprovalNeededInput<SupportedChainIds>): Promise<ApprovalNeededOutput>;
-    approveInfinite(args: ApproveInfiniteInput<SupportedChainIds>): Promise<string>;
+    executeTrade(args: ExecuteTradeInput<ChainId>): Promise<TradeResult>;
+    approvalNeeded(args: ApprovalNeededInput<ChainId>): Promise<ApprovalNeededOutput>;
+    approveInfinite(args: ApproveInfiniteInput<ChainId>): Promise<string>;
     filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): AssetId[];
     filterAssetIdsBySellable(assetIds: AssetId[]): AssetId[];
     getTradeTxs(): Promise<TradeTxs>;

package/dist/swappers/test/TestSwapper.d.ts

@@ -1,11 +1,11 @@
-import { AssetId } from '@shapeshiftoss/caip';
-import { Asset, SupportedChainIds } from '@shapeshiftoss/types';
+import { AssetId, ChainId } from '@shapeshiftoss/caip';
+import { Asset } from '@shapeshiftoss/types';
 import { ApprovalNeededOutput, BuyAssetBySellIdInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
 /**
  * Playground for testing different scenarios of multiple swappers in the manager.
  * Meant for local testing only
  */
-export declare class TestSwapper implements Swapper {
+export declare class TestSwapper implements Swapper<ChainId> {
     supportAssets: string[];
     initialize(): Promise<void>;
     getType(): SwapperType;
@@ -15,8 +15,8 @@ export declare class TestSwapper implements Swapper {
     approveInfinite(): Promise<string>;
     filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): AssetId[];
     filterAssetIdsBySellable(): AssetId[];
-    buildTrade(): Promise<Trade<SupportedChainIds>>;
-    getTradeQuote(): Promise<TradeQuote<SupportedChainIds>>;
+    buildTrade(): Promise<Trade<ChainId>>;
+    getTradeQuote(): Promise<TradeQuote<ChainId>>;
     executeTrade(): Promise<TradeResult>;
     getTradeTxs(): Promise<TradeTxs>;
 }

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

@@ -1,8 +1,8 @@
-import { AssetId } from '@shapeshiftoss/caip';
-import { Asset, SupportedChainIds } from '@shapeshiftoss/types';
-import { ApprovalNeededOutput, BuyAssetBySellIdInput, ExecuteTradeInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
+import { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import { ApprovalNeededOutput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
 import { ThorchainSwapperDeps } from './types';
-export declare class ThorchainSwapper implements Swapper {
+export declare class ThorchainSwapper implements Swapper<ChainId> {
     private swapSupportedChainIds;
     private supportedAssetIds;
     deps: ThorchainSwapperDeps;
@@ -14,8 +14,8 @@ export declare class ThorchainSwapper implements Swapper {
     approveInfinite(): Promise<string>;
     filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): AssetId[];
     filterAssetIdsBySellable(): AssetId[];
-    buildTrade(): Promise<Trade<SupportedChainIds>>;
-    getTradeQuote(): Promise<TradeQuote<SupportedChainIds>>;
-    executeTrade(args: ExecuteTradeInput<SupportedChainIds>): Promise<TradeResult>;
+    buildTrade(): Promise<Trade<ChainId>>;
+    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<ChainId>>;
+    executeTrade(args: ExecuteTradeInput<ChainId>): Promise<TradeResult>;
     getTradeTxs(): Promise<TradeTxs>;
 }

package/dist/swappers/thorchain/ThorchainSwapper.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThorchainSwapper = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const api_1 = require("../../api");
+const getTradeQuote_1 = require("./getThorTradeQuote/getTradeQuote");
 const getUsdRate_1 = require("./utils/getUsdRate/getUsdRate");
 const thorService_1 = require("./utils/thorService");
 class ThorchainSwapper {
@@ -55,15 +56,18 @@ class ThorchainSwapper {
     async buildTrade() {
         throw new Error('ThorchainSwapper: buildTrade unimplemented');
     }
-    async getTradeQuote() {
-        throw new Error('ThorchainSwapper: getTradeQuote unimplemented');
+    async getTradeQuote(input) {
+        return (0, getTradeQuote_1.getThorTradeQuote)({ deps: this.deps, input });
     }
     async executeTrade(args) {
         const { trade, wallet } = args;
-        const adapter = await this.deps.adapterManager.byChainId(trade.sellAsset.chainId);
-        if (trade.sellAsset.chainId === 'eip155:1') {
+        const adapter = this.deps.adapterManager.get(trade.sellAsset.chainId);
+        if (adapter && trade.sellAsset.chainId === 'eip155:1') {
             const thorTradeEth = trade;
-            const signedTx = await adapter.signTransaction({ txToSign: thorTradeEth.txData, wallet });
+            const signedTx = await adapter.signTransaction({
+                txToSign: thorTradeEth.txData,
+                wallet
+            });
             const txid = await adapter.broadcastTransaction(signedTx);
             return { tradeId: txid };
         }

package/dist/swappers/thorchain/getThorTradeQuote/getTradeQuote.d.ts

@@ -0,0 +1,7 @@
+import { ChainId } from '@shapeshiftoss/caip';
+import { GetTradeQuoteInput, TradeQuote } from '../../../api';
+import { ThorchainSwapperDeps } from '../types';
+export declare const getThorTradeQuote: ({ deps, input }: {
+    deps: ThorchainSwapperDeps;
+    input: GetTradeQuoteInput;
+}) => Promise<TradeQuote<ChainId>>;

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThorTradeQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const api_1 = require("../../../api");
+const bignumber_1 = require("../../utils/bignumber");
+const constants_1 = require("../../utils/constants");
+const helpers_1 = require("../../utils/helpers/helpers");
+const constants_2 = require("../utils/constants");
+const getThorTxData_1 = require("../utils/ethereum/utils/getThorTxData");
+const getPriceRatio_1 = require("../utils/getPriceRatio/getPriceRatio");
+const getEthTxFees_1 = require("../utils/txFeeHelpers/ethTxFees/getEthTxFees");
+const getThorTradeQuote = async ({ deps, input }) => {
+    const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, wallet } = input;
+    if (!wallet)
+        throw new api_1.SwapError('[getTradeQuote] - wallet is required', {
+            code: api_1.SwapErrorTypes.VALIDATION_FAILED
+        });
+    try {
+        const { assetReference: sellAssetErc20Address, chainReference, chainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const isErc20Trade = sellAssetErc20Address.startsWith('0x');
+        const sellAssetChainId = (0, caip_1.toChainId)({ chainReference, chainNamespace });
+        const adapter = deps.adapterManager.get(sellAssetChainId);
+        if (!adapter)
+            throw new api_1.SwapError(`[getThorTxInfo] - No chain adapter found for ${sellAssetChainId}.`, {
+                code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
+                details: { sellAssetChainId }
+            });
+        const bip44Params = adapter.buildBIP44Params({ accountNumber: Number(sellAssetAccountNumber) });
+        const receiveAddress = await adapter.getAddress({ wallet, bip44Params });
+        const { data, router } = await (0, getThorTxData_1.getThorTxInfo)({
+            deps,
+            sellAsset,
+            buyAsset,
+            sellAmount,
+            slippageTolerance: constants_1.DEFAULT_SLIPPAGE,
+            destinationAddress: receiveAddress,
+            isErc20Trade
+        });
+        const feeData = await (async () => {
+            switch (sellAssetChainId) {
+                case 'eip155:1':
+                    return await (0, getEthTxFees_1.getEthTxFees)({
+                        deps,
+                        data,
+                        router,
+                        buyAsset,
+                        sellAmount,
+                        adapterManager: deps.adapterManager,
+                        receiveAddress,
+                        sellAssetReference: sellAssetErc20Address
+                    });
+                default:
+                    throw new api_1.SwapError('[getThorTxInfo] - Asset chainId is not supported.', {
+                        code: api_1.SwapErrorTypes.UNSUPPORTED_CHAIN,
+                        details: { sellAssetChainId }
+                    });
+            }
+        })();
+        const sellAssetId = sellAsset.assetId;
+        const buyAssetId = buyAsset.assetId;
+        const feeAssetId = (0, caip_1.getFeeAssetIdFromAssetId)(buyAssetId);
+        if (!feeAssetId)
+            throw new api_1.SwapError(`[getThorTxInfo] - No feeAssetId found for ${buyAssetId}.`, {
+                code: api_1.SwapErrorTypes.VALIDATION_FAILED,
+                details: { buyAssetId }
+            });
+        const feeAssetRatio = await (0, getPriceRatio_1.getPriceRatio)(deps, { sellAssetId, buyAssetId: feeAssetId });
+        const priceRatio = await (0, getPriceRatio_1.getPriceRatio)(deps, { sellAssetId, buyAssetId });
+        const rate = (0, bignumber_1.bnOrZero)(1).div(priceRatio).toString();
+        const buyAmount = (0, helpers_1.normalizeAmount)((0, bignumber_1.bnOrZero)(sellAmount).times(rate));
+        const sellAssetTradeFee = (0, bignumber_1.bnOrZero)(feeData.tradeFee).times((0, bignumber_1.bnOrZero)(feeAssetRatio));
+        // padding minimum by 1.5 the trade fee to avoid thorchain "not enough to cover fee" errors.
+        const minimum = (0, bignumber_1.fromBaseUnit)(sellAssetTradeFee.times(1.5).toString(), sellAsset.precision);
+        return {
+            rate,
+            minimum,
+            maximum: constants_2.MAX_THORCHAIN_TRADE,
+            feeData,
+            sellAmount,
+            buyAmount,
+            sources: [{ name: 'thorchain', proportion: '1' }],
+            allowanceContract: router,
+            buyAsset,
+            sellAsset,
+            sellAssetAccountNumber
+        };
+    }
+    catch (e) {
+        if (e instanceof api_1.SwapError)
+            throw e;
+        throw new api_1.SwapError('[getThorTradeQuote]', {
+            cause: e,
+            code: api_1.SwapErrorTypes.TRADE_QUOTE_FAILED
+        });
+    }
+};
+exports.getThorTradeQuote = getThorTradeQuote;

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

@@ -0,0 +1 @@
+export declare const MAX_THORCHAIN_TRADE = "100000000000000000000000000";

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_THORCHAIN_TRADE = void 0;
+exports.MAX_THORCHAIN_TRADE = '100000000000000000000000000';

package/dist/swappers/thorchain/utils/ethereum/makeTradeTx.d.ts

@@ -1,10 +1,7 @@
 import { ethereum } from '@shapeshiftoss/chain-adapters';
 import { ETHSignTx, HDWallet } from '@shapeshiftoss/hdwallet-core';
 import { Asset, BIP44Params } from '@shapeshiftoss/types';
-import BigNumber from 'bignumber.js';
 import { ThorchainSwapperDeps } from '../../types';
-export declare const fromBaseUnit: (value: BigNumber.Value, decimals: number, displayDecimals?: number) => string;
-export declare const toBaseUnit: (amount: BigNumber.Value | undefined, precision: number) => string;
 export declare const makeTradeTx: ({ wallet, bip44Params, sellAmount, buyAsset, sellAsset, destinationAddress, adapter, maxFeePerGas, maxPriorityFeePerGas, slippageTolerance, deps, gasLimit }: {
     wallet: HDWallet;
     bip44Params: BIP44Params;

package/dist/swappers/thorchain/utils/ethereum/makeTradeTx.js

@@ -1,63 +1,22 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeTradeTx = exports.toBaseUnit = exports.fromBaseUnit = void 0;
+exports.makeTradeTx = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const api_1 = require("../../../../api");
-const bignumber_1 = require("../../../utils/bignumber");
-const getPriceRatio_1 = require("../getPriceRatio/getPriceRatio");
-const makeSwapMemo_1 = require("../makeSwapMemo/makeSwapMemo");
-const thorService_1 = require("../thorService");
-const routerCalldata_1 = require("./routerCalldata");
-const fromBaseUnit = (value, decimals, displayDecimals = 6) => {
-    return (0, bignumber_1.bnOrZero)(value)
-        .div(`1e+${decimals}`)
-        .decimalPlaces(displayDecimals, bignumber_js_1.default.ROUND_DOWN)
-        .toString();
-};
-exports.fromBaseUnit = fromBaseUnit;
-const toBaseUnit = (amount, precision) => {
-    return (0, bignumber_1.bnOrZero)(amount)
-        .times(new bignumber_js_1.default(10).exponentiatedBy((0, bignumber_1.bnOrZero)(precision)))
-        .toFixed(0);
-};
-exports.toBaseUnit = toBaseUnit;
+const getThorTxData_1 = require("../ethereum/utils/getThorTxData");
 const makeTradeTx = async ({ wallet, bip44Params, sellAmount, buyAsset, sellAsset, destinationAddress, adapter, maxFeePerGas, maxPriorityFeePerGas, slippageTolerance, deps, gasLimit }) => {
     try {
         const { assetReference } = (0, caip_1.fromAssetId)(sellAsset.assetId);
         const isErc20Trade = assetReference.startsWith('0x');
-        const { data: inboundAddresses } = await thorService_1.thorService.get(`${deps.midgardUrl}/thorchain/inbound_addresses`);
-        const ethInboundAddresses = inboundAddresses.find((inbound) => inbound.chain === 'ETH');
-        const vault = ethInboundAddresses === null || ethInboundAddresses === void 0 ? void 0 : ethInboundAddresses.address;
-        const router = ethInboundAddresses === null || ethInboundAddresses === void 0 ? void 0 : ethInboundAddresses.router;
-        if (!vault || !router)
-            throw new api_1.SwapError(`[getPriceRatio]: router or vault found for ETH`, {
-                code: api_1.SwapErrorTypes.RESPONSE_ERROR,
-                details: { inboundAddresses }
-            });
-        const priceRatio = await (0, getPriceRatio_1.getPriceRatio)(deps, {
-            buyAssetId: buyAsset.assetId,
-            sellAssetId: sellAsset.assetId
-        });
-        const expectedBuyAmount = (0, exports.toBaseUnit)((0, exports.fromBaseUnit)((0, bignumber_1.bnOrZero)(sellAmount).dividedBy(priceRatio), sellAsset.precision), buyAsset.precision);
-        if (!(0, bignumber_1.bnOrZero)(expectedBuyAmount).gte(0) ||
-            !((0, bignumber_1.bnOrZero)(slippageTolerance).gte(0) && (0, bignumber_1.bnOrZero)(slippageTolerance).lte(1)))
-            throw new api_1.SwapError('[makeTradeTx]: bad expected buy amount or bad slippage tolerance', {
-                code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED
-            });
-        const limit = (0, bignumber_1.bnOrZero)(expectedBuyAmount)
-            .times(new bignumber_js_1.default(1).minus(slippageTolerance))
-            .decimalPlaces(0)
-            .toString();
-        const memo = (0, makeSwapMemo_1.makeSwapMemo)({
-            buyAssetId: buyAsset.assetId,
+        const { data, router } = await (0, getThorTxData_1.getThorTxInfo)({
+            deps,
+            sellAsset,
+            buyAsset,
+            sellAmount,
+            slippageTolerance,
             destinationAddress,
-            limit
+            isErc20Trade
         });
-        const data = await (0, routerCalldata_1.deposit)(vault, router, isErc20Trade ? assetReference : '0x0000000000000000000000000000000000000000', sellAmount, memo);
         return adapter.buildCustomTx({
             wallet,
             bip44Params,

package/dist/swappers/thorchain/utils/ethereum/utils/getThorTxData.d.ts

@@ -0,0 +1,15 @@
+import { Asset } from '@shapeshiftoss/types';
+import { ThorchainSwapperDeps } from '../../../types';
+export declare const getThorTxInfo: ({ deps, sellAsset, buyAsset, sellAmount, slippageTolerance, destinationAddress, isErc20Trade }: {
+    deps: ThorchainSwapperDeps;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellAmount: string;
+    slippageTolerance: string;
+    destinationAddress: string;
+    isErc20Trade: boolean;
+}) => Promise<{
+    data: any;
+    memo: string;
+    router: string;
+}>;