tapimo 0.1.0 → 0.3.0

package/src/db/tables/stripeCustomers.ts

@@ -0,0 +1,162 @@
+import type { Selectable } from 'kysely'
+
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `stripe_customers` table, derived from `Schema.StripeCustomer`. */
+export type Table = db_Schema.StripeCustomer
+
+/** A stored Stripe billing-source row. */
+export type Record = Selectable<Table>
+
+/** A billing status. */
+export type Status = Record['status']
+
+/** Billing statuses; `active` alone opens the production sponsorship gate. */
+export const statuses = ['active', 'canceled', 'none', 'past_due'] as const satisfies readonly Status[] // prettier-ignore
+
+/**
+ * Inserts a Stripe billing source (status `none`) and returns the stored record.
+ * Idempotent per organization: a concurrent first-checkout race resolves to
+ * the winner's row — the loser's Stripe customer stays orphaned in Stripe,
+ * which is harmless.
+ *
+ * @param db - The database.
+ * @param input - The Stripe source to insert.
+ * @returns The stored record.
+ */
+export async function create(db: Db.Db, input: create.Input): Promise<Record> {
+  const now = new Date().toISOString()
+  const environment = input.environment ?? 'production'
+  const inserted = await db.kysely
+    .insertInto('stripe_customers')
+    .values({
+      createdAt: now,
+      environment,
+      orgId: input.orgId,
+      status: 'none',
+      stripeCustomerId: input.stripeCustomerId,
+      updatedAt: now,
+    })
+    // Untargeted so it holds against either the org pkey (before the pkey drop
+    // release) or the `(org_id, environment)` unique index (after).
+    .onConflict((oc) => oc.doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  if (inserted) return inserted
+  return await db.kysely
+    .selectFrom('stripe_customers')
+    .selectAll()
+    .where('orgId', '=', input.orgId)
+    .where('environment', '=', environment)
+    .executeTakeFirstOrThrow()
+}
+
+export declare namespace create {
+  /** Fields accepted when inserting a Stripe billing source. */
+  type Input = {
+    /** Environment this source backs; defaults to `production`. */
+    environment?: Record['environment'] | undefined
+    /** Organization id (`org_…`) the Stripe source belongs to. */
+    orgId: string
+    /** Stripe customer id backing this account. */
+    stripeCustomerId: string
+  }
+}
+
+/**
+ * Deletes an organization's Stripe billing source. The Stripe customer is never
+ * deleted; its invoice history stays in Stripe for audit.
+ *
+ * @param db - The database.
+ * @param orgId - The organization id (`org_…`).
+ * @returns Whether a Stripe source existed and was deleted.
+ */
+export async function deleteByOrg(db: Db.Db, orgId: string): Promise<boolean> {
+  const result = await db.kysely
+    .deleteFrom('stripe_customers')
+    .where('orgId', '=', orgId)
+    .executeTakeFirst()
+  return result.numDeletedRows > 0n
+}
+
+/**
+ * Reads an organization's Stripe billing source.
+ *
+ * @param db - The database.
+ * @param orgId - The organization id (`org_…`).
+ * @param environment - The environment to read; defaults to `production`.
+ * @returns The stored record, or `undefined` when the org has none.
+ */
+export function get(
+  db: Db.Db,
+  orgId: string,
+  environment: Record['environment'] = 'production',
+): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('stripe_customers')
+    .selectAll()
+    .where('orgId', '=', orgId)
+    .where('environment', '=', environment)
+    .executeTakeFirst()
+}
+
+/**
+ * Lists every billing source in an environment — the driver set for the cron
+ * job that reconciles cached billing snapshots (e.g. API-key records) against
+ * this authoritative table.
+ *
+ * @param db - The database.
+ * @param environment - The environment to enumerate.
+ * @returns The stored records for that environment.
+ */
+export function listByEnvironment(
+  db: Db.Db,
+  environment: Record['environment'],
+): Promise<Record[]> {
+  return db.kysely
+    .selectFrom('stripe_customers')
+    .selectAll()
+    .where('environment', '=', environment)
+    .execute()
+}
+
+/**
+ * Reads a Stripe billing source by its customer id — the webhook handler's
+ * lookup for inbound events.
+ *
+ * @param db - The database.
+ * @param stripeCustomerId - The Stripe customer id.
+ * @returns The stored record, or `undefined` for unknown customers.
+ */
+export function getByCustomer(db: Db.Db, stripeCustomerId: string): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('stripe_customers')
+    .selectAll()
+    .where('stripeCustomerId', '=', stripeCustomerId)
+    .executeTakeFirst()
+}
+
+/**
+ * Sets an organization's billing status.
+ *
+ * @param db - The database.
+ * @param orgId - The organization id (`org_…`).
+ * @param status - The derived status to persist.
+ * @param environment - The environment to update; defaults to `production`.
+ * @returns The updated record, or `undefined` when the org has no Stripe source.
+ */
+export function setStatus(
+  db: Db.Db,
+  orgId: string,
+  status: Status,
+  environment: Record['environment'] = 'production',
+): Promise<Record | undefined> {
+  return db.kysely
+    .updateTable('stripe_customers')
+    .set({ status, updatedAt: new Date().toISOString() })
+    .where('orgId', '=', orgId)
+    .where('environment', '=', environment)
+    .returningAll()
+    .executeTakeFirst()
+}

