@shapeshiftoss/swapper 8.3.1 → 8.5.1

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { AssetId, ChainId } from '@shapeshiftoss/caip';
-import { avalanche, ethereum } from '@shapeshiftoss/chain-adapters';
+import { avalanche, cosmos, ethereum, osmosis } from '@shapeshiftoss/chain-adapters';
 import { HDWallet } from '@shapeshiftoss/hdwallet-core';
 import { Asset, BIP44Params, ChainSpecific, KnownChainIds, UtxoAccountType } from '@shapeshiftoss/types';
 export declare const SwapError: {
@@ -67,17 +67,22 @@ declare type CommonTradeInput = {
     receiveAddress: string;
 };
 export declare type EvmSupportedChainIds = KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet;
+export declare type CosmosSdkSupportedChainIds = KnownChainIds.CosmosMainnet | KnownChainIds.OsmosisMainnet;
 export declare type EvmSupportedChainAdapters = ethereum.ChainAdapter | avalanche.ChainAdapter;
+export declare type CosmosSdkSupportedChainAdapters = cosmos.ChainAdapter | osmosis.ChainAdapter;
 export declare type GetEvmTradeQuoteInput = CommonTradeInput & {
     chainId: EvmSupportedChainIds;
 };
+export declare type GetCosmosSdkTradeQuoteInput = CommonTradeInput & {
+    chainId: CosmosSdkSupportedChainIds;
+};
 declare type GetBtcTradeQuoteInput = CommonTradeInput & {
     chainId: KnownChainIds.BitcoinMainnet;
     accountType: UtxoAccountType;
     bip44Params: BIP44Params;
     wallet: HDWallet;
 };
-export declare type GetTradeQuoteInput = GetBtcTradeQuoteInput | GetEvmTradeQuoteInput;
+export declare type GetTradeQuoteInput = GetBtcTradeQuoteInput | GetEvmTradeQuoteInput | GetCosmosSdkTradeQuoteInput;
 export declare type BuildTradeInput = GetTradeQuoteInput & {
     buyAssetAccountNumber: number;
     slippage?: string;
@@ -131,6 +136,7 @@ export declare enum SwapperType {
     ZrxEthereum = "0xEthereum",
     ZrxAvalanche = "0xAvalanche",
     Thorchain = "Thorchain",
+    Osmosis = "Osmosis",
     CowSwap = "CowSwap",
     Test = "Test"
 }

package/dist/api.js

@@ -9,6 +9,7 @@ var SwapperType;
     SwapperType["ZrxEthereum"] = "0xEthereum";
     SwapperType["ZrxAvalanche"] = "0xAvalanche";
     SwapperType["Thorchain"] = "Thorchain";
+    SwapperType["Osmosis"] = "Osmosis";
     SwapperType["CowSwap"] = "CowSwap";
     SwapperType["Test"] = "Test";
 })(SwapperType = exports.SwapperType || (exports.SwapperType = {}));

package/dist/swappers/index.d.ts

@@ -1,4 +1,5 @@
 export * from './zrx/ZrxSwapper';
 export * from './thorchain/ThorchainSwapper';
 export * from './test/TestSwapper';
+export * from './osmosis/OsmosisSwapper';
 export * from './cow/CowSwapper';

package/dist/swappers/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./zrx/ZrxSwapper"), exports);
 __exportStar(require("./thorchain/ThorchainSwapper"), exports);
 __exportStar(require("./test/TestSwapper"), exports);
+__exportStar(require("./osmosis/OsmosisSwapper"), exports);
 __exportStar(require("./cow/CowSwapper"), exports);

package/dist/swappers/osmosis/OsmosisSwapper.d.ts

@@ -0,0 +1,23 @@
+import { AssetId, ChainId } from '@shapeshiftoss/caip';
+import { Asset } from '@shapeshiftoss/types';
+import { ApprovalNeededOutput, BuildTradeInput, BuyAssetBySellIdInput, ExecuteTradeInput, GetTradeQuoteInput, MinMaxOutput, Swapper, SwapperType, Trade, TradeQuote, TradeResult, TradeTxs } from '../../api';
+import { OsmoSwapperDeps } from './utils/types';
+export declare class OsmosisSwapper implements Swapper<ChainId> {
+    readonly name = "Osmosis";
+    supportAssets: string[];
+    deps: OsmoSwapperDeps;
+    getType(): SwapperType;
+    constructor(deps: OsmoSwapperDeps);
+    getTradeTxs(tradeResult: TradeResult): Promise<TradeTxs>;
+    getUsdRate(input: Pick<Asset, 'symbol' | 'assetId'>): Promise<string>;
+    getMinMax(input: {
+        sellAsset: Asset;
+    }): Promise<MinMaxOutput>;
+    approvalNeeded(): Promise<ApprovalNeededOutput>;
+    approveInfinite(): Promise<string>;
+    filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): string[];
+    filterAssetIdsBySellable(): AssetId[];
+    buildTrade(args: BuildTradeInput): Promise<Trade<ChainId>>;
+    getTradeQuote(input: GetTradeQuoteInput): Promise<TradeQuote<ChainId>>;
+    executeTrade({ trade, wallet }: ExecuteTradeInput<ChainId>): Promise<TradeResult>;
+}

