@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/swappers/osmosis/OsmosisSwapper.js

@@ -1,256 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OsmosisSwapper = void 0;
-const caip_1 = require("@shapeshiftoss/caip");
-const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
-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 = api_1.SwapperName.Osmosis;
-        this.deps = deps;
-        this.supportedAssetIds = [caip_1.cosmosAssetId, caip_1.osmosisAssetId];
-    }
-    getType() {
-        return api_1.SwapperType.Osmosis;
-    }
-    async getTradeTxs(tradeResult) {
-        if (tradeResult.cosmosAddress) {
-            const cosmosAdapter = this.deps.adapterManager.get(caip_1.cosmosChainId);
-            if (!cosmosAdapter)
-                throw new api_1.SwapError('OsmosisSwapper: couldnt get cosmos adapter', {
-                    code: api_1.SwapErrorType.GET_TRADE_TXS_FAILED,
-                });
-            const cosmosTxHistory = await cosmosAdapter.getTxHistory({
-                pubkey: tradeResult.cosmosAddress,
-                pageSize: 1,
-            });
-            const currentCosmosTxid = cosmosTxHistory === null || cosmosTxHistory === void 0 ? void 0 : cosmosTxHistory.transactions[0].txid;
-            return {
-                sellTxid: tradeResult.tradeId,
-                // This logic assumes there are the next cosmos tx will be the correct ibc transfer
-                // a random incoming tx COULD cause this logic to fail but its unlikely
-                // TODO find a better solution (may require unchained and parser additions)
-                buyTxid: currentCosmosTxid !== tradeResult.previousCosmosTxid ? currentCosmosTxid : '',
-            };
-        }
-        else {
-            return {
-                sellTxid: tradeResult.previousCosmosTxid,
-                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.SwapErrorType.RESPONSE_ERROR,
-        });
-    }
-    async approveAmount() {
-        throw new api_1.SwapError('Osmosis: approveAmount unimplemented', {
-            code: api_1.SwapErrorType.RESPONSE_ERROR,
-        });
-    }
-    filterBuyAssetsBySellAssetId(args) {
-        const { assetIds = [], sellAssetId } = args;
-        if (!this.supportedAssetIds.includes(sellAssetId))
-            return [];
-        return assetIds.filter((assetId) => this.supportedAssetIds.includes(assetId) && assetId !== sellAssetId);
-    }
-    filterAssetIdsBySellable() {
-        return this.supportedAssetIds;
-    }
-    async buildTrade(args) {
-        const { sellAsset, buyAsset, sellAmountBeforeFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, receiveAddress, accountNumber, receiveAccountNumber, } = args;
-        if (!sellAmountCryptoBaseUnit) {
-            throw new api_1.SwapError('sellAmountCryptoPrecision is required', {
-                code: api_1.SwapErrorType.BUILD_TRADE_FAILED,
-            });
-        }
-        const { buyAssetTradeFeeUsd, rate, buyAmountCryptoBaseUnit } = await (0, helpers_1.getRateInfo)(sellAsset.symbol, buyAsset.symbol, sellAmountCryptoBaseUnit !== '0' ? sellAmountCryptoBaseUnit : '1', this.deps.osmoUrl);
-        //convert amount to base
-        const sellAmountCryptoBase = String((0, bignumber_1.bnOrZero)(sellAmountCryptoBaseUnit).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.SwapErrorType.BUILD_TRADE_FAILED,
-            });
-        const feeData = await osmosisAdapter.getFeeData({});
-        const fee = feeData.fast.txFee;
-        return {
-            buyAmountCryptoBaseUnit,
-            buyAsset,
-            feeData: {
-                networkFeeCryptoBaseUnit: fee,
-                sellAssetTradeFeeUsd: '0',
-                buyAssetTradeFeeUsd,
-            },
-            rate,
-            receiveAddress,
-            sellAmountBeforeFeesCryptoBaseUnit: sellAmountCryptoBase,
-            sellAsset,
-            accountNumber,
-            receiveAccountNumber,
-            sources: [{ name: api_1.SwapperName.Osmosis, proportion: '100' }],
-        };
-    }
-    async getTradeQuote(input) {
-        const { accountNumber, sellAsset, buyAsset, sellAmountBeforeFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, } = input;
-        if (!sellAmountCryptoBaseUnit) {
-            throw new api_1.SwapError('sellAmount is required', {
-                code: api_1.SwapErrorType.RESPONSE_ERROR,
-            });
-        }
-        const { buyAssetTradeFeeUsd, rate, buyAmountCryptoBaseUnit } = await (0, helpers_1.getRateInfo)(sellAsset.symbol, buyAsset.symbol, sellAmountCryptoBaseUnit !== '0' ? sellAmountCryptoBaseUnit : '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.SwapErrorType.TRADE_QUOTE_FAILED,
-            });
-        const feeData = await osmosisAdapter.getFeeData({});
-        const fee = feeData.fast.txFee;
-        return {
-            buyAsset,
-            feeData: {
-                networkFeeCryptoBaseUnit: fee,
-                sellAssetTradeFeeUsd: '0',
-                buyAssetTradeFeeUsd,
-            },
-            maximum,
-            minimumCryptoHuman: minimum,
-            accountNumber,
-            rate,
-            sellAsset,
-            sellAmountBeforeFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
-            buyAmountCryptoBaseUnit,
-            sources: constants_1.DEFAULT_SOURCE,
-            allowanceContract: '',
-        };
-    }
-    async executeTrade({ trade, wallet }) {
-        var _a;
-        const { sellAsset, buyAsset, sellAmountBeforeFeesCryptoBaseUnit: sellAmountCryptoBaseUnit, accountNumber, receiveAccountNumber, receiveAddress, } = trade;
-        if (receiveAccountNumber === undefined)
-            throw new api_1.SwapError('Receive account number not provided', {
-                code: api_1.SwapErrorType.RECEIVE_ACCOUNT_NUMBER_NOT_PROVIDED,
-            });
-        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.SwapErrorType.EXECUTE_TRADE_FAILED,
-            });
-        }
-        const feeData = await osmosisAdapter.getFeeData({});
-        const gas = feeData.fast.chainSpecific.gasLimit;
-        let sellAddress;
-        let cosmosIbcTradeId = '';
-        if (!isFromOsmo) {
-            sellAddress = await cosmosAdapter.getAddress({ wallet, accountNumber });
-            if (!sellAddress)
-                throw new api_1.SwapError('Failed to get address', {
-                    code: api_1.SwapErrorType.EXECUTE_TRADE_FAILED,
-                });
-            const transfer = {
-                sender: sellAddress,
-                receiver: receiveAddress,
-                amount: sellAmountCryptoBaseUnit,
-            };
-            const responseAccount = await cosmosAdapter.getAccount(sellAddress);
-            const ibcAccountNumber = parseInt(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, feeData.fast.txFee, accountNumber, ibcAccountNumber, sequence, gas, 'uatom');
-            cosmosIbcTradeId = tradeId;
-            // 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.SwapErrorType.EXECUTE_TRADE_FAILED,
-                });
-            ibcSellAmount = await (0, helpers_1.pollForAtomChannelBalance)(receiveAddress, this.deps.osmoUrl);
-            // delay to ensure all nodes we interact with are up to date at this point
-            // seeing intermittent bugs that suggest the balances and sequence numbers were sometimes off
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-        }
-        else {
-            sellAddress = await osmosisAdapter.getAddress({ wallet, accountNumber });
-            if (!sellAddress)
-                throw new api_1.SwapError('failed to get osmoAddress', {
-                    code: api_1.SwapErrorType.EXECUTE_TRADE_FAILED,
-                });
-        }
-        const osmoAddress = isFromOsmo ? sellAddress : receiveAddress;
-        const cosmosAddress = isFromOsmo ? receiveAddress : sellAddress;
-        const signTxInput = await (0, helpers_1.buildTradeTx)({
-            osmoAddress,
-            accountNumber: isFromOsmo ? accountNumber : receiveAccountNumber,
-            adapter: osmosisAdapter,
-            buyAssetDenom,
-            sellAssetDenom,
-            sellAmount: ibcSellAmount !== null && ibcSellAmount !== void 0 ? ibcSellAmount : sellAmountCryptoBaseUnit,
-            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.SwapErrorType.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 = Number(ibcResponseAccount.chainSpecific.accountNumber);
-            const ibcSequence = ibcResponseAccount.chainSpecific.sequence || '0';
-            // delay to ensure all nodes we interact with are up to date at this point
-            // seeing intermittent bugs that suggest the balances and sequence numbers were sometimes off
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-            const cosmosTxHistory = await cosmosAdapter.getTxHistory({
-                pubkey: cosmosAddress,
-                pageSize: 1,
-            });
-            await (0, helpers_1.performIbcTransfer)(transfer, osmosisAdapter, wallet, this.deps.cosmosUrl, buyAssetDenom, constants_1.OSMO_COSMO_CHANNEL, chain_adapters_1.osmosis.MIN_FEE, accountNumber, ibcAccountNumber, ibcSequence, gas, 'uosmo');
-            return { tradeId, previousCosmosTxid: (_a = cosmosTxHistory.transactions[0]) === null || _a === void 0 ? void 0 : _a.txid, cosmosAddress };
-        }
-        return { tradeId, previousCosmosTxid: cosmosIbcTradeId };
-    }
-}
-exports.OsmosisSwapper = OsmosisSwapper;

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