package/src/db/tables/users.ts

@@ -0,0 +1,85 @@
+import type { Selectable } from 'kysely'
+
+import * as Id from '../../internal/Id.js'
+import type * as Db from '../Db.js'
+import type * as db_Schema from '../Schema.js'
+
+/** Columns of the `users` table, derived from `Schema.User`. */
+export type Table = db_Schema.User
+
+/** A stored user row. */
+export type Record = Selectable<Table>
+
+/**
+ * Reads a user by id (`usr_…`).
+ *
+ * @param db - The database.
+ * @param id - The user id.
+ * @returns The record, or `undefined` when absent.
+ */
+export function get(db: Db.Db, id: string): Promise<Record | undefined> {
+  return db.kysely.selectFrom('users').selectAll().where('id', '=', id).executeTakeFirst()
+}
+
+/**
+ * Reads a user by wallet address (compared lowercase).
+ *
+ * @param db - The database.
+ * @param address - The wallet address.
+ * @returns The record, or `undefined` when absent.
+ */
+export function getByAddress(db: Db.Db, address: string): Promise<Record | undefined> {
+  return db.kysely
+    .selectFrom('users')
+    .selectAll()
+    .where('address', '=', address.toLowerCase())
+    .executeTakeFirst()
+}
+
+/**
+ * Inserts a user for `address` when absent and returns the stored record.
+ * Existing users are returned unchanged, so repeated sign-ins are idempotent.
+ *
+ * @param db - The database.
+ * @param input - The user to ensure.
+ * @returns The stored record.
+ */
+export async function upsertByAddress(db: Db.Db, input: upsertByAddress.Input): Promise<Record> {
+  const address = input.address.toLowerCase()
+  const now = new Date().toISOString()
+  const inserted = await db.kysely
+    .insertInto('users')
+    .values({ address, createdAt: now, email: null, id: Id.generate('usr'), updatedAt: now })
+    .onConflict((oc) => oc.column('address').doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  if (inserted) return inserted
+  return db.kysely
+    .selectFrom('users')
+    .selectAll()
+    .where('address', '=', address)
+    .executeTakeFirstOrThrow()
+}
+
+export declare namespace upsertByAddress {
+  /** Fields accepted when ensuring a user. */
+  type Input = {
+    /** Wallet address that signed in (stored lowercase). */
+    address: string
+  }
+}
+
+/**
+ * Sets a user's verified email, bumping `updatedAt`.
+ *
+ * @param db - The database.
+ * @param id - The user id (`usr_…`).
+ * @param email - The verified email.
+ */
+export async function setEmail(db: Db.Db, id: string, email: string): Promise<void> {
+  await db.kysely
+    .updateTable('users')
+    .set({ email, updatedAt: new Date().toISOString() })
+    .where('id', '=', id)
+    .execute()
+}

package/src/handlers/internal/executionError.ts

@@ -34,6 +34,7 @@ export const messages: Record<AbiErrorName, string> = {
   ChannelNotFound: 'Channel not found.',
   CloseNotReady: 'Channel is not ready to close.',
   ContractPaused: 'Contract is paused.',
+  DelegateCallNotAllowed: 'Delegate call is not allowed.',
   DepositOverflow: 'Deposit overflow.',
   DivisionByZero: 'Division by zero.',
   EmptyV1ValidatorSet: 'Validator set is empty.',
@@ -65,6 +66,7 @@ export const messages: Record<AbiErrorName, string> = {
   InvalidLogoURI: 'Invalid logo URI.',
   InvalidMasterAddress: 'Invalid master address.',
   InvalidMigrationIndex: 'Invalid migration index.',
+  InvalidMode: 'Invalid mode.',
   InvalidNonceKey: 'Invalid nonce key.',
   InvalidOwner: 'Invalid owner.',
   InvalidPayee: 'Invalid payee.',

package/src/handlers/internal/multisig.test.ts

@@ -1,9 +1,13 @@
 import { Address, Hex, P256 } from 'ox'
 import { MultisigConfig, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
 import { createClient, custom } from 'viem'
+import { prepareTransactionRequest, sendTransactionSync, signTransaction } from 'viem/actions'
 import { Account, Transaction } from 'viem/tempo'
 import { tempoDevnet } from 'viem/tempo/chains'
 
+import * as Relay from '../../../test/Relay.js'
+import * as Runtime from '../../../test/runtime.js'
+import * as StateStore from '../../internal/Store.js'
 import * as Multisig from './multisig.js'
 
 const privateKey_1 = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80'
@@ -245,12 +249,12 @@ describe('config resolution', () => {
     expect({
       hash,
       init: transaction_submitted.signature.init
-        ? MultisigConfig.toId(transaction_submitted.signature.init)
+        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
         : undefined,
     }).toMatchInlineSnapshot(`
       {
         "hash": "${hash}",
-        "init": "${MultisigConfig.toId(account.config)}",
+        "init": "${account.address.toLowerCase()}",
       }
     `)
   })
@@ -311,12 +315,12 @@ describe('config resolution', () => {
     expect({
       hash,
       init: transaction_submitted.signature.init
-        ? MultisigConfig.toId(transaction_submitted.signature.init)
+        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
         : undefined,
     }).toMatchInlineSnapshot(`
       {
         "hash": "${hash}",
-        "init": "${MultisigConfig.toId(account.config)}",
+        "init": "${account.address.toLowerCase()}",
       }
     `)
   })
@@ -376,12 +380,12 @@ describe('config resolution', () => {
     expect({
       hash,
       init: transaction_submitted.signature.init
-        ? MultisigConfig.toId(transaction_submitted.signature.init)
+        ? MultisigConfig.getAddress(transaction_submitted.signature.init)
         : undefined,
     }).toMatchInlineSnapshot(`
       {
         "hash": "${hash}",
-        "init": "${MultisigConfig.toId(account.config)}",
+        "init": "${account.address.toLowerCase()}",
       }
     `)
   })
@@ -474,12 +478,12 @@ describe('config resolution', () => {
       signature: SignatureEnvelope.Multisig
     }
     expect({
+      account: transaction_submitted.signature.account,
       hash,
       init: transaction_submitted.signature.init,
-      genesisConfigId: transaction_submitted.signature.genesisConfigId,
     }).toMatchInlineSnapshot(`
       {
-        "genesisConfigId": "${MultisigConfig.toId(account.config)}",
+        "account": "${account.address.toLowerCase()}",
         "hash": "${hash}",
         "init": undefined,
       }
@@ -566,6 +570,7 @@ describe('handleRawTransaction with sponsor', () => {
       signatures: [signature_2],
     } as never)
     const broadcasted: string[] = []
+    const sponsored: unknown[] = []
 
     await Multisig.handleRawTransaction({
       getClient: (() => undefined) as never,
@@ -593,6 +598,10 @@ describe('handleRawTransaction with sponsor', () => {
       request: { params: [second] },
       sponsor: {
         account: feePayer as never,
+        onSponsored: (event) => {
+          sponsored.push(event)
+          expect(broadcasted).toHaveLength(0)
+        },
         resolveFeeToken: () => feeToken,
       },
       store,
@@ -608,6 +617,7 @@ describe('handleRawTransaction with sponsor', () => {
       feeToken: (transaction_broadcasted['feeToken'] as string).toLowerCase(),
       hash,
       init: Boolean(signature.init),
+      sponsored: sponsored.length,
       signature: signature.type,
     }).toMatchInlineSnapshot(`
       {
@@ -616,6 +626,7 @@ describe('handleRawTransaction with sponsor', () => {
         "hash": "${hash}",
         "init": true,
         "signature": "multisig",
+        "sponsored": 1,
       }
     `)
   })
@@ -706,13 +717,77 @@ describe('handleRawTransaction with sponsor', () => {
   })
 })
 
+describe.runIf(Runtime.get().mode === 'localnet' && process.env.TEMPO_IMAGE_TAG === 'sha-8968664')(
+  'e2e',
+  () => {
+    const owner_1 = Relay.accounts[1]!
+    const owner_2 = Relay.accounts[2]!
+    const feePayer = Relay.accounts[0]!
+    const sponsorFeeToken = Relay.addresses.pathUsd
+    const store = StateStore.memory()
+    let client: ReturnType<typeof Relay.getClient>
+    let server: Relay.Server
+
+    beforeAll(async () => {
+      server = await Relay.createServer(
+        (
+          await Relay.relay({
+            feePayer: {
+              account: feePayer,
+              feeToken: sponsorFeeToken,
+            },
+            multisig: { store },
+          })
+        ).listener,
+      )
+      client = Relay.getClient({ url: server.url })
+    })
+
+    afterAll(() => {
+      server.close()
+    })
+
+    test('behavior: sponsors bootstrap multisig', async () => {
+      const account = Account.fromMultisig({
+        threshold: 2,
+        owners: [
+          { owner: owner_1.address, weight: 1 },
+          { owner: owner_2.address, weight: 1 },
+        ],
+      })
+      const transaction = await prepareTransactionRequest(client, {
+        account,
+        feePayer: true,
+        to: account.address,
+        value: 0n,
+      })
+      const signatures = await Promise.all(
+        [owner_1, owner_2].map((owner) =>
+          signTransaction(client, { ...transaction, account: owner }),
+        ),
+      )
+      const receipt = await sendTransactionSync(client, {
+        ...transaction,
+        account,
+        signatures,
+      })
+
+      expect(receipt).toMatchObject({
+        feePayer: feePayer.address.toLowerCase(),
+        feeToken: sponsorFeeToken.toLowerCase(),
+        from: account.address.toLowerCase(),
+        status: 'success',
+      })
+    })
+  },
+)
+
 function createOperation(): Multisig.Operation {
   const now = Date.now()
   return {
     account: '0x0000000000000000000000000000000000000001',
     chainId: tempoDevnet.id,
     createdAt: now,
-    genesisConfigId: `0x${'11'.repeat(32)}`,
     id: `0x${'22'.repeat(32)}`,
     payload: `0x${'33'.repeat(32)}`,
     signatures: [],
@@ -737,7 +812,6 @@ function withoutInit(serialized: `0x${string}`) {
   return TxEnvelopeTempo.serialize(TxEnvelopeTempo.from(unsigned as never), {
     signature: SignatureEnvelope.from({
       account: signature.account,
-      genesisConfigId: signature.genesisConfigId,
       signatures: signature.signatures,
     }),
   })