tapimo 0.13.0 → 0.15.0

package/dist/internal/{funding → routes}/providers/relay.js

@@ -1,21 +1,22 @@
-import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex, RpcTransport } from 'ox';
-import { createClient, custom, fallback } from 'viem';
+import { AbiEvent, AbiFunction, Address, Base58, Bytes, Hash, Hex } 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 FundingDepositAddresses from '../../../db/tables/fundingDepositAddresses.js';
-import * as FundingDepositRequestObservations from '../../../db/tables/fundingDepositRequestObservations.js';
+import * as RoutesDepositAddresses from '../../../db/tables/routesDepositAddresses.js';
+import * as RoutesDepositRequestObservations from '../../../db/tables/routesDepositRequestObservations.js';
+import * as Value from '../../Value.js';
 import * as Viem from '../../Viem.js';
-import * as FundingCatalog from '../Catalog.js';
-import * as FundingChain from '../Chain.js';
+import * as RoutesCatalog from '../Catalog.js';
+import * as RoutesChain from '../Chain.js';
 import * as Evidence from '../Evidence.js';
-import * as FundingProvider from '../Provider.js';
+import * as RoutesProvider from '../Provider.js';
 import * as Subsidy from '../Subsidy.js';
 const defaultBaseUrl = 'https://api.relay.link';
 const defaultFetch = (input, init) => globalThis.fetch(input, init);
 const deliveryBackfillBlocks = 256n;
 const relayChainsCacheTtlMs = 60_000;
 const relayRefundStatuses = ['refund', 'refunded'];
+const relayRequestPageLimit = 100;
 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)');
@@ -106,10 +107,10 @@ var schema;
             id: Integer,
             protocol: z.optional(z.object({
                 v2: z.optional(z.object({
-                    depository: z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/)),
+                    depository: z.string().check(z.minLength(1)),
                 })),
             })),
-            solverAddresses: z.optional(z.array(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/)))),
+            solverAddresses: z.optional(z.array(z.string().check(z.minLength(1)))),
         })),
     });
     schema.DeliveryObservation = z.object({
@@ -128,14 +129,24 @@ var schema;
             solver: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
         }),
     });
+    // Relay can publish output entries before assigning their transaction hashes.
     const RequestTransaction = z.object({
-        txHash: z.string().check(z.minLength(1)),
+        txHash: z.optional(z.nullable(z.string())),
     });
     schema.Requests = z.object({
         continuation: z.optional(z.string().check(z.minLength(1))),
         requests: z.array(z.object({
             createdAt: z.iso.datetime(),
             data: z.optional(z.object({
+                feeSponsorship: z.optional(z.object({
+                    actual: z.optional(z.object({
+                        sponsorPayment: z.optional(z.object({
+                            address: z.string().check(z.minLength(1)),
+                            amount: z.string().check(z.regex(/^\d+$/)),
+                            chainId: Integer,
+                        })),
+                    })),
+                })),
                 outTxs: z.optional(z.array(RequestTransaction)),
             })),
             depositAddress: z.optional(z.nullable(z.object({
@@ -175,23 +186,104 @@ var schema;
 export function parseDepositAddressRequests(value) {
     const parsed = schema.Requests.safeParse(value);
     if (!parsed.success)
-        throw new FundingProvider.ProviderPayloadError(z.prettifyError(parsed.error));
+        throw new RoutesProvider.ProviderPayloadError(z.prettifyError(parsed.error));
     return parsed.data;
 }
-/** Creates a Relay funding provider backed by `/quote/v2`. */
+/** Creates a Relay route provider backed by `/quote/v2`. */
 export function relay(options = {}) {
     const userAddresses = parseUserAddresses(options.userAddresses);
     if (Object.entries(userAddresses).some(([chainId, address]) => invalidUserAddress(chainId, address)))
-        throw new FundingProvider.ProviderConfigurationError();
+        throw new RoutesProvider.ProviderConfigurationError();
     const endpoint = quoteEndpoint(options);
     const fetch = options.fetch ?? defaultFetch;
     const now = options.now ?? (() => new Date());
+    async function listDepositAddressRequests(parameters, signal) {
+        const requestUrl = requestsEndpoint(options);
+        if (parameters.requestId)
+            requestUrl.searchParams.set('id', parameters.requestId);
+        else
+            requestUrl.searchParams.set('depositAddress', parameters.address);
+        requestUrl.searchParams.set('includeChildRequests', 'true');
+        requestUrl.searchParams.set('limit', '50');
+        requestUrl.searchParams.set('sortBy', 'updatedAt');
+        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,
+        });
+        const parsed = parseDepositAddressRequests(response);
+        return {
+            ...(parsed.continuation ? { continuation: parsed.continuation } : {}),
+            requests: parsed.requests.map((request) => {
+                const outputTransactionHashes = request.data?.outTxs?.flatMap((transaction) => transaction.txHash ? [transaction.txHash] : []) ?? [];
+                const subsidy = (() => {
+                    const payment = request.data?.feeSponsorship?.actual?.sponsorPayment;
+                    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) &&
+                        token.address.toLowerCase() === payment.address.toLowerCase());
+                    if (!token)
+                        throw new RoutesProvider.ProviderPayloadError();
+                    return {
+                        amount: Value.tokenAmount({
+                            baseUnits: payment.amount,
+                            currency: token.currency,
+                            decimals: token.decimals,
+                        }),
+                        provider: 'relay',
+                        token,
+                    };
+                })();
+                const refunded = relayRefundStatuses.includes(request.status);
+                const correlation = (() => {
+                    const { protocol } = request;
+                    if (!protocol)
+                        return undefined;
+                    const relay = {
+                        ...(protocol.deposit?.origin?.depositor
+                            ? { depositor: protocol.deposit.origin.depositor }
+                            : {}),
+                        ...(protocol.deposit?.origin?.depository
+                            ? { depository: protocol.deposit.origin.depository }
+                            : {}),
+                        ...(protocol.orderId ? { orderId: protocol.orderId } : {}),
+                        ...(protocol.solver?.address ? { solver: protocol.solver.address } : {}),
+                    };
+                    if (Object.keys(relay).length === 0)
+                        return undefined;
+                    return schema.RequestCorrelation.parse({ relay });
+                })();
+                return {
+                    createdAt: new Date(request.createdAt).toISOString(),
+                    destinationTransactionHashes: refunded ? [] : outputTransactionHashes,
+                    id: request.id,
+                    ...(correlation ? { providerState: correlation } : {}),
+                    ...(refunded && request.refundCurrencyData
+                        ? { refundAmountExpected: request.refundCurrencyData.amount }
+                        : {}),
+                    refundTransactionHashes: refunded ? outputTransactionHashes : [],
+                    sourceTransactionHashes: request.depositAddress?.depositTxHash
+                        ? [request.depositAddress.depositTxHash]
+                        : [],
+                    ...(subsidy ? { subsidy } : {}),
+                    status: request.status,
+                    updatedAt: new Date(request.updatedAt).toISOString(),
+                };
+            }),
+        };
+    }
     const observeDepositAddressRequest = options.observation
         ? createDepositAddressObserver({
             ...options.observation,
             ...(options.apiKey ? { apiKey: options.apiKey } : {}),
             ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
             fetch,
+            listDepositAddressRequests,
             now,
         })
         : undefined;
@@ -208,7 +300,7 @@ export function relay(options = {}) {
                         return verify(input);
                     }
                     catch (cause) {
-                        webhook.onResult?.(cause instanceof FundingProvider.WebhookAuthenticationError
+                        webhook.onResult?.(cause instanceof RoutesProvider.WebhookAuthenticationError
                             ? 'authentication_failed'
                             : 'payload_invalid');
                         throw cause;
@@ -219,7 +311,7 @@ export function relay(options = {}) {
                     return { type: 'ignored' };
                 }
                 const database = Db.get(webhook.db);
-                const address = await FundingDepositAddresses.getByProviderAddress(database, {
+                const address = await RoutesDepositAddresses.getByProviderAddress(database, {
                     address: hint.address,
                     providerId: 'relay',
                 });
@@ -228,7 +320,7 @@ export function relay(options = {}) {
                     return { type: 'unknown_address' };
                 }
                 if (hint.requestId)
-                    await FundingDepositRequestObservations.observeWebhook(database, {
+                    await RoutesDepositRequestObservations.observeWebhook(database, {
                         depositAddressId: address.id,
                         providerRequestId: hint.requestId,
                         receivedAt,
@@ -252,7 +344,7 @@ export function relay(options = {}) {
                         addressId: address.id,
                         ...(hint.requestId ? { requestId: hint.requestId } : {}),
                         trigger: 'webhook',
-                        type: 'funding:deposit-address:reconcile',
+                        type: 'routes:deposit-address:reconcile',
                         ...(webhookTiming ? { webhookTiming } : {}),
                     });
                 }
@@ -266,7 +358,7 @@ export function relay(options = {}) {
             verify,
         };
     })();
-    return FundingProvider.from({
+    return RoutesProvider.from({
         id: 'relay',
         name: 'Relay',
         ...(webhook ? { webhook } : {}),
@@ -278,10 +370,10 @@ export function relay(options = {}) {
                         destinationToken: candidate.destinationToken,
                         sourceToken: candidate.sourceToken,
                     })))
-                throw new FundingProvider.ProviderUnavailableError();
+                throw new RoutesProvider.ProviderUnavailableError();
             const quote = await (async () => {
                 try {
-                    return await FundingProvider.requestJson(endpoint, {
+                    return await RoutesProvider.requestJson(endpoint, {
                         body: {
                             amount,
                             destinationChainId: relayChainId(candidate.route.destination.chain),
@@ -302,19 +394,19 @@ export function relay(options = {}) {
                     });
                 }
                 catch (cause) {
-                    if (FundingProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
-                        throw new FundingProvider.ProviderUnavailableError();
+                    if (RoutesProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
+                        throw new RoutesProvider.ProviderUnavailableError();
                     throw cause;
                 }
             })();
             const parsed = schema.DepositAddress.safeParse(quote);
             if (!parsed.success)
-                throw new FundingProvider.ProviderPayloadError();
+                throw new RoutesProvider.ProviderPayloadError();
             if (parsed.data.details.currencyIn.amount !== amount)
-                throw new FundingProvider.ProviderPayloadError();
+                throw new RoutesProvider.ProviderPayloadError();
             const step = parsed.data.steps.find((candidate) => candidate.depositAddress && candidate.requestId);
             if (!step?.depositAddress || !step.requestId)
-                throw new FundingProvider.ProviderPayloadError();
+                throw new RoutesProvider.ProviderPayloadError();
             const checkEndpoint = step.items?.find((item) => item.check)?.check?.endpoint;
             const providerFee = parsed.data.fees?.relayer?.amount;
             return {
@@ -332,7 +424,7 @@ export function relay(options = {}) {
         async getQuote({ candidate, route }, signal) {
             const userAddress = userAddresses[route.source.chain.id];
             if (userAddress === undefined)
-                return FundingProvider.unavailableResult({
+                return RoutesProvider.unavailableResult({
                     detail: 'relay:quote-v2',
                     message: 'QUOTE_USER_NOT_CONFIGURED',
                     now: now(),
@@ -340,7 +432,7 @@ export function relay(options = {}) {
                 });
             const recipientAddress = userAddresses[route.destination.chain.id];
             if (recipientAddress === undefined)
-                return FundingProvider.unavailableResult({
+                return RoutesProvider.unavailableResult({
                     detail: 'relay:quote-v2',
                     message: 'QUOTE_RECIPIENT_NOT_CONFIGURED',
                     now: now(),
@@ -349,7 +441,7 @@ export function relay(options = {}) {
             const destinationChainId = relayChainId(route.destination.chain);
             const sourceChainId = relayChainId(route.source.chain);
             try {
-                const quote = await FundingProvider.requestJson(endpoint, {
+                const quote = await RoutesProvider.requestJson(endpoint, {
                     body: {
                         amount: candidate.sourceAmount.amount,
                         destinationChainId,
@@ -367,7 +459,7 @@ export function relay(options = {}) {
                 });
                 const parsed = schema.Quote.safeParse(quote);
                 if (!parsed.success)
-                    throw new FundingProvider.ProviderPayloadError();
+                    throw new RoutesProvider.ProviderPayloadError();
                 const destinationAmount = parsed.data.details?.currencyOut?.amount;
                 const status = destinationAmount
                     ? { status: 'available', tier: 'liquid' }
@@ -386,14 +478,14 @@ export function relay(options = {}) {
                 };
             }
             catch (cause) {
-                const unavailable = FundingProvider.unavailable(cause, [
+                const unavailable = RoutesProvider.unavailable(cause, [
                     'NO_QUOTES',
                     'NO_ROUTE',
                     'UNSUPPORTED_ROUTE',
                 ]);
                 if (!unavailable)
                     throw cause;
-                return FundingProvider.unavailableResult({
+                return RoutesProvider.unavailableResult({
                     detail: 'relay:quote-v2',
                     message: unavailable,
                     now: now(),
@@ -401,80 +493,21 @@ export function relay(options = {}) {
                 });
             }
         },
-        async listDepositAddressRequests({ address, continuation, requestId }, signal) {
-            const requestUrl = requestsEndpoint(options);
-            if (requestId)
-                requestUrl.searchParams.set('id', requestId);
-            else
-                requestUrl.searchParams.set('depositAddress', address);
-            requestUrl.searchParams.set('includeChildRequests', 'true');
-            requestUrl.searchParams.set('limit', '50');
-            requestUrl.searchParams.set('sortBy', 'updatedAt');
-            requestUrl.searchParams.set('sortDirection', 'desc');
-            if (continuation)
-                requestUrl.searchParams.set('continuation', continuation);
-            const response = await FundingProvider.requestJson(requestUrl, {
-                fetch,
-                headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
-                method: 'GET',
-                signal,
-            });
-            const parsed = parseDepositAddressRequests(response);
-            return {
-                ...(parsed.continuation ? { continuation: parsed.continuation } : {}),
-                requests: parsed.requests.map((request) => {
-                    const outputTransactionHashes = request.data?.outTxs?.map((tx) => tx.txHash) ?? [];
-                    const refunded = relayRefundStatuses.includes(request.status);
-                    const correlation = (() => {
-                        const { protocol } = request;
-                        if (!protocol)
-                            return undefined;
-                        const relay = {
-                            ...(protocol.deposit?.origin?.depositor
-                                ? { depositor: protocol.deposit.origin.depositor }
-                                : {}),
-                            ...(protocol.deposit?.origin?.depository
-                                ? { depository: protocol.deposit.origin.depository }
-                                : {}),
-                            ...(protocol.orderId ? { orderId: protocol.orderId } : {}),
-                            ...(protocol.solver?.address ? { solver: protocol.solver.address } : {}),
-                        };
-                        if (Object.keys(relay).length === 0)
-                            return undefined;
-                        return schema.RequestCorrelation.parse({ relay });
-                    })();
-                    return {
-                        createdAt: new Date(request.createdAt).toISOString(),
-                        destinationTransactionHashes: refunded ? [] : outputTransactionHashes,
-                        id: request.id,
-                        ...(correlation ? { providerState: correlation } : {}),
-                        ...(refunded && request.refundCurrencyData
-                            ? { refundAmountExpected: request.refundCurrencyData.amount }
-                            : {}),
-                        refundTransactionHashes: refunded ? outputTransactionHashes : [],
-                        sourceTransactionHashes: request.depositAddress?.depositTxHash
-                            ? [request.depositAddress.depositTxHash]
-                            : [],
-                        status: request.status,
-                        updatedAt: new Date(request.updatedAt).toISOString(),
-                    };
-                }),
-            };
-        },
+        listDepositAddressRequests,
         ...(observeDepositAddressRequest ? { observeDepositAddressRequest } : {}),
         async prepareTransfer({ candidate, method, mode, recipient, sender, slippageBps }, signal) {
             // Catalog capabilities gate deposit addresses and exact destination
             // off this adapter; refuse them defensively if one slips through.
             if (method !== 'transaction' || mode !== 'exactSource')
-                throw new FundingProvider.ProviderConfigurationError();
+                throw new RoutesProvider.ProviderConfigurationError();
             const quote = await (async () => {
                 try {
-                    return await FundingProvider.requestJson(endpoint, {
+                    return await RoutesProvider.requestJson(endpoint, {
                         body: {
                             amount: candidate.sourceAmount.amount,
-                            destinationChainId: Number(FundingChain.eip155Id(candidate.route.destination.chain)),
+                            destinationChainId: Number(RoutesChain.eip155Id(candidate.route.destination.chain)),
                             destinationCurrency: candidate.destinationToken.address,
-                            originChainId: Number(FundingChain.eip155Id(candidate.route.source.chain)),
+                            originChainId: Number(RoutesChain.eip155Id(candidate.route.source.chain)),
                             originCurrency: candidate.sourceToken.address,
                             recipient,
                             ...(slippageBps !== undefined ? { slippageTolerance: String(slippageBps) } : {}),
@@ -488,30 +521,30 @@ export function relay(options = {}) {
                     });
                 }
                 catch (cause) {
-                    if (FundingProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
-                        throw new FundingProvider.ProviderUnavailableError();
+                    if (RoutesProvider.unavailable(cause, ['NO_QUOTES', 'NO_ROUTE', 'UNSUPPORTED_ROUTE']))
+                        throw new RoutesProvider.ProviderUnavailableError();
                     throw cause;
                 }
             })();
             const parsed = schema.PreparedQuote.safeParse(quote);
             if (!parsed.success)
-                throw new FundingProvider.ProviderPayloadError();
+                throw new RoutesProvider.ProviderPayloadError();
             const { details, fees, steps } = parsed.data;
             // The quoted input must match the request exactly; a drifted amount
             // would desynchronize the stored terms from the prepared calls.
             if (details.currencyIn.amount !== candidate.sourceAmount.amount)
-                throw new FundingProvider.ProviderPayloadError();
+                throw new RoutesProvider.ProviderPayloadError();
             const items = steps
                 .filter((step) => step.kind === 'transaction')
                 .flatMap((step) => step.items ?? []);
             const requestId = steps.find((step) => step.requestId)?.requestId;
             if (items.length === 0 || !requestId)
-                throw new FundingProvider.ProviderPayloadError();
-            const sourceChainId = Number(FundingChain.eip155Id(candidate.route.source.chain));
+                throw new RoutesProvider.ProviderPayloadError();
+            const sourceChainId = Number(RoutesChain.eip155Id(candidate.route.source.chain));
             for (const item of items)
                 if (item.data.chainId !== sourceChainId ||
                     item.data.from.toLowerCase() !== sender.toLowerCase())
-                    throw new FundingProvider.ProviderPayloadError();
+                    throw new RoutesProvider.ProviderPayloadError();
             const checkEndpoint = items.find((item) => item.check)?.check?.endpoint;
             // Relay's `relayer` fee is the solver's total source-side charge (gas
             // plus service); it surfaces as the transfer's provider fee.
@@ -549,12 +582,12 @@ function parseUserAddresses(value) {
                 return JSON.parse(value);
             }
             catch {
-                throw new FundingProvider.ProviderConfigurationError();
+                throw new RoutesProvider.ProviderConfigurationError();
             }
         })()
         : value;
     if (!addresses || typeof addresses !== 'object' || Array.isArray(addresses))
-        throw new FundingProvider.ProviderConfigurationError();
+        throw new RoutesProvider.ProviderConfigurationError();
     return addresses;
 }
 function invalidUserAddress(chainId, address) {
@@ -593,7 +626,7 @@ function createDepositAddressObserver(options) {
         if (chainsPromise && options.now().getTime() < chainsExpiresAt)
             return chainsPromise;
         chainsExpiresAt = options.now().getTime() + relayChainsCacheTtlMs;
-        chainsPromise = FundingProvider.requestJson(chainsEndpoint(options), {
+        chainsPromise = RoutesProvider.requestJson(chainsEndpoint(options), {
             fetch: options.fetch,
             headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
             signal,
@@ -610,7 +643,7 @@ function createDepositAddressObserver(options) {
         if (urlsPromise && options.now().getTime() < urlsExpiresAt)
             return urlsPromise;
         urlsExpiresAt = options.now().getTime() + relayChainsCacheTtlMs;
-        urlsPromise = FundingCatalog.read(Db.get(options.db))
+        urlsPromise = RoutesCatalog.read(Db.get(options.db))
             .then((catalog) => new Map([...catalog.chainsByKey.values()].map((chain) => [
             chain.id,
             Evidence.resolveRpcUrls({
@@ -647,8 +680,10 @@ function createDepositAddressObserver(options) {
         const depository = sourceChain?.protocol?.v2?.depository;
         const solvers = destinationChain?.solverAddresses;
         if (!depository ||
+            !Address.validate(depository, { strict: false }) ||
             !solvers ||
             solvers.length === 0 ||
+            solvers.some((solver) => !Address.validate(solver, { strict: false })) ||
             !sourceUrls?.length ||
             !destinationUrls?.length)
             return { type: 'unsupported' };
@@ -664,7 +699,7 @@ function createDepositAddressObserver(options) {
         const sourceObservation = await (async () => {
             if (stored.success)
                 return stored.data.relay;
-            const sourceClient = jsonRpcClient({ fetch: options.fetch, urls: sourceUrls });
+            const sourceClient = Viem.createEvmClient({ fetch: options.fetch, urls: sourceUrls });
             const sourceReceipt = await getTransactionReceipt(sourceClient, {
                 hash: parameters.source.transactionHash,
             });
@@ -710,7 +745,55 @@ function createDepositAddressObserver(options) {
         })();
         if (!sourceObservation)
             return { type: 'pending' };
-        const destinationClient = jsonRpcClient({ fetch: options.fetch, urls: destinationUrls });
+        const indexedRequest = await (async () => {
+            let continuation;
+            try {
+                for (let page = 0; page < relayRequestPageLimit; page++) {
+                    const result = parameters.request
+                        ? { continuation: undefined, requests: [parameters.request] }
+                        : await options.listDepositAddressRequests({
+                            address: parameters.address,
+                            ...(continuation ? { continuation } : {}),
+                            destinationToken: parameters.destinationToken,
+                            sourceToken: parameters.sourceToken,
+                        }, signal);
+                    const request = result.requests.find((request) => {
+                        if (!deliveryObservationStatuses.includes(request.status))
+                            return false;
+                        const parsed = schema.RequestCorrelation.safeParse(request.providerState);
+                        return Boolean(parsed.success &&
+                            parsed.data.relay.orderId &&
+                            Hex.isEqual(parsed.data.relay.orderId, sourceObservation.orderId));
+                    });
+                    if (request || !result.continuation)
+                        return request;
+                    continuation = result.continuation;
+                }
+            }
+            catch (cause) {
+                if (signal.aborted)
+                    throw cause;
+                // Relay indexing is optional evidence, so preserve the onchain fallback when it is unavailable.
+            }
+            return undefined;
+        })();
+        if (indexedRequest && indexedRequest.destinationTransactionHashes.length > 0)
+            return {
+                destinationTransactionHashes: indexedRequest.destinationTransactionHashes,
+                providerState: {
+                    relay: {
+                        ...sourceObservation,
+                        destinationObservedAt: options.now().toISOString(),
+                    },
+                },
+                providerTransactionHashes: [
+                    sourceObservation.sourceSweepTransactionHash,
+                    ...indexedRequest.destinationTransactionHashes,
+                ],
+                ...(indexedRequest.subsidy ? { subsidy: indexedRequest.subsidy } : {}),
+                type: 'verified',
+            };
+        const destinationClient = Viem.createEvmClient({ fetch: options.fetch, urls: destinationUrls });
         const destinationHead = await getBlockNumber(destinationClient, { cacheTime: 0 });
         const destinationLogs = await getLogs(destinationClient, {
             address: parameters.destinationToken.address,
@@ -831,14 +914,6 @@ function decodeEvent(abiEvent, log) {
         return undefined;
     }
 }
-function jsonRpcClient(options) {
-    return createClient({
-        transport: fallback(options.urls.map((url) => {
-            const transport = RpcTransport.fromHttp(url, { fetchFn: options.fetch });
-            return custom(transport, { retryCount: 0 });
-        })),
-    });
-}
 function minimum(left, right) {
     return left < right ? left : right;
 }
@@ -918,20 +993,20 @@ function webhookTimestamp(value) {
 }
 function relayChainId(chain) {
     if (chain.id.startsWith('eip155:'))
-        return Number(FundingChain.eip155Id(chain));
+        return Number(RoutesChain.eip155Id(chain));
     // Relay uses a numeric chain ID for Solana instead of its CAIP-2 reference.
     if (chain.id === 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp')
         return 792_703_809;
     if (chain.id.startsWith('tron:'))
         return Number(chain.id.slice('tron:'.length));
-    throw new FundingProvider.ProviderConfigurationError();
+    throw new RoutesProvider.ProviderConfigurationError();
 }
 /** Relay webhook signature is missing, stale, or invalid. */
-export class WebhookSignatureError extends FundingProvider.WebhookAuthenticationError {
-    name = 'Funding.Provider.Relay.WebhookSignatureError';
+export class WebhookSignatureError extends RoutesProvider.WebhookAuthenticationError {
+    name = 'Routes.Provider.Relay.WebhookSignatureError';
 }
 /** Relay webhook body does not match the expected status event shape. */
-export class WebhookPayloadError extends FundingProvider.WebhookPayloadError {
-    name = 'Funding.Provider.Relay.WebhookPayloadError';
+export class WebhookPayloadError extends RoutesProvider.WebhookPayloadError {
+    name = 'Routes.Provider.Relay.WebhookPayloadError';
 }
 //# sourceMappingURL=relay.js.map