import * as NodeBuffer from 'node:buffer'

import { AbiEvent, AbiFunction, AbiParameters, Address, Hex } from 'ox'

import * as Metrics from '../../Metrics.js'
import * as FundingCatalog from '../../db/tables/fundingCatalog.js'
import * as FundingDepositAddresses from '../../db/tables/fundingDepositAddresses.js'
import * as FundingDepositRequestObservations from '../../db/tables/fundingDepositRequestObservations.js'
import * as FundingDeposits from '../../db/tables/fundingDeposits.js'
import * as TestApp from '../../../test/App.js'
import * as TestFunding from '../../../test/Funding.js'
import * as TestRelay from '../../../test/Relay.js'
import * as Chain from './Chain.js'
import * as Deposit from './Deposit.js'
import * as DepositAddress from './DepositAddress.js'
import * as Evidence from './Evidence.js'
import * as Provider from './Provider.js'
import * as Reconciliation from './Reconciliation.js'
import * as Relay from './providers/relay.js'
import * as SourceObservation from './SourceObservation.js'

const db = TestApp.database()
const transferTopic = AbiEvent.getSelector('event Transfer(address,address,uint256)')

describe('createTracker', () => {
  test('keeps Relay success pending without destination evidence', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'44'.repeat(20)}`
    const sourceTransactionHash = `0x${'aa'.repeat(32)}`
    const providerTransactionHash = `0x${'cc'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-01T00:00:00.000Z'),
      orgId: 'org_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'55'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const counts: Parameters<Metrics.Metrics['count']>[] = []
    const metrics = Metrics.from({
      count(...parameters) {
        counts.push(parameters)
      },
      flush() {},
      gauge() {},
      histogram() {},
    })
    const server = await TestRelay.createServer(async (request, response) => {
      if (request.method === 'GET') {
        response.writeHead(200, { 'content-type': 'application/json' })
        response.end(
          JSON.stringify({
            requests: [
              {
                createdAt: '2026-01-01T00:01:00.000Z',
                data: {
                  inTxs: [{ txHash: providerTransactionHash }],
                  outTxs: [],
                },
                depositAddress: { depositTxHash: sourceTransactionHash },
                id: 'relay-child-request',
                status: 'success',
                updatedAt: '2026-01-01T00:02:00.000Z',
              },
            ],
          }),
        )
        return
      }

      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result =
        body.method === 'eth_blockNumber'
          ? '0x100'
          : {
              blockNumber: '0x80',
              logs: [
                hash === sourceTransactionHash
                  ? transferLog({
                      amount: 1_000_000n,
                      recipient: depositAddress,
                      sender: `0x${'66'.repeat(20)}`,
                      token: route.sourceToken.address,
                    })
                  : transferLog({
                      amount: 950_000n,
                      recipient: route.recipient,
                      sender: `0x${'77'.repeat(20)}`,
                      token: route.destinationToken.address,
                    }),
              ],
              status: '0x1',
            }
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source',
          },
        ],
        routes: [],
        tokens: [],
      })
      const messages: Provider.Webhook.receive.Dispatchable[] = []
      const provider = Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })
      const tracker = Reconciliation.createTracker({
        db,
        dispatch: async (message) => {
          messages.push(message)
        },
        metrics,
        now: () => new Date('2027-01-01T00:00:00.000Z'),
        providers: [provider],
        verifyTransfers: Evidence.createVerifier({
          db,
        }),
      })

      const tick = await tracker.tick()
      const message = messages[0]
      if (!message) throw new Error('Expected a reconciliation message.')
      const queuedBeforeAttribution: Provider.Webhook.receive.Queued = {
        addressId: message.addressId,
        pollLeaseVersion: message.pollLeaseVersion,
        type: message.type,
      }
      const reconciliation = await tracker.reconcile(queuedBeforeAttribution)
      const duplicate = await tracker.reconcile(queuedBeforeAttribution)
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })
      const observation = await FundingDepositRequestObservations.get(db, {
        depositAddressId: address.id,
        providerRequestId: 'relay-child-request',
      })
      const storedAddress = await FundingDepositAddresses.get(db, address.id)

      expect({
        counts,
        duplicate,
        observation,
        reconciliation,
        record,
        storedAddress,
        tick,
      }).toMatchInlineSnapshot(
        {
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
          observation: { depositAddressId: expect.any(String) },
          storedAddress: {
            id: expect.any(String),
            providerOutputToken: expect.any(Object),
            snapshot: expect.any(Object),
          },
        },
        `
        {
          "counts": [
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "enqueued",
                "provider": "relay",
                "trigger": "poll",
              },
            ],
            [
              "funding_deposit_detection_count",
              1,
              {
                "provider": "relay",
                "trigger": "poll",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_enqueued",
                "provider": "relay",
                "trigger": "poll",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "poll",
              },
            ],
          ],
          "duplicate": {
            "type": "busy",
          },
          "observation": {
            "depositAddressId": Any<String>,
            "pollObservedAt": "2027-01-01T00:00:00.000Z",
            "providerRequestId": "relay-child-request",
            "webhookReceivedAt": null,
          },
          "reconciliation": {
            "created": 1,
            "type": "completed",
            "updated": 1,
          },
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "poll",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_reconciliation",
            "pollObservedAt": "2027-01-01T00:00:00.000Z",
            "projectId": null,
            "providerOutputAmount": null,
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "relay-child-request",
            "providerRequestIds": [
              "relay-child-request",
            ],
            "providerState": null,
            "providerTransactionHashes": [],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "destinationTransactionHashes": [],
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x5555555555555555555555555555555555555555",
              "sender": "0x6666666666666666666666666666666666666666",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            "sourceTransferIndex": 0,
            "status": "bridging",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 3,
            "webhookReceivedAt": null,
          },
          "storedAddress": {
            "address": "0x4444444444444444444444444444444444444444",
            "apiKeyId": "key_reconciliation",
            "createdAt": "2026-01-01T00:00:00.000Z",
            "deliveryStrategy": "provider",
            "destinationTokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
            "environment": "production",
            "id": Any<String>,
            "lastPolledAt": "2027-01-01T00:00:00.000Z",
            "nextPollAt": "2027-01-01T00:01:00.000Z",
            "orgId": "org_reconciliation",
            "pollFailureCount": 0,
            "pollLeaseUntil": null,
            "pollLeaseVersion": 1,
            "projectId": null,
            "providerId": "relay",
            "providerOutputToken": Any<Object>,
            "providerRequestIds": [],
            "providerState": {
              "reconciliation": {
                "pendingRequestIds": [
                  "relay-child-request",
                ],
                "requestIds": [
                  "relay-child-request",
                ],
                "updatedAt": "2026-01-01T00:02:00.000Z",
              },
            },
            "recipient": "0x1111111111111111111111111111111111111111",
            "refundAddress": "0x5555555555555555555555555555555555555555",
            "snapshot": Any<Object>,
            "sourceChainId": "eip155:8453",
            "sourceTokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
            "status": "active",
            "subsidize": false,
            "updatedAt": "2026-01-01T00:00:00.000Z",
            "version": 1,
          },
          "tick": {
            "claimed": 1,
            "failed": 0,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('completes an unsubsidized deposit at its verified provider output', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'45'.repeat(20)}`
    const destinationTransactionHash = `0x${'cd'.repeat(32)}`
    const sourceTransactionHash = `0x${'ab'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_unsubsidized_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-06T00:00:00.000Z'),
      orgId: 'org_unsubsidized_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'local', name: 'Local' },
        recipient: route.recipient,
        refundAddress: `0x${'46'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const server = await TestRelay.createServer(async (request, response) => {
      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const source = body.params?.[0] === sourceTransactionHash
      const result =
        body.method === 'eth_blockNumber'
          ? '0x100'
          : {
              blockNumber: '0x80',
              logs: [
                transferLog({
                  amount: source ? 1_000_000n : 950_000n,
                  recipient: source ? depositAddress : route.recipient,
                  sender: `0x${'47'.repeat(20)}`,
                  token: source ? route.sourceToken.address : route.destinationToken.address,
                }),
              ],
              status: '0x1',
            }
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination-unsubsidized',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source-unsubsidized',
          },
        ],
        routes: [],
        tokens: [],
      })
      const result = await Reconciliation.reconcileRequest(db, {
        address,
        request: {
          createdAt: '2026-01-06T00:01:00.000Z',
          destinationTransactionHashes: [destinationTransactionHash],
          id: 'unsubsidized-request',
          refundTransactionHashes: [],
          sourceTransactionHashes: [sourceTransactionHash],
          status: 'success',
          updatedAt: '2026-01-06T00:02:00.000Z',
        },
        trigger: 'manual',
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })

      expect({ record, result }).toMatchInlineSnapshot(
        {
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
        },
        `
        {
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "manual",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_unsubsidized_reconciliation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": {
              "baseUnits": "950000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "0.95",
            },
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "unsubsidized-request",
            "providerRequestIds": [
              "unsubsidized-request",
            ],
            "providerState": null,
            "providerTransactionHashes": [
              "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
            ],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationAmount": {
                "baseUnits": "950000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "0.95",
              },
              "destinationAmountRequired": {
                "baseUnits": "950000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "0.95",
              },
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "destinationTransactionHashes": [
                "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
              ],
              "provider": {
                "id": "local",
                "name": "Local",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x4646464646464646464646464646464646464646",
              "sender": "0x4747474747474747474747474747474747474747",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xabababababababababababababababababababababababababababababababab",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0xabababababababababababababababababababababababababababababababab",
            "sourceTransferIndex": 0,
            "status": "completed",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 3,
            "webhookReceivedAt": null,
          },
          "result": {
            "created": 1,
            "terminal": true,
            "updated": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('verifies Relay refunds on the source chain before completing recovery', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'48'.repeat(20)}`
    const firstRefundTransactionHash = `0x${'ce'.repeat(32)}`
    const refundAddress = `0x${'49'.repeat(20)}`
    const secondRefundTransactionHash = `0x${'cd'.repeat(32)}`
    const settlementTransactionHash = `0x${'cf'.repeat(32)}`
    const sourceTransactionHash = `0x${'ac'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_refund_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-07T00:00:00.000Z'),
      orgId: 'org_refund_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const counts: Parameters<Metrics.Metrics['count']>[] = []
    const metrics = Metrics.from({
      count(...parameters) {
        counts.push(parameters)
      },
      flush() {},
      gauge() {},
      histogram() {},
    })
    let secondRefundVisible = false
    const server = await TestRelay.createServer(async (request, response) => {
      response.writeHead(200, { 'content-type': 'application/json' })
      if (request.method === 'GET') {
        response.end(
          JSON.stringify({
            requests: [
              {
                createdAt: '2026-01-07T00:01:00.000Z',
                data: {
                  outTxs: [
                    { txHash: firstRefundTransactionHash },
                    { txHash: firstRefundTransactionHash },
                    { txHash: secondRefundTransactionHash },
                    { txHash: settlementTransactionHash },
                  ],
                },
                depositAddress: { depositTxHash: sourceTransactionHash },
                id: 'relay-refund-request',
                refundCurrencyData: { amount: '900000' },
                status: 'refund',
                updatedAt: '2026-01-07T00:02:00.000Z',
              },
            ],
          }),
        )
        return
      }

      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result = (() => {
        if (body.method === 'eth_blockNumber') return '0x100'
        if (hash === secondRefundTransactionHash && !secondRefundVisible) return null
        const log = (() => {
          if (hash === sourceTransactionHash)
            return transferLog({
              amount: 1_000_000n,
              recipient: depositAddress,
              sender: `0x${'4a'.repeat(20)}`,
              token: route.sourceToken.address,
            })
          if (hash === firstRefundTransactionHash)
            return transferLog({
              amount: 400_000n,
              recipient: refundAddress,
              sender: `0x${'4b'.repeat(20)}`,
              token: route.sourceToken.address,
            })
          if (hash === secondRefundTransactionHash)
            return transferLog({
              amount: 500_000n,
              recipient: refundAddress,
              sender: `0x${'4b'.repeat(20)}`,
              token: route.sourceToken.address,
            })
          return transferLog({
            amount: 100_000n,
            recipient: `0x${'4c'.repeat(20)}`,
            sender: `0x${'4b'.repeat(20)}`,
            token: route.sourceToken.address,
          })
        })()
        return { blockNumber: '0x80', logs: [log], status: '0x1' }
      })()
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination-refund',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source-refund',
          },
        ],
        routes: [],
        tokens: [],
      })
      const provider = Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })
      const request = (
        await provider.listDepositAddressRequests!(
          { address: depositAddress },
          new AbortController().signal,
        )
      ).requests[0]
      if (!request) throw new Error('Expected a Relay refund request.')
      const verifyTransfers = Evidence.createVerifier({ db })
      const depositUpdateVersions: number[] = []
      const first = await Reconciliation.reconcileRequest(db, {
        address,
        metrics,
        onDeposit: (deposit) => depositUpdateVersions.push(deposit.version),
        request,
        verifyTransfers,
      })
      const [firstRecord] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })
      secondRefundVisible = true
      const second = await Reconciliation.reconcileRequest(db, {
        address,
        metrics,
        onDeposit: (deposit) => depositUpdateVersions.push(deposit.version),
        request,
        verifyTransfers,
      })
      const duplicate = await Reconciliation.reconcileRequest(db, {
        address,
        metrics,
        onDeposit: (deposit) => depositUpdateVersions.push(deposit.version),
        request,
        verifyTransfers,
      })
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })
      if (!firstRecord || !record) throw new Error('Expected reconciled funding deposits.')

      expect(depositUpdateVersions).toEqual([2, firstRecord.version, 4, record.version])

      expect({
        counts,
        duplicate,
        first,
        firstRecord,
        record,
        request,
        second,
      }).toMatchInlineSnapshot(
        {
          firstRecord: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
        },
        `
        {
          "counts": [
            [
              "funding_deposit_refund_count",
              1,
              {
                "outcome": "pending",
                "provider": "relay",
              },
            ],
            [
              "funding_deposit_refund_count",
              1,
              {
                "outcome": "verified",
                "provider": "relay",
              },
            ],
          ],
          "duplicate": {
            "created": 0,
            "terminal": true,
            "updated": 0,
          },
          "first": {
            "created": 1,
            "followUp": "delivery",
            "terminal": false,
            "updated": 1,
          },
          "firstRecord": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "poll",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_refund_reconciliation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": null,
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "relay-refund-request",
            "providerRequestIds": [
              "relay-refund-request",
            ],
            "providerState": null,
            "providerTransactionHashes": [
              "0xcececececececececececececececececececececececececececececececece",
              "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
              "0xcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf",
            ],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x4949494949494949494949494949494949494949",
              "sender": "0x4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacac",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0xacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacac",
            "sourceTransferIndex": 0,
            "status": "refunding",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 3,
            "webhookReceivedAt": null,
          },
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "poll",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_refund_reconciliation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": null,
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "relay-refund-request",
            "providerRequestIds": [
              "relay-refund-request",
            ],
            "providerState": null,
            "providerTransactionHashes": [
              "0xcececececececececececececececececececececececececececececececece",
              "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
              "0xcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf",
            ],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x4949494949494949494949494949494949494949",
              "refundAmount": {
                "baseUnits": "900000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "0.9",
              },
              "refundTransactionHashes": [
                "0xcececececececececececececececececececececececececececececececece",
                "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
              ],
              "sender": "0x4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacac",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0xacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacac",
            "sourceTransferIndex": 0,
            "status": "refunded",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 5,
            "webhookReceivedAt": null,
          },
          "request": {
            "createdAt": "2026-01-07T00:01:00.000Z",
            "destinationTransactionHashes": [],
            "id": "relay-refund-request",
            "refundAmountExpected": "900000",
            "refundTransactionHashes": [
              "0xcececececececececececececececececececececececececececececececece",
              "0xcececececececececececececececececececececececececececececececece",
              "0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
              "0xcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcfcf",
            ],
            "sourceTransactionHashes": [
              "0xacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacacac",
            ],
            "status": "refund",
            "updatedAt": "2026-01-07T00:02:00.000Z",
          },
          "second": {
            "created": 0,
            "terminal": true,
            "updated": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('preserves refund allocations when retrying a partially committed request', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'50'.repeat(20)}`
    const refundAddress = `0x${'51'.repeat(20)}`
    const refundTransactionHash = `0x${'d0'.repeat(32)}`
    const sourceTransactionHash = `0x${'b0'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_refund_retry',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-09T00:00:00.000Z'),
      orgId: 'org_refund_retry',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const first = await Deposit.create(db, {
      id: 'fdp_refund_retry_0',
      now: new Date('2026-01-09T00:01:00.000Z'),
      providerRequestId: 'relay-refund-retry-request',
      providerTransferIndex: 0,
      snapshot: {
        depositAddressId: address.id,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress,
        sourceAmount: {
          baseUnits: '1000000',
          currency: route.sourceToken.currency,
          decimals: route.sourceToken.decimals,
          formatted: '1',
        },
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        sourceTransactionHashes: [sourceTransactionHash],
      },
      sourceTransactionHash,
      sourceTransferIndex: 0,
    })
    await Deposit.create(db, {
      id: 'fdp_refund_retry_1',
      now: new Date('2026-01-09T00:01:01.000Z'),
      providerRequestId: 'relay-refund-retry-request',
      providerTransferIndex: 1,
      snapshot: {
        depositAddressId: address.id,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress,
        sourceAmount: {
          baseUnits: '2000000',
          currency: route.sourceToken.currency,
          decimals: route.sourceToken.decimals,
          formatted: '2',
        },
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        sourceTransactionHashes: [sourceTransactionHash],
      },
      sourceTransactionHash,
      sourceTransferIndex: 1,
    })
    const refunding = await Deposit.transition(db, {
      expectedVersion: first.version,
      id: first.id,
      providerTransactionHashes: [refundTransactionHash],
      status: 'refunding',
    })
    if (refunding.type !== 'applied') throw new Error('Expected the first deposit to refund.')
    const refunded = await Deposit.transition(db, {
      expectedVersion: refunding.record.version,
      id: refunding.record.id,
      snapshot: {
        ...refunding.record.snapshot,
        refundAmount: {
          baseUnits: '300000',
          currency: route.sourceToken.currency,
          decimals: route.sourceToken.decimals,
          formatted: '0.3',
        },
        refundTransactionHashes: [refundTransactionHash],
      },
      status: 'refunded',
    })
    if (refunded.type !== 'applied') throw new Error('Expected the first deposit to be refunded.')

    const server = await TestRelay.createServer(async (request, response) => {
      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result = (() => {
        if (body.method === 'eth_blockNumber') return '0x100'
        if (hash === sourceTransactionHash)
          return {
            blockNumber: '0x80',
            logs: [
              transferLog({
                amount: 1_000_000n,
                logIndex: 0,
                recipient: depositAddress,
                sender: `0x${'52'.repeat(20)}`,
                token: route.sourceToken.address,
              }),
              transferLog({
                amount: 2_000_000n,
                logIndex: 1,
                recipient: depositAddress,
                sender: `0x${'53'.repeat(20)}`,
                token: route.sourceToken.address,
              }),
            ],
            status: '0x1',
          }
        return {
          blockNumber: '0x80',
          logs: [
            transferLog({
              amount: 900_000n,
              recipient: refundAddress,
              sender: `0x${'54'.repeat(20)}`,
              token: route.sourceToken.address,
            }),
          ],
          status: '0x1',
        }
      })()
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination-refund-retry',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source-refund-retry',
          },
        ],
        routes: [],
        tokens: [],
      })
      const result = await Reconciliation.reconcileRequest(db, {
        address,
        request: {
          createdAt: '2026-01-09T00:01:00.000Z',
          destinationTransactionHashes: [],
          id: 'relay-refund-retry-request',
          refundTransactionHashes: [refundTransactionHash],
          sourceTransactionHashes: [sourceTransactionHash],
          status: 'refund',
          updatedAt: '2026-01-09T00:02:00.000Z',
        },
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const records = (
        await FundingDeposits.listBySourceTransaction(db, {
          depositAddressId: address.id,
          sourceTransactionHash,
        })
      ).sort((left, right) => left.providerTransferIndex - right.providerTransferIndex)

      expect({ records: records.map(Deposit.toPublic), result }).toMatchInlineSnapshot(
        {
          records: [
            { depositAddressId: expect.any(String), updatedAt: expect.any(String) },
            { depositAddressId: expect.any(String), updatedAt: expect.any(String) },
          ],
        },
        `
        {
          "records": [
            {
              "createdAt": "2026-01-09T00:01:00.000Z",
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "id": "fdp_refund_retry_0",
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x5151515151515151515151515151515151515151",
              "refundAmount": {
                "baseUnits": "300000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "0.3",
              },
              "refundTransactionHashes": [
                "0xd0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0",
              ],
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0",
              ],
              "sourceTransferIndex": 0,
              "status": "refunded",
              "updatedAt": Any<String>,
            },
            {
              "createdAt": "2026-01-09T00:01:01.000Z",
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "id": "fdp_refund_retry_1",
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x5151515151515151515151515151515151515151",
              "refundAmount": {
                "baseUnits": "600000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "0.6",
              },
              "refundTransactionHashes": [
                "0xd0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0",
              ],
              "sender": "0x5353535353535353535353535353535353535353",
              "sourceAmount": {
                "baseUnits": "2000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "2",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0",
              ],
              "sourceTransferIndex": 1,
              "status": "refunded",
              "updatedAt": Any<String>,
            },
          ],
          "result": {
            "created": 0,
            "terminal": true,
            "updated": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('reconciles destination evidence reported with a Relay failure', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'56'.repeat(20)}`
    const destinationTransactionHash = `0x${'d1'.repeat(32)}`
    const sourceTransactionHash = `0x${'b1'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_failure_delivery',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-10T00:00:00.000Z'),
      orgId: 'org_failure_delivery',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'57'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const server = await TestRelay.createServer(async (request, response) => {
      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result = (() => {
        if (body.method === 'eth_blockNumber') return '0x100'
        if (hash === sourceTransactionHash)
          return {
            blockNumber: '0x80',
            logs: [
              transferLog({
                amount: 1_000_000n,
                recipient: depositAddress,
                sender: `0x${'58'.repeat(20)}`,
                token: route.sourceToken.address,
              }),
            ],
            status: '0x1',
          }
        return {
          blockNumber: '0x80',
          logs: [
            transferLog({
              amount: 1_000_000n,
              recipient: route.recipient,
              sender: `0x${'59'.repeat(20)}`,
              token: route.destinationToken.address,
            }),
          ],
          status: '0x1',
        }
      })()
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination-failure-delivery',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source-failure-delivery',
          },
        ],
        routes: [],
        tokens: [],
      })
      const result = await Reconciliation.reconcileRequest(db, {
        address,
        request: {
          createdAt: '2026-01-10T00:01:00.000Z',
          destinationTransactionHashes: [destinationTransactionHash],
          id: 'relay-failure-delivery-request',
          refundTransactionHashes: [],
          sourceTransactionHashes: [sourceTransactionHash],
          status: 'failure',
          updatedAt: '2026-01-10T00:02:00.000Z',
        },
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })
      if (!record) throw new Error('Expected a reconciled deposit.')

      expect({ record: Deposit.toPublic(record), result }).toMatchInlineSnapshot(
        {
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            updatedAt: expect.any(String),
          },
        },
        `
        {
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "destinationAmount": {
              "baseUnits": "1000000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "1",
            },
            "destinationAmountRequired": {
              "baseUnits": "1000000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "1",
            },
            "destinationChain": {
              "addressFormat": "hex",
              "id": "eip155:4217",
              "kind": "evm",
              "name": "Tempo",
            },
            "destinationToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "destinationTransactionHashes": [
              "0xd1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1",
            ],
            "detectionTrigger": "poll",
            "id": Any<String>,
            "provider": {
              "id": "relay",
              "name": "Relay",
            },
            "recipient": "0x1111111111111111111111111111111111111111",
            "refundAddress": "0x5757575757575757575757575757575757575757",
            "sender": "0x5858585858585858585858585858585858585858",
            "sourceAmount": {
              "baseUnits": "1000000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "1",
            },
            "sourceChain": {
              "addressFormat": "hex",
              "id": "eip155:8453",
              "kind": "evm",
              "name": "Base",
            },
            "sourceToken": {
              "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
              "currency": "USD",
              "decimals": 6,
              "name": "USD Coin",
              "standard": "ERC-20",
              "symbol": "USDC",
              "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
              "verified": true,
            },
            "sourceTransactionHashes": [
              "0xb1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1b1",
            ],
            "sourceTransferIndex": 0,
            "status": "completed",
            "updatedAt": Any<String>,
          },
          "result": {
            "created": 1,
            "terminal": true,
            "updated": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('keeps Relay failures with unverified destination transactions pending for recovery', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'4d'.repeat(20)}`
    const sourceTransactionHash = `0x${'ad'.repeat(32)}`
    const unrelatedDestinationTransactionHash = `0x${'d2'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_failed_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-08T00:00:00.000Z'),
      orgId: 'org_failed_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'4e'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const counts: Parameters<Metrics.Metrics['count']>[] = []
    const metrics = Metrics.from({
      count(...parameters) {
        counts.push(parameters)
      },
      flush() {},
      gauge() {},
      histogram() {},
    })
    const server = await TestRelay.createServer(async (request, response) => {
      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
      }
      const result =
        body.method === 'eth_blockNumber'
          ? '0x100'
          : {
              blockNumber: '0x80',
              logs: [
                transferLog({
                  amount: 1_000_000n,
                  recipient: depositAddress,
                  sender: `0x${'4f'.repeat(20)}`,
                  token: route.sourceToken.address,
                }),
              ],
              status: '0x1',
            }
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination-failed',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source-failed',
          },
        ],
        routes: [],
        tokens: [],
      })
      const result = await Reconciliation.reconcileRequest(db, {
        address,
        metrics,
        request: {
          createdAt: '2026-01-08T00:01:00.000Z',
          destinationTransactionHashes: [unrelatedDestinationTransactionHash],
          id: 'relay-failed-request',
          refundTransactionHashes: [],
          sourceTransactionHashes: [sourceTransactionHash],
          status: 'failure',
          updatedAt: '2026-01-08T00:02:00.000Z',
        },
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })

      expect({ counts, record, result }).toMatchInlineSnapshot(
        {
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
        },
        `
        {
          "counts": [
            [
              "funding_deposit_refund_count",
              1,
              {
                "outcome": "provider_failed",
                "provider": "relay",
              },
            ],
          ],
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "poll",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_failed_reconciliation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": null,
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "relay-failed-request",
            "providerRequestIds": [
              "relay-failed-request",
            ],
            "providerState": null,
            "providerTransactionHashes": [],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e",
              "sender": "0x4f4f4f4f4f4f4f4f4f4f4f4f4f4f4f4f4f4f4f4f",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadad",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0xadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadadad",
            "sourceTransferIndex": 0,
            "status": "refunding",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 3,
            "webhookReceivedAt": null,
          },
          "result": {
            "created": 1,
            "followUp": "delivery",
            "terminal": false,
            "updated": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('persists a detected deposit before source verification succeeds', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'20'.repeat(20)}`
    const sourceTransactionHash = `0x${'21'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_observed_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-04T00:00:00.000Z'),
      orgId: 'org_observed_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'22'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const server = await TestRelay.createServer(async (request, response) => {
      response.writeHead(200, { 'content-type': 'application/json' })
      if (request.method === 'GET') {
        response.end(
          JSON.stringify({
            requests: [
              {
                createdAt: '2026-01-04T00:01:00.000Z',
                data: { inTxs: [{ txHash: sourceTransactionHash }], outTxs: [] },
                depositAddress: { depositTxHash: sourceTransactionHash },
                id: 'relay-observed-request',
                status: 'pending',
                updatedAt: '2026-01-04T00:02:00.000Z',
              },
            ],
          }),
        )
        return
      }

      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as { id: number }
      response.end(
        JSON.stringify({
          error: { code: -32_000, message: 'Source RPC unavailable.' },
          id: body.id,
          jsonrpc: '2.0',
        }),
      )
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source',
          },
        ],
        routes: [],
        tokens: [],
      })
      const dispatchedEventIds: string[][] = []
      const tracker = Reconciliation.createTracker({
        db,
        dispatch: async () => undefined,
        dispatchDepositUpdates: async (references) => {
          dispatchedEventIds.push(references.map((reference) => reference.eventId))
          return references.length
        },
        providers: [Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })],
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const failures: boolean[] = []
      for (let attempt = 0; attempt < 2; attempt++)
        failures.push(
          await tracker
            .reconcile({
              addressId: address.id,
              type: 'funding:deposit-address:reconcile',
            })
            .then(
              () => false,
              () => true,
            ),
        )
      const records = await FundingDeposits.listByAddress(
        db,
        { environment: 'production', orgId: 'org_observed_reconciliation' },
        address.id,
        { limit: 10 },
      )

      expect(dispatchedEventIds).toEqual([])

      expect({ failures, records: records.map(Deposit.toPublic) }).toMatchInlineSnapshot(
        {
          records: [
            {
              createdAt: expect.any(String),
              depositAddressId: expect.any(String),
              id: expect.any(String),
              updatedAt: expect.any(String),
            },
          ],
        },
        `
        {
          "failures": [
            true,
            true,
          ],
          "records": [
            {
              "createdAt": Any<String>,
              "depositAddressId": Any<String>,
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "detectionTrigger": "webhook",
              "id": Any<String>,
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x2222222222222222222222222222222222222222",
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0x2121212121212121212121212121212121212121212121212121212121212121",
              ],
              "status": "detected",
              "updatedAt": Any<String>,
            },
          ],
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('rechecks pending Relay requests by id until delivery is verified', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'88'.repeat(20)}`
    const sourceTransactionHash = `0x${'cc'.repeat(32)}`
    const destinationTransactionHash = `0x${'dd'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_pending_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-02T00:00:00.000Z'),
      orgId: 'org_pending_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'99'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const counts: Parameters<Metrics.Metrics['count']>[] = []
    const dispatches: Parameters<Reconciliation.createTracker.Options['dispatch']>[] = []
    const histograms: Parameters<Metrics.Metrics['histogram']>[] = []
    const metrics = Metrics.from({
      count(...parameters) {
        counts.push(parameters)
      },
      flush() {},
      gauge() {},
      histogram(...parameters) {
        histograms.push(parameters)
      },
    })
    const requestTargets: string[] = []
    let delivered = false
    let dispatchFailure = true
    let includeAddressRequest = true
    let indexed = false
    let providerUpdateVisible = false
    let returnOlderDirect = false
    const server = await TestRelay.createServer(async (request, response) => {
      if (request.method === 'GET') {
        const url = new URL(request.url ?? '/', server.url)
        requestTargets.push(`${url.pathname}${url.search}`)
        const direct = url.searchParams.get('id') === 'relay-pending-request'
        response.writeHead(200, { 'content-type': 'application/json' })
        response.end(
          JSON.stringify({
            requests:
              indexed && (includeAddressRequest || direct)
                ? [
                    {
                      createdAt: '2026-01-02T00:01:00.000Z',
                      data: {
                        inTxs: [{ txHash: sourceTransactionHash }],
                        outTxs: delivered ? [{ txHash: destinationTransactionHash }] : [],
                      },
                      depositAddress: { depositTxHash: sourceTransactionHash },
                      id: 'relay-pending-request',
                      status: delivered ? 'success' : 'pending',
                      updatedAt: (() => {
                        if (direct && returnOlderDirect) return '2026-01-01T00:00:00.000Z'
                        if (!providerUpdateVisible) return '2026-01-02T00:02:00.000Z'
                        if (delivered) return '2026-01-02T00:03:00.500Z'
                        return '2026-01-02T00:03:00Z'
                      })(),
                    },
                  ]
                : [],
          }),
        )
        return
      }

      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result =
        body.method === 'eth_blockNumber'
          ? '0x100'
          : {
              blockNumber: '0x80',
              logs: [
                hash === sourceTransactionHash
                  ? transferLog({
                      amount: 1_000_000n,
                      recipient: depositAddress,
                      sender: `0x${'aa'.repeat(20)}`,
                      token: route.sourceToken.address,
                    })
                  : transferLog({
                      amount: 1_000_000n,
                      recipient: route.recipient,
                      sender: `0x${'bb'.repeat(20)}`,
                      token: route.destinationToken.address,
                    }),
              ],
              status: '0x1',
            }
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source',
          },
        ],
        routes: [],
        tokens: [],
      })
      const provider = Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })
      let trackerNow = new Date('2026-01-02T00:03:10.000Z')
      const tracker = Reconciliation.createTracker({
        db,
        dispatch: async (...parameters) => {
          if (dispatchFailure) {
            dispatchFailure = false
            throw new Error('Reconciliation queue unavailable.')
          }
          dispatches.push(parameters)
        },
        metrics,
        now: () => trackerNow,
        providers: [provider],
        verifyTransfers: Evidence.createVerifier({ db }),
      })

      const message = {
        addressId: address.id,
        requestId: 'relay-pending-request',
        trigger: 'webhook',
        type: 'funding:deposit-address:reconcile',
        webhookTiming: {
          enqueuedAt: '2026-01-02T00:03:07.000Z',
          providerStatus: 'pending',
          providerUpdatedAt: '2026-01-02T00:03:00.000Z',
          receivedAt: '2026-01-02T00:03:06.000Z',
          sentAt: '2026-01-02T00:03:05.000Z',
        },
      } satisfies Provider.Webhook.receive.Dispatchable
      await expect(tracker.reconcile(message)).rejects.toThrowErrorMatchingInlineSnapshot(
        `[Error: Reconciliation queue unavailable.]`,
      )
      const pending = await tracker.reconcile(message)
      const [firstFollowUp] = dispatches
      if (!firstFollowUp) throw new Error('Expected a provider follow-up message.')
      indexed = true
      const pendingFollowUp = await tracker.reconcile(firstFollowUp[0])
      const exhausted = await tracker.reconcile({
        ...firstFollowUp[0],
        followUp: { attempt: 5, kind: 'provider' },
      })
      const [, secondFollowUp] = dispatches
      if (!secondFollowUp) throw new Error('Expected a second provider follow-up message.')
      delivered = true
      includeAddressRequest = false
      providerUpdateVisible = true
      trackerNow = new Date('2026-01-02T00:03:15.000Z')
      const completed = await tracker.reconcile(secondFollowUp[0])
      includeAddressRequest = true
      const replay = await tracker.reconcile({
        addressId: address.id,
        trigger: 'webhook',
        type: 'funding:deposit-address:reconcile',
      })
      includeAddressRequest = false
      returnOlderDirect = true
      const webhook = await tracker.reconcile({
        addressId: address.id,
        requestId: 'relay-pending-request',
        trigger: 'webhook',
        type: 'funding:deposit-address:reconcile',
      })
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })
      const storedAddress = await FundingDepositAddresses.get(db, address.id)

      expect({
        completed,
        counts,
        dispatches,
        exhausted,
        histograms,
        pending,
        pendingFollowUp,
        record,
        replay,
        requestTargets,
        storedAddress,
        webhook,
      }).toMatchInlineSnapshot(
        {
          dispatches: [
            [{ addressId: expect.any(String) }, { delaySeconds: 5 }],
            [{ addressId: expect.any(String) }, { delaySeconds: 5 }],
          ],
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
          storedAddress: {
            id: expect.any(String),
            providerOutputToken: expect.any(Object),
            snapshot: expect.any(Object),
          },
        },
        `
        {
          "completed": {
            "created": 0,
            "type": "completed",
            "updated": 1,
          },
          "counts": [
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_enqueue_failed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "failed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_enqueued",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_detection_count",
              1,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_enqueued",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_exhausted",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
          ],
          "dispatches": [
            [
              {
                "addressId": Any<String>,
                "followUp": {
                  "attempt": 0,
                  "kind": "provider",
                },
                "requestId": "relay-pending-request",
                "trigger": "webhook",
                "type": "funding:deposit-address:reconcile",
                "webhookTiming": {
                  "enqueuedAt": "2026-01-02T00:03:07.000Z",
                  "providerStatus": "pending",
                  "providerUpdatedAt": "2026-01-02T00:03:00.000Z",
                  "receivedAt": "2026-01-02T00:03:06.000Z",
                  "sentAt": "2026-01-02T00:03:05.000Z",
                },
              },
              {
                "delaySeconds": 5,
              },
            ],
            [
              {
                "addressId": Any<String>,
                "followUp": {
                  "attempt": 1,
                  "kind": "provider",
                },
                "requestId": "relay-pending-request",
                "trigger": "webhook",
                "type": "funding:deposit-address:reconcile",
                "webhookTiming": {
                  "enqueuedAt": "2026-01-02T00:03:07.000Z",
                  "providerStatus": "pending",
                  "providerUpdatedAt": "2026-01-02T00:03:00.000Z",
                  "receivedAt": "2026-01-02T00:03:06.000Z",
                  "sentAt": "2026-01-02T00:03:05.000Z",
                },
              },
              {
                "delaySeconds": 5,
              },
            ],
          ],
          "exhausted": {
            "created": 0,
            "type": "completed",
            "updated": 1,
          },
          "histograms": [
            [
              "funding_deposit_reconciliation_duration_ms",
              0,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_duration_ms",
              0,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_duration_ms",
              0,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_webhook_latency_ms",
              5000,
              {
                "provider": "relay",
                "segment": "provider_to_sent",
                "status": "pending",
              },
            ],
            [
              "funding_deposit_webhook_latency_ms",
              1000,
              {
                "provider": "relay",
                "segment": "sent_to_received",
                "status": "pending",
              },
            ],
            [
              "funding_deposit_webhook_latency_ms",
              1000,
              {
                "provider": "relay",
                "segment": "received_to_enqueued",
                "status": "pending",
              },
            ],
            [
              "funding_deposit_webhook_latency_ms",
              8000,
              {
                "provider": "relay",
                "segment": "enqueued_to_reconciled",
                "status": "pending",
              },
            ],
            [
              "funding_deposit_webhook_latency_ms",
              15000,
              {
                "provider": "relay",
                "segment": "provider_to_reconciled",
                "status": "pending",
              },
            ],
            [
              "funding_deposit_reconciliation_duration_ms",
              0,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_duration_ms",
              0,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
            [
              "funding_deposit_reconciliation_duration_ms",
              0,
              {
                "provider": "relay",
                "trigger": "webhook",
              },
            ],
          ],
          "pending": {
            "created": 0,
            "type": "completed",
            "updated": 0,
          },
          "pendingFollowUp": {
            "created": 1,
            "type": "completed",
            "updated": 1,
          },
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "webhook",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_pending_reconciliation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": {
              "baseUnits": "1000000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "1",
            },
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "relay-pending-request",
            "providerRequestIds": [
              "relay-pending-request",
            ],
            "providerState": null,
            "providerTransactionHashes": [
              "0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
            ],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "destinationAmountRequired": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "destinationTransactionHashes": [
                "0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
              ],
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x9999999999999999999999999999999999999999",
              "sender": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
            "sourceTransferIndex": 0,
            "status": "completed",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 7,
            "webhookReceivedAt": null,
          },
          "replay": {
            "created": 0,
            "type": "completed",
            "updated": 0,
          },
          "requestTargets": [
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?id=relay-pending-request&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?id=relay-pending-request&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?id=relay-pending-request&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
            "/requests/v3?id=relay-pending-request&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
          ],
          "storedAddress": {
            "address": "0x8888888888888888888888888888888888888888",
            "apiKeyId": "key_pending_reconciliation",
            "createdAt": "2026-01-02T00:00:00.000Z",
            "deliveryStrategy": "provider",
            "destinationTokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
            "environment": "production",
            "id": Any<String>,
            "lastPolledAt": "2026-01-02T00:03:15.000Z",
            "nextPollAt": "2026-01-02T00:04:15.000Z",
            "orgId": "org_pending_reconciliation",
            "pollFailureCount": 0,
            "pollLeaseUntil": null,
            "pollLeaseVersion": 7,
            "projectId": null,
            "providerId": "relay",
            "providerOutputToken": Any<Object>,
            "providerRequestIds": [],
            "providerState": {
              "reconciliation": {
                "pendingRequestIds": [],
                "requestIds": [
                  "relay-pending-request",
                ],
                "updatedAt": "2026-01-02T00:03:00.500Z",
                "webhookTiming": {
                  "enqueuedAt": "2026-01-02T00:03:07.000Z",
                  "providerStatus": "pending",
                  "providerUpdatedAt": "2026-01-02T00:03:00.000Z",
                  "receivedAt": "2026-01-02T00:03:06.000Z",
                  "reconciliationCompletedAt": "2026-01-02T00:03:15.000Z",
                  "requestId": "relay-pending-request",
                  "sentAt": "2026-01-02T00:03:05.000Z",
                },
              },
            },
            "recipient": "0x1111111111111111111111111111111111111111",
            "refundAddress": "0x9999999999999999999999999999999999999999",
            "snapshot": Any<Object>,
            "sourceChainId": "eip155:8453",
            "sourceTokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
            "status": "active",
            "subsidize": false,
            "updatedAt": "2026-01-02T00:00:00.000Z",
            "version": 1,
          },
          "webhook": {
            "created": 0,
            "type": "completed",
            "updated": 0,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('completes chain-detected Relay delivery before provider attribution', async () => {
    const route = TestFunding.transferSnapshot()
    const ambiguousOrderId = `0x${'3d'.repeat(32)}`
    const ambiguousSweepTransactionHash = `0x${'3e'.repeat(32)}`
    const depositAddress = `0x${'31'.repeat(20)}`
    const depository = `0x${'32'.repeat(20)}`
    const destinationTransactionHash = `0x${'33'.repeat(32)}`
    const orderId = `0x${'34'.repeat(32)}`
    const refundAddress = `0x${'38'.repeat(20)}`
    const solver = `0x${'35'.repeat(20)}`
    const sourceSweepTransactionHash = `0x${'36'.repeat(32)}`
    const sourceTransactionHash = `0x${'37'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_delivery_observation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-04T00:00:00.000Z'),
      orgId: 'org_delivery_observation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: true,
      },
    })
    const counts: Parameters<Metrics.Metrics['count']>[] = []
    const dispatches: Parameters<Reconciliation.createTracker.Options['dispatch']>[] = []
    const metrics = Metrics.from({
      count(...parameters) {
        counts.push(parameters)
      },
      flush() {},
      gauge() {},
      histogram() {},
    })
    const rpcMethods: string[] = []
    let ambiguous = true
    let correlateDestination = false
    let delivered = false
    let indexed = false
    const server = await TestRelay.createServer(async (request, response) => {
      if (request.method === 'GET') {
        const url = new URL(request.url ?? '/', server.url)
        response.writeHead(200, { 'content-type': 'application/json' })
        response.end(
          JSON.stringify(
            url.pathname === '/chains'
              ? {
                  chains: [
                    {
                      id: Number(route.sourceChain.id.slice('eip155:'.length)),
                      protocol: { v2: { depository } },
                      solverAddresses: [],
                    },
                    {
                      id: Number(route.destinationChain.id.slice('eip155:'.length)),
                      solverAddresses: [solver],
                    },
                  ],
                }
              : {
                  requests: indexed
                    ? [
                        {
                          createdAt: '2026-01-04T00:01:00.000Z',
                          data: { outTxs: [] },
                          depositAddress: { depositTxHash: sourceTransactionHash },
                          id: 'relay-observed-request',
                          protocol: {
                            deposit: { origin: { depositor: refundAddress, depository } },
                            orderId,
                            solver: { address: solver },
                          },
                          status: 'pending',
                          updatedAt: '2026-01-04T00:02:00.000Z',
                        },
                      ]
                    : [],
                },
          ),
        )
        return
      }

      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly unknown[] | undefined
      }
      rpcMethods.push(body.method)
      const parameter = body.params?.[0]
      const result = (() => {
        if (body.method === 'eth_blockNumber') return '0x100'
        if (body.method === 'eth_getTransactionByHash')
          return parameter === destinationTransactionHash
            ? rpcTransaction({
                blockNumber: 0xf0,
                from: solver,
                hash: destinationTransactionHash,
                input: (() => {
                  const input = AbiFunction.encodeData(
                    AbiFunction.from('function transfer(address recipient,uint256 amount)'),
                    [route.recipient as Address.Address, 1_000_000n],
                  )
                  if (!correlateDestination) return input
                  return Hex.concat(input, orderId as Hex.Hex)
                })(),
                to: route.destinationToken.address,
              })
            : rpcTransaction({
                blockNumber: 0x82,
                from: depositAddress,
                hash:
                  parameter === sourceSweepTransactionHash
                    ? sourceSweepTransactionHash
                    : ambiguousSweepTransactionHash,
                input: (() => {
                  if (parameter === sourceSweepTransactionHash)
                    return AbiFunction.encodeData(
                      AbiFunction.from(
                        'function depositErc20(address depositor,address token,bytes32 id)',
                      ),
                      [
                        refundAddress as Address.Address,
                        route.sourceToken.address as Address.Address,
                        orderId as Hex.Hex,
                      ],
                    )
                  return AbiFunction.encodeData(
                    AbiFunction.from(
                      'function depositErc20(address depositor,address token,uint256 amount,bytes32 id)',
                    ),
                    [
                      refundAddress as Address.Address,
                      route.sourceToken.address as Address.Address,
                      1_000_000n,
                      ambiguousOrderId as Hex.Hex,
                    ],
                  )
                })(),
                to: depository,
              })
        if (body.method === 'eth_getLogs') {
          const filter = parameter as { address?: string | undefined }
          if (filter.address?.toLowerCase() === depository.toLowerCase())
            return [
              ...(ambiguous
                ? [
                    relayDepositLog({
                      amount: 1_000_000n,
                      blockNumber: 0x81,
                      depository,
                      from: refundAddress,
                      orderId: ambiguousOrderId,
                      token: route.sourceToken.address,
                      transactionHash: ambiguousSweepTransactionHash,
                    }),
                  ]
                : []),
              relayDepositLog({
                amount: 1_000_000n,
                blockNumber: 0x82,
                depository,
                from: refundAddress,
                orderId,
                token: route.sourceToken.address,
                transactionHash: sourceSweepTransactionHash,
              }),
            ]
          if (delivered)
            return [
              transferLog({
                amount: 1_000_000n,
                blockNumber: 0xf0,
                recipient: route.recipient,
                sender: solver,
                token: route.destinationToken.address,
                transactionHash: destinationTransactionHash,
              }),
            ]
          return []
        }
        if (body.method === 'eth_getTransactionReceipt') {
          const hash = parameter
          return {
            blockNumber: hash === sourceTransactionHash ? '0x80' : '0xf0',
            logs: [
              hash === sourceTransactionHash
                ? transferLog({
                    amount: 1_000_000n,
                    recipient: depositAddress,
                    sender: `0x${'3c'.repeat(20)}`,
                    token: route.sourceToken.address,
                  })
                : transferLog({
                    amount: 1_000_000n,
                    recipient: route.recipient,
                    sender: solver,
                    token: route.destinationToken.address,
                  }),
            ],
            status: '0x1',
          }
        }
        throw new Error(`Unexpected RPC method: ${body.method}`)
      })()
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source',
          },
        ],
        routes: [],
        tokens: [],
      })
      const provider = Relay.relay({
        apiKey: 'relay-api-key',
        baseUrl: server.url,
        now: () => new Date('2026-01-04T00:03:00.000Z'),
        observation: { db },
      })
      if (!Provider.canObserveDepositAddressRequest(provider))
        throw new Error('Expected Relay delivery observation.')
      const ambiguousObservation = await provider.observeDepositAddressRequest(
        {
          address: depositAddress,
          destinationChain: route.destinationChain,
          destinationToken: route.destinationToken,
          recipient: route.recipient,
          refundAddress,
          source: { amount: '1000000', transactionHash: sourceTransactionHash },
          sourceChain: route.sourceChain,
          sourceToken: route.sourceToken,
        },
        new AbortController().signal,
      )
      ambiguous = false
      delivered = true
      const uncorrelatedObservation = await provider.observeDepositAddressRequest(
        {
          address: depositAddress,
          destinationChain: route.destinationChain,
          destinationToken: route.destinationToken,
          recipient: route.recipient,
          refundAddress,
          source: { amount: '1000000', transactionHash: sourceTransactionHash },
          sourceChain: route.sourceChain,
          sourceToken: route.sourceToken,
        },
        new AbortController().signal,
      )
      correlateDestination = true
      delivered = false
      const observed = await SourceObservation.observe(db, {
        addressId: address.id,
        amount: '1000000',
        chainId: route.sourceChain.id,
        now: new Date('2026-01-04T00:00:30.000Z'),
        recipient: depositAddress,
        sender: refundAddress,
        tokenAddress: route.sourceToken.address,
        transactionHash: sourceTransactionHash,
        transferIndex: 0,
      })
      if (observed.type === 'ignored') throw new Error('Expected source observation.')
      const tracker = Reconciliation.createTracker({
        db,
        dispatch: async (...parameters) => {
          dispatches.push(parameters)
        },
        metrics,
        now: () => new Date('2026-01-04T00:03:00.000Z'),
        providers: [provider],
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const pending = await tracker.reconcile({
        addressId: address.id,
        trigger: 'chain',
        type: 'funding:deposit-address:reconcile',
      })
      const [deliveryFollowUp] = dispatches
      if (!deliveryFollowUp) throw new Error('Expected a delivery follow-up message.')
      delivered = true
      const completed = await tracker.reconcile(deliveryFollowUp[0])
      const completedRecord = await FundingDeposits.get(db, observed.record.id)
      const [, providerFollowUp] = dispatches
      if (!providerFollowUp) throw new Error('Expected a provider follow-up message.')
      indexed = true
      const attributed = await tracker.reconcile(providerFollowUp[0])
      const [record] = await FundingDeposits.listBySourceTransaction(db, {
        depositAddressId: address.id,
        sourceTransactionHash,
      })

      expect({
        ambiguousObservation,
        attributed,
        completed,
        completedRecord,
        counts,
        dispatches: dispatches.map(([message, dispatchOptions]) => [
          { ...message, addressId: '<address-id>' },
          dispatchOptions,
        ]),
        pending,
        record,
        rpcMethods,
        sourceObservation: observed.type,
        uncorrelatedObservation,
      }).toMatchInlineSnapshot(
        {
          record: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
          completedRecord: {
            createdAt: expect.any(String),
            depositAddressId: expect.any(String),
            id: expect.any(String),
            snapshot: { depositAddressId: expect.any(String) },
            updatedAt: expect.any(String),
          },
        },
        `
        {
          "ambiguousObservation": {
            "type": "pending",
          },
          "attributed": {
            "created": 0,
            "type": "completed",
            "updated": 1,
          },
          "completed": {
            "created": 0,
            "type": "completed",
            "updated": 1,
          },
          "completedRecord": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "chain",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_delivery_observation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": {
              "baseUnits": "1000000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "1",
            },
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": null,
            "providerRequestIds": [],
            "providerState": {
              "relay": {
                "destinationObservedAt": "2026-01-04T00:03:00.000Z",
                "orderId": "0x3434343434343434343434343434343434343434343434343434343434343434",
                "sourceDepository": "0x3232323232323232323232323232323232323232",
                "sourceObservedAt": "2026-01-04T00:03:00.000Z",
                "sourceSweepTransactionHash": "0x3636363636363636363636363636363636363636363636363636363636363636",
              },
            },
            "providerTransactionHashes": [
              "0x3636363636363636363636363636363636363636363636363636363636363636",
              "0x3333333333333333333333333333333333333333333333333333333333333333",
            ],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "destinationTransactionHashes": [
                "0x3333333333333333333333333333333333333333333333333333333333333333",
              ],
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x3838383838383838383838383838383838383838",
              "sender": "0x3838383838383838383838383838383838383838",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0x3737373737373737373737373737373737373737373737373737373737373737",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0x3737373737373737373737373737373737373737373737373737373737373737",
            "sourceTransferIndex": 0,
            "status": "completed",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 3,
            "webhookReceivedAt": null,
          },
          "counts": [
            [
              "funding_deposit_delivery_observation_count",
              1,
              {
                "outcome": "pending",
                "provider": "relay",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_enqueued",
                "provider": "relay",
                "trigger": "chain",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "chain",
              },
            ],
            [
              "funding_deposit_delivery_observation_count",
              1,
              {
                "outcome": "verified",
                "provider": "relay",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "follow_up_enqueued",
                "provider": "relay",
                "trigger": "chain",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "chain",
              },
            ],
            [
              "funding_deposit_reconciliation_count",
              1,
              {
                "outcome": "completed",
                "provider": "relay",
                "trigger": "chain",
              },
            ],
          ],
          "dispatches": [
            [
              {
                "addressId": "<address-id>",
                "followUp": {
                  "attempt": 0,
                  "kind": "delivery",
                },
                "trigger": "chain",
                "type": "funding:deposit-address:reconcile",
              },
              {
                "delaySeconds": 1,
              },
            ],
            [
              {
                "addressId": "<address-id>",
                "followUp": {
                  "attempt": 0,
                  "kind": "provider",
                },
                "trigger": "chain",
                "type": "funding:deposit-address:reconcile",
              },
              {
                "delaySeconds": 1,
              },
            ],
          ],
          "pending": {
            "created": 0,
            "type": "completed",
            "updated": 1,
          },
          "record": {
            "createdAt": Any<String>,
            "depositAddressId": Any<String>,
            "detectionTrigger": "chain",
            "environment": "production",
            "id": Any<String>,
            "orgId": "org_delivery_observation",
            "pollObservedAt": null,
            "projectId": null,
            "providerOutputAmount": {
              "baseUnits": "1000000",
              "currency": "USD",
              "decimals": 6,
              "formatted": "1",
            },
            "providerOutputToken": {
              "address": "0x20c000000000000000000000b9537d11c60e8b50",
              "currency": "USD",
              "decimals": 6,
              "name": "Bridged USDC (Stargate)",
              "standard": "TIP-20",
              "symbol": "USDC.e",
              "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
              "verified": true,
            },
            "providerRequestId": "relay-observed-request",
            "providerRequestIds": [
              "relay-observed-request",
            ],
            "providerState": {
              "relay": {
                "destinationObservedAt": "2026-01-04T00:03:00.000Z",
                "orderId": "0x3434343434343434343434343434343434343434343434343434343434343434",
                "sourceDepository": "0x3232323232323232323232323232323232323232",
                "sourceObservedAt": "2026-01-04T00:03:00.000Z",
                "sourceSweepTransactionHash": "0x3636363636363636363636363636363636363636363636363636363636363636",
              },
            },
            "providerTransactionHashes": [
              "0x3636363636363636363636363636363636363636363636363636363636363636",
              "0x3333333333333333333333333333333333333333333333333333333333333333",
            ],
            "providerTransferIndex": 0,
            "retryState": null,
            "settlementTransaction": null,
            "settlementTransactionHash": null,
            "snapshot": {
              "depositAddressId": Any<String>,
              "destinationAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "destinationAmountRequired": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "destinationChain": {
                "addressFormat": "hex",
                "id": "eip155:4217",
                "kind": "evm",
                "name": "Tempo",
              },
              "destinationToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "destinationTransactionHashes": [
                "0x3333333333333333333333333333333333333333333333333333333333333333",
              ],
              "provider": {
                "id": "relay",
                "name": "Relay",
              },
              "recipient": "0x1111111111111111111111111111111111111111",
              "refundAddress": "0x3838383838383838383838383838383838383838",
              "sender": "0x3838383838383838383838383838383838383838",
              "sourceAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "sourceChain": {
                "addressFormat": "hex",
                "id": "eip155:8453",
                "kind": "evm",
                "name": "Base",
              },
              "sourceToken": {
                "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "currency": "USD",
                "decimals": 6,
                "name": "USD Coin",
                "standard": "ERC-20",
                "symbol": "USDC",
                "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                "verified": true,
              },
              "sourceTransactionHashes": [
                "0x3737373737373737373737373737373737373737373737373737373737373737",
              ],
            },
            "sourceChainId": "eip155:8453",
            "sourceTransactionHash": "0x3737373737373737373737373737373737373737373737373737373737373737",
            "sourceTransferIndex": 0,
            "status": "completed",
            "statusReason": null,
            "subsidyAmount": null,
            "tempoGasPaid": null,
            "updatedAt": Any<String>,
            "version": 4,
            "webhookReceivedAt": null,
          },
          "rpcMethods": [
            "eth_getTransactionReceipt",
            "eth_blockNumber",
            "eth_getLogs",
            "eth_getTransactionByHash",
            "eth_getTransactionByHash",
            "eth_getTransactionReceipt",
            "eth_blockNumber",
            "eth_getLogs",
            "eth_getTransactionByHash",
            "eth_blockNumber",
            "eth_getLogs",
            "eth_getTransactionByHash",
            "eth_getTransactionReceipt",
            "eth_blockNumber",
            "eth_getTransactionReceipt",
            "eth_blockNumber",
            "eth_getLogs",
            "eth_getTransactionByHash",
            "eth_blockNumber",
            "eth_getLogs",
            "eth_getTransactionReceipt",
            "eth_blockNumber",
            "eth_blockNumber",
            "eth_getLogs",
            "eth_getTransactionByHash",
            "eth_getTransactionReceipt",
            "eth_blockNumber",
            "eth_getTransactionReceipt",
            "eth_blockNumber",
          ],
          "sourceObservation": "created",
          "uncorrelatedObservation": {
            "providerState": {
              "relay": {
                "orderId": "0x3434343434343434343434343434343434343434343434343434343434343434",
                "sourceDepository": "0x3232323232323232323232323232323232323232",
                "sourceObservedAt": "2026-01-04T00:03:00.000Z",
                "sourceSweepTransactionHash": "0x3636363636363636363636363636363636363636363636363636363636363636",
              },
            },
            "providerTransactionHashes": [
              "0x3636363636363636363636363636363636363636363636363636363636363636",
            ],
            "type": "pending",
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('renews the address lease during a slow provider read', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'16'.repeat(20)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_lease_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-04T00:00:00.000Z'),
      orgId: 'org_lease_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'17'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    const providerReleased = Promise.withResolvers<void>()
    const providerStarted = Promise.withResolvers<void>()
    const server = await TestRelay.createServer(async (request, response) => {
      if (request.method !== 'GET') throw new Error('Expected a Relay request read.')
      providerStarted.resolve()
      await providerReleased.promise
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ requests: [] }))
    })

    try {
      vi.useFakeTimers({ now: new Date('2027-01-04T00:00:00.000Z') })
      const tracker = Reconciliation.createTracker({
        db,
        dispatch: async () => undefined,
        leaseMs: 100,
        now: () => new Date(),
        providers: [Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })],
        verifyTransfers: Evidence.createVerifier({ db }),
      })

      const reconciliation = tracker.reconcile({
        addressId: address.id,
        trigger: 'webhook',
        type: 'funding:deposit-address:reconcile',
      })
      await providerStarted.promise
      await vi.advanceTimersByTimeAsync(60)
      const renewed = await FundingDepositAddresses.get(db, address.id)
      providerReleased.resolve()
      const result = await reconciliation
      const completed = await FundingDepositAddresses.get(db, address.id)

      expect({ completed, renewed, result }).toMatchInlineSnapshot(
        {
          completed: {
            id: expect.any(String),
            providerOutputToken: expect.any(Object),
            snapshot: expect.any(Object),
          },
          renewed: {
            id: expect.any(String),
            providerOutputToken: expect.any(Object),
            snapshot: expect.any(Object),
          },
        },
        `
        {
          "completed": {
            "address": "0x1616161616161616161616161616161616161616",
            "apiKeyId": "key_lease_reconciliation",
            "createdAt": "2026-01-04T00:00:00.000Z",
            "deliveryStrategy": "provider",
            "destinationTokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
            "environment": "production",
            "id": Any<String>,
            "lastPolledAt": "2027-01-04T00:00:00.060Z",
            "nextPollAt": "2027-01-04T00:01:00.060Z",
            "orgId": "org_lease_reconciliation",
            "pollFailureCount": 0,
            "pollLeaseUntil": null,
            "pollLeaseVersion": 1,
            "projectId": null,
            "providerId": "relay",
            "providerOutputToken": Any<Object>,
            "providerRequestIds": [],
            "providerState": {
              "reconciliation": {
                "pendingRequestIds": [],
                "requestIds": [],
              },
            },
            "recipient": "0x1111111111111111111111111111111111111111",
            "refundAddress": "0x1717171717171717171717171717171717171717",
            "snapshot": Any<Object>,
            "sourceChainId": "eip155:8453",
            "sourceTokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
            "status": "active",
            "subsidize": false,
            "updatedAt": "2026-01-04T00:00:00.000Z",
            "version": 1,
          },
          "renewed": {
            "address": "0x1616161616161616161616161616161616161616",
            "apiKeyId": "key_lease_reconciliation",
            "createdAt": "2026-01-04T00:00:00.000Z",
            "deliveryStrategy": "provider",
            "destinationTokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
            "environment": "production",
            "id": Any<String>,
            "lastPolledAt": null,
            "nextPollAt": "2026-01-04T00:00:00.000Z",
            "orgId": "org_lease_reconciliation",
            "pollFailureCount": 0,
            "pollLeaseUntil": "2027-01-04T00:00:00.150Z",
            "pollLeaseVersion": 1,
            "projectId": null,
            "providerId": "relay",
            "providerOutputToken": Any<Object>,
            "providerRequestIds": [],
            "providerState": null,
            "recipient": "0x1111111111111111111111111111111111111111",
            "refundAddress": "0x1717171717171717171717171717171717171717",
            "snapshot": Any<Object>,
            "sourceChainId": "eip155:8453",
            "sourceTokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
            "status": "active",
            "subsidize": false,
            "updatedAt": "2026-01-04T00:00:00.000Z",
            "version": 1,
          },
          "result": {
            "created": 0,
            "type": "completed",
            "updated": 0,
          },
        }
      `,
      )
    } finally {
      providerReleased.resolve()
      vi.useRealTimers()
      await server.closeAsync()
    }
  })

  test('waits for every source transaction before allocating provider output', async () => {
    const route = TestFunding.transferSnapshot()
    const depositAddress = `0x${'21'.repeat(20)}`
    const firstSourceTransactionHash = `0x${'31'.repeat(32)}`
    const secondSourceTransactionHash = `0x${'32'.repeat(32)}`
    const destinationTransactionHash = `0x${'33'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_source_evidence_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-05T00:00:00.000Z'),
      orgId: 'org_source_evidence_reconciliation',
      providerOutputToken: route.destinationToken,
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'local', name: 'Local' },
        recipient: route.recipient,
        refundAddress: `0x${'22'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken: route.sourceToken,
        subsidize: false,
      },
    })
    let destinationReceiptReads = 0
    const server = await TestRelay.createServer(async (request, response) => {
      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result = (() => {
        if (body.method === 'eth_blockNumber') return '0x100'
        if (hash === secondSourceTransactionHash) return null
        const source = hash === firstSourceTransactionHash
        if (!source) destinationReceiptReads += 1
        return {
          blockNumber: '0x80',
          logs: [
            transferLog({
              amount: source ? 1_000_000n : 3_000_000n,
              recipient: source ? depositAddress : route.recipient,
              sender: `0x${'23'.repeat(20)}`,
              token: source ? route.sourceToken.address : route.destinationToken.address,
            }),
          ],
          status: '0x1',
        }
      })()
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination-source-evidence',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source-source-evidence',
          },
        ],
        routes: [],
        tokens: [],
      })
      const result = await Reconciliation.reconcileRequest(db, {
        address,
        request: {
          createdAt: '2026-01-05T00:01:00.000Z',
          destinationTransactionHashes: [destinationTransactionHash],
          id: 'source-evidence-request',
          refundTransactionHashes: [],
          sourceTransactionHashes: [firstSourceTransactionHash, secondSourceTransactionHash],
          status: 'success',
          updatedAt: '2026-01-05T00:02:00.000Z',
        },
        verifyTransfers: Evidence.createVerifier({ db }),
      })
      const records = (
        await FundingDeposits.listByAddress(
          db,
          { environment: 'production', orgId: 'org_source_evidence_reconciliation' },
          address.id,
          { limit: 10 },
        )
      ).toSorted((left, right) =>
        left.sourceTransactionHash.localeCompare(right.sourceTransactionHash),
      )

      expect({ destinationReceiptReads, records, result }).toMatchInlineSnapshot(
        {
          records: [
            {
              createdAt: expect.any(String),
              depositAddressId: expect.any(String),
              id: expect.any(String),
              snapshot: { depositAddressId: expect.any(String) },
              updatedAt: expect.any(String),
            },
            {
              createdAt: expect.any(String),
              depositAddressId: expect.any(String),
              id: expect.any(String),
              snapshot: { depositAddressId: expect.any(String) },
              updatedAt: expect.any(String),
            },
          ],
        },
        `
        {
          "destinationReceiptReads": 0,
          "records": [
            {
              "createdAt": Any<String>,
              "depositAddressId": Any<String>,
              "detectionTrigger": "poll",
              "environment": "production",
              "id": Any<String>,
              "orgId": "org_source_evidence_reconciliation",
              "pollObservedAt": null,
              "projectId": null,
              "providerOutputAmount": null,
              "providerOutputToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "providerRequestId": "source-evidence-request",
              "providerRequestIds": [
                "source-evidence-request",
              ],
              "providerState": null,
              "providerTransactionHashes": [],
              "providerTransferIndex": 0,
              "retryState": null,
              "settlementTransaction": null,
              "settlementTransactionHash": null,
              "snapshot": {
                "depositAddressId": Any<String>,
                "destinationChain": {
                  "addressFormat": "hex",
                  "id": "eip155:4217",
                  "kind": "evm",
                  "name": "Tempo",
                },
                "destinationToken": {
                  "address": "0x20c000000000000000000000b9537d11c60e8b50",
                  "currency": "USD",
                  "decimals": 6,
                  "name": "Bridged USDC (Stargate)",
                  "standard": "TIP-20",
                  "symbol": "USDC.e",
                  "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                  "verified": true,
                },
                "provider": {
                  "id": "local",
                  "name": "Local",
                },
                "recipient": "0x1111111111111111111111111111111111111111",
                "refundAddress": "0x2222222222222222222222222222222222222222",
                "sender": "0x2323232323232323232323232323232323232323",
                "sourceAmount": {
                  "baseUnits": "1000000",
                  "currency": "USD",
                  "decimals": 6,
                  "formatted": "1",
                },
                "sourceChain": {
                  "addressFormat": "hex",
                  "id": "eip155:8453",
                  "kind": "evm",
                  "name": "Base",
                },
                "sourceToken": {
                  "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "currency": "USD",
                  "decimals": 6,
                  "name": "USD Coin",
                  "standard": "ERC-20",
                  "symbol": "USDC",
                  "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "verified": true,
                },
                "sourceTransactionHashes": [
                  "0x3131313131313131313131313131313131313131313131313131313131313131",
                ],
              },
              "sourceChainId": "eip155:8453",
              "sourceTransactionHash": "0x3131313131313131313131313131313131313131313131313131313131313131",
              "sourceTransferIndex": 0,
              "status": "bridging",
              "statusReason": null,
              "subsidyAmount": null,
              "tempoGasPaid": null,
              "updatedAt": Any<String>,
              "version": 2,
              "webhookReceivedAt": null,
            },
            {
              "createdAt": Any<String>,
              "depositAddressId": Any<String>,
              "detectionTrigger": "poll",
              "environment": "production",
              "id": Any<String>,
              "orgId": "org_source_evidence_reconciliation",
              "pollObservedAt": null,
              "projectId": null,
              "providerOutputAmount": null,
              "providerOutputToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "providerRequestId": "source-evidence-request",
              "providerRequestIds": [
                "source-evidence-request",
              ],
              "providerState": null,
              "providerTransactionHashes": [],
              "providerTransferIndex": 0,
              "retryState": null,
              "settlementTransaction": null,
              "settlementTransactionHash": null,
              "snapshot": {
                "depositAddressId": Any<String>,
                "destinationChain": {
                  "addressFormat": "hex",
                  "id": "eip155:4217",
                  "kind": "evm",
                  "name": "Tempo",
                },
                "destinationToken": {
                  "address": "0x20c000000000000000000000b9537d11c60e8b50",
                  "currency": "USD",
                  "decimals": 6,
                  "name": "Bridged USDC (Stargate)",
                  "standard": "TIP-20",
                  "symbol": "USDC.e",
                  "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                  "verified": true,
                },
                "provider": {
                  "id": "local",
                  "name": "Local",
                },
                "recipient": "0x1111111111111111111111111111111111111111",
                "refundAddress": "0x2222222222222222222222222222222222222222",
                "sourceChain": {
                  "addressFormat": "hex",
                  "id": "eip155:8453",
                  "kind": "evm",
                  "name": "Base",
                },
                "sourceToken": {
                  "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "currency": "USD",
                  "decimals": 6,
                  "name": "USD Coin",
                  "standard": "ERC-20",
                  "symbol": "USDC",
                  "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "verified": true,
                },
                "sourceTransactionHashes": [
                  "0x3232323232323232323232323232323232323232323232323232323232323232",
                ],
              },
              "sourceChainId": "eip155:8453",
              "sourceTransactionHash": "0x3232323232323232323232323232323232323232323232323232323232323232",
              "sourceTransferIndex": null,
              "status": "detected",
              "statusReason": null,
              "subsidyAmount": null,
              "tempoGasPaid": null,
              "updatedAt": Any<String>,
              "version": 1,
              "webhookReceivedAt": null,
            },
          ],
          "result": {
            "created": 2,
            "terminal": false,
            "updated": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })

  test('records multiple source transfers with finer precision independently', async () => {
    const route = TestFunding.transferSnapshot()
    const sourceToken = { ...route.sourceToken, decimals: 18 }
    const depositAddress = `0x${'12'.repeat(20)}`
    const sourceTransactionHash = `0x${'ee'.repeat(32)}`
    const destinationTransactionHash = `0x${'ff'.repeat(32)}`
    const address = await DepositAddress.create(db, {
      apiKeyId: 'key_precision_reconciliation',
      deliveryStrategy: 'provider',
      environment: 'production',
      now: new Date('2026-01-03T00:00:00.000Z'),
      orgId: 'org_precision_reconciliation',
      providerOutputToken: route.destinationToken,
      providerRequestIds: ['relay-address-request'],
      snapshot: {
        address: depositAddress,
        destinationChain: route.destinationChain,
        destinationToken: route.destinationToken,
        provider: { id: 'relay', name: 'Relay' },
        recipient: route.recipient,
        refundAddress: `0x${'13'.repeat(20)}`,
        sourceChain: route.sourceChain,
        sourceToken,
        subsidize: false,
      },
    })
    const server = await TestRelay.createServer(async (request, response) => {
      if (request.method === 'GET') {
        response.writeHead(200, { 'content-type': 'application/json' })
        response.end(
          JSON.stringify({
            requests: [
              {
                createdAt: '2026-01-03T00:01:00.000Z',
                data: {
                  inTxs: [{ txHash: sourceTransactionHash }],
                  outTxs: [{ txHash: destinationTransactionHash }],
                },
                depositAddress: { depositTxHash: sourceTransactionHash },
                id: 'relay-multiple-transfer-request',
                status: 'success',
                updatedAt: '2026-01-03T00:02:00.000Z',
              },
            ],
          }),
        )
        return
      }

      const chunks: Uint8Array[] = []
      for await (const chunk of request) chunks.push(chunk)
      const body = JSON.parse(NodeBuffer.Buffer.concat(chunks).toString()) as {
        id: number
        method: string
        params?: readonly string[] | undefined
      }
      const hash = body.params?.[0]
      const result =
        body.method === 'eth_blockNumber'
          ? '0x100'
          : {
              blockNumber: '0x80',
              logs:
                hash === sourceTransactionHash
                  ? [
                      transferLog({
                        amount: 1_000_000_000_000_000_001n,
                        logIndex: 0,
                        recipient: depositAddress,
                        sender: `0x${'14'.repeat(20)}`,
                        token: sourceToken.address,
                      }),
                      transferLog({
                        amount: 2_000_000_000_000_000_001n,
                        logIndex: 1,
                        recipient: depositAddress,
                        sender: `0x${'14'.repeat(20)}`,
                        token: sourceToken.address,
                      }),
                    ]
                  : [
                      transferLog({
                        amount: 3_000_000n,
                        logIndex: 0,
                        recipient: route.recipient,
                        sender: `0x${'15'.repeat(20)}`,
                        token: route.destinationToken.address,
                      }),
                    ],
              status: '0x1',
            }
      response.writeHead(200, { 'content-type': 'application/json' })
      response.end(JSON.stringify({ id: body.id, jsonrpc: '2.0', result }))
    })

    try {
      await FundingCatalog.publish(db, {
        chainTokens: [],
        chains: [
          {
            aliases: [],
            id: route.destinationChain.id as Chain.Id,
            name: route.destinationChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'destination',
          },
          {
            aliases: [],
            id: route.sourceChain.id as Chain.Id,
            name: route.sourceChain.name,
            parentChainId: null,
            rpcUrls: [server.url],
            slug: 'source',
          },
        ],
        routes: [],
        tokens: [],
      })
      const tracker = Reconciliation.createTracker({
        db,
        dispatch: async () => undefined,
        now: () => new Date('2027-01-03T00:00:00.000Z'),
        providers: [Relay.relay({ apiKey: 'relay-api-key', baseUrl: server.url })],
        verifyTransfers: Evidence.createVerifier({ db }),
      })

      const result = await tracker.reconcile({
        addressId: address.id,
        trigger: 'webhook',
        type: 'funding:deposit-address:reconcile',
      })
      const records = (
        await FundingDeposits.listByAddress(
          db,
          { environment: 'production', orgId: 'org_precision_reconciliation' },
          address.id,
          { limit: 10 },
        )
      ).toSorted(
        (left, right) => (right.sourceTransferIndex ?? -1) - (left.sourceTransferIndex ?? -1),
      )
      const storedAddress = await FundingDepositAddresses.get(db, address.id)

      expect({ records, result, storedAddress }).toMatchInlineSnapshot(
        {
          records: [
            {
              createdAt: expect.any(String),
              depositAddressId: expect.any(String),
              id: expect.any(String),
              snapshot: { depositAddressId: expect.any(String) },
              updatedAt: expect.any(String),
            },
            {
              createdAt: expect.any(String),
              depositAddressId: expect.any(String),
              id: expect.any(String),
              snapshot: { depositAddressId: expect.any(String) },
              updatedAt: expect.any(String),
            },
          ],
          storedAddress: {
            id: expect.any(String),
            providerOutputToken: expect.any(Object),
            snapshot: expect.any(Object),
          },
        },
        `
        {
          "records": [
            {
              "createdAt": Any<String>,
              "depositAddressId": Any<String>,
              "detectionTrigger": "webhook",
              "environment": "production",
              "id": Any<String>,
              "orgId": "org_precision_reconciliation",
              "pollObservedAt": null,
              "projectId": null,
              "providerOutputAmount": {
                "baseUnits": "2000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "2",
              },
              "providerOutputToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "providerRequestId": "relay-multiple-transfer-request",
              "providerRequestIds": [
                "relay-multiple-transfer-request",
              ],
              "providerState": null,
              "providerTransactionHashes": [
                "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
              ],
              "providerTransferIndex": 1,
              "retryState": null,
              "settlementTransaction": null,
              "settlementTransactionHash": null,
              "snapshot": {
                "depositAddressId": Any<String>,
                "destinationAmount": {
                  "baseUnits": "2000000",
                  "currency": "USD",
                  "decimals": 6,
                  "formatted": "2",
                },
                "destinationAmountRequired": {
                  "baseUnits": "2000000",
                  "currency": "USD",
                  "decimals": 6,
                  "formatted": "2",
                },
                "destinationChain": {
                  "addressFormat": "hex",
                  "id": "eip155:4217",
                  "kind": "evm",
                  "name": "Tempo",
                },
                "destinationToken": {
                  "address": "0x20c000000000000000000000b9537d11c60e8b50",
                  "currency": "USD",
                  "decimals": 6,
                  "name": "Bridged USDC (Stargate)",
                  "standard": "TIP-20",
                  "symbol": "USDC.e",
                  "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                  "verified": true,
                },
                "destinationTransactionHashes": [
                  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
                ],
                "provider": {
                  "id": "relay",
                  "name": "Relay",
                },
                "recipient": "0x1111111111111111111111111111111111111111",
                "refundAddress": "0x1313131313131313131313131313131313131313",
                "sender": "0x1414141414141414141414141414141414141414",
                "sourceAmount": {
                  "baseUnits": "2000000000000000001",
                  "currency": "USD",
                  "decimals": 18,
                  "formatted": "2.000000000000000001",
                },
                "sourceChain": {
                  "addressFormat": "hex",
                  "id": "eip155:8453",
                  "kind": "evm",
                  "name": "Base",
                },
                "sourceToken": {
                  "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "currency": "USD",
                  "decimals": 18,
                  "name": "USD Coin",
                  "standard": "ERC-20",
                  "symbol": "USDC",
                  "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "verified": true,
                },
                "sourceTransactionHashes": [
                  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                ],
              },
              "sourceChainId": "eip155:8453",
              "sourceTransactionHash": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
              "sourceTransferIndex": 1,
              "status": "completed",
              "statusReason": null,
              "subsidyAmount": null,
              "tempoGasPaid": null,
              "updatedAt": Any<String>,
              "version": 3,
              "webhookReceivedAt": null,
            },
            {
              "createdAt": Any<String>,
              "depositAddressId": Any<String>,
              "detectionTrigger": "webhook",
              "environment": "production",
              "id": Any<String>,
              "orgId": "org_precision_reconciliation",
              "pollObservedAt": null,
              "projectId": null,
              "providerOutputAmount": {
                "baseUnits": "1000000",
                "currency": "USD",
                "decimals": 6,
                "formatted": "1",
              },
              "providerOutputToken": {
                "address": "0x20c000000000000000000000b9537d11c60e8b50",
                "currency": "USD",
                "decimals": 6,
                "name": "Bridged USDC (Stargate)",
                "standard": "TIP-20",
                "symbol": "USDC.e",
                "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                "verified": true,
              },
              "providerRequestId": "relay-multiple-transfer-request",
              "providerRequestIds": [
                "relay-multiple-transfer-request",
              ],
              "providerState": null,
              "providerTransactionHashes": [
                "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
              ],
              "providerTransferIndex": 0,
              "retryState": null,
              "settlementTransaction": null,
              "settlementTransactionHash": null,
              "snapshot": {
                "depositAddressId": Any<String>,
                "destinationAmount": {
                  "baseUnits": "1000000",
                  "currency": "USD",
                  "decimals": 6,
                  "formatted": "1",
                },
                "destinationAmountRequired": {
                  "baseUnits": "1000000",
                  "currency": "USD",
                  "decimals": 6,
                  "formatted": "1",
                },
                "destinationChain": {
                  "addressFormat": "hex",
                  "id": "eip155:4217",
                  "kind": "evm",
                  "name": "Tempo",
                },
                "destinationToken": {
                  "address": "0x20c000000000000000000000b9537d11c60e8b50",
                  "currency": "USD",
                  "decimals": 6,
                  "name": "Bridged USDC (Stargate)",
                  "standard": "TIP-20",
                  "symbol": "USDC.e",
                  "tokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
                  "verified": true,
                },
                "destinationTransactionHashes": [
                  "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
                ],
                "provider": {
                  "id": "relay",
                  "name": "Relay",
                },
                "recipient": "0x1111111111111111111111111111111111111111",
                "refundAddress": "0x1313131313131313131313131313131313131313",
                "sender": "0x1414141414141414141414141414141414141414",
                "sourceAmount": {
                  "baseUnits": "1000000000000000001",
                  "currency": "USD",
                  "decimals": 18,
                  "formatted": "1.000000000000000001",
                },
                "sourceChain": {
                  "addressFormat": "hex",
                  "id": "eip155:8453",
                  "kind": "evm",
                  "name": "Base",
                },
                "sourceToken": {
                  "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "currency": "USD",
                  "decimals": 18,
                  "name": "USD Coin",
                  "standard": "ERC-20",
                  "symbol": "USDC",
                  "tokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
                  "verified": true,
                },
                "sourceTransactionHashes": [
                  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                ],
              },
              "sourceChainId": "eip155:8453",
              "sourceTransactionHash": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
              "sourceTransferIndex": 0,
              "status": "completed",
              "statusReason": null,
              "subsidyAmount": null,
              "tempoGasPaid": null,
              "updatedAt": Any<String>,
              "version": 3,
              "webhookReceivedAt": null,
            },
          ],
          "result": {
            "created": 2,
            "type": "completed",
            "updated": 2,
          },
          "storedAddress": {
            "address": "0x1212121212121212121212121212121212121212",
            "apiKeyId": "key_precision_reconciliation",
            "createdAt": "2026-01-03T00:00:00.000Z",
            "deliveryStrategy": "provider",
            "destinationTokenKey": "eip155:4217/erc20:0x20c000000000000000000000b9537d11c60e8b50",
            "environment": "production",
            "id": Any<String>,
            "lastPolledAt": "2027-01-03T00:00:00.000Z",
            "nextPollAt": "2027-01-03T00:01:00.000Z",
            "orgId": "org_precision_reconciliation",
            "pollFailureCount": 0,
            "pollLeaseUntil": null,
            "pollLeaseVersion": 1,
            "projectId": null,
            "providerId": "relay",
            "providerOutputToken": Any<Object>,
            "providerRequestIds": [
              "relay-address-request",
            ],
            "providerState": {
              "reconciliation": {
                "pendingRequestIds": [],
                "requestIds": [
                  "relay-multiple-transfer-request",
                ],
                "updatedAt": "2026-01-03T00:02:00.000Z",
              },
            },
            "recipient": "0x1111111111111111111111111111111111111111",
            "refundAddress": "0x1313131313131313131313131313131313131313",
            "snapshot": Any<Object>,
            "sourceChainId": "eip155:8453",
            "sourceTokenKey": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
            "status": "active",
            "subsidize": false,
            "updatedAt": "2026-01-03T00:00:00.000Z",
            "version": 1,
          },
        }
      `,
      )
    } finally {
      await server.closeAsync()
    }
  })
})

function transferLog(options: transferLog.Options) {
  return {
    address: options.token,
    ...(options.blockNumber !== undefined
      ? { blockNumber: `0x${options.blockNumber.toString(16)}` }
      : {}),
    data: `0x${options.amount.toString(16).padStart(64, '0')}`,
    logIndex: `0x${(options.logIndex ?? 0).toString(16)}`,
    topics: [transferTopic, topicAddress(options.sender), topicAddress(options.recipient)],
    ...(options.transactionHash ? { transactionHash: options.transactionHash } : {}),
  }
}

declare namespace transferLog {
  type Options = {
    amount: bigint
    blockNumber?: number | undefined
    logIndex?: number | undefined
    recipient: string
    sender: string
    token: string
    transactionHash?: string | undefined
  }
}

function relayDepositLog(options: relayDepositLog.Options) {
  const event = AbiEvent.from(
    'event RelayErc20Deposit(address from, address token, uint256 amount, bytes32 id)',
  )
  return {
    address: options.depository,
    blockNumber: `0x${options.blockNumber.toString(16)}`,
    data: AbiParameters.encode(event.inputs, [
      options.from as Address.Address,
      options.token as Address.Address,
      options.amount,
      options.orderId as Hex.Hex,
    ]),
    logIndex: '0x0',
    topics: [AbiEvent.getSelector(event)],
    transactionHash: options.transactionHash,
  }
}

declare namespace relayDepositLog {
  type Options = {
    amount: bigint
    blockNumber: number
    depository: string
    from: string
    orderId: string
    token: string
    transactionHash: string
  }
}

function rpcTransaction(options: rpcTransaction.Options) {
  return {
    blockHash: `0x${'39'.repeat(32)}`,
    blockNumber: `0x${options.blockNumber.toString(16)}`,
    from: options.from,
    gas: '0x5208',
    gasPrice: '0x1',
    hash: options.hash,
    input: options.input,
    nonce: '0x1',
    r: `0x${'3a'.repeat(32)}`,
    s: `0x${'3b'.repeat(32)}`,
    to: options.to,
    transactionIndex: '0x0',
    type: '0x0',
    v: '0x1b',
    value: '0x0',
  }
}

declare namespace rpcTransaction {
  type Options = {
    blockNumber: number
    from: string
    hash: string
    input: string
    to: string
  }
}

function topicAddress(address: string) {
  return `0x${address.slice(2).padStart(64, '0')}`
}