tapimo 0.15.1 → 0.18.0

package/src/db/tables/routesTransferSubsidyNonces.ts

@@ -10,7 +10,10 @@ export type Record = Selectable<Table>
 
 /** Serializes inventory and nonce operations for one signer and chain. */
 async function lock(db: Db.Db, options: Lane): Promise<void> {
-  const key = `${options.chainId}:${options.account.toLowerCase()}`
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
+  const key = `${options.chainId}:${account}`
   await sql`SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`.execute(db.kysely)
 }
 
@@ -24,10 +27,13 @@ type Lane = {
 /** Locks a signer lane and rejects new work when its nonce cannot be recovered. */
 export async function lockAvailableIn(db: Db.Db, options: Lane): Promise<void> {
   await lock(db, options)
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
   const current = await db.kysely
     .selectFrom('routes_transfer_subsidy_nonces')
     .selectAll()
-    .where('account', '=', options.account.toLowerCase())
+    .where('account', '=', account)
     .where('chainId', '=', options.chainId)
     .forUpdate()
     .executeTakeFirst()
@@ -51,7 +57,11 @@ export async function blockIn(db: Db.Db, options: block.Options): Promise<void>
       blockedTransferId: options.transferId,
       updatedAt: now,
     })
-    .where('account', '=', options.account.toLowerCase())
+    .where(
+      'account',
+      '=',
+      options.chainId.startsWith('eip155:') ? options.account.toLowerCase() : options.account,
+    )
     .where('chainId', '=', options.chainId)
     .executeTakeFirst()
   if (updated.numUpdatedRows !== 1n) throw new MissingCursorError()
@@ -69,7 +79,9 @@ export declare namespace block {
 
 /** Reserves one nonce under a transaction-scoped signer and chain lock. */
 export async function reserve(db: Db.Db, options: reserve.Options): Promise<number> {
-  const account = options.account.toLowerCase()
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
   await lock(db, options)
   const current = await db.kysely
     .selectFrom('routes_transfer_subsidy_nonces')

package/src/db/tables/routesTransfers.test.ts

@@ -85,6 +85,60 @@ describe('listProcessing', () => {
   })
 })
 
