mppx 0.6.28 → 0.6.30

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.6.28",
+  "version": "0.6.30",
   "main": "./dist/index.js",
   "license": "MIT",
   "files": [
@@ -11,93 +11,113 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./cli": {
-      "types": "./dist/cli/config.d.ts",
       "src": "./src/cli/config.ts",
+      "types": "./dist/cli/config.d.ts",
       "default": "./dist/cli/config.js"
     },
     "./cli/plugins": {
-      "types": "./dist/cli/plugins/index.d.ts",
       "src": "./src/cli/plugins/index.ts",
+      "types": "./dist/cli/plugins/index.d.ts",
       "default": "./dist/cli/plugins/index.js"
     },
     "./client": {
-      "types": "./dist/client/index.d.ts",
       "src": "./src/client/index.ts",
+      "types": "./dist/client/index.d.ts",
       "default": "./dist/client/index.js"
     },
     "./discovery": {
-      "types": "./dist/discovery/index.d.ts",
       "src": "./src/discovery/index.ts",
+      "types": "./dist/discovery/index.d.ts",
       "default": "./dist/discovery/index.js"
     },
+    "./evm": {
+      "src": "./src/evm/index.ts",
+      "types": "./dist/evm/index.d.ts",
+      "default": "./dist/evm/index.js"
+    },
+    "./evm/client": {
+      "src": "./src/evm/client/index.ts",
+      "types": "./dist/evm/client/index.d.ts",
+      "default": "./dist/evm/client/index.js"
+    },
+    "./evm/server": {
+      "src": "./src/evm/server/index.ts",
+      "types": "./dist/evm/server/index.d.ts",
+      "default": "./dist/evm/server/index.js"
+    },
     "./mcp-sdk/client": {
-      "types": "./dist/mcp-sdk/client/index.d.ts",
       "src": "./src/mcp-sdk/client/index.ts",
+      "types": "./dist/mcp-sdk/client/index.d.ts",
       "default": "./dist/mcp-sdk/client/index.js"
     },
     "./mcp-sdk/server": {
-      "types": "./dist/mcp-sdk/server/index.d.ts",
       "src": "./src/mcp-sdk/server/index.ts",
+      "types": "./dist/mcp-sdk/server/index.d.ts",
       "default": "./dist/mcp-sdk/server/index.js"
     },
     "./proxy": {
-      "types": "./dist/proxy/index.d.ts",
       "src": "./src/proxy/index.ts",
+      "types": "./dist/proxy/index.d.ts",
       "default": "./dist/proxy/index.js"
     },
     "./server": {
-      "types": "./dist/server/index.d.ts",
       "src": "./src/server/index.ts",
+      "types": "./dist/server/index.d.ts",
       "default": "./dist/server/index.js"
     },
     "./stripe": {
-      "types": "./dist/stripe/index.d.ts",
       "src": "./src/stripe/index.ts",
+      "types": "./dist/stripe/index.d.ts",
       "default": "./dist/stripe/index.js"
     },
     "./stripe/client": {
-      "types": "./dist/stripe/client/index.d.ts",
       "src": "./src/stripe/client/index.ts",
+      "types": "./dist/stripe/client/index.d.ts",
       "default": "./dist/stripe/client/index.js"
     },
     "./stripe/server": {
-      "types": "./dist/stripe/server/index.d.ts",
       "src": "./src/stripe/server/index.ts",
+      "types": "./dist/stripe/server/index.d.ts",
       "default": "./dist/stripe/server/index.js"
     },
