@shapeshiftoss/swapper 20.3.0 → 20.4.0

package/dist/cjs/swappers/FyndSwapper/utils/getFyndStepData.d.ts

@@ -0,0 +1,25 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types';
+import type { FyndEncodedQuote } from '../types';
+type BaseArgs = {
+    quote: FyndEncodedQuote;
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+};
+export type GetFyndStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type FyndRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type FyndQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getFyndStepData(args: Extract<GetFyndStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<FyndRateStepData, SwapErrorRight>>;
+export declare function getFyndStepData(args: Extract<GetFyndStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<FyndQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/FyndSwapper/utils/getFyndStepData.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFyndStepData = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const utils_1 = require("../../../utils");
+const evm_1 = require("../../../utils/evm");
+async function getFyndStepData(args) {
+    const { quote, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, from, type, input, deps } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number((0, caip_1.fromChainId)(sellAsset.chainId).chainReference),
+        to: quote.transaction.to,
+        data: quote.transaction.data,
+        value: quote.transaction.value,
+    };
+    const stateOverride = { sellAsset, sellAmountCryptoBaseUnit, spenderAddress };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+        })
+            .catch(() => (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({ adapter, supportsEIP1559, gasLimit: quote.gas_estimate }))
+            .catch(() => undefined);
+        const stepData = { networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return (0, monads_1.Ok)(stepData);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getFyndStepData', error));
+    }
+}
+exports.getFyndStepData = getFyndStepData;

package/dist/cjs/swappers/FyndSwapper/utils/getFyndTradeContext.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
+import type { FyndTradeQuoteInput, FyndTradeRateInput } from '../types';
+import type { GetFyndStepDataArgs } from './getFyndStepData';
+type FyndTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    deadline: number | undefined;
+    stepDataArgs: Omit<GetFyndStepDataArgs, 'type' | 'input'>;
+};
+export declare const getFyndTradeContext: ({ input, deps, from, to, }: {
+    input: FyndTradeQuoteInput | FyndTradeRateInput;
+    deps: SwapperDeps;
+    from: string;
+    to: string;
+}) => Promise<Result<FyndTradeContext, SwapErrorRight>>;
+export {};

package/dist/cjs/swappers/FyndSwapper/utils/getFyndTradeContext.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFyndTradeContext = void 0;
+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");
+const fetchFromFynd_1 = require("./fetchFromFynd");
+const helpers_2 = require("./helpers");
+const getFyndTradeContext = async ({ input, deps, from, to, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const maybeChainId = (0, helpers_2.assertValidTrade)({ sellAsset, buyAsset });
+    if (maybeChainId.isErr())
+        return (0, monads_1.Err)(maybeChainId.unwrapErr());
+    const chainId = maybeChainId.unwrap();
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        (0, constants_1.getDefaultSlippageDecimalPercentageForSwapper)(types_1.SwapperName.Fynd);
+    const clientFeeBps = (0, helpers_2.getFyndClientFeeBps)(affiliateBps);
+    const maybeQuote = await (0, fetchFromFynd_1.fetchFromFynd)({
+        input,
+        chainId,
+        sender: from,
+        receiver: to,
+        slippageTolerancePercentageDecimal,
+        clientFeeBps,
+        baseUrl: deps.config.VITE_FYND_BASE_URL,
+    });
+    if (maybeQuote.isErr())
+        return (0, monads_1.Err)(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const { router_fee: routerFee, client_fee: clientFee } = quote.fee_breakdown;
+    const buyAmountBeforeFeesCryptoBaseUnit = quote.amount_out;
+    const buyAmountAfterFeesCryptoBaseUnit = (0, utils_1.bn)(quote.amount_out)
+        .minus(routerFee)
+        .minus(clientFee)
+        .toFixed();
+    const rate = (0, utils_2.getInputOutputRate)({
+        sellAmountCryptoBaseUnit: quote.amount_in,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const protocols = (0, helpers_2.getFyndRouteProtocols)(quote.route?.swaps);
+    const source = protocols.length
+        ? `${types_1.SwapperName.Fynd} • ${protocols.join(', ')}`
+        : types_1.SwapperName.Fynd;
+    const allowanceContract = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? '' : quote.transaction.to;
+    const protocolFees = (0, utils_1.bn)(routerFee).gt(0)
+        ? {
+            [buyAsset.assetId]: {
+                amountCryptoBaseUnit: routerFee,
+                asset: buyAsset,
+                requiresBalance: false,
+            },
+        }
+        : {};
+    return (0, monads_1.Ok)({
+        tradeCommon: {
+            id: (0, uuid_1.v4)(),
+            rate,
+            swapperName: types_1.SwapperName.Fynd,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            estimatedExecutionTimeMs: 0,
+            allowanceContract,
+            rate,
+            sellAsset,
+            buyAsset,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            source,
+            affiliateFee: (0, utils_1.bn)(clientFee).gt(0)
+                ? { assetId: buyAsset.assetId, amountCryptoBaseUnit: clientFee, asset: buyAsset }
+                : undefined,
+        },
+        protocolFees,
+        deadline: quote.client_fee_deadline ? (0, helpers_1.normalizeEpochToMs)(quote.client_fee_deadline) : undefined,
+        stepDataArgs: {
+            quote,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            from,
+            deps,
+        },
+    });
+};
+exports.getFyndTradeContext = getFyndTradeContext;

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

@@ -0,0 +1,24 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { Address } from 'viem';
+import type { SwapErrorRight } from '../../../types';
+import type { FyndEncodedQuote, FyndQuoteResponse, FyndRouteSwap } from '../types';
+import type { FyndSupportedChainId } from './constants';
+export declare const getFyndRouteProtocols: (swaps: FyndRouteSwap[] | undefined) => string[];
+export declare const getFyndClientFeeBps: (affiliateBps: string) => number;
+export declare const convertAssetIdToFyndToken: (assetId: AssetId) => Address;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<FyndSupportedChainId, SwapErrorRight>;
+export declare const getFyndRequestError: (error: SwapErrorRight) => SwapErrorRight;
+type FyndQuoteContext = {
+    chainId: FyndSupportedChainId;
+    sellAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    slippageTolerancePercentageDecimal: string;
+    clientFeeBps: number;
+};
+export declare const validateFyndQuoteResponse: (response: FyndQuoteResponse, context: FyndQuoteContext) => Result<FyndEncodedQuote, SwapErrorRight>;
+export {};

package/dist/cjs/swappers/FyndSwapper/utils/helpers.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFyndQuoteResponse = exports.getFyndRequestError = exports.assertValidTrade = exports.convertAssetIdToFyndToken = exports.getFyndClientFeeBps = exports.getFyndRouteProtocols = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const axios_1 = __importDefault(require("axios"));
+const viem_1 = require("viem");
+const types_1 = require("../../../types");
+const utils_2 = require("../../../utils");
+const helpers_1 = require("../../../utils/helpers");
+const constants_1 = require("./constants");
+const isFyndSupportedChainId = (chainId) => chainId in constants_1.FYND_CHAINS;
+// Protocol ids look like uniswap_v3, vm:balancer_v2 or fallback:rfq:bebop
+const formatFyndProtocol = (protocol) => protocol
+    .slice(protocol.lastIndexOf(':') + 1)
+    .split('_')
+    .map(word => /^v\d+$/.test(word) ? word.toUpperCase() : word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+// The native_wrapper hop is only the WETH wrap/unwrap around the real venues
+const getFyndRouteProtocols = (swaps) => {
+    const venues = (swaps ?? [])
+        .map(swap => swap.protocol)
+        .filter(protocol => !protocol.endsWith('native_wrapper'));
+    return [...new Set(venues)].map(formatFyndProtocol);
+};
+exports.getFyndRouteProtocols = getFyndRouteProtocols;
+const getFyndClientFeeBps = (affiliateBps) => (0, utils_1.bn)(affiliateBps).div(constants_1.FYND_CLIENT_FEE_SHARE).integerValue(utils_1.BigNumber.ROUND_CEIL).toNumber();
+exports.getFyndClientFeeBps = getFyndClientFeeBps;
+const convertAssetIdToFyndToken = (assetId) => {
+    if ((0, helpers_1.isNativeEvmAsset)(assetId))
+        return viem_1.zeroAddress;
+    return (0, viem_1.getAddress)((0, caip_1.fromAssetId)(assetId).assetReference);
+};
+exports.convertAssetIdToFyndToken = convertAssetIdToFyndToken;
+const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    if (sellAsset.chainId !== buyAsset.chainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Fynd does not support cross-chain trades',
+            code: types_1.TradeQuoteError.CrossChainNotSupported,
+        }));
+    }
+    if (!isFyndSupportedChainId(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: 'Fynd only supports configured EVM chains',
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    return (0, monads_1.Ok)(sellAsset.chainId);
+};
+exports.assertValidTrade = assertValidTrade;
+const getFyndStatusError = (status, detail) => {
+    const code = (() => {
+        switch (status.toLowerCase()) {
+            case 'no_route_found':
+            case 'insufficient_liquidity':
+                return types_1.TradeQuoteError.NoRouteFound;
+            case 'timeout':
+                return types_1.TradeQuoteError.Timeout;
+            default:
+                return types_1.TradeQuoteError.QueryFailed;
+        }
+    })();
+    return (0, utils_2.makeSwapErrorRight)({
+        message: `Fynd quote failed: ${status}${detail ? ` (${detail})` : ''}`,
+        code,
+    });
+};
+const isFyndErrorResponse = (value) => typeof value === 'object' &&
+    value !== null &&
+    'error' in value &&
+    typeof value.error === 'string' &&
+    'code' in value &&
+    typeof value.code === 'string';
+const getFyndRequestError = (error) => {
+    const { cause } = error;
+    if (!axios_1.default.isAxiosError(cause))
+        return error;
+    if (cause.response?.status === 429) {
+        return (0, utils_2.makeSwapErrorRight)({
+            message: 'Fynd rate limit exceeded',
+            code: types_1.TradeQuoteError.RateLimitExceeded,
+        });
+    }
+    const body = cause.response?.data;
+    if (isFyndErrorResponse(body))
+        return getFyndStatusError(body.code, body.error);
+    return (0, utils_2.makeSwapErrorRight)({
+        message: `Fynd request failed with status ${cause.response?.status}`,
+        code: types_1.TradeQuoteError.QueryFailed,
+        cause,
+    });
+};
+exports.getFyndRequestError = getFyndRequestError;
+const invalidResponse = (message, details) => (0, utils_2.makeSwapErrorRight)({ message, details, code: types_1.TradeQuoteError.InvalidResponse });
+const getQuoteError = (quote, { chainId, sellAsset, sellAmountCryptoBaseUnit, slippageTolerancePercentageDecimal, clientFeeBps, }) => {
+    const { transaction, fee_breakdown: fees } = quote;
+    const pinnedRouter = constants_1.FYND_CHAINS[chainId].routerAddress;
+    if (!(0, viem_1.isAddress)(transaction.to, { strict: false }) ||
+        !(0, viem_1.isAddressEqual)(transaction.to, pinnedRouter)) {
+        return invalidResponse(`Fynd router ${transaction.to} is not the pinned router ${pinnedRouter} for ${chainId}`);
+    }
+    if (!(0, utils_1.bn)(quote.amount_in).eq(sellAmountCryptoBaseUnit)) {
+        return invalidResponse('Fynd quoted a different sell amount', {
+            amountIn: quote.amount_in,
+            sellAmountCryptoBaseUnit,
+        });
+    }
+    const expectedValue = (0, helpers_1.isNativeEvmAsset)(sellAsset.assetId) ? sellAmountCryptoBaseUnit : '0';
+    if (!(0, utils_1.bn)(transaction.value).eq(expectedValue)) {
+        return invalidResponse('Fynd transaction value does not match the sell amount', {
+            value: transaction.value,
+            expectedValue,
+        });
+    }
+    // The router enforces min_amount_received, which may not be looser than the requested slippage
+    const netOutput = (0, utils_1.bn)(quote.amount_out).minus(fees.router_fee).minus(fees.client_fee);
+    const outputFloor = netOutput
+        .times((0, utils_1.bn)(1).minus(slippageTolerancePercentageDecimal))
+        .integerValue(utils_1.BigNumber.ROUND_DOWN);
+    if ((0, utils_1.bn)(fees.min_amount_received).lt(outputFloor)) {
+        return invalidResponse('Fynd output floor is below the requested slippage', {
+            minAmountReceived: fees.min_amount_received,
+            outputFloor: outputFloor.toFixed(),
+            slippageTolerancePercentageDecimal,
+        });
+    }
+    if (clientFeeBps === 0) {
+        if (!(0, utils_1.bn)(fees.client_fee).isZero()) {
+            return invalidResponse('Fynd returned an unexpected client fee', {
+                clientFee: fees.client_fee,
+            });
+        }
+        return;
+    }
+    // Our share of the gross client fee, allowing one unit of rounding
+    const minClientFee = (0, utils_1.bn)(quote.amount_out)
+        .times(clientFeeBps)
+        .div(10_000)
+        .times(constants_1.FYND_CLIENT_FEE_SHARE)
+        .integerValue(utils_1.BigNumber.ROUND_DOWN)
+        .minus(1);
+    if ((0, utils_1.bn)(fees.client_fee).lt(minClientFee)) {
+        return invalidResponse('Fynd client fee is below the requested share', {
+            clientFee: fees.client_fee,
+            amountOut: quote.amount_out,
+            clientFeeBps,
+        });
+    }
+    // The proxy patches the signature over Fynd's zeroed placeholder at the reported offset
+    const offset = transaction.client_fee_signature_offset;
+    const signature = typeof offset === 'number'
+        ? transaction.data.slice(2 + offset * 2, 2 + (offset + constants_1.FYND_CLIENT_FEE_SIGNATURE_BYTES) * 2)
+        : '';
+    if (signature.length !== constants_1.FYND_CLIENT_FEE_SIGNATURE_BYTES * 2 || /^0+$/.test(signature)) {
+        return invalidResponse('Fynd quote is not signed for the client fee', { offset });
+    }
+    if (!quote.client_fee_deadline) {
+        return invalidResponse('Fynd quote is missing its client fee deadline');
+    }
+};
+const validateFyndQuoteResponse = (response, context) => {
+    const order = Array.isArray(response?.orders) ? response.orders[0] : undefined;
+    if (!order)
+        return (0, monads_1.Err)(invalidResponse('Fynd returned no order'));
+    if (order.status !== 'success')
+        return (0, monads_1.Err)(getFyndStatusError(order.status));
+    const error = getQuoteError(order, context);
+    return error ? (0, monads_1.Err)(error) : (0, monads_1.Ok)(order);
+};
+exports.validateFyndQuoteResponse = validateFyndQuoteResponse;

package/dist/cjs/swappers/FyndSwapper/utils/helpers.test.d.ts

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

package/dist/cjs/swappers/FyndSwapper/utils/helpers.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@shapeshiftoss/types");
+const vitest_1 = require("vitest");
+const assets_1 = require("../../../utils/test-data/assets");
+const constants_1 = require("./constants");
+const helpers_1 = require("./helpers");
+(0, vitest_1.describe)('getFyndClientFeeBps', () => {
+    vitest_1.it.each([
+        ['nets the default fee after the 20% share', '60', 75],
+        ['rounds up so the net never falls short', '55', 69],
+        ['requests nothing for a fee-free swap', '0', 0],
+    ])('%s', (_label, affiliateBps, grossBps) => {
+        (0, vitest_1.expect)((0, helpers_1.getFyndClientFeeBps)(affiliateBps)).toBe(grossBps);
+    });
+});
+(0, vitest_1.describe)('validateFyndQuoteResponse', () => {
+    const router = constants_1.FYND_CHAINS['eip155:1'].routerAddress;
+    const unpinnedRouter = '0x1111111111111111111111111111111111111111';
+    const transaction = {
+        to: router,
+        value: '0',
+        data: '0x12345678',
+        client_fee_signature_offset: null,
+    };
+    const fees = { router_fee: '10', client_fee: '0', max_slippage: '4', min_amount_received: '986' };
+    const order = {
+        status: 'success',
+        amount_in: '1000',
+        amount_out: '1000',
+        gas_estimate: '21000',
+        transaction,
+        fee_breakdown: fees,
+    };
+    const context = {
+        chainId: types_1.KnownChainIds.EthereumMainnet,
+        sellAsset: assets_1.WETH,
+        sellAmountCryptoBaseUnit: '1000',
+        slippageTolerancePercentageDecimal: '0.005',
+        clientFeeBps: 0,
+    };
+    const validate = (overrides, contextOverrides = {}) => (0, helpers_1.validateFyndQuoteResponse)({ orders: [{ ...order, ...overrides }] }, { ...context, ...contextOverrides });
+    (0, vitest_1.it)('accepts a quote that matches the request', () => {
+        (0, vitest_1.expect)(validate({}).isOk()).toBe(true);
+    });
+    vitest_1.it.each([
+        ['an unpinned router', { transaction: { ...transaction, to: unpinnedRouter } }],
+        ['a different sell amount', { amount_in: '999' }],
+        ['native value on a token sell', { transaction: { ...transaction, value: '1' } }],
+        [
+            'an output floor looser than the slippage',
+            { fee_breakdown: { ...fees, min_amount_received: '984' } },
+        ],
+        ['a client fee we did not request', { fee_breakdown: { ...fees, client_fee: '1' } }],
+    ])('rejects %s', (_label, overrides) => {
+        (0, vitest_1.expect)(validate(overrides).isErr()).toBe(true);
+    });
+    (0, vitest_1.it)('binds native transaction value to the requested sell amount', () => {
+        (0, vitest_1.expect)(validate({}, { sellAsset: assets_1.ETH }).isErr()).toBe(true);
+        (0, vitest_1.expect)(validate({ transaction: { ...transaction, value: '1000' } }, { sellAsset: assets_1.ETH }).isOk()).toBe(true);
+    });
+    (0, vitest_1.it)('maps a missing route to NoRouteFound', () => {
+        const result = (0, helpers_1.validateFyndQuoteResponse)({ orders: [{ status: 'no_route_found' }] }, context);
+        (0, vitest_1.expect)(result.unwrapErr().code).toBe('NoRouteFound');
+    });
+    (0, vitest_1.describe)('with a client fee', () => {
+        const feeContext = { clientFeeBps: 75 };
+        const feeOrder = {
+            transaction: {
+                ...transaction,
+                data: `0x12345678${'ab'.repeat(65)}`,
+                client_fee_signature_offset: 4,
+            },
+            fee_breakdown: {
+                router_fee: '2',
+                client_fee: '6',
+                max_slippage: '4',
+                min_amount_received: '988',
+            },
+            client_fee_deadline: 1_900_000_000,
+        };
+        (0, vitest_1.it)('accepts a signed quote carrying our share of the fee', () => {
+            (0, vitest_1.expect)(validate(feeOrder, feeContext).isOk()).toBe(true);
+        });
+        vitest_1.it.each([
+            [
+                'a fee below our share',
+                {
+                    fee_breakdown: { ...feeOrder.fee_breakdown, client_fee: '4', min_amount_received: '990' },
+                },
+            ],
+            [
+                'an unsigned placeholder',
+                { transaction: { ...feeOrder.transaction, data: `0x12345678${'00'.repeat(65)}` } },
+            ],
+            ['a missing deadline', { client_fee_deadline: null }],
+        ])('rejects %s', (_label, overrides) => {
+            (0, vitest_1.expect)(validate({ ...feeOrder, ...overrides }, feeContext).isErr()).toBe(true);
+        });
+    });
+});

package/dist/cjs/swappers/MayachainSwapper/generated/generatedTradableAssetMap.json

@@ -4,7 +4,6 @@
     "ARB.ETH": "eip155:42161/slip44:60",
     "ARB.GLD-0XAFD091F140C21770F4E5D53D26B2859AE97555AA": "eip155:42161/erc20:0xafd091f140c21770f4e5d53d26b2859ae97555aa",
     "ARB.LEO-0X93864D81175095DD93360FFA2A529B8642F76A6E": "eip155:42161/erc20:0x93864d81175095dd93360ffa2a529b8642f76a6e",
-    "ARB.LINK-0XF97F4DF75117A78C1A5A0DBB814AF92458539FB4": "eip155:42161/erc20:0xf97f4df75117a78c1a5a0dbb814af92458539fb4",
     "ARB.PEPE-0X25D887CE7A35172C62FEBFD67A1856F20FAEBB00": "eip155:42161/erc20:0x25d887ce7a35172c62febfd67a1856f20faebb00",
     "ARB.TGT-0X429FED88F10285E61B12BDF00848315FBDFCC341": "eip155:42161/erc20:0x429fed88f10285e61b12bdf00848315fbdfcc341",
     "ARB.USDC-0XAF88D065E77C8CC2239327C5EDB3A432268E5831": "eip155:42161/erc20:0xaf88d065e77c8cc2239327c5edb3a432268e5831",

package/dist/cjs/swappers/PortalsSwapper/endpoints.js

@@ -62,7 +62,7 @@ exports.portalsApi = {
                 const txStatus = relayTxStatus === unchained_client_1.TxStatus.Unknown ? unchained_client_1.TxStatus.Pending : relayTxStatus;
                 return {
                     status: txStatus,
-                    buyTxHash: relayRequest.data?.outTxs?.[0]?.hash,
+                    buyTxHash: relayRequest.data?.outTxs?.[0]?.txHash,
                     message: txStatus === unchained_client_1.TxStatus.Failed
                         ? (0, relayStatus_1.getRelayRequestFailureMessage)(relayRequest)
                         : txStatus === unchained_client_1.TxStatus.Confirmed
@@ -71,6 +71,9 @@ exports.portalsApi = {
                 };
             }
         }
+        else {
+            console.error('Failed to fetch relay request:', relayResult.unwrapErr());
+        }
         const axelarscanResult = await (0, fetchAxelarscanStatus_1.fetchAxelarscanBridgeStatus)(txHash);
         if (axelarscanResult.isOk()) {
             const bridgeStatus = axelarscanResult.unwrap();

package/dist/cjs/swappers/PortalsSwapper/getPortalsTradeQuote/getPortalsTradeQuote.js

@@ -141,7 +141,7 @@ const getPortalsTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: expiryMs ?? Date.now() + helpers_1.FALLBACK_QUOTE_DEADLINE_MS,
+        deadline: expiryMs,
         receiveAddress,
         steps: [
             {

package/dist/cjs/swappers/RelaySwapper/getTradeQuote/getTradeQuote.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExactOutputTradeQuote = exports.getTradeQuote = void 0;
 const monads_1 = require("@sniptt/monads");
 const utils_1 = require("../../../utils");
-const helpers_1 = require("../../../utils/helpers");
 const getRelayStepData_1 = require("../utils/getRelayStepData");
 const getRelayTradeContext_1 = require("../utils/getRelayTradeContext");
 const getQuote = async (input, deps, relayChainMap) => {
@@ -15,7 +14,7 @@ const getQuote = async (input, deps, relayChainMap) => {
     const maybeContext = await (0, getRelayTradeContext_1.getRelayTradeContext)({ input, deps, relayChainMap });
     if (maybeContext.isErr())
         return (0, monads_1.Err)(maybeContext.unwrapErr());
-    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId } = maybeContext.unwrap();
+    const { tradeCommon, stepCommon, protocolFees, relayStepInputs, stepDataArgs, relayId, deadline, } = maybeContext.unwrap();
     const stepResults = await Promise.all(relayStepInputs.map(async ({ data, allowanceContract }) => {
         const maybeStepData = await (0, getRelayStepData_1.getRelayStepData)({
             ...stepDataArgs,
@@ -45,7 +44,7 @@ const getQuote = async (input, deps, relayChainMap) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + helpers_1.FALLBACK_QUOTE_DEADLINE_MS,
+        deadline,
         receiveAddress,
         steps,
     };

package/dist/cjs/swappers/RelaySwapper/utils/getRelayTradeContext.d.ts

@@ -13,6 +13,7 @@ type RelayTradeContext = {
     }[];
     stepDataArgs: Omit<GetRelayStepDataArgs, 'type' | 'input' | 'data' | 'spenderAddress'>;
     relayId: string;
+    deadline: number | undefined;
 };
 export declare const getRelayTradeContext: ({ input, deps, relayChainMap, }: {
     input: RelayTradeQuoteInput | RelayTradeRateInput | RelayExactOutputTradeQuoteInput | RelayExactOutputTradeRateInput;

package/dist/cjs/swappers/RelaySwapper/utils/getRelayTradeContext.js

@@ -264,6 +264,9 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
         .plus(appFeesBaseUnit)
         .toFixed();
     const relayId = quote.steps[0].requestId;
+    // Only cross-chain (protocol v2) orders carry an expiry; past it the solver submits a no-fill refund
+    const orderDeadline = quote.protocol?.v2?.orderData?.output?.deadline;
+    const deadline = orderDeadline === undefined ? undefined : (0, helpers_1.normalizeEpochToMs)(orderDeadline);
     const relayStepInputs = swapSteps.map(step => {
         const data = step.items?.[0]?.data;
         return { data, allowanceContract: (0, helpers_2.getRelayAllowanceContract)(data) };
@@ -307,6 +310,7 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
             ...appFeesAsProtocolFee,
         },
         relayStepInputs,
+        deadline,
         stepDataArgs: {
             sellAsset,
             sellAmountCryptoBaseUnit,

package/dist/cjs/swappers/RelaySwapper/utils/relayStatus.js

@@ -25,14 +25,14 @@ const relayStatusToTxStatus = (status) => {
 exports.relayStatusToTxStatus = relayStatusToTxStatus;
 // Relay index requests by origin tx hash, resolving a swap we hold no relayId for
 const fetchRelayRequestByTxHash = async (txHash, config) => {
-    const maybeResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/requests/v2?hash=${txHash}`, (0, relayService_1.getRelayRequestConfig)(config));
+    const maybeResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/requests/v3?depositTxHash=${txHash}`, (0, relayService_1.getRelayRequestConfig)(config));
     // Match the origin tx ourselves rather than trusting the listing to have filtered on it
-    return maybeResponse.map(({ data }) => data.requests?.find(({ data: request }) => request?.inTxs?.some(({ hash }) => hash?.toLowerCase() === txHash.toLowerCase())));
+    return maybeResponse.map(({ data }) => data.requests?.find(({ data: request }) => request?.inTxs?.some(({ txHash: hash }) => hash?.toLowerCase() === txHash.toLowerCase())));
 };
 exports.fetchRelayRequestByTxHash = fetchRelayRequestByTxHash;
 const getRelayRequestFailureMessage = (request) => {
     const { failReason, refundFailReason } = request.data ?? {};
-    // Relay report 'N/A' rather than omitting the reason when there isn't one
+    // Relay can report 'N/A' rather than null when there isn't one
     const reason = [failReason, refundFailReason].find(value => value && value !== 'N/A');
     return reason ?? 'Bridge failed';
 };

package/dist/cjs/swappers/RelaySwapper/utils/types.d.ts

@@ -9,12 +9,12 @@ export type RelayMetadata = {
     data?: string;
 };
 export type RelayRequestTransaction = {
-    hash?: string;
+    txHash?: string;
     chainId?: number;
 };
 export type RelayRequestData = {
-    failReason?: string;
-    refundFailReason?: string;
+    failReason?: string | null;
+    refundFailReason?: string | null;
     inTxs?: RelayRequestTransaction[];
     outTxs?: RelayRequestTransaction[];
 };
@@ -121,9 +121,14 @@ export type RelayQuoteStep = {
     requestId: string;
     items?: RelayQuoteItem[];
 };
+export type RelayOrderData = {
+    output?: {
+        deadline?: number;
+    };
+};
 export type RelayProtocolV2 = {
     orderId: string | undefined;
-    orderData?: unknown;
+    orderData?: RelayOrderData;
     paymentDetails?: {
         chainId: string;
         depository: string;

package/dist/cjs/swappers/SymbiosisSwapper/SymbiosisSwapper.d.ts

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types';
+export declare const symbiosisSwapper: Swapper;

package/dist/cjs/swappers/SymbiosisSwapper/SymbiosisSwapper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbiosisSwapper = void 0;
+const utils_1 = require("../../utils");
+exports.symbiosisSwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeTronTransaction: utils_1.executeTronTransaction,
+};

package/dist/cjs/swappers/SymbiosisSwapper/endpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types';
+export declare const symbiosisApi: SwapperApi;