+describe('recordTronEventCursor', () => {
+  test('advances only the current source scan and leaves the public version unchanged', async () => {
+    const guid = `0x${'ab'.repeat(32)}`
+    const record = await seed({
+      providerState: { legacyMeshOutbound: { amount: '1000000', guid } },
+      snapshot: TestRoutes.transferSnapshot({
+        provider: { id: 'legacy-mesh', name: 'USDT0 Legacy Mesh' },
+      }),
+    })
+    const processing = await Transfer.transition(db, {
+      expectedVersion: record.version,
+      id: record.id,
+      status: 'processing',
+    })
+    if (processing.type !== 'applied') throw new Error('Expected processing transfer.')
+
+    const first = await RoutesTransfers.recordTronEventCursor(db, {
+      cursor: { fingerprint: 'next-page', offset: 0 },
+      guid,
+      id: record.id,
+      previousCursor: null,
+    })
+    expect(first?.providerState).toMatchObject({
+      legacyMeshOutbound: { guid },
+      tronEventCursor: { fingerprint: 'next-page', offset: 0 },
+    })
+    expect(first?.version).toBe(processing.record.version)
+    expect(
+      await RoutesTransfers.recordTronEventCursor(db, {
+        cursor: { fingerprint: 'wrong-source', offset: 0 },
+        guid: `0x${'cd'.repeat(32)}`,
+        id: record.id,
+        previousCursor: { fingerprint: 'next-page', offset: 0 },
+      }),
+    ).toBeUndefined()
+    expect(
+      await RoutesTransfers.recordTronEventCursor(db, {
+        cursor: { fingerprint: 'stale-page', offset: 0 },
+        guid,
+        id: record.id,
+        previousCursor: null,
+      }),
+    ).toBeUndefined()
+    const cleared = await RoutesTransfers.recordTronEventCursor(db, {
+      cursor: null,
+      guid,
+      id: record.id,
+      previousCursor: { fingerprint: 'next-page', offset: 0 },
+    })
+    expect(cleared?.providerState).not.toHaveProperty('tronEventCursor')
+    expect(cleared?.version).toBe(processing.record.version)
+  })
+})
+
 describe('count', () => {
   test('shares the list filter and stops at the cap', async () => {
     const total = await RoutesTransfers.count(db, owner, { cap: 100 })
@@ -134,6 +188,69 @@ describe('update', () => {
 })
 
 describe('subsidies', () => {
+  test('retains Tempo obligations operationally while billing only enterprise and legacy payers', async () => {
+    const records = await Promise.all(
+      (['tempo', 'enterprise', 'legacy'] as const).map(async (payer) => {
+        const record = await seed({
+          orgId: `org_transfer_payer_${payer}`,
+          ...(payer === 'legacy'
+            ? {}
+            : {
+                providerState: {
+                  routePolicy: {
+                    maxAmount: '1',
+                    scope: { environment: 'production', orgId: `org_transfer_payer_${payer}` },
+                    subsidyPayer: payer,
+                    versions: [1],
+                  },
+                },
+              }),
+          subsidyCommitment: {
+            account: `0x${'ac'.repeat(20)}`,
+            amount: { baseUnits: '1', currency: 'USD', decimals: 6, formatted: '0.000001' },
+            chainId: '4217',
+            nativeAmount: '0',
+            tokenAddress: `0x${'bc'.repeat(20)}`,
+          },
+        })
+        expect(await RoutesTransfers.hasUnreportedSubsidies(db, record.orgId)).toBe(true)
+        let result = await Transfer.transition(db, {
+          expectedVersion: record.version,
+          id: record.id,
+          status: 'processing',
+        })
+        if (result.type !== 'applied') throw new Error('Expected processing transfer.')
+        result = await Transfer.transition(db, {
+          expectedVersion: result.record.version,
+          id: record.id,
+          subsidyAmount: { baseUnits: '1', currency: 'USD', decimals: 6, formatted: '0.000001' },
+          subsidyTransactionHash: `0x${payer.charCodeAt(0).toString(16).repeat(64).slice(0, 64)}`,
+        })
+        if (result.type !== 'applied') throw new Error('Expected subsidized transfer.')
+        result = await Transfer.transition(db, {
+          expectedVersion: result.record.version,
+          id: record.id,
+          status: 'completed',
+        })
+        if (result.type !== 'applied') throw new Error('Expected completed transfer.')
+        expect(await RoutesTransfers.hasUnreportedSubsidies(db, record.orgId)).toBe(
+          payer !== 'tempo',
+        )
+        return result.record
+      }),
+    )
+
+    expect(records.map((record) => RoutesTransfers.subsidies(record))).toHaveLength(3)
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).toEqual(
+      expect.arrayContaining(records.filter((_, index) => index > 0).map(({ id }) => id)),
+    )
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).not.toContain(
+      records[0]!.id,
+    )
+    for (const record of records.slice(1))
+      await RoutesTransfers.markSubsidyReported(db, record.id, new Date().toISOString())
+  })
+
   test('keeps prepared liability durable and reports completed production usage once', async () => {
     const record = await seed({ orgId: 'org_transfer_subsidy' })
     const processing = await Transfer.transition(db, {
@@ -217,7 +334,11 @@ describe('subsidies', () => {
         chainId: commitment.chainId,
         tokenAddress: commitment.tokenAddress,
       }),
-    ).toEqual({ nativeAmount: 200n, tokenAmount: 6002n })
+    ).toEqual({
+      nativeAmount: 200n,
+      tokenAmount: 6002n,
+      tokenAmounts: { [commitment.tokenAddress]: 6002n },
+    })
     expect(await RoutesTransfers.hasUnreportedSubsidies(db, 'org_expired_transfer_subsidy')).toBe(
       true,
     )
@@ -244,11 +365,71 @@ describe('subsidies', () => {
         chainId: commitment.chainId,
         tokenAddress: commitment.tokenAddress,
       }),
-    ).toEqual({ nativeAmount: 100n, tokenAmount: 3001n })
+    ).toEqual({
+      nativeAmount: 100n,
+      tokenAmount: 3001n,
+      tokenAmounts: { [commitment.tokenAddress]: 3001n },
+    })
     expect(await RoutesTransfers.hasUnreportedSubsidies(db, expired.orgId)).toBe(false)
   })
 })
 