+    "./x402": {
+      "src": "./src/x402/index.ts",
+      "types": "./dist/x402/index.d.ts",
+      "default": "./dist/x402/index.js"
+    },
     "./tempo": {
-      "types": "./dist/tempo/index.d.ts",
       "src": "./src/tempo/index.ts",
+      "types": "./dist/tempo/index.d.ts",
       "default": "./dist/tempo/index.js"
     },
     "./html": {
-      "types": "./dist/Html.d.ts",
       "src": "./src/Html.ts",
+      "types": "./dist/Html.d.ts",
       "default": "./dist/Html.js"
     },
     "./hono": {
-      "types": "./dist/middlewares/hono.d.ts",
       "src": "./src/middlewares/hono.ts",
+      "types": "./dist/middlewares/hono.d.ts",
       "default": "./dist/middlewares/hono.js"
     },
     "./express": {
-      "types": "./dist/middlewares/express.d.ts",
       "src": "./src/middlewares/express.ts",
+      "types": "./dist/middlewares/express.d.ts",
       "default": "./dist/middlewares/express.js"
     },
     "./nextjs": {
-      "types": "./dist/middlewares/nextjs.d.ts",
       "src": "./src/middlewares/nextjs.ts",
+      "types": "./dist/middlewares/nextjs.d.ts",
       "default": "./dist/middlewares/nextjs.js"
     },
     "./elysia": {
-      "types": "./dist/middlewares/elysia.d.ts",
       "src": "./src/middlewares/elysia.ts",
+      "types": "./dist/middlewares/elysia.d.ts",
       "default": "./dist/middlewares/elysia.js"
     }
   },
@@ -106,7 +126,7 @@
     "elysia": ">=1",
     "express": ">=5",
     "hono": ">=4.12.18",
