@shapeshiftoss/swapper 20.3.0 → 20.5.0

package/dist/esm/swappers/SymbiosisSwapper/utils/helpers.js

@@ -0,0 +1,156 @@
+import { ASSET_NAMESPACE, fromAssetId, toAssetId, tronChainId } from '@shapeshiftoss/caip';
+import { tron } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bn, bnOrZero, chainIdToFeeAssetId, isToken } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { getAddress, keccak256, toHex } from 'viem';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { chainIdToSymbiosisChainId, DEFAULT_SYMBIOSIS_EVM_USER_ADDRESS, DEFAULT_SYMBIOSIS_TRON_USER_ADDRESS, SYMBIOSIS_CROSSCHAIN_SWAP_KIND, SYMBIOSIS_MAX_SLIPPAGE_BPS, SYMBIOSIS_MIN_SLIPPAGE_BPS, SYMBIOSIS_PARTNER_ADDRESS, SYMBIOSIS_PARTNER_FEE_BPS, SYMBIOSIS_PARTNER_SWAP_LABEL, SYMBIOSIS_SEMI_CENTRALIZED_LABEL, SYMBIOSIS_SRC_CHAIN_SWAP_LABEL, SYMBIOSIS_TRON_BRIDGE_ENERGY, SYMBIOSIS_TRON_SOURCE_SWAP_ENERGY, symbiosisChainIdToChainId, } from './constants.js';
+import { SymbiosisStatusCode } from './types.js';
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    const sellSymbiosisChainId = chainIdToSymbiosisChainId[sellAsset.chainId];
+    const buySymbiosisChainId = chainIdToSymbiosisChainId[buyAsset.chainId];
+    if (sellSymbiosisChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Sell asset chain '${sellAsset.chainId}' not supported by Symbiosis`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (buySymbiosisChainId === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `Buy asset chain '${buyAsset.chainId}' not supported by Symbiosis`,
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    if (sellAsset.chainId === buyAsset.chainId) {
+        return Err(makeSwapErrorRight({
+            message: 'Symbiosis same-chain swaps are not supported',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
+    return Ok({ sellSymbiosisChainId, buySymbiosisChainId });
+};
+export const getSymbiosisTokenAddress = (asset) => {
+    if (!isToken(asset.assetId))
+        return '';
+    const { assetReference } = fromAssetId(asset.assetId);
+    if (asset.chainId === tronChainId)
+        return tron.toTronHex(assetReference);
+    return getAddress(assetReference);
+};
+export const getSymbiosisSlippageBps = (slippageTolerancePercentageDecimal) => {
+    const bps = Math.round(bnOrZero(slippageTolerancePercentageDecimal).times(10000).toNumber());
+    return Math.min(Math.max(bps, SYMBIOSIS_MIN_SLIPPAGE_BPS), SYMBIOSIS_MAX_SLIPPAGE_BPS);
+};
+export const getDefaultUserAddress = (chainId) => chainId === tronChainId ? DEFAULT_SYMBIOSIS_TRON_USER_ADDRESS : DEFAULT_SYMBIOSIS_EVM_USER_ADDRESS;
+// Symbiosis fixes the partner rate on its side, so only a fee-free swap or the registered rate can be honored
+export const getSymbiosisPartnerAddress = (affiliateBps) => {
+    const requestedBps = bnOrZero(affiliateBps);
+    if (requestedBps.isZero())
+        return Ok(undefined);
+    if (requestedBps.eq(SYMBIOSIS_PARTNER_FEE_BPS))
+        return Ok(SYMBIOSIS_PARTNER_ADDRESS);
+    return Err(makeSwapErrorRight({
+        message: `Symbiosis only supports a ${SYMBIOSIS_PARTNER_FEE_BPS} bps affiliate fee, got ${affiliateBps}`,
+        code: TradeQuoteError.UnsupportedTradePair,
+    }));
+};
+// Symbiosis returns the function signature and its encoded parameters separately
+export const buildSymbiosisTronCallData = ({ functionSelector, data, }) => {
+    const selector = keccak256(toHex(functionSelector)).slice(0, 10);
+    const parameters = data.startsWith('0x') ? data.slice(2) : data;
+    return `${selector}${parameters}`;
+};
+export const getSymbiosisTronFallbackEnergy = (labels) => labels.includes(SYMBIOSIS_SRC_CHAIN_SWAP_LABEL)
+    ? SYMBIOSIS_TRON_SOURCE_SWAP_ENERGY
+    : SYMBIOSIS_TRON_BRIDGE_ENERGY;
+export const isSymbiosisRouteSupported = ({ quote, sellAsset, }) => {
+    if (quote.kind !== SYMBIOSIS_CROSSCHAIN_SWAP_KIND)
+        return false;
+    if (quote.labels.includes(SYMBIOSIS_PARTNER_SWAP_LABEL))
+        return false;
+    if (quote.labels.includes(SYMBIOSIS_SEMI_CENTRALIZED_LABEL))
+        return false;
+    const expectedType = sellAsset.chainId === tronChainId ? 'tron' : 'evm';
+    return quote.type === expectedType;
+};
+export const getSymbiosisFeeAssetId = ({ chainId: symbiosisChainId, address, }) => {
+    const chainId = symbiosisChainIdToChainId[symbiosisChainId];
+    if (!chainId)
+        return;
+    if (!address)
+        return chainIdToFeeAssetId(chainId);
+    if (chainId === tronChainId) {
+        return toAssetId({
+            chainId,
+            assetNamespace: ASSET_NAMESPACE.trc20,
+            assetReference: tron.toTronBase58(address),
+        });
+    }
+    return toAssetId({
+        chainId,
+        assetNamespace: ASSET_NAMESPACE.erc20,
+        assetReference: address.toLowerCase(),
+    });
+};
+// Fees on the Symbiosis host chain are charged in sTokens we have no asset for - they are already net of the buy amount
+export const getSymbiosisProtocolFees = (fees) => fees.reduce((acc, { value }) => {
+    const assetId = getSymbiosisFeeAssetId(value);
+    const chainId = symbiosisChainIdToChainId[value.chainId];
+    if (!assetId || !chainId)
+        return acc;
+    acc[assetId] = {
+        amountCryptoBaseUnit: bnOrZero(acc[assetId]?.amountCryptoBaseUnit)
+            .plus(value.amount)
+            .toFixed(0),
+        asset: { symbol: value.symbol, chainId, precision: value.decimals },
+        requiresBalance: false,
+    };
+    return acc;
+}, {});
+export const symbiosisErrorToTradeQuoteError = (message) => {
+    if (message?.startsWith('Amount is too low'))
+        return TradeQuoteError.SellAmountBelowTradeFee;
+    if (message === 'This swap is not available')
+        return TradeQuoteError.NoRouteFound;
+    return TradeQuoteError.QueryFailed;
+};
+// A mined Tron call that did not succeed (REVERT, OUT_OF_ENERGY, ...) never reaches Symbiosis, which answers not found for it
+export const isTronSourceTxFailed = (tx) => {
+    const contractRet = tx.ret?.[0]?.contractRet;
+    return contractRet !== undefined && contractRet !== 'SUCCESS';
+};
+export const getSymbiosisTradeStatus = ({ response, buySymbiosisChainId, }) => {
+    const { status, tx, transitTokenSent } = response;
+    switch (status.code) {
+        case SymbiosisStatusCode.Success: {
+            // Until the operation is indexed, Symbiosis answers Success for the plain source transaction
+            if (tx?.chainId !== buySymbiosisChainId) {
+                return { status: TxStatus.Pending, buyTxHash: undefined, message: undefined };
+            }
+            const message = transitTokenSent
+                ? `Received ${bn(transitTokenSent.amount)
+                    .shiftedBy(-transitTokenSent.decimals)
+                    .toFixed()} ${transitTokenSent.symbol} instead of the buy asset`
+                : undefined;
+            return { status: TxStatus.Confirmed, buyTxHash: tx?.hash, message };
+        }
+        case SymbiosisStatusCode.Pending:
+            return { status: TxStatus.Pending, buyTxHash: undefined, message: undefined };
+        case SymbiosisStatusCode.Stuck:
+            return {
+                status: TxStatus.Pending,
+                buyTxHash: undefined,
+                message: 'Swap is stuck and is being reverted by Symbiosis',
+            };
+        case SymbiosisStatusCode.Reverted:
+            return {
+                status: TxStatus.Failed,
+                buyTxHash: undefined,
+                message: 'Swap was reverted by Symbiosis',
+            };
+        default:
+            return { status: TxStatus.Unknown, buyTxHash: undefined, message: undefined };
+    }
+};

package/dist/esm/swappers/SymbiosisSwapper/utils/helpers.test.d.ts

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

package/dist/esm/swappers/SymbiosisSwapper/utils/helpers.test.js

@@ -0,0 +1,149 @@
+import { usdtOnTronAssetId } from '@shapeshiftoss/caip';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { describe, expect, it } from 'vitest';
+import { SYMBIOSIS_PARTNER_ADDRESS } from './constants.js';
+import { buildSymbiosisTronCallData, getSymbiosisFeeAssetId, getSymbiosisPartnerAddress, getSymbiosisProtocolFees, getSymbiosisSlippageBps, getSymbiosisTradeStatus, isTronSourceTxFailed, } from './helpers.js';
+import { SymbiosisStatusCode } from './types.js';
+const BSC_USDC_ADDRESS = '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d';
+const BSC_USDC_ASSET_ID = 'eip155:56/erc20:0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d';
+// The fees array of a live Arbitrum USDC -> BSC quote: one host chain sToken entry, one destination entry
+const liveFees = [
+    {
+        provider: 'symbiosis',
+        description: 'Cross-chain fee',
+        value: {
+            symbol: 'sUSDC',
+            address: '0xc317169a336b484f65B0AB4A794bBe66a7491E83',
+            amount: '250000',
+            chainId: 13863860,
+            decimals: 6,
+        },
+    },
+    {
+        provider: 'symbiosis',
+        description: 'Cross-chain fee',
+        value: {
+            symbol: 'USDC',
+            address: BSC_USDC_ADDRESS,
+            amount: '250000000000000000',
+            chainId: 56,
+            decimals: 18,
+        },
+    },
+];
+describe('getSymbiosisSlippageBps', () => {
+    it('raises slippage below the Symbiosis minimum to 10 bps', () => {
+        expect(getSymbiosisSlippageBps('0.0005')).toBe(10);
+        expect(getSymbiosisSlippageBps('0')).toBe(10);
+    });
+    it('lowers slippage above the Symbiosis maximum to 1000 bps', () => {
+        expect(getSymbiosisSlippageBps('0.25')).toBe(1000);
+    });
+});
+describe('getSymbiosisPartnerAddress', () => {
+    it('sends the partner address at the registered rate', () => {
+        expect(getSymbiosisPartnerAddress('60').unwrap()).toBe(SYMBIOSIS_PARTNER_ADDRESS);
+    });
+    it('omits the partner address for a fee-free swap', () => {
+        expect(getSymbiosisPartnerAddress('0').unwrap()).toBeUndefined();
+    });
+    it('rejects any other rate instead of silently dropping the fee', () => {
+        expect(getSymbiosisPartnerAddress('30').isErr()).toBe(true);
+        expect(getSymbiosisPartnerAddress('80').isErr()).toBe(true);
+    });
+});
+describe('buildSymbiosisTronCallData', () => {
+    const functionSelector = 'metaRoute((bytes,bytes,address[],address,address,uint256,bool,address,bytes))';
+    it('prefixes the parameters with the 4-byte selector of the signature', () => {
+        const data = `0x${'00'.repeat(31)}20`;
+        expect(buildSymbiosisTronCallData({ functionSelector, data })).toBe(`0xa11b1198${'00'.repeat(31)}20`);
+    });
+});
+describe('getSymbiosisFeeAssetId', () => {
+    it('maps a Tron hex address to its base58 trc20 asset id', () => {
+        expect(getSymbiosisFeeAssetId({
+            chainId: 728126428,
+            address: '0xa614f803b6fd780986a42c78ec9c7f77e6ded13c',
+        })).toBe(usdtOnTronAssetId);
+    });
+});
+describe('getSymbiosisProtocolFees', () => {
+    it('keeps resolvable fees and skips host chain sToken fees', () => {
+        expect(getSymbiosisProtocolFees(liveFees)).toEqual({
+            [BSC_USDC_ASSET_ID]: {
+                amountCryptoBaseUnit: '250000000000000000',
+                asset: { symbol: 'USDC', chainId: 'eip155:56', precision: 18 },
+                requiresBalance: false,
+            },
+        });
+    });
+    it('sums fees charged in the same asset', () => {
+        const fees = getSymbiosisProtocolFees([liveFees[1], liveFees[1]]);
+        expect(fees[BSC_USDC_ASSET_ID]?.amountCryptoBaseUnit).toBe('500000000000000000');
+    });
+});
+describe('getSymbiosisTradeStatus', () => {
+    const buySymbiosisChainId = 56;
+    const makeResponse = (overrides) => ({
+        status: { code: SymbiosisStatusCode.Success, text: 'Success' },
+        txIn: { hash: '0xsell', chainId: 42161 },
+        tx: { hash: '0xbuy', chainId: 56 },
+        ...overrides,
+    });
+    it('confirms with the destination hash once the destination tx is on the buy chain', () => {
+        expect(getSymbiosisTradeStatus({ response: makeResponse({}), buySymbiosisChainId })).toEqual({
+            status: TxStatus.Confirmed,
+            buyTxHash: '0xbuy',
+            message: undefined,
+        });
+    });
+    it('stays pending when Success describes the source transaction itself', () => {
+        const response = makeResponse({ tx: { hash: '0xsell', chainId: 42161 } });
+        expect(getSymbiosisTradeStatus({ response, buySymbiosisChainId })).toEqual({
+            status: TxStatus.Pending,
+            buyTxHash: undefined,
+            message: undefined,
+        });
+    });
+    it('names the transit token when the destination swap did not complete', () => {
+        const response = makeResponse({
+            transitTokenSent: {
+                chainId: 56,
+                address: BSC_USDC_ADDRESS,
+                decimals: 18,
+                symbol: 'USDC',
+                amount: '250000000000000000',
+            },
+        });
+        expect(getSymbiosisTradeStatus({ response, buySymbiosisChainId })).toEqual({
+            status: TxStatus.Confirmed,
+            buyTxHash: '0xbuy',
+            message: 'Received 0.25 USDC instead of the buy asset',
+        });
+    });
+    it('maps pending, stuck, reverted and not found', () => {
+        const pending = makeResponse({ status: { code: SymbiosisStatusCode.Pending, text: '' } });
+        const stuck = makeResponse({ status: { code: SymbiosisStatusCode.Stuck, text: '' } });
+        const reverted = makeResponse({ status: { code: SymbiosisStatusCode.Reverted, text: '' } });
+        const notFound = makeResponse({ status: { code: SymbiosisStatusCode.NotFound, text: '' } });
+        expect(getSymbiosisTradeStatus({ response: pending, buySymbiosisChainId }).status).toBe(TxStatus.Pending);
+        expect(getSymbiosisTradeStatus({ response: stuck, buySymbiosisChainId })).toEqual({
+            status: TxStatus.Pending,
+            buyTxHash: undefined,
+            message: 'Swap is stuck and is being reverted by Symbiosis',
+        });
+        expect(getSymbiosisTradeStatus({ response: reverted, buySymbiosisChainId })).toEqual({
+            status: TxStatus.Failed,
+            buyTxHash: undefined,
+            message: 'Swap was reverted by Symbiosis',
+        });
+        expect(getSymbiosisTradeStatus({ response: notFound, buySymbiosisChainId }).status).toBe(TxStatus.Unknown);
+    });
+});
+describe('isTronSourceTxFailed', () => {
+    it('is true for any contract result other than SUCCESS', () => {
+        expect(isTronSourceTxFailed({ ret: [{ contractRet: 'REVERT' }] })).toBe(true);
+        expect(isTronSourceTxFailed({ ret: [{ contractRet: 'OUT_OF_ENERGY' }] })).toBe(true);
+        expect(isTronSourceTxFailed({ ret: [{ contractRet: 'SUCCESS' }] })).toBe(false);
+    });
+});

package/dist/esm/swappers/SymbiosisSwapper/utils/symbiosisService.d.ts

@@ -0,0 +1,5 @@
+export declare const symbiosisService: {
+    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
+};

package/dist/esm/swappers/SymbiosisSwapper/utils/symbiosisService.js

@@ -0,0 +1,12 @@
+import axios from 'axios';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
+import { SYMBIOSIS_PARTNER_ID } from './constants.js';
+const symbiosisServiceBase = axios.create({
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'X-Partner-Id': SYMBIOSIS_PARTNER_ID,
+    },
+});
+export const symbiosisService = makeSwapperAxiosServiceMonadic(symbiosisServiceBase);

package/dist/esm/swappers/SymbiosisSwapper/utils/types.d.ts

@@ -0,0 +1,83 @@
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetTronTradeQuoteInput, GetTronTradeRateInput } from '../../../types.js';
+export type SymbiosisTradeQuoteInput = GetEvmTradeQuoteInput | GetTronTradeQuoteInput;
+export type SymbiosisTradeRateInput = GetEvmTradeRateInput | GetTronTradeRateInput;
+export type SymbiosisToken = {
+    chainId: number;
+    address: string;
+    decimals: number;
+    symbol: string;
+};
+export type SymbiosisTokenAmount = SymbiosisToken & {
+    amount: string;
+};
+export type SymbiosisQuoteRequest = {
+    tokenAmountIn: Omit<SymbiosisTokenAmount, 'symbol'>;
+    tokenOut: Omit<SymbiosisToken, 'symbol'>;
+    from: string;
+    to: string;
+    slippage: number;
+    disabledProviders: string;
+    partnerAddress?: string;
+};
+export type SymbiosisFee = {
+    provider: string;
+    description?: string;
+    value: SymbiosisTokenAmount;
+};
+export type SymbiosisEvmTx = {
+    chainId: number;
+    to: string;
+    data: string;
+    value?: string;
+};
+export type SymbiosisTronTx = {
+    chainId: number;
+    from: string;
+    to: string;
+    data: string;
+    value?: string;
+    feeLimit: number;
+    functionSelector?: string;
+};
+export type SymbiosisSwapTx = {
+    type: 'evm';
+    tx: SymbiosisEvmTx;
+} | {
+    type: 'tron';
+    tx: SymbiosisTronTx;
+};
+export type SymbiosisQuoteResponse = SymbiosisSwapTx & {
+    kind: string;
+    labels: string[];
+    approveTo?: string;
+    tokenAmountOut: SymbiosisTokenAmount;
+    tokenAmountOutMin: SymbiosisTokenAmount;
+    fees: SymbiosisFee[];
+    estimatedTime: number;
+};
+export type SymbiosisErrorResponse = {
+    code: number;
+    message: string;
+};
+export declare enum SymbiosisStatusCode {
+    NotFound = -1,
+    Success = 0,
+    Pending = 1,
+    Stuck = 2,
+    Reverted = 3
+}
+export type SymbiosisTxResponse = {
+    status: {
+        code: SymbiosisStatusCode;
+        text: string;
+    };
+    tx?: {
+        hash?: string;
+        chainId: number;
+    };
+    txIn?: {
+        hash?: string;
+        chainId: number;
+    };
+    transitTokenSent?: SymbiosisTokenAmount;
+};

package/dist/esm/swappers/SymbiosisSwapper/utils/types.js

@@ -0,0 +1,8 @@
+export var SymbiosisStatusCode;
+(function (SymbiosisStatusCode) {
+    SymbiosisStatusCode[SymbiosisStatusCode["NotFound"] = -1] = "NotFound";
+    SymbiosisStatusCode[SymbiosisStatusCode["Success"] = 0] = "Success";
+    SymbiosisStatusCode[SymbiosisStatusCode["Pending"] = 1] = "Pending";
+    SymbiosisStatusCode[SymbiosisStatusCode["Stuck"] = 2] = "Stuck";
+    SymbiosisStatusCode[SymbiosisStatusCode["Reverted"] = 3] = "Reverted";
+})(SymbiosisStatusCode || (SymbiosisStatusCode = {}));

package/dist/esm/swappers/ThorchainSwapper/generated/generatedThorLongtailTokens.json

@@ -1017,6 +1017,7 @@
     "eip155:1/erc20:0x2c06ba9e7f0daccbc1f6a33ea67e85bb68fbee3a",
     "eip155:1/erc20:0xcbb8f1bda10b9696c57e13bc128fe674769dcec0",
     "eip155:1/erc20:0x72dfb2e44f59c5ad2bafe84314e5b99a7cd5075e",
+    "eip155:1/erc20:0xce682c89c63d2850cb2ca898e44d6c7c30d897a6",
     "eip155:43114/erc20:0xc891eb4cbdeff6e073e859e987815ed1505c2acd",
     "eip155:43114/erc20:0xd24c2ad096400b6fbcd2ad8b24e7acbc21a1da64",
     "eip155:43114/erc20:0x47c3118ad183712acd42648e9e522e13690f29a0",

package/dist/esm/swappers/ThorchainSwapper/generated/generatedTradableAssetMap.json

@@ -41,5 +41,6 @@
     "THOR.TCY": "cosmos:thorchain-1/slip44:tcy",
     "TRON.TRX": "tron:0x2b6653dc/slip44:195",
     "TRON.USDT-TR7NHQJEKQXGTCI8Q8ZY4PL8OTSZGJLJ6T": "tron:0x2b6653dc/trc20:tr7nhqjekqxgtci8q8zy4pl8otszgjlj6t",
+    "ZEC.ZEC": "bip122:00040fe8ec8471911baa1db1266ea15d/slip44:133",
     "THOR.RUNE": "cosmos:thorchain-1/slip44:931"
 }

package/dist/esm/swappers/ThorchainSwapper/getTradeQuote/getTradeQuote.test.js

@@ -79,7 +79,7 @@ const expectedQuoteResponse = [
                             asset: ETH,
                         },
                     },
-                    networkFeeCryptoBaseUnit: '400000',
+                    networkFeeCryptoBaseUnit: '480000',
                 },
                 rate: '143505.61489594191334131621',
                 source: SwapperName.Thorchain,
@@ -130,7 +130,7 @@ const expectedQuoteResponse = [
                             asset: ETH,
                         },
                     },
-                    networkFeeCryptoBaseUnit: '400000',
+                    networkFeeCryptoBaseUnit: '480000',
                 },
                 rate: '157530.57158846677816130059',
                 source: `${SwapperName.Thorchain} • Streaming`,

package/dist/esm/swappers/ThorchainSwapper/utils/getLongtailQuote.js

@@ -74,7 +74,7 @@ export const getLongtailToL1Quote = async (input, deps, streamingInterval, swapp
         return Ok({
             ...quote,
             // The aggregator swapIn deadline is tighter than the daemon quote expiry
-            deadline: Math.min(quote.deadline, Number(deadline) * 1000),
+            deadline: Math.min(quote.deadline ?? Infinity, Number(deadline) * 1000),
             data: data ?? quote.data,
             // This logic will need to be updated to support multi-hop, if that's ever implemented for THORChain
             steps: quote.steps.map(s => ({

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

@@ -2,11 +2,13 @@ import { Err, Ok } from '@sniptt/monads';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS, isNativeEvmAsset } from '../../../utils/helpers.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
 import { fetchZrxQuote } from '../utils/fetchFromZrx.js';
+import { getZrxNativeCheckDeadline } from '../utils/getZrxNativeCheckDeadline.js';
 import { getZrxStepData } from '../utils/getZrxStepData.js';
 import { getZrxTradeContext } from '../utils/getZrxTradeContext.js';
 import { assertValidTrade, isWrappedNativeSell } from '../utils/helpers.js';
+const isValidDeadlineSeconds = (deadline) => Number.isSafeInteger(deadline) && deadline > 0 && Number.isSafeInteger(deadline * 1000);
 export const getZrxTradeQuote = async (input, deps) => {
     const { sellAsset, buyAsset, accountNumber, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
     const maybeAddresses = assertQuoteAddresses(input);
@@ -37,8 +39,18 @@ export const getZrxTradeQuote = async (input, deps) => {
     });
     if (maybeZrxQuoteResponse.isErr())
         return Err(maybeZrxQuoteResponse.unwrapErr());
-    const { sellAmount, buyAmount, fees, permit2, transaction, route } = maybeZrxQuoteResponse.unwrap();
+    const { sellAmount, buyAmount, fees, permit2, transaction, totalNetworkFee, route } = maybeZrxQuoteResponse.unwrap();
     const permit2Eip712 = permit2?.eip712;
+    const permit2Deadline = permit2Eip712 ? Number(permit2Eip712.message.deadline) : undefined;
+    if (permit2Deadline !== undefined &&
+        ((typeof permit2Eip712?.message.deadline !== 'string' &&
+            typeof permit2Eip712?.message.deadline !== 'number') ||
+            !isValidDeadlineSeconds(permit2Deadline))) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid Permit2 deadline from 0x response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
     if (!isNativeEvmAsset(sellAsset.assetId) && !isWrappedNativeSell(route) && !permit2Eip712) {
         return Err(makeSwapErrorRight({
             message: 'Missing required Permit2 metadata from 0x response',
@@ -53,6 +65,17 @@ export const getZrxTradeQuote = async (input, deps) => {
             details: { transaction, permit2Eip712 },
         }));
     }
+    // Permit2 calldata is not decodable until the signature is spliced in, so only native sells are read
+    const nativeCheckDeadline = permit2Eip712
+        ? undefined
+        : getZrxNativeCheckDeadline(transaction.data);
+    if (nativeCheckDeadline !== undefined && !isValidDeadlineSeconds(nativeCheckDeadline)) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid NATIVE_CHECK deadline in 0x calldata',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const deadlineSeconds = permit2Deadline ?? nativeCheckDeadline;
     const maybeContext = getZrxTradeContext({
         input,
         deps,
@@ -67,6 +90,8 @@ export const getZrxTradeQuote = async (input, deps) => {
         type: 'quote',
         input,
         transaction,
+        totalNetworkFee,
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         permit2Eip712,
         from: receiveAddress,
     });
@@ -76,7 +101,7 @@ export const getZrxTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
+        deadline: deadlineSeconds === undefined ? undefined : deadlineSeconds * 1000,
         receiveAddress,
         steps: [
             {

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

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

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

@@ -0,0 +1,108 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { Ok } from '@sniptt/monads';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { TradeQuoteError } from '../../../types.js';
+import { ETH, USDC_MAINNET, WETH } from '../../../utils/test-data/assets.js';
+import { fetchZrxQuote } from '../utils/fetchFromZrx.js';
+import { getZrxTradeQuote } from './getZrxTradeQuote.js';
+vi.mock('../utils/fetchFromZrx', () => ({ fetchZrxQuote: vi.fn() }));
+vi.mock('../utils/getZrxStepData', () => ({
+    getZrxStepData: vi.fn(({ permit2Eip712 }) => Promise.resolve(Ok({
+        transactionData: {
+            type: 'evm',
+            chainId: 1,
+            to: '0x1111111111111111111111111111111111111111',
+            data: '0x1234',
+            value: '0',
+            ...(permit2Eip712 && {
+                signatureRequired: { type: 'permit2', eip712: permit2Eip712 },
+            }),
+        },
+        networkFeeCryptoBaseUnit: '100000',
+    }))),
+}));
+const input = {
+    sellAsset: WETH,
+    buyAsset: USDC_MAINNET,
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: '1000000000000000000',
+    sendAddress: '0x1111111111111111111111111111111111111111',
+    receiveAddress: '0x1111111111111111111111111111111111111111',
+    accountNumber: 0,
+    affiliateBps: '0',
+    allowMultiHop: false,
+    quoteOrRate: 'quote',
+    chainId: KnownChainIds.EthereumMainnet,
+    supportsEIP1559: true,
+};
+const deps = {
+    assetsById: {},
+    config: { VITE_ZRX_BASE_URL: 'https://example.com' },
+};
+const typedData = (deadline) => ({
+    domain: { name: 'Permit2', chainId: 1 },
+    types: { PermitTransferFrom: [{ name: 'deadline', type: 'uint256' }] },
+    primaryType: 'PermitTransferFrom',
+    message: { deadline },
+});
+// Live Settler calldata for an ETH -> USDC sell, NATIVE_CHECK deadline 1791997786
+const nativeSellCalldata = '0x1fff991f000000000000000000000000ea8eb5ba11a3ea66f417ae29abf70c6fb4ba9626000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000e750ef800000000000000000000000000000000000000000000000000000000000000a0939d83c32b72441d72643cf60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000003600000000000000000000000000000000000000000000000000000000000000044bd01c226000000000000000000000000000000000000000000000000000000006acfb75a000000000000000000000000000000000000000000000000016345785d8a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010438c9c147000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee00000000000000000000000000000000000000000000000000000000000f4240000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000024d0e30db00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e48d68a156000000000000000000000000666fedd4cdd4e890a5ad20e7b60975409435a64a00000000000000000000000000000000000000000000000000000000000f4240000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040c02aaa39b223fe8d0a0e5c4f27ead9083c756cc201000064fffd8963efd1fc6a506488495d951d5263988d25a0b86991c6218b36c1d19d4a2e9eb0ce3606eb4800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008434ee90ca000000000000000000000000f5c4f3dc02c3fb9279495a8fef7b0741da956157000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000000000000000000000000000000000000e9a9ab900000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000';
+const quoteResponse = (eip712, data = '0x1234') => ({
+    blockNumber: '1',
+    buyAmount: '1000000',
+    buyToken: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    sellAmount: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+    sellToken: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+    fees: { integratorFee: null, zeroExFee: null, gasFee: null },
+    issues: { allowance: null, balance: null, simulationIncomplete: false, invalidSourcesPassed: [] },
+    liquidityAvailable: true,
+    minBuyAmount: '990000',
+    route: { fills: [], tokens: [] },
+    tokenMetadata: {
+        buyToken: { buyTaxBps: null, sellTaxBps: null },
+        sellToken: { buyTaxBps: null, sellTaxBps: null },
+    },
+    totalNetworkFee: null,
+    zid: 'test',
+    permit2: eip712 ? { type: 'Permit2', hash: '0x1234', eip712 } : null,
+    transaction: {
+        to: '0x1111111111111111111111111111111111111111',
+        data,
+        gas: '100000',
+        gasPrice: '1000000000',
+        value: '0',
+    },
+});
+describe('getZrxTradeQuote Permit2 deadline', () => {
+    beforeEach(() => {
+        vi.mocked(fetchZrxQuote).mockResolvedValue(Ok(quoteResponse(typedData('1791934983'))));
+    });
+    it.each(['1791934983', 1791934983])('uses the provider deadline in milliseconds (%s)', async (deadline) => {
+        const eip712 = typedData(deadline);
+        vi.mocked(fetchZrxQuote).mockResolvedValue(Ok(quoteResponse(eip712)));
+        const result = await getZrxTradeQuote(input, deps);
+        expect(result.isOk()).toBe(true);
+        const [quote] = result.unwrap();
+        expect(quote.deadline).toBe(1791934983000);
+        expect(quote.steps[0].transactionData).toMatchObject({
+            signatureRequired: { eip712 },
+        });
+    });
+    it.each([undefined, null, true, '', 'invalid', '-1', '1.5', '9007199254740991'])('rejects an invalid Permit2 deadline (%s)', async (deadline) => {
+        vi.mocked(fetchZrxQuote).mockResolvedValue(Ok(quoteResponse(typedData(deadline))));
+        const result = await getZrxTradeQuote(input, deps);
+        expect(result.isErr()).toBe(true);
+        expect(result.unwrapErr().code).toBe(TradeQuoteError.InvalidResponse);
+    });
+    it('reads the NATIVE_CHECK deadline from native-token sell calldata', async () => {
+        vi.mocked(fetchZrxQuote).mockResolvedValue(Ok(quoteResponse(null, nativeSellCalldata)));
+        const result = await getZrxTradeQuote({ ...input, sellAsset: ETH }, deps);
+        expect(result.isOk()).toBe(true);
+        expect(result.unwrap()[0].deadline).toBe(1791997786000);
+    });
+    it('leaves native-token quotes without a NATIVE_CHECK action free of a fabricated deadline', async () => {
+        vi.mocked(fetchZrxQuote).mockResolvedValue(Ok(quoteResponse(null)));
+        const result = await getZrxTradeQuote({ ...input, sellAsset: ETH }, deps);
+        expect(result.isOk()).toBe(true);
+        expect(result.unwrap()[0].deadline).toBeUndefined();
+    });
+});

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

@@ -1,5 +1,6 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
-import type { Address, TypedData } from 'viem';
+import type { TypedData } from 'eip-712';
+import type { Address } from 'viem';
 import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
 export type ZrxTradeQuoteInput = GetEvmTradeQuoteInput;
 export type ZrxTradeRateInput = GetEvmTradeRateInput;