tapimo 0.8.0 → 0.10.0

package/src/internal/funding/Reconciliation.ts

@@ -13,12 +13,16 @@ 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
 >
 const maximumPages = 100
 const maximumFollowUpAttempts = 6
+const providerFailureStatuses = ['failure'] as const
+const providerRefundStatuses = ['refund', 'refunded'] as const
 
 /** Verified token transfer returned by an authoritative chain reader. */
 export type TransferEvidence = {
@@ -141,6 +145,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 +586,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 +606,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 +622,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 +640,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 +717,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 +780,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 +838,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 +868,195 @@ 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 recovery = await reconcileProviderRecovery(db, { ...options, verified })
+  if (recovery) {
+    for (const id of recovery.updatedIds) updatedIds.add(id)
+    return {
+      created,
+      ...(recovery.followUp ? { followUp: recovery.followUp } : {}),
+      terminal: recovery.terminal,
+      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
+  }
+
+  /** 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 reconcileProviderRecovery(db: Db.Db, options: ReconcileDeliveryOptions) {
+  const failed = (providerFailureStatuses as readonly string[]).includes(
+    options.request?.status ?? '',
+  )
+  const refunded = (providerRefundStatuses as readonly string[]).includes(
+    options.request?.status ?? '',
+  )
+  if (!refunded && !failed) return undefined
+  if (failed) {
+    const destinationEvidence = await Promise.all(
+      unique(options.request?.destinationTransactionHashes ?? []).map((transactionHash) =>
+        options.verifyTransfers({
+          chain: options.address.snapshot.destinationChain,
+          recipient: options.address.recipient,
+          token: options.address.providerOutputToken,
+          transactionHash,
+        }),
+      ),
+    )
+    if (destinationEvidence.some((transfers) => transfers.length > 0)) return undefined
+  }
 
-  const deliveryObservation = await observeProviderDelivery(options, verified)
+  const updatedIds = new Set<string>()
+  if (options.verified.every((entry) => Deposit.isTerminal(entry.deposit.status)))
+    return { terminal: true, updatedIds }
+
+  // Relay auto-refunds may include an internal settlement transaction; only matching source-token transfers become public evidence.
+  const providerRefundTransactionHashes = unique(options.request?.refundTransactionHashes ?? [])
+  const refundEvidence = await Promise.all(
+    providerRefundTransactionHashes.map((transactionHash) =>
+      options.verifyTransfers({
+        chain: options.address.snapshot.sourceChain,
+        recipient: options.address.refundAddress,
+        token: options.address.snapshot.sourceToken,
+        transactionHash,
+      }),
+    ),
+  )
+  const refundTransfers = refundEvidence.flat()
+  const refundOutput = refundTransfers.reduce(
+    (total, transfer) => total + BigInt(transfer.amount),
+    0n,
+  )
+  const refundTransactionHashes = unique(
+    refundTransfers.map((transfer) => transfer.transactionHash),
+  )
+  // Relay can include internal transactions, so its reported amount proves when all matching refund transfers are visible.
+  const expectedRefundOutput = options.request?.refundAmountExpected
+    ? BigInt(options.request.refundAmountExpected)
+    : undefined
+  const refundEvidenceComplete = (() => {
+    if (refundOutput === 0n) return false
+    if (expectedRefundOutput !== undefined) return refundOutput === expectedRefundOutput
+    return refundEvidence.length > 0 && refundEvidence.every((transfers) => transfers.length > 0)
+  })()
+  const totalSource = options.verified.reduce((total, entry) => total + entry.sourceAmount, 0n)
+  let allocated = 0n
+  let cumulativeSource = 0n
+  let terminal = refundEvidenceComplete
+
+  // Include terminal rows in proportional allocation so retries preserve the original split without reallocating their verified refunds.
+  for (const entry of options.verified) {
+    cumulativeSource += entry.sourceAmount
+    const nextAllocated = totalSource === 0n ? 0n : (refundOutput * cumulativeSource) / totalSource
+    const amount = nextAllocated - allocated
+    allocated = nextAllocated
+    if (Deposit.isTerminal(entry.deposit.status)) continue
+    let deposit = entry.deposit
+    if (deposit.status !== 'refunding') {
+      const result = await Deposit.transition(db, {
+        expectedVersion: deposit.version,
+        id: deposit.id,
+        providerTransactionHashes: unique([
+          ...deposit.providerTransactionHashes,
+          ...providerRefundTransactionHashes,
+        ]),
+        status: 'refunding',
+      })
+      if (result.type === 'applied') {
+        deposit = result.record
+        updatedIds.add(deposit.id)
+      } else if (result.type === 'stale') deposit = result.current
+    }
+    if (!refundEvidenceComplete) continue
+    if (Deposit.isTerminal(deposit.status)) continue
+    if (deposit.status !== 'refunding') {
+      terminal = false
+      continue
+    }
+    const result = await Deposit.transition(db, {
+      expectedVersion: deposit.version,
+      id: deposit.id,
+      snapshot: {
+        ...deposit.snapshot,
+        refundAmount: Value.tokenAmount({
+          baseUnits: amount,
+          currency: options.address.snapshot.sourceToken.currency,
+          decimals: options.address.snapshot.sourceToken.decimals,
+        }),
+        refundTransactionHashes,
+      },
+      status: 'refunded',
+    })
+    if (result.type === 'applied') updatedIds.add(deposit.id)
+    else if (result.type !== 'stale' || !Deposit.isTerminal(result.current.status)) terminal = false
+  }
+
+  const outcome = (() => {
+    if (refundEvidenceComplete) return 'verified'
+    // Relay failure can be followed by an automatic refund; durable exhaustion owns escalation to action-required.
+    if (failed) return 'provider_failed'
+    return 'pending'
+  })()
+  options.metrics?.count('funding_deposit_refund_count', 1, {
+    outcome,
+    provider: options.address.providerId,
+  })
+  return {
+    ...(!refundEvidenceComplete ? { followUp: 'delivery' as const } : {}),
+    terminal,
+    updatedIds,
+  }
+}
+
+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 +1073,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 +1128,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 +1141,7 @@ export async function reconcileRequest(
         : {}),
       providerTransactionHashes: unique([
         ...deposit.providerTransactionHashes,
-        ...options.request.destinationTransactionHashes,
+        ...providerTransactionHashes,
         ...(deliveryObservation?.providerTransactionHashes ?? []),
       ]),
       ...(settlement.settlementTransaction
@@ -914,41 +1184,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 +1385,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

@@ -188,6 +188,7 @@ describe('observe', () => {
           createdAt: '2026-01-01T00:00:02.000Z',
           destinationTransactionHashes: [],
           id: 'relay-source-request',
+          refundTransactionHashes: [],
           sourceTransactionHashes: [sourceTransactionHash],
           status: 'pending',
           updatedAt: '2026-01-01T00:00:03.000Z',
@@ -230,7 +231,7 @@ describe('observe', () => {
         })(),
       }).toMatchInlineSnapshot(
         {
-          dispatches: [[{ addressId: expect.any(String) }, { delaySeconds: 5 }]],
+          dispatches: [[{ addressId: expect.any(String) }, { delaySeconds: 1 }]],
         },
         `
         {
@@ -246,7 +247,7 @@ describe('observe', () => {
                 "type": "funding:deposit-address:reconcile",
               },
               {
-                "delaySeconds": 5,
+                "delaySeconds": 1,
               },
             ],
           ],

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

@@ -151,11 +151,8 @@ describe.skipIf(!apiKey)('relay.prepareTransfer (live)', () => {
     expect(result.correlation.requestId).toMatch(/^0x[0-9a-f]{64}$/)
     expect(result.correlation.checkEndpoint).toContain('/intents/status/v3')
     expect(BigInt(result.destinationAmount) > 0n).toBe(true)
+    expect(BigInt(result.destinationAmountMin) > 0n).toBe(true)
     expect(BigInt(result.destinationAmountMin) <= BigInt(result.destinationAmount)).toBe(true)
-    // The forwarded slippage bound holds on the quoted minimum.
-    expect(
-      BigInt(result.destinationAmountMin) >= (BigInt(result.destinationAmount) * 9_700n) / 10_000n,
-    ).toBe(true)
     // Relay returns no quote validity window; the fan-out applies the default.
     expect(result.expiresAt).toBeUndefined()
     expect(Number.isNaN(Date.parse(result.sampledAt))).toBe(false)

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

@@ -17,6 +17,7 @@ const defaultBaseUrl = 'https://api.relay.link'
 const defaultFetch: FundingProvider.Fetch = (input, init) => globalThis.fetch(input, init)
 const deliveryBackfillBlocks = 256n
 const relayChainsCacheTtlMs = 60_000
+const relayRefundStatuses = ['refund', 'refunded'] as const
 const sourceSweepForwardBlocks = 256n
 const depositErc20FullAllowance = AbiFunction.from(
   'function depositErc20(address depositor,address token,bytes32 id)',
@@ -46,6 +47,7 @@ const webhookStatuses = [
   'fallback',
   'pending',
   'refund',
+  'refunded',
   'submitted',
   'success',
   'waiting',
@@ -196,6 +198,13 @@ namespace schema {
           ),
         ),
         id: z.string().check(z.minLength(1)),
+        refundCurrencyData: z.optional(
+          z.nullable(
+            z.object({
+              amount: z.string().check(z.regex(/^\d+$/)),
+            }),
+          ),
+        ),
         protocol: z.optional(
           z.nullable(
             z.object({
@@ -481,6 +490,8 @@ export function relay(options: relay.Options = {}): FundingProvider.Provider<'re
       return {
         ...(parsed.continuation ? { continuation: parsed.continuation } : {}),
         requests: parsed.requests.map((request) => {
+          const outputTransactionHashes = request.data?.outTxs?.map((tx) => tx.txHash) ?? []
+          const refunded = (relayRefundStatuses as readonly string[]).includes(request.status)
           const correlation = (() => {
             const { protocol } = request
             if (!protocol) return undefined
@@ -499,9 +510,13 @@ export function relay(options: relay.Options = {}): FundingProvider.Provider<'re
           })()
           return {
             createdAt: new Date(request.createdAt).toISOString(),
-            destinationTransactionHashes: request.data?.outTxs?.map((tx) => tx.txHash) ?? [],
+            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]
               : [],
@@ -709,7 +724,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 +757,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 +872,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 []
     })()