tapimo 0.15.1 → 0.18.1

package/dist/internal/routes/providers/relay.js

@@ -1,22 +1,49 @@
-import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex } from 'ox';
+import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex, Value as core_Value } from 'ox';
 import { getBlockNumber, getLogs, getTransaction, getTransactionReceipt } from 'viem/actions';
 import * as z from 'zod/mini';
 import * as Db from '../../../db/Db.js';
 import * as RoutesDepositAddresses from '../../../db/tables/routesDepositAddresses.js';
 import * as RoutesDepositRequestObservations from '../../../db/tables/routesDepositRequestObservations.js';
+import * as Store from '../../Store.js';
 import * as Value from '../../Value.js';
 import * as Viem from '../../Viem.js';
 import * as RoutesCatalog from '../Catalog.js';
 import * as RoutesChain from '../Chain.js';
 import * as Evidence from '../Evidence.js';
 import * as RoutesProvider from '../Provider.js';
+import * as ProviderQuota from '../Quota.js';
 import * as Subsidy from '../Subsidy.js';
 const defaultBaseUrl = 'https://api.relay.link';
 const defaultFetch = (input, init) => globalThis.fetch(input, init);
 const deliveryBackfillBlocks = 256n;
+// Quote-time fee insufficiency is an expected rejection, not a provider outage.
+const quoteUnavailableCodes = ['AMOUNT_TOO_LOW', 'NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE'];
+// Recheck the Relay key dashboard before changing account-specific quotas.
+// Treat /quote/v2 as generic /quote until Relay confirms its bridge classification.
+const quoteRateLimit = 10;
+// Reserve two requests for operations that must turn an accepted quote into work.
+const quoteReadRateLimit = 8;
+const quoteRateLimitWindowMs = 1_000;
+const quoteQuotaStoreKey = 'routes:relay:quote-v2';
 const relayChainsCacheTtlMs = 60_000;
 const relayRefundStatuses = ['refund', 'refunded'];
 const relayRequestPageLimit = 100;
+const requestsRateLimit = 20;
+const requestsRateLimitWindowMs = 1_000;
+const requestsQuotaStoreKey = 'routes:relay:requests-v3';
+const chainsTimeoutMs = 10_000;
+const requestsTimeoutMs = 10_000;
+// Relay app-balance sponsorship can settle in Base USDC even when neither route leg uses it.
+const sponsorToken = {
+    address: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+    currency: 'USD',
+    decimals: 6,
+    name: 'USD Coin',
+    standard: 'ERC-20',
+    symbol: 'USDC',
+    tokenKey: 'eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+    verified: true,
+};
 const sourceSweepForwardBlocks = 256n;
 const depositErc20FullAllowance = AbiFunction.from('function depositErc20(address depositor,address token,bytes32 id)');
 const depositErc20WithAmount = AbiFunction.from('function depositErc20(address depositor,address token,uint256 amount,bytes32 id)');
@@ -92,7 +119,9 @@ var schema;
         steps: z.array(Step),
     });
     schema.DepositAddress = z.object({
-        details: schema.PreparedQuote.shape.details,
+        details: z.extend(schema.PreparedQuote.shape.details, {
+            isFixedRate: z.optional(z.boolean()),
+        }),
         fees: schema.PreparedQuote.shape.fees,
         steps: z.array(z.object({
             depositAddress: z.optional(z.string()),
@@ -172,6 +201,46 @@ var schema;
             updatedAt: z.iso.datetime(),
         })),
     });
+    const TransferCurrency = z.object({
+        amount: Decimal,
+        currency: z.object({
+            address: z.string(),
+            chainId: Integer,
+        }),
+    });
+    const TransferTransaction = z.object({
+        chainId: Integer,
+        status: z.string(),
+        txHash: z.nullish(z.string()),
+    });
+    schema.TransferRequests = z.object({
+        requests: z.array(z.object({
+            data: z.optional(z.object({
+                inTxs: z.optional(z.array(TransferTransaction)),
+                outTxs: z.optional(z.array(TransferTransaction)),
+                route: z.optional(z.object({
+                    actual: z.optional(z.object({
+                        destination: z.optional(z.object({ outputCurrency: TransferCurrency })),
+                        origin: z.optional(z.object({ inputCurrency: TransferCurrency })),
+                    })),
+                })),
+            })),
+            id: z.string().check(z.minLength(1)),
+            protocol: z.nullish(z.object({
+                deposit: z.optional(z.object({
+                    origin: z.optional(z.object({
+                        depository: z.optional(z.string()),
+                    })),
+                })),
+            })),
+            recipient: z.optional(z.string()),
+            sender: z.optional(z.string()),
+            status: z.string().check(z.minLength(1)),
+        })),
+    });
+    schema.TransferCorrelation = z.object({
+        requestId: z.string().check(z.minLength(1)),
+    });
     schema.WebhookPayload = z.object({
         data: z.object({
             depositAddress: z.nullable(z.object({ address: z.string().check(z.minLength(1)) })),
@@ -197,6 +266,80 @@ export function relay(options = {}) {
     const endpoint = quoteEndpoint(options);
     const fetch = options.fetch ?? defaultFetch;
     const now = options.now ?? (() => new Date());
+    const rateLimitStore = options.rateLimitStore ?? Store.memory();
+    const verifyTransfers = options.observation
+        ? Evidence.createVerifier({
+            ...options.observation,
+            fetch,
+        })
+        : undefined;
+    let transferChainsExpiresAt = 0;
+    let transferChainsPromise;
+    const getTransferChains = (signal) => {
+        if (transferChainsPromise && now().getTime() < transferChainsExpiresAt)
+            return transferChainsPromise;
+        transferChainsExpiresAt = now().getTime() + relayChainsCacheTtlMs;
+        transferChainsPromise = RoutesProvider.requestJson(chainsEndpoint(options), {
+            fetch,
+            headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+            signal: AbortSignal.any([signal, AbortSignal.timeout(chainsTimeoutMs)]),
+        })
+            .then((value) => schema.Chains.parse(value).chains)
+            .catch((cause) => {
+            transferChainsExpiresAt = 0;
+            transferChainsPromise = undefined;
+            if (cause instanceof DOMException && cause.name === 'TimeoutError')
+                throw new RoutesProvider.ProviderTimeoutError();
+            throw cause;
+        });
+        return transferChainsPromise;
+    };
+    const consumeQuoteQuota = (limit) => ProviderQuota.consume(rateLimitStore, {
+        key: quoteQuotaStoreKey,
+        limit,
+        now: now(),
+        windowMs: quoteRateLimitWindowMs,
+    });
+    const consumeRequestsQuota = () => ProviderQuota.consume(rateLimitStore, {
+        key: requestsQuotaStoreKey,
+        limit: requestsRateLimit,
+        now: now(),
+        windowMs: requestsRateLimitWindowMs,
+    });
+    const blockQuoteOnRateLimit = (cause) => ProviderQuota.blockOnRateLimit(rateLimitStore, cause, {
+        key: quoteQuotaStoreKey,
+        now: now(),
+        windowMs: quoteRateLimitWindowMs,
+    });
+    const blockRequestsOnRateLimit = (cause) => ProviderQuota.blockOnRateLimit(rateLimitStore, cause, {
+        key: requestsQuotaStoreKey,
+        now: now(),
+        windowMs: requestsRateLimitWindowMs,
+    });
+    const getTransferRequest = async (requestId, signal) => {
+        const url = requestsEndpoint(options);
+        url.searchParams.set('id', requestId);
+        await consumeRequestsQuota();
+        const response = await RoutesProvider.requestJson(url, {
+            fetch,
+            headers: { 'x-api-key': options.apiKey },
+            method: 'GET',
+            signal: AbortSignal.any([signal, AbortSignal.timeout(requestsTimeoutMs)]),
+        }).catch(async (cause) => {
+            await blockRequestsOnRateLimit(cause);
+            if (cause instanceof DOMException && cause.name === 'TimeoutError')
+                throw new RoutesProvider.ProviderTimeoutError();
+            throw cause;
+        });
+        const requests = schema.TransferRequests.safeParse(response);
+        if (!requests.success)
+            throw new RoutesProvider.ProviderPayloadError();
+        if (requests.data.requests.some((request) => request.id !== requestId))
+            throw new RoutesProvider.ProviderPayloadError();
+        if (requests.data.requests.length > 1)
+            throw new RoutesProvider.ProviderPayloadError();
+        return requests.data.requests[0];
+    };
     async function listDepositAddressRequests(parameters, signal) {
         const requestUrl = requestsEndpoint(options);
         if (parameters.requestId)
@@ -209,12 +352,23 @@ export function relay(options = {}) {
         requestUrl.searchParams.set('sortDirection', 'desc');
         if (parameters.continuation)
             requestUrl.searchParams.set('continuation', parameters.continuation);
-        const response = await RoutesProvider.requestJson(requestUrl, {
-            fetch,
-            headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
-            method: 'GET',
-            signal,
-        });
+        await consumeRequestsQuota();
+        const response = await (async () => {
+            try {
+                return await RoutesProvider.requestJson(requestUrl, {
+                    fetch,
+                    headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+                    method: 'GET',
+                    signal: AbortSignal.any([signal, AbortSignal.timeout(requestsTimeoutMs)]),
+                });
+            }
+            catch (cause) {
+                await blockRequestsOnRateLimit(cause);
+                if (cause instanceof DOMException && cause.name === 'TimeoutError')
+                    throw new RoutesProvider.ProviderTimeoutError();
+                throw cause;
+            }
+        })();
         const parsed = parseDepositAddressRequests(response);
         return {
             ...(parsed.continuation ? { continuation: parsed.continuation } : {}),
@@ -225,7 +379,7 @@ export function relay(options = {}) {
                     if (!payment || BigInt(payment.amount) === 0n)
                         return undefined;
                     const chainId = `eip155:${payment.chainId}/`;
-                    const token = [parameters.destinationToken, parameters.sourceToken].find((token) => token?.tokenKey.startsWith(chainId) &&
+                    const token = [parameters.destinationToken, parameters.sourceToken, sponsorToken].find((token) => token?.tokenKey.startsWith(chainId) &&
                         token.address.toLowerCase() === payment.address.toLowerCase());
                     if (!token)
                         throw new RoutesProvider.ProviderPayloadError();
@@ -362,8 +516,14 @@ export function relay(options = {}) {
         id: 'relay',
         name: 'Relay',
         ...(webhook ? { webhook } : {}),
-        async createDepositAddress({ amount, candidate, recipient, refundAddress, subsidize }, signal) {
+        async createDepositAddress({ amount, candidate, recipient, refundAddress, subsidize, subsidyMaxAmount }, signal) {
+            if (subsidize &&
+                subsidyMaxAmount !== undefined &&
+                (candidate.sourceToken.currency !== 'USD' ||
+                    !Subsidy.supportsGap({ maxAmount: subsidyMaxAmount }, { amount: 0n, destinationToken: candidate.destinationToken })))
+                throw new RoutesProvider.ProviderUnavailableError();
             if (subsidize &&
+                subsidyMaxAmount === undefined &&
                 (!options.subsidies ||
                     !Subsidy.supports(options.subsidies, {
                         amount,
@@ -373,11 +533,17 @@ export function relay(options = {}) {
                 throw new RoutesProvider.ProviderUnavailableError();
             const quote = await (async () => {
                 try {
+                    await consumeQuoteQuota(quoteRateLimit);
+                    const maximum = subsidyMaxAmount ?? options.subsidies?.maxAmount;
                     return await RoutesProvider.requestJson(endpoint, {
                         body: {
                             amount,
                             destinationChainId: relayChainId(candidate.route.destination.chain),
                             destinationCurrency: candidate.destinationToken.address,
+                            ...(subsidize ? { fixedRate: '1:1' } : {}),
+                            ...(subsidize && maximum !== undefined
+                                ? { maxSubsidizationAmount: core_Value.from(maximum, 6).toString() }
+                                : {}),
                             originChainId: relayChainId(candidate.route.source.chain),
                             originCurrency: candidate.sourceToken.address,
                             recipient,
@@ -394,8 +560,12 @@ export function relay(options = {}) {
                     });
                 }
                 catch (cause) {
-                    if (RoutesProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
-                        throw new RoutesProvider.ProviderUnavailableError();
+                    await blockQuoteOnRateLimit(cause);
+                    const unavailable = RoutesProvider.unavailable(cause, quoteUnavailableCodes);
+                    if (unavailable === 'AMOUNT_TOO_LOW')
+                        throw new RoutesProvider.AmountTooLowError(unavailable, { cause });
+                    if (unavailable)
+                        throw new RoutesProvider.ProviderUnavailableError(unavailable, { cause });
                     throw cause;
                 }
             })();
@@ -404,6 +574,18 @@ export function relay(options = {}) {
                 throw new RoutesProvider.ProviderPayloadError();
             if (parsed.data.details.currencyIn.amount !== amount)
                 throw new RoutesProvider.ProviderPayloadError();
+            if (subsidize) {
+                const expected = (BigInt(amount) * 10n ** BigInt(candidate.destinationToken.decimals)) /
+                    10n ** BigInt(candidate.sourceToken.decimals);
+                // Relay can quote 1:1 with isFixedRate=false and a slippage-adjusted minimum; validate the quoted output.
+                if (BigInt(parsed.data.details.currencyOut.amount) !== expected)
+                    // Relay may have issued an address already; retain the irrevocable claim on invalid terms.
+                    throw new RoutesProvider.ProviderPayloadError(`FIXED_RATE_MISMATCH: ${JSON.stringify({
+                        amount: parsed.data.details.currencyOut.amount,
+                        expected: expected.toString(),
+                        isFixedRate: parsed.data.details.isFixedRate ?? null,
+                    })}`);
+            }
             const step = parsed.data.steps.find((candidate) => candidate.depositAddress && candidate.requestId);
             if (!step?.depositAddress || !step.requestId)
                 throw new RoutesProvider.ProviderPayloadError();
@@ -413,6 +595,7 @@ export function relay(options = {}) {
                 address: step.depositAddress,
                 correlation: {
                     ...(checkEndpoint ? { checkEndpoint } : {}),
+                    ...(subsidize ? { fixedRate: '1:1' } : {}),
                     requestId: step.requestId,
                 },
                 destinationAmount: parsed.data.details.currencyOut.amount,
@@ -441,6 +624,7 @@ export function relay(options = {}) {
             const destinationChainId = relayChainId(route.destination.chain);
             const sourceChainId = relayChainId(route.source.chain);
             try {
+                await consumeQuoteQuota(quoteReadRateLimit);
                 const quote = await RoutesProvider.requestJson(endpoint, {
                     body: {
                         amount: candidate.sourceAmount.amount,
@@ -478,11 +662,8 @@ export function relay(options = {}) {
                 };
             }
             catch (cause) {
-                const unavailable = RoutesProvider.unavailable(cause, [
-                    'NO_QUOTES',
-                    'NO_ROUTE',
-                    'UNSUPPORTED_ROUTE',
-                ]);
+                await blockQuoteOnRateLimit(cause);
+                const unavailable = RoutesProvider.unavailable(cause, quoteUnavailableCodes);
                 if (!unavailable)
                     throw cause;
                 return RoutesProvider.unavailableResult({
@@ -502,12 +683,13 @@ export function relay(options = {}) {
                 throw new RoutesProvider.ProviderConfigurationError();
             const quote = await (async () => {
                 try {
+                    await consumeQuoteQuota(quoteRateLimit);
                     return await RoutesProvider.requestJson(endpoint, {
                         body: {
                             amount: candidate.sourceAmount.amount,
-                            destinationChainId: Number(RoutesChain.eip155Id(candidate.route.destination.chain)),
+                            destinationChainId: relayChainId(candidate.route.destination.chain),
                             destinationCurrency: candidate.destinationToken.address,
-                            originChainId: Number(RoutesChain.eip155Id(candidate.route.source.chain)),
+                            originChainId: relayChainId(candidate.route.source.chain),
                             originCurrency: candidate.sourceToken.address,
                             recipient,
                             ...(slippageBps !== undefined ? { slippageTolerance: String(slippageBps) } : {}),
@@ -521,8 +703,10 @@ export function relay(options = {}) {
                     });
                 }
                 catch (cause) {
-                    if (RoutesProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
-                        throw new RoutesProvider.ProviderUnavailableError();
+                    await blockQuoteOnRateLimit(cause);
+                    const unavailable = RoutesProvider.unavailable(cause, quoteUnavailableCodes);
+                    if (unavailable)
+                        throw new RoutesProvider.ProviderUnavailableError(unavailable, { cause });
                     throw cause;
                 }
             })();
@@ -540,7 +724,7 @@ export function relay(options = {}) {
             const requestId = steps.find((step) => step.requestId)?.requestId;
             if (items.length === 0 || !requestId)
                 throw new RoutesProvider.ProviderPayloadError();
-            const sourceChainId = Number(RoutesChain.eip155Id(candidate.route.source.chain));
+            const sourceChainId = relayChainId(candidate.route.source.chain);
             for (const item of items)
                 if (item.data.chainId !== sourceChainId ||
                     item.data.from.toLowerCase() !== sender.toLowerCase())
@@ -571,6 +755,118 @@ export function relay(options = {}) {
                 sampledAt: now().toISOString(),
             };
         },
+        ...(verifyTransfers && options.apiKey
+            ? {
+                async verifySourceTransaction({ destinationChain, providerState, sourceChain, transactionHash, transfer }, signal) {
+                    const correlation = schema.TransferCorrelation.safeParse(providerState);
+                    if (!correlation.success ||
+                        sourceChain.kind !== 'evm' ||
+                        (destinationChain.kind !== 'evm' && destinationChain.kind !== 'solana') ||
+                        !transfer.sender ||
+                        transfer.method !== 'transaction' ||
+                        transfer.mode !== 'exactSource')
+                        return { type: 'invalid' };
+                    const request = await getTransferRequest(correlation.data.requestId, signal);
+                    if (!request)
+                        return { type: 'pending' };
+                    if (!transferRequestMatches(request, { destinationChain, sourceChain, transfer }))
+                        return { type: 'invalid' };
+                    const source = request.data?.inTxs?.find((entry) => entry.chainId === relayChainId(sourceChain) &&
+                        entry.txHash?.toLowerCase() === transactionHash.toLowerCase());
+                    if (!source)
+                        return { type: 'pending' };
+                    if (source.status === 'failure' ||
+                        source.status === 'failed' ||
+                        source.status === 'cancelled' ||
+                        source.status === 'canceled')
+                        return { type: 'invalid' };
+                    if (source.status !== 'success')
+                        return { type: 'pending' };
+                    const chains = await getTransferChains(signal);
+                    const depository = relayEvmChain(chains, sourceChain)?.protocol?.v2?.depository;
+                    if (!depository || !Address.validate(depository, { strict: false }))
+                        throw new RoutesProvider.ProviderConfigurationError();
+                    const reportedDepository = request.protocol?.deposit?.origin?.depository;
+                    if (reportedDepository &&
+                        (!Address.validate(reportedDepository, { strict: false }) ||
+                            !Address.isEqual(reportedDepository, depository)))
+                        return { type: 'invalid' };
+                    const evidence = await verifyTransfers({
+                        chain: sourceChain,
+                        recipient: depository,
+                        token: transfer.sourceToken,
+                        transactionHash,
+                    });
+                    const amount = evidence
+                        .filter((entry) => entry.sender?.toLowerCase() === transfer.sender.toLowerCase())
+                        .reduce((total, entry) => total + BigInt(entry.amount), 0n);
+                    if (amount === 0n)
+                        return { type: 'pending' };
+                    if (amount !== BigInt(transfer.sourceAmount.baseUnits))
+                        return { type: 'invalid' };
+                    return { type: 'verified' };
+                },
+                async verifyDestinationDelivery({ destinationChain, providerState, sourceChain, transfer }, signal) {
+                    const correlation = schema.TransferCorrelation.safeParse(providerState);
+                    if (!correlation.success ||
+                        sourceChain.kind !== 'evm' ||
+                        (destinationChain.kind !== 'evm' && destinationChain.kind !== 'solana'))
+                        return { type: 'invalid' };
+                    const request = await getTransferRequest(correlation.data.requestId, signal);
+                    if (!request)
+                        return { type: 'pending' };
+                    if (!transferRequestMatches(request, { destinationChain, sourceChain, transfer }))
+                        return { type: 'invalid' };
+                    if (request.status === 'failure' ||
+                        request.status === 'fallback' ||
+                        request.status === 'refund' ||
+                        request.status === 'refunded')
+                        return {
+                            statusReason: {
+                                code: 'manual_recovery_required',
+                                message: 'Relay could not complete the destination transfer.',
+                            },
+                            type: 'action-required',
+                        };
+                    if (request.status !== 'success')
+                        return { type: 'pending' };
+                    const destination = request.data?.route?.actual?.destination?.outputCurrency;
+                    const outputs = request.data?.outTxs?.filter((entry) => entry.chainId === relayChainId(destinationChain));
+                    if (!destination ||
+                        !outputs ||
+                        outputs.length !== 1 ||
+                        outputs[0]?.status !== 'success' ||
+                        !outputs[0].txHash)
+                        return { type: 'pending' };
+                    const transactionHash = outputs[0].txHash;
+                    const evidence = await verifyTransfers({
+                        chain: destinationChain,
+                        recipient: transfer.recipient,
+                        token: transfer.destinationToken,
+                        transactionHash,
+                    });
+                    const amount = evidence.reduce((total, entry) => total + BigInt(entry.amount), 0n);
+                    if (amount === 0n)
+                        return { type: 'pending' };
+                    if (amount !== BigInt(destination.amount))
+                        return { type: 'invalid' };
+                    if (transfer.destinationAmountMin &&
+                        amount < BigInt(transfer.destinationAmountMin.baseUnits))
+                        return {
+                            statusReason: {
+                                code: 'manual_recovery_required',
+                                message: 'Relay delivered less than the quoted minimum destination amount.',
+                            },
+                            type: 'action-required',
+                        };
+                    return {
+                        destinationAmount: amount.toString(),
+                        transactionHash,
+                        type: 'verified',
+                    };
+                },
+            }
+            : {}),
     });
 }
 function parseUserAddresses(value) {
@@ -804,11 +1100,8 @@ function createDepositAddressObserver(options) {
         });
         const solverAddresses = (correlation?.solver ? [correlation.solver] : solvers).map((address) => address);
         const correlatedTransactionHashes = [];
-        const uncorrelatedTransactionHashes = [];
         for (const log of destinationLogs) {
-            if (!log.transactionHash ||
-                correlatedTransactionHashes.includes(log.transactionHash) ||
-                uncorrelatedTransactionHashes.includes(log.transactionHash))
+            if (!log.transactionHash || correlatedTransactionHashes.includes(log.transactionHash))
                 continue;
             const event = decodeEvent(transferEvent, log);
             if (!event ||
@@ -825,23 +1118,12 @@ function createDepositAddressObserver(options) {
                 !Address.isEqual(transaction.to, parameters.destinationToken.address) ||
                 !Address.isEqual(call.recipient, event.to) ||
                 call.amount !== event.value ||
-                (call.orderId && !Hex.isEqual(call.orderId, sourceObservation.orderId)))
+                !call.orderId ||
+                !Hex.isEqual(call.orderId, sourceObservation.orderId))
                 continue;
-            if (call.orderId)
-                correlatedTransactionHashes.push(log.transactionHash);
-            else
-                uncorrelatedTransactionHashes.push(log.transactionHash);
+            correlatedTransactionHashes.push(log.transactionHash);
         }
-        const destinationTransactionHashes = (() => {
-            if (correlatedTransactionHashes.length > 0)
-                return correlatedTransactionHashes;
-            // Provider-independent completion requires the Relay order id to bind both chain legs.
-            if (!parameters.request)
-                return [];
-            if (uncorrelatedTransactionHashes.length === 1)
-                return uncorrelatedTransactionHashes;
-            return [];
-        })();
+        const destinationTransactionHashes = correlatedTransactionHashes;
         const providerState = { relay: sourceObservation };
         if (destinationTransactionHashes.length === 0)
             return {
@@ -1001,6 +1283,35 @@ function relayChainId(chain) {
         return Number(chain.id.slice('tron:'.length));
     throw new RoutesProvider.ProviderConfigurationError();
 }
+function transferRequestMatches(request, options) {
+    const { destinationChain, sourceChain, transfer } = options;
+    const actual = request.data?.route?.actual;
+    if (!transfer.sender ||
+        !request.sender ||
+        !request.recipient ||
+        !Address.validate(request.sender, { strict: false }) ||
+        !Address.isEqual(request.sender, transfer.sender) ||
+        (destinationChain.kind === 'evm'
+            ? !Address.validate(request.recipient, { strict: false }) ||
+                !Address.isEqual(request.recipient, transfer.recipient)
+            : request.recipient !== transfer.recipient))
+        return false;
+    if (!actual)
+        return true;
+    const source = actual.origin?.inputCurrency;
+    const destination = actual.destination?.outputCurrency;
+    return ((!source ||
+        (source.currency.chainId === relayChainId(sourceChain) &&
+            Address.validate(source.currency.address, { strict: false }) &&
+            Address.isEqual(source.currency.address, transfer.sourceToken.address) &&
+            source.amount === transfer.sourceAmount.baseUnits)) &&
+        (!destination ||
+            (destination.currency.chainId === relayChainId(destinationChain) &&
+                (destinationChain.kind === 'evm'
+                    ? Address.validate(destination.currency.address, { strict: false }) &&
+                        Address.isEqual(destination.currency.address, transfer.destinationToken.address)
+                    : destination.currency.address === transfer.destinationToken.address))));
+}
 /** Relay webhook signature is missing, stale, or invalid. */
 export class WebhookSignatureError extends RoutesProvider.WebhookAuthenticationError {
     name = 'Routes.Provider.Relay.WebhookSignatureError';