mppx 0.1.1 → 0.2.1

package/src/Intent.test.ts

@@ -1,180 +0,0 @@
-import { Intent } from 'mppx'
-import { describe, expect, test } from 'vitest'
-
-describe('charge', () => {
-  test('behavior: validates valid request', () => {
-    const result = Intent.charge.schema.request.parse({
-      amount: '1000',
-      currency: 'USD',
-      decimals: 6,
-    })
-    expect(result.amount).toBe('1000000000')
-    expect(result.currency).toBe('USD')
-    expect(result.expires).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-  })
-
-  test('behavior: validates with all optional fields', () => {
-    expect(
-      Intent.charge.schema.request.parse({
-        amount: '1000',
-        currency: 'USD',
-        decimals: 6,
-        description: 'Test payment',
-        expires: '2030-01-01T00:00:00Z',
-        externalId: 'order-123',
-        recipient: '0x1234567890abcdef',
-      }),
-    ).toMatchInlineSnapshot(`
-      {
-        "amount": "1000000000",
-        "currency": "USD",
-        "description": "Test payment",
-        "expires": "2030-01-01T00:00:00Z",
-        "externalId": "order-123",
-        "recipient": "0x1234567890abcdef",
-      }
-    `)
-  })
-
-  test('error: invalid amount (non-numeric)', () => {
-    expect(() =>
-      Intent.charge.schema.request.parse({
-        amount: 'abc',
-        currency: 'USD',
-      }),
-    ).toThrowErrorMatchingInlineSnapshot(`
-      [$ZodError: [
-        {
-          "origin": "string",
-          "code": "invalid_format",
-          "format": "regex",
-          "pattern": "/^\\\\d+(\\\\.\\\\d+)?$/",
-          "path": [
-            "amount"
-          ],
-          "message": "Invalid amount"
-        },
-        {
-          "expected": "number",
-          "code": "invalid_type",
-          "path": [
-            "decimals"
-          ],
-          "message": "Invalid input"
-        }
-      ]]
-    `)
-  })
-
-  test('error: invalid amount (decimal)', () => {
-    expect(() =>
-      Intent.charge.schema.request.parse({
-        amount: '100.50',
-        currency: 'USD',
-      }),
-    ).toThrowErrorMatchingInlineSnapshot(`
-      [$ZodError: [
-        {
-          "expected": "number",
-          "code": "invalid_type",
-          "path": [
-            "decimals"
-          ],
-          "message": "Invalid input"
-        }
-      ]]
-    `)
-  })
-
-  test('error: invalid expires (not ISO 8601)', () => {
-    expect(() =>
-      Intent.charge.schema.request.parse({
-        amount: '1000',
-        currency: 'USD',
-        expires: 'not-a-date',
-      }),
-    ).toThrowErrorMatchingInlineSnapshot(`
-      [$ZodError: [
-        {
-          "expected": "number",
-          "code": "invalid_type",
-          "path": [
-            "decimals"
-          ],
-          "message": "Invalid input"
-        },
-        {
-          "origin": "string",
-          "code": "invalid_format",
-          "format": "regex",
-          "pattern": "/^\\\\d{4}-\\\\d{2}-\\\\d{2}T\\\\d{2}:\\\\d{2}:\\\\d{2}(?:\\\\.\\\\d+)?(?:Z|[+-]\\\\d{2}:\\\\d{2})$/",
-          "path": [
-            "expires"
-          ],
-          "message": "Invalid ISO 8601 datetime"
-        }
-      ]]
-    `)
-  })
-})
-
-describe('session', () => {
-  test('behavior: converts amount to base units', () => {
-    const result = Intent.session.schema.request.parse({
-      amount: '0.000025',
-      unitType: 'llm_token',
-      currency: '0x20c0000000000000000000000000000000000001',
-      decimals: 6,
-      recipient: '0x1234567890abcdef1234567890abcdef12345678',
-    })
-    expect(result.amount).toBe('25')
-    expect(result.unitType).toBe('llm_token')
-    expect(result.currency).toBe('0x20c0000000000000000000000000000000000001')
-    expect(result).not.toHaveProperty('decimals')
-  })
-
-  test('behavior: converts suggestedDeposit to base units', () => {
-    const result = Intent.session.schema.request.parse({
-      amount: '0.000025',
-      unitType: 'llm_token',
-      currency: '0x20c0000000000000000000000000000000000001',
-      decimals: 6,
-      recipient: '0x1234567890abcdef1234567890abcdef12345678',
-      suggestedDeposit: '10',
-    })
-    expect(result.amount).toBe('25')
-    expect(result.suggestedDeposit).toBe('10000000')
-  })
-
-  test('behavior: works without suggestedDeposit', () => {
-    const result = Intent.session.schema.request.parse({
-      amount: '1',
-      unitType: 'request',
-      currency: '0x20c0000000000000000000000000000000000001',
-      decimals: 6,
-    })
-    expect(result.amount).toBe('1000000')
-    expect(result).not.toHaveProperty('suggestedDeposit')
-  })
-
-  test('error: rejects missing decimals', () => {
-    expect(() =>
-      Intent.session.schema.request.parse({
-        amount: '25',
-        unitType: 'llm_token',
-        currency: '0x20c0000000000000000000000000000000000001',
-      }),
-    ).toThrow()
-  })
-
-  test('error: rejects invalid amount', () => {
-    expect(() =>
-      Intent.session.schema.request.parse({
-        amount: 'abc',
-        unitType: 'llm_token',
-        currency: '0x20c0000000000000000000000000000000000001',
-        decimals: 6,
-      }),
-    ).toThrow()
-  })
-})