@@ -1,9 +0,0 @@
-import { SwapperName } from '../../../api';
-export declare const DEFAULT_SOURCE: {
-    name: SwapperName;
-    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

@@ -1,9 +0,0 @@
-"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;
-const api_1 = require("../../../api");
-exports.DEFAULT_SOURCE = [{ name: api_1.SwapperName.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

@@ -1,44 +0,0 @@
-import { osmosis } from '@shapeshiftoss/chain-adapters';
-import { HDWallet, Osmosis } from '@shapeshiftoss/hdwallet-core';
-import { TradeResult } from '../../../api';
-import { OsmosisSupportedChainAdapter } from '../OsmosisSwapper';
-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;
-    buyAssetTradeFeeUsd: string;
-    buyAmountCryptoBaseUnit: string;
-}>;
-export declare const performIbcTransfer: (input: IbcTransferInput, adapter: OsmosisSupportedChainAdapter, wallet: HDWallet, blockBaseUrl: string, denom: string, sourceChannel: string, feeAmount: string, accountNumber: number, ibcAccountNumber: number, sequence: string, gas: string, feeDenom: string) => Promise<TradeResult>;
-export declare const buildTradeTx: ({ osmoAddress, adapter, accountNumber, buyAssetDenom, sellAssetDenom, sellAmount, gas, wallet, }: {
-    osmoAddress: string;
-    adapter: osmosis.ChainAdapter;
-    accountNumber: number;
-    buyAssetDenom: string;
-    sellAssetDenom: string;
-    sellAmount: string;
-    gas: string;
-    wallet: HDWallet;
-}) => Promise<{
-    txToSign: {
-        tx: Osmosis.StdTx;
-        addressNList: number[];
-        chain_id: "osmosis-1";
-        account_number: string;
-        sequence: string;
-    };
-    wallet: HDWallet;
-}>;

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

@@ -1,277 +0,0 @@
-"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 axios_1 = __importDefault(require("axios"));
-const lodash_1 = require("lodash");
-const api_1 = require("../../../api");
-const bignumber_1 = require("../../utils/bignumber");
-const constants_1 = require("./constants");
-const osmoService_1 = require("./osmoService");
-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.warn('Retrying to retrieve status');
-    }
-    return 'not found';
-};
-// TODO: leverage chain-adapters websockets
-const pollForComplete = async (txid, baseUrl) => {
-    return new Promise((resolve, reject) => {
-        const timeout = 300000; // 5 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 api_1.SwapError(`Couldnt find tx ${txid}`, {
-                    code: api_1.SwapErrorType.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 api_1.SwapError('failed to get balance', {
-                code: api_1.SwapErrorType.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.warn('Retrying to get ibc balance');
-    }
-    return toAtomChannelBalance;
-};
-exports.getAtomChannelBalance = getAtomChannelBalance;
-const pollForAtomChannelBalance = async (address, osmoUrl) => {
-    return new Promise((resolve, reject) => {
-        const timeout = 300000; // 5 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 api_1.SwapError(`Couldnt find channel balance for ${address}`, {
-                    code: api_1.SwapErrorType.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 osmoService_1.osmoService.get(poolsUrl);
-        }
-        catch (e) {
-            throw new api_1.SwapError('failed to get pool', {
-                code: api_1.SwapErrorType.POOL_NOT_FOUND,
-            });
-        }
-    })();
-    const foundPool = (0, lodash_1.find)(poolsResponse.data.pools, (pool) => {
-        const token0Denom = pool.pool_assets[0].token.denom;
-        const token1Denom = pool.pool_assets[1].token.denom;
-        return ((token0Denom === sellAssetDenom && token1Denom === buyAssetDenom) ||
-            (token0Denom === buyAssetDenom && token1Denom === sellAssetDenom));
-    });
-    if (!foundPool)
-        throw new api_1.SwapError('could not find pool', {
-            code: api_1.SwapErrorType.POOL_NOT_FOUND,
-        });
-    const { sellAssetIndex, buyAssetIndex } = (() => {
-        if (foundPool.pool_assets[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.pool_assets[0].token.amount).times(pool.pool_assets[1].token.amount);
-    const sellAssetInitialPoolSize = (0, bignumber_1.bnOrZero)(pool.pool_assets[sellAssetIndex].token.amount);
-    const buyAssetInitialPoolSize = (0, bignumber_1.bnOrZero)(pool.pool_assets[buyAssetIndex].token.amount);
-    const initialMarketPrice = sellAssetInitialPoolSize.dividedBy(buyAssetInitialPoolSize);
-    const sellAssetFinalPoolSize = sellAssetInitialPoolSize.plus(sellAmount);
-    const buyAssetFinalPoolSize = constantProduct.dividedBy(sellAssetFinalPoolSize);
-    const finalMarketPrice = sellAssetFinalPoolSize.dividedBy(buyAssetFinalPoolSize);
-    const buyAmountCryptoBaseUnit = buyAssetInitialPoolSize.minus(buyAssetFinalPoolSize).toString();
-    const rate = (0, bignumber_1.bnOrZero)(buyAmountCryptoBaseUnit).dividedBy(sellAmount).toString();
-    const priceImpact = (0, bignumber_1.bn)(1).minus(initialMarketPrice.dividedBy(finalMarketPrice)).abs().toString();
-    const tradeFeeBase = (0, bignumber_1.bnOrZero)(buyAmountCryptoBaseUnit).times((0, bignumber_1.bnOrZero)(pool.pool_params.swap_fee));
-    const buyAssetTradeFeeUsd = tradeFeeBase
-        .dividedBy((0, bignumber_1.bn)(10).exponentiatedBy(constants_1.OSMOSIS_PRECISION))
-        .toString();
-    return {
-        rate,
-        priceImpact,
-        buyAssetTradeFeeUsd,
-        buyAmountCryptoBaseUnit,
-    };
-};
-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, ibcAccountNumber, sequence, gas, feeDenom) => {
-    const { sender, receiver, amount } = input;
-    const responseLatestBlock = await (async () => {
-        try {
-            return axios_1.default.get(`${blockBaseUrl}/blocks/latest`);
-        }
-        catch (e) {
-            throw new api_1.SwapError('failed to get latest block', {
-                code: api_1.SwapErrorType.RESPONSE_ERROR,
-            });
-        }
-    })();
-    const latestBlock = responseLatestBlock.data.block.header.height;
-    const tx = {
-        memo: '',
-        fee: {
-            amount: [
-                {
-                    amount: feeAmount.toString(),
-                    denom: feeDenom,
-                },
-            ],
-            gas,
-        },
-        signatures: [],
-        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 bip44Params = adapter.getBIP44Params({ accountNumber });
-    const signed = await adapter.signTransaction({
-        txToSign: {
-            tx,
-            addressNList: (0, chain_adapters_1.toAddressNList)(bip44Params),
-            chain_id: (0, caip_1.fromChainId)(adapter.getChainId()).chainReference,
-            account_number: ibcAccountNumber.toString(),
-            sequence,
-        },
-        wallet,
-    });
-    const tradeId = await adapter.broadcastTransaction(signed);
-    return {
-        tradeId,
-    };
-};
-exports.performIbcTransfer = performIbcTransfer;
-// TODO: move to chain adapters
-const buildTradeTx = async ({ osmoAddress, adapter, accountNumber, buyAssetDenom, sellAssetDenom, sellAmount, gas, wallet, }) => {
-    const responseAccount = await adapter.getAccount(osmoAddress);
-    // note - this is a cosmos sdk specific account_number, not a bip44Params accountNumber
-    const account_number = responseAccount.chainSpecific.accountNumber || '0';
-    const sequence = responseAccount.chainSpecific.sequence || '0';
-    const tx = {
-        memo: '',
-        fee: {
-            amount: [
-                {
-                    amount: chain_adapters_1.osmosis.MIN_FEE,
-                    denom: 'uosmo',
-                },
-            ],
-            gas,
-        },
-        signatures: [],
-        msg: [
-            {
-                type: 'osmosis/gamm/swap-exact-amount-in',
-                value: {
-                    sender: osmoAddress,
-                    routes: [
-                        {
-                            pool_id: '1',
-                            token_out_denom: buyAssetDenom,
-                        },
-                    ],
-                    token_in: {
-                        denom: sellAssetDenom,
-                        amount: sellAmount,
-                    },
-                    token_out_min_amount: '1', // slippage tolerance
-                },
-            },
-        ],
-    };
-    const bip44Params = adapter.getBIP44Params({ accountNumber });
-    return {
-        txToSign: {
-            tx,
-            addressNList: (0, chain_adapters_1.toAddressNList)(bip44Params),
-            chain_id: caip_1.CHAIN_REFERENCE.OsmosisMainnet,
-            account_number,
-            sequence,
-        },
-        wallet,
-    };
-};
-exports.buildTradeTx = buildTradeTx;

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

@@ -1 +0,0 @@
-export declare const osmoService: import("axios").AxiosInstance;

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

@@ -1,20 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.osmoService = void 0;
-const axios_1 = __importDefault(require("axios"));
-const utils_1 = require("../../../utils");
-const maxAge = 3 * 1000; // 3 seconds
-const cachedUrls = ['/osmosis/gamm/v1beta1/pools'];
-const cache = (0, utils_1.createCache)(maxAge, cachedUrls);
-const axiosConfig = {
-    timeout: 10000,
-    headers: {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-    },
-    adapter: cache.adapter,
-};
-exports.osmoService = axios_1.default.create(axiosConfig);

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

@@ -1,27 +0,0 @@
-import { ChainAdapterManager } from '@shapeshiftoss/chain-adapters';
-import { TradeResult } from '../../../api';
-export declare type OsmoSwapperDeps = {
-    adapterManager: ChainAdapterManager;
-    osmoUrl: string;
-    cosmosUrl: string;
-};
-export declare type IbcTransferInput = {
-    sender: string;
-    receiver: string;
-    amount: string;
-};
-export declare type PoolInfo = {
-    pool_assets: PoolAssetInfo[];
-    pool_params: {
-        swap_fee: string;
-    };
-};
-export declare type PoolAssetInfo = {
-    token: {
-        amount: string;
-    };
-};
-export interface OsmosisTradeResult extends TradeResult {
-    previousCosmosTxid: string;
-    cosmosAddress?: string;
-}

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

@@ -1,24 +0,0 @@
-import { Asset } from '@shapeshiftoss/asset-service';
-import { AssetId, ChainId } from '@shapeshiftoss/caip';
-import { ApprovalNeededOutput, BuyAssetBySellIdInput, Swapper, SwapperName, 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<ChainId> {
-    readonly name = SwapperName.Test;
-    supportAssets: string[];
-    initialize(): Promise<void>;
-    getType(): SwapperType;
-    constructor();
-    getUsdRate(input: Pick<Asset, 'symbol' | 'assetId'>): Promise<string>;
-    approvalNeeded(): Promise<ApprovalNeededOutput>;
-    approveInfinite(): Promise<string>;
-    approveAmount(): Promise<string>;
-    filterBuyAssetsBySellAssetId(args: BuyAssetBySellIdInput): AssetId[];
-    filterAssetIdsBySellable(): AssetId[];
-    buildTrade(): Promise<Trade<ChainId>>;
-    getTradeQuote(): Promise<TradeQuote<ChainId>>;
-    executeTrade(): Promise<TradeResult>;
-    getTradeTxs(): Promise<TradeTxs>;
-}