@shapeshiftoss/swapper 19.0.0 → 20.1.0

package/dist/esm/exactOutputFiltering.test.d.ts

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

package/dist/esm/exactOutputFiltering.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import { swappers } from './constants.js';
+import { getTradeQuotes, getTradeRates } from './swapper.js';
+import { SwapperName, TradeQuoteError } from './types.js';
+import { BTC, ETH } from './utils/test-data/assets.js';
+// Exact-output support is structural - a swapper cannot claim it without implementing it
+describe('exact output capability', () => {
+    it('is implemented by the swappers whose upstream API can honour an exact buy amount', () => {
+        for (const swapperName of [SwapperName.NearIntents, SwapperName.Relay]) {
+            expect(swappers[swapperName]?.getExactOutputTradeRate).toBeDefined();
+            expect(swappers[swapperName]?.getExactOutputTradeQuote).toBeDefined();
+        }
+    });
+    it('is absent everywhere else', () => {
+        const exactOutputCapable = Object.values(SwapperName).filter(swapperName => swappers[swapperName]?.getExactOutputTradeRate !== undefined);
+        expect(exactOutputCapable).toEqual([SwapperName.Relay, SwapperName.NearIntents]);
+    });
+});
+const exactOutputInput = {
+    sellAsset: ETH,
+    buyAsset: BTC,
+    buyAmountCryptoBaseUnit: '100000',
+    affiliateBps: '0',
+    allowMultiHop: true,
+    receiveAddress: undefined,
+    accountNumber: undefined,
+    quoteOrRate: 'rate',
+};
+const deps = {};
+describe('getTradeRates on an exact buy amount', () => {
+    // Silently omitting these would read as the swapper being unavailable rather than unable
+    it('reports an error for a swapper that cannot quote one', async () => {
+        const result = await getTradeRates(exactOutputInput, SwapperName.Thorchain, deps);
+        expect(result).toBeDefined();
+        expect(result?.isErr()).toBe(true);
+        expect(result?.unwrapErr().code).toEqual(TradeQuoteError.ExactOutputNotSupported);
+        expect(result?.swapperName).toEqual(SwapperName.Thorchain);
+    });
+    it('skips entirely on a zero buy amount', async () => {
+        const result = await getTradeRates({ ...exactOutputInput, buyAmountCryptoBaseUnit: '0' }, SwapperName.Thorchain, deps);
+        expect(result).toBeUndefined();
+    });
+    // The base-unit regex upstream admits padded zeros, so the check can't be a string comparison
+    it('skips entirely on a padded zero buy amount', async () => {
+        const result = await getTradeRates({ ...exactOutputInput, buyAmountCryptoBaseUnit: '00' }, SwapperName.Thorchain, deps);
+        expect(result).toBeUndefined();
+    });
+});
+// Quotes dispatch on the same input shape as rates, so they gate the same way
+describe('getTradeQuotes on an exact buy amount', () => {
+    const exactOutputQuoteInput = {
+        ...exactOutputInput,
+        receiveAddress: 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq',
+        accountNumber: 0,
+        quoteOrRate: 'quote',
+    };
+    it('reports an error for a swapper that cannot quote one', async () => {
+        const result = await getTradeQuotes(exactOutputQuoteInput, SwapperName.Thorchain, deps);
+        expect(result).toBeDefined();
+        expect(result?.isErr()).toBe(true);
+        expect(result?.unwrapErr().code).toEqual(TradeQuoteError.ExactOutputNotSupported);
+        expect(result?.swapperName).toEqual(SwapperName.Thorchain);
+    });
+    it('skips entirely on a zero buy amount', async () => {
+        const result = await getTradeQuotes({ ...exactOutputQuoteInput, buyAmountCryptoBaseUnit: '0' }, SwapperName.Thorchain, deps);
+        expect(result).toBeUndefined();
+    });
+});

package/dist/esm/swapper.d.ts