package/src/Intent.ts

@@ -1,109 +0,0 @@
-import { parseUnits } from 'viem'
-import * as Expires from './Expires.js'
-import * as z from './zod.js'
-
-/**
- * A payment intent.
- */
-export type Intent = {
-  name: string
-  schema: {
-    request: z.z.ZodMiniObject | z.z.ZodMiniPipe<z.z.ZodMiniObject>
-  }
-}
-
-/**
- * Creates an intent.
- *
- * @example
- * ```ts
- * import { z } from 'mppx'
- *
- * const charge = Intent.from({
- *   name: 'charge',
- *   schema: {
- *     request: z.object({
- *       amount: z.string(),
- *       currency: z.string(),
- *       recipient: z.optional(z.string()),
- *     }),
- *   },
- * })
- * ```
- */
-export function from<const intent extends Intent>(intent: intent): intent {
-  return intent
-}
-
-/**
- * Charge intent for one-time immediate payments.
- *
- * @see https://github.com/tempoxyz/payment-auth-spec/blob/main/specs/intents/draft-payment-intent-charge-00.md
- */
-export const charge = from({
-  name: 'charge',
-  schema: {
-    request: z.pipe(
-      z.object({
-        amount: z.amount(),
-        currency: z.string(),
-        decimals: z.number(),
-        description: z.optional(z.string()),
-        expires: z._default(z.datetime(), () => Expires.minutes(5)),
-        externalId: z.optional(z.string()),
-        recipient: z.optional(z.string()),
-      }),
-      // Note: Since the spec states we must have `amount` as a base unit, we
-      // will transform the amount to decimal units based on `decimals`.
-      z.transform(({ amount, decimals, ...rest }) => ({
-        ...rest,
-        amount: parseUnits(amount, decimals).toString(),
-      })),
-    ),
-  },
-})
-
-/**
- * Session intent for pay-as-you-go streaming payments.
- *
- * Uses cumulative vouchers over a payment channel for
- * incremental micropayments without per-request transactions.
- */
-export const session = from({
-  name: 'session',
-  schema: {
-    request: z.pipe(
-      z.object({
-        amount: z.amount(),
-        unitType: z.string(),
-        currency: z.string(),
-        decimals: z.number(),
-        recipient: z.optional(z.string()),
-        suggestedDeposit: z.optional(z.amount()),
-      }),
-      z.transform(({ amount, decimals, suggestedDeposit, ...rest }) => ({
-        ...rest,
-        amount: parseUnits(amount, decimals).toString(),
-        ...(suggestedDeposit
-          ? { suggestedDeposit: parseUnits(suggestedDeposit, decimals).toString() }
-          : {}),
-      })),
-    ),
-  },
-})
-
-/** @internal Extracts shape from an intent's request schema, supporting both object and pipe. */
-export type ShapeOf<intent extends Intent> = intent['schema']['request'] extends z.z.ZodMiniObject
-  ? intent['schema']['request']['shape']
-  : intent['schema']['request'] extends z.z.ZodMiniPipe<infer A>
-    ? A extends z.z.ZodMiniObject
-      ? A['shape']
-      : never
-    : never
-
-/** @internal Extracts the inner object from a pipe or returns the schema directly. */
-export function shapeOf(intent: Intent): Record<string, z.z.ZodMiniType> {
-  const { request } = intent.schema
-  if ('shape' in request) return request.shape as Record<string, z.z.ZodMiniType>
-  return (request as any)._zod.def.in.shape
-}

package/src/MethodIntent.test.ts