package/dist/swappers/osmosis/OsmosisSwapper.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsmosisSwapper = 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");
+class OsmosisSwapper {
+    constructor(deps) {
+        this.name = 'Osmosis';
+        this.deps = deps;
+        this.supportAssets = [caip_1.cosmosAssetId, caip_1.osmosisAssetId];
+    }
+    getType() {
+        return api_1.SwapperType.Osmosis;
+    }
+    async getTradeTxs(tradeResult) {
+        return {
+            sellTxid: tradeResult.tradeId,
+            buyTxid: tradeResult.tradeId
+        };
+    }
+    async getUsdRate(input) {
+        const { symbol } = input;
+        const sellAssetSymbol = symbol;
+        const buyAssetSymbol = 'USDC';
+        const sellAmount = '1';
+        const { rate: osmoRate } = await (0, helpers_1.getRateInfo)('OSMO', buyAssetSymbol, sellAmount, this.deps.osmoUrl);
+        if (sellAssetSymbol !== 'OSMO') {
+            const { rate } = await (0, helpers_1.getRateInfo)(sellAssetSymbol, 'OSMO', sellAmount, this.deps.osmoUrl);
+            return (0, bignumber_1.bnOrZero)(rate).times(osmoRate).toString();
+        }
+        return osmoRate;
+    }
+    async getMinMax(input) {
+        const { sellAsset } = input;
+        const usdRate = await this.getUsdRate({ ...sellAsset });
+        const minimum = (0, bignumber_1.bn)(1).dividedBy((0, bignumber_1.bnOrZero)(usdRate)).toString();
+        const maximum = constants_1.MAX_SWAPPER_SELL;
+        return {
+            minimum,
+            maximum
+        };
+    }
+    async approvalNeeded() {
+        return { approvalNeeded: false };
+    }
+    async approveInfinite() {
+        throw new api_1.SwapError('OsmosisSwapper: approveInfinite unimplemented', {
+            code: api_1.SwapErrorTypes.RESPONSE_ERROR
+        });
+    }
+    filterBuyAssetsBySellAssetId(args) {
+        const { sellAssetId } = args;
+        if (!this.supportAssets.includes(sellAssetId))
+            return [];
+        return this.supportAssets;
+    }
+    filterAssetIdsBySellable() {
+        return this.supportAssets;
+    }
+    async buildTrade(args) {
+        const { sellAsset, buyAsset, sellAmount, receiveAddress } = args;
+        if (!sellAmount) {
+            throw new api_1.SwapError('sellAmount is required', {
+                code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED
+            });
+        }
+        const { tradeFee, rate, buyAmount } = await (0, helpers_1.getRateInfo)(sellAsset.symbol, buyAsset.symbol, sellAmount !== '0' ? sellAmount : '1', this.deps.osmoUrl);
+        //convert amount to base
+        const amountBaseSell = String((0, bignumber_1.bnOrZero)(sellAmount).dp(0));
+        const osmosisAdapter = this.deps.adapterManager.get(caip_1.osmosisChainId);
+        if (!osmosisAdapter)
+            throw new api_1.SwapError('Failed to get Osmosis adapter', {
+                code: api_1.SwapErrorTypes.BUILD_TRADE_FAILED
+            });
+        const feeData = await osmosisAdapter.getFeeData({});
+        const fee = feeData.average.txFee;
+        return {
+            buyAmount,
+            buyAsset,
+            feeData: { fee, tradeFee },
+            rate,
+            receiveAddress,
+            sellAmount: amountBaseSell,
+            sellAsset,
+            sellAssetAccountNumber: 0,
+            sources: [{ name: 'Osmosis', proportion: '100' }]
+        };
+    }
+    async getTradeQuote(input) {
+        const { sellAsset, buyAsset, sellAmount } = input;
+        if (!sellAmount) {
+            throw new api_1.SwapError('sellAmount is required', {
+                code: api_1.SwapErrorTypes.RESPONSE_ERROR
+            });
+        }
+        const { tradeFee, rate, buyAmount } = await (0, helpers_1.getRateInfo)(sellAsset.symbol, buyAsset.symbol, sellAmount !== '0' ? sellAmount : '1', this.deps.osmoUrl);
+        const { minimum, maximum } = await this.getMinMax(input);
+        const osmosisAdapter = this.deps.adapterManager.get(caip_1.osmosisChainId);
+        if (!osmosisAdapter)
+            throw new api_1.SwapError('Failed to get Osmosis adapter', {
+                code: api_1.SwapErrorTypes.TRADE_QUOTE_FAILED
+            });
+        const feeData = await osmosisAdapter.getFeeData({});
+        const fee = feeData.average.txFee;
+        return {
+            buyAsset,
+            feeData: { fee, tradeFee },
+            maximum,
+            minimum,
+            sellAssetAccountNumber: 0,
+            rate,
+            sellAsset,
+            sellAmount,
+            buyAmount,
+            sources: constants_1.DEFAULT_SOURCE,
+            allowanceContract: ''
+        };
+    }
+    async executeTrade({ trade, wallet }) {
+        const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber, receiveAddress } = trade;
+        const isFromOsmo = sellAsset.assetId === caip_1.osmosisAssetId;
+        const sellAssetDenom = helpers_1.symbolDenomMapping[sellAsset.symbol];
+        const buyAssetDenom = helpers_1.symbolDenomMapping[buyAsset.symbol];
+        let ibcSellAmount;
+        const osmosisAdapter = this.deps.adapterManager.get(caip_1.osmosisChainId);
+        const cosmosAdapter = this.deps.adapterManager.get(caip_1.cosmosChainId);
+        if (!cosmosAdapter || !osmosisAdapter) {
+            throw new api_1.SwapError('Failed to get adapters', {
+                code: api_1.SwapErrorTypes.EXECUTE_TRADE_FAILED
+            });
+        }
+        let sellAddress;
+        const feeData = await osmosisAdapter.getFeeData({});
+        const gas = feeData.average.chainSpecific.gasLimit;
+        if (!isFromOsmo) {
+            const sellBip44Params = cosmosAdapter.buildBIP44Params({
+                accountNumber: Number(sellAssetAccountNumber)
+            });
+            sellAddress = await cosmosAdapter.getAddress({ wallet, bip44Params: sellBip44Params });
+            if (!sellAddress)
+                throw new api_1.SwapError('Failed to get address', {
+                    code: api_1.SwapErrorTypes.EXECUTE_TRADE_FAILED
+                });
+            const transfer = {
+                sender: sellAddress,
+                receiver: receiveAddress,
+                amount: sellAmount
+            };
+            const responseAccount = await cosmosAdapter.getAccount(sellAddress);
+            const accountNumber = responseAccount.chainSpecific.accountNumber || '0';
+            const sequence = responseAccount.chainSpecific.sequence || '0';
+            const { tradeId } = await (0, helpers_1.performIbcTransfer)(transfer, cosmosAdapter, wallet, this.deps.osmoUrl, 'uatom', constants_1.COSMO_OSMO_CHANNEL, '0', accountNumber, sequence, gas);
+            // wait till confirmed
+            const pollResult = await (0, helpers_1.pollForComplete)(tradeId, this.deps.cosmosUrl);
+            if (pollResult !== 'success')
+                throw new api_1.SwapError('ibc transfer failed', {
+                    code: api_1.SwapErrorTypes.EXECUTE_TRADE_FAILED
+                });
+            ibcSellAmount = await (0, helpers_1.pollForAtomChannelBalance)(receiveAddress, this.deps.osmoUrl);
+        }
+        else {
+            const sellBip44Params = osmosisAdapter.buildBIP44Params({
+                accountNumber: Number(sellAssetAccountNumber)
+            });
+            sellAddress = await osmosisAdapter.getAddress({ wallet, bip44Params: sellBip44Params });
+            if (!sellAddress)
+                throw new api_1.SwapError('failed to get osmoAddress', {
+                    code: api_1.SwapErrorTypes.EXECUTE_TRADE_FAILED
+                });
+        }
+        const osmoAddress = isFromOsmo ? sellAddress : receiveAddress;
+        const signTxInput = await (0, helpers_1.buildTradeTx)({
+            osmoAddress,
+            adapter: osmosisAdapter,
+            trade,
+            buyAssetDenom,
+            sellAssetDenom,
+            sellAmount: ibcSellAmount !== null && ibcSellAmount !== void 0 ? ibcSellAmount : sellAmount,
+            gas,
+            wallet
+        });
+        const signed = await osmosisAdapter.signTransaction(signTxInput);
+        const tradeId = await osmosisAdapter.broadcastTransaction(signed);
+        if (isFromOsmo) {
+            const pollResult = await (0, helpers_1.pollForComplete)(tradeId, this.deps.osmoUrl);
+            if (pollResult !== 'success')
+                throw new api_1.SwapError('osmo swap failed', {
+                    code: api_1.SwapErrorTypes.EXECUTE_TRADE_FAILED
+                });
+            const amount = await (0, helpers_1.pollForAtomChannelBalance)(sellAddress, this.deps.osmoUrl);
+            const transfer = {
+                sender: sellAddress,
+                receiver: receiveAddress,
+                amount
+            };
+            const ibcResponseAccount = await osmosisAdapter.getAccount(sellAddress);
+            const ibcAccountNumber = ibcResponseAccount.chainSpecific.accountNumber || '0';
+            const ibcSequence = ibcResponseAccount.chainSpecific.sequence || '0';
+            await (0, helpers_1.performIbcTransfer)(transfer, osmosisAdapter, wallet, this.deps.cosmosUrl, buyAssetDenom, constants_1.OSMO_COSMO_CHANNEL, trade.feeData.fee, ibcAccountNumber, ibcSequence, gas);
+        }
+        return { tradeId: tradeId || 'error' };
+    }
+}
+exports.OsmosisSwapper = OsmosisSwapper;

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