@@ -1,3 +1,3 @@
-import type { GetTradeQuoteInput, GetTradeRateInput, QuoteResult, RateResult, SwapperDeps, SwapperName } from './types.js';
-export declare const getTradeQuotes: (getTradeQuoteInput: GetTradeQuoteInput, swapperName: SwapperName, deps: SwapperDeps) => Promise<QuoteResult | undefined>;
-export declare const getTradeRates: (getTradeRateInput: GetTradeRateInput, swapperName: SwapperName, deps: SwapperDeps, quoteTimeoutMs?: number) => Promise<RateResult | undefined>;
+import type { GetExactOutputTradeQuoteInput, GetExactOutputTradeRateInput, GetTradeQuoteInput, GetTradeRateInput, QuoteResult, RateResult, SwapperDeps, SwapperName } from './types.js';
+export declare const getTradeQuotes: (getTradeQuoteInput: GetTradeQuoteInput | GetExactOutputTradeQuoteInput, swapperName: SwapperName, deps: SwapperDeps) => Promise<QuoteResult | undefined>;
+export declare const getTradeRates: (getTradeRateInput: GetTradeRateInput | GetExactOutputTradeRateInput, swapperName: SwapperName, deps: SwapperDeps, quoteTimeoutMs?: number) => Promise<RateResult | undefined>;

package/dist/esm/swapper.js

@@ -1,17 +1,31 @@
 import { bnOrZero, timeoutMonadic, timeoutMonadicWithOriginal } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
 import { QUOTE_TIMEOUT_ERROR, QUOTE_TIMEOUT_MS, swappers } from './constants.js';
 import { TradeQuoteError } from './types.js';
 import { makeSwapErrorRight } from './utils/index.js';
