tapimo 0.7.0 → 0.7.2

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

@@ -0,0 +1,2020 @@
+import * as NodeBuffer from 'node:buffer'
+
+import { AbiEvent } from 'ox'
+
+import * as FundingCatalog from '../../db/tables/fundingCatalog.js'
+import * as FundingDepositAddresses from '../../db/tables/fundingDepositAddresses.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'
+
+const db = TestApp.database()
+const transferTopic = AbiEvent.getSelector('event Transfer(address,address,uint256)')
+
+describe('createTracker', () => {
+  test('requires action when Relay completes without destination funds', 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 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: [{ hash: 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)
+        },
+        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 reconciliation = await tracker.reconcile(message)
+      const duplicate = await tracker.reconcile(message)
+      const [record] = await FundingDeposits.listBySourceTransaction(db, {
+        depositAddressId: address.id,
+        sourceTransactionHash,
+      })
+      const storedAddress = await FundingDepositAddresses.get(db, address.id)
+
+      expect({ duplicate, 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),
+          },
+          storedAddress: {
+            id: expect.any(String),
+            providerOutputToken: expect.any(Object),
+            snapshot: expect.any(Object),
+          },
+        },
+        `
+        {
+          "duplicate": {
+            "type": "busy",
+          },
+          "reconciliation": {
+            "created": 1,
+            "type": "completed",
+            "updated": 1,
+          },
+          "record": {
+            "createdAt": Any<String>,
+            "depositAddressId": Any<String>,
+            "environment": "production",
+            "id": Any<String>,
+            "orgId": "org_reconciliation",
+            "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": "action-required",
+            "statusReason": {
+              "code": "delivery_failed",
+              "message": "The provider completed without delivering destination funds.",
+            },
+            "subsidyAmount": null,
+            "tempoGasPaid": null,
+            "updatedAt": Any<String>,
+            "version": 3,
+          },
+          "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": [],
+                "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',
+          sourceTransactionHashes: [sourceTransactionHash],
+          status: 'success',
+          updatedAt: '2026-01-06T00:02:00.000Z',
+        },
+        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>,
+            "environment": "production",
+            "id": Any<String>,
+            "orgId": "org_unsubsidized_reconciliation",
+            "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,
+          },
+          "result": {
+            "created": 1,
+            "terminal": true,
+            "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: [{ hash: 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 tracker = Reconciliation.createTracker({
+        db,
+        dispatch: async () => undefined,
+        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({ 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,
+              },
+              "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 requestTargets: string[] = []
+    let delivered = false
+    let includeAddressRequest = true
+    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:
+              includeAddressRequest || direct
+                ? [
+                    {
+                      createdAt: '2026-01-02T00:01:00.000Z',
+                      data: {
+                        inTxs: [{ hash: sourceTransactionHash }],
+                        outTxs: delivered ? [{ hash: destinationTransactionHash }] : [],
+                      },
+                      depositAddress: { depositTxHash: sourceTransactionHash },
+                      id: 'relay-pending-request',
+                      status: delivered ? 'success' : 'pending',
+                      updatedAt: (() => {
+                        if (direct && returnOlderDirect) return '2026-01-01T00:00: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 })
+      const tracker = Reconciliation.createTracker({
+        db,
+        dispatch: async () => undefined,
+        now: () => new Date('2027-01-02T00:00:00.000Z'),
+        providers: [provider],
+        verifyTransfers: Evidence.createVerifier({ db }),
+      })
+
+      const pending = await tracker.reconcile({
+        addressId: address.id,
+        type: 'funding:deposit-address:reconcile',
+      })
+      delivered = true
+      includeAddressRequest = false
+      const completed = await tracker.reconcile({
+        addressId: address.id,
+        type: 'funding:deposit-address:reconcile',
+      })
+      includeAddressRequest = true
+      const replay = await tracker.reconcile({
+        addressId: address.id,
+        type: 'funding:deposit-address:reconcile',
+      })
+      includeAddressRequest = false
+      returnOlderDirect = true
+      const webhook = await tracker.reconcile({
+        addressId: address.id,
+        requestId: 'relay-pending-request',
+        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,
+        pending,
+        record,
+        replay,
+        requestTargets,
+        storedAddress,
+        webhook,
+      }).toMatchInlineSnapshot(
+        {
+          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,
+          },
+          "pending": {
+            "created": 1,
+            "type": "completed",
+            "updated": 1,
+          },
+          "record": {
+            "createdAt": Any<String>,
+            "depositAddressId": Any<String>,
+            "environment": "production",
+            "id": Any<String>,
+            "orgId": "org_pending_reconciliation",
+            "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": 5,
+          },
+          "replay": {
+            "created": 0,
+            "type": "completed",
+            "updated": 0,
+          },
+          "requestTargets": [
+            "/requests/v2?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
+            "/requests/v2?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
+            "/requests/v2?id=relay-pending-request&limit=50&sortBy=updatedAt&sortDirection=desc",
+            "/requests/v2?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
+            "/requests/v2?depositAddress=0x8888888888888888888888888888888888888888&includeChildRequests=true&limit=50&sortBy=updatedAt&sortDirection=desc",
+            "/requests/v2?id=relay-pending-request&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": "2027-01-02T00:00:00.000Z",
+            "nextPollAt": "2027-01-02T00:01:00.000Z",
+            "orgId": "org_pending_reconciliation",
+            "pollFailureCount": 0,
+            "pollLeaseUntil": null,
+            "pollLeaseVersion": 4,
+            "projectId": null,
+            "providerId": "relay",
+            "providerOutputToken": Any<Object>,
+            "providerRequestIds": [],
+            "providerState": {
+              "reconciliation": {
+                "pendingRequestIds": [],
+                "requestIds": [
+                  "relay-pending-request",
+                ],
+                "updatedAt": "2026-01-02T00:03:00.500Z",
+              },
+            },
+            "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('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,
+        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',
+          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>,
+              "environment": "production",
+              "id": Any<String>,
+              "orgId": "org_source_evidence_reconciliation",
+              "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,
+            },
+            {
+              "createdAt": Any<String>,
+              "depositAddressId": Any<String>,
+              "environment": "production",
+              "id": Any<String>,
+              "orgId": "org_source_evidence_reconciliation",
+              "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,
+            },
+          ],
+          "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: [{ hash: sourceTransactionHash }],
+                  outTxs: [{ hash: 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,
+        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>,
+              "environment": "production",
+              "id": Any<String>,
+              "orgId": "org_precision_reconciliation",
+              "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,
+            },
+            {
+              "createdAt": Any<String>,
+              "depositAddressId": Any<String>,
+              "environment": "production",
+              "id": Any<String>,
+              "orgId": "org_precision_reconciliation",
+              "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,
+            },
+          ],
+          "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,
+    data: `0x${options.amount.toString(16).padStart(64, '0')}`,
+    logIndex: `0x${(options.logIndex ?? 0).toString(16)}`,
+    topics: [transferTopic, topicAddress(options.sender), topicAddress(options.recipient)],
+  }
+}
+
+declare namespace transferLog {
+  type Options = {
+    amount: bigint
+    logIndex?: number | undefined
+    recipient: string
+    sender: string
+    token: string
+  }
+}
+
+function topicAddress(address: string) {
+  return `0x${address.slice(2).padStart(64, '0')}`
+}