tapimo 0.15.1 → 0.18.0

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

@@ -2,11 +2,15 @@ import * as NodeBuffer from 'node:buffer'
 
 import { AbiEvent } from 'ox'
 
+import * as RoutesCatalog from '../../db/tables/routesCatalog.js'
+import * as RoutesDepositRequestObservations from '../../db/tables/routesDepositRequestObservations.js'
 import * as RoutesDeposits from '../../db/tables/routesDeposits.js'
 import * as TestApp from '../../../test/App.js'
 import * as TestRoutes from '../../../test/Routes.js'
 import * as TestRelay from '../../../test/Relay.js'
+import * as Chain from './Chain.js'
 import * as DepositAddress from './DepositAddress.js'
+import * as Evidence from './Evidence.js'
 import * as Reconciliation from './Reconciliation.js'
 import * as SourceObservation from './SourceObservation.js'
 import * as Relay from './providers/relay.js'
@@ -294,8 +298,225 @@ describe('observe', () => {
       await server.closeAsync()
     }
   })
+
+  test('converges when chain observation records another transfer during reconciliation', async () => {
+    const database = TestApp.databaseFactory()
+    const route = TestRoutes.transferSnapshot()
+    const providerAddress = `0x${'77'.repeat(20)}`
+    const sender = `0x${'88'.repeat(20)}`
+    const sourceTransactionHash = `0x${'99'.repeat(32)}`
+    const address = await DepositAddress.create(database(), {
+      deliveryStrategy: 'provider',
+      environment: 'production',
+      id: 'rda_source_reconciliation_race',
+      now: new Date('2026-01-02T00:00:00.000Z'),
+      orgId: 'org_source_reconciliation_race',
+      providerOutputToken: route.destinationToken,
+      snapshot: {
+        address: providerAddress,
+        destinationChain: route.destinationChain,
+        destinationToken: route.destinationToken,
+        provider: route.provider,
+        recipient: route.recipient,
+        refundAddress: `0x${'aa'.repeat(20)}`,
+        sourceChain: route.sourceChain,
+        sourceToken: route.sourceToken,
+        subsidize: false,
+      },
+    })
+    let observed = 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
+      }
+      if (body.method === 'eth_getTransactionReceipt' && !observed) {
+        observed = true
+        await SourceObservation.observe(database(), {
+          addressId: address.id,
+          amount: '2000000',
+          chainId: route.sourceChain.id,
+          now: new Date('2026-01-02T00:00:03.000Z'),
+          recipient: providerAddress,
+          sender,
+          tokenAddress: route.sourceToken.address,
+          transactionHash: sourceTransactionHash,
+          transferIndex: 1,
+        })
+      }
+      const result =
+        body.method === 'eth_blockNumber'
+          ? '0x100'
+          : {
+              blockNumber: '0x80',
+              logs: [
+                transferLog({
+                  amount: 1_000_000n,
+                  logIndex: 0,
+                  recipient: providerAddress,
+                  sender,
+                  token: route.sourceToken.address,
+                }),
+                transferLog({
+                  amount: 2_000_000n,
+                  logIndex: 1,
+                  recipient: providerAddress,
+                  sender,
+                  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 RoutesCatalog.publish(database(), {
+        chainTokens: [],
+        chains: [
+          {
+            aliases: [],
+            id: route.destinationChain.id as Chain.Id,
+            name: route.destinationChain.name,
+            parentChainId: null,
+            rpcUrls: [server.url],
+            slug: 'destination-source-race',
+          },
+          {
+            aliases: [],
+            id: route.sourceChain.id as Chain.Id,
+            name: route.sourceChain.name,
+            parentChainId: null,
+            rpcUrls: [server.url],
+            slug: 'source-source-race',
+          },
+        ],
+        routes: [],
+        tokens: [],
+      })
+      const initial = await SourceObservation.observe(database(), {
+        addressId: address.id,
+        amount: '1000000',
+        chainId: route.sourceChain.id,
+        now: new Date('2026-01-02T00:00:00.500Z'),
+        recipient: providerAddress,
+        sender,
+        tokenAddress: route.sourceToken.address,
+        transactionHash: sourceTransactionHash,
+        transferIndex: 0,
+      })
+      const request = {
+        createdAt: '2026-01-02T00:00:01.000Z',
+        destinationTransactionHashes: [],
+        id: 'relay-source-reconciliation-race',
+        refundTransactionHashes: [],
+        sourceTransactionHashes: [sourceTransactionHash],
+        status: 'pending' as const,
+        updatedAt: '2026-01-02T00:00:02.000Z',
+      }
+      await RoutesDepositRequestObservations.observePoll(database(), {
+        depositAddressId: address.id,
+        observedAt: '2026-01-02T00:00:02.500Z',
+        providerRequestIds: [request.id],
+      })
+      const verifyTransfers = Evidence.createVerifier({ db: database })
+
+      const first = await Reconciliation.reconcileRequest(database(), {
+        address,
+        request,
+        verifyTransfers,
+      })
+      const retry = await Reconciliation.reconcileRequest(database(), {
+        address,
+        request,
+        verifyTransfers,
+      })
+      const records = await RoutesDeposits.listBySourceTransaction(database(), {
+        depositAddressId: address.id,
+        sourceTransactionHash,
+      })
+
+      expect({
+        first,
+        initial: initial.type,
+        records: records.map((record) => ({
+          detectionTrigger: record.detectionTrigger,
+          pollObservedAt: record.pollObservedAt,
+          providerRequestIds: record.providerRequestIds,
+          sourceAmount: record.snapshot.sourceAmount?.baseUnits,
+          sourceTransferIndex: record.sourceTransferIndex,
+          status: record.status,
+        })),
+        retry,
+      }).toMatchInlineSnapshot(`
+        {
+          "first": {
+            "created": 0,
+            "terminal": false,
+            "updated": 2,
+          },
+          "initial": "created",
+          "records": [
+            {
+              "detectionTrigger": "chain",
+              "pollObservedAt": "2026-01-02T00:00:02.500Z",
+              "providerRequestIds": [
+                "relay-source-reconciliation-race",
+              ],
+              "sourceAmount": "1000000",
+              "sourceTransferIndex": 0,
+              "status": "bridging",
+            },
+            {
+              "detectionTrigger": "chain",
+              "pollObservedAt": "2026-01-02T00:00:02.500Z",
+              "providerRequestIds": [
+                "relay-source-reconciliation-race",
+              ],
+              "sourceAmount": "2000000",
+              "sourceTransferIndex": 1,
+              "status": "bridging",
+            },
+          ],
+          "retry": {
+            "created": 0,
+            "terminal": false,
+            "updated": 0,
+          },
+        }
+      `)
+    } 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.toString(16)}`,
+    topics: [
+      AbiEvent.getSelector(transferEvent),
+      topicAddress(options.sender),
+      topicAddress(options.recipient),
+    ],
+  }
+}
+
+declare namespace transferLog {
+  type Options = {
+    amount: bigint
+    logIndex: number
+    recipient: string
+    sender: string
+    token: string
+  }
+}
+
 function topicAddress(address: string) {
   return `0x${address.slice(2).toLowerCase().padStart(64, '0')}`
 }

package/src/internal/routes/Subsidy.local.test.ts

@@ -1,16 +1,21 @@
 /** @module-tag localnet */
 
+import { horcruxTempoAccount } from '@horcrux/viem'
 import { waitForTransactionReceipt } from 'viem/actions'
+import { mnemonicToAccount } from 'viem/accounts'
 import { Actions, Addresses } from 'viem/tempo'
 import { TxEnvelopeTempo } from 'ox/tempo'
+import { inject } from 'vite-plus/test'
 
 import * as Runtime from '../../../test/runtime.js'
 import * as TestTempo from '../../../test/Tempo.js'
 import * as Subsidy from './Subsidy.js'
 
 const account = TestTempo.accounts[6]!
+const horcruxWallet = mnemonicToAccount(inject('tempoTestMnemonic'), { addressIndex: 6 })
 const recipient = TestTempo.accounts[7]!
 const runtime = Runtime.get()
+const horcruxUrl = inject('horcruxUrl')
 const client = TestTempo.getClient()
 const settler = Subsidy.create({
   account,
@@ -20,9 +25,50 @@ const settler = Subsidy.create({
 
 beforeAll(async () => {
   await Actions.faucet.fundSync(client, { account, timeout: 60_000 })
+  if (horcruxUrl) await Actions.faucet.fundSync(client, { account: horcruxWallet, timeout: 60_000 })
 })
 
 describe.skipIf(runtime.mode !== 'localnet')('create', () => {
+  test.skipIf(!horcruxUrl)('uses Horcrux to sign a three-call Tempo deposit subsidy', async () => {
+    const destinationToken = runtime.fixtures?.crossTokenTransfer?.destinationToken
+    if (!destinationToken || !horcruxUrl) throw new Error('Expected a seeded DEX pair and Horcrux.')
+    const signer = horcruxTempoAccount({
+      address: horcruxWallet.address,
+      auth: { type: 'none' },
+      url: horcruxUrl,
+    })
+    const horcruxSettler = Subsidy.create({
+      account: signer,
+      getClient: TestTempo.readClient(),
+      policy: { maxAmount: '10' },
+    })
+    const before = await Actions.token.getBalance(client, {
+      account: recipient.address,
+      decimals: 6,
+      token: destinationToken,
+    })
+    const prepared = await horcruxSettler.prepare({
+      amount: 100_000n,
+      depositId: 'rdp_local_horcrux_activity_usd',
+      recipient: recipient.address,
+      token: destinationToken,
+    })
+    const envelope = TxEnvelopeTempo.deserialize(prepared.transaction as TxEnvelopeTempo.Serialized)
+    expect(envelope.calls).toHaveLength(3)
+
+    await horcruxSettler.broadcast(prepared)
+    await waitForTransactionReceipt(client, { hash: prepared.hash })
+    const after = await Actions.token.getBalance(client, {
+      account: recipient.address,
+      decimals: 6,
+      token: destinationToken,
+    })
+    expect({
+      delivered: after.amount - before.amount,
+      status: await horcruxSettler.status({ hash: prepared.hash }),
+    }).toMatchObject({ delivered: 100_000n, status: { type: 'success' } })
+  })
+
   test('transfers a pathUSD subsidy through a persisted signed transaction', async () => {
     const before = await Actions.token.getBalance(client, {
       account: recipient.address,

package/src/internal/routes/Subsidy.ts

@@ -33,8 +33,10 @@ export type Policy = {
 /** Public messages for Routes subsidy policy denials. */
 export const denialMessages = {
   billing_past_due: 'Billing past due.',
-  billing_required: 'Billing required.',
-  routes_subsidy_not_enabled: 'Routes subsidies are not enabled for this organization.',
+  billing_required:
+    'Active billing is required for enterprise-paid route subsidies. Set up billing for this organization, then retry.',
+  routes_subsidy_not_enabled:
+    'Route subsidies are not enabled for this request. Contact Tempo to enable them, or use an API key from an organization with subsidies enabled.',
 } as const
 
 /** Reason that a Routes subsidy policy denied a request or settlement. */