-    "viem": ">=2.50.4"
+    "viem": ">=2.51.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -124,7 +144,7 @@
   },
   "dependencies": {
     "incur": "^0.4.5",
-    "ox": "0.14.22",
+    "ox": "0.14.24",
     "zod": "^4.4.3"
   },
   "repository": {

package/src/Challenge.test.ts

@@ -453,6 +453,60 @@ describe('serialize', () => {
     expect(header).toContain('digest="sha-256=abc"')
     expect(header).toContain('expires="2025-01-06T12:00:00Z"')
   })
+
+  test.each([
+    {
+      description: 'Plain payment description',
+      escaped: 'Plain payment description',
+      label: 'plain values',
+    },
+    {
+      description: 'Pay "premium"',
+      escaped: 'Pay \\"premium\\"',
+      label: 'double quotes',
+    },
+    {
+      description: 'Path C:\\tempo\\api',
+      escaped: 'Path C:\\\\tempo\\\\api',
+      label: 'backslashes',
+    },
+    {
+      description: 'Pay "premium" path C:\\tempo\\api',
+      escaped: 'Pay \\"premium\\" path C:\\\\tempo\\\\api',
+      label: 'mixed quotes and backslashes',
+    },
+    {
+      description: 'Ends with slash \\',
+      escaped: 'Ends with slash \\\\',
+      label: 'trailing backslash',
+    },
+  ])('behavior: escapes quoted-string values: $label', ({ description, escaped }) => {
+    const challenge = Challenge.from({
+      id: 'abc123',
+      realm: 'api.example.com',
+      method: 'tempo',
+      intent: 'charge',
+      request: { amount: '1000000' },
+      description,
+    })
+
+    const header = Challenge.serialize(challenge)
+    expect(header).toContain(`description="${escaped}"`)
+    expect(Challenge.deserialize(header).description).toBe(description)
+  })
+
+  test('error: rejects CRLF in quoted-string values', () => {
+    const challenge = Challenge.from({
+      id: 'abc123',
+      realm: 'api.example.com',
+      method: 'tempo',
+      intent: 'charge',
+      request: { amount: '1000000' },
+      description: 'Line one\r\nLine two',
+    })
+
+    expect(() => Challenge.serialize(challenge)).toThrow('Invalid quoted-string value.')
+  })
 })
 
 describe('deserialize', () => {

package/src/Challenge.ts

@@ -294,23 +294,30 @@ export declare namespace fromMethod {
  */
 export function serialize(challenge: Challenge): string {
   const parts = [
-    `id="${challenge.id}"`,
-    `realm="${challenge.realm}"`,
-    `method="${challenge.method}"`,
-    `intent="${challenge.intent}"`,
-    `request="${PaymentRequest.serialize(challenge.request)}"`,
+    authParam('id', challenge.id),
+    authParam('realm', challenge.realm),
+    authParam('method', challenge.method),
+    authParam('intent', challenge.intent),
+    authParam('request', PaymentRequest.serialize(challenge.request)),
   ]
 
-  if (challenge.description !== undefined) parts.push(`description="${challenge.description}"`)
-  if (challenge.digest !== undefined) parts.push(`digest="${challenge.digest}"`)
-  if (challenge.expires !== undefined) parts.push(`expires="${challenge.expires}"`)
-  if (challenge.opaque !== undefined) parts.push(`opaque="${challenge.opaque}"`)
+  if (challenge.description !== undefined)
+    parts.push(authParam('description', challenge.description))
+  if (challenge.digest !== undefined) parts.push(authParam('digest', challenge.digest))
+  if (challenge.expires !== undefined) parts.push(authParam('expires', challenge.expires))
+  if (challenge.opaque !== undefined) parts.push(authParam('opaque', challenge.opaque))
   else if (challenge.meta !== undefined)
-    parts.push(`opaque="${PaymentRequest.serialize(challenge.meta)}"`)
+    parts.push(authParam('opaque', PaymentRequest.serialize(challenge.meta)))
 
   return `Payment ${parts.join(', ')}`
 }
 
+/** @internal */
+function authParam(name: string, value: string): string {
+  if (/[\r\n]/.test(value)) throw new Error('Invalid quoted-string value.')
+  return `${name}="${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`
+}
+
 /**
  * Deserializes a WWW-Authenticate header value to a challenge.
  *

package/src/Method.ts

@@ -334,7 +334,7 @@ export declare namespace toServer {
     request?: RequestFn<method> | undefined
     respond?: RespondFn<method> | undefined
     stableBinding?: StableBindingFn<method> | undefined
-    transport?: transportOverride | undefined
+    transport?: transportOverride | Transport.AnyTransport | undefined
     verify: VerifyFn<method>
   }
 }

package/src/client/Methods.ts

@@ -1,3 +1,4 @@
+export { evm } from '../evm/client/index.js'
 export { stripe } from '../stripe/client/index.js'
 export { subscription } from '../tempo/client/Subscription.js'
 export { tempo } from '../tempo/client/index.js'

package/src/client/Mppx.ts

@@ -7,7 +7,7 @@ import * as Fetch from './internal/Fetch.js'
 import * as Transport from './Transport.js'
 
 export type Methods = readonly (Method.AnyClient | readonly Method.AnyClient[])[]
-type EventResponseOf<transport extends Transport.Transport> =
+type EventResponseOf<transport extends Transport.AnyTransport> =
   | Response
   | Transport.ResponseOf<transport>
 
@@ -16,7 +16,7 @@ type EventResponseOf<transport extends Transport.Transport> =
  */
 export type Mppx<
   methods extends Methods = Methods,
-  transport extends Transport.Transport = Transport.Transport,
+  transport extends Transport.AnyTransport = Transport.Transport,
 > = {
   /** Payment-aware fetch function that automatically handles 402 responses. */
   fetch: Fetch.from.Fetch<FlattenMethods<methods>>
@@ -125,6 +125,7 @@ export function create<
     ...(resolvedOnChallenge && { onChallenge: resolvedOnChallenge }),
     ...(orderChallenges && { orderChallenges }),
     methods,
+    transport,
   } satisfies Fetch.from.Config<FlattenMethods<methods>>
   const fetch = Fetch.from<FlattenMethods<methods>>(config_fetch)
 
@@ -282,7 +283,7 @@ export function restore(): void {
 export declare namespace create {
   type Config<
     methods extends Methods = Methods,
-    transport extends Transport.Transport = Transport.Transport,
+    transport extends Transport.AnyTransport = Transport.Transport,
   > = {
     /** Controls when `Accept-Payment` is injected. */
     acceptPaymentPolicy?: Fetch.from.Config['acceptPaymentPolicy'] | undefined

package/src/client/Transport.test.ts

@@ -1,6 +1,7 @@
 import { Challenge, Credential, Mcp } from 'mppx'
 import { Transport } from 'mppx/client'
 import { Methods } from 'mppx/tempo'
+import { Header as x402_Header, Types as x402_Types, type PaymentRequired } from 'mppx/x402'
 import { describe, expect, test } from 'vp/test'
 
 const realm = 'api.example.com'
@@ -23,27 +24,34 @@ const credential = Credential.from({
   payload: { signature: '0xabc123', type: 'transaction' },
 })
 
+const x402PaymentRequired = {
+  accepts: [
+    {
+      amount: '10000',
+      asset: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+      maxTimeoutSeconds: 60,
+      network: 'eip155:84532',
+      payTo: '0x209693Bc6afc0C5328bA36FaF03C514EF312287C',
+      scheme: x402_Types.schemes[0],
+    },
+  ],
+  resource: {
+    url: 'https://api.example.com/x402',
+  },
+  x402Version: 2,
+} satisfies PaymentRequired
+
 describe('http', () => {
   describe('isPaymentRequired', () => {
-    test('returns true for 402 response', () => {
-      const transport = Transport.http()
-      const response = new Response(null, { status: 402 })
-
-      expect(transport.isPaymentRequired(response)).toBe(true)
-    })
+    test.each([
+      { expected: true, status: 402 },
+      { expected: false, status: 200 },
+      { expected: false, status: 401 },
+    ])('returns $expected for $status response', ({ expected, status }) => {
+      const response = new Response(null, { status })
 
-    test('returns false for 200 response', () => {
       const transport = Transport.http()
-      const response = new Response(null, { status: 200 })
-
-      expect(transport.isPaymentRequired(response)).toBe(false)
-    })
-
-    test('returns false for other error responses', () => {
-      const transport = Transport.http()
-      const response = new Response(null, { status: 401 })
-
-      expect(transport.isPaymentRequired(response)).toBe(false)
+      expect(transport.isPaymentRequired(response)).toBe(expected)
     })
   })
 
@@ -80,32 +88,159 @@ describe('http', () => {
   })
 
   describe('getChallenges', () => {
-    test('returns all HTTP challenges', () => {
+    test.each([
+      {
+        expectedIds: [challenge.id, 'alternate'],
+        expectedMethods: ['tempo', 'stripe'],
+        headers: () => ({
+          'WWW-Authenticate': `${Challenge.serialize(challenge)}, ${Challenge.serialize({
+            ...challenge,
+            id: 'alternate',
+            method: 'stripe' as const,
+          })}`,
+        }),
+        name: 'Payment auth challenges',
+      },
+      {
+        expectedIds: [`${x402_Types.syntheticChallengeIdPrefix}0`],
+        expectedMethods: [x402_Types.paymentMethod],
+        headers: () => ({
+          'PAYMENT-REQUIRED': x402_Header.encodePaymentRequired(x402PaymentRequired),
+        }),
+        name: 'x402 challenges',
+      },
+      {
+        expectedIds: [
+          `${x402_Types.syntheticChallengeIdPrefix}0`,
+          `${x402_Types.syntheticChallengeIdPrefix}1`,
+        ],
+        expectedMethods: [x402_Types.paymentMethod, x402_Types.paymentMethod],
+        headers: () => ({
+          'PAYMENT-REQUIRED': x402_Header.encodePaymentRequired({
+            ...x402PaymentRequired,
+            accepts: [
+              x402PaymentRequired.accepts[0]!,
+              {
+                ...x402PaymentRequired.accepts[0]!,
+                amount: '20000',
+              },
+            ],
+          }),
+        }),
+        name: 'multiple x402 accepts',
+      },
+      {
+        expectedIds: [challenge.id, `${x402_Types.syntheticChallengeIdPrefix}0`],
+        expectedMethods: ['tempo', x402_Types.paymentMethod],
+        headers: () => ({
+          'PAYMENT-REQUIRED': x402_Header.encodePaymentRequired(x402PaymentRequired),
+          'WWW-Authenticate': Challenge.serialize(challenge),
+        }),
+        name: 'Payment auth and x402 challenges when both are present',
+      },
+    ])('returns $name', ({ expectedIds, expectedMethods, headers }) => {
       const transport = Transport.http()
-      const alternate = { ...challenge, id: 'alternate', method: 'stripe' as const }
       const response = new Response(null, {
         status: 402,
-        headers: {
-          'WWW-Authenticate': `${Challenge.serialize(challenge)}, ${Challenge.serialize(alternate)}`,
-        },
+        headers: headers(),
       })
+      const challenges = transport.getChallenges?.(response) ?? []
 
-      expect(transport.getChallenges?.(response).map((entry) => entry.id)).toEqual([
-        challenge.id,
-        'alternate',
-      ])
+      expect(challenges.map((entry) => entry.id)).toEqual(expectedIds)
+      expect(challenges.map((entry) => entry.method)).toEqual(expectedMethods)
     })
   })
 
   describe('setCredential', () => {
-    test('default', () => {
+    test.each([
+      {
+        challenge,
+        credential: Credential.serialize(credential),
+        expectedHeader: 'Authorization',
+        expectedValue: Credential.serialize(credential),
+        name: 'Payment auth credential for Payment auth challenge',
+      },
+      {
+        challenge: Transport.http().getChallenges!(
+          new Response(null, {
+            status: 402,
+            headers: {
+              'PAYMENT-REQUIRED': x402_Header.encodePaymentRequired(x402PaymentRequired),
+            },
+          }),
+        )[0],
+        credential: 'x402-signature',
+        expectedHeader: 'PAYMENT-SIGNATURE',
+        expectedValue: 'x402-signature',
+        name: 'raw x402 credential for x402 challenge',
+      },
+      {
+        challenge,
+        credential: 'custom-credential',
+        expectedHeader: 'Authorization',
+        expectedValue: 'custom-credential',
+        name: 'non-Payment credential for non-x402 challenge',
+      },
+      {
+        challenge: undefined,
+        credential: 'custom-credential',
+        expectedHeader: 'Authorization',
+        expectedValue: 'custom-credential',
+        name: 'credential without selected challenge',
+      },
+    ])('writes $name', ({ challenge, credential, expectedHeader, expectedValue }) => {
       const transport = Transport.http()
-      const serialized = Credential.serialize(credential)
 
-      const result = transport.setCredential({}, serialized)
+      const result = transport.setCredential({}, credential, { challenge })
+      const headers = result.headers as Headers
+
+      expect(headers.get(expectedHeader)).toBe(expectedValue)
+    })
+
+    test('does not treat unbranded Payment-auth challenges as x402', () => {
+      const transport = Transport.http()
+      const untrustedChallenge = Challenge.from({
+        id: `${x402_Types.syntheticChallengeIdPrefix}0`,
+        intent: x402_Types.exactIntent,
+        method: x402_Types.paymentMethod,
+        realm: 'api.example.com',
+        request: x402PaymentRequired.accepts[0]!,
+      })
+
+      const result = transport.setCredential({}, 'credential', {
+        challenge: untrustedChallenge,
+      })
+      const headers = result.headers as Headers
+
+      expect(headers.get('Authorization')).toBe('credential')
+      expect(headers.get(x402_Types.paymentSignatureHeader)).toBeNull()
+    })
+
+    test('removes stale credential headers before setting the retry credential', () => {
+      const transport = Transport.http()
+      const x402Challenge = Transport.http().getChallenges!(
+        new Response(null, {
+          status: 402,
+          headers: {
+            'PAYMENT-REQUIRED': x402_Header.encodePaymentRequired(x402PaymentRequired),
+          },
+        }),
+      )[0]
+
+      const result = transport.setCredential(
+        {
+          headers: {
+            Authorization: 'Payment stale',
+            [x402_Types.paymentSignatureHeader]: 'stale-x402',
+          },
+        },
+        'fresh-x402',
+        { challenge: x402Challenge },
+      )
       const headers = result.headers as Headers
 
-      expect(headers.get('Authorization')).toBe(serialized)
+      expect(headers.get('Authorization')).toBeNull()
+      expect(headers.get(x402_Types.paymentSignatureHeader)).toBe('fresh-x402')
     })
 
     test('preserves existing headers', () => {

package/src/client/Transport.ts

@@ -1,6 +1,19 @@
 import * as Challenge from '../Challenge.js'
 import * as Credential from '../Credential.js'
 import * as Mcp from '../Mcp.js'
+import * as x402_Header from '../x402/Header.js'
+import * as x402_ChallengeBrand from '../x402/internal/ChallengeBrand.js'
+import * as x402_Types from '../x402/Types.js'
+
+const paymentRequiredStatus = 402
+const paymentAuthChallengeHeader = 'WWW-Authenticate'
+const paymentAuthCredentialHeader = 'Authorization'
+const credentialHeaders = [
+  paymentAuthCredentialHeader,
+  x402_Types.paymentRequiredHeader,
+  x402_Types.paymentResponseHeader,
+  x402_Types.paymentSignatureHeader,
+]
 
 /**
  * Client-side transport adapter.
@@ -18,10 +31,21 @@ export type Transport<in out request = unknown, in out response = unknown> = {
   /** Extracts the challenge from a payment-required response. */
   getChallenge: (response: response) => Challenge.Challenge
   /** Attaches a credential to a request. */
-  setCredential: (request: request, credential: string) => request
+  setCredential: (
+    request: request,
+    credential: string,
+    options?: setCredential.Options | undefined,
+  ) => request
 }
 export type AnyTransport = Transport<any, any>
 
+export declare namespace setCredential {
+  type Options = {
+    /** Challenge selected for credential creation. */
+    challenge?: Challenge.Challenge | undefined
+  }
+}
+
 /** Extracts the response type from a transport. */
 export type ResponseOf<transport extends Transport> =
   transport extends Transport<any, infer response> ? response : never
@@ -55,33 +79,77 @@ export function from<request, response>(
  * HTTP transport for client-side payment handling.
  *
  * - Detects payment required via 402 status
- * - Extracts challenges from `WWW-Authenticate` header
- * - Sends credentials via `Authorization` header
+ * - Extracts Payment auth challenges from `WWW-Authenticate`
+ * - Falls back to x402 exact challenges from `PAYMENT-REQUIRED`
+ * - Sends credentials via `Authorization` or `PAYMENT-SIGNATURE`
  */
 export function http() {
   return from<RequestInit, Response>({
     name: 'http',
 
     isPaymentRequired(response) {
-      return response.status === 402
+      return response.status === paymentRequiredStatus
     },
 
     getChallenges(response) {
-      return Challenge.fromResponseList(response)
+      return paymentRequiredChallenges(response)
     },
 
     getChallenge(response) {
-      return Challenge.fromResponse(response)
+      const challenge = paymentRequiredChallenges(response)[0]
+      if (!challenge) throw new Error('No challenge in response.')
+      return challenge
     },
 
-    setCredential(request, credential) {
+    setCredential(request, credential, options) {
       const headers = new Headers(request.headers)
-      headers.set('Authorization', credential)
+      for (const header of credentialHeaders) headers.delete(header)
+      if (isX402Challenge(options?.challenge)) {
+        headers.set(x402_Types.paymentSignatureHeader, credential)
+      } else {
+        headers.set(paymentAuthCredentialHeader, credential)
+      }
       return { ...request, headers }
     },
   })
 }
 
+function paymentRequiredChallenges(response: Response): Challenge.Challenge[] {
+  return [
+    ...(response.headers.has(paymentAuthChallengeHeader)
+      ? Challenge.fromResponseList(response)
+      : []),
+    ...x402Challenges(response),
+  ]
+}
+
+function x402Challenges(response: Response): Challenge.Challenge[] {
+  const header = response.headers.get(x402_Types.paymentRequiredHeader)
+  if (!header) return []
+  const paymentRequired = x402_Header.decodePaymentRequired(header)
+  if (response.url && paymentRequired.resource.url !== response.url)
+    throw new Error('x402 payment-required resource does not match response URL.')
+  return paymentRequired.accepts.map((accepted, index) =>
+    x402_ChallengeBrand.mark(
+      Challenge.from({
+        id: `${x402_Types.syntheticChallengeIdPrefix}${index}`,
+        intent: x402_Types.exactIntent,
+        method: x402_Types.paymentMethod,
+        realm: new URL(paymentRequired.resource.url).host,
+        request: {
+          ...accepted,
+          ...(paymentRequired.extensions ? { extensions: paymentRequired.extensions } : {}),
+          resource: paymentRequired.resource,
+        },
+      }),
+    ),
+  )
+}
+
+function isX402Challenge(challenge: Challenge.Challenge | undefined): boolean {
+  return x402_ChallengeBrand.is(challenge)
+}
+
 /**
  * MCP transport for client-side payment handling.
  *

package/src/client/index.ts

@@ -1,5 +1,5 @@
 export * as Expires from '../Expires.js'
 export * as Fetch from './internal/Fetch.js'
-export { session, stripe, tempo } from './Methods.js'
+export { evm, session, stripe, tempo } from './Methods.js'
 export * as Mppx from './Mppx.js'
 export * as Transport from './Transport.js'