@shapeshiftoss/swapper 19.0.0 → 20.1.0

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsStepData.js

@@ -2,23 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPortalsStepData = void 0;
 const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
 const monads_1 = require("@sniptt/monads");
-const utils_1 = require("../../../utils");
+const utils_2 = require("../../../utils");
 const evm_1 = require("../../../utils/evm");
 const fetchPortalsTradeOrder_1 = require("./fetchPortalsTradeOrder");
 async function getPortalsStepData(args) {
-    const { tx, sellAsset, spenderAddress, input, deps } = args;
+    const { tx, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, input, deps } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     if (args.type === 'rate') {
         try {
             // No placeholder estimation for provider built routes - overridden estimation (approval
-            // state need not exist yet) with the Portals estimate endpoint as fallback
+            // state need not exist yet) with the Portals order and estimate endpoint as fallbacks
             const gasLimit = await (async () => {
                 try {
                     const gasLimit = await (0, evm_1.estimateGasWithStateOverride)({
                         sellAsset,
-                        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                        sellAmountCryptoBaseUnit,
                         from: tx.from,
                         spenderAddress,
                         to: tx.to,
@@ -28,6 +29,10 @@ async function getPortalsStepData(args) {
                     return gasLimit;
                 }
                 catch {
+                    // Portals only carry a tx gas limit on the bridge routes their estimate endpoint zeroes
+                    const { gasLimit: txGasLimit } = tx;
+                    if (txGasLimit && (0, utils_1.bnOrZero)(txGasLimit).gt(0))
+                        return txGasLimit;
                     const quoteEstimateResponse = await (0, fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate)({
                         inputToken: args.inputToken,
                         outputToken: args.outputToken,
@@ -35,7 +40,10 @@ async function getPortalsStepData(args) {
                         slippageTolerancePercentage: args.slippageTolerancePercentage,
                         swapperConfig: deps.config,
                     });
-                    return quoteEstimateResponse.context.gasLimit.toString();
+                    const estimatedGasLimit = quoteEstimateResponse.context.gasLimit.toString();
+                    if ((0, utils_1.bnOrZero)(estimatedGasLimit).lte(0))
+                        throw new Error('no Portals gas limit');
+                    return estimatedGasLimit;
                 }
             })();
             const networkFeeCryptoBaseUnit = await (0, evm_1.getEvmNetworkFeeCryptoBaseUnit)({
@@ -47,7 +55,7 @@ async function getPortalsStepData(args) {
             return (0, monads_1.Ok)(stepData);
         }
         catch (error) {
-            return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
+            return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
         }
     }
     const transactionData = {
@@ -68,7 +76,7 @@ async function getPortalsStepData(args) {
             supportsEIP1559,
             stateOverride: {
                 sellAsset,
-                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                sellAmountCryptoBaseUnit,
                 spenderAddress,
             },
         });
@@ -76,7 +84,7 @@ async function getPortalsStepData(args) {
         return (0, monads_1.Ok)(stepData);
     }
     catch (error) {
-        return (0, monads_1.Err)((0, utils_1.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
+        return (0, monads_1.Err)((0, utils_2.makeNetworkFeeEstimationFailedErr)('getPortalsStepData', error));
     }
 }
 exports.getPortalsStepData = getPortalsStepData;

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsStepData.test.d.ts

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

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsStepData.test.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const evm_1 = require("../../../utils/evm");
+const assets_1 = require("../../../utils/test-data/assets");
+const fetchPortalsTradeOrder_1 = require("./fetchPortalsTradeOrder");
+const getPortalsStepData_1 = require("./getPortalsStepData");
+vitest_1.vi.mock('../../../utils/evm', async (importOriginal) => ({
+    ...(await importOriginal()),
+    estimateGasWithStateOverride: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('./fetchPortalsTradeOrder', async (importOriginal) => ({
+    ...(await importOriginal()),
+    fetchPortalsTradeEstimate: vitest_1.vi.fn(),
+}));
+const GAS_PRICE = '1000000000';
+const deps = {
+    assertGetEvmChainAdapter: () => ({
+        getGasFeeData: () => Promise.resolve({
+            average: { gasPrice: GAS_PRICE, maxFeePerGas: '0', maxPriorityFeePerGas: '0' },
+        }),
+    }),
+    config: {},
+};
+const tx = (gasLimit) => ({
+    to: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    from: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+    data: '0xdeadbeef',
+    value: '0',
+    gasLimit,
+});
+const rate = (portalsTx) => (0, getPortalsStepData_1.getPortalsStepData)({
+    type: 'rate',
+    input: { supportsEIP1559: false },
+    deps,
+    tx: portalsTx,
+    sellAsset: assets_1.USDC_MAINNET,
+    sellAmountCryptoBaseUnit: '1000000000',
+    spenderAddress: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    inputToken: 'ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    outputToken: 'arbitrum:0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+    inputAmount: '1000000000',
+    slippageTolerancePercentage: 2.5,
+});
+const estimateEndpointGasLimit = (gasLimit) => vitest_1.vi.mocked(fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate).mockResolvedValue({
+    context: { gasLimit },
+});
+(0, vitest_1.describe)('getPortalsStepData rate gas limit', () => {
+    (0, vitest_1.beforeEach)(() => vitest_1.vi.clearAllMocks());
+    (0, vitest_1.it)('falls back to the order gas limit on bridge routes the estimate endpoint zeroes', async () => {
+        vitest_1.vi.mocked(evm_1.estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        estimateEndpointGasLimit(0);
+        const actual = await rate(tx('76384'));
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '76384000000000' });
+        (0, vitest_1.expect)(fetchPortalsTradeOrder_1.fetchPortalsTradeEstimate).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('falls back to the estimate endpoint when the order carries no gas limit', async () => {
+        vitest_1.vi.mocked(evm_1.estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        estimateEndpointGasLimit(273203);
+        const actual = await rate(tx(undefined));
+        (0, vitest_1.expect)(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '273203000000000' });
+    });
+    (0, vitest_1.it)('errors rather than pricing a zero gas limit as a free trade', async () => {
+        vitest_1.vi.mocked(evm_1.estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        estimateEndpointGasLimit(0);
+        const actual = await rate(tx(undefined));
+        (0, vitest_1.expect)(actual.isErr()).toBe(true);
+        (0, vitest_1.expect)(actual.unwrapErr().message).toContain('getPortalsStepData');
+    });
+});

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsTradeContext.d.ts

@@ -10,16 +10,17 @@ type PortalsTradeContext = {
     stepDataArgs: {
         deps: SwapperDeps;
         sellAsset: Asset;
+        sellAmountCryptoBaseUnit: string;
         spenderAddress: string;
         tx: PortalsTx;
     };
 };
-export declare const getPortalsTradeContext: ({ input, deps, sellChainId, inputToken, orderContext, tx, }: {
+export declare const getPortalsTradeContext: ({ input, deps, sellChainId, orderContext, outputToken, tx, }: {
     input: PortalsTradeQuoteInput | PortalsTradeRateInput;
     deps: SwapperDeps;
     sellChainId: PortalsSupportedChainId;
-    inputToken: string;
     orderContext: PortalsTradeOrderResponse['context'];
+    outputToken: string;
     tx: PortalsTx;
 }) => Result<PortalsTradeContext, SwapErrorRight>;
 export {};

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsTradeContext.js

@@ -7,11 +7,26 @@ const types_1 = require("../../../types");
 const utils_2 = require("../../../utils");
 const affiliateFee_1 = require("../../../utils/affiliateFee");
 const helpers_1 = require("./helpers");
-const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderContext, tx, }) => {
-    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
-    const { orderId, outputAmount, minOutputAmount, target, feeAmount, feeToken } = orderContext;
+const getPortalsTradeContext = ({ input, deps, sellChainId, orderContext, outputToken, tx, }) => {
+    const { sellAsset, buyAsset, affiliateBps } = input;
+    const { orderId, inputAmount, outputAmount, minOutputAmount, target, feeAmount, feeToken, slippageTolerancePercentage, } = orderContext;
+    // Portals can fill less than we asked for - price against what the transaction actually spends
+    const sellAmountIncludingProtocolFeesCryptoBaseUnit = inputAmount;
     const isCrossChain = sellAsset.chainId !== buyAsset.chainId;
-    const buyAmountAfterFeesCryptoBaseUnit = isCrossChain ? minOutputAmount : outputAmount;
+    // Portals report the slippage they applied, not the one we requested - bridge routes apply none
+    const appliedSlippageDecimal = (0, utils_1.bnOrZero)(slippageTolerancePercentage).div(100);
+    // Unvalidated orders report the post-slippage minimum in both amount fields
+    const hasSlippageBuffer = (0, utils_1.bnOrZero)(outputAmount).gt(minOutputAmount);
+    const preSlippageOutputAmount = (0, utils_1.bnOrZero)(minOutputAmount)
+        .div((0, utils_1.bn)(1).minus(appliedSlippageDecimal))
+        .toFixed(0);
+    const buyAmountAfterFeesCryptoBaseUnit = hasSlippageBuffer
+        ? outputAmount
+        : preSlippageOutputAmount;
+    const bufferSlippageDecimal = hasSlippageBuffer
+        ? (0, utils_1.bnOrZero)(outputAmount).minus(minOutputAmount).div(outputAmount)
+        : appliedSlippageDecimal;
+    const slippageTolerancePercentageDecimal = utils_1.BigNumber.max(appliedSlippageDecimal, bufferSlippageDecimal).toString();
     const rate = (0, utils_2.getInputOutputRate)({
         sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -27,16 +42,13 @@ const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderCon
             details: { chainId: sellChainId },
         }));
     }
-    // Portals reports the slippage we requested, not what it applied — recover the actual buffer from the amounts
-    const actualBufferDecimal = (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit)
-        .minus(minOutputAmount)
-        .div(buyAmountAfterFeesCryptoBaseUnit)
-        .toString();
-    // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
-    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(minOutputAmount)
-        .div((0, utils_1.bn)(1).minus(actualBufferDecimal))
-        .toFixed(0);
-    const protocolFeeAsset = feeToken === inputToken ? sellAsset : buyAsset;
+    // Portals lower-case echoed tokens, and take their fee in the sell asset on ERC20 sells
+    const isBuyAssetFee = feeToken?.toLowerCase() === outputToken.toLowerCase();
+    const protocolFeeAsset = isBuyAssetFee ? buyAsset : sellAsset;
+    // Portals report an output already net of their fee
+    const buyAmountBeforeFeesCryptoBaseUnit = isBuyAssetFee && feeAmount
+        ? (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit).plus(feeAmount).toFixed(0)
+        : buyAmountAfterFeesCryptoBaseUnit;
     const protocolFees = (() => {
         if (!feeToken || !feeAmount)
             return;
@@ -54,7 +66,7 @@ const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderCon
             rate,
             swapperName: types_1.SwapperName.Portals,
             affiliateBps,
-            slippageTolerancePercentageDecimal: actualBufferDecimal,
+            slippageTolerancePercentageDecimal,
         },
         stepCommon: {
             estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,
@@ -77,7 +89,13 @@ const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderCon
             }),
         },
         protocolFees,
-        stepDataArgs: { deps, sellAsset, spenderAddress: allowanceContract, tx },
+        stepDataArgs: {
+            deps,
+            sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            spenderAddress: allowanceContract,
+            tx,
+        },
     });
 };
 exports.getPortalsTradeContext = getPortalsTradeContext;

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsTradeContext.test.d.ts

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

package/dist/cjs/swappers/PortalsSwapper/utils/getPortalsTradeContext.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const assets_1 = require("../../../utils/test-data/assets");
+const getPortalsTradeContext_1 = require("./getPortalsTradeContext");
+const deps = {};
+const tx = {
+    to: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    from: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+    data: '0xdeadbeef',
+    value: '0',
+};
+const makeInput = (buyAsset = assets_1.USDC_ARBITRUM) => ({
+    sellAsset: assets_1.USDC_MAINNET,
+    buyAsset,
+    affiliateBps: '0',
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: '4631313795',
+});
+const makeOrderContext = (overrides) => ({
+    orderId: 'eaae8ea5-30af-4463-97ab-1c5b1fe7def4',
+    target: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    inputAmount: '4631313795',
+    ...overrides,
+});
+const unwrap = (args) => (0, getPortalsTradeContext_1.getPortalsTradeContext)(args).unwrap();
+(0, vitest_1.describe)('getPortalsTradeContext', () => {
+    (0, vitest_1.it)('does not gross up a bridge route Portals applied no slippage to', () => {
+        const { stepCommon, tradeCommon } = unwrap({
+            input: makeInput(),
+            deps,
+            sellChainId: assets_1.USDC_MAINNET.chainId,
+            orderContext: makeOrderContext({
+                outputAmount: '4616564490',
+                minOutputAmount: '4616564490',
+                slippageTolerancePercentage: 0,
+            }),
+            outputToken: 'arbitrum:0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+            tx,
+        });
+        (0, vitest_1.expect)(stepCommon.buyAmountAfterFeesCryptoBaseUnit).toBe('4616564490');
+        (0, vitest_1.expect)(tradeCommon.slippageTolerancePercentageDecimal).toBe('0');
+    });
+    (0, vitest_1.it)('reverses the applied slippage on an unvalidated order collapsed to its minimum', () => {
+        const { stepCommon, tradeCommon } = unwrap({
+            input: makeInput(assets_1.USDC_MAINNET),
+            deps,
+            sellChainId: assets_1.USDC_MAINNET.chainId,
+            orderContext: makeOrderContext({
+                outputAmount: '2360574345',
+                minOutputAmount: '2360574345',
+                slippageTolerancePercentage: 2.5,
+            }),
+            outputToken: 'ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            tx,
+        });
+        // Within 0.01% of the 2420957576 the same order returns when validated
+        (0, vitest_1.expect)(stepCommon.buyAmountAfterFeesCryptoBaseUnit).toBe('2421101892');
+        (0, vitest_1.expect)(tradeCommon.slippageTolerancePercentageDecimal).toBe('0.025');
+    });
+    (0, vitest_1.it)('keeps the reported output of a validated order and advertises the wider buffer', () => {
+        const { stepCommon, tradeCommon } = unwrap({
+            input: makeInput(assets_1.USDC_MAINNET),
+            deps,
+            sellChainId: assets_1.USDC_MAINNET.chainId,
+            orderContext: makeOrderContext({
+                outputAmount: '2420957576',
+                minOutputAmount: '2360574345',
+                slippageTolerancePercentage: 2.5,
+            }),
+            outputToken: 'ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            tx,
+        });
+        (0, vitest_1.expect)(stepCommon.buyAmountAfterFeesCryptoBaseUnit).toBe('2420957576');
+        (0, vitest_1.expect)(tradeCommon.slippageTolerancePercentageDecimal).toBe('0.025');
+    });
+    (0, vitest_1.it)('prices against the input amount Portals filled rather than the one requested', () => {
+        const { stepCommon } = unwrap({
+            input: makeInput(),
+            deps,
+            sellChainId: assets_1.USDC_MAINNET.chainId,
+            orderContext: makeOrderContext({
+                // Portals withhold 0.01% of the requested 4631313795 on cross-chain orders
+                inputAmount: '4630850664',
+                outputAmount: '4616564490',
+                minOutputAmount: '4616564490',
+                slippageTolerancePercentage: 0,
+            }),
+            outputToken: 'arbitrum:0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+            tx,
+        });
+        (0, vitest_1.expect)(stepCommon.sellAmountIncludingProtocolFeesCryptoBaseUnit).toBe('4630850664');
+    });
+});

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

@@ -14,6 +14,7 @@ const getTradeRate_1 = require("./getTradeRate/getTradeRate");
 const getLatestRelayStatusMessage_1 = require("./utils/getLatestRelayStatusMessage");
 const notifyTransactionIndexing_1 = require("./utils/notifyTransactionIndexing");
 const relayService_1 = require("./utils/relayService");
+const relayStatus_1 = require("./utils/relayStatus");
 // Keep track of the trades we already notified the relay indexer about
 const txIndexingMap = new Map();
 exports.relayApi = {
@@ -23,6 +24,12 @@ exports.relayApi = {
     getTradeRate: (input, deps) => {
         return (0, getTradeRate_1.getTradeRate)(input, deps, constant_1.chainIdToRelayChainId);
     },
+    getExactOutputTradeQuote: (input, deps) => {
+        return (0, getTradeQuote_1.getExactOutputTradeQuote)(input, deps, constant_1.chainIdToRelayChainId);
+    },
+    getExactOutputTradeRate: (input, deps) => {
+        return (0, getTradeRate_1.getExactOutputTradeRate)(input, deps, constant_1.chainIdToRelayChainId);
+    },
     getEvmTransactionFees: evm_1.getEvmTransactionFees,
     getUnsignedEvmTransaction: evm_1.getUnsignedEvmTransaction,
     getUnsignedUtxoTransaction: utxo_1.getUnsignedUtxoTransaction,
@@ -63,7 +70,7 @@ exports.relayApi = {
         }
         // relay.link tracks the swap by its origin chain transaction
         const swapperTxId = txHash;
-        const swapperTxLink = `https://relay.link/transaction/${txHash}`;
+        const swapperTxLink = (0, relayStatus_1.getRelayTrackingLink)(txHash);
         const maybeStatusResponse = await relayService_1.relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v3?requestId=${relayMetadata.relayId}`, (0, relayService_1.getRelayRequestConfig)(config));
         if (maybeStatusResponse.isErr()) {
             return {
@@ -75,23 +82,7 @@ exports.relayApi = {
             };
         }
         const { data: statusResponse } = maybeStatusResponse.unwrap();
-        const status = (() => {
-            switch (statusResponse.status) {
-                case 'success':
-                    return unchained_client_1.TxStatus.Confirmed;
-                case 'waiting':
-                case 'delayed':
-                case 'pending':
-                case 'depositing':
-                case 'submitted':
-                    return unchained_client_1.TxStatus.Pending;
-                case 'failure':
-                case 'refund':
-                    return unchained_client_1.TxStatus.Failed;
-                default:
-                    return unchained_client_1.TxStatus.Unknown;
-            }
-        })();
+        const status = (0, relayStatus_1.relayStatusToTxStatus)(statusResponse.status);
         // Relay refers to in Txs as "inTxHashes" but to out Txs as simply "txHashes" when they really mean "outTxHashes"
         // One thing to note is that for same-chain Txs, there is no "out Tx" per se since the in Tx *is* the out Tx
         const outTxHashes = statusResponse.txHashes;

package/dist/cjs/swappers/RelaySwapper/getTradeQuote/getTradeQuote.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from '@sniptt/monads';
 import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types';
 import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
-import type { RelayTradeQuoteInput } from '../utils/types';
+import type { RelayExactOutputTradeQuoteInput, RelayTradeQuoteInput } from '../utils/types';
 export declare const getTradeQuote: (input: RelayTradeQuoteInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeQuote[], SwapErrorRight>>;
+export declare const getExactOutputTradeQuote: (input: RelayExactOutputTradeQuoteInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTradeQuote = void 0;
+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 getTradeQuote = async (input, deps, relayChainMap) => {
+const getQuote = async (input, deps, relayChainMap) => {
     const { accountNumber } = input;
     const addresses = (0, utils_1.assertQuoteAddresses)(input);
     if (addresses.isErr())
@@ -52,4 +52,7 @@ const getTradeQuote = async (input, deps, relayChainMap) => {
     };
     return (0, monads_1.Ok)([tradeQuote]);
 };
+const getTradeQuote = (input, deps, relayChainMap) => getQuote(input, deps, relayChainMap);
 exports.getTradeQuote = getTradeQuote;
+const getExactOutputTradeQuote = (input, deps, relayChainMap) => getQuote(input, deps, relayChainMap);
+exports.getExactOutputTradeQuote = getExactOutputTradeQuote;

package/dist/cjs/swappers/RelaySwapper/getTradeRate/getTradeRate.d.ts

@@ -1,5 +1,6 @@
 import type { Result } from '@sniptt/monads';
 import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types';
 import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
-import type { RelayTradeRateInput } from '../utils/types';
+import type { RelayExactOutputTradeRateInput, RelayTradeRateInput } from '../utils/types';
 export declare const getTradeRate: (input: RelayTradeRateInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeRate[], SwapErrorRight>>;
+export declare const getExactOutputTradeRate: (input: RelayExactOutputTradeRateInput, deps: SwapperDeps, relayChainMap: typeof relayChainMapImplementation) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTradeRate = void 0;
+exports.getExactOutputTradeRate = exports.getTradeRate = void 0;
 const monads_1 = require("@sniptt/monads");
 const getRelayStepData_1 = require("../utils/getRelayStepData");
 const getRelayTradeContext_1 = require("../utils/getRelayTradeContext");
-const getTradeRate = async (input, deps, relayChainMap) => {
+const getRate = async (input, deps, relayChainMap) => {
     const maybeContext = await (0, getRelayTradeContext_1.getRelayTradeContext)({ input, deps, relayChainMap });
     if (maybeContext.isErr())
         return (0, monads_1.Err)(maybeContext.unwrapErr());
@@ -39,4 +39,7 @@ const getTradeRate = async (input, deps, relayChainMap) => {
     };
     return (0, monads_1.Ok)([tradeRate]);
 };
+const getTradeRate = (input, deps, relayChainMap) => getRate(input, deps, relayChainMap);
 exports.getTradeRate = getTradeRate;
+const getExactOutputTradeRate = (input, deps, relayChainMap) => getRate(input, deps, relayChainMap);
+exports.getExactOutputTradeRate = getExactOutputTradeRate;

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

@@ -2,7 +2,7 @@ import type { Result } from '@sniptt/monads';
 import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types';
 import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
 import type { GetRelayStepDataArgs } from './getRelayStepData';
-import type { RelayQuoteItem, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
+import type { RelayExactOutputTradeQuoteInput, RelayExactOutputTradeRateInput, RelayQuoteItem, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
 type RelayTradeContext = {
     tradeCommon: TradeCommon;
     stepCommon: Omit<TradeStepCommon, 'feeData' | 'allowanceContract'>;
@@ -15,7 +15,7 @@ type RelayTradeContext = {
     relayId: string;
 };
 export declare const getRelayTradeContext: ({ input, deps, relayChainMap, }: {
-    input: RelayTradeQuoteInput | RelayTradeRateInput;
+    input: RelayTradeQuoteInput | RelayTradeRateInput | RelayExactOutputTradeQuoteInput | RelayExactOutputTradeRateInput;
     deps: SwapperDeps;
     relayChainMap: typeof relayChainMapImplementation;
 }) => Promise<Result<RelayTradeContext, SwapErrorRight>>;

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

@@ -22,7 +22,9 @@ const fetchRelayTrade_1 = require("./fetchRelayTrade");
 const helpers_2 = require("./helpers");
 const types_2 = require("./types");
 const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
-    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps } = input;
+    const { sellAsset, buyAsset, affiliateBps } = input;
+    const amount = (0, helpers_1.getTradeAmount)(input);
+    const isExactOutput = amount.direction === 'exactOut';
     const xpub = 'xpub' in input ? input.xpub : undefined;
     const slippageToleranceBps = input.slippageTolerancePercentageDecimal
         ? (0, utils_1.convertDecimalPercentageToBasisPoints)(input.slippageTolerancePercentageDecimal).toFixed()
@@ -41,8 +43,8 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
         originCurrency: (0, getRelayAssetAddress_1.getRelayAssetAddress)(sellAsset),
         destinationChainId: buyRelayChainId,
         destinationCurrency: (0, getRelayAssetAddress_1.getRelayAssetAddress)(buyAsset),
-        tradeType: 'EXACT_INPUT',
-        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        tradeType: isExactOutput ? 'EXACT_OUTPUT' : 'EXACT_INPUT',
+        amount: amount.cryptoBaseUnit,
         recipient,
         user: sendAddress,
         refundTo,
@@ -84,10 +86,19 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
             code: types_1.TradeQuoteError.UnknownError,
         }));
     }
-    const { slippageTolerance, currencyOut, timeEstimate } = quote.details;
-    const buyAmountAfterFeesCryptoBaseUnit = currencyOut.amount;
+    const { slippageTolerance, currencyIn, currencyOut, timeEstimate } = quote.details;
+    const sellAmountCryptoBaseUnit = currencyIn.amount;
+    const buyAmountAfterFeesCryptoBaseUnit = isExactOutput
+        ? currencyOut.minimumAmount
+        : currencyOut.amount;
+    if (isExactOutput && !(0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit).eq(amount.cryptoBaseUnit)) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: `Relay guarantees ${buyAmountAfterFeesCryptoBaseUnit} against a requested exact output of ${amount.cryptoBaseUnit}`,
+            code: types_1.TradeQuoteError.InvalidResponse,
+        }));
+    }
     const rate = (0, utils_2.getInputOutputRate)({
-        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        sellAmountCryptoBaseUnit,
         buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
         sellAsset,
         buyAsset,
@@ -248,7 +259,7 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
     })();
     // Add back relayer service and gas fees (relayer is including both) since they are downsides,
     // and add appFees — these are quote-level and identical across every step
-    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(currencyOut.amount)
+    const buyAmountBeforeFeesCryptoBaseUnit = (0, utils_1.bnOrZero)(buyAmountAfterFeesCryptoBaseUnit)
         .plus(relayerFeesBuyAssetCryptoBaseUnit)
         .plus(appFeesBaseUnit)
         .toFixed();
@@ -262,6 +273,7 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
             id: relayId,
             rate,
             swapperName: types_1.SwapperName.Relay,
+            isExactOutput,
             affiliateBps,
             slippageTolerancePercentageDecimal,
         },
@@ -269,7 +281,7 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
             rate,
             buyAmountBeforeFeesCryptoBaseUnit,
             buyAmountAfterFeesCryptoBaseUnit,
-            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmountCryptoBaseUnit,
             buyAsset,
             sellAsset,
             source: types_1.SwapperName.Relay,
@@ -279,7 +291,7 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
                 affiliateBps,
                 sellAsset,
                 buyAsset,
-                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                sellAmountCryptoBaseUnit,
                 buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
                 fixedAssetId: (0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId),
                 fixedAsset: deps.assetsById[(0, utils_1.chainIdToFeeAssetId)(caip_1.baseChainId)],
@@ -297,7 +309,7 @@ const getRelayTradeContext = async ({ input, deps, relayChainMap, }) => {
         relayStepInputs,
         stepDataArgs: {
             sellAsset,
-            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            sellAmountCryptoBaseUnit,
             orderId,
             from: sendAddress,
             xpub,

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

@@ -4,7 +4,7 @@ import type { Result } from '@sniptt/monads';
 import type { TransactionInstruction } from '@solana/web3.js';
 import type { SwapErrorRight } from '../../../types';
 import type { chainIdToRelayChainId as relayChainMapImplementation } from '../constant';
-import type { RelayQuoteItem, RelaySolanaInstruction, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
+import type { RelayExactOutputTradeQuoteInput, RelayExactOutputTradeRateInput, RelayQuoteItem, RelaySolanaInstruction, RelayTradeQuoteInput, RelayTradeRateInput } from './types';
 export declare const assertValidTrade: ({ sellAsset, buyAsset, relayChainMap, }: {
     sellAsset: Asset;
     buyAsset: Asset;
@@ -14,7 +14,7 @@ export declare const assertValidTrade: ({ sellAsset, buyAsset, relayChainMap, }:
     buyRelayChainId: number;
 }, SwapErrorRight>;
 export declare const resolveRelayAddresses: ({ input, sellChainId, buyChainId, }: {
-    input: RelayTradeQuoteInput | RelayTradeRateInput;
+    input: RelayTradeQuoteInput | RelayTradeRateInput | RelayExactOutputTradeQuoteInput | RelayExactOutputTradeRateInput;
     sellChainId: ChainId;
     buyChainId: ChainId;
 }) => {

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

@@ -0,0 +1,8 @@
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperConfig } from '../../../types';
+import type { RelayRequest, RelayStatus } from './types';
+export declare const getRelayTrackingLink: (txHash: string) => string;
+export declare const relayStatusToTxStatus: (status: RelayStatus['status'] | undefined) => TxStatus;
+export declare const fetchRelayRequestByTxHash: (txHash: string, config: SwapperConfig) => Promise<Result<RelayRequest | undefined, SwapErrorRight>>;
+export declare const getRelayRequestFailureMessage: (request: RelayRequest) => string;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelayRequestFailureMessage = exports.fetchRelayRequestByTxHash = exports.relayStatusToTxStatus = exports.getRelayTrackingLink = void 0;
+const unchained_client_1 = require("@shapeshiftoss/unchained-client");
+const relayService_1 = require("./relayService");
+const getRelayTrackingLink = (txHash) => `https://relay.link/transaction/${txHash}`;
+exports.getRelayTrackingLink = getRelayTrackingLink;
+const relayStatusToTxStatus = (status) => {
+    switch (status) {
+        case 'success':
+            return unchained_client_1.TxStatus.Confirmed;
+        case 'waiting':
+        case 'delayed':
+        case 'pending':
+        case 'depositing':
+        case 'submitted':
+            return unchained_client_1.TxStatus.Pending;
+        case 'failure':
+        case 'refund':
+            return unchained_client_1.TxStatus.Failed;
+        default:
+            return unchained_client_1.TxStatus.Unknown;
+    }
+};
+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));
+    // 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())));
+};
+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
+    const reason = [failReason, refundFailReason].find(value => value && value !== 'N/A');
+    return reason ?? 'Bridge failed';
+};
+exports.getRelayRequestFailureMessage = getRelayRequestFailureMessage;