tapimo 0.8.0 → 0.9.0

package/src/internal/funding/Reconciliation.ts

@@ -13,6 +13,8 @@ import * as Subsidy from './Subsidy.js'
 const defaultBatchSize = 25
 const defaultLeaseMs = 2 * 60_000
 const defaultPollIntervalMs = 60_000
+const chainProviderFollowUpDelaySeconds = 1
+const chainProviderMaximumFollowUpAttempts = 30
 const followUpDelaySeconds = { delivery: 1, provider: 5, settlement: 2 } as const satisfies Record<
   Provider.Webhook.receive.FollowUp['kind'],
   number
@@ -141,6 +143,18 @@ export function createTracker(options: createTracker.Options): createTracker.Tra
             followUpKind = result.followUp ?? followUpKind ?? 'provider'
           }
         }
+        const unattributed = await reconcileUnattributed(database, {
+          address: claimed,
+          metrics: options.metrics,
+          provider,
+          signal: options.signal,
+          subsidies: options.subsidies,
+          verifyTransfers: options.verifyTransfers,
+        })
+        heartbeat.assert()
+        updated += unattributed.updatedIds.size
+        if (!unattributed.terminal)
+          followUpKind = unattributed.followUp ?? followUpKind ?? 'provider'
         const awaitsProvider = await FundingDeposits.hasUnattributed(database, claimed.id)
         if (message.requestId && message.webhookTiming && !webhookUpdateObserved)
           pendingRequestIds.add(message.requestId)
@@ -570,10 +584,19 @@ type VerifiedDeposit = {
   sourceAmount: bigint
 }
 
