tapimo 0.15.1 → 0.18.1

package/src/internal/routes/Transfer.solana.test.ts

@@ -0,0 +1,389 @@
+import { ed25519 } from '@noble/curves/ed25519'
+import {
+  findAssociatedTokenPda,
+  getTransferCheckedInstruction,
+  TOKEN_PROGRAM_ADDRESS,
+} from '@solana-program/token'
+import {
+  address,
+  appendTransactionMessageInstruction,
+  blockhash,
+  compileTransaction,
+  createTransactionMessage,
+  getTransactionEncoder,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  signatureBytes,
+} from '@solana/kit'
+import { Base58 } from 'ox'
+
+import * as TestApp from '../../../test/App.js'
+import * as TestRoutes from '../../../test/Routes.js'
+import * as RoutesTransfers from '../../db/tables/routesTransfers.js'
+import * as SolanaTransferSubsidy from './SolanaTransferSubsidy.js'
+import * as Transfer from './Transfer.js'
+
+const db = TestApp.database()
+const chainId = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp'
+const token = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'
+const amount = { baseUnits: '3001', currency: 'USD', decimals: 6, formatted: '0.003001' }
+
+beforeEach(() => vi.useFakeTimers({ now: new Date('2026-01-01T00:00:00.000Z'), toFake: ['Date'] }))
+afterEach(() => vi.useRealTimers())
+
+describe('prepareSolanaSubsidy', () => {
+  test('preserves base58 terms and shares one signed settlement per source payment', async () => {
+    const secret = crypto.getRandomValues(new Uint8Array(32))
+    const account = Base58.fromBytes(ed25519.getPublicKey(secret))
+    const recipient = Base58.fromBytes(
+      ed25519.getPublicKey(crypto.getRandomValues(new Uint8Array(32))),
+    )
+    const mint = address(token)
+    const [[source], [destination]] = await Promise.all([
+      findAssociatedTokenPda({
+        mint,
+        owner: address(account),
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      }),
+      findAssociatedTokenPda({
+        mint,
+        owner: address(recipient),
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      }),
+    ])
+    const message = appendTransactionMessageInstruction(
+      getTransferCheckedInstruction({
+        amount: 3001n,
+        authority: address(account),
+        decimals: 6,
+        destination,
+        mint,
+        source,
+      }),
+      setTransactionMessageLifetimeUsingBlockhash(
+        {
+          blockhash: blockhash(Base58.fromBytes(crypto.getRandomValues(new Uint8Array(32)))),
+          lastValidBlockHeight: 0n,
+        },
+        setTransactionMessageFeePayer(
+          address(account),
+          createTransactionMessage({ version: 'legacy' }),
+        ),
+      ),
+    )
+    const transaction = compileTransaction(message)
+    const prepared: SolanaTransferSubsidy.Prepared = {
+      account,
+      amount: amount.baseUnits,
+      chainId,
+      destination,
+      lastValidBlockHeight: 123456,
+      nativeAmount: '5000',
+      originSlot: 123306,
+      recipient,
+      request: {
+        network: 'solana:mainnet-beta',
+        transaction: Buffer.from(getTransactionEncoder().encode(transaction)).toString('base64'),
+      },
+      source,
+      token,
+    }
+    const signature = signatureBytes(ed25519.sign(Buffer.from(transaction.messageBytes), secret))
+    const signed: SolanaTransferSubsidy.Signed = {
+      ...prepared,
+      hash: Base58.fromBytes(signature),
+      transaction: Buffer.from(
+        getTransactionEncoder().encode({ ...transaction, signatures: { [account]: signature } }),
+      ).toString('base64'),
+    }
+    const snapshot = TestRoutes.transferSnapshot({
+      destinationChain: { addressFormat: 'base58', id: chainId, kind: 'solana', name: 'Solana' },
+      destinationToken: {
+        address: token,
+        currency: 'USD',
+        decimals: 6,
+        name: 'USD Coin',
+        standard: 'SPL',
+        symbol: 'USDC',
+        tokenKey: `${chainId}/spl:${token}`,
+        verified: true,
+      },
+      recipient,
+      sourceChain: { addressFormat: 'hex', id: 'eip155:4217', kind: 'evm', name: 'Tempo' },
+    })
+    const subsidyCommitment = {
+      account: prepared.account,
+      amount,
+      chainId,
+      nativeAmount: prepared.nativeAmount,
+      tokenAddress: token,
+    }
+    const sourceHash = `0x${'ab'.repeat(32)}`
+    const records = []
+    for (const orgId of ['org_solana_first', 'org_solana_second']) {
+      const record = await Transfer.create(db, {
+        apiKeyId: 'key_test',
+        environment: 'production',
+        orgId,
+        snapshot,
+        subsidyCommitment,
+      })
+      records.push(record)
+      expect(
+        (
+          await Transfer.registerSourceTransactions(db, {
+            chainId: snapshot.sourceChain.id,
+            id: record.id,
+            providerState: {},
+            transactionHashes: [sourceHash],
+          })
+        ).type,
+      ).toBe('registered')
+    }
+    const first = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => false,
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      prepare: async () => prepared,
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(first.type).toBe('prepared')
+    if (first.type !== 'prepared') throw new Error('Expected persisted Solana preparation.')
+    expect(
+      SolanaTransferSubsidy.readPrepared(
+        first.record.providerState?.['solanaTransferSubsidyPrepared'],
+      ),
+    ).toEqual(prepared)
+    const replay = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => false,
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      prepare: async () => {
+        throw new Error('Prepared Solana request was replaced.')
+      },
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(replay.type).toBe('prepared')
+    const refreshedTransaction = compileTransaction(
+      setTransactionMessageLifetimeUsingBlockhash(
+        {
+          blockhash: blockhash(Base58.fromBytes(crypto.getRandomValues(new Uint8Array(32)))),
+          lastValidBlockHeight: 0n,
+        },
+        message,
+      ),
+    )
+    const refreshed: SolanaTransferSubsidy.Prepared = {
+      ...prepared,
+      lastValidBlockHeight: 123600,
+      originSlot: 123450,
+      request: {
+        ...prepared.request,
+        transaction: Buffer.from(getTransactionEncoder().encode(refreshedTransaction)).toString(
+          'base64',
+        ),
+      },
+    }
+    const replacement = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => true,
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      prepare: async () => refreshed,
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(replacement.type).toBe('prepared')
+    if (replacement.type !== 'prepared') throw new Error('Expected refreshed Solana preparation.')
+    expect(replacement.prepared).toEqual(refreshed)
+    await expect(Transfer.signSolanaSubsidy(db, { id: records[0]!.id, signed })).rejects.toThrow()
+    const refreshedSignature = signatureBytes(
+      ed25519.sign(Buffer.from(refreshedTransaction.messageBytes), secret),
+    )
+    const refreshedSigned: SolanaTransferSubsidy.Signed = {
+      ...refreshed,
+      hash: Base58.fromBytes(refreshedSignature),
+      transaction: Buffer.from(
+        getTransactionEncoder().encode({
+          ...refreshedTransaction,
+          signatures: { [account]: refreshedSignature },
+        }),
+      ).toString('base64'),
+    }
+    const persisted = await Transfer.signSolanaSubsidy(db, {
+      id: records[0]!.id,
+      signed: refreshedSigned,
+    })
+    expect(persisted.type).toBe('signed')
+    const shared = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => false,
+      id: records[1]!.id,
+      orgId: records[1]!.orgId,
+      prepare: async () => {
+        throw new Error('Shared source produced a second subsidy.')
+      },
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(shared.type).toBe('shared')
+    if (shared.type !== 'shared') throw new Error('Expected shared Solana settlement.')
+    expect(shared.record.subsidyAmount).toBeNull()
+    expect(shared.record.subsidyTransactionHash).toBe(refreshedSigned.hash)
+    const expired = await Transfer.recoverExpiredSolanaSubsidy(db, {
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      signed: refreshedSigned,
+    })
+    expect(expired.type).toBe('recovered')
+    if (expired.type !== 'recovered') throw new Error('Expected signed Solana expiry recovery.')
+    expect(expired.record.subsidyTransactionHash).toBeNull()
+    expect(expired.record.subsidyAmount).toEqual(amount)
+    expect(
+      (
+        await Transfer.recoverExpiredSolanaSubsidy(db, {
+          id: records[1]!.id,
+          orgId: records[1]!.orgId,
+          signed: refreshedSigned,
+        })
+      ).type,
+    ).toBe('pending')
+    expect(
+      (
+        await Transfer.syncSharedSolanaSubsidy(db, {
+          id: records[1]!.id,
+          orgId: records[1]!.orgId,
+          signed: refreshedSigned,
+        })
+      ).type,
+    ).toBe('pending')
+    const waiting = await Transfer.create(db, {
+      apiKeyId: 'key_test',
+      environment: 'production',
+      orgId: 'org_solana_waiting',
+      snapshot,
+      subsidyCommitment,
+    })
+    records.push(waiting)
+    expect(
+      (
+        await Transfer.registerSourceTransactions(db, {
+          chainId: snapshot.sourceChain.id,
+          id: waiting.id,
+          providerState: {},
+          transactionHashes: [sourceHash],
+        })
+      ).type,
+    ).toBe('registered')
+    const deferred = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => false,
+      id: waiting.id,
+      orgId: waiting.orgId,
+      prepare: async () => {
+        throw new Error('A shared transfer prepared during owner recovery.')
+      },
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(deferred.type).toBe('pending')
+    const latestTransaction = compileTransaction(
+      setTransactionMessageLifetimeUsingBlockhash(
+        {
+          blockhash: blockhash(Base58.fromBytes(crypto.getRandomValues(new Uint8Array(32)))),
+          lastValidBlockHeight: 0n,
+        },
+        message,
+      ),
+    )
+    const latestPrepared: SolanaTransferSubsidy.Prepared = {
+      ...refreshed,
+      lastValidBlockHeight: 123700,
+      originSlot: 123550,
+      request: {
+        ...refreshed.request,
+        transaction: Buffer.from(getTransactionEncoder().encode(latestTransaction)).toString(
+          'base64',
+        ),
+      },
+    }
+    const next = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => false,
+      id: records[0]!.id,
+      orgId: records[0]!.orgId,
+      prepare: async () => latestPrepared,
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(next.type).toBe('prepared')
+    if (next.type !== 'prepared') throw new Error('Expected a fresh Solana subsidy request.')
+    const latestSignature = signatureBytes(
+      ed25519.sign(Buffer.from(latestTransaction.messageBytes), secret),
+    )
+    const latestSigned: SolanaTransferSubsidy.Signed = {
+      ...latestPrepared,
+      hash: Base58.fromBytes(latestSignature),
+      transaction: Buffer.from(
+        getTransactionEncoder().encode({
+          ...latestTransaction,
+          signatures: { [account]: latestSignature },
+        }),
+      ).toString('base64'),
+    }
+    expect(
+      (await Transfer.signSolanaSubsidy(db, { id: records[0]!.id, signed: latestSigned })).type,
+    ).toBe('signed')
+    const synchronized = await Transfer.syncSharedSolanaSubsidy(db, {
+      id: records[1]!.id,
+      orgId: records[1]!.orgId,
+      signed: refreshedSigned,
+    })
+    expect(synchronized.type).toBe('synchronized')
+    if (synchronized.type !== 'synchronized') throw new Error('Expected shared Solana replacement.')
+    expect(synchronized.record.subsidyTransactionHash).toBe(latestSigned.hash)
+    expect(synchronized.record.subsidyAmount).toBeNull()
+    const joined = await Transfer.prepareSolanaSubsidy(db, {
+      account: prepared.account,
+      chainId,
+      expiring: async () => false,
+      id: waiting.id,
+      orgId: waiting.orgId,
+      prepare: async () => {
+        throw new Error('A shared source produced a second subsidy.')
+      },
+      subsidyAmount: amount,
+      tokenAddress: token,
+    })
+    expect(joined.type).toBe('shared')
+    if (joined.type !== 'shared') throw new Error('Expected shared Solana replacement.')
+    expect(joined.record.subsidyTransactionHash).toBe(latestSigned.hash)
+    for (const record of records)
+      expect(
+        (
+          await Transfer.complete(db, {
+            chainId,
+            destinationAmount: snapshot.destinationAmount!,
+            id: record.id,
+            transactionHashes: [
+              Base58.fromBytes(crypto.getRandomValues(new Uint8Array(32))),
+              latestSigned.hash,
+            ],
+          })
+        ).type,
+      ).toBe('completed')
+    expect((await RoutesTransfers.listUnreportedSubsidies(db)).map(({ id }) => id)).toEqual([
+      records[0]!.id,
+    ])
+  })
+})

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