@@ -1,303 +0,0 @@
-import { Intent, MethodIntent, z } from 'mppx'
-import { describe, expect, expectTypeOf, test } from 'vitest'
-
-describe('from', () => {
-  test('behavior: creates intent', () => {
-    const intent = MethodIntent.from({
-      method: 'tempo',
-      name: 'charge',
-      schema: {
-        credential: {
-          payload: z.object({
-            signature: z.string(),
-          }),
-        },
-        request: z.object({
-          amount: z.string(),
-          currency: z.string(),
-        }),
-      },
-    })
-
-    expect(intent.name).toBe('charge')
-    expect(intent.method).toBe('tempo')
-    expect(intent.schema.request).toBeDefined()
-    expect(intent.schema.credential.payload).toBeDefined()
-  })
-
-  test('types: name literal is inferred', () => {
-    const intent = MethodIntent.from({
-      method: 'tempo',
-      name: 'charge',
-      schema: {
-        credential: { payload: z.object({ sig: z.string() }) },
-        request: z.object({ amount: z.string() }),
-      },
-    })
-
-    expectTypeOf(intent.name).toEqualTypeOf<'charge'>()
-  })
-
-  test('types: method literal is inferred', () => {
-    const intent = MethodIntent.from({
-      method: 'tempo',
-      name: 'charge',
-      schema: {
-        credential: { payload: z.object({ sig: z.string() }) },
-        request: z.object({ amount: z.string() }),
-      },
-    })
-
-    expectTypeOf(intent.method).toEqualTypeOf<'tempo'>()
-  })
-
-  test('types: schema types are preserved', () => {
-    const requestSchema = z.object({
-      amount: z.string(),
-      currency: z.string(),
-    })
-    const payloadSchema = z.object({
-      signature: z.string(),
-      type: z.literal('transaction'),
-    })
-
-    const intent = MethodIntent.from({
-      method: 'tempo',
-      name: 'charge',
-      schema: {
-        credential: { payload: payloadSchema },
-        request: requestSchema,
-      },
-    })
-
-    expectTypeOf(intent.schema.request).toEqualTypeOf(requestSchema)
-    expectTypeOf(intent.schema.credential.payload).toEqualTypeOf(payloadSchema)
-  })
-})
-
-describe('fromIntent', () => {
-  test('behavior: creates method intent from base intent', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-          currency: z.string(),
-          recipient: z.optional(z.string()),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: {
-          payload: z.object({
-            signature: z.string(),
-            type: z.literal('transaction'),
-          }),
-        },
-        request: {
-          methodDetails: z.object({
-            chainId: z.number(),
-          }),
-          requires: ['recipient'],
-        },
-      },
-    })
-
-    expect(tempoCharge.name).toBe('charge')
-    expect(tempoCharge.method).toBe('tempo')
-    expect(tempoCharge.schema.request).toBeDefined()
-    expect(tempoCharge.schema.credential.payload).toBeDefined()
-  })
-
-  test('types: name and method literals are inferred', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-          currency: z.string(),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: {
-          payload: z.object({ signature: z.string() }),
-        },
-        request: {
-          methodDetails: z.object({}),
-          requires: [],
-        },
-      },
-    })
-
-    expectTypeOf(tempoCharge.name).toEqualTypeOf<'charge'>()
-    expectTypeOf(tempoCharge.method).toEqualTypeOf<'tempo'>()
-  })
-
-  test('types: request output has methodDetails nested', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-          currency: z.string(),
-          recipient: z.optional(z.string()),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: { payload: z.object({}) },
-        request: {
-          methodDetails: z.object({
-            chainId: z.number(),
-          }),
-          requires: [],
-        },
-      },
-    })
-
-    type Input = z.input<typeof tempoCharge.schema.request>
-    expectTypeOf<Input>().toExtend<{
-      amount: string
-      chainId: number
-      currency: string
-    }>()
-
-    type Output = z.output<typeof tempoCharge.schema.request>
-    expectTypeOf<Output>().toExtend<{
-      amount: string
-      currency: string
-      methodDetails?: { chainId: number }
-    }>()
-  })
-
-  test('types: requires makes optional fields required in output type', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-          recipient: z.optional(z.string()),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: { payload: z.object({}) },
-        request: {
-          methodDetails: z.object({}),
-          requires: ['recipient'],
-        },
-      },
-    })
-
-    type Request = z.infer<typeof tempoCharge.schema.request>
-    expectTypeOf<Request>().toMatchTypeOf<{ amount: string; recipient: string }>()
-  })
-
-  test('behavior: request schema includes base intent fields', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-          currency: z.string(),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: { payload: z.object({}) },
-        request: {
-          methodDetails: z.object({}),
-          requires: [],
-        },
-      },
-    })
-
-    const result = tempoCharge.schema.request.safeParse({
-      amount: '100',
-      currency: 'USD',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  test('behavior: request schema includes methodDetails fields', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: { payload: z.object({}) },
-        request: {
-          methodDetails: z.object({
-            chainId: z.number(),
-            recipient: z.string(),
-          }),
-          requires: [],
-        },
-      },
-    })
-
-    const result = tempoCharge.schema.request.safeParse({
-      amount: '100',
-      chainId: 42431,
-      recipient: '0x123',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  test('behavior: requires makes optional fields required', () => {
-    const charge = Intent.from({
-      name: 'charge',
-      schema: {
-        request: z.object({
-          amount: z.string(),
-          recipient: z.optional(z.string()),
-        }),
-      },
-    })
-
-    const tempoCharge = MethodIntent.fromIntent(charge, {
-      method: 'tempo',
-      schema: {
-        credential: { payload: z.object({}) },
-        request: {
-          methodDetails: z.object({}),
-          requires: ['recipient'],
-        },
-      },
-    })
-
-    const withRecipient = tempoCharge.schema.request.safeParse({
-      amount: '100',
-      recipient: '0x123',
-    })
-    expect(withRecipient.success).toBe(true)
-
-    const withoutRecipient = tempoCharge.schema.request.safeParse({
-      amount: '100',
-    })
-    expect(withoutRecipient.success).toBe(false)
-  })
-})