mppx 0.4.9 → 0.4.11

package/src/Challenge.fuzz.test.ts

@@ -0,0 +1,121 @@
+import * as fc from 'fast-check'
+import { Challenge } from 'mppx'
+import { describe, expect, test } from 'vp/test'
+
+describe('parseAuthParams robustness', () => {
+  test('deserialize never throws unhandled exception on arbitrary input', () => {
+    fc.assert(
+      fc.property(fc.string(), (input) => {
+        try {
+          Challenge.deserialize(input)
+        } catch (e) {
+          if (!(e instanceof Error)) throw e
+          if (e instanceof TypeError || e instanceof RangeError) throw e
+        }
+      }),
+      { numRuns: 10_000 },
+    )
+  })
+})
+
+describe('adversarial header strings', () => {
+  const adversarialHeader = fc.oneof(
+    // Deeply nested quotes
+    fc.string().map((s) => `Payment ${s}`),
+    // Unterminated quotes
+    fc.string().map((s) => `Payment id="${s}`),
+    // Escaped characters at boundary
+    fc.string().map((s) => `Payment id="\\${s}"`),
+    // Many commas
+    fc.nat({ max: 100 }).map((n) => `Payment ${',,,,'.repeat(n)}`),
+    // Very long keys
+    fc
+      .string({ minLength: 1000, maxLength: 5000 })
+      .map((s) => `Payment ${s.replace(/[^a-z]/g, 'a')}="val"`),
+    // NUL and control characters
+    fc
+      .uint8Array({ minLength: 1, maxLength: 200 })
+      .map((arr) => `Payment id="${String.fromCharCode(...arr)}"`),
+  )
+
+  test('adversarial headers never cause unhandled exceptions', () => {
+    fc.assert(
+      fc.property(adversarialHeader, (input) => {
+        try {
+          Challenge.deserialize(input)
+        } catch (e) {
+          if (!(e instanceof Error)) throw e
+          if (e instanceof TypeError || e instanceof RangeError) throw e
+        }
+      }),
+      { numRuns: 10_000 },
+    )
+  })
+})
+
+describe('serialize/deserialize roundtrip', () => {
+  const challengeArb = fc.record({
+    id: fc.string({ minLength: 1 }).filter((s) => /^[A-Za-z0-9_-]+$/.test(s)),
+    realm: fc.string({ minLength: 1 }).filter((s) => /^[A-Za-z0-9._-]+$/.test(s)),
+    method: fc.string({ minLength: 1 }).filter((s) => /^[a-z][a-z0-9:_-]*$/.test(s)),
+    intent: fc.string({ minLength: 1 }).filter((s) => /^[a-z][a-z0-9_-]*$/.test(s)),
+    request: fc.dictionary(
+      fc
+        .string({ minLength: 1 })
+        .filter((s) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s) && s !== '__proto__'),
+      fc.oneof(fc.string(), fc.integer().map(String), fc.boolean().map(String)),
+    ),
+  })
+
+  test('serialize then deserialize produces equivalent challenge', () => {
+    fc.assert(
+      fc.property(challengeArb, (input) => {
+        const serialized = Challenge.serialize(input as Challenge.Challenge)
+        const deserialized = Challenge.deserialize(serialized)
+
+        expect(deserialized.id).toBe(input.id)
+        expect(deserialized.realm).toBe(input.realm)
+        expect(deserialized.method).toBe(input.method)
+        expect(deserialized.intent).toBe(input.intent)
+        expect(deserialized.request).toEqual(input.request)
+      }),
+      { numRuns: 1_000 },
+    )
+  })
+})
+
+describe('deserializeList roundtrip', () => {
+  const challengeArb = fc.record({
+    id: fc.string({ minLength: 1 }).filter((s) => /^[A-Za-z0-9_-]+$/.test(s)),
+    realm: fc.string({ minLength: 1 }).filter((s) => /^[A-Za-z0-9._-]+$/.test(s)),
+    method: fc.string({ minLength: 1 }).filter((s) => /^[a-z][a-z0-9:_-]*$/.test(s)),
+    intent: fc.string({ minLength: 1 }).filter((s) => /^[a-z][a-z0-9_-]*$/.test(s)),
+    request: fc.dictionary(
+      fc
+        .string({ minLength: 1 })
+        .filter((s) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s) && s !== '__proto__'),
+      fc.oneof(fc.string(), fc.integer().map(String), fc.boolean().map(String)),
+    ),
+  })
+
+  test('serialize multiple then deserializeList returns all challenges', () => {
+    fc.assert(
+      fc.property(fc.array(challengeArb, { minLength: 1, maxLength: 3 }), (challenges) => {
+        const header = challenges
+          .map((c) => Challenge.serialize(c as Challenge.Challenge))
+          .join(', ')
+        const result = Challenge.deserializeList(header)
+
+        expect(result).toHaveLength(challenges.length)
+        for (let i = 0; i < challenges.length; i++) {
+          expect(result[i]!.id).toBe(challenges[i]!.id)
+          expect(result[i]!.realm).toBe(challenges[i]!.realm)
+          expect(result[i]!.method).toBe(challenges[i]!.method)
+          expect(result[i]!.intent).toBe(challenges[i]!.intent)
+          expect(result[i]!.request).toEqual(challenges[i]!.request)
+        }
+      }),
+      { numRuns: 1_000 },
+    )
+  })
+})