@@ -201,10 +201,14 @@ describe('create', () => {
           {
             "nativeAmount": 0n,
             "tokenAmount": 0n,
+            "tokenAmounts": {},
           },
           {
             "nativeAmount": 100n,
             "tokenAmount": 20000n,
+            "tokenAmounts": {
+              "0x6666666666666666666666666666666666666666": 20000n,
+            },
           },
         ],
         "rows": [
@@ -540,6 +544,50 @@ describe('registerSourceTransactions', () => {
 })
 
 describe('reopenSourceTransaction', () => {
+  test('security: retains the pinned payer and cap when reorg recovery replaces provider evidence', async () => {
+    const routePolicy = {
+      maxAmount: '0.05',
+      scope: { apiKeyId: 'key_test', environment: 'production', orgId: 'org_test' },
+      subsidyPayer: 'tempo',
+      versions: [1, 2],
+    }
+    const routePolicyKey = '["tempo","0.050000"]'
+    const routeConfiguration = { poolAddress: `0x${'cc'.repeat(20)}` }
+    const record = await Transfer.create(
+      db,
+      createInput({
+        providerState: { routePolicy, routePolicyKey },
+        snapshot: TestRoutes.transferSnapshot({ provider: { id: 'stargate', name: 'Stargate' } }),
+      }),
+    )
+    const transactionHash = `0x${'b4'.repeat(32)}`
+    const registered = await Transfer.registerSourceTransactions(db, {
+      chainId: record.snapshot.sourceChain.id,
+      id: record.id,
+      providerState: {
+        destinationBlockNumber: '123',
+        routeConfiguration,
+        stargate: { guid: `0x${'bb'.repeat(32)}`, sourceEid: 30_184 },
+      },
+      transactionHashes: [transactionHash],
+    })
+    expect(registered.type).toBe('registered')
+    expect((await RoutesTransfers.get(db, record.id))?.providerState).toMatchObject({ routePolicy })
+
+    // Stargate's reorg result contains only the parsed provider fields, minus
+    // stargate evidence. Financial terms must survive independently of it.
+    const reopened = await Transfer.reopenSourceTransaction(db, {
+      chainId: record.snapshot.sourceChain.id,
+      id: record.id,
+      providerState: { destinationBlockNumber: '123', routeConfiguration },
+      transactionHash,
+    })
+    expect(reopened.type).toBe('reopened')
+    const stored = await RoutesTransfers.get(db, record.id)
+    expect(stored?.providerState).not.toHaveProperty('stargate')
+    expect(stored?.providerState).toMatchObject({ routePolicy, routePolicyKey })
+  })
+
   test('removes invalidated source evidence and accepts a replacement', async () => {
     const record = await Transfer.create(db, createInput())
     const transactionHash = `0x${'a4'.repeat(32)}`
@@ -619,12 +667,59 @@ describe('complete', () => {
       }
     `)
   })
+
+  test('replays an uppercase Tron transaction id without changing its case', async () => {
+    const tron = TestRoutes.depositAddressSnapshot()
+    const record = await Transfer.create(
+      db,
+      createInput({
+        snapshot: TestRoutes.transferSnapshot({
+          destinationChain: tron.sourceChain,
+          destinationToken: tron.sourceToken,
+          recipient: tron.refundAddress!,
+        }),
+      }),
+    )
+    await Transfer.registerSourceTransactions(db, {
+      chainId: 'eip155:8453',
+      id: record.id,
+      providerState: {},
+      transactionHashes: [`0x${'f6'.repeat(32)}`],
+    })
+    const transactionHash = 'AB'.repeat(32)
+    const options = {
+      chainId: tron.sourceChain.id,
+      destinationAmount: record.snapshot.destinationAmount!,
+      id: record.id,
+      transactionHashes: [transactionHash] as const,
+    }
+    const completed = await Transfer.complete(db, options)
+    const replayed = await Transfer.complete(db, options)
+    const changedCase = await Transfer.complete(db, {
+      ...options,
+      transactionHashes: [transactionHash.toLowerCase()],
+    })
+    expect({
+      completed: completed.type,
+      destinationTransactionHashes:
+        completed.type === 'completed'
+          ? completed.record.snapshot.destinationTransactionHashes
+          : undefined,
+      replayed: replayed.type,
+      changedCase: changedCase.type,
+    }).toEqual({
+      completed: 'completed',
+      destinationTransactionHashes: [transactionHash],
+      replayed: 'replayed',
+      changedCase: 'invalid',
+    })
+  })
 })
 
 describe('reserveSubsidy', () => {
   test('shares one signed subsidy across concurrent tenants and bills its owner once', async () => {
     const database = TestApp.databaseFactory()
-    const account = Anvil.getAccount(0)
+    const account = Anvil.getSubsidyAccount(0)
     const base = TestRoutes.transferSnapshot()
     const snapshot = TestRoutes.transferSnapshot({
       destinationChain: base.sourceChain,
@@ -842,10 +937,16 @@ describe('reserveSubsidy', () => {
           {
             "nativeAmount": 100n,
             "tokenAmount": 3001n,
+            "tokenAmounts": {
+              "0x2222222222222222222222222222222222222222": 3001n,
+            },
           },
           {
             "nativeAmount": 100n,
             "tokenAmount": 3001n,
+            "tokenAmounts": {
+              "0x2222222222222222222222222222222222222222": 3001n,
+            },
           },
         ],
         "nonces": [
@@ -959,6 +1060,34 @@ describe('reserveSubsidy', () => {
 })
 
 describe('transition', () => {
+  test.each([null, { routePolicy: { subsidyPayer: 'enterprise' }, routePolicyKey: 'replacement' }])(
+    'preserves financial terms when provider state is replaced with %j',
+    async (providerState) => {
+      const routePolicy = {
+        maxAmount: '0.05',
+        scope: { environment: 'production', orgId: 'org_test' },
+        subsidyPayer: 'tempo',
+        versions: [1],
+      }
+      const routePolicyKey = '["tempo","0.050000"]'
+      const record = await Transfer.create(
+        db,
+        createInput({ providerState: { routePolicy, routePolicyKey, oldEvidence: true } }),
+      )
+      const result = await Transfer.transition(db, {
+        expectedVersion: record.version,
+        id: record.id,
+        providerState,
+        status: 'processing',
+      })
+      expect(result.type).toBe('applied')
+      expect((await RoutesTransfers.get(db, record.id))?.providerState).toEqual({
+        routePolicy,
+        routePolicyKey,
+      })
+    },
+  )
+
   test('applies a guarded status change and appends an event', async () => {
     const record = await Transfer.create(db, createInput())
     vi.setSystemTime(new Date('2026-01-01T00:00:10.000Z'))