@shapeshiftoss/swapper 17.6.3 → 17.6.5

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.d.ts

@@ -0,0 +1,6 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+import type { AssetsByIdPartial } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeQuoteInputBase, SwapErrorRight, TradeQuote } from '../../../types';
+export declare function getZrxTradeQuote(input: GetEvmTradeQuoteInputBase, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, assetsById: AssetsByIdPartial, zrxBaseUrl: string): Promise<Result<TradeQuote, SwapErrorRight>>;

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZrxTradeQuote = void 0;
+const chain_adapters_1 = require("@shapeshiftoss/chain-adapters");
+const contracts_1 = require("@shapeshiftoss/contracts");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../utils/helpers/helpers");
+const fetchFromZrx_1 = require("../utils/fetchFromZrx");
+const helpers_2 = require("../utils/helpers/helpers");
+async function getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsById, zrxBaseUrl) {
+    const { sellAsset, buyAsset, accountNumber, receiveAddress, affiliateBps, chainId, supportsEIP1559, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const assertion = (0, helpers_2.assertValidTrade)({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Zrx);
+    const maybeZrxQuoteResponse = await (0, fetchFromZrx_1.fetchZrxQuote)({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        // Cross-account not supported for ZRX
+        sellAddress: receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        zrxBaseUrl,
+    });
+    if (maybeZrxQuoteResponse.isErr())
+        return (0, monads_1.Err)(maybeZrxQuoteResponse.unwrapErr());
+    const zrxQuoteResponse = maybeZrxQuoteResponse.unwrap();
+    const { sellAmount, buyAmount, fees, permit2, transaction, route } = zrxQuoteResponse;
+    const permit2Eip712 = permit2?.eip712;
+    const isWrappedNative = route.fills.some(fill => fill.source === 'Wrapped_Native' && fill.proportionBps === '10000');
+    if (!(0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) && !isWrappedNative && !permit2Eip712) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Missing required Permit2 metadata from 0x response',
+            code: types_1.TradeQuoteError.InvalidResponse,
+            details: { transaction, permit2Eip712 },
+        }));
+    }
+    if (!transaction) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Missing required transaction metadata from 0x response',
+            code: types_1.TradeQuoteError.InvalidResponse,
+            details: { transaction, permit2Eip712 },
+        }));
+    }
+    const transactionMetadata = {
+        to: transaction.to,
+        data: transaction.data,
+        gasPrice: transaction.gasPrice || undefined,
+        gas: transaction.gas || undefined,
+        value: transaction.value,
+    };
+    const rate = (0, helpers_2.calculateRate)({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, helpers_2.calculateBuyAmountBeforeFeesCryptoBaseUnit)({
+        buyAmount,
+        fees,
+        buyAsset,
+        sellAsset,
+    });
+    try {
+        const adapter = assertGetEvmChainAdapter(chainId);
+        const { average } = await adapter.getGasFeeData();
+        const networkFeeCryptoBaseUnit = chain_adapters_1.evm.calcNetworkFeeCryptoBaseUnit({
+            ...average,
+            supportsEIP1559: Boolean(supportsEIP1559),
+            // add gas limit buffer to account for the fact we perform all of our validation on the trade quote estimations
+            // which are inaccurate and not what we use for the tx to broadcast
+            gasLimit: (0, utils_1.bnOrZero)(transaction.gas).times(1.2).toFixed(),
+        });
+        return (0, monads_1.Ok)({
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: 'quote',
+            receiveAddress,
+            affiliateBps,
+            // Slippage protection is always enabled for 0x api v2 unlike api v1 which was only supported on specific pairs.
+            slippageTolerancePercentageDecimal,
+            rate,
+            swapperName: types_1.SwapperName.Zrx,
+            steps: [
+                {
+                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+                    estimatedExecutionTimeMs: 0,
+                    allowanceContract: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) || isWrappedNative ? undefined : contracts_1.PERMIT2_CONTRACT,
+                    buyAsset,
+                    sellAsset,
+                    accountNumber,
+                    rate,
+                    feeData: {
+                        protocolFees: (0, helpers_2.getProtocolFees)({ fees, sellAsset, assetsById }),
+                        networkFeeCryptoBaseUnit,
+                    },
+                    buyAmountBeforeFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit: buyAmount,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                    source: types_1.SwapperName.Zrx,
+                    permit2Eip712: permit2Eip712,
+                    zrxTransactionMetadata: transactionMetadata,
+                },
+            ],
+        });
+    }
+    catch (err) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'failed to get fee data',
+            cause: err,
+            code: types_1.TradeQuoteError.NetworkFeeEstimationFailed,
+        }));
+    }
+}
+exports.getZrxTradeQuote = getZrxTradeQuote;

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.test.js

