tapimo 0.13.0 → 0.15.0

package/src/apps/mpp/internal/Sponsorship.test.ts

@@ -0,0 +1,207 @@
+import { Address } from 'ox'
+import { SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
+
+import * as TestApp from '../../../../test/App.js'
+import * as Tempo from '../../../../test/Tempo.js'
+import * as BillingSettings from '../../../db/tables/billingSettings.js'
+import * as SponsoredTransactions from '../../../db/tables/sponsoredTransactions.js'
+import type * as Auth from '../../../internal/Auth.js'
+import * as VerifiedTokens from '../../../internal/VerifiedTokens.js'
+import * as Zones from '../../Zones.js'
+import * as Sponsorship from './Sponsorship.js'
+
+const zones = new Map(Zones.chains.map((zone) => [zone.id, zone]))
+const mainnetChainIds = [4217, Zones.zoneMainnetInternal.id, Zones.zoneDeel.id]
+const feeToken = Address.from(Tempo.currency)
+const principal = {
+  apiKey: {
+    allowedIps: [],
+    environment: 'production',
+    id: 'key_mpp',
+    orgId: 'org_mpp',
+    scopes: ['mpp:write', '*'],
+  },
+  environment: 'production',
+  id: 'key_mpp',
+  orgId: 'org_mpp',
+  type: 'api_key',
+} satisfies Auth.Principal
+const token = {
+  address: feeToken,
+  currency: 'USD',
+  decimals: 6,
+  name: 'Path USD',
+  symbol: 'pathUSD',
+}
+
+describe('record', () => {
+  test.each(mainnetChainIds)(
+    'records chain %s as billable and eligible for metering',
+    async (chainId) => {
+      const db = TestApp.database()
+      await VerifiedTokens.replace(db, chainId, [token])
+      await Sponsorship.record({
+        db,
+        dbCached: db,
+        principal,
+        serializedTransaction: await transaction({ chainId }),
+        txFeeLimit: 1_000_000n,
+        zones,
+      })
+      const [record] = await SponsoredTransactions.listPending(db)
+      expect(record).toMatchObject({
+        billable: true,
+        chainId,
+        currency: 'usd',
+        feeMax: '600000',
+        feeToken: Tempo.currency,
+        orgId: principal.orgId,
+      })
+      await SponsoredTransactions.finalize(db, record!.id, {
+        feeAmount: '500000',
+        finalizedAt: new Date().toISOString(),
+      })
+      expect(
+        await SponsoredTransactions.listUnreported(db, { chainIds: mainnetChainIds }),
+      ).toMatchObject([{ billable: true, chainId, feeAmount: '500000' }])
+    },
+  )
+
+  test.each([undefined, { ...token, currency: 'EUR' }, { ...token, decimals: 18 }])(
+    'rejects an unsupported Zone fee token %j',
+    async (verified) => {
+      const db = TestApp.database()
+      const chainId = Zones.zoneDeel.id
+      await VerifiedTokens.replace(db, chainId, verified ? [verified] : [])
+      await expect(
+        Sponsorship.record({
+          db,
+          dbCached: db,
+          principal,
+          serializedTransaction: await transaction({ chainId }),
+          txFeeLimit: 1_000_000n,
+          zones,
+        }),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `[Mpp.Policy.PolicyDeniedError: Fee-sponsored transaction uses an unsupported fee token.]`,
+      )
+      expect(await SponsoredTransactions.listPending(db)).toMatchInlineSnapshot(`[]`)
+    },
+  )
+
+  test.each([
+    { orgLimit: '1.00', platformLimit: 500_000n },
+    { orgLimit: '0.50', platformLimit: 1_000_000n },
+  ])('enforces Zone caps $orgLimit and $platformLimit', async ({ orgLimit, platformLimit }) => {
+    const db = TestApp.database()
+    const chainId = Zones.zoneDeel.id
+    await VerifiedTokens.replace(db, chainId, [token])
+    await BillingSettings.upsert(db, { orgId: principal.orgId, txFeeLimit: orgLimit })
+    await expect(
+      Sponsorship.record({
+        db,
+        dbCached: db,
+        principal,
+        serializedTransaction: await transaction({ chainId }),
+        txFeeLimit: platformLimit,
+        zones,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Mpp.Policy.PolicyDeniedError: Transaction fee limit exceeded.]`,
+    )
+    expect(await SponsoredTransactions.listPending(db)).toMatchInlineSnapshot(`[]`)
+  })
+
+  test.each([
+    [4217, Zones.zoneDeel.id],
+    [Zones.zoneDeel.id, 4217],
+    [Zones.zoneMainnetInternal.id, Zones.zoneDeel.id],
+    [Zones.zoneDeel.id, Zones.zoneDeel.id],
+  ])('shares the organization spend limit between chains %s and %s', async (first, second) => {
+    const db = TestApp.database()
+    for (const chainId of new Set([first, second]))
+      await VerifiedTokens.replace(db, chainId, [token])
+    await BillingSettings.upsert(db, { orgId: principal.orgId, spendLimit: '1.00' })
+    const options = { db, dbCached: db, principal, txFeeLimit: 1_000_000n, zones }
+    await Sponsorship.record({
+      ...options,
+      serializedTransaction: await transaction({ chainId: first }),
+    })
+    await expect(
+      Sponsorship.record({
+        ...options,
+        serializedTransaction: await transaction({ chainId: second, nonce: 1 }),
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Mpp.Policy.PolicyDeniedError: Spend limit exceeded.]`,
+    )
+    expect(await SponsoredTransactions.listPending(db)).toHaveLength(1)
+  })
+
+  test('rejects a sandbox key at mainnet Zone recording', async () => {
+    const db = TestApp.database()
+    await expect(
+      Sponsorship.record({
+        db,
+        dbCached: db,
+        principal: { ...principal, environment: 'sandbox' },
+        serializedTransaction: await transaction({ chainId: Zones.zoneDeel.id }),
+        txFeeLimit: 1_000_000n,
+        zones,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Mpp.Policy.PolicyDeniedError: Mainnet fee sponsorship requires a production API key.]`,
+    )
+    expect(await SponsoredTransactions.listPending(db)).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('keeps sandbox testnet Zone sponsorship non-billable', async () => {
+    const db = TestApp.database()
+    await BillingSettings.upsert(db, {
+      orgId: principal.orgId,
+      spendLimit: '0.00',
+      txFeeLimit: '0.00',
+    })
+    await Sponsorship.record({
+      db,
+      dbCached: db,
+      principal: { ...principal, environment: 'sandbox' },
+      serializedTransaction: await transaction({ chainId: Zones.zoneModeratoInternal.id }),
+      txFeeLimit: 1n,
+      zones,
+    })
+    expect(await SponsoredTransactions.listPending(db)).toMatchObject([
+      { billable: false, chainId: Zones.zoneModeratoInternal.id, environment: 'sandbox' },
+    ])
+  })
+})
+
+async function transaction(options: transaction.Options) {
+  const serialized = await Tempo.accounts[0].signTransaction({
+    calls: [{ data: '0x', to: Tempo.accounts[1].address }],
+    chainId: options.chainId,
+    feePayer: true,
+    gas: 100_000n,
+    maxFeePerGas: 6_000_000_000_000n,
+    maxPriorityFeePerGas: 0n,
+    nonce: options.nonce ?? 0,
+  })
+  const envelope = {
+    ...TxEnvelopeTempo.deserialize(serialized as TxEnvelopeTempo.Serialized),
+    feeToken,
+  }
+  const signature = SignatureEnvelope.from(
+    await Tempo.accounts[2].sign({
+      hash: TxEnvelopeTempo.getFeePayerSignPayload(envelope, { sender: Tempo.accounts[0].address }),
+    }),
+  )
+  if (signature.type !== 'secp256k1') throw new Error('Expected a secp256k1 fee-payer signature.')
+  return TxEnvelopeTempo.serialize(envelope, { feePayerSignature: signature.signature })
+}
+
+declare namespace transaction {
+  type Options = {
+    chainId: number
+    nonce?: number | undefined
+  }
+}

package/src/apps/mpp/internal/Sponsorship.ts

@@ -3,6 +3,7 @@ import { TxEnvelopeTempo } from 'ox/tempo'
 import type { LocalAccount } from 'viem/accounts'
 import { TokenId, Transaction } from 'viem/tempo'
 
+import type * as App from '../../../App.js'
 import type * as Auth from '../../../internal/Auth.js'
 import * as BillingSettings from '../../../db/tables/billingSettings.js'
 import type * as Db from '../../../db/Db.js'
@@ -11,6 +12,7 @@ import * as Fees from '../../../internal/Fees.js'
 import * as VerifiedTokens from '../../../internal/VerifiedTokens.js'
 import * as Viem from '../../../internal/Viem.js'
 import * as Billing from '../../management/Billing.js'
+import * as Zones from '../../Zones.js'
 import * as Policy from './Policy.js'
 
 /** Wraps a managed fee payer to record its signed transaction before broadcast. */
@@ -50,7 +52,7 @@ type SponsoredTransaction = {
 
 /** Records a sponsorship and atomically enforces its billing limits. */
 export async function record(options: record.Options): Promise<void> {
-  const { db, dbCached, principal, serializedTransaction, txFeeLimit } = options
+  const { db, dbCached, principal, serializedTransaction, txFeeLimit, zones } = options
   const transaction = Transaction.deserialize(serializedTransaction) as SponsoredTransaction
   if (!transaction.from)
     throw new Policy.PolicyDeniedError('Fee-sponsored transaction must declare a sender.')
@@ -70,7 +72,9 @@ export async function record(options: record.Options): Promise<void> {
       throw new Policy.PolicyDeniedError('Fee-sponsored transaction uses an invalid fee token.')
     }
   })()
-  const mainnet = Viem.isMainnet(chainId)
+  const mainnet = Viem.isMainnet(zones.get(chainId)?.sourceId ?? chainId)
+  if (mainnet && principal.environment !== 'production')
+    throw new Policy.PolicyDeniedError('Mainnet fee sponsorship requires a production API key.')
   const settings = mainnet ? await BillingSettings.get(db, principal.orgId) : undefined
 
   let currency: string | undefined
@@ -116,7 +120,7 @@ export async function record(options: record.Options): Promise<void> {
   }
   try {
     await SponsoredTransactions.reserve(db, input, {
-      chainIds: [Viem.chainId.mainnet],
+      chainIds: Zones.chainIds({ sourceId: Viem.chainId.mainnet, zones: zones.values() }),
       max: Billing.toBaseUnits(settings.spendLimit),
       since: Billing.periodStart(settings.period),
     })
@@ -140,5 +144,7 @@ export declare namespace record {
     serializedTransaction: `0x${string}`
     /** Platform per-transaction cap in fee-token base units. */
     txFeeLimit: bigint
+    /** Configured Zones and their parent chains. */
+    zones: App.Environment['Variables']['zones']
   }
 }