tapimo 0.13.0 → 0.15.0

package/src/admin/apps/scopes.test.ts

@@ -20,13 +20,13 @@ describe('GET /scopes', () => {
             "selfServe": true,
           },
           {
-            "description": "Read organization funding transfers, deposit addresses, and deposits.",
-            "scope": "funding:read",
-            "selfServe": false,
+            "description": "Read organization route transfers, deposit addresses, and deposits.",
+            "scope": "routes:read",
+            "selfServe": true,
           },
           {
-            "description": "Create funding transfers and register their source transactions.",
-            "scope": "funding:write",
+            "description": "Create route transfers and register their source transactions.",
+            "scope": "routes:write",
             "selfServe": false,
           },
           {
@@ -49,6 +49,16 @@ describe('GET /scopes', () => {
             "scope": "mpp:write",
             "selfServe": true,
           },
+          {
+            "description": "Read wallet and Earn vault reward eligibility associations.",
+            "scope": "rewards:read",
+            "selfServe": false,
+          },
+          {
+            "description": "Legacy reward eligibility write scope retained for existing keys; registration requires wildcard access.",
+            "scope": "rewards:write",
+            "selfServe": false,
+          },
           {
             "description": "Fill and submit transactions through the relay.",
             "scope": "rpc-relay:read",

package/src/admin/apps/subsidies.test.ts

@@ -0,0 +1,306 @@
+import { Hash } from 'ox'
+import { TxEnvelopeTempo } from 'ox/tempo'
+
+import type * as Db from '../../db/Db.js'
+import * as Organizations from '../../db/tables/organizations.js'
+import * as Projects from '../../db/tables/projects.js'
+import * as SponsoredTransactions from '../../db/tables/sponsoredTransactions.js'
+import * as Deposit from '../../internal/routes/Deposit.js'
+import * as DepositAddress from '../../internal/routes/DepositAddress.js'
+import * as Transfer from '../../internal/routes/Transfer.js'
+import * as TestAdmin from '../../../test/Admin.js'
+import * as TestApp from '../../../test/App.js'
+import * as TestRoutes from '../../../test/Routes.js'
+import * as TestTempo from '../../../test/Tempo.js'
+import * as AdminSubsidies from './subsidies.js'
+
+describe('GET /subsidies/transactions', () => {
+  test('lists managed fee-payer transactions with attribution and amounts', async () => {
+    const { client, db } = TestAdmin.setup()
+    const { organization, project } = await seedAttribution(db)
+    const feePayer = TestTempo.accounts[0]
+    const sender = TestTempo.accounts[1]
+    const serialized = await sender.signTransaction({
+      calls: [{ to: `0x${'30'.repeat(20)}`, value: 0n }],
+      chainId: 4217,
+      feePayer,
+      feeToken: `0x${'20'.repeat(20)}`,
+      gas: 50_000n,
+      maxFeePerGas: 1n,
+      maxPriorityFeePerGas: 0n,
+      nonce: 0,
+      nonceKey: 0,
+    })
+    const envelope = TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized)
+    if (!envelope.from) throw new Error('Expected a recoverable sender.')
+    const transaction = await SponsoredTransactions.upsert(db, {
+      apiKeyId: 'key_admin_subsidies',
+      billable: true,
+      chainId: 4217,
+      currency: 'usd',
+      environment: 'production',
+      feeMax: '50000',
+      feeToken: `0x${'20'.repeat(20)}`,
+      orgId: organization.id,
+      projectId: project.id,
+      signPayload: TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender: envelope.from }),
+      transaction: serialized,
+      transactionHash: Hash.keccak256(serialized),
+    })
+    await SponsoredTransactions.finalize(db, transaction.id, {
+      feeAmount: '12345',
+      finalizedAt: '2026-09-03T00:01:00.000Z',
+    })
+
+    const response = await client.subsidies.transactions.$get({ query: {} })
+    const body = await TestApp.json(response, AdminSubsidies.schema.listTransactions.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data).toEqual([
+      expect.objectContaining({
+        feeAmount: { baseUnits: '12345', currency: 'USD', decimals: 6, formatted: '0.012345' }, // prettier-ignore
+        feeMaximum: { baseUnits: '50000', currency: 'USD', decimals: 6, formatted: '0.05' }, // prettier-ignore
+        id: transaction.id,
+        organization: { id: organization.id, name: organization.name },
+        project: { id: project.id, name: project.name },
+        status: 'finalized',
+        subsidizerAccount: feePayer.address.toLowerCase(),
+      }),
+    ])
+  })
+})
+
+describe('GET /subsidies/routes', () => {
+  test('lists inbound deposits and outbound transfers with recorded subsidies', async () => {
+    const { client, db } = TestAdmin.setup()
+    const { organization, project } = await seedAttribution(db)
+    const subsidizer = TestTempo.accounts[0]
+    const settlementTransaction = await subsidizer.signTransaction({
+      calls: [{ to: `0x${'40'.repeat(20)}`, value: 0n }],
+      chainId: 4217,
+      feeToken: `0x${'20'.repeat(20)}`,
+      gas: 50_000n,
+      maxFeePerGas: 1n,
+      maxPriorityFeePerGas: 0n,
+      nonce: 1,
+      nonceKey: 0,
+    })
+    const settlementTransactionHash = Hash.keccak256(settlementTransaction)
+    const address = await DepositAddress.create(db, {
+      deliveryStrategy: 'tempo',
+      environment: 'production',
+      now: new Date('2026-09-03T00:00:00.000Z'),
+      orgId: organization.id,
+      projectId: project.id,
+      providerOutputToken: TestRoutes.providerOutputToken(),
+      providerRequestIds: ['provider_address_request'],
+      snapshot: TestRoutes.depositAddressSnapshot({ subsidize: true }),
+    })
+    await Deposit.create(db, {
+      now: new Date('2026-09-03T00:01:00.000Z'),
+      providerRequestId: 'provider_plain',
+      snapshot: TestRoutes.depositSnapshot(address.id),
+      sourceTransactionHash: '11'.repeat(32),
+    })
+    const deposit = await Deposit.create(db, {
+      now: new Date('2026-09-03T00:02:00.000Z'),
+      providerRequestId: 'provider_subsidized',
+      providerSubsidy: {
+        amount: { baseUnits: '23838', currency: 'USD', decimals: 6, formatted: '0.023838' }, // prettier-ignore
+        provider: 'relay',
+        token: address.snapshot.sourceToken,
+      },
+      providerTransactionHashes: [`0x${'44'.repeat(32)}`],
+      settlementTransaction,
+      settlementTransactionHash,
+      snapshot: TestRoutes.depositSnapshot(address.id),
+      sourceTransactionHash: '22'.repeat(32),
+      subsidyAmount: {
+        baseUnits: '0',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0',
+      },
+    })
+    const route = TestRoutes.transferSnapshot()
+    const transfer = await Transfer.create(db, {
+      apiKeyId: 'key_admin_subsidies',
+      environment: 'production',
+      orgId: organization.id,
+      projectId: project.id,
+      snapshot: TestRoutes.transferSnapshot({
+        destinationChain: route.sourceChain,
+        destinationToken: route.sourceToken,
+        sourceChain: route.destinationChain,
+        sourceToken: route.destinationToken,
+      }),
+    })
+    const subsidyTransactionHash = `0x${'55'.repeat(32)}`
+    const subsidized = await Transfer.transition(db, {
+      expectedVersion: transfer.version,
+      id: transfer.id,
+      status: 'processing',
+      subsidyAccount: subsidizer.address,
+      subsidyAmount: {
+        baseUnits: '12000',
+        currency: 'USD',
+        decimals: 6,
+        formatted: '0.012',
+      },
+      subsidyChainId: route.sourceChain.id,
+      subsidyTransactionHash,
+    })
+    if (subsidized.type !== 'applied') throw new Error('Expected outbound subsidy.')
+    const additionalTransfers = []
+    for (let index = 0; index < 4; index++) {
+      const record = await Transfer.create(db, {
+        apiKeyId: 'key_admin_subsidies',
+        environment: 'production',
+        orgId: organization.id,
+        projectId: project.id,
+        snapshot: TestRoutes.transferSnapshot(),
+      })
+      const result = await Transfer.transition(db, {
+        expectedVersion: record.version,
+        id: record.id,
+        subsidyAmount: {
+          baseUnits: String(index + 1),
+          currency: 'USD',
+          decimals: 6,
+          formatted: `0.00000${index + 1}`,
+        },
+      })
+      if (result.type !== 'applied') throw new Error('Expected paginated subsidy.')
+      additionalTransfers.push(record)
+    }
+    await Transfer.create(db, {
+      apiKeyId: 'key_admin_subsidies',
+      environment: 'production',
+      orgId: organization.id,
+      projectId: project.id,
+      snapshot: TestRoutes.transferSnapshot(),
+    })
+
+    const response = await client.subsidies.routes.$get({ query: {} })
+    const body = await TestApp.json(response, AdminSubsidies.schema.listRoutes.Response)
+
+    expect(response.status).toBe(200)
+    expect(body.data).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          direction: 'inbound',
+          id: deposit.id,
+          organization: { id: organization.id, name: organization.name },
+          project: { id: project.id, name: project.name },
+          subsidies: [
+            {
+              amount: { baseUnits: '23838', currency: 'USD', decimals: 6, formatted: '0.023838' }, // prettier-ignore
+              provider: 'relay',
+              token: address.snapshot.sourceToken,
+            },
+          ],
+          subsidizerAccount: subsidizer.address.toLowerCase(),
+          subsidyTransaction: {
+            chainId: address.snapshot.destinationChain.id,
+            transactionRef: settlementTransactionHash,
+          },
+        }),
+        expect.objectContaining({
+          direction: 'outbound',
+          id: transfer.id,
+          organization: { id: organization.id, name: organization.name },
+          project: { id: project.id, name: project.name },
+          subsidies: [
+            {
+              amount: { baseUnits: '12000', currency: 'USD', decimals: 6, formatted: '0.012' }, // prettier-ignore
+              provider: 'tempo',
+              token: route.sourceToken,
+            },
+          ],
+          subsidizerAccount: subsidizer.address.toLowerCase(),
+          subsidyTransaction: {
+            chainId: route.sourceChain.id,
+            transactionRef: subsidyTransactionHash,
+          },
+        }),
+      ]),
+    )
+    expect(body.data).toHaveLength(6)
+
+    const firstResponse = await client.subsidies.routes.$get({ query: { limit: '5' } })
+    const first = await TestApp.json(firstResponse, AdminSubsidies.schema.listRoutes.Response)
+    expect(first.nextCursor).toEqual(expect.any(String))
+    const secondResponse = await client.subsidies.routes.$get({
+      query: { cursor: first.nextCursor!, limit: '5' },
+    })
+    const second = await TestApp.json(secondResponse, AdminSubsidies.schema.listRoutes.Response)
+    expect([...first.data, ...second.data].map(({ id }) => id).sort()).toEqual(
+      [deposit.id, transfer.id, ...additionalTransfers.map(({ id }) => id)].sort(),
+    )
+  })
+
+  test('paginates case-sensitive transfer ids in database order', async () => {
+    const { client, db } = TestAdmin.setup()
+    const { organization, project } = await seedAttribution(db)
+    const updatedAt = new Date('2026-09-03T00:03:00.000Z')
+    vi.useFakeTimers({ now: updatedAt, toFake: ['Date'] })
+    try {
+      const ids = [
+        `rtr_202609030000000_${'A'.repeat(24)}`,
+        `rtr_202609030000000_${'B'.repeat(24)}`,
+        `rtr_202609030000000_${'C'.repeat(24)}`,
+        `rtr_202609030000000_${'a'.repeat(24)}`,
+        `rtr_202609030000000_${'b'.repeat(24)}`,
+        `rtr_202609030000000_${'c'.repeat(24)}`,
+      ]
+      for (const id of ids) {
+        const record = await Transfer.create(db, {
+          apiKeyId: 'key_admin_subsidies',
+          environment: 'production',
+          id,
+          orgId: organization.id,
+          projectId: project.id,
+          snapshot: TestRoutes.transferSnapshot(),
+        })
+        const result = await Transfer.transition(db, {
+          expectedVersion: record.version,
+          id: record.id,
+          subsidyAmount: {
+            baseUnits: '1',
+            currency: 'USD',
+            decimals: 6,
+            formatted: '0.000001',
+          },
+        })
+        if (result.type !== 'applied') throw new Error('Expected subsidized transfer.')
+      }
+
+      const firstResponse = await client.subsidies.routes.$get({ query: { limit: '5' } })
+      const first = await TestApp.json(firstResponse, AdminSubsidies.schema.listRoutes.Response)
+      const secondResponse = await client.subsidies.routes.$get({
+        query: { cursor: first.nextCursor!, limit: '5' },
+      })
+      const second = await TestApp.json(secondResponse, AdminSubsidies.schema.listRoutes.Response)
+
+      expect([...first.data, ...second.data].map(({ id }) => id)).toEqual([
+        ids[5],
+        ids[4],
+        ids[3],
+        ids[2],
+        ids[1],
+        ids[0],
+      ])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+async function seedAttribution(db: Db.Db) {
+  const organization = await Organizations.create(db, {
+    id: 'org_admin_subsidies',
+    name: 'Acme',
+  })
+  const project = await Projects.create(db, { name: 'Checkout', orgId: organization.id })
+  return { organization, project }
+}