@@ -0,0 +1,159 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const monads_1 = require("@sniptt/monads");
+const vitest_1 = require("vitest");
+const types_2 = require("../../../types");
+const assets_1 = require("../../utils/test-data/assets");
+const fees_1 = require("../../utils/test-data/fees");
+const setupSwapQuote_1 = require("../../utils/test-data/setupSwapQuote");
+const zrxService_1 = require("../utils/zrxService");
+const getZrxTradeQuote_1 = require("./getZrxTradeQuote");
+vitest_1.vi.mock('../utils/zrxService', () => {
+    const get = vitest_1.vi.fn();
+    const post = vitest_1.vi.fn();
+    return {
+        zrxServiceFactory: vitest_1.vi.fn(() => ({
+            get,
+            post,
+        })),
+    };
+});
+vitest_1.vi.mock('../utils/helpers/helpers', async () => {
+    const actual = await vitest_1.vi.importActual('../utils/helpers/helpers');
+    return {
+        ...actual,
+        baseUrlFromChainId: vitest_1.vi.fn(() => 'https://0x.shapeshift.com/ethereum/'),
+    };
+});
+vitest_1.vi.mock('@shapeshiftoss/chain-adapters', async () => {
+    const { KnownChainIds } = await Promise.resolve().then(() => __importStar(require('@shapeshiftoss/types')));
+    const actual = await vitest_1.vi.importActual('@shapeshiftoss/chain-adapters');
+    return {
+        ...actual,
+        isEvmChainId: vitest_1.vi.fn(() => true),
+        evmChainIds: [KnownChainIds.EthereumMainnet],
+        optimism: {
+            isOptimismChainAdapter: vitest_1.vi.fn(() => false),
+        },
+    };
+});
+const mockOk = monads_1.Ok;
+const mockErr = monads_1.Err;
+(0, vitest_1.describe)('getZrxTradeQuote', () => {
+    const zrxBaseUrl = 'https://0x.shapeshift.com/ethereum/';
+    const assertGetChainAdapter = (_chainId) => {
+        return {
+            getChainId: () => types_1.KnownChainIds.EthereumMainnet,
+            getGasFeeData: () => Promise.resolve(fees_1.gasFeeData),
+        };
+    };
+    const zrxService = (0, zrxService_1.zrxServiceFactory)({ baseUrl: zrxBaseUrl });
+    (0, vitest_1.it)('returns quote with fee data', async () => {
+        const { quoteInput } = (0, setupSwapQuote_1.setupQuote)();
+        vitest_1.vi.mocked(zrxService.get).mockReturnValue(Promise.resolve(mockOk({
+            data: {
+                buyAmount: quoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                sellAmount: quoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                fees: {
+                    integratorFee: null,
+                    zeroExFee: {
+                        amount: '3978501710063',
+                        token: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+                    },
+                },
+                transaction: {
+                    gas: '237315',
+                },
+                route: { fills: [] },
+                permit2: { eip712: {} },
+            },
+        })));
+        const maybeQuote = await (0, getZrxTradeQuote_1.getZrxTradeQuote)(quoteInput, assertGetChainAdapter, { 'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': quoteInput.buyAsset }, zrxBaseUrl);
+        if (maybeQuote.isErr())
+            console.log(maybeQuote.unwrapErr());
+        (0, vitest_1.expect)(maybeQuote.isErr()).toBe(false);
+        const quote = maybeQuote.unwrap();
+        (0, vitest_1.expect)(quote.steps[0].feeData).toStrictEqual({
+            protocolFees: {
+                'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': {
+                    amountCryptoBaseUnit: '3978501710063',
+                    asset: quoteInput.buyAsset,
+                    requiresBalance: false,
+                },
+            },
+            networkFeeCryptoBaseUnit: '22507856397000000',
+        });
+        (0, vitest_1.expect)(quote.steps[0].rate).toBe('1');
+    });
+    (0, vitest_1.it)('bubbles up the zrxService Err from a bad zrx response', async () => {
+        const { quoteInput } = (0, setupSwapQuote_1.setupQuote)();
+        vitest_1.vi.mocked(zrxService.get).mockReturnValue(Promise.resolve(mockErr({ some: 'error' })));
+        const maybeTradeQuote = await (0, getZrxTradeQuote_1.getZrxTradeQuote)(quoteInput, assertGetChainAdapter, {}, zrxBaseUrl);
+        (0, vitest_1.expect)(maybeTradeQuote.isErr()).toBe(true);
+        (0, vitest_1.expect)(maybeTradeQuote.unwrapErr()).toMatchObject({
+            some: 'error',
+        });
+    });
+    (0, vitest_1.it)('returns an Err on errored zrx response', async () => {
+        const { quoteInput } = (0, setupSwapQuote_1.setupQuote)();
+        vitest_1.vi.mocked(zrxService.get).mockResolvedValue((0, monads_1.Err)({
+            response: { data: { code: 502, reason: 'Failed to do some stuff' } },
+        }));
+        const maybeTradeQuote = await (0, getZrxTradeQuote_1.getZrxTradeQuote)(quoteInput, assertGetChainAdapter, {}, zrxBaseUrl);
+        (0, vitest_1.expect)(maybeTradeQuote.isErr()).toBe(true);
+        (0, vitest_1.expect)(maybeTradeQuote.unwrapErr()).toMatchObject({
+            response: { data: { code: 502, reason: 'Failed to do some stuff' } },
+        });
+    });
+    (0, vitest_1.it)('returns an Err on non ethereum chain for buyAsset', async () => {
+        const { quoteInput } = (0, setupSwapQuote_1.setupQuote)();
+        vitest_1.vi.mocked(zrxService.get).mockReturnValue(Promise.resolve((0, monads_1.Ok)({})));
+        const maybeTradeQuote = await (0, getZrxTradeQuote_1.getZrxTradeQuote)({ ...quoteInput, buyAsset: assets_1.BTC }, assertGetChainAdapter, {}, zrxBaseUrl);
+        (0, vitest_1.expect)(maybeTradeQuote.isErr()).toBe(true);
+        (0, vitest_1.expect)(maybeTradeQuote.unwrapErr()).toMatchObject({
+            cause: undefined,
+            code: types_2.TradeQuoteError.UnsupportedChain,
+            message: 'unsupported chainId',
+            name: 'SwapError',
+        });
+    });
+    (0, vitest_1.it)('returns an Err on non ethereum chain for sellAsset', async () => {
+        const { quoteInput, sellAsset } = (0, setupSwapQuote_1.setupQuote)();
+        vitest_1.vi.mocked(zrxService.get).mockReturnValue(Promise.resolve((0, monads_1.Ok)({})));
+        const maybeTradeQuote = await (0, getZrxTradeQuote_1.getZrxTradeQuote)({ ...quoteInput, sellAsset: { ...sellAsset, chainId: caip_1.btcChainId } }, assertGetChainAdapter, {}, zrxBaseUrl);
+        (0, vitest_1.expect)(maybeTradeQuote.isErr()).toBe(true);
+        (0, vitest_1.expect)(maybeTradeQuote.unwrapErr()).toMatchObject({
+            code: types_2.TradeQuoteError.UnsupportedChain,
+            details: {
+                chainId: 'bip122:000000000019d6689c085ae165831e93',
+            },
+            message: 'unsupported chainId',
+            name: 'SwapError',
+        });
+    });
+});

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeRate/getZrxTradeRate.d.ts

@@ -0,0 +1,4 @@
+import type { AssetsByIdPartial } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { GetEvmTradeRateInput, SwapErrorRight, TradeRate } from '../../../types';
+export declare function getZrxTradeRate(input: GetEvmTradeRateInput, assetsById: AssetsByIdPartial, zrxBaseUrl: string): Promise<Result<TradeRate, SwapErrorRight>>;

package/dist/cjs/swappers/ZrxSwapper/getZrxTradeRate/getZrxTradeRate.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZrxTradeRate = void 0;
+const contracts_1 = require("@shapeshiftoss/contracts");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const constants_1 = require("../../../constants");
+const types_1 = require("../../../types");
+const helpers_1 = require("../../utils/helpers/helpers");
+const fetchFromZrx_1 = require("../utils/fetchFromZrx");
+const helpers_2 = require("../utils/helpers/helpers");
+async function getZrxTradeRate(input, assetsById, zrxBaseUrl) {
+    const { sellAsset, buyAsset, accountNumber, receiveAddress, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const assertion = (0, helpers_2.assertValidTrade)({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return (0, monads_1.Err)(assertion.unwrapErr());
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Zrx);
+    const maybeZrxPriceResponse = await (0, fetchFromZrx_1.fetchZrxPrice)({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        // Cross-account not supported for ZRX
+        sellAddress: receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        zrxBaseUrl,
+    });
+    if (maybeZrxPriceResponse.isErr())
+        return (0, monads_1.Err)(maybeZrxPriceResponse.unwrapErr());
+    const zrxPriceResponse = maybeZrxPriceResponse.unwrap();
+    const { buyAmount, sellAmount, fees, totalNetworkFee, route } = zrxPriceResponse;
+    const isWrappedNative = route.fills.some(fill => fill.source === 'Wrapped_Native' && fill.proportionBps === '10000');
+    const rate = (0, helpers_2.calculateRate)({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, helpers_2.calculateBuyAmountBeforeFeesCryptoBaseUnit)({
+        buyAmount,
+        fees,
+        buyAsset,
+        sellAsset,
+    });
+    return (0, monads_1.Ok)({
+        id: (0, uuid_1.v4)(),
+        quoteOrRate: 'rate',
+        accountNumber: undefined,
+        receiveAddress,
+        affiliateBps,
+        // Slippage protection is always enabled for 0x api v2 unlike api v1 which was only supported on specific pairs.
+        slippageTolerancePercentageDecimal,
+        rate,
+        swapperName: types_1.SwapperName.Zrx,
+        steps: [
+            {
+                // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+                estimatedExecutionTimeMs: 0,
+                allowanceContract: (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) || isWrappedNative ? undefined : contracts_1.PERMIT2_CONTRACT,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                rate,
+                feeData: {
+                    protocolFees: (0, helpers_2.getProtocolFees)({ fees, sellAsset, assetsById }),
+                    networkFeeCryptoBaseUnit: totalNetworkFee,
+                },
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit: buyAmount,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                source: types_1.SwapperName.Zrx,
+            },
+        ],
+    });
+}
+exports.getZrxTradeRate = getZrxTradeRate;

package/dist/cjs/swappers/ZrxSwapper/types.d.ts

@@ -0,0 +1,76 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { Address, TypedData } from 'viem';
+export declare const zrxSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet];
+export type ZrxSupportedChainId = (typeof zrxSupportedChainIds)[number];
+type ZrxFee = {
+    amount: string;
+    token: Address;
+    type: string;
+};
+export type ZrxFees = {
+    integratorFee: ZrxFee | null;
+    zeroExFee: ZrxFee | null;
+    gasFee: ZrxFee | null;
+};
+type ZrxTokenMetadata = {
+    buyTaxBps: string | null;
+    sellTaxBps: string | null;
+};
+export type ZrxPriceResponse = {
+    blockNumber: string;
+    buyAmount: string;
+    buyToken: string;
+    fees: ZrxFees;
+    gas: string | null;
+    gasPrice: string;
+    issues: {
+        allowance: {
+            actual: string;
+            spender: Address;
+        } | null;
+        balance: {
+            token: Address;
+            actual: string;
+            expected: string;
+        } | null;
+        simulationIncomplete: boolean;
+        invalidSourcesPassed: string[];
+    };
+    liquidityAvailable: boolean;
+    minBuyAmount: string;
+    route: {
+        fills: {
+            from: Address;
+            to: Address;
+            source: string;
+            proportionBps: string;
+        }[];
+        tokens: {
+            address: Address;
+            symbol: string;
+        }[];
+    };
+    sellAmount: string;
+    sellToken: Address;
+    tokenMetadata: {
+        buyToken: ZrxTokenMetadata;
+        sellToken: ZrxTokenMetadata;
+    };
+    totalNetworkFee: string | null;
+    zid: string;
+};
+export type ZrxQuoteResponse = Omit<ZrxPriceResponse, 'gas' | 'gasPrice'> & {
+    permit2: {
+        type: 'Permit2';
+        hash: string;
+        eip712: TypedData | null;
+    } | null;
+    transaction: {
+        to: Address;
+        data: string;
+        gas: string | null;
+        gasPrice: string;
+        value: string;
+    };
+};
+export {};

package/dist/cjs/swappers/ZrxSwapper/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zrxSupportedChainIds = void 0;
+const types_1 = require("@shapeshiftoss/types");
+exports.zrxSupportedChainIds = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.OptimismMainnet,
+    types_1.KnownChainIds.BnbSmartChainMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+];

package/dist/cjs/swappers/ZrxSwapper/utils/constants.d.ts

@@ -0,0 +1,4 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+export declare const ZRX_UNSUPPORTED_ASSETS: readonly string[];
+export declare const ZRX_SUPPORTED_CHAINIDS: readonly KnownChainIds[];
+export declare const ZRX_NATIVE_ASSET_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";

package/dist/cjs/swappers/ZrxSwapper/utils/constants.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZRX_NATIVE_ASSET_ADDRESS = exports.ZRX_SUPPORTED_CHAINIDS = exports.ZRX_UNSUPPORTED_ASSETS = void 0;
+const types_1 = require("@shapeshiftoss/types");
+// Zrx doesn't have an easily accessible master assets list.
+// We assume all erc20's are supported and remove these explicitly unsupported assets
+exports.ZRX_UNSUPPORTED_ASSETS = Object.freeze([
+    // Foxy token unsupported by zrx
+    'eip155:1/erc20:0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3',
+    /**
+     * ERC20 RUNE - we don't want people buying this instead of native RUNE
+     * as it's exchangeable value for native RUNE is currently decaying from 1 towards 0
+     */
+    'eip155:1/erc20:0x3155ba85d5f96b2d030a4966af206230e46849cb',
+]);
+exports.ZRX_SUPPORTED_CHAINIDS = Object.freeze([
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.AvalancheMainnet,
+    types_1.KnownChainIds.OptimismMainnet,
+    types_1.KnownChainIds.BnbSmartChainMainnet,
+    types_1.KnownChainIds.PolygonMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.BaseMainnet,
+]);
+// https://0x.org/docs/developer-resources/faqs-and-troubleshooting
+exports.ZRX_NATIVE_ASSET_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

package/dist/cjs/swappers/ZrxSwapper/utils/fetchFromZrx.d.ts

@@ -0,0 +1,25 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types';
+import type { ZrxPriceResponse, ZrxQuoteResponse } from '../types';
+type FetchZrxQuoteInput = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    sellAddress: string;
+    affiliateBps: string;
+    slippageTolerancePercentageDecimal: string;
+    zrxBaseUrl: string;
+};
+type FetchZrxPriceInput = {
+    buyAsset: Asset;
+    sellAsset: Asset;
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
+    sellAddress: string | undefined;
+    affiliateBps: string;
+    slippageTolerancePercentageDecimal: string;
+    zrxBaseUrl: string;
+};
+export declare const fetchZrxPrice: (args: FetchZrxPriceInput) => Promise<Result<ZrxPriceResponse, SwapErrorRight>>;
+export declare const fetchZrxQuote: (args: FetchZrxQuoteInput) => Promise<Result<ZrxQuoteResponse, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/ZrxSwapper/utils/fetchFromZrx.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchZrxQuote = exports.fetchZrxPrice = void 0;
+const contracts_1 = require("@shapeshiftoss/contracts");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const helpers_1 = require("../../utils/helpers/helpers");
+const helpers_2 = require("./helpers/helpers");
+const zrxService_1 = require("./zrxService");
+const fetchFromZrx = async ({ quoteOrRate, buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAddress, affiliateBps, slippageTolerancePercentageDecimal, zrxBaseUrl, }) => {
+    const zrxService = (0, zrxService_1.zrxServiceFactory)({ baseUrl: zrxBaseUrl });
+    const maybeTreasuryAddress = (() => {
+        try {
+            return (0, helpers_1.getTreasuryAddressFromChainId)(buyAsset.chainId);
+        }
+        catch (err) { }
+    })();
+    // Rates are gotten using ZRX /swap/permit2/price endpoint
+    const endpoint = quoteOrRate === 'quote' ? 'quote' : 'price';
+    // https://0x.org/docs/api#tag/Swap/operation/swap::permit2::getPrice
+    // https://0x.org/docs/api#tag/Swap/operation/swap::permit2::getQuote
+    const maybeZrxPriceResponse = await zrxService.get(`/swap/permit2/${endpoint}`, {
+        params: {
+            chainId: contracts_1.viemNetworkIdByChainId[sellAsset.chainId],
+            buyToken: (0, helpers_2.assetIdToZrxToken)(buyAsset.assetId),
+            sellToken: (0, helpers_2.assetIdToZrxToken)(sellAsset.assetId),
+            sellAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            taker: sellAddress,
+            swapFeeBps: (0, utils_1.bn)(affiliateBps).toNumber(),
+            swapFeeToken: (0, helpers_2.assetIdToZrxToken)(buyAsset.assetId),
+            slippageBps: (0, utils_1.convertDecimalPercentageToBasisPoints)(slippageTolerancePercentageDecimal).toNumber(),
+            swapFeeRecipient: maybeTreasuryAddress,
+            feeRecipientTradeSurplus: maybeTreasuryAddress, // Where trade surplus is sent
+        },
+    });
+    if (maybeZrxPriceResponse.isErr()) {
+        return (0, monads_1.Err)(maybeZrxPriceResponse.unwrapErr());
+    }
+    return (0, monads_1.Ok)(maybeZrxPriceResponse.unwrap().data);
+};
+const fetchZrxPrice = (args) => {
+    return fetchFromZrx({
+        quoteOrRate: 'rate',
+        ...args,
+    });
+};
+exports.fetchZrxPrice = fetchZrxPrice;
+const fetchZrxQuote = (args) => {
+    return fetchFromZrx({
+        quoteOrRate: 'quote',
+        ...args,
+    });
+};
+exports.fetchZrxQuote = fetchZrxQuote;

package/dist/cjs/swappers/ZrxSwapper/utils/helpers/helpers.d.ts

@@ -0,0 +1,34 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { ZrxFees } from '../../types';
+export declare const assetIdToZrxToken: (assetId: AssetId) => string;
+export declare const zrxTokenToAssetId: (token: string, chainId: ChainId) => AssetId;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet;
+export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types").SwapErrorRight>;
+export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
+    buyAmount: string;
+    sellAmount: string;
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => string;
+export declare const calculateBuyAmountBeforeFeesCryptoBaseUnit: ({ buyAmount, fees, buyAsset, sellAsset, }: {
+    buyAmount: string;
+    fees: ZrxFees;
+    buyAsset: Asset;
+    sellAsset: Asset;
+}) => string | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types").SwapErrorRight>;
+export declare const getProtocolFees: ({ fees, sellAsset, assetsById, }: {
+    fees: ZrxFees;
+    sellAsset: Asset;
+    assetsById: AssetsByIdPartial;
+}) => {
+    [x: string]: {
+        requiresBalance: boolean;
+        amountCryptoBaseUnit: string;
+        asset: Asset | undefined;
+    };
+};