@shapeshiftoss/swapper 11.1.3 → 11.2.0

package/dist/adapters.d.ts

@@ -0,0 +1,2 @@
+import { ChainAdapterManager } from '@shapeshiftoss/chain-adapters';
+export declare const getAdapterManager: () => ChainAdapterManager;

package/dist/adapters.js

@@ -0,0 +1,94 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdapterManager = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const types_1 = require("@shapeshiftoss/types");
+const unchained = __importStar(require("@shapeshiftoss/unchained-client"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const { UNCHAINED_ETH_HTTPS_API = 'http://localhost:31300', UNCHAINED_ETH_WS_API = 'wss://localhost:31300', UNCHAINED_BTC_HTTPS_API = 'http://localhost:31300', UNCHAINED_BTC_WS_API = 'wss://localhost:31300', UNCHAINED_LTC_HTTPS_API = 'http://localhost:31300', UNCHAINED_LTC_WS_API = 'wss://localhost:31300', UNCHAINED_RUNE_HTTPS_API = 'http://localhost:31300', UNCHAINED_RUNE_WS_API = 'wss://localhost:31300', UNCHAINED_ATOM_HTTPS_API = 'http://localhost:31300', UNCHAINED_ATOM_WS_API = 'wss://localhost:31300', ETH_NODE_URL = 'http://localhost:31300', } = process.env;
+const getAdapterManager = () => {
+    const ethChainAdapter = new chain_adapters_1.ethereum.ChainAdapter({
+        providers: {
+            ws: new unchained.ws.Client(UNCHAINED_ETH_WS_API),
+            http: new unchained.ethereum.V1Api(new unchained.ethereum.Configuration({
+                basePath: UNCHAINED_ETH_HTTPS_API,
+            })),
+        },
+        rpcUrl: ETH_NODE_URL,
+    });
+    const btcAdapterArgs = {
+        coinName: 'bitcoin',
+        providers: {
+            ws: new unchained.ws.Client(UNCHAINED_BTC_WS_API),
+            http: new unchained.bitcoin.V1Api(new unchained.bitcoin.Configuration({
+                basePath: UNCHAINED_BTC_HTTPS_API,
+            })),
+        },
+    };
+    const bitcoinChainAdapter = new chain_adapters_1.bitcoin.ChainAdapter(btcAdapterArgs);
+    const ltcAdapterArgs = {
+        coinName: 'litecoin',
+        providers: {
+            ws: new unchained.ws.Client(UNCHAINED_LTC_WS_API),
+            http: new unchained.bitcoin.V1Api(new unchained.bitcoin.Configuration({
+                basePath: UNCHAINED_LTC_HTTPS_API,
+            })),
+        },
+    };
+    const litecoinChainAdapter = new chain_adapters_1.bitcoin.ChainAdapter(ltcAdapterArgs);
+    const runeAdapterArgs = {
+        coinName: 'rune',
+        providers: {
+            ws: new unchained.ws.Client(UNCHAINED_RUNE_WS_API),
+            http: new unchained.thorchain.V1Api(new unchained.thorchain.Configuration({
+                basePath: UNCHAINED_RUNE_HTTPS_API,
+            })),
+        },
+    };
+    const thorchainChainAdapter = new chain_adapters_1.thorchain.ChainAdapter(runeAdapterArgs);
+    const cosmosAdapterArgs = {
+        coinName: 'atom',
+        providers: {
+            ws: new unchained.ws.Client(UNCHAINED_ATOM_WS_API),
+            http: new unchained.thorchain.V1Api(new unchained.thorchain.Configuration({
+                basePath: UNCHAINED_ATOM_HTTPS_API,
+            })),
+        },
+    };
+    const cosmosChainAdapter = new chain_adapters_1.cosmos.ChainAdapter(cosmosAdapterArgs);
+    const adapterManager = new Map();
+    adapterManager.set(types_1.KnownChainIds.BitcoinMainnet, bitcoinChainAdapter);
+    adapterManager.set(types_1.KnownChainIds.EthereumMainnet, ethChainAdapter);
+    adapterManager.set(types_1.KnownChainIds.ThorchainMainnet, thorchainChainAdapter);
+    adapterManager.set(types_1.KnownChainIds.LitecoinMainnet, litecoinChainAdapter);
+    adapterManager.set(types_1.KnownChainIds.CosmosMainnet, cosmosChainAdapter);
+    return adapterManager;
+};
+exports.getAdapterManager = getAdapterManager;

package/dist/api.d.ts

@@ -74,6 +74,7 @@ export declare type SupportedSellAssetsInput = {
     assetIds: AssetId[];
 };
 declare type CommonTradeInput = {
+    bip44Params?: BIP44Params;
     sellAsset: Asset;
     buyAsset: Asset;
     sellAmount: string;
@@ -82,7 +83,7 @@ declare type CommonTradeInput = {
     receiveAddress: string;
 };
 export declare type EvmSupportedChainIds = KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet;
-export declare type CosmosSdkSupportedChainIds = KnownChainIds.CosmosMainnet | KnownChainIds.OsmosisMainnet;
+export declare type CosmosSdkSupportedChainIds = KnownChainIds.CosmosMainnet | KnownChainIds.OsmosisMainnet | KnownChainIds.ThorchainMainnet;
 export declare type EvmSupportedChainAdapters = ethereum.ChainAdapter | avalanche.ChainAdapter;
 export declare type CosmosSdkSupportedChainAdapters = cosmos.ChainAdapter | osmosis.ChainAdapter;
 export declare type UtxoSupportedChainIds = KnownChainIds.BitcoinMainnet | KnownChainIds.DogecoinMainnet | KnownChainIds.LitecoinMainnet | KnownChainIds.BitcoinCashMainnet;

package/dist/swappercli.js

@@ -1,44 +1,22 @@
 "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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const asset_service_1 = require("@shapeshiftoss/asset-service");
+const caip_1 = require("@shapeshiftoss/caip");
 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 adapters_1 = require("./adapters");
 const SwapperManager_1 = require("./manager/SwapperManager");
+const swappers_1 = require("./swappers");
 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;
+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) => {
     return new bignumber_js_1.default(amount)
         .multipliedBy(new bignumber_js_1.default(10).exponentiatedBy(new bignumber_js_1.default(precision)))
@@ -62,7 +40,7 @@ const getWallet = async () => {
 const main = async () => {
     const [, , ...args] = process.argv;
     const [sellSymbol, buySymbol, sellAmount] = args;
-    console.info(`sellSymbol: sell ${sellAmount} of ${sellSymbol} to ${buySymbol}`);
+    console.info(`sell ${sellAmount} of ${sellSymbol} to ${buySymbol}`);
     if (!sellAmount || !sellSymbol || !buySymbol) {
         console.error(`
       Usage:
@@ -82,64 +60,119 @@ const main = async () => {
         console.error(`No asset ${buySymbol} found in asset service`);
         return;
     }
+    const adapterManager = (0, adapters_1.getAdapterManager)();
+    const ethAdapter = adapterManager.get(caip_1.ethChainId);
+    if (!ethAdapter) {
+        throw new Error('no ethAdapter');
+    }
+    const sellAdapter = adapterManager.get(sellAsset.chainId);
+    if (!sellAdapter) {
+        throw new Error(`no sellAdapter ${sellAsset.chainId}`);
+    }
+    const buyAdapter = adapterManager.get(buyAsset.chainId);
+    if (!buyAdapter) {
+        throw new Error(`no buyAdapter ${buyAsset.chainId}`);
+    }
     // Swapper Deps
     const wallet = await getWallet();
-    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, adapter: ethChainAdapter, web3 };
-    const manager = new SwapperManager_1.SwapperManager();
+    const zrxSwapperDeps = {
+        wallet,
+        adapter: ethAdapter,
+        web3,
+    };
+    const swapManager = new SwapperManager_1.SwapperManager();
     const zrxSwapper = new ZrxSwapper_1.ZrxSwapper(zrxSwapperDeps);
-    manager.addSwapper(zrxSwapper);
-    const swapper = await manager.getBestSwapper({
-        sellAssetId: 'eip155:1/slip44:60',
-        buyAssetId: 'eip155:1/erc20:0xc770eefad204b5180df6a14ee197d99d808ee52d',
+    swapManager.addSwapper(zrxSwapper);
+    const tcDeps = { midgardUrl: MIDGARD_URL, web3, adapterManager };
+    const tc = new swappers_1.ThorchainSwapper(tcDeps);
+    await tc.initialize();
+    swapManager.addSwapper(tc);
+    const swapper = await swapManager.getBestSwapper({
+        sellAssetId: sellAsset.assetId,
+        buyAssetId: buyAsset.assetId,
     });
-    if (!swapper)
+    console.info(`using swapper ${swapper === null || swapper === void 0 ? void 0 : swapper.getType()}`);
+    if (!swapper) {
+        console.warn(`no swapper found for specified assets`);
         return;
+    }
+    if (sellAdapter == undefined || sellAdapter == null) {
+        throw new Error('huh');
+    }
+    let utxoAccountType;
+    if (sellAdapter.getSupportedAccountTypes) {
+        utxoAccountType = chain_adapters_1.bitcoin.ChainAdapter.defaultUtxoAccountType;
+    }
+    const bip44Params = sellAdapter.getBIP44Params({
+        accountNumber: 0,
+        accountType: utxoAccountType,
+    });
+    if (!bip44Params) {
+        throw new Error('falsy bip44Params');
+    }
+    const { chainNamespace: sellChainNamespace } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    switch (sellChainNamespace) {
+        case caip_1.CHAIN_NAMESPACE.Evm:
+        case caip_1.CHAIN_NAMESPACE.Utxo:
+        case caip_1.CHAIN_NAMESPACE.CosmosSdk:
+    }
+    let publicKey;
+    if (sellChainNamespace == caip_1.CHAIN_NAMESPACE.Utxo) {
+        if (!utxoAccountType) {
+            throw new Error('utxoAccountType must be defined');
+        }
+        publicKey = await sellAdapter.getPublicKey(wallet, bip44Params, utxoAccountType);
+    }
     const sellAmountBase = toBaseUnit(sellAmount, sellAsset.precision);
+    const buyAssetReceiveAddr = await buyAdapter.getAddress({
+        wallet,
+        accountType: utxoAccountType,
+        bip44Params,
+    });
+    console.info(`${buyAsset.name} using receive addr ${buyAssetReceiveAddr}`);
     let quote;
     try {
         quote = await swapper.getTradeQuote({
-            chainId: types_1.KnownChainIds.EthereumMainnet,
+            chainId: sellAsset.chainId,
             sellAsset,
             buyAsset,
             sellAmount: sellAmountBase,
             sellAssetAccountNumber: 0,
             sendMax: false,
-            receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+            accountType: utxoAccountType || chain_adapters_1.bitcoin.ChainAdapter.defaultUtxoAccountType,
+            bip44Params,
+            xpub: (publicKey === null || publicKey === void 0 ? void 0 : publicKey.xpub) || '',
+            receiveAddress: buyAssetReceiveAddr,
         });
     }
     catch (e) {
         console.error(e);
+        return;
     }
     if (!quote) {
+        console.warn('no quote returned');
         return;
     }
-    console.info('quote = ', JSON.stringify(quote));
     const buyAmount = fromBaseUnit(quote.buyAmount || '0', buyAsset.precision);
     const answer = readline_sync_1.default.question(`Swap ${sellAmount} ${sellAsset.symbol} for ${buyAmount} ${buyAsset.symbol} on ${swapper.getType()}? (y/n): `);
     if (answer === 'y') {
         const trade = await swapper.buildTrade({
-            chainId: types_1.KnownChainIds.EthereumMainnet,
+            chainId: sellAsset.chainId,
             wallet,
             buyAsset,
             sendMax: false,
             sellAmount: sellAmountBase,
             sellAsset,
             sellAssetAccountNumber: 0,
-            receiveAddress: '0xc770eefad204b5180df6a14ee197d99d808ee52d',
+            receiveAddress: buyAssetReceiveAddr,
+            accountType: utxoAccountType || chain_adapters_1.bitcoin.ChainAdapter.defaultUtxoAccountType,
+            bip44Params,
+            xpub: (publicKey === null || publicKey === void 0 ? void 0 : publicKey.xpub) || '',
         });
-        const txid = await swapper.executeTrade({ trade, wallet });
-        console.info('broadcast tx with id: ', txid);
+        const tradeResult = await swapper.executeTrade({ trade, wallet });
+        console.info('broadcast tx with id: ', tradeResult.tradeId);
     }
 };
 main().then(() => console.info('Done'));

package/dist/swappers/thorchain/ThorchainSwapper.js

@@ -58,6 +58,7 @@ class ThorchainSwapper {
                 acc.push(assetId);
                 return acc;
             }, []);
+            this.supportedSellAssetIds.push(caip_1.thorchainAssetId);
             this.supportedBuyAssetIds = responseData.reduce((acc, midgardPool) => {
                 const assetId = caip_1.adapters.poolAssetIdToAssetId(midgardPool.asset);
                 if (!assetId || !this.buySupportedChainIds[(0, caip_1.fromAssetId)(assetId).chainId])
@@ -65,6 +66,7 @@ class ThorchainSwapper {
                 acc.push(assetId);
                 return acc;
             }, []);
+            this.supportedBuyAssetIds.push(caip_1.thorchainAssetId);
         }
         catch (e) {
             throw new api_1.SwapError('[thorchainInitialize]: initialize failed to set supportedAssetIds', {
@@ -163,8 +165,11 @@ class ThorchainSwapper {
                 ? tradeResult.tradeId.slice(2)
                 : tradeResult.tradeId;
             const { data: responseData } = await thorService_1.thorService.get(`${this.deps.midgardUrl}/actions?txid=${midgardTxid}`);
+            // https://gitlab.com/thorchain/thornode/-/blob/develop/common/tx.go#L22
+            // responseData?.actions[0].out[0].txID should be the txId for consistency, but the outbound Tx for Thor rune swaps is actually a BlankTxId
+            // so we use the buyTxId for completion detection
             const buyTxid = ((_a = responseData === null || responseData === void 0 ? void 0 : responseData.actions[0]) === null || _a === void 0 ? void 0 : _a.status) === 'success' && ((_b = responseData === null || responseData === void 0 ? void 0 : responseData.actions[0]) === null || _b === void 0 ? void 0 : _b.type) === 'swap'
-                ? responseData === null || responseData === void 0 ? void 0 : responseData.actions[0].out[0].txID
+                ? midgardTxid
                 : '';
             // This will detect all the errors I have seen.
             if (((_c = responseData === null || responseData === void 0 ? void 0 : responseData.actions[0]) === null || _c === void 0 ? void 0 : _c.status) === 'success' &&

package/dist/swappers/thorchain/buildThorTrade/buildThorTrade.js

@@ -12,7 +12,7 @@ const makeTradeTx_1 = require("../utils/ethereum/makeTradeTx");
 const buildTrade = async ({ deps, input, }) => {
     var _a, _b, _c, _d;
     try {
-        const { buyAsset, sellAsset, sellAssetAccountNumber, sellAmount, wallet, slippage: slippageTolerance = constants_1.DEFAULT_SLIPPAGE, receiveAddress: destinationAddress, } = input;
+        const { bip44Params, buyAsset, receiveAddress: destinationAddress, sellAmount, sellAsset, sellAssetAccountNumber, slippage: slippageTolerance = constants_1.DEFAULT_SLIPPAGE, wallet, } = input;
         const quote = await (0, getTradeQuote_1.getThorTradeQuote)({ deps, input });
         const sellAdapter = deps.adapterManager.get(sellAsset.chainId);
         if (!sellAdapter)
@@ -78,7 +78,11 @@ const buildTrade = async ({ deps, input, }) => {
             };
         }
         else if (chainNamespace === caip_1.CHAIN_NAMESPACE.CosmosSdk) {
+            if (!bip44Params) {
+                throw new Error('bip44Params required as input');
+            }
             const txData = await (0, cosmosTxData_1.cosmosTxData)({
+                bip44Params,
                 deps,
                 sellAdapter: sellAdapter,
                 sellAmount,
@@ -111,6 +115,7 @@ const buildTrade = async ({ deps, input, }) => {
         throw new api_1.SwapError('[buildTrade]: error building trade', {
             code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED,
             fn: 'buildTrade',
+            cause: e,
         });
     }
 };

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

@@ -17,7 +17,7 @@ const MINIMUM_USD_TRADE_AMOUNT = (0, bignumber_1.bn)(1);
 const getThorTradeQuote = async ({ deps, input }) => {
     const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, chainId, receiveAddress } = input;
     try {
-        const { assetReference: sellAssetErc20Address } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+        const { assetReference: sellAssetReference } = (0, caip_1.fromAssetId)(sellAsset.assetId);
         const sellAdapter = deps.adapterManager.get(chainId);
         if (!sellAdapter)
             throw new api_1.SwapError(`[getThorTradeQuote] - No chain adapter found for ${chainId}.`, {
@@ -62,7 +62,7 @@ const getThorTradeQuote = async ({ deps, input }) => {
                     });
                     const feeData = await (0, getEthTxFees_1.getEthTxFees)({
                         adapterManager: deps.adapterManager,
-                        sellAssetReference: sellAssetErc20Address,
+                        sellAssetReference,
                         tradeFee,
                     });
                     return {

package/dist/swappers/thorchain/utils/cosmos/cosmosTxData.d.ts

@@ -3,9 +3,11 @@ import { ChainId } from '@shapeshiftoss/caip';
 import { ChainAdapter } from '@shapeshiftoss/chain-adapters';
 import { HDWallet } from '@shapeshiftoss/hdwallet-core';
 import { KnownChainIds } from '@shapeshiftoss/types';
+import { BIP44Params } from '@shapeshiftoss/types';
 import { TradeQuote } from '../../../../api';
 import { ThorchainSwapperDeps } from '../../types';
 export declare const cosmosTxData: (input: {
+    bip44Params: BIP44Params;
     destinationAddress: string;
     deps: ThorchainSwapperDeps;
     sellAmount: string;

package/dist/swappers/thorchain/utils/cosmos/cosmosTxData.js

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosmosTxData = void 0;
+const types_1 = require("@shapeshiftoss/types");
 const api_1 = require("../../../../api");
 const getLimit_1 = require("../getLimit/getLimit");
 const makeSwapMemo_1 = require("../makeSwapMemo/makeSwapMemo");
 const thorService_1 = require("../thorService");
 const cosmosTxData = async (input) => {
-    const { deps, destinationAddress, sellAmount, sellAsset, buyAsset, slippageTolerance, quote, wallet, sellAdapter, } = input;
+    const { bip44Params, deps, destinationAddress, sellAmount, sellAsset, buyAsset, slippageTolerance, quote, wallet, sellAdapter, } = input;
+    const fromThorAsset = sellAsset.chainId == types_1.KnownChainIds.ThorchainMainnet;
     const { data: inboundAddresses } = await thorService_1.thorService.get(`${deps.midgardUrl}/thorchain/inbound_addresses`);
     const atomInboundAddresses = inboundAddresses.find((inbound) => inbound.chain === 'GAIA');
     const vault = atomInboundAddresses === null || atomInboundAddresses === void 0 ? void 0 : atomInboundAddresses.address;
-    if (!vault)
+    if (!vault && !fromThorAsset)
         throw new api_1.SwapError('[buildTrade]: no vault for chain', {
             code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED,
             fn: 'buildTrade',
@@ -31,7 +33,25 @@ const cosmosTxData = async (input) => {
         destinationAddress,
         limit,
     });
+    if (fromThorAsset) {
+        const buildTxResponse = await sellAdapter.buildDepositTransaction({
+            bip44Params,
+            value: sellAmount,
+            wallet,
+            memo,
+            gas: quote.feeData.chainSpecific.estimatedGas,
+            fee: quote.feeData.fee,
+        });
+        return buildTxResponse.txToSign;
+    }
+    if (!vault)
+        throw new api_1.SwapError('[buildTrade]: no vault for chain', {
+            code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED,
+            fn: 'buildTrade',
+            details: { chainId: input.chainId },
+        });
     const buildTxResponse = await sellAdapter.buildSendTransaction({
+        bip44Params,
         value: sellAmount,
         wallet,
         to: vault,

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

@@ -5,8 +5,13 @@ const caip_1 = require("@shapeshiftoss/caip");
 const api_1 = require("../../../../api");
 const constants_1 = require("../constants");
 const getPriceRatio_1 = require("../getPriceRatio/getPriceRatio");
+const isRune_1 = require("../isRune/isRune");
 const thorService_1 = require("../thorService");
+// TODO rename this estimateOutboundFee or similar
 const estimateTradeFee = async (deps, buyAsset) => {
+    if ((0, isRune_1.isRune)(buyAsset.assetId)) {
+        return '0.02'; // todo - read from TC mimir/constants
+    }
     const thorId = caip_1.adapters.assetIdToPoolAssetId({ assetId: buyAsset.assetId });
     if (!thorId)
         throw new api_1.SwapError('[estimateTradeFee] - undefined thorId for given buyAssetId', {

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

@@ -4,8 +4,8 @@ exports.getTradeRate = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 const api_1 = require("../../../../api");
 const bignumber_1 = require("../../../utils/bignumber");
-const bignumber_2 = require("../../../utils/bignumber");
 const getPriceRatio_1 = require("../getPriceRatio/getPriceRatio");
+const isRune_1 = require("../isRune/isRune");
 const thorService_1 = require("../thorService");
 const THOR_PRECISION = 8;
 const getSwapOutput = (inputAmount, poolData, toRune) => {
@@ -33,33 +33,74 @@ const getTradeRate = async (sellAsset, buyAssetId, sellAmount, deps) => {
     }
     const buyPoolId = caip_1.adapters.assetIdToPoolAssetId({ assetId: buyAssetId });
     const sellPoolId = caip_1.adapters.assetIdToPoolAssetId({ assetId: sellAsset.assetId });
-    if (!buyPoolId || !sellPoolId)
-        throw new api_1.SwapError(`[getPriceRatio]: No thorchain pool found`, {
+    if (!buyPoolId && !(0, isRune_1.isRune)(buyAssetId)) {
+        throw new api_1.SwapError(`[getTradeRate]: No buyPoolId for asset ${buyAssetId}`, {
             code: api_1.SwapErrorTypes.POOL_NOT_FOUND,
-            fn: 'getPriceRatio',
-            details: { buyPoolId, sellPoolId },
+            fn: 'getTradeRate',
+            details: { buyAssetId },
         });
+    }
+    if (!sellPoolId && !(0, isRune_1.isRune)(sellAsset.assetId)) {
+        throw new api_1.SwapError(`[getTradeRate]: No sellPoolId for asset ${sellAsset.assetId}`, {
+            code: api_1.SwapErrorTypes.POOL_NOT_FOUND,
+            fn: 'getTradeRate',
+            details: { sellAsset: sellAsset.assetId },
+        });
+    }
     const { data: responseData } = await thorService_1.thorService.get(`${deps.midgardUrl}/pools`);
-    const buyPool = responseData.find((response) => response.asset === buyPoolId);
-    const sellPool = responseData.find((response) => response.asset === sellPoolId);
-    if (!buyPool || !sellPool)
-        throw new api_1.SwapError(`[getPriceRatio]: no pools found for`, {
+    const buyPool = buyPoolId && responseData.find((response) => response.asset === buyPoolId);
+    const sellPool = sellPoolId && responseData.find((response) => response.asset === sellPoolId);
+    if (buyPoolId && !buyPool) {
+        throw new api_1.SwapError(`[getTradeRate]: No buyPool for poolId ${buyPoolId}`, {
             code: api_1.SwapErrorTypes.POOL_NOT_FOUND,
-            fn: 'getPriceRatio',
-            details: { buyPoolId, sellPoolId },
+            fn: 'getTradeRate',
+            details: { buyPoolId },
         });
+    }
+    if (sellPoolId && !sellPool) {
+        throw new api_1.SwapError(`[getTradeRate]: No sellPool for poolId ${sellPoolId}`, {
+            code: api_1.SwapErrorTypes.POOL_NOT_FOUND,
+            fn: 'getTradeRate',
+            details: { sellPoolId },
+        });
+    }
     // All thorchain pool amounts are base 8 regardless of token precision
-    const sellBaseAmount = (0, bignumber_1.bn)((0, bignumber_2.toBaseUnit)((0, bignumber_2.fromBaseUnit)(sellAmount, sellAsset.precision), THOR_PRECISION));
-    const sellAssetPoolData = {
-        assetBalance: (0, bignumber_1.bn)(sellPool.assetDepth),
-        runeBalance: (0, bignumber_1.bn)(sellPool.runeDepth),
-    };
-    const buyAssetPoolData = {
-        assetBalance: (0, bignumber_1.bn)(buyPool.assetDepth),
-        runeBalance: (0, bignumber_1.bn)(buyPool.runeDepth),
-    };
-    const outputAmountBase8 = getDoubleSwapOutput(sellBaseAmount, sellAssetPoolData, buyAssetPoolData);
-    const outputAmount = (0, bignumber_2.fromBaseUnit)(outputAmountBase8, THOR_PRECISION);
-    return (0, bignumber_1.bn)(outputAmount).div((0, bignumber_2.fromBaseUnit)(sellAmount, sellAsset.precision)).toString();
+    const sellBaseAmount = (0, bignumber_1.bn)((0, bignumber_1.toBaseUnit)((0, bignumber_1.fromBaseUnit)(sellAmount, sellAsset.precision), THOR_PRECISION));
+    const doubleSwap = buyPool != undefined && sellPool != undefined;
+    const toRune = buyAssetId === caip_1.thorchainAssetId;
+    const outputAmountBase8 = (() => {
+        if (doubleSwap && sellPool && buyPool) {
+            const sellAssetPoolData = {
+                assetBalance: (0, bignumber_1.bn)(sellPool.assetDepth),
+                runeBalance: (0, bignumber_1.bn)(sellPool.runeDepth),
+            };
+            const buyAssetPoolData = {
+                assetBalance: (0, bignumber_1.bn)(buyPool.assetDepth),
+                runeBalance: (0, bignumber_1.bn)(buyPool.runeDepth),
+            };
+            return getDoubleSwapOutput(sellBaseAmount, sellAssetPoolData, buyAssetPoolData);
+        }
+        else {
+            const poolData = sellPool
+                ? {
+                    assetBalance: (0, bignumber_1.bn)(sellPool.assetDepth),
+                    runeBalance: (0, bignumber_1.bn)(sellPool.runeDepth),
+                }
+                : buyPool && {
+                    assetBalance: (0, bignumber_1.bn)(buyPool.assetDepth),
+                    runeBalance: (0, bignumber_1.bn)(buyPool.runeDepth),
+                };
+            if (!poolData) {
+                throw new api_1.SwapError(`[getPriceRatio]: No pool data for rune swap`, {
+                    code: api_1.SwapErrorTypes.POOL_NOT_FOUND,
+                    fn: 'getPriceRatio',
+                    details: { buyAssetId, sellAsset, buyPool, sellPool },
+                });
+            }
+            return getSwapOutput(sellBaseAmount, poolData, toRune);
+        }
+    })();
+    const outputAmount = (0, bignumber_1.fromBaseUnit)(outputAmountBase8, THOR_PRECISION);
+    return (0, bignumber_1.bn)(outputAmount).div((0, bignumber_1.fromBaseUnit)(sellAmount, sellAsset.precision)).toString();
 };
 exports.getTradeRate = getTradeRate;

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

@@ -3,19 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUsdRate = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
 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;
     try {
-        const thorchainPoolId = caip_1.adapters.assetIdToPoolAssetId({ assetId });
+        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}`, {
                 code: api_1.SwapErrorTypes.USD_RATE_FAILED,
             });
         const { data: responseData } = await thorService_1.thorService.get(`${deps.midgardUrl}/pool/${thorchainPoolId}`);
-        const rate = responseData === null || responseData === void 0 ? void 0 : responseData.assetPriceUSD;
+        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 found`, {
+            throw new api_1.SwapError(`[getUsdRate]: No rate for ${assetId}`, {
                 code: api_1.SwapErrorTypes.USD_RATE_FAILED,
             });
         return rate;

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

@@ -0,0 +1,2 @@
+import { AssetId } from '@shapeshiftoss/caip';
+export declare const isRune: (assetId: AssetId) => boolean;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRune = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const isRune = (assetId) => assetId === caip_1.thorchainAssetId;
+exports.isRune = isRune;

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

@@ -6,12 +6,15 @@ const api_1 = require("../../../../api");
 const constants_1 = require("../constants");
 // BTC (and likely other utxo coins) can only support up to 80 character memos
 const MAX_LENGTH = 80;
+// use symbol of thor Asset?
+const runeThorId = 'RUNE';
 /**
  * @returns thorchain memo shortened to a max of 80 characters as described:
  * https://dev.thorchain.org/thorchain-dev/memos#mechanism-for-transaction-intent
  */
 const makeSwapMemo = ({ buyAssetId, destinationAddress, limit, }) => {
-    const thorId = caip_1.adapters.assetIdToPoolAssetId({ assetId: buyAssetId });
+    const isRune = buyAssetId === caip_1.thorchainAssetId;
+    const thorId = isRune ? runeThorId : caip_1.adapters.assetIdToPoolAssetId({ assetId: buyAssetId });
     if (!thorId)
         throw new api_1.SwapError('[makeSwapMemo] - undefined thorId for given buyAssetId', {
             code: api_1.SwapErrorTypes.MAKE_MEMO_FAILED,

package/dist/swappers/utils/test-data/setupSwapQuote.d.ts

@@ -10,6 +10,7 @@ export declare const setupQuote: () => {
 };
 export declare const setupBuildTrade: () => {
     buildTradeInput: {
+        bip44Params?: import("@shapeshiftoss/types").BIP44Params | undefined;
         sellAsset: Asset;
         buyAsset: Asset;
         sellAmount: string;

package/package.json

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