+describe('subsidyReservations', () => {
+  test('preserves case-sensitive Solana wallet and mint reservations', async () => {
+    const account = 'So11111111111111111111111111111111111111112'
+    const tokenAddress = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
+    const chainId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+    const record = await seed({
+      subsidyCommitment: {
+        account,
+        amount: { baseUnits: '3001', currency: 'USD', decimals: 6, formatted: '0.003001' },
+        chainId,
+        nativeAmount: '5000',
+        tokenAddress,
+      },
+    })
+    expect({ account: record.subsidyAccount, tokenAddress: record.subsidyTokenAddress }).toEqual({
+      account,
+      tokenAddress,
+    })
+    expect(
+      await RoutesTransfers.subsidyReservations(db, { account, chainId, tokenAddress }),
+    ).toEqual({
+      nativeAmount: 5000n,
+      tokenAmount: 3001n,
+      tokenAmounts: { [tokenAddress]: 3001n },
+    })
+  })
+
+  test('includes other delivery tokens that can also pay Tempo fees', async () => {
+    const account = `0x${'78'.repeat(20)}`
+    const token = `0x${'79'.repeat(20)}`
+    const feeToken = `0x${'80'.repeat(20)}`
+    const commitment = {
+      account,
+      amount: { baseUnits: '3001', currency: 'USD', decimals: 6, formatted: '0.003001' },
+      chainId: 'eip155:4217',
+      nativeAmount: '1000000000000',
+      tokenAddress: token,
+    }
+    const first = await seed({ subsidyCommitment: commitment })
+    await seed({ subsidyCommitment: { ...commitment, tokenAddress: feeToken } })
+    const options = { account, chainId: commitment.chainId, tokenAddress: token }
+    expect(await RoutesTransfers.subsidyReservations(db, options)).toEqual({
+      nativeAmount: 2_000_000_000_000n,
+      tokenAmount: 3001n,
+      tokenAmounts: { [feeToken]: 3001n, [token]: 3001n },
+    })
+    expect(
+      await RoutesTransfers.subsidyReservations(db, { ...options, excludeId: first.id }),
+    ).toEqual({
+      nativeAmount: 1_000_000_000_000n,
+      tokenAmount: 0n,
+      tokenAmounts: { [feeToken]: 3001n },
+    })
+  })
+})
+
 describe('list', () => {
   test('filters across owners and searches transaction references', async () => {
     const record = await seed({

package/src/db/tables/routesTransfers.ts

@@ -138,6 +138,45 @@ export declare namespace recordProviderDelivery {
   }
 }
 
+/** Saves a private Tron event-index cursor without publishing an unchanged transfer snapshot. */
+export function recordTronEventCursor(
+  db: Db.Db,
+  options: recordTronEventCursor.Options,
+): Promise<Record | undefined> {
+  const providerState =
+    options.cursor === null
+      ? sql<Record['providerState']>`coalesce(provider_state, '{}'::jsonb) - 'tronEventCursor'`
+      : sql<
+          Record['providerState']
+        >`jsonb_set(coalesce(provider_state, '{}'::jsonb), '{tronEventCursor}', ${JSON.stringify(options.cursor)}::jsonb, true)`
+  return db.kysely
+    .updateTable('routes_transfers')
+    .set({ providerState })
+    .where('id', '=', options.id)
+    .where('providerId', '=', 'legacy-mesh')
+    .where('status', '=', 'processing')
+    .where(sql<boolean>`provider_state->'legacyMeshOutbound'->>'guid' = ${options.guid}`)
+    .where(
+      sql<boolean>`provider_state->'tronEventCursor' IS NOT DISTINCT FROM ${options.previousCursor === null ? null : JSON.stringify(options.previousCursor)}::jsonb`,
+    )
+    .returningAll()
+    .executeTakeFirst()
+}
+
+export declare namespace recordTronEventCursor {
+  /** Cursor update guarded by the current source GUID and prior cursor. */
+  type Options = {
+    /** Next index page and offset, or null to restart after index exhaustion. */
+    cursor: { fingerprint?: string | undefined; offset: number } | null
+    /** Source packet GUID whose destination is being scanned. */
+    guid: string
+    /** Route transfer id (`rtr_…`). */
+    id: string
+    /** Cursor read before the scan, or null before the first page. */
+    previousCursor: { fingerprint?: string | undefined; offset: number } | null
+  }
+}
+
 /** Gets an owner-visible transfer by id; `undefined` for absent or foreign rows. */
 export function getOwned(db: Db.Db, owner: Owner, id: string): Promise<Record | undefined> {
   let query = db.kysely
@@ -420,6 +459,9 @@ export function listUnreportedSubsidies(
     .where('subsidyAmount', 'is not', null)
     .where(sql<boolean>`(subsidy_amount->>'baseUnits')::numeric > 0`)
     .where('subsidyMeterReportedAt', 'is', null)
+    .where(
+      sql<boolean>`coalesce(provider_state->'routePolicy'->>'subsidyPayer', 'enterprise') <> 'tempo'`,
+    )
     .orderBy('statusUpdatedAt', 'asc')
     .orderBy('id', 'asc')
   if (options.limit !== undefined) query = query.limit(options.limit)
@@ -459,6 +501,7 @@ export async function hasUnreportedSubsidies(db: Db.Db, orgId: string): Promise<
             eb('subsidyAmount', 'is not', null),
             sql<boolean>`(subsidy_amount->>'baseUnits')::numeric > 0`,
             eb('subsidyMeterReportedAt', 'is', null),
+            sql<boolean>`coalesce(provider_state->'routePolicy'->>'subsidyPayer', 'enterprise') <> 'tempo'`,
           ]),
           eb.and([
             eb('status', 'in', ['awaiting-source', 'processing', 'action-required', 'refunding']),
@@ -524,21 +567,35 @@ export async function subsidyReservations(
   db: Db.Db,
   options: subsidyReservations.Options,
 ): Promise<subsidyReservations.Result> {
-  const tokenAmount = sql<string>`coalesce(sum(CASE WHEN subsidy_token_address = ${options.tokenAddress.toLowerCase()} THEN (subsidy_commitment_amount->>'baseUnits')::numeric ELSE 0 END), 0)`
+  const account = options.chainId.startsWith('eip155:')
+    ? options.account.toLowerCase()
+    : options.account
+  const tokenAddress = options.chainId.startsWith('eip155:')
+    ? options.tokenAddress.toLowerCase()
+    : options.tokenAddress
   let query = db.kysely
     .selectFrom('routes_transfers')
     .select([
       sql<string>`coalesce(sum(subsidy_native_amount::numeric), 0)`.as('nativeAmount'),
-      tokenAmount.as('tokenAmount'),
+      sql<string>`sum((subsidy_commitment_amount->>'baseUnits')::numeric)`.as('tokenAmount'),
+      'subsidyTokenAddress',
     ])
     .where('status', 'in', ['awaiting-source', 'processing', 'action-required', 'refunding'])
-    .where('subsidyAccount', '=', options.account.toLowerCase())
+    .where('subsidyAccount', '=', account)
     .where('subsidyChainId', '=', options.chainId)
     .where('subsidyCommitmentAmount', 'is not', null)
     .where(sql<boolean>`(subsidy_commitment_amount->>'baseUnits')::numeric > 0`)
+    .groupBy('subsidyTokenAddress')
   if (options.excludeId !== undefined) query = query.where('id', '!=', options.excludeId)
-  const row = await query.executeTakeFirstOrThrow()
-  return { nativeAmount: BigInt(row.nativeAmount), tokenAmount: BigInt(row.tokenAmount) }
+  const rows = await query.execute()
+  const tokenAmounts = Object.fromEntries(
+    rows.map((row) => [row.subsidyTokenAddress!, BigInt(row.tokenAmount)]),
+  )
+  return {
+    nativeAmount: rows.reduce((total, row) => total + BigInt(row.nativeAmount), 0n),
+    tokenAmount: tokenAmounts[tokenAddress] ?? 0n,
+    tokenAmounts,
+  }
 }
 
 /** Lists abandoned subsidy commitments eligible for bounded expiry. */
@@ -584,10 +641,12 @@ export declare namespace subsidyReservations {
 
   /** Inventory promised by signed transactions that have not completed. */
   type Result = {
-    /** Native gas amount reserved on the signer chain. */
+    /** Gas cost reserved on the signer chain, in wei, SUN, or rounded attodollars on Tempo. */
     nativeAmount: bigint
     /** Destination token amount reserved for the requested token. */
     tokenAmount: bigint
+    /** Delivery commitments by chain-canonical token address, including tokens used for Tempo fees. */
+    tokenAmounts: { [address: string]: bigint }
   }
 }