@@ -0,0 +1,8 @@
+export declare const DEFAULT_SOURCE: {
+    name: string;
+    proportion: string;
+}[];
+export declare const MAX_SWAPPER_SELL = "100000000000000000000000000";
+export declare const OSMOSIS_PRECISION = 6;
+export declare const COSMO_OSMO_CHANNEL = "channel-141";
+export declare const OSMO_COSMO_CHANNEL = "channel-0";

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OSMO_COSMO_CHANNEL = exports.COSMO_OSMO_CHANNEL = exports.OSMOSIS_PRECISION = exports.MAX_SWAPPER_SELL = exports.DEFAULT_SOURCE = void 0;
+exports.DEFAULT_SOURCE = [{ name: 'Osmosis', proportion: '1' }];
+exports.MAX_SWAPPER_SELL = '100000000000000000000000000';
+exports.OSMOSIS_PRECISION = 6;
+exports.COSMO_OSMO_CHANNEL = 'channel-141';
+exports.OSMO_COSMO_CHANNEL = 'channel-0';

package/dist/swappers/osmosis/utils/helpers.d.ts

@@ -0,0 +1,69 @@
+import { ChainId } from '@shapeshiftoss/caip';
+import { osmosis } from '@shapeshiftoss/chain-adapters';
+import { HDWallet } from '@shapeshiftoss/hdwallet-core';
+import { CosmosSdkSupportedChainAdapters, Trade, TradeResult } from '../../../index';
+import { IbcTransferInput } from './types';
+export interface SymbolDenomMapping {
+    OSMO: string;
+    ATOM: string;
+    USDC: string;
+}
+export declare const symbolDenomMapping: {
+    OSMO: string;
+    ATOM: string;
+    USDC: string;
+};
+export declare const pollForComplete: (txid: string, baseUrl: string) => Promise<string>;
+export declare const getAtomChannelBalance: (address: string, osmoUrl: string) => Promise<number>;
+export declare const pollForAtomChannelBalance: (address: string, osmoUrl: string) => Promise<string>;
+export declare const getRateInfo: (sellAsset: string, buyAsset: string, sellAmount: string, osmoUrl: string) => Promise<{
+    rate: string;
+    priceImpact: string;
+    tradeFee: string;
+    buyAmount: string;
+}>;
+export declare const performIbcTransfer: (input: IbcTransferInput, adapter: CosmosSdkSupportedChainAdapters, wallet: HDWallet, blockBaseUrl: string, denom: string, sourceChannel: string, feeAmount: string, accountNumber: string, sequence: string, gas: string) => Promise<TradeResult>;
+export declare const buildTradeTx: ({ osmoAddress, adapter, trade, buyAssetDenom, sellAssetDenom, sellAmount, gas, wallet }: {
+    osmoAddress: string;
+    adapter: osmosis.ChainAdapter;
+    trade: Trade<ChainId>;
+    buyAssetDenom: string;
+    sellAssetDenom: string;
+    sellAmount: string;
+    gas: string;
+    wallet: HDWallet;
+}) => Promise<{
+    txToSign: {
+        tx: {
+            memo: string;
+            fee: {
+                amount: {
+                    amount: string;
+                    denom: string;
+                }[];
+                gas: string;
+            };
+            signatures: null;
+            msg: {
+                type: string;
+                value: {
+                    sender: string;
+                    routes: {
+                        poolId: string;
+                        tokenOutDenom: string;
+                    }[];
+                    tokenIn: {
+                        denom: string;
+                        amount: string;
+                    };
+                    tokenOutMinAmount: string;
+                };
+            }[];
+        };
+        addressNList: number[];
+        chain_id: "osmosis-1";
+        account_number: string;
+        sequence: string;
+    };
+    wallet: HDWallet;
+}>;