package/src/Challenge.test-d.ts

@@ -1,4 +1,4 @@
-import { assertType, describe, expectTypeOf, test } from 'vitest'
+import { assertType, describe, expectTypeOf, test } from 'vp/test'
 
 import * as Challenge from './Challenge.js'
 import { Method } from './index.js'

package/src/Challenge.test.ts

@@ -1,6 +1,6 @@
 import { Challenge } from 'mppx'
 import { Methods } from 'mppx/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 describe('from', () => {
   test('behavior: creates challenge', () => {

package/src/Credential.fuzz.test.ts

@@ -0,0 +1,62 @@
+import * as fc from 'fast-check'
+import { Challenge, Credential, Receipt } from 'mppx'
+import { describe, expect, test } from 'vp/test'
+
+describe('Credential', () => {
+  test('serialize → deserialize roundtrip', () => {
+    const credentialArb = fc.record({
+      challenge: fc.record({
+        id: fc.string({ minLength: 1 }).filter((s) => /^[A-Za-z0-9_-]+$/.test(s)),
+        realm: fc.string({ minLength: 1 }).filter((s) => /^[^\x00-\x1f]+$/.test(s)),
+        method: fc.string({ minLength: 1 }).filter((s) => /^[a-z][a-z0-9:_-]*$/.test(s)),
+        intent: fc.string({ minLength: 1 }).filter((s) => /^[a-z][a-z0-9_-]*$/.test(s)),
+        request: fc.constant({ amount: '1000' }),
+      }),
+      payload: fc.dictionary(
+        fc.string({ minLength: 1 }).filter((s) => /^[a-zA-Z_]+$/.test(s)),
+        fc.string(),
+      ),
+    })
+
+    fc.assert(
+      fc.property(credentialArb, (input) => {
+        const challenge = Challenge.from(input.challenge)
+        const credential = Credential.from({ challenge, payload: input.payload })
+        const serialized = Credential.serialize(credential)
+        const deserialized = Credential.deserialize(serialized)
+
+        expect(deserialized.challenge.id).toBe(challenge.id)
+        expect(deserialized.challenge.realm).toBe(challenge.realm)
+        expect(deserialized.challenge.method).toBe(challenge.method)
+        expect(deserialized.challenge.intent).toBe(challenge.intent)
+        expect(deserialized.challenge.request).toEqual(challenge.request)
+        expect(deserialized.payload).toEqual(input.payload)
+      }),
+      { numRuns: 1_000 },
+    )
+  })
+})
+
+describe('Receipt', () => {
+  test('serialize → deserialize roundtrip', () => {
+    const receiptArb = fc.record({
+      method: fc.string({ minLength: 1 }).filter((s) => /^[a-z]+$/.test(s)),
+      reference: fc.string({ minLength: 1 }),
+      status: fc.constant('success' as const),
+      timestamp: fc
+        .integer({ min: new Date('2020-01-01').getTime(), max: new Date('2030-01-01').getTime() })
+        .map((t) => new Date(t).toISOString()),
+    })
+
+    fc.assert(
+      fc.property(receiptArb, (input) => {
+        const receipt = Receipt.from(input)
+        const serialized = Receipt.serialize(receipt)
+        const deserialized = Receipt.deserialize(serialized)
+
+        expect(deserialized).toEqual(receipt)
+      }),
+      { numRuns: 1_000 },
+    )
+  })
+})

package/src/Credential.test.ts

@@ -1,5 +1,5 @@
 import { Challenge, Credential } from 'mppx'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 const challenge = Challenge.from({
   id: 'x7Tg2pLqR9mKvNwY3hBcZa',

package/src/Errors.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import {
   AmountExceedsDepositError,

package/src/Expires.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vp/test'
 
 import * as Expires from './Expires.js'
 

package/src/Method.test.ts

@@ -1,5 +1,5 @@
 import { Method, z } from 'mppx'
-import { describe, expect, expectTypeOf, test } from 'vitest'
+import { describe, expect, expectTypeOf, test } from 'vp/test'
 
 describe('from', () => {
   test('behavior: creates intent', () => {

package/src/PaymentRequest.test.ts

@@ -1,6 +1,6 @@
 import { PaymentRequest } from 'mppx'
 import { Methods } from 'mppx/tempo'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 describe('from', () => {
   test('creates a request', () => {

package/src/Receipt.test.ts

@@ -1,5 +1,5 @@
 import { Receipt } from 'mppx'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 describe('from', () => {
   test('behavior: creates receipt with success status', () => {

package/src/Store.test-d.ts

@@ -1,4 +1,4 @@
-import { expectTypeOf, test } from 'vitest'
+import { expectTypeOf, test } from 'vp/test'
 
 import * as Store from './Store.js'
 

package/src/Store.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Store from './Store.js'
 

package/src/cli/cli.test.ts

@@ -6,7 +6,7 @@ import * as path from 'node:path'
 import { parseUnits } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { Addresses } from 'viem/tempo'
-import { afterAll, describe, expect, test } from 'vitest'
+import { afterAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { rpcUrl } from '~test/tempo/prool.js'
 import { deployEscrow } from '~test/tempo/session.js'
@@ -76,6 +76,217 @@ async function serve(argv: string[], options?: { env?: Record<string, string | u
   return { output, stderr, exitCode }
 }
 
+describe('discover validate', () => {
+  test('validates a local discovery document', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-discovery-'))
+    const file = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              requestBody: {
+                content: { 'application/json': { schema: { type: 'object' } } },
+              },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      }),
+    )
+
+    const { output, exitCode } = await serve(['discover', 'validate', file])
+    expect(exitCode).toBeUndefined()
+    expect(output).toContain('Discovery document is valid.')
+  })
+
+  test('returns non-zero for invalid discovery documents', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-discovery-'))
+    const file = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      file,
+      JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              responses: {
+                '200': { description: 'OK' },
+              },
+            },
+          },
+        },
+      }),
+    )
+
+    const { output, exitCode } = await serve(['discover', 'validate', file])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('[error]')
+    expect(output).toContain('402')
+  })
+
+  test(
+    'validates remote discovery documents and reports warnings',
+    { timeout: 20_000 },
+    async () => {
+      const body = JSON.stringify({
+        info: { title: 'Test', version: '1.0.0' },
+        openapi: '3.1.0',
+        paths: {
+          '/search': {
+            post: {
+              'x-payment-info': {
+                amount: '100',
+                intent: 'charge',
+                method: 'tempo',
+              },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      })
+      const server = await Http.createServer((_req, res) => {
+        res.setHeader('Content-Type', 'application/json')
+        res.end(body)
+      })
+
+      try {
+        const { output, exitCode } = await serve(['discover', 'validate', server.url])
+        expect(exitCode).toBeUndefined()
+        expect(output).toContain('[warning]')
+        expect(output).toContain('requestBody')
+        expect(output).toContain('valid with 1 warning')
+      } finally {
+        server.close()
+      }
+    },
+  )
+
+  test(
+    'rejects oversized discovery documents via content-length',
+    { timeout: 20_000 },
+    async () => {
+      const server = await Http.createServer((_req, res) => {
+        res.setHeader('Content-Type', 'application/json')
+        res.setHeader('Content-Length', String(11 * 1024 * 1024))
+        res.end('{}')
+      })
+
+      try {
+        const { exitCode, output } = await serve(['discover', 'validate', server.url])
+        expect(exitCode).toBe(1)
+        expect(output).toContain('10 MB')
+      } finally {
+        server.close()
+      }
+    },
+  )
+})
+
+describe('discover generate', () => {
+  test('generates from a pre-built OpenAPI document module', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'doc.mjs')
+    fs.writeFileSync(
+      mod,
+      `export default ${JSON.stringify({
+        openapi: '3.1.0',
+        info: { title: 'Test', version: '1.0.0' },
+        paths: {
+          '/pay': {
+            post: {
+              'x-payment-info': { amount: '100', intent: 'charge', method: 'tempo' },
+              responses: {
+                '200': { description: 'OK' },
+                '402': { description: 'Payment Required' },
+              },
+            },
+          },
+        },
+      })}`,
+    )
+
+    const { output, exitCode } = await serve(['discover', 'generate', mod])
+    expect(exitCode).toBeUndefined()
+    const doc = JSON.parse(output)
+    expect(doc.openapi).toBe('3.1.0')
+    expect(doc.paths['/pay'].post['x-payment-info'].amount).toBe('100')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+
+  test('writes to file with --output', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'doc.mjs')
+    const outFile = path.join(dir, 'openapi.json')
+    fs.writeFileSync(
+      mod,
+      `export default ${JSON.stringify({
+        openapi: '3.1.0',
+        info: { title: 'Test', version: '1.0.0' },
+        paths: {},
+      })}`,
+    )
+
+    const { output, stderr, exitCode } = await serve([
+      'discover',
+      'generate',
+      mod,
+      '--output',
+      outFile,
+    ])
+    expect(exitCode).toBeUndefined()
+    expect(output).toBe('')
+    expect(stderr).toContain(outFile)
+    const written = JSON.parse(fs.readFileSync(outFile, 'utf-8'))
+    expect(written.openapi).toBe('3.1.0')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+
+  test('errors when module not found', async () => {
+    const { output, exitCode } = await serve([
+      'discover',
+      'generate',
+      '/tmp/nonexistent-mppx-module.mjs',
+    ])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('MODULE_NOT_FOUND')
+  })
+
+  test('errors when module has no mppx or openapi export', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mppx-generate-'))
+    const mod = path.join(dir, 'bad.mjs')
+    fs.writeFileSync(mod, 'export default { foo: "bar" }')
+
+    const { output, exitCode } = await serve(['discover', 'generate', mod])
+    expect(exitCode).toBe(1)
+    expect(output).toContain('INVALID_MODULE')
+
+    fs.rmSync(dir, { recursive: true, force: true })
+  })
+})
+
 describe('basic charge (examples/basic)', () => {
   test('happy path: makes payment and receives response', { timeout: 120_000 }, async () => {
     const { Actions } = await import('viem/tempo')

package/src/cli/cli.ts

@@ -11,6 +11,7 @@ import { tempo as tempoMainnet } from 'viem/chains'
 import * as Challenge from '../Challenge.js'
 import { normalizeHeaders } from '../client/internal/Fetch.js'
 import * as Mppx from '../client/Mppx.js'
+import { validate as validateDiscovery } from '../discovery/Validate.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from './account.js'
 import { loadConfig, resolvePlugin } from './internal.js'
 import type { Plugin } from './plugins/plugin.js'
@@ -915,7 +916,168 @@ export default defineConfig({
   },
 })
 
+const discover = Cli.create('discover', {
+  description: 'Discovery tooling',
+})
+  .command('generate', {
+    description: 'Generate a static OpenAPI discovery document from a module',
+    args: z.object({
+      module: z.string().describe('Path to a module that default-exports a discovery config'),
+    }),
+    options: z.object({
+      output: z.string().optional().describe('Write output to a file instead of stdout'),
+    }),
+    alias: { output: 'o' },
+    async run(c) {
+      const modulePath = path.resolve(c.args.module)
+      if (!fs.existsSync(modulePath)) {
+        return c.error({
+          code: 'MODULE_NOT_FOUND',
+          message: `Module not found: ${modulePath}`,
+          exitCode: 1,
+        })
+      }
+
+      let mod: Record<string, unknown>
+      try {
+        mod = await import(modulePath)
+      } catch (error) {
+        return c.error({
+          code: 'MODULE_IMPORT_FAILED',
+          message: `Failed to import module: ${(error as Error).message}`,
+          exitCode: 1,
+        })
+      }
+
+      const exported = (mod.default ?? mod) as Record<string, unknown>
+
+      // If the export is already a plain OpenAPI doc (has `openapi` key), use it directly.
+      // Otherwise, expect { mppx, ...GenerateConfig } and call generate().
+      let doc: Record<string, unknown>
+      if (typeof exported.openapi === 'string') {
+        doc = exported
+      } else {
+        const { generate } = await import('../discovery/OpenApi.js')
+        const mppx = exported.mppx as { methods: readonly any[]; realm: string }
+        if (!mppx) {
+          return c.error({
+            code: 'INVALID_MODULE',
+            message:
+              'Module must default-export an OpenAPI document (with `openapi` key) or an object with `mppx` (server instance) and `routes`.',
+            exitCode: 1,
+          })
+        }
+        doc = generate(mppx, exported as any)
+      }
+
+      const json = JSON.stringify(doc, null, 2)
+      if (c.options.output) {
+        const outPath = path.resolve(c.options.output)
+        fs.writeFileSync(outPath, `${json}\n`)
+        process.stderr.write(`Wrote ${outPath}\n`)
+      } else {
+        console.log(json)
+      }
+    },
+  })
+  .command('validate', {
+    description: 'Validate an OpenAPI discovery document from a file or URL',
+    args: z.object({
+      input: z.string().describe('Path or URL to a discovery document'),
+    }),
+    async run(c) {
+      const input = c.args.input
+      let raw: string
+      if (/^https?:\/\//.test(input)) {
+        const controller = new AbortController()
+        const timeout = setTimeout(() => controller.abort(), 30_000)
+        let response: Response
+        try {
+          response = await globalThis.fetch(input, { signal: controller.signal })
+        } catch (error) {
+          clearTimeout(timeout)
+          const msg =
+            error instanceof DOMException && error.name === 'AbortError'
+              ? 'Request timed out after 30s'
+              : (error as Error).message
+          return c.error({
+            code: 'DISCOVERY_FETCH_FAILED',
+            message: `Failed to fetch discovery document: ${msg}`,
+            exitCode: 1,
+          })
+        }
+        clearTimeout(timeout)
+        if (!response.ok) {
+          return c.error({
+            code: 'DISCOVERY_FETCH_FAILED',
+            message: `Failed to fetch discovery document: HTTP ${response.status}`,
+            exitCode: 1,
+          })
+        }
+        const maxSize = 10 * 1024 * 1024 // 10 MB
+        const contentLength = response.headers.get('content-length')
+        if (contentLength && Number(contentLength) > maxSize) {
+          return c.error({
+            code: 'DISCOVERY_TOO_LARGE',
+            message: `Discovery document exceeds 10 MB limit`,
+            exitCode: 1,
+          })
+        }
+        raw = await response.text()
+        if (raw.length > maxSize) {
+          return c.error({
+            code: 'DISCOVERY_TOO_LARGE',
+            message: `Discovery document exceeds 10 MB limit`,
+            exitCode: 1,
+          })
+        }
+      } else {
+        const resolved = path.resolve(input)
+        if (!fs.existsSync(resolved)) {
+          return c.error({
+            code: 'DISCOVERY_NOT_FOUND',
+            message: `Discovery document not found: ${resolved}`,
+            exitCode: 1,
+          })
+        }
+        raw = fs.readFileSync(resolved, 'utf-8')
+      }
+
+      let doc: unknown
+      try {
+        doc = JSON.parse(raw)
+      } catch (error) {
+        return c.error({
+          code: 'DISCOVERY_INVALID_JSON',
+          message: `Invalid discovery JSON: ${(error as Error).message}`,
+          exitCode: 1,
+        })
+      }
+
+      const issues = validateDiscovery(doc)
+      for (const issue of issues) console.log(`[${issue.severity}] ${issue.path}: ${issue.message}`)
+
+      const errorCount = issues.filter((issue) => issue.severity === 'error').length
+      const warningCount = issues.filter((issue) => issue.severity === 'warning').length
+
+      if (errorCount > 0) {
+        return c.error({
+          code: 'DISCOVERY_INVALID',
+          message: `Discovery document has ${errorCount} error(s) and ${warningCount} warning(s).`,
+          exitCode: 1,
+        })
+      }
+
+      console.log(
+        warningCount > 0
+          ? `Discovery document is valid with ${warningCount} warning(s).`
+          : 'Discovery document is valid.',
+      )
+    },
+  })
+
 cli.command(account)
+cli.command(discover)
 cli.command(init)
 cli.command(sign)
 

package/src/client/Mppx.test-d.ts

@@ -1,5 +1,5 @@
 import type { Account } from 'viem'
-import { describe, expectTypeOf, test } from 'vitest'
+import { describe, expectTypeOf, test } from 'vp/test'
 
 import * as Method from '../Method.js'
 import { charge } from '../tempo/client/Charge.js'

package/src/client/Mppx.test.ts

@@ -2,7 +2,7 @@ import { Challenge, Credential, Mcp, Method, Receipt } from 'mppx'
 import { Mppx, Transport, tempo } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { Methods } from 'mppx/tempo'
-import { afterEach, describe, expect, test } from 'vitest'
+import { afterEach, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'