@shapeshiftoss/swapper 20.0.0 → 20.1.1

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

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

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

@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { estimateGasWithStateOverride } from '../../../utils/evm/index.js';
+import { USDC_MAINNET } from '../../../utils/test-data/assets.js';
+import { fetchPortalsTradeEstimate } from './fetchPortalsTradeOrder.js';
+import { getPortalsStepData } from './getPortalsStepData.js';
+vi.mock('../../../utils/evm', async (importOriginal) => ({
+    ...(await importOriginal()),
+    estimateGasWithStateOverride: vi.fn(),
+}));
+vi.mock('./fetchPortalsTradeOrder', async (importOriginal) => ({
+    ...(await importOriginal()),
+    fetchPortalsTradeEstimate: 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) => getPortalsStepData({
+    type: 'rate',
+    input: { supportsEIP1559: false },
+    deps,
+    tx: portalsTx,
+    sellAsset: USDC_MAINNET,
+    sellAmountCryptoBaseUnit: '1000000000',
+    spenderAddress: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    inputToken: 'ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    outputToken: 'arbitrum:0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+    inputAmount: '1000000000',
+    slippageTolerancePercentage: 2.5,
+});
+const estimateEndpointGasLimit = (gasLimit) => vi.mocked(fetchPortalsTradeEstimate).mockResolvedValue({
+    context: { gasLimit },
+});
+describe('getPortalsStepData rate gas limit', () => {
+    beforeEach(() => vi.clearAllMocks());
+    it('falls back to the order gas limit on bridge routes the estimate endpoint zeroes', async () => {
+        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        estimateEndpointGasLimit(0);
+        const actual = await rate(tx('76384'));
+        expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '76384000000000' });
+        expect(fetchPortalsTradeEstimate).not.toHaveBeenCalled();
+    });
+    it('falls back to the estimate endpoint when the order carries no gas limit', async () => {
+        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        estimateEndpointGasLimit(273203);
+        const actual = await rate(tx(undefined));
+        expect(actual.unwrap()).toEqual({ networkFeeCryptoBaseUnit: '273203000000000' });
+    });
+    it('errors rather than pricing a zero gas limit as a free trade', async () => {
+        vi.mocked(estimateGasWithStateOverride).mockRejectedValue(new Error('execution reverted'));
+        estimateEndpointGasLimit(0);
+        const actual = await rate(tx(undefined));
+        expect(actual.isErr()).toBe(true);
+        expect(actual.unwrapErr().message).toContain('getPortalsStepData');
+    });
+});

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

@@ -15,12 +15,12 @@ type PortalsTradeContext = {
         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/esm/swappers/PortalsSwapper/utils/getPortalsTradeContext.js

@@ -1,14 +1,29 @@
-import { bn, bnOrZero } from '@shapeshiftoss/utils';
+import { BigNumber, bn, bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils/index.js';
 import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
 import { getPortalsRouterAddressByChainId } from './helpers.js';
-export const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, orderContext, tx, }) => {
-    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
-    const { orderId, outputAmount, minOutputAmount, target, feeAmount, feeToken } = orderContext;
+export 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 = bnOrZero(slippageTolerancePercentage).div(100);
+    // Unvalidated orders report the post-slippage minimum in both amount fields
+    const hasSlippageBuffer = bnOrZero(outputAmount).gt(minOutputAmount);
+    const preSlippageOutputAmount = bnOrZero(minOutputAmount)
+        .div(bn(1).minus(appliedSlippageDecimal))
+        .toFixed(0);
+    const buyAmountAfterFeesCryptoBaseUnit = hasSlippageBuffer
+        ? outputAmount
+        : preSlippageOutputAmount;
+    const bufferSlippageDecimal = hasSlippageBuffer
+        ? bnOrZero(outputAmount).minus(minOutputAmount).div(outputAmount)
+        : appliedSlippageDecimal;
+    const slippageTolerancePercentageDecimal = BigNumber.max(appliedSlippageDecimal, bufferSlippageDecimal).toString();
     const rate = getInputOutputRate({
         sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
         buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
@@ -24,16 +39,13 @@ export const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, o
             details: { chainId: sellChainId },
         }));
     }
-    // Portals reports the slippage we requested, not what it applied — recover the actual buffer from the amounts
-    const actualBufferDecimal = bnOrZero(buyAmountAfterFeesCryptoBaseUnit)
-        .minus(minOutputAmount)
-        .div(buyAmountAfterFeesCryptoBaseUnit)
-        .toString();
-    // Reverse the buffer to recover the expected output (minOutput / (1 - buffer) = output)
-    const buyAmountBeforeFeesCryptoBaseUnit = bnOrZero(minOutputAmount)
-        .div(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
+        ? bnOrZero(buyAmountAfterFeesCryptoBaseUnit).plus(feeAmount).toFixed(0)
+        : buyAmountAfterFeesCryptoBaseUnit;
     const protocolFees = (() => {
         if (!feeToken || !feeAmount)
             return;
@@ -51,7 +63,7 @@ export const getPortalsTradeContext = ({ input, deps, sellChainId, inputToken, o
             rate,
             swapperName: SwapperName.Portals,
             affiliateBps,
-            slippageTolerancePercentageDecimal: actualBufferDecimal,
+            slippageTolerancePercentageDecimal,
         },
         stepCommon: {
             estimatedExecutionTimeMs: isCrossChain ? 300000 : 0,

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

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

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

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { USDC_ARBITRUM, USDC_MAINNET } from '../../../utils/test-data/assets.js';
+import { getPortalsTradeContext } from './getPortalsTradeContext.js';
+const deps = {};
+const tx = {
+    to: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    from: '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
+    data: '0xdeadbeef',
+    value: '0',
+};
+const makeInput = (buyAsset = USDC_ARBITRUM) => ({
+    sellAsset: USDC_MAINNET,
+    buyAsset,
+    affiliateBps: '0',
+    sellAmountIncludingProtocolFeesCryptoBaseUnit: '4631313795',
+});
+const makeOrderContext = (overrides) => ({
+    orderId: 'eaae8ea5-30af-4463-97ab-1c5b1fe7def4',
+    target: '0x4cd00e387622c35bddb9b4c962c136462338bc31',
+    inputAmount: '4631313795',
+    ...overrides,
+});
+const unwrap = (args) => getPortalsTradeContext(args).unwrap();
+describe('getPortalsTradeContext', () => {
+    it('does not gross up a bridge route Portals applied no slippage to', () => {
+        const { stepCommon, tradeCommon } = unwrap({
+            input: makeInput(),
+            deps,
+            sellChainId: USDC_MAINNET.chainId,
+            orderContext: makeOrderContext({
+                outputAmount: '4616564490',
+                minOutputAmount: '4616564490',
+                slippageTolerancePercentage: 0,
+            }),
+            outputToken: 'arbitrum:0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+            tx,
+        });
+        expect(stepCommon.buyAmountAfterFeesCryptoBaseUnit).toBe('4616564490');
+        expect(tradeCommon.slippageTolerancePercentageDecimal).toBe('0');
+    });
+    it('reverses the applied slippage on an unvalidated order collapsed to its minimum', () => {
+        const { stepCommon, tradeCommon } = unwrap({
+            input: makeInput(USDC_MAINNET),
+            deps,
+            sellChainId: 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
+        expect(stepCommon.buyAmountAfterFeesCryptoBaseUnit).toBe('2421101892');
+        expect(tradeCommon.slippageTolerancePercentageDecimal).toBe('0.025');
+    });
+    it('keeps the reported output of a validated order and advertises the wider buffer', () => {
+        const { stepCommon, tradeCommon } = unwrap({
+            input: makeInput(USDC_MAINNET),
+            deps,
+            sellChainId: USDC_MAINNET.chainId,
+            orderContext: makeOrderContext({
+                outputAmount: '2420957576',
+                minOutputAmount: '2360574345',
+                slippageTolerancePercentage: 2.5,
+            }),
+            outputToken: 'ethereum:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            tx,
+        });
+        expect(stepCommon.buyAmountAfterFeesCryptoBaseUnit).toBe('2420957576');
+        expect(tradeCommon.slippageTolerancePercentageDecimal).toBe('0.025');
+    });
+    it('prices against the input amount Portals filled rather than the one requested', () => {
+        const { stepCommon } = unwrap({
+            input: makeInput(),
+            deps,
+            sellChainId: 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,
+        });
+        expect(stepCommon.sellAmountIncludingProtocolFeesCryptoBaseUnit).toBe('4630850664');
+    });
+});

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

@@ -11,6 +11,7 @@ import { getExactOutputTradeRate, getTradeRate } from './getTradeRate/getTradeRa
 import { getLatestRelayStatusMessage } from './utils/getLatestRelayStatusMessage.js';
 import { notifyTransactionIndexing } from './utils/notifyTransactionIndexing.js';
 import { getRelayRequestConfig, relayService } from './utils/relayService.js';
+import { getRelayTrackingLink, relayStatusToTxStatus } from './utils/relayStatus.js';
 // Keep track of the trades we already notified the relay indexer about
 const txIndexingMap = new Map();
 export const relayApi = {
@@ -66,7 +67,7 @@ export const relayApi = {
         }
         // relay.link tracks the swap by its origin chain transaction
         const swapperTxId = txHash;
-        const swapperTxLink = `https://relay.link/transaction/${txHash}`;
+        const swapperTxLink = getRelayTrackingLink(txHash);
         const maybeStatusResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/intents/status/v3?requestId=${relayMetadata.relayId}`, getRelayRequestConfig(config));
         if (maybeStatusResponse.isErr()) {
             return {
@@ -78,23 +79,7 @@ export const relayApi = {
             };
         }
         const { data: statusResponse } = maybeStatusResponse.unwrap();
-        const status = (() => {
-            switch (statusResponse.status) {
-                case 'success':
-                    return TxStatus.Confirmed;
-                case 'waiting':
-                case 'delayed':
-                case 'pending':
-                case 'depositing':
-                case 'submitted':
-                    return TxStatus.Pending;
-                case 'failure':
-                case 'refund':
-                    return TxStatus.Failed;
-                default:
-                    return TxStatus.Unknown;
-            }
-        })();
+        const status = 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/esm/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.js';
+import type { RelayRequest, RelayStatus } from './types.js';
+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/esm/swappers/RelaySwapper/utils/relayStatus.js

@@ -0,0 +1,32 @@
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { getRelayRequestConfig, relayService } from './relayService.js';
+export const getRelayTrackingLink = (txHash) => `https://relay.link/transaction/${txHash}`;
+export const relayStatusToTxStatus = (status) => {
+    switch (status) {
+        case 'success':
+            return TxStatus.Confirmed;
+        case 'waiting':
+        case 'delayed':
+        case 'pending':
+        case 'depositing':
+        case 'submitted':
+            return TxStatus.Pending;
+        case 'failure':
+        case 'refund':
+            return TxStatus.Failed;
+        default:
+            return TxStatus.Unknown;
+    }
+};
+// Relay index requests by origin tx hash, resolving a swap we hold no relayId for
+export const fetchRelayRequestByTxHash = async (txHash, config) => {
+    const maybeResponse = await relayService.get(`${config.VITE_RELAY_API_URL}/requests/v2?hash=${txHash}`, 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())));
+};
+export 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';
+};

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

@@ -12,6 +12,20 @@ export type RelayMetadata = {
     relayId: string;
     data?: string;
 };
+export type RelayRequestTransaction = {
+    hash?: string;
+    chainId?: number;
+};
+export type RelayRequestData = {
+    failReason?: string;
+    refundFailReason?: string;
+    inTxs?: RelayRequestTransaction[];
+    outTxs?: RelayRequestTransaction[];
+};
+export type RelayRequest = {
+    status?: RelayStatus['status'];
+    data?: RelayRequestData;
+};
 export type RelayStatus = {
     status: 'success' | 'failure' | 'pending' | 'submitted' | 'depositing' | 'refund' | 'delayed' | 'waiting';
     details?: string;

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

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

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

@@ -27,7 +27,7 @@ const fetchFromZrx = async ({ quoteOrRate, buyAsset, sellAsset, sellAmountInclud
             swapFeeToken: assetIdToZrxToken(buyAsset.assetId),
             slippageBps: convertDecimalPercentageToBasisPoints(slippageTolerancePercentageDecimal).toNumber(),
             swapFeeRecipient: maybeTreasuryAddress,
-            feeRecipientTradeSurplus: maybeTreasuryAddress, // Where trade surplus is sent
+            tradeSurplusRecipient: maybeTreasuryAddress, // Where trade surplus is sent
         },
     });
     if (maybeZrxPriceResponse.isErr()) {

package/dist/esm/types.d.ts

@@ -574,6 +574,7 @@ export type CheckTradeStatusInput = {
 export type TradeStatus = {
     status: TxStatus;
     buyTxHash: string | undefined;
+    sellTxHash?: string | undefined;
     swapperTxId?: string | undefined;
     swapperTxLink?: string | undefined;
     message: string | [string, InterpolationOptions] | undefined;
@@ -583,6 +584,7 @@ export type TradeQuoteResult = Result<TradeQuote[], SwapErrorRight>;
 export type TradeRateResult = Result<TradeRate[], SwapErrorRight>;
 export type EvmMessageToSign = CowMessageToSign;
 export type Swapper = {
+    supportsExternalPayment?: boolean;
     executeEvmTransaction?: (txToSign: SignTx<EvmChainId>, callbacks: EvmTransactionExecutionProps) => Promise<string>;
     executeEvmMessage?: (txMetaToSign: EvmMessageToSign, callbacks: EvmMessageExecutionProps, config: SwapperConfig) => Promise<string>;
     executeUtxoTransaction?: (txToSign: SignTx<UtxoChainId>, callbacks: UtxoTransactionExecutionProps) => Promise<string>;

package/dist/esm/utils/cowswap/index.d.ts

@@ -1,4 +1,5 @@
-import type { OrderClass1 } from '@cowprotocol/app-data/dist/generatedTypes/v1.3.0';
+import type { AppDataRootSchema as AppDataRootSchemaLegacy } from '@cowprotocol/app-data/dist/generatedTypes/v0.4.0';
+import type { AppDataRootSchema as AppDataRootSchemaLatest, OrderClass1 } from '@cowprotocol/app-data/dist/generatedTypes/v1.3.0';
 import type { ChainId } from '@shapeshiftoss/caip';
 import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
 import type { HDWallet } from '@shapeshiftoss/hdwallet-core';
@@ -22,3 +23,5 @@ export declare const getFullAppData: (slippageTolerancePercentage: string, affil
     appDataHash: string;
     appData: string;
 }>;
+export type ParsedAppData = AppDataRootSchemaLatest | AppDataRootSchemaLegacy;
+export declare const isLegacyAppData: (appData: ParsedAppData) => appData is AppDataRootSchemaLegacy;

package/dist/esm/utils/cowswap/index.js

@@ -158,3 +158,6 @@ export const getFullAppData = async (slippageTolerancePercentage, affiliateAppDa
     const { fullAppData, appDataKeccak256 } = await generateAppDataFromDoc(appDataDoc);
     return { appDataHash: appDataKeccak256, appData: fullAppData };
 };
+export const isLegacyAppData = (appData) => {
+    return appData.version === '0.4.0';
+};

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

@@ -1,5 +1,6 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
-import type { TradeAmount } from '../types.js';
+import type { TradeAmount, TradeStepCommon } from '../types.js';
+import { SwapperName } from '../types.js';
 export declare const FALLBACK_QUOTE_DEADLINE_MS = 60000;
 export declare const getTradeAmount: (input: {
     sellAmountIncludingProtocolFeesCryptoBaseUnit: string;
@@ -9,3 +10,5 @@ export declare const getTradeAmount: (input: {
 export declare const normalizeEpochToMs: (value: number) => number;
 export declare const isNativeEvmAsset: (assetId: AssetId) => boolean;
 export declare const getTreasuryAddressFromChainId: (chainId: ChainId) => string;
+export type DepositAddressStep = Pick<TradeStepCommon, 'chainflipSpecific' | 'swapperMetadata'>;
+export declare const getDepositAddress: (step: DepositAddressStep, swapperName: SwapperName) => string | undefined;

package/dist/esm/utils/helpers.js

@@ -1,6 +1,7 @@
 import { arbitrumAssetId, avalancheAssetId, baseAssetId, bscAssetId, ethAssetId, fromAssetId, gnosisAssetId, katanaAssetId, monadAssetId, optimismAssetId, plasmaAssetId, polygonAssetId, } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { DAO_TREASURY_ARBITRUM, DAO_TREASURY_AVALANCHE, DAO_TREASURY_BASE, DAO_TREASURY_BITCOIN, DAO_TREASURY_BOB, DAO_TREASURY_BSC, DAO_TREASURY_ETHEREUM_MAINNET, DAO_TREASURY_GNOSIS, DAO_TREASURY_HYPEREVM, DAO_TREASURY_MONAD, DAO_TREASURY_OPTIMISM, DAO_TREASURY_POLYGON, DAO_TREASURY_SOLANA, DAO_TREASURY_STARKNET, DAO_TREASURY_TON, isTreasuryChainId, } from '@shapeshiftoss/utils';
+import { SwapperName } from '../types.js';
 // Deadline for providers without their own expiry - short enough to keep priced amounts honest
 export const FALLBACK_QUOTE_DEADLINE_MS = 60_000;
 export const getTradeAmount = (input) => 'buyAmountCryptoBaseUnit' in input
@@ -71,3 +72,19 @@ export const getTreasuryAddressFromChainId = (chainId) => {
         throw new Error(`[getTreasuryAddressFromChainId] - Unsupported chainId: ${chainId}`);
     return treasuryAddress;
 };
+export const getDepositAddress = (step, swapperName) => {
+    switch (swapperName) {
+        case SwapperName.Chainflip:
+            return step.chainflipSpecific?.depositAddress || undefined;
+        case SwapperName.NearIntents: {
+            if (step.swapperMetadata?.name !== 'nearIntents')
+                return;
+            const { depositAddress, depositMemo } = step.swapperMetadata;
+            if (depositMemo)
+                return;
+            return depositAddress || undefined;
+        }
+        default:
+            return;
+    }
+};

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

@@ -2,7 +2,9 @@ import { thorchainChainId } from '@shapeshiftoss/caip';
 import { KnownChainIds } from '@shapeshiftoss/types';
 import { treasuryChainIds } from '@shapeshiftoss/utils';
 import { describe, expect, it } from 'vitest';
-import { getTreasuryAddressFromChainId, normalizeEpochToMs } from './helpers.js';
+import { swappers } from '../constants.js';
+import { SwapperName } from '../types.js';
+import { getDepositAddress, getTreasuryAddressFromChainId, normalizeEpochToMs } from './helpers.js';
 describe('getTreasuryAddressFromChainId', () => {
     // Affiliate and fee recipient addresses for every swapper flow through here, so pin the values
     // rather than the wiring - a chain pointing at another chain's treasury misroutes revenue silently
@@ -47,3 +49,42 @@ describe('normalizeEpochToMs', () => {
         expect(normalizeEpochToMs(epochMs * 1e6)).toBe(epochMs);
     });
 });
+const makeStep = (step) => step;
+describe('getDepositAddress', () => {
+    it('reads the chainflip deposit address', () => {
+        const step = makeStep({ chainflipSpecific: { depositAddress: 'bc1qdeposit' } });
+        expect(getDepositAddress(step, SwapperName.Chainflip)).toBe('bc1qdeposit');
+    });
+    it('returns undefined when chainflip has no deposit address', () => {
+        expect(getDepositAddress(makeStep({}), SwapperName.Chainflip)).toBeUndefined();
+    });
+    it('reads the near intents deposit address', () => {
+        const step = makeStep({
+            swapperMetadata: { name: 'nearIntents', depositAddress: '0xdeposit' },
+        });
+        expect(getDepositAddress(step, SwapperName.NearIntents)).toBe('0xdeposit');
+    });
+    it('rejects a memo-bound near intents deposit address', () => {
+        const step = makeStep({
+            swapperMetadata: { name: 'nearIntents', depositAddress: 'EQdeposit', depositMemo: '12345' },
+        });
+        expect(getDepositAddress(step, SwapperName.NearIntents)).toBeUndefined();
+    });
+    it('rejects an empty near intents deposit address', () => {
+        const step = makeStep({ swapperMetadata: { name: 'nearIntents', depositAddress: '' } });
+        expect(getDepositAddress(step, SwapperName.NearIntents)).toBeUndefined();
+    });
+    it('returns undefined for swappers that do not use deposit addresses', () => {
+        const step = makeStep({ chainflipSpecific: { depositAddress: 'bc1qdeposit' } });
+        expect(getDepositAddress(step, SwapperName.Relay)).toBeUndefined();
+    });
+});
+describe('supportsExternalPayment', () => {
+    it('is flagged on exactly the externally paid swappers', () => {
+        const flagged = Object.entries(swappers)
+            .filter(([, swapper]) => swapper?.supportsExternalPayment)
+            .map(([name]) => name)
+            .sort();
+        expect(flagged).toEqual([SwapperName.Chainflip, SwapperName.NearIntents].sort());
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/swapper",
-  "version": "20.0.0",
+  "version": "20.1.1",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "@coral-xyz/anchor": "0.29.0",
     "@cowprotocol/app-data": "^2.3.0",
     "@defuse-protocol/one-click-sdk-typescript": "^0.1.1-0.2",
-    "@gobob/bob-sdk": "5.8.1",
+    "@gobob/bob-sdk": "5.11.1",
     "@mysten/sui": "^1.45.2",
     "@shapeshiftoss/bitcoinjs-lib": "7.0.0-shapeshift.0",
     "@sniptt/monads": "^0.5.10",
@@ -50,13 +50,13 @@
     "retry-axios": "^2.6.0",
     "uuid": "^9.0.0",
     "viem": "2.55.11",
+    "@shapeshiftoss/caip": "^8.17.0",
     "@shapeshiftoss/chain-adapters": "^11.5.1",
-    "@shapeshiftoss/hdwallet-core": "^1.62.41",
     "@shapeshiftoss/contracts": "^1.0.7",
-    "@shapeshiftoss/caip": "^8.16.10",
     "@shapeshiftoss/unchained-client": "^10.14.11",
-    "@shapeshiftoss/utils": "^1.1.0",
-    "@shapeshiftoss/types": "^9.0.0"
+    "@shapeshiftoss/types": "^9.0.1",
+    "@shapeshiftoss/utils": "^1.2.0",
+    "@shapeshiftoss/hdwallet-core": "^1.62.41"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.178",