@shapeshiftoss/swapper 20.2.0 → 20.4.0

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/endpoints.js

@@ -1,12 +1,11 @@
-import { SwapperName } from '../../types.js';
 import { getCosmosSdkTransactionFees, getUnsignedCosmosSdkTransaction } from '../../utils/cosmossdk/index.js';
 import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
-import { checkTradeStatus, tron } from '../../utils/thorchain/index.js';
+import { checkTradeStatus } from '../../utils/thorchain/index.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
 import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
 import { getTradeRate } from './getTradeRate/getTradeRate.js';
-const swapperName = SwapperName.Thorchain;
 export const thorchainApi = {
     getTradeRate: (input, deps) => getTradeRate(input, deps),
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
@@ -18,8 +17,8 @@ export const thorchainApi = {
     getCosmosSdkTransactionFees,
     getUnsignedSolanaTransaction,
     getSolanaTransactionFees,
-    getUnsignedTronTransaction: input => tron.getUnsignedTronTransaction(input, swapperName),
-    getTronTransactionFees: input => tron.getTronTransactionFees(input, swapperName),
+    getUnsignedTronTransaction,
+    getTronTransactionFees,
     checkTradeStatus: input => {
         const { config } = input;
         const nodeUrl = `${config.VITE_THORCHAIN_NODE_URL}/thorchain`;

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/utils/addL1ToLongtailPartsToMemo/addL1ToLongtailPartsToMemo.js

@@ -34,7 +34,12 @@ export const addL1ToLongtailPartsToMemo = ({ sellAssetChainId, quotedMemo, aggre
         finalAssetAddress: finalAssetContractAddressShortened,
     });
     const [prefix, nativeAssetName, address, nativeAssetLimitWithManualSlippage, affiliate, affiliateBps, aggregatorLastTwoChars, finalAssetContract,] = quotedMemoWithAggregatorAndFinalAssetContract.split(MEMO_PART_DELIMITER);
-    const shortenedNativeAssetName = shortenedNativeAssetNameByNativeAssetName[nativeAssetName];
+    // THORNode quote memos may already use the shortened native asset name
+    const shortenedNativeAssetNames = Object.values(shortenedNativeAssetNameByNativeAssetName);
+    const isAlreadyShortened = shortenedNativeAssetNames.includes(nativeAssetName);
+    const shortenedNativeAssetName = isAlreadyShortened
+        ? nativeAssetName
+        : shortenedNativeAssetNameByNativeAssetName[nativeAssetName];
     assert(shortenedNativeAssetName, 'cannot find shortened native asset name');
     const memoWithoutFinalAssetLimit = [
         prefix,

package/dist/esm/swappers/ThorchainSwapper/utils/addL1ToLongtailPartsToMemo/addL1ToLongtailPartsToMemo.test.js

@@ -35,6 +35,21 @@ describe('addL1ToLongtailPartsToMemo', () => {
         // The aggregator will turn the finalAssetAmountOut from 94136714201 to 9413671420 using the last 2 bytes as exponents
         `=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100:d2:a6df4741:94136714201`);
     });
+    it('should accept a quoted memo with an already shortened native asset name', () => {
+        const finalAssetAmountOut = '9508759019';
+        const quotedMemo = `=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100`;
+        const modifiedMemo = addL1ToLongtailPartsToMemo({
+            sellAssetChainId: ethChainId,
+            quotedMemo,
+            aggregator: AGGREGATOR_ADDRESS,
+            finalAssetAssetId: FINAL_ASSET_ASSETID,
+            finalAssetAmountOut,
+            slippageBps,
+            longtailTokens: THORCHAIN_ASSETIDS_ONE_COLLISION,
+            affiliate: THORCHAIN_AFFILIATE_NAME,
+        });
+        expect(modifiedMemo).toBe(`=:e:0x32DBc9Cf9E8FbCebE1e0a2ecF05Ed86Ca3096Cb6:42:ss:100:d2:a6df4741:94136714201`);
+    });
     it('should throw if chainId is BCH and initial memo length is > 220', () => {
         const finalAssetAmountOut = '2083854765519275828179229';
         const memoOver220Bytes = `=:ETH.ETH:${REALLY_BIG_ADDRESS}:42:ss:100`;

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

@@ -67,5 +67,12 @@ export const assertValidL1ToLongtailTrade = async ({ sellAsset, buyAsset, deps,
             details: { sellAssetChainId: sellAsset.chainId },
         }));
     }
+    if (sellAsset.assetId === buyAssetFeeAsset.assetId) {
+        return Err(makeSwapErrorRight({
+            message: `[getThorTradeQuote] - Cannot swap ${sellAsset.assetId} to itself before the aggregator.`,
+            code: TradeQuoteError.UnsupportedTradePair,
+            details: { buyAsset, sellAsset },
+        }));
+    }
     return Ok({ buyAssetFeeAsset, longtailTokens });
 };

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

@@ -1,4 +1,3 @@
-import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
 import { convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
@@ -82,7 +81,6 @@ export const getL1ToLongtailQuote = async (input, deps, streamingInterval, swapp
                 buyAmountAfterFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
-                allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
                 transactionData,
                 feeData: { ...s.feeData, networkFeeCryptoBaseUnit },
             })),

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

@@ -1,4 +1,3 @@
-import { TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET } from '@shapeshiftoss/contracts';
 import { Err, Ok } from '@sniptt/monads';
 import { getSuccessfulTrades, getThorL1TradeRate, TradeType } from '../../../utils/thorchain/index.js';
 import { assertValidL1ToLongtailTrade } from './assertValidLongtailTrade.js';
@@ -35,7 +34,6 @@ export const getL1ToLongtailRate = async (input, deps, streamingInterval, swappe
                 buyAmountAfterFeesCryptoBaseUnit: quotedAmountOut.toString(),
                 // This is wrong, we should get the get the value before fees or display ETH value received after the thorchain bridge
                 buyAmountBeforeFeesCryptoBaseUnit: quotedAmountOut.toString(),
-                allowanceContract: TS_AGGREGATOR_TOKEN_TRANSFER_PROXY_CONTRACT_MAINNET,
             })),
             isLongtail: true,
         });

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/ThorchainSwapper/utils/getUniqueAddressSubstring/getUniqueAddressSubstring.d.ts