package/dist/swappers/osmosis/utils/helpers.js

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTradeTx = exports.performIbcTransfer = exports.getRateInfo = exports.pollForAtomChannelBalance = exports.getAtomChannelBalance = exports.pollForComplete = exports.symbolDenomMapping = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const hdwallet_core_1 = require("@shapeshiftoss/hdwallet-core");
+const axios_1 = __importDefault(require("axios"));
+const lodash_1 = require("lodash");
+const index_1 = require("../../../index");
+const bignumber_1 = require("../../utils/bignumber");
+const constants_1 = require("./constants");
+exports.symbolDenomMapping = {
+    OSMO: 'uosmo',
+    ATOM: 'ibc/27394FB092D2ECCD56123C74F36E4C1F926001CEADA9CA97EA622B25F41E5EB2',
+    USDC: 'ibc/D189335C6E4A68B513C10AB227BF1C1D38C746766278BA3EEB4FB14124F1D858'
+};
+const txStatus = async (txid, baseUrl) => {
+    var _a, _b, _c;
+    try {
+        const txResponse = await axios_1.default.get(`${baseUrl}/txs/${txid}`);
+        if (!((_a = txResponse === null || txResponse === void 0 ? void 0 : txResponse.data) === null || _a === void 0 ? void 0 : _a.codespace) && !!((_b = txResponse === null || txResponse === void 0 ? void 0 : txResponse.data) === null || _b === void 0 ? void 0 : _b.gas_used))
+            return 'success';
+        if ((_c = txResponse === null || txResponse === void 0 ? void 0 : txResponse.data) === null || _c === void 0 ? void 0 : _c.codespace)
+            return 'failed';
+    }
+    catch (e) {
+        console.error('Failed to get status');
+    }
+    return 'not found';
+};
+// TODO: leverage chain-adapters websockets
+const pollForComplete = async (txid, baseUrl) => {
+    return new Promise((resolve, reject) => {
+        const timeout = 120000; // 2 mins
+        const startTime = Date.now();
+        const interval = 5000; // 5 seconds
+        const poll = async function () {
+            const status = await txStatus(txid, baseUrl);
+            if (status === 'success') {
+                resolve(status);
+            }
+            else if (Date.now() - startTime > timeout) {
+                reject(new index_1.SwapError(`Couldnt find tx ${txid}`, {
+                    code: index_1.SwapErrorTypes.RESPONSE_ERROR
+                }));
+            }
+            else {
+                setTimeout(poll, interval);
+            }
+        };
+        poll();
+    });
+};
+exports.pollForComplete = pollForComplete;
+const getAtomChannelBalance = async (address, osmoUrl) => {
+    const osmoResponseBalance = await (async () => {
+        try {
+            return axios_1.default.get(`${osmoUrl}/bank/balances/${address}`);
+        }
+        catch (e) {
+            throw new index_1.SwapError('failed to get balance', {
+                code: index_1.SwapErrorTypes.RESPONSE_ERROR
+            });
+        }
+    })();
+    let toAtomChannelBalance = 0;
+    try {
+        const { amount } = (0, lodash_1.find)(osmoResponseBalance.data.result, (b) => b.denom === exports.symbolDenomMapping.ATOM);
+        toAtomChannelBalance = Number(amount);
+    }
+    catch (e) {
+        console.error('no channel balance');
+    }
+    return toAtomChannelBalance;
+};
+exports.getAtomChannelBalance = getAtomChannelBalance;
+const pollForAtomChannelBalance = async (address, osmoUrl) => {
+    return new Promise((resolve, reject) => {
+        const timeout = 120000; // 2 mins
+        const startTime = Date.now();
+        const interval = 5000; // 5 seconds
+        const poll = async function () {
+            const balance = await (0, exports.getAtomChannelBalance)(address, osmoUrl);
+            if (balance > 0) {
+                resolve(balance.toString());
+            }
+            else if (Date.now() - startTime > timeout) {
+                reject(new index_1.SwapError(`Couldnt find channel balance for ${address}`, {
+                    code: index_1.SwapErrorTypes.RESPONSE_ERROR
+                }));
+            }
+            else {
+                setTimeout(poll, interval);
+            }
+        };
+        poll();
+    });
+};
+exports.pollForAtomChannelBalance = pollForAtomChannelBalance;
+const findPool = async (sellAssetSymbol, buyAssetSymbol, osmoUrl) => {
+    const sellAssetDenom = exports.symbolDenomMapping[sellAssetSymbol];
+    const buyAssetDenom = exports.symbolDenomMapping[buyAssetSymbol];
+    const poolsUrl = osmoUrl + '/osmosis/gamm/v1beta1/pools?pagination.limit=1000';
+    const poolsResponse = await (async () => {
+        try {
+            return axios_1.default.get(poolsUrl);
+        }
+        catch (e) {
+            throw new index_1.SwapError('failed to get pool', {
+                code: index_1.SwapErrorTypes.POOL_NOT_FOUND
+            });
+        }
+    })();
+    const foundPool = (0, lodash_1.find)(poolsResponse.data.pools, (pool) => {
+        const token0Denom = pool.poolAssets[0].token.denom;
+        const token1Denom = pool.poolAssets[1].token.denom;
+        return ((token0Denom === sellAssetDenom && token1Denom === buyAssetDenom) ||
+            (token0Denom === buyAssetDenom && token1Denom === sellAssetDenom));
+    });
+    if (!foundPool)
+        throw new index_1.SwapError('could not find pool', {
+            code: index_1.SwapErrorTypes.POOL_NOT_FOUND
+        });
+    const { sellAssetIndex, buyAssetIndex } = (() => {
+        if (foundPool.poolAssets[0].token.denom === sellAssetDenom) {
+            return { sellAssetIndex: 0, buyAssetIndex: 1 };
+        }
+        else {
+            return { sellAssetIndex: 1, buyAssetIndex: 0 };
+        }
+    })();
+    return { pool: foundPool, sellAssetIndex, buyAssetIndex };
+};
+const getInfoFromPool = (sellAmount, pool, sellAssetIndex, buyAssetIndex) => {
+    const constantProduct = (0, bignumber_1.bnOrZero)(pool.poolAssets[0].token.amount).times(pool.poolAssets[1].token.amount);
+    const sellAssetInitialPoolSize = (0, bignumber_1.bnOrZero)(pool.poolAssets[sellAssetIndex].token.amount);
+    const buyAssetInitialPoolSize = (0, bignumber_1.bnOrZero)(pool.poolAssets[buyAssetIndex].token.amount);
+    const initialMarketPrice = sellAssetInitialPoolSize.dividedBy(buyAssetInitialPoolSize);
+    const sellAssetFinalPoolSize = sellAssetInitialPoolSize.plus(sellAmount);
+    const buyAssetFinalPoolSize = constantProduct.dividedBy(sellAssetFinalPoolSize);
+    const finalMarketPrice = sellAssetFinalPoolSize.dividedBy(buyAssetFinalPoolSize);
+    const buyAmount = buyAssetInitialPoolSize.minus(buyAssetFinalPoolSize).toString();
+    const rate = (0, bignumber_1.bnOrZero)(buyAmount).dividedBy(sellAmount).toString();
+    const priceImpact = (0, bignumber_1.bn)(1).minus(initialMarketPrice.dividedBy(finalMarketPrice)).abs().toString();
+    const tradeFeeBase = (0, bignumber_1.bnOrZero)(buyAmount).times((0, bignumber_1.bnOrZero)(pool.poolParams.swapFee));
+    const tradeFee = tradeFeeBase.dividedBy((0, bignumber_1.bn)(10).exponentiatedBy(constants_1.OSMOSIS_PRECISION)).toString();
+    return {
+        rate,
+        priceImpact,
+        tradeFee,
+        buyAmount
+    };
+};
+const getRateInfo = async (sellAsset, buyAsset, sellAmount, osmoUrl) => {
+    const { pool, sellAssetIndex, buyAssetIndex } = await findPool(sellAsset, buyAsset, osmoUrl);
+    return getInfoFromPool(sellAmount, pool, sellAssetIndex, buyAssetIndex);
+};
+exports.getRateInfo = getRateInfo;
+// TODO: move to chain adapters
+const performIbcTransfer = async (input, adapter, wallet, blockBaseUrl, denom, sourceChannel, feeAmount, accountNumber, sequence, gas) => {
+    const { sender, receiver, amount } = input;
+    const responseLatestBlock = await (async () => {
+        try {
+            return axios_1.default.get(`${blockBaseUrl}/blocks/latest`);
+        }
+        catch (e) {
+            throw new index_1.SwapError('failed to get latest block', {
+                code: index_1.SwapErrorTypes.RESPONSE_ERROR
+            });
+        }
+    })();
+    const latestBlock = responseLatestBlock.data.block.header.height;
+    const bip44Params = adapter.buildBIP44Params({
+        accountNumber: 0 // TODO: Use real accountNumbers
+    });
+    const path = (0, chain_adapters_1.toPath)(bip44Params);
+    const addressNList = (0, hdwallet_core_1.bip32ToAddressNList)(path);
+    const tx1 = {
+        memo: '',
+        fee: {
+            amount: [
+                {
+                    amount: feeAmount.toString(),
+                    denom: 'uosmo'
+                }
+            ],
+            gas
+        },
+        signatures: null,
+        msg: [
+            {
+                type: 'cosmos-sdk/MsgTransfer',
+                value: {
+                    source_port: 'transfer',
+                    source_channel: sourceChannel,
+                    token: {
+                        denom,
+                        amount
+                    },
+                    sender,
+                    receiver,
+                    timeout_height: {
+                        revision_number: '4',
+                        revision_height: String(Number(latestBlock) + 100)
+                    }
+                }
+            }
+        ]
+    };
+    const signed = await adapter.signTransaction({
+        txToSign: {
+            tx: tx1,
+            addressNList,
+            chain_id: caip_1.CHAIN_REFERENCE.OsmosisMainnet,
+            account_number: accountNumber,
+            sequence
+        },
+        wallet
+    });
+    const tradeId = await adapter.broadcastTransaction(signed);
+    return {
+        tradeId
+    };
+};
+exports.performIbcTransfer = performIbcTransfer;
+// TODO: move to chain adapters
+const buildTradeTx = async ({ osmoAddress, adapter, trade, buyAssetDenom, sellAssetDenom, sellAmount, gas, wallet }) => {
+    const responseAccount = await adapter.getAccount(osmoAddress);
+    const accountNumber = responseAccount.chainSpecific.accountNumber || '0';
+    const sequence = responseAccount.chainSpecific.sequence || '0';
+    const bip44Params = adapter.buildBIP44Params({
+        accountNumber: 0 // TODO: Use real accountNumbers
+    });
+    const path = (0, chain_adapters_1.toPath)(bip44Params);
+    const osmoAddressNList = (0, hdwallet_core_1.bip32ToAddressNList)(path);
+    const tx = {
+        memo: '',
+        fee: {
+            amount: [
+                {
+                    amount: trade.feeData.fee.toString(),
+                    denom: 'uosmo'
+                }
+            ],
+            gas
+        },
+        signatures: null,
+        msg: [
+            {
+                type: 'osmosis/gamm/swap-exact-amount-in',
+                value: {
+                    sender: osmoAddress,
+                    routes: [
+                        {
+                            poolId: '1',
+                            tokenOutDenom: buyAssetDenom
+                        }
+                    ],
+                    tokenIn: {
+                        denom: sellAssetDenom,
+                        amount: sellAmount
+                    },
+                    tokenOutMinAmount: '1' // slippage tolerance
+                }
+            }
+        ]
+    };
+    return {
+        txToSign: {
+            tx,
+            addressNList: osmoAddressNList,
+            chain_id: caip_1.CHAIN_REFERENCE.OsmosisMainnet,
+            account_number: accountNumber,
+            sequence
+        },
+        wallet
+    };
+};
+exports.buildTradeTx = buildTradeTx;

package/dist/swappers/osmosis/utils/types.d.ts

@@ -0,0 +1,22 @@
+import { ChainAdapterManager } from '@shapeshiftoss/chain-adapters';
+export declare type OsmoSwapperDeps = {
+    adapterManager: ChainAdapterManager;
+    osmoUrl: string;
+    cosmosUrl: string;
+};
+export declare type IbcTransferInput = {
+    sender: string;
+    receiver: string;
+    amount: string;
+};
+export declare type PoolInfo = {
+    poolAssets: PoolAssetInfo[];
+    poolParams: {
+        swapFee: string;
+    };
+};
+export declare type PoolAssetInfo = {
+    token: {
+        amount: string;
+    };
+};

package/dist/swappers/osmosis/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/swappers/thorchain/thorTradeApproveInfinite/thorTradeApproveInfinite.js

@@ -4,13 +4,27 @@ exports.thorTradeApproveInfinite = void 0;
 const types_1 = require("@shapeshiftoss/types");
 const api_1 = require("../../../api");
 const erc20_abi_1 = require("../../utils/abi/erc20-abi");
+const constants_1 = require("../../utils/constants");
 const helpers_1 = require("../../utils/helpers/helpers");
-const constants_1 = require("../utils/constants");
+const constants_2 = require("../utils/constants");
 const thorTradeApproveInfinite = async ({ deps, input }) => {
     try {
         const { adapterManager, web3 } = deps;
         const { quote, wallet } = input;
-        const sellAssetChainId = quote.sellAsset.chainId;
+        const approvalQuote = {
+            ...quote,
+            sellAmount: constants_2.MAX_ALLOWANCE,
+            feeData: {
+                ...quote.feeData,
+                chainSpecific: {
+                    ...quote.feeData.chainSpecific,
+                    // Thor approvals are cheaper than trades, but we don't have dynamic quote data for them.
+                    // Instead, we use a hardcoded gasLimit estimate in place of the estimatedGas in the Thor quote response.
+                    estimatedGas: constants_1.APPROVAL_GAS_LIMIT
+                }
+            }
+        };
+        const sellAssetChainId = approvalQuote.sellAsset.chainId;
         const adapter = adapterManager.get(types_1.KnownChainIds.EthereumMainnet);
         if (!adapter)
             throw new api_1.SwapError(`[thorTradeApproveInfinite] - No chain adapter found for ${sellAssetChainId}.`, {
@@ -18,10 +32,7 @@ const thorTradeApproveInfinite = async ({ deps, input }) => {
                 details: { sellAssetChainId }
             });
         const allowanceGrantRequired = await (0, helpers_1.grantAllowance)({
-            quote: {
-                ...quote,
-                sellAmount: constants_1.MAX_ALLOWANCE
-            },
+            quote: approvalQuote,
             wallet,
             adapter,
             erc20Abi: erc20_abi_1.erc20Abi,

package/dist/swappers/zrx/getZrxTradeQuote/getZrxTradeQuote.js

@@ -11,7 +11,6 @@ const constants_2 = require("../utils/constants");
 const helpers_2 = require("../utils/helpers/helpers");
 const zrxService_1 = require("../utils/zrxService");
 async function getZrxTradeQuote(input) {
-    var _a;
     try {
         const { sellAsset, buyAsset, sellAmount, sellAssetAccountNumber } = input;
         if (buyAsset.chainId !== input.chainId || sellAsset.chainId !== input.chainId) {
@@ -46,27 +45,31 @@ async function getZrxTradeQuote(input) {
                 sellAmount: normalizedSellAmount
             }
         });
-        const { data } = quoteResponse;
-        const estimatedGas = (0, bignumber_1.bnOrZero)(data.estimatedGas).times(1.5);
-        const rate = useSellAmount ? data.price : (0, bignumber_1.bn)(1).div(data.price).toString();
+        const { data: { estimatedGas: estimatedGasResponse, gasPrice, price, sellAmount: sellAmountResponse, buyAmount, sources, allowanceTarget } } = quoteResponse;
+        const estimatedGas = (0, bignumber_1.bnOrZero)(estimatedGasResponse).times(1.5);
+        const rate = useSellAmount ? price : (0, bignumber_1.bn)(1).div(price).toString();
+        const fee = (0, bignumber_1.bnOrZero)(estimatedGas).multipliedBy((0, bignumber_1.bnOrZero)(gasPrice)).toString();
+        // 0x approvals are cheaper than trades, but we don't have dynamic quote data for them.
+        // Instead, we use a hardcoded gasLimit estimate in place of the estimatedGas in the 0x quote response.
+        const approvalFee = sellAssetErc20Address &&
+            (0, bignumber_1.bnOrZero)(constants_1.APPROVAL_GAS_LIMIT).multipliedBy((0, bignumber_1.bnOrZero)(gasPrice)).toString();
         return {
             rate,
             minimum,
             maximum,
             feeData: {
-                fee: (0, bignumber_1.bnOrZero)(estimatedGas).multipliedBy((0, bignumber_1.bnOrZero)(data.gasPrice)).toString(),
+                fee,
                 chainSpecific: {
                     estimatedGas: estimatedGas.toString(),
-                    gasPrice: data.gasPrice,
-                    approvalFee: sellAssetErc20Address &&
-                        (0, bignumber_1.bnOrZero)(constants_1.APPROVAL_GAS_LIMIT).multipliedBy((0, bignumber_1.bnOrZero)(data.gasPrice)).toString()
+                    gasPrice,
+                    approvalFee
                 },
                 tradeFee: '0'
             },
-            sellAmount: data.sellAmount,
-            buyAmount: data.buyAmount,
-            sources: ((_a = data.sources) === null || _a === void 0 ? void 0 : _a.filter((s) => parseFloat(s.proportion) > 0)) || constants_2.DEFAULT_SOURCE,
-            allowanceContract: data.allowanceTarget,
+            sellAmount: sellAmountResponse,
+            buyAmount,
+            sources: (sources === null || sources === void 0 ? void 0 : sources.filter((s) => parseFloat(s.proportion) > 0)) || constants_2.DEFAULT_SOURCE,
+            allowanceContract: allowanceTarget,
             buyAsset,
             sellAsset,
             sellAssetAccountNumber

package/dist/swappers/zrx/utils/test-data/setupZrxSwapQuote.d.ts

@@ -18,6 +18,7 @@ export declare const setupExecuteTrade: () => {
         sellAsset: Asset;
         sendMax: boolean;
         sellAssetAccountNumber: number;
+        buyAssetAccountNumber: number;
         txData: string;
         depositAddress: string;
         receiveAddress: string;

package/dist/swappers/zrx/utils/test-data/setupZrxSwapQuote.js

@@ -34,6 +34,7 @@ const setupExecuteTrade = () => {
         sellAsset,
         sendMax: false,
         sellAssetAccountNumber: 0,
+        buyAssetAccountNumber: 0,
         txData: '0x0',
         depositAddress: '0x0',
         receiveAddress: '0x0',

package/dist/swappers/zrx/zrxApproveInfinite/zrxApproveInfinite.js

@@ -3,15 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zrxApproveInfinite = void 0;
 const api_1 = require("../../../api");
 const erc20_abi_1 = require("../../utils/abi/erc20-abi");
+const constants_1 = require("../../utils/constants");
 const helpers_1 = require("../../utils/helpers/helpers");
-const constants_1 = require("../utils/constants");
+const constants_2 = require("../utils/constants");
 async function zrxApproveInfinite({ adapter, web3 }, { quote, wallet }) {
     try {
+        const approvalQuote = {
+            ...quote,
+            sellAmount: constants_2.MAX_ALLOWANCE,
+            feeData: {
+                ...quote.feeData,
+                chainSpecific: {
+                    ...quote.feeData.chainSpecific,
+                    // 0x approvals are cheaper than trades, but we don't have dynamic quote data for them.
+                    // Instead, we use a hardcoded gasLimit estimate in place of the estimatedGas in the 0x quote response.
+                    estimatedGas: constants_1.APPROVAL_GAS_LIMIT
+                }
+            }
+        };
         const allowanceGrantRequired = await (0, helpers_1.grantAllowance)({
-            quote: {
-                ...quote,
-                sellAmount: constants_1.MAX_ALLOWANCE
-            },
+            quote: approvalQuote,
             wallet,
             adapter,
             erc20Abi: erc20_abi_1.erc20Abi,

package/package.json

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