-async function observeProviderDelivery(
-  options: reconcileRequest.Options,
-  verified: readonly VerifiedDeposit[],
-) {
+type ReconcileDeliveryOptions = {
+  address: FundingDepositAddresses.Record
+  metrics?: Metrics.Metrics | undefined
+  provider?: Provider.Provider | undefined
+  request?: Provider.listDepositAddressRequests.ReturnType['requests'][number] | undefined
+  signal?: AbortSignal | undefined
+  subsidies?: Subsidy.Settler | undefined
+  verified: readonly VerifiedDeposit[]
+  verifyTransfers: VerifyTransfers
+}
+
+async function observeProviderDelivery(options: ReconcileDeliveryOptions) {
+  const { verified } = options
   const [entry] = verified
   if (
     !entry ||
@@ -581,7 +604,7 @@ async function observeProviderDelivery(
     options.address.deliveryStrategy !== 'provider' ||
     options.address.providerOutputToken.tokenKey !==
       options.address.snapshot.destinationToken.tokenKey ||
-    (options.request.status === 'success' &&
+    (options.request?.status === 'success' &&
       options.request.destinationTransactionHashes.length > 0) ||
     !options.provider ||
     !Provider.canObserveDepositAddressRequest(options.provider)
@@ -597,7 +620,7 @@ async function observeProviderDelivery(
         providerState: entry.deposit.providerState ?? undefined,
         recipient: options.address.recipient,
         refundAddress: options.address.refundAddress,
-        request: options.request,
+        ...(options.request ? { request: options.request } : {}),
         source: entry.source,
         sourceChain: options.address.snapshot.sourceChain,
         sourceToken: options.address.snapshot.sourceToken,
@@ -615,6 +638,63 @@ async function observeProviderDelivery(
   return result
 }
 
+async function reconcileUnattributed(db: Db.Db, options: reconcileUnattributed.Options) {
+  const deposits = await FundingDeposits.listUnattributed(db, options.address.id)
+  if (deposits.length === 0) return { terminal: true, updatedIds: new Set<string>() }
+
+  const transfersByTransaction = new Map(
+    await Promise.all(
+      unique(deposits.map((deposit) => deposit.sourceTransactionHash)).map(
+        async (transactionHash) =>
+          [
+            transactionHash,
+            await options.verifyTransfers({
+              chain: options.address.snapshot.sourceChain,
+              recipient: options.address.address,
+              token: options.address.snapshot.sourceToken,
+              transactionHash,
+            }),
+          ] as const,
+      ),
+    ),
+  )
+  let followUp: reconcileRequest.ReturnType['followUp']
+  let terminal = true
+  const updatedIds = new Set<string>()
+  for (const deposit of deposits) {
+    const source = transfersByTransaction
+      .get(deposit.sourceTransactionHash)
+      ?.find((transfer) => transfer.transferIndex === deposit.sourceTransferIndex)
+    if (!source) {
+      terminal = false
+      continue
+    }
+    const delivery = await reconcileDelivery(db, {
+      ...options,
+      verified: [
+        {
+          deposit,
+          required: destinationBaseUnits(
+            BigInt(source.amount),
+            options.address.snapshot.sourceToken.decimals,
+            options.address.snapshot.destinationToken.decimals,
+          ),
+          source,
+          sourceAmount: BigInt(source.amount),
+        },
+      ],
+    })
+    if (delivery.followUp === 'delivery' || !followUp) followUp = delivery.followUp
+    if (!delivery.terminal) terminal = false
+    for (const id of delivery.updatedIds) updatedIds.add(id)
+  }
+  return { ...(followUp ? { followUp } : {}), terminal, updatedIds }
+}
+
+declare namespace reconcileUnattributed {
+  type Options = Omit<ReconcileDeliveryOptions, 'request' | 'verified'>
+}
+
 /** Reconciles one provider request against verified chain evidence. */
 export async function reconcileRequest(
   db: Db.Db,
@@ -635,7 +715,6 @@ export async function reconcileRequest(
         : {}),
     })
   let created = 0
-  let followUp: reconcileRequest.ReturnType['followUp']
   const observed: ObservedSourceTransaction[] = []
   // Persist provider observations first so transient chain failures do not hide acknowledged deposits.
   for (const transactionHash of unique(options.request.sourceTransactionHashes)) {
@@ -699,7 +778,6 @@ export async function reconcileRequest(
 
   const sourceEvidenceComplete =
     sources.length > 0 && sources.every((source) => source.transfers.length > 0)
-  let terminal = sourceEvidenceComplete
   const updatedIds = new Set<string>()
   const verified: VerifiedDeposit[] = []
   for (const source of sources) {
@@ -758,7 +836,11 @@ export async function reconcileRequest(
         source.deposits.push(deposit)
         created += 1
       }
-      if (!Deposit.isTerminal(deposit.status)) {
+      if (
+        !Deposit.isTerminal(deposit.status) ||
+        deposit.providerRequestId === null ||
+        !deposit.providerRequestIds.includes(options.request.id)
+      ) {
         const result = await Deposit.transition(db, {
           expectedVersion: deposit.version,
           id: deposit.id,
@@ -784,11 +866,61 @@ export async function reconcileRequest(
   }
   if (verified.length === 0) return { created, terminal: false, updated: updatedIds.size }
   if (!sourceEvidenceComplete) return { created, terminal: false, updated: updatedIds.size }
+  const delivery = await reconcileDelivery(db, { ...options, verified })
+  for (const id of delivery.updatedIds) updatedIds.add(id)
+  return {
+    created,
+    ...(delivery.followUp ? { followUp: delivery.followUp } : {}),
+    terminal: delivery.terminal,
+    updated: updatedIds.size,
+  }
+}
+
+export declare namespace reconcileRequest {
+  /** Provider request, address, and settlement dependencies. */
+  type Options = {
+    /** Reusable deposit address attributed by the provider. */
+    address: FundingDepositAddresses.Record
+    /** Optional bounded operational metrics sink. */
+    metrics?: Metrics.Metrics | undefined
+    /** Provider integration that discovered the request. */
+    provider?: Provider.Provider | undefined
+    /** Provider request containing discovered chain transactions. */
+    request: Provider.listDepositAddressRequests.ReturnType['requests'][number]
+    /** Abort signal forwarded to provider delivery observation. */
+    signal?: AbortSignal | undefined
+    /** Optional pathUSD-funded subsidy settler. */
+    subsidies?: Subsidy.Settler | undefined
+    /** Mechanism that requested reconciliation. */
+    trigger?: Deposit.DetectionTrigger | undefined
+    /** Authoritative source and destination transfer verifier. */
+    verifyTransfers: VerifyTransfers
+  }
 
-  const deliveryObservation = await observeProviderDelivery(options, verified)
+  /** Material changes produced by one provider request. */
+  type ReturnType = {
+    /** Number of newly detected source transfers. */
+    created: number
+    /** Work that needs a bounded delayed follow-up. */
+    followUp?: 'delivery' | 'settlement' | undefined
+    /** Whether every deposit from this request reached a terminal state. */
+    terminal: boolean
+    /** Number of existing or new deposits materially changed. */
+    updated: number
+  }
+}
+
+async function reconcileDelivery(db: Db.Db, options: ReconcileDeliveryOptions) {
+  let followUp: reconcileRequest.ReturnType['followUp']
+  let terminal = true
+  const updatedIds = new Set<string>()
+  if (options.verified.every((entry) => Deposit.isTerminal(entry.deposit.status)))
+    return { terminal, updatedIds }
+  const deliveryObservation = await observeProviderDelivery(options)
   if (deliveryObservation?.type === 'pending') followUp = 'delivery'
+  const providerTransactionHashes = options.request?.destinationTransactionHashes ?? []
   const destinationTransactionHashes = unique([
-    ...options.request.destinationTransactionHashes,
+    ...providerTransactionHashes,
     ...(deliveryObservation?.type === 'verified'
       ? deliveryObservation.destinationTransactionHashes
       : []),
@@ -805,18 +937,18 @@ export async function reconcileRequest(
   )
   const destinationTransfers = destinationEvidence.flat()
   const providerEvidenceComplete =
-    (options.request.status === 'success' || deliveryObservation?.type === 'verified') &&
+    (options.request?.status === 'success' || deliveryObservation?.type === 'verified') &&
     destinationEvidence.length > 0 &&
     destinationEvidence.every((transfers) => transfers.length > 0)
   const providerOutput = destinationTransfers.reduce(
     (total, transfer) => total + BigInt(transfer.amount),
     0n,
   )
-  const totalRequired = verified.reduce((total, entry) => total + entry.required, 0n)
+  const totalRequired = options.verified.reduce((total, entry) => total + entry.required, 0n)
   let allocated = 0n
   let cumulativeRequired = 0n
 
-  for (const entry of verified) {
+  for (const entry of options.verified) {
     const { required, sourceAmount } = entry
     cumulativeRequired += required
     const nextAllocated =
@@ -860,7 +992,9 @@ export async function reconcileRequest(
             }),
           }
         : {}),
-      providerRequestIds: unique([...deposit.providerRequestIds, options.request.id]),
+      providerRequestIds: options.request
+        ? unique([...deposit.providerRequestIds, options.request.id])
+        : deposit.providerRequestIds,
       ...(deliveryObservation?.providerState
         ? {
             providerState: {
@@ -871,7 +1005,7 @@ export async function reconcileRequest(
         : {}),
       providerTransactionHashes: unique([
         ...deposit.providerTransactionHashes,
-        ...options.request.destinationTransactionHashes,
+        ...providerTransactionHashes,
         ...(deliveryObservation?.providerTransactionHashes ?? []),
       ]),
       ...(settlement.settlementTransaction
@@ -914,41 +1048,7 @@ export async function reconcileRequest(
       }
     }
   }
-  return { created, ...(followUp ? { followUp } : {}), terminal, updated: updatedIds.size }
-}
-
-export declare namespace reconcileRequest {
-  /** Provider request, address, and settlement dependencies. */
-  type Options = {
-    /** Reusable deposit address attributed by the provider. */
-    address: FundingDepositAddresses.Record
-    /** Optional bounded operational metrics sink. */
-    metrics?: Metrics.Metrics | undefined
-    /** Provider integration that discovered the request. */
-    provider?: Provider.Provider | undefined
-    /** Provider request containing discovered chain transactions. */
-    request: Provider.listDepositAddressRequests.ReturnType['requests'][number]
-    /** Abort signal forwarded to provider delivery observation. */
-    signal?: AbortSignal | undefined
-    /** Optional pathUSD-funded subsidy settler. */
-    subsidies?: Subsidy.Settler | undefined
-    /** Mechanism that requested reconciliation. */
-    trigger?: Deposit.DetectionTrigger | undefined
-    /** Authoritative source and destination transfer verifier. */
-    verifyTransfers: VerifyTransfers
-  }
-
-  /** Material changes produced by one provider request. */
-  type ReturnType = {
-    /** Number of newly detected source transfers. */
-    created: number
-    /** Work that needs a bounded delayed follow-up. */
-    followUp?: 'delivery' | 'settlement' | undefined
-    /** Whether every deposit from this request reached a terminal state. */
-    terminal: boolean
-    /** Number of existing or new deposits materially changed. */
-    updated: number
-  }
+  return { ...(followUp ? { followUp } : {}), terminal, updatedIds }
 }
 
 type ReconcileSubsidyOptions = {
@@ -1149,8 +1249,15 @@ function nextFollowUp(
   kind: Provider.Webhook.receive.FollowUp['kind'],
 ) {
   const attempt = message.followUp?.kind === kind ? message.followUp.attempt + 1 : 0
-  if (attempt >= maximumFollowUpAttempts) return undefined
-  return { delaySeconds: followUpDelaySeconds[kind], state: { attempt, kind } }
+  const chainProvider = kind === 'provider' && message.trigger === 'chain'
+  const maximumAttempts = chainProvider
+    ? chainProviderMaximumFollowUpAttempts
+    : maximumFollowUpAttempts
+  if (attempt >= maximumAttempts) return undefined
+  return {
+    delaySeconds: chainProvider ? chainProviderFollowUpDelaySeconds : followUpDelaySeconds[kind],
+    state: { attempt, kind },
+  }
 }
 
 type RecordWebhookLatencyOptions = {

package/src/internal/funding/SourceObservation.test.ts

@@ -230,7 +230,7 @@ describe('observe', () => {
         })(),
       }).toMatchInlineSnapshot(
         {
-          dispatches: [[{ addressId: expect.any(String) }, { delaySeconds: 5 }]],
+          dispatches: [[{ addressId: expect.any(String) }, { delaySeconds: 1 }]],
         },
         `
         {
@@ -246,7 +246,7 @@ describe('observe', () => {
                 "type": "funding:deposit-address:reconcile",
               },
               {
-                "delaySeconds": 5,
+                "delaySeconds": 1,
               },
             ],
           ],

package/src/internal/funding/providers/relay.ts

@@ -709,7 +709,10 @@ function createDepositAddressObserver(
   }
 
   return async (parameters, signal) => {
-    if (!(deliveryObservationStatuses as readonly string[]).includes(parameters.request.status))
+    if (
+      parameters.request &&
+      !(deliveryObservationStatuses as readonly string[]).includes(parameters.request.status)
+    )
       return { type: 'unsupported' }
     if (parameters.sourceChain.kind !== 'evm' || parameters.destinationChain.kind !== 'evm')
       return { type: 'unsupported' }
@@ -739,7 +742,7 @@ function createDepositAddressObserver(
     )
       return { type: 'unsupported' }
 
-    const parsedCorrelation = schema.RequestCorrelation.safeParse(parameters.request.providerState)
+    const parsedCorrelation = schema.RequestCorrelation.safeParse(parameters.request?.providerState)
     const correlation = parsedCorrelation.success ? parsedCorrelation.data.relay : undefined
     if (
       (correlation?.depository &&
@@ -854,6 +857,8 @@ function createDepositAddressObserver(
     }
     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 []
     })()