@@ -1,2 +1,2 @@
 import type { AssetId } from '@shapeshiftoss/caip';
-export declare const getUniqueAddressSubstring: (destinationAssetId: AssetId, longTailAssetIds: AssetId[]) => AssetId;
+export declare const getUniqueAddressSubstring: (destinationAssetId: AssetId, longTailAssetIds: AssetId[]) => string;

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

@@ -1,23 +1,20 @@
+import { fromAssetId } from '@shapeshiftoss/caip';
+const MINIMUM_UNIQUE_SUBSTRING = 2;
+// Mirrors THORNode's externalAssetMatch: a case-insensitive suffix match against the target chain's token list only
 export const getUniqueAddressSubstring = (destinationAssetId, longTailAssetIds) => {
-    const MINIMUM_UNIQUE_SUBSTRING = 2;
-    let maybeShortenedDestinationAddress = destinationAssetId;
-    const substringsCount = {};
-    for (let length = MINIMUM_UNIQUE_SUBSTRING; length <= destinationAssetId.length - 2; length++) {
-        const currentSubstring = destinationAssetId.slice(-length);
-        substringsCount[currentSubstring] = 0;
+    const { chainId, assetReference } = fromAssetId(destinationAssetId);
+    const address = assetReference.toLowerCase();
+    const sameChainAddresses = longTailAssetIds
+        .map(assetId => fromAssetId(assetId))
+        .filter(asset => asset.chainId === chainId)
+        .map(asset => asset.assetReference.toLowerCase());
+    if (!sameChainAddresses.includes(address))
+        return address;
+    for (let length = MINIMUM_UNIQUE_SUBSTRING; length < address.length; length++) {
+        const suffix = address.slice(-length);
+        const matchCount = sameChainAddresses.filter(sameChainAddress => sameChainAddress.endsWith(suffix)).length;
+        if (matchCount === 1)
+            return suffix;
     }
-    longTailAssetIds.forEach(assetId => {
-        Object.keys(substringsCount).forEach(substring => {
-            if (assetId.includes(substring)) {
-                substringsCount[substring] += 1;
-            }
-        });
-    });
-    for (const [substring, count] of Object.entries(substringsCount)) {
-        if (count === 1) {
-            maybeShortenedDestinationAddress = substring;
-            break;
-        }
-    }
-    return maybeShortenedDestinationAddress;
+    return address;
 };

package/dist/esm/swappers/ThorchainSwapper/utils/getUniqueAddressSubstring/getUniqueAddressSubstring.test.js

@@ -1,5 +1,6 @@
-import { ethChainId, toAssetId } from '@shapeshiftoss/caip';
+import { bscChainId, ethChainId, toAssetId } from '@shapeshiftoss/caip';
 import { describe, expect, it } from 'vitest';
+import longtailTokens from '../../generated/generatedThorLongtailTokens.json';
 import { getUniqueAddressSubstring } from './getUniqueAddressSubstring.js';
 const FINAL_ASSET_ASSETID = toAssetId({
     chainId: ethChainId,
@@ -16,6 +17,16 @@ const BIGGER_COLLIDING_FINAL_ASSETID = toAssetId({
     assetReference: '0xa0b86991c6218b36c1d19d4a2e9eb032a6dF4741',
     assetNamespace: 'erc20',
 });
+const SAME_ADDRESS_OTHER_CHAIN_ASSETID = toAssetId({
+    chainId: bscChainId,
+    assetReference: '0x8a65ac0E23F31979db06Ec62Af62b432a6dF4741',
+    assetNamespace: 'erc20',
+});
+const ONE_INCH_ASSETID = toAssetId({
+    chainId: ethChainId,
+    assetReference: '0x111111111117dc0aa78b770fa6a738034120c302',
+    assetNamespace: 'erc20',
+});
 const SHORTENED_FINAL_ASSET_ADDRESS = 'a6df4741';
 const BIGGER_SHORTENED_FINAL_ASSET_ADDRESS = '432a6df4741';
 const THORCHAIN_ASSETIDS_ONE_COLLISION = [FINAL_ASSET_ASSETID, COLLIDING_FINAL_ASSETID];
@@ -33,4 +44,21 @@ describe('getUniqueAddressSubstring', () => {
         const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, THORCHAIN_ASSETIDS_TWO_COLLISION);
         expect(substring).toBe(BIGGER_SHORTENED_FINAL_ASSET_ADDRESS);
     });
+    it('should ignore the same address on other chains', () => {
+        const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, [
+            ...THORCHAIN_ASSETIDS_ONE_COLLISION,
+            SAME_ADDRESS_OTHER_CHAIN_ASSETID,
+        ]);
+        expect(substring).toBe(SHORTENED_FINAL_ASSET_ADDRESS);
+    });
+    it('should return the full address when the asset is not in the list', () => {
+        const substring = getUniqueAddressSubstring(FINAL_ASSET_ASSETID, [COLLIDING_FINAL_ASSETID]);
+        expect(substring).toBe('0x8a65ac0e23f31979db06ec62af62b432a6df4741');
+    });
+    it('should return a hex suffix for an address listed on multiple chains', () => {
+        expect(longtailTokens).toContain(ONE_INCH_ASSETID);
+        const substring = getUniqueAddressSubstring(ONE_INCH_ASSETID, longtailTokens);
+        expect(substring).toMatch(/^[0-9a-f]+$/);
+        expect('0x111111111117dc0aa78b770fa6a738034120c302'.endsWith(substring)).toBe(true);
+    });
 });

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);
@@ -39,6 +41,16 @@ export const getZrxTradeQuote = async (input, deps) => {
         return Err(maybeZrxQuoteResponse.unwrapErr());
     const { sellAmount, buyAmount, fees, permit2, transaction, 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,
@@ -76,7 +99,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 = '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';
+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;

package/dist/esm/swappers/ZrxSwapper/utils/getZrxNativeCheckDeadline.d.ts

@@ -0,0 +1 @@
+export declare const getZrxNativeCheckDeadline: (data: string) => number | undefined;

package/dist/esm/swappers/ZrxSwapper/utils/getZrxNativeCheckDeadline.js

@@ -0,0 +1,22 @@
+import { decodeFunctionData, parseAbi, toFunctionSelector } from 'viem';
+const settlerAbi = parseAbi([
+    'function execute((address recipient, address buyToken, uint256 minAmountOut) slippage, bytes[] actions, bytes32 zid)',
+    'function NATIVE_CHECK(uint256 deadline, uint256 msgValue)',
+]);
+const NATIVE_CHECK_SELECTOR = toFunctionSelector('function NATIVE_CHECK(uint256,uint256)');
+// Native sells carry no Permit2, but Settler reverts with SignatureExpired past any NATIVE_CHECK deadline
+export const getZrxNativeCheckDeadline = (data) => {
+    try {
+        const { functionName, args } = decodeFunctionData({ abi: settlerAbi, data: data });
+        if (functionName !== 'execute')
+            return undefined;
+        const deadlines = args[1]
+            .filter(action => action.startsWith(NATIVE_CHECK_SELECTOR))
+            .map(action => decodeFunctionData({ abi: settlerAbi, data: action }))
+            .flatMap(decoded => decoded.functionName === 'NATIVE_CHECK' ? [Number(decoded.args[0])] : []);
+        return deadlines.length ? Math.min(...deadlines) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};

package/dist/esm/types.d.ts

@@ -12,14 +12,12 @@ import type { InterpolationOptions } from 'node-polyglot';
 import type { AvnuMetadata } from './swappers/AvnuSwapper/types.js';
 import type { BebopMetadata } from './swappers/BebopSwapper/types.js';
 import type { BobGatewayMetadata } from './swappers/BobGatewaySwapper/types.js';
-import type { ButterSwapTransactionMetadata } from './swappers/ButterSwap/types.js';
 import type { ChainflipMetadata } from './swappers/ChainflipSwapper/types.js';
 import type { CowMessageToSign } from './swappers/CowSwapper/types.js';
 import type { DebridgeMetadata } from './swappers/DebridgeSwapper/utils/types.js';
 import type { NearIntentsMetadata } from './swappers/NearIntentsSwapper/types.js';
-import type { RelayMetadata, RelayTransactionMetadata } from './swappers/RelaySwapper/utils/types.js';
+import type { RelayMetadata } from './swappers/RelaySwapper/utils/types.js';
 import type { StonfiMetadata, StonfiTransactionData } from './swappers/StonfiSwapper/types.js';
-import type { SunioTransactionData } from './swappers/SunioSwapper/types.js';
 import type { makeSwapperAxiosServiceMonadic } from './utils/index.js';
 import type { MayachainMetadata, ThorchainMetadata } from './utils/thorchain/types.js';
 export type SwapperConfig = {
@@ -45,6 +43,7 @@ export type SwapperConfig = {
     VITE_COWSWAP_BASE_URL: string;
     VITE_PORTALS_BASE_URL: string;
     VITE_ZRX_BASE_URL: string;
+    VITE_FYND_BASE_URL: string;
     VITE_CHAINFLIP_API_KEY: string;
     VITE_CHAINFLIP_API_URL: string;
     VITE_FEATURE_CHAINFLIP_SWAP_DCA: boolean;
@@ -58,6 +57,7 @@ export type SwapperConfig = {
     VITE_ACROSS_API_KEY: string;
     VITE_DEBRIDGE_API_URL: string;
     VITE_BOB_GATEWAY_API_KEY: string;
+    VITE_SYMBIOSIS_API_URL: string;
 };
 export declare enum SwapperName {
     Thorchain = "THORChain",
@@ -78,7 +78,9 @@ export declare enum SwapperName {
     Stonfi = "STON.fi",
     Across = "Across",
     Debridge = "deBridge",
-    BobGateway = "BOB Gateway"
+    BobGateway = "BOB Gateway",
+    Symbiosis = "Symbiosis",
+    Fynd = "Fynd"
 }
 export type SwapSource = SwapperName | `${SwapperName} • ${string}`;
 export type SwapErrorRight = {
@@ -323,8 +325,9 @@ export type TxBuildData = {
 } | {
     type: 'tron';
     to: string;
-    data: string;
     value: string;
+    data?: string;
+    memo?: string;
 } | {
     type: 'cowswap';
     chainId: ChainId;
@@ -344,12 +347,6 @@ export type TradeStepCommon = {
     estimatedExecutionTimeMs: number | undefined;
     swapperMetadata?: SwapperMetadata;
     stonfiTransactionData?: StonfiTransactionData;
-    sunioTransactionData?: SunioTransactionData;
-    relayTransactionMetadata?: RelayTransactionMetadata;
-    butterSwapTransactionMetadata?: ButterSwapTransactionMetadata;
-    chainflipSpecific?: {
-        depositAddress?: string;
-    };
     affiliateFee?: AffiliateFee;
 };
 export type TradeQuoteStep = TradeStepCommon & {
@@ -456,7 +453,7 @@ export type TradeQuote = TradeQuoteBase & {
 } & {
     quoteOrRate: 'quote';
     receiveAddress: string;
-    deadline: number;
+    deadline?: number;
 };
 export type MultiHopTradeQuote = TradeQuote & {
     steps: MultiHopTradeQuoteSteps;
@@ -477,6 +474,11 @@ export type EvmMessageExecutionProps = {
 };
 export type UtxoTransactionExecutionProps = {
     signAndBroadcastTransaction: (txToSign: SignTx<UtxoChainId>) => Promise<string>;
+    signTransaction?: (txToSign: SignTx<UtxoChainId>) => Promise<string>;
+};
+export type UtxoTransactionExecutionContext = {
+    config: SwapperConfig;
+    swapperMetadata: SwapperMetadata | undefined;
 };
 export type CosmosSdkTransactionExecutionProps = {
     signAndBroadcastTransaction: (txToSign: SignTx<CosmosSdkChainId>) => Promise<string>;
@@ -587,7 +589,7 @@ export type Swapper = {
     supportsExternalPayment?: boolean;
     executeEvmTransaction?: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
     executeEvmMessage?: (txMetaToSign: EvmMessageToSign, callbacks: EvmMessageExecutionProps, config: SwapperConfig) => Promise<string>;
-    executeUtxoTransaction?: (txToSign: SignTx<UtxoChainId>, callbacks: UtxoTransactionExecutionProps) => Promise<string>;
+    executeUtxoTransaction?: (txToSign: SignTx<UtxoChainId>, callbacks: UtxoTransactionExecutionProps, context?: UtxoTransactionExecutionContext) => Promise<string>;
     executeCosmosSdkTransaction?: (txToSign: SignTx<CosmosSdkChainId>, callbacks: CosmosSdkTransactionExecutionProps) => Promise<string>;
     executeSolanaTransaction?: (txToSign: SolanaSignTx, callbacks: SolanaTransactionExecutionProps) => Promise<string>;
     executeSolanaMessage?: (messageData: SolanaMessageToSign, callbacks: SolanaMessageExecutionProps, config: SwapperConfig) => Promise<string>;

package/dist/esm/types.js

@@ -19,6 +19,8 @@ export var SwapperName;
     SwapperName["Across"] = "Across";
     SwapperName["Debridge"] = "deBridge";
     SwapperName["BobGateway"] = "BOB Gateway";
+    SwapperName["Symbiosis"] = "Symbiosis";
+    SwapperName["Fynd"] = "Fynd";
 })(SwapperName || (SwapperName = {}));
 export var TradeQuoteError;
 (function (TradeQuoteError) {