tapimo 0.7.2 → 0.8.0

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

@@ -1,13 +1,45 @@
-import { Address, Hash, Hex } from 'ox';
+import { AbiEvent, AbiFunction, Address, Hash, Hex, RpcTransport } from 'ox';
+import { createClient, custom, fallback } from 'viem';
+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 Viem from '../../Viem.js';
+import * as FundingCatalog from '../Catalog.js';
 import * as FundingChain from '../Chain.js';
+import * as Evidence from '../Evidence.js';
 import * as FundingProvider from '../Provider.js';
 import * as Subsidy from '../Subsidy.js';
 const defaultBaseUrl = 'https://api.relay.link';
 const defaultFetch = (input, init) => globalThis.fetch(input, init);
-const webhookSignatureToleranceSeconds = 300;
+const deliveryBackfillBlocks = 256n;
+const relayChainsCacheTtlMs = 60_000;
+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)');
+const relayErc20DepositEvent = AbiEvent.from('event RelayErc20Deposit(address from, address token, uint256 amount, bytes32 id)');
+const relayTransfer = AbiFunction.from('function transfer(address recipient,uint256 amount)');
+const transferEvent = AbiEvent.from('event Transfer(address indexed from, address indexed to, uint256 value)');
+const webhookSignatureToleranceMs = 300_000;
+const deliveryObservationStatuses = [
+    'depositing',
+    'pending',
+    'submitted',
+    'success',
+    'waiting',
+];
+// Bound provider statuses before using them as metric tags.
+const webhookStatuses = [
+    'depositing',
+    'failure',
+    'fallback',
+    'pending',
+    'refund',
+    'submitted',
+    'success',
+    'waiting',
+];
 var schema;
 (function (schema) {
     const Decimal = z.union([
@@ -67,8 +99,35 @@ var schema;
             requestId: z.optional(z.string()),
         })),
     });
+    schema.Chains = z.object({
+        chains: z.array(z.object({
+            id: Integer,
+            protocol: z.optional(z.object({
+                v2: z.optional(z.object({
+                    depository: z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/)),
+                })),
+            })),
+            solverAddresses: z.optional(z.array(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/)))),
+        })),
+    });
+    schema.DeliveryObservation = z.object({
+        relay: z.object({
+            orderId: z.string().check(z.regex(/^0x[0-9a-fA-F]{64}$/)),
+            sourceDepository: z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/)),
+            sourceObservedAt: z.iso.datetime(),
+            sourceSweepTransactionHash: z.string().check(z.regex(/^0x[0-9a-fA-F]{64}$/)),
+        }),
+    });
+    schema.RequestCorrelation = z.object({
+        relay: z.object({
+            depositor: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
+            depository: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
+            orderId: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{64}$/))),
+            solver: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
+        }),
+    });
     const RequestTransaction = z.object({
-        hash: z.string().check(z.minLength(1)),
+        txHash: z.string().check(z.minLength(1)),
     });
     schema.Requests = z.object({
         continuation: z.optional(z.string().check(z.minLength(1))),
@@ -77,10 +136,22 @@ var schema;
             data: z.optional(z.object({
                 outTxs: z.optional(z.array(RequestTransaction)),
             })),
-            depositAddress: z.optional(z.object({
-                depositTxHash: z.optional(z.string().check(z.minLength(1))),
-            })),
+            depositAddress: z.optional(z.nullable(z.object({
+                depositTxHash: z.optional(z.nullable(z.string().check(z.minLength(1)))),
+            }))),
             id: z.string().check(z.minLength(1)),
+            protocol: z.optional(z.nullable(z.object({
+                deposit: z.optional(z.object({
+                    origin: z.optional(z.object({
+                        depositor: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
+                        depository: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
+                    })),
+                })),
+                orderId: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{64}$/))),
+                solver: z.optional(z.object({
+                    address: z.optional(z.string().check(z.regex(/^0x[0-9a-fA-F]{40}$/))),
+                })),
+            }))),
             status: z.string().check(z.minLength(1)),
             updatedAt: z.iso.datetime(),
         })),
@@ -89,10 +160,19 @@ var schema;
         data: z.object({
             depositAddress: z.nullable(z.object({ address: z.string().check(z.minLength(1)) })),
             requestId: z.optional(z.string().check(z.minLength(1))),
+            status: z.string().check(z.minLength(1)),
+            updatedAt: z.number().check(z.int(), z.nonnegative()),
         }),
         event: z.literal('request.status.updated'),
     });
 })(schema || (schema = {}));
+/** Validates a Relay request-list response and reports payload drift with field-level details. */
+export function parseDepositAddressRequests(value) {
+    const parsed = schema.Requests.safeParse(value);
+    if (!parsed.success)
+        throw new FundingProvider.ProviderPayloadError(z.prettifyError(parsed.error));
+    return parsed.data;
+}
 /** Creates a Relay funding provider backed by `/quote/v2`. */
 export function relay(options = {}) {
     if ((options.userAddress !== undefined &&
@@ -103,6 +183,15 @@ export function relay(options = {}) {
     const endpoint = quoteEndpoint(options);
     const fetch = options.fetch ?? defaultFetch;
     const now = options.now ?? (() => new Date());
+    const observeDepositAddressRequest = options.observation
+        ? createDepositAddressObserver({
+            ...options.observation,
+            ...(options.apiKey ? { apiKey: options.apiKey } : {}),
+            ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
+            fetch,
+            now,
+        })
+        : undefined;
     const webhook = (() => {
         if (!options.apiKey || !options.webhook)
             return undefined;
@@ -110,6 +199,7 @@ export function relay(options = {}) {
         const verify = (input) => verifyWebhook(webhookOptions(input, apiKey));
         return {
             async receive(input) {
+                const receivedAt = now().toISOString();
                 const hint = (() => {
                     try {
                         return verify(input);
@@ -125,7 +215,8 @@ export function relay(options = {}) {
                     webhook.onResult?.('ignored');
                     return { type: 'ignored' };
                 }
-                const address = await FundingDepositAddresses.getByProviderAddress(Db.get(webhook.db), {
+                const database = Db.get(webhook.db);
+                const address = await FundingDepositAddresses.getByProviderAddress(database, {
                     address: hint.address,
                     providerId: 'relay',
                 });
@@ -133,11 +224,33 @@ export function relay(options = {}) {
                     webhook.onResult?.('unknown_address');
                     return { type: 'unknown_address' };
                 }
+                if (hint.requestId)
+                    await FundingDepositRequestObservations.observeWebhook(database, {
+                        depositAddressId: address.id,
+                        providerRequestId: hint.requestId,
+                        receivedAt,
+                    }).catch((cause) => {
+                        webhook.onResult?.('observation_failed');
+                        throw cause;
+                    });
                 try {
+                    const webhookTiming = (() => {
+                        if (!hint.providerStatus || !hint.providerUpdatedAt || !hint.requestId || !hint.sentAt)
+                            return undefined;
+                        return {
+                            enqueuedAt: now().toISOString(),
+                            providerStatus: hint.providerStatus,
+                            providerUpdatedAt: hint.providerUpdatedAt,
+                            receivedAt,
+                            sentAt: hint.sentAt,
+                        };
+                    })();
                     await webhook.dispatch({
                         addressId: address.id,
                         ...(hint.requestId ? { requestId: hint.requestId } : {}),
+                        trigger: 'webhook',
                         type: 'funding:deposit-address:reconcile',
+                        ...(webhookTiming ? { webhookTiming } : {}),
                     });
                 }
                 catch (cause) {
@@ -280,10 +393,9 @@ export function relay(options = {}) {
             const requestUrl = requestsEndpoint(options);
             if (requestId)
                 requestUrl.searchParams.set('id', requestId);
-            else {
+            else
                 requestUrl.searchParams.set('depositAddress', address);
-                requestUrl.searchParams.set('includeChildRequests', 'true');
-            }
+            requestUrl.searchParams.set('includeChildRequests', 'true');
             requestUrl.searchParams.set('limit', '50');
             requestUrl.searchParams.set('sortBy', 'updatedAt');
             requestUrl.searchParams.set('sortDirection', 'desc');
@@ -295,23 +407,43 @@ export function relay(options = {}) {
                 method: 'GET',
                 signal,
             });
-            const parsed = schema.Requests.safeParse(response);
-            if (!parsed.success)
-                throw new FundingProvider.ProviderPayloadError();
+            const parsed = parseDepositAddressRequests(response);
             return {
-                ...(parsed.data.continuation ? { continuation: parsed.data.continuation } : {}),
-                requests: parsed.data.requests.map((request) => ({
-                    createdAt: new Date(request.createdAt).toISOString(),
-                    destinationTransactionHashes: request.data?.outTxs?.map((tx) => tx.hash) ?? [],
-                    id: request.id,
-                    sourceTransactionHashes: request.depositAddress?.depositTxHash
-                        ? [request.depositAddress.depositTxHash]
-                        : [],
-                    status: request.status,
-                    updatedAt: new Date(request.updatedAt).toISOString(),
-                })),
+                ...(parsed.continuation ? { continuation: parsed.continuation } : {}),
+                requests: parsed.requests.map((request) => {
+                    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: request.data?.outTxs?.map((tx) => tx.txHash) ?? [],
+                        id: request.id,
+                        ...(correlation ? { providerState: correlation } : {}),
+                        sourceTransactionHashes: request.depositAddress?.depositTxHash
+                            ? [request.depositAddress.depositTxHash]
+                            : [],
+                        status: request.status,
+                        updatedAt: new Date(request.updatedAt).toISOString(),
+                    };
+                }),
             };
         },
+        ...(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.
@@ -390,12 +522,273 @@ export function relay(options = {}) {
         },
     });
 }
+function createDepositAddressObserver(options) {
+    let chainsExpiresAt = 0;
+    let chainsPromise;
+    let urlsExpiresAt = 0;
+    let urlsPromise;
+    const getChains = (signal) => {
+        if (chainsPromise && options.now().getTime() < chainsExpiresAt)
+            return chainsPromise;
+        chainsExpiresAt = options.now().getTime() + relayChainsCacheTtlMs;
+        chainsPromise = FundingProvider.requestJson(chainsEndpoint(options), {
+            fetch: options.fetch,
+            headers: options.apiKey ? { 'x-api-key': options.apiKey } : undefined,
+            signal,
+        })
+            .then((value) => schema.Chains.parse(value).chains)
+            .catch((cause) => {
+            chainsExpiresAt = 0;
+            chainsPromise = undefined;
+            throw cause;
+        });
+        return chainsPromise;
+    };
+    const getUrls = () => {
+        if (urlsPromise && options.now().getTime() < urlsExpiresAt)
+            return urlsPromise;
+        urlsExpiresAt = options.now().getTime() + relayChainsCacheTtlMs;
+        urlsPromise = FundingCatalog.read(Db.get(options.db))
+            .then((catalog) => new Map([...catalog.chainsByKey.values()].map((chain) => [
+            chain.id,
+            Evidence.resolveRpcUrls({
+                chain,
+                defaultChainId: options.defaultChainId ?? Viem.defaultChainId,
+                rpcUrlEnv: options.rpcUrlEnv,
+            }),
+        ])))
+            .catch((cause) => {
+            urlsExpiresAt = 0;
+            urlsPromise = undefined;
+            throw cause;
+        });
+        return urlsPromise;
+    };
+    return async (parameters, signal) => {
+        if (!deliveryObservationStatuses.includes(parameters.request.status))
+            return { type: 'unsupported' };
+        if (parameters.sourceChain.kind !== 'evm' || parameters.destinationChain.kind !== 'evm')
+            return { type: 'unsupported' };
+        if (!Address.validate(parameters.address, { strict: false }) ||
+            !Address.validate(parameters.destinationToken.address, { strict: false }) ||
+            !Address.validate(parameters.recipient, { strict: false }) ||
+            !Address.validate(parameters.refundAddress, { strict: false }) ||
+            !Address.validate(parameters.sourceToken.address, { strict: false }) ||
+            !Hash.validate(parameters.source.transactionHash))
+            return { type: 'unsupported' };
+        const [chains, urls] = await Promise.all([getChains(signal), getUrls()]);
+        const sourceChain = relayEvmChain(chains, parameters.sourceChain);
+        const destinationChain = relayEvmChain(chains, parameters.destinationChain);
+        const sourceUrls = urls.get(parameters.sourceChain.id);
+        const destinationUrls = urls.get(parameters.destinationChain.id);
+        const depository = sourceChain?.protocol?.v2?.depository;
+        const solvers = destinationChain?.solverAddresses;
+        if (!depository ||
+            !solvers ||
+            solvers.length === 0 ||
+            !sourceUrls?.length ||
+            !destinationUrls?.length)
+            return { type: 'unsupported' };
+        const parsedCorrelation = schema.RequestCorrelation.safeParse(parameters.request.providerState);
+        const correlation = parsedCorrelation.success ? parsedCorrelation.data.relay : undefined;
+        if ((correlation?.depository &&
+            !Address.isEqual(correlation.depository, depository)) ||
+            (correlation?.solver &&
+                !solvers.some((solver) => Address.isEqual(solver, correlation.solver))))
+            return { type: 'unsupported' };
+        const depositor = (correlation?.depositor ?? parameters.refundAddress);
+        const stored = schema.DeliveryObservation.safeParse(parameters.providerState);
+        const sourceObservation = await (async () => {
+            if (stored.success)
+                return stored.data.relay;
+            const sourceClient = jsonRpcClient({ fetch: options.fetch, urls: sourceUrls });
+            const sourceReceipt = await getTransactionReceipt(sourceClient, {
+                hash: parameters.source.transactionHash,
+            });
+            if (sourceReceipt.status !== 'success' || sourceReceipt.blockNumber === null)
+                return undefined;
+            const sourceHead = await getBlockNumber(sourceClient, { cacheTime: 0 });
+            const sweepLogs = await getLogs(sourceClient, {
+                address: depository,
+                event: relayErc20DepositEvent,
+                fromBlock: sourceReceipt.blockNumber,
+                toBlock: minimum(sourceHead, sourceReceipt.blockNumber + sourceSweepForwardBlocks),
+            });
+            const observations = [];
+            for (const log of sweepLogs) {
+                if (!log.transactionHash)
+                    continue;
+                const event = decodeEvent(relayErc20DepositEvent, log);
+                if (!event ||
+                    !Address.isEqual(event.from, depositor) ||
+                    !Address.isEqual(event.token, parameters.sourceToken.address) ||
+                    event.amount !== BigInt(parameters.source.amount) ||
+                    (correlation?.orderId && !Hex.isEqual(event.id, correlation.orderId)))
+                    continue;
+                const transaction = await getTransaction(sourceClient, { hash: log.transactionHash });
+                const call = decodeRelayErc20Deposit(transaction.input);
+                if (!call ||
+                    !Address.isEqual(transaction.from, parameters.address) ||
+                    !transaction.to ||
+                    !Address.isEqual(transaction.to, depository) ||
+                    !Address.isEqual(call.depositor, event.from) ||
+                    !Address.isEqual(call.token, event.token) ||
+                    (call.amount !== undefined && call.amount !== event.amount) ||
+                    !Hex.isEqual(call.id, event.id))
+                    continue;
+                observations.push({
+                    orderId: event.id,
+                    sourceDepository: depository,
+                    sourceObservedAt: options.now().toISOString(),
+                    sourceSweepTransactionHash: log.transactionHash,
+                });
+            }
+            return observations.length === 1 ? observations[0] : undefined;
+        })();
+        if (!sourceObservation)
+            return { type: 'pending' };
+        const destinationClient = jsonRpcClient({ fetch: options.fetch, urls: destinationUrls });
+        const destinationHead = await getBlockNumber(destinationClient, { cacheTime: 0 });
+        const destinationLogs = await getLogs(destinationClient, {
+            address: parameters.destinationToken.address,
+            args: { to: parameters.recipient },
+            event: transferEvent,
+            fromBlock: destinationHead > deliveryBackfillBlocks ? destinationHead - deliveryBackfillBlocks : 0n,
+            toBlock: destinationHead,
+        });
+        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))
+                continue;
+            const event = decodeEvent(transferEvent, log);
+            if (!event ||
+                event.value === 0n ||
+                !Address.isEqual(event.to, parameters.recipient) ||
+                !solverAddresses.some((address) => Address.isEqual(address, event.from)))
+                continue;
+            const transaction = await getTransaction(destinationClient, { hash: log.transactionHash });
+            const call = decodeRelayTransfer(transaction.input);
+            if (!call ||
+                !solverAddresses.some((address) => Address.isEqual(address, transaction.from)) ||
+                !Address.isEqual(event.from, transaction.from) ||
+                !transaction.to ||
+                !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)))
+                continue;
+            if (call.orderId)
+                correlatedTransactionHashes.push(log.transactionHash);
+            else
+                uncorrelatedTransactionHashes.push(log.transactionHash);
+        }
+        const destinationTransactionHashes = (() => {
+            if (correlatedTransactionHashes.length > 0)
+                return correlatedTransactionHashes;
+            if (uncorrelatedTransactionHashes.length === 1)
+                return uncorrelatedTransactionHashes;
+            return [];
+        })();
+        const providerState = { relay: sourceObservation };
+        if (destinationTransactionHashes.length === 0)
+            return {
+                providerState,
+                providerTransactionHashes: [sourceObservation.sourceSweepTransactionHash],
+                type: 'pending',
+            };
+        return {
+            destinationTransactionHashes,
+            providerState: {
+                relay: {
+                    ...sourceObservation,
+                    destinationObservedAt: options.now().toISOString(),
+                },
+            },
+            providerTransactionHashes: [
+                sourceObservation.sourceSweepTransactionHash,
+                ...destinationTransactionHashes,
+            ],
+            type: 'verified',
+        };
+    };
+}
+function chainsEndpoint(options) {
+    const endpoint = new URL(options.baseUrl ?? defaultBaseUrl);
+    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/chains`;
+    return endpoint;
+}
+function decodeRelayErc20Deposit(data) {
+    const fullAllowanceLength = 2 + 2 * (4 + 32 * 3);
+    const withAmountLength = 2 + 2 * (4 + 32 * 4);
+    try {
+        if (data.length === withAmountLength) {
+            const [depositor, token, amount, id] = AbiFunction.decodeData(depositErc20WithAmount, data);
+            return { amount, depositor, id, token };
+        }
+        if (data.length === fullAllowanceLength) {
+            const [depositor, token, id] = AbiFunction.decodeData(depositErc20FullAllowance, data);
+            return { depositor, id, token };
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function decodeRelayTransfer(data) {
+    const encodedLength = 2 + 2 * (4 + 32 * 2);
+    if (data.length !== encodedLength && data.length !== encodedLength + 64)
+        return undefined;
+    try {
+        const [recipient, amount] = AbiFunction.decodeData(relayTransfer, data.slice(0, encodedLength));
+        return {
+            amount,
+            ...(data.length > encodedLength
+                ? { orderId: `0x${data.slice(encodedLength)}` }
+                : {}),
+            recipient,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function decodeEvent(abiEvent, log) {
+    try {
+        return AbiEvent.decode(abiEvent, log);
+    }
+    catch {
+        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;
+}
+function relayEvmChain(chains, chain) {
+    if (chain.kind !== 'evm')
+        return undefined;
+    const match = /^eip155:(\d+)$/.exec(chain.id);
+    if (!match?.[1])
+        return undefined;
+    return chains.find((candidate) => candidate.id === Number(match[1]));
+}
 function verifyWebhook(options) {
     const timestamp = Number(options.timestamp);
     if (!Number.isSafeInteger(timestamp))
         throw new WebhookSignatureError();
-    const now = Math.floor(Date.now() / 1_000);
-    if (Math.abs(now - timestamp) > webhookSignatureToleranceSeconds)
+    if (Math.abs(Date.now() - timestamp) > webhookSignatureToleranceMs)
         throw new WebhookSignatureError();
     if (!/^[0-9a-fA-F]{64}$/.test(options.signature))
         throw new WebhookSignatureError();
@@ -415,7 +808,10 @@ function verifyWebhook(options) {
         throw new WebhookPayloadError();
     return {
         address: parsed.data.data.depositAddress?.address,
+        providerStatus: webhookStatus(parsed.data.data.status),
+        providerUpdatedAt: webhookTimestamp(parsed.data.data.updatedAt),
         requestId: parsed.data.data.requestId,
+        sentAt: webhookTimestamp(timestamp),
     };
 }
 function webhookOptions(input, secret) {
@@ -432,7 +828,7 @@ function quoteEndpoint(options) {
 }
 function requestsEndpoint(options) {
     const endpoint = new URL(options.baseUrl ?? defaultBaseUrl);
-    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/requests/v2`;
+    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, '')}/requests/v3`;
     return endpoint;
 }
 function timingSafeEqual(left, right) {
@@ -443,6 +839,17 @@ function timingSafeEqual(left, right) {
         mismatch |= left.charCodeAt(index) ^ right.charCodeAt(index);
     return mismatch === 0;
 }
+function webhookStatus(status) {
+    return webhookStatuses.includes(status) ? status : 'unknown';
+}
+function webhookTimestamp(value) {
+    try {
+        return new Date(value).toISOString();
+    }
+    catch {
+        throw new WebhookPayloadError();
+    }
+}
 function relayChainId(chain) {
     if (chain.id.startsWith('eip155:'))
         return Number(FundingChain.eip155Id(chain));