+const EXACT_OUTPUT_NOT_SUPPORTED_ERROR = makeSwapErrorRight({
+    code: TradeQuoteError.ExactOutputNotSupported,
+    message: 'This swapper cannot derive a sell amount from an exact buy amount',
+});
 export const getTradeQuotes = async (getTradeQuoteInput, swapperName, deps) => {
     if (bnOrZero(getTradeQuoteInput.affiliateBps).lt(0))
         return;
-    if (getTradeQuoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
-        return;
     const swapper = swappers[swapperName];
     if (swapper === undefined)
         return;
+    // Compared numerically so a padded zero can't slip through as an amount
+    const drivingAmount = 'buyAmountCryptoBaseUnit' in getTradeQuoteInput
+        ? getTradeQuoteInput.buyAmountCryptoBaseUnit
+        : getTradeQuoteInput.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+    if (bnOrZero(drivingAmount).isZero())
+        return;
+    const quotePromise = 'buyAmountCryptoBaseUnit' in getTradeQuoteInput
+        ? swapper.getExactOutputTradeQuote?.(getTradeQuoteInput, deps)
+        : swapper.getTradeQuote(getTradeQuoteInput, deps);
+    if (!quotePromise)
+        return { ...Err(EXACT_OUTPUT_NOT_SUPPORTED_ERROR), swapperName };
     try {
-        const quote = await timeoutMonadic(swapper.getTradeQuote(getTradeQuoteInput, deps), QUOTE_TIMEOUT_MS, QUOTE_TIMEOUT_ERROR);
+        const quote = await timeoutMonadic(quotePromise, QUOTE_TIMEOUT_MS, QUOTE_TIMEOUT_ERROR);
         return {
             ...quote,
             swapperName,
@@ -26,13 +40,22 @@ export const getTradeQuotes = async (getTradeQuoteInput, swapperName, deps) => {
 export const getTradeRates = async (getTradeRateInput, swapperName, deps, quoteTimeoutMs = QUOTE_TIMEOUT_MS) => {
     if (bnOrZero(getTradeRateInput.affiliateBps).lt(0))
         return;
-    if (getTradeRateInput.sellAmountIncludingProtocolFeesCryptoBaseUnit === '0')
-        return;
     const swapper = swappers[swapperName];
     if (swapper === undefined)
         return;
+    // Compared numerically so a padded zero can't slip through as an amount
+    const drivingAmount = 'buyAmountCryptoBaseUnit' in getTradeRateInput
+        ? getTradeRateInput.buyAmountCryptoBaseUnit
+        : getTradeRateInput.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+    if (bnOrZero(drivingAmount).isZero())
+        return;
+    const ratePromise = 'buyAmountCryptoBaseUnit' in getTradeRateInput
+        ? swapper.getExactOutputTradeRate?.(getTradeRateInput, deps)
+        : swapper.getTradeRate(getTradeRateInput, deps);
+    if (!ratePromise)
+        return { ...Err(EXACT_OUTPUT_NOT_SUPPORTED_ERROR), swapperName };
     try {
-        const { timed, original } = timeoutMonadicWithOriginal(swapper.getTradeRate(getTradeRateInput, deps), quoteTimeoutMs, makeSwapErrorRight({
+        const { timed, original } = timeoutMonadicWithOriginal(ratePromise, quoteTimeoutMs, makeSwapErrorRight({
             code: TradeQuoteError.Timeout,
             message: `quote timed out after ${quoteTimeoutMs / 1000}s`,
         }));

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossStepData.d.ts

@@ -3,6 +3,7 @@ import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.j
 import type { AcrossSwapTx } from './types.js';
 type BaseArgs = {
     swapTx: AcrossSwapTx;
+    sellAmountCryptoBaseUnit: string;
     spenderAddress: string;
     fallbackNetworkFeeCryptoBaseUnit: string;
 };

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossStepData.js

@@ -7,7 +7,7 @@ import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight, makeTradeStepBui
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 import { getSolanaNetworkFeeCryptoBaseUnit } from '../../../utils/solana/index.js';
 export async function getAcrossStepData(args) {
-    const { swapTx, sellAsset, spenderAddress, from, type, input, fallbackNetworkFeeCryptoBaseUnit, deps, } = args;
+    const { swapTx, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, from, type, input, fallbackNetworkFeeCryptoBaseUnit, deps, } = args;
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     switch (swapTx.ecosystem) {
         case 'evm': {
@@ -22,7 +22,7 @@ export async function getAcrossStepData(args) {
             };
             const stateOverride = {
                 sellAsset,
-                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                sellAmountCryptoBaseUnit,
                 spenderAddress,
             };
             if (type === 'rate') {

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossTradeContext.js

@@ -167,6 +167,7 @@ export const getAcrossTradeContext = async ({ input, deps, depositor, recipient,
         stepDataArgs: {
             swapTx: quote.swapTx,
             sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             from: depositor,
             spenderAddress: allowanceContract,
             fallbackNetworkFeeCryptoBaseUnit: quote.fees.originGas.amount,

package/dist/esm/swappers/BebopSwapper/utils/getBebopStepData.d.ts

@@ -3,6 +3,7 @@ import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.j
 import type { BebopQuoteResponse } from '../types.js';
 type BaseArgs = {
     tx: BebopQuoteResponse['tx'];
+    sellAmountCryptoBaseUnit: string;
     spenderAddress: string;
 };
 export type GetBebopStepDataArgs = StepDataArgs<BaseArgs, {

package/dist/esm/swappers/BebopSwapper/utils/getBebopStepData.js

@@ -5,7 +5,7 @@ import { fromHex } from 'viem';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 export async function getBebopStepData(args) {
-    const { tx, spenderAddress, sellAsset, type, input, from, deps } = args;
+    const { tx, spenderAddress, sellAsset, sellAmountCryptoBaseUnit, type, input, from, deps } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     if (type === 'rate') {
@@ -40,7 +40,7 @@ export async function getBebopStepData(args) {
             supportsEIP1559,
             stateOverride: {
                 sellAsset,
-                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                sellAmountCryptoBaseUnit,
                 spenderAddress,
             },
         });

package/dist/esm/swappers/BebopSwapper/utils/getBebopTradeContext.js

@@ -75,6 +75,7 @@ export const getBebopTradeContext = async ({ input, deps, from, receiver, }) =>
             tx: quote.tx,
             spenderAddress: allowanceContract,
             sellAsset,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             from,
             deps,
         },

package/dist/esm/swappers/BobGatewaySwapper/swapperApi/getTradeQuote.js

@@ -10,14 +10,18 @@ export const getBobGatewayTradeQuote = async (input, deps) => {
     if (maybeAddresses.isErr())
         return Err(maybeAddresses.unwrapErr());
     const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const isEvmSell = isEvmChainId(sellAsset.chainId);
     // omit the sender for utxo sells so order creation does not enforce a per-address confirmed
     // funds check (deposits are matched via op_return, not the sending address)
-    const sender = isEvmChainId(sellAsset.chainId) ? sendAddress : undefined;
+    const sender = isEvmSell ? sendAddress : undefined;
+    // utxo deposits are refunded on the sell chain, so refunds go to the sending address
+    const refundAddress = isEvmSell ? undefined : sendAddress;
     const maybeContext = await getBobGatewayTradeContext({
         input,
         deps,
         sender,
         recipient: receiveAddress,
+        refundAddress,
     });
     if (maybeContext.isErr())
         return Err(maybeContext.unwrapErr());

package/dist/esm/swappers/BobGatewaySwapper/swapperApi/getTradeRate.js

@@ -5,9 +5,18 @@ import { getBobGatewayTradeContext } from '../utils/getBobGatewayTradeContext.js
 import { dummyAddressForChainId } from '../utils/helpers.js';
 export const getBobGatewayTradeRate = async (input, deps) => {
     const { accountNumber, sellAsset, buyAsset, receiveAddress } = input;
+    const isBtcSell = sellAsset.chainId === btcChainId;
     const recipient = receiveAddress ?? dummyAddressForChainId(buyAsset.chainId);
-    const sender = sellAsset.chainId === btcChainId ? undefined : dummyAddressForChainId(sellAsset.chainId);
-    const maybeContext = await getBobGatewayTradeContext({ input, deps, sender, recipient });
+    const sender = isBtcSell ? undefined : dummyAddressForChainId(sellAsset.chainId);
+    // utxo deposits are refunded on the sell chain, so the refund address must be a btc address
+    const refundAddress = isBtcSell ? dummyAddressForChainId(sellAsset.chainId) : undefined;
+    const maybeContext = await getBobGatewayTradeContext({
+        input,
+        deps,
+        sender,
+        recipient,
+        refundAddress,
+    });
     if (maybeContext.isErr())
         return Err(maybeContext.unwrapErr());
     const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();

package/dist/esm/swappers/BobGatewaySwapper/utils/getBobGatewayTradeContext.d.ts

@@ -8,10 +8,11 @@ type BobGatewayTradeContext = {
     protocolFees: QuoteFeeData['protocolFees'];
     stepDataArgs: Omit<GetBobGatewayStepDataArgs, 'type' | 'input' | 'from'>;
 };
-export declare const getBobGatewayTradeContext: ({ input, deps, sender, recipient, }: {
+export declare const getBobGatewayTradeContext: ({ input, deps, sender, recipient, refundAddress, }: {
     input: BobGatewayTradeQuoteInput | BobGatewayTradeRateInput;
     deps: SwapperDeps;
     sender: string | undefined;
     recipient: string;
+    refundAddress: string | undefined;
 }) => Promise<Result<BobGatewayTradeContext, SwapErrorRight>>;
 export {};

package/dist/esm/swappers/BobGatewaySwapper/utils/getBobGatewayTradeContext.js

@@ -4,7 +4,7 @@ import { v4 as uuid } from 'uuid';
 import { SwapperName } from '../../../types.js';
 import { getInputOutputRate } from '../../../utils/index.js';
 import { assertValidTrade, getBobGatewayAllowanceContract, getBobGatewayQuote, parseBobGatewayQuote, } from './helpers.js';
-export const getBobGatewayTradeContext = async ({ input, deps, sender, recipient, }) => {
+export const getBobGatewayTradeContext = async ({ input, deps, sender, recipient, refundAddress, }) => {
     const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, affiliateBps, slippageTolerancePercentageDecimal, } = input;
     const assertion = assertValidTrade({ sellAsset, buyAsset });
     if (assertion.isErr())
@@ -18,6 +18,7 @@ export const getBobGatewayTradeContext = async ({ input, deps, sender, recipient
         buyChainName,
         sender,
         recipient,
+        refundAddress,
         amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         affiliateBps,
         slippageTolerancePercentageDecimal,

package/dist/esm/swappers/BobGatewaySwapper/utils/helpers.d.ts

@@ -11,7 +11,7 @@ export declare const getBobGatewayClient: (config: SwapperConfig) => GatewaySDK;
 export declare const toTronBase58: (address: string) => string;
 export declare const assetIdToBobGatewayToken: (assetId: string) => string;
 export declare const getBobGatewayAffiliates: (affiliateBps: string) => GetQuoteParams['affiliates'];
-export declare const getBobGatewayQuote: ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }: {
+export declare const getBobGatewayQuote: ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, refundAddress, amount, affiliateBps, slippageTolerancePercentageDecimal, }: {
     config: SwapperConfig;
     sellAsset: Asset;
     buyAsset: Asset;
@@ -19,6 +19,7 @@ export declare const getBobGatewayQuote: ({ config, sellAsset, buyAsset, sellCha
     buyChainName: BobGatewayChainName;
     sender: string | undefined;
     recipient: string;
+    refundAddress: string | undefined;
     amount: string;
     affiliateBps: string;
     slippageTolerancePercentageDecimal: string | undefined;

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

@@ -41,7 +41,7 @@ export const getBobGatewayAffiliates = (affiliateBps) => {
     const affiliateAddress = getTreasuryAddressFromChainId(ethChainId);
     return [{ address: getAddress(affiliateAddress), bps: bps.toNumber() }];
 };
-export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }) => {
+export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, refundAddress, amount, affiliateBps, slippageTolerancePercentageDecimal, }) => {
     const slippage = decimalSlippageToBobBps(slippageTolerancePercentageDecimal ??
         getDefaultSlippageDecimalPercentageForSwapper(SwapperName.BobGateway));
     try {
@@ -55,6 +55,7 @@ export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChai
             amount,
             maxSlippage: Number(slippage),
             ownerAddress: sellChainName === 'bitcoin' ? recipient : sender,
+            refundAddress,
             affiliates: getBobGatewayAffiliates(affiliateBps),
         });
         return Ok(quote);

package/dist/esm/swappers/ChainflipSwapper/ChainflipSwapper.js

@@ -1,5 +1,6 @@
 import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils/index.js';
 export const chainflipSwapper = {
+    supportsExternalPayment: true,
     executeEvmTransaction,
     executeSolanaTransaction,
     executeTronTransaction,

package/dist/esm/swappers/ChainflipSwapper/checkTradeStatus.test.d.ts

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

package/dist/esm/swappers/ChainflipSwapper/checkTradeStatus.test.js

@@ -0,0 +1,46 @@
+import { Ok } from '@sniptt/monads';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { chainflipApi } from './endpoints.js';
+import { chainflipService } from './utils/chainflipService.js';
+vi.mock('./utils/chainflipService', () => ({
+    chainflipService: { get: vi.fn() },
+}));
+const makeInput = () => ({
+    config: { VITE_CHAINFLIP_API_URL: 'https://broker', VITE_CHAINFLIP_API_KEY: 'key' },
+    swap: { metadata: { swapperMetadata: { name: 'chainflip', swapId: 1234 } } },
+});
+const mockStatus = (status) => vi.mocked(chainflipService.get).mockResolvedValue(Ok({ data: { status } }));
+describe('chainflip checkTradeStatus', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('reports the deposit tx hash while the swap is still pending', async () => {
+        mockStatus({
+            state: 'swapping',
+            swapId: '1234',
+            deposit: { transactionReference: '0xdeposit' },
+        });
+        const result = await chainflipApi.checkTradeStatus(makeInput());
+        expect(result.sellTxHash).toBe('0xdeposit');
+        expect(result.buyTxHash).toBeUndefined();
+    });
+    it('reports the deposit tx hash alongside a completed egress', async () => {
+        mockStatus({
+            state: 'completed',
+            swapId: '1234',
+            deposit: { transactionReference: '0xdeposit' },
+            swapEgress: { transactionReference: '0xegress' },
+        });
+        const result = await chainflipApi.checkTradeStatus(makeInput());
+        expect(result.sellTxHash).toBe('0xdeposit');
+        expect(result.buyTxHash).toBe('0xegress');
+    });
+    it('has no deposit tx hash before the deposit is witnessed', async () => {
+        mockStatus({ state: 'waiting', swapId: '1234' });
+        expect((await chainflipApi.checkTradeStatus(makeInput())).sellTxHash).toBeUndefined();
+    });
+    it('treats a null transaction reference as no deposit yet', async () => {
+        mockStatus({ state: 'receiving', swapId: '1234', deposit: { transactionReference: null } });
+        expect((await chainflipApi.checkTradeStatus(makeInput())).sellTxHash).toBeUndefined();
+    });
+});

package/dist/esm/swappers/ChainflipSwapper/endpoints.js

@@ -52,13 +52,15 @@ export const chainflipApi = {
             };
         }
         const { data: statusResponse } = maybeStatusResponse.unwrap();
-        const buyTxHash = statusResponse.status.swapEgress?.transactionReference;
+        const buyTxHash = statusResponse.status.swapEgress?.transactionReference ?? undefined;
+        const sellTxHash = statusResponse.status.deposit?.transactionReference ?? undefined;
         const swapperTxId = statusResponse.status.swapId;
         const swapperTxLink = swapperTxId ? `https://scan.chainflip.io/swaps/${swapperTxId}` : undefined;
         // Assume no outbound Tx is a pending Tx
         if (!buyTxHash) {
             return {
-                buyTxHash: undefined,
+                buyTxHash,
+                sellTxHash,
                 status: TxStatus.Pending,
                 swapperTxId,
                 swapperTxLink,
@@ -69,6 +71,7 @@ export const chainflipApi = {
         // Chainflip waits for 3 confirmations to assume complete (vs. 1 for us), which is turbo long.
         return {
             buyTxHash,
+            sellTxHash,
             status: TxStatus.Confirmed,
             swapperTxId,
             swapperTxLink,

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

@@ -11,6 +11,9 @@ export type ChainFlipStatus = {
     status: {
         state: 'waiting' | 'receiving' | 'swapping' | 'sending' | 'sent' | 'completed' | 'failed';
         swapId?: string;
+        deposit?: {
+            transactionReference?: string | null;
+        };
         swap?: ChainflipBaasStatusSwap;
         swapEgress?: ChainflipBaasStatusEgress;
     };

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.d.ts

@@ -3,6 +3,7 @@ import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.j
 import type { DebridgeTx } from './types.js';
 type BaseArgs = {
     tx: DebridgeTx;
+    sellAmountCryptoBaseUnit: string;
     gasLimit: string | undefined;
     spenderAddress: string;
     fallbackNetworkFeeCryptoBaseUnit: string | undefined;

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.js

@@ -3,7 +3,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 export async function getDebridgeStepData(args) {
-    const { tx, gasLimit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
+    const { tx, sellAmountCryptoBaseUnit, gasLimit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     const transactionData = {
@@ -16,7 +16,7 @@ export async function getDebridgeStepData(args) {
     };
     const stateOverride = {
         sellAsset,
-        sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        sellAmountCryptoBaseUnit,
         spenderAddress,
     };
     if (type === 'rate') {

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeTradeContext.js

@@ -81,6 +81,7 @@ export const getDebridgeTradeContext = async ({ input, deps, senderAddress, reci
         protocolFees: quote.protocolFees,
         stepDataArgs: {
             tx: quote.tx,
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
             gasLimit: quote.gasLimit,
             fallbackNetworkFeeCryptoBaseUnit: quote.fallbackNetworkFeeCryptoBaseUnit,
             sellAsset,

package/dist/esm/swappers/NearIntentsSwapper/NearIntentsSwapper.js

@@ -1,5 +1,6 @@
 import { executeEvmTransaction, executeNearTransaction, executeSolanaTransaction, executeStarknetTransaction, executeSuiTransaction, executeTonTransaction, executeTronTransaction, } from '../../utils/index.js';
 export const nearIntentsSwapper = {
+    supportsExternalPayment: true,
     executeEvmTransaction,
     executeSolanaTransaction,
     executeStarknetTransaction,

package/dist/esm/swappers/NearIntentsSwapper/checkTradeStatus.test.d.ts

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

package/dist/esm/swappers/NearIntentsSwapper/checkTradeStatus.test.js

@@ -0,0 +1,50 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { nearIntentsApi } from './endpoints.js';
+import { OneClickService } from './utils/oneClickService.js';
+vi.mock('./utils/oneClickService', () => ({
+    initializeOneClickService: vi.fn(),
+    OneClickService: { getExecutionStatus: vi.fn() },
+}));
+const makeInput = () => ({
+    config: { VITE_NEAR_INTENTS_API_KEY: 'key' },
+    swap: {
+        metadata: { swapperMetadata: { name: 'nearIntents', depositAddress: '0xdepositaddress' } },
+    },
+});
+const mockExecutionStatus = (response) => vi.mocked(OneClickService.getExecutionStatus).mockResolvedValue(response);
+describe('near intents checkTradeStatus', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('reports the origin chain deposit tx hash', async () => {
+        mockExecutionStatus({
+            status: 'PROCESSING',
+            swapDetails: {
+                originChainTxHashes: [{ hash: '0xdeposit', explorerUrl: '' }],
+                destinationChainTxHashes: [],
+            },
+        });
+        const result = await nearIntentsApi.checkTradeStatus(makeInput());
+        expect(result.sellTxHash).toBe('0xdeposit');
+        expect(result.buyTxHash).toBeUndefined();
+    });
+    it('reports both sides once the swap settles', async () => {
+        mockExecutionStatus({
+            status: 'SUCCESS',
+            swapDetails: {
+                originChainTxHashes: [{ hash: '0xdeposit', explorerUrl: '' }],
+                destinationChainTxHashes: [{ hash: '0xsettlement', explorerUrl: '' }],
+            },
+        });
+        const result = await nearIntentsApi.checkTradeStatus(makeInput());
+        expect(result.sellTxHash).toBe('0xdeposit');
+        expect(result.buyTxHash).toBe('0xsettlement');
+    });
+    it('has no deposit tx hash before the deposit lands', async () => {
+        mockExecutionStatus({
+            status: 'PENDING_DEPOSIT',
+            swapDetails: { originChainTxHashes: [], destinationChainTxHashes: [] },
+        });
+        expect((await nearIntentsApi.checkTradeStatus(makeInput())).sellTxHash).toBeUndefined();
+    });
+});

package/dist/esm/swappers/NearIntentsSwapper/constants.d.ts

@@ -1,4 +1,4 @@
 export declare const ONE_CLICK_BASE_URL = "https://1click.chaindefuser.com";
 export declare const DEFAULT_SLIPPAGE_BPS = 50;
 export declare const DEFAULT_QUOTE_DEADLINE_MS: number;
-export declare const BTC_QUOTE_DEADLINE_MS: number;
+export declare const UTXO_QUOTE_DEADLINE_MS: number;

package/dist/esm/swappers/NearIntentsSwapper/constants.js

@@ -1,4 +1,5 @@
 export const ONE_CLICK_BASE_URL = 'https://1click.chaindefuser.com';
 export const DEFAULT_SLIPPAGE_BPS = 50;
-export const DEFAULT_QUOTE_DEADLINE_MS = 30 * 60 * 1000;
-export const BTC_QUOTE_DEADLINE_MS = 60 * 60 * 1000;
+// 1Click refunds a deposit it cannot settle by the requested deadline, and prices a quote the same at any length
+export const DEFAULT_QUOTE_DEADLINE_MS = 60 * 60 * 1000;
+export const UTXO_QUOTE_DEADLINE_MS = 4 * 60 * 60 * 1000;

package/dist/esm/swappers/NearIntentsSwapper/endpoints.js

@@ -4,13 +4,15 @@ import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/ev
 import { getSolanaTransactionFees, getUnsignedSolanaTransaction } from '../../utils/solana/index.js';
 import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
 import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
-import { getTradeQuote } from './swapperApi/getTradeQuote.js';
-import { getTradeRate } from './swapperApi/getTradeRate.js';
+import { getExactOutputTradeQuote, getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getExactOutputTradeRate, getTradeRate } from './swapperApi/getTradeRate.js';
 import { getNearIntentsStatusMessage, mapNearIntentsStatus } from './utils/helpers.js';
 import { initializeOneClickService, OneClickService } from './utils/oneClickService.js';
 export const nearIntentsApi = {
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
     getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getExactOutputTradeQuote: (input, deps) => getExactOutputTradeQuote(input, deps),
+    getExactOutputTradeRate: (input, deps) => getExactOutputTradeRate(input, deps),
     getUnsignedEvmTransaction,
     getEvmTransactionFees,
     getUnsignedUtxoTransaction,
@@ -161,14 +163,15 @@ export const nearIntentsApi = {
             const statusResponse = await OneClickService.getExecutionStatus(depositAddress);
             const txStatus = mapNearIntentsStatus(statusResponse.status);
             const message = getNearIntentsStatusMessage(statusResponse.status);
-            // Extract buyTxHash from destination chain transactions
             const buyTxHash = statusResponse.swapDetails?.destinationChainTxHashes?.[0]?.hash;
+            const sellTxHash = statusResponse.swapDetails?.originChainTxHashes?.[0]?.hash;
             // amountOut is only meaningful destination-denominated on terminal success - in-flight and
             // refund states may carry settlement-internal or refund values
             const actualBuyAmountCryptoBaseUnit = statusResponse.status === 'SUCCESS' ? statusResponse.swapDetails?.amountOut : undefined;
             return {
                 status: txStatus,
                 buyTxHash,
+                sellTxHash,
                 swapperTxLink: `https://explorer.near-intents.org/transactions/${depositAddress}`,
                 message,
                 actualBuyAmountCryptoBaseUnit,

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.d.ts

@@ -1,4 +1,5 @@
 import type { Result } from '@sniptt/monads';
 import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
-import type { NearIntentsTradeQuoteInput } from '../types.js';
+import type { NearIntentsExactOutputTradeQuoteInput, NearIntentsTradeQuoteInput } from '../types.js';
 export declare const getTradeQuote: (input: NearIntentsTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;
+export declare const getExactOutputTradeQuote: (input: NearIntentsExactOutputTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeQuote.js

@@ -1,17 +1,19 @@
 import { Err, Ok } from '@sniptt/monads';
 import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getTradeAmount } from '../../../utils/helpers.js';
 import { QuoteRequest } from '../types.js';
 import { getNearIntentsStepData } from '../utils/getNearIntentsStepData.js';
 import { getNearIntentsTradeContext } from '../utils/getNearIntentsTradeContext.js';
 import { buildNearIntentsQuoteRequest, fetchNearIntentsQuote, getNearIntentsQuoteDeadline, resolveNearIntentsAssets, } from '../utils/helpers.js';
 import { initializeOneClickService } from '../utils/oneClickService.js';
-export const getTradeQuote = async (input, deps) => {
-    const { sellAsset, buyAsset, accountNumber, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, } = input;
+const getQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, accountNumber, affiliateBps } = input;
     const addresses = assertQuoteAddresses(input);
     if (addresses.isErr())
         return Err(addresses.unwrapErr());
     const { sendAddress, receiveAddress } = addresses.unwrap();
     initializeOneClickService(deps.config.VITE_NEAR_INTENTS_API_KEY);
+    const amount = getTradeAmount(input);
     const maybeAssets = await resolveNearIntentsAssets({ sellAsset, buyAsset });
     if (maybeAssets.isErr())
         return Err(maybeAssets.unwrapErr());
@@ -19,7 +21,7 @@ export const getTradeQuote = async (input, deps) => {
     const quoteRequest = buildNearIntentsQuoteRequest({
         originAsset,
         destinationAsset,
-        sellAmountCryptoBaseUnit: sellAmount,
+        amount,
         slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
         affiliateBps,
         refundTo: sendAddress,
@@ -72,3 +74,5 @@ export const getTradeQuote = async (input, deps) => {
     };
     return Ok([tradeQuote]);
 };
+export const getTradeQuote = (input, deps) => getQuote(input, deps);
+export const getExactOutputTradeQuote = (input, deps) => getQuote(input, deps);

package/dist/esm/swappers/NearIntentsSwapper/swapperApi/getTradeRate.d.ts

@@ -1,4 +1,5 @@
 import type { Result } from '@sniptt/monads';
 import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
-import type { NearIntentsTradeRateInput } from '../types.js';
+import type { NearIntentsExactOutputTradeRateInput, NearIntentsTradeRateInput } from '../types.js';
 export declare const getTradeRate: (input: NearIntentsTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;
+export declare const getExactOutputTradeRate: (input: NearIntentsExactOutputTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;