mppx 0.1.0 → 0.2.0

package/src/stripe/server/Charge.ts

@@ -1,22 +1,37 @@
+import type * as Credential from '../../Credential.js'
 import {
   PaymentActionRequiredError,
   PaymentExpiredError,
   VerificationFailedError,
 } from '../../Errors.js'
-import type { LooseOmit } from '../../internal/types.js'
-import * as MethodIntent from '../../MethodIntent.js'
-import * as Intents from '../Intents.js'
+import type { LooseOmit, OneOf } from '../../internal/types.js'
+import * as Method from '../../Method.js'
+import type { StripeClient } from '../internal/types.js'
+import * as Methods from '../Methods.js'
 
 /**
  * Creates a Stripe charge method intent for usage on the server.
  *
  * Verifies payment by creating a Stripe PaymentIntent with the provided SPT.
  *
+ * Accepts either a `client` (a pre-configured Stripe SDK instance) or a raw
+ * `secretKey`. Using `client` is recommended—it lets you configure retries,
+ * API version, and other options on the Stripe instance you control.
+ *
+ * @example
+ * ```ts
+ * import Stripe from 'stripe'
+ * import { stripe } from 'mppx/server'
+ *
+ * const stripeClient = new Stripe(process.env.STRIPE_SECRET_KEY!)
+ * const charge = stripe.charge({ client: stripeClient, networkId: 'internal', paymentMethodTypes: ['card'] })
+ * ```
+ *
  * @example
  * ```ts
  * import { stripe } from 'mppx/server'
  *
- * const charge = stripe.charge({ secretKey: 'sk_...' })
+ * const charge = stripe.charge({ secretKey: 'sk_...', networkId: 'internal', paymentMethodTypes: ['card'] })
  * ```
  */
 export function charge<const parameters extends charge.Parameters>(parameters: parameters) {
@@ -29,11 +44,13 @@ export function charge<const parameters extends charge.Parameters>(parameters: p
     metadata,
     networkId,
     paymentMethodTypes,
-    secretKey,
   } = parameters
 
+  const client = 'client' in parameters ? parameters.client : undefined
+  const secretKey = 'secretKey' in parameters ? parameters.secretKey : undefined
+
   type Defaults = charge.DeriveDefaults<parameters>
-  return MethodIntent.toServer<typeof Intents.charge, Defaults>(Intents.charge, {
+  return Method.toServer<typeof Methods.charge, Defaults>(Methods.charge, {
     defaults: {
       amount,
       currency,
@@ -52,41 +69,25 @@ export function charge<const parameters extends charge.Parameters>(parameters: p
       if (request.expires && new Date(request.expires) < new Date())
         throw new PaymentExpiredError({ expires: request.expires })
 
-      const parsed = Intents.charge.schema.credential.payload.safeParse(credential.payload)
+      const parsed = Methods.charge.schema.credential.payload.safeParse(credential.payload)
       if (!parsed.success) throw new Error('Invalid credential payload: missing or malformed spt')
       const { spt, externalId: credentialExternalId } = parsed.data as {
         spt: string
         externalId?: string
       }
 
-      const body = new URLSearchParams({
-        amount: request.amount as string,
-        currency: request.currency as string,
-        shared_payment_granted_token: spt,
-        confirm: 'true',
-        'automatic_payment_methods[enabled]': 'true',
-        'automatic_payment_methods[allow_redirects]': 'never',
-      })
-      const resolvedMetadata = request.methodDetails?.metadata as Record<string, string> | undefined
-      if (resolvedMetadata) {
-        for (const [key, value] of Object.entries(resolvedMetadata)) {
-          body.set(`metadata[${key}]`, value)
-        }
-      }
+      const userMetadata = request.methodDetails?.metadata as Record<string, string> | undefined
+      const resolvedMetadata = { ...buildAnalytics({ credential }), ...userMetadata }
 
-      const response = await fetch('https://api.stripe.com/v1/payment_intents', {
-        method: 'POST',
-        headers: {
-          Authorization: `Basic ${btoa(`${secretKey}:`)}`,
-          'Content-Type': 'application/x-www-form-urlencoded',
-          'Idempotency-Key': `mppx_${challenge.id}_${spt}`,
-        },
-        body,
-      })
-
-      if (!response.ok) throw new VerificationFailedError({ reason: 'Stripe PaymentIntent failed' })
-
-      const pi = (await response.json()) as { id: string; status: string }
+      const pi = client
+        ? await createWithClient({ client, challenge, request, spt, metadata: resolvedMetadata })
+        : await createWithSecretKey({
+            secretKey: secretKey!,
+            challenge,
+            request,
+            spt,
+            metadata: resolvedMetadata,
+          })
 
       if (pi.status === 'requires_action') {
         throw new PaymentActionRequiredError({ reason: 'Stripe PaymentIntent requires action' })
@@ -105,17 +106,102 @@ export function charge<const parameters extends charge.Parameters>(parameters: p
 }
 
 export declare namespace charge {
-  type Defaults = LooseOmit<MethodIntent.RequestDefaults<typeof Intents.charge>, 'recipient'>
+  type Defaults = LooseOmit<Method.RequestDefaults<typeof Methods.charge>, 'recipient'>
 
   type Parameters = {
-    /** Stripe secret API key. */
-    secretKey: string
     /** Optional metadata to include in SPT creation requests. */
     metadata?: Record<string, string> | undefined
-  } & Defaults
+  } & Defaults &
+    OneOf<
+      | {
+          /** Pre-configured Stripe SDK instance. Any object matching the duck-typed `StripeClient` shape works. */
+          client: StripeClient
+        }
+      | {
+          /** Stripe secret API key. */
+          secretKey: string
+        }
+    >
 
   type DeriveDefaults<parameters extends Parameters> = Pick<
     parameters,
     Extract<keyof parameters, keyof Defaults>
   > & { decimals: number }
 }
+
+/** Creates a PaymentIntent using the Stripe SDK client. */
+async function createWithClient(parameters: {
+  client: StripeClient
+  challenge: { id: string }
+  metadata: Record<string, string>
+  request: { amount: unknown; currency: unknown }
+  spt: string
+}): Promise<{ id: string; status: string }> {
+  const { client, challenge, metadata, request, spt } = parameters
+  try {
+    const result = await client.paymentIntents.create(
+      {
+        amount: Number(request.amount),
+        automatic_payment_methods: { allow_redirects: 'never', enabled: true },
+        confirm: true,
+        currency: request.currency as string,
+        metadata,
+        payment_method: spt,
+      },
+      { idempotencyKey: `mppx_${challenge.id}_${spt}` },
+    )
+    return { id: result.id, status: result.status }
+  } catch {
+    throw new VerificationFailedError({ reason: 'Stripe PaymentIntent failed' })
+  }
+}
+
+/** Creates a PaymentIntent using a raw secret key and fetch. */
+async function createWithSecretKey(parameters: {
+  secretKey: string
+  challenge: { id: string }
+  metadata: Record<string, string>
+  request: { amount: unknown; currency: unknown }
+  spt: string
+}): Promise<{ id: string; status: string }> {
+  const { secretKey, challenge, metadata, request, spt } = parameters
+
+  const body = new URLSearchParams({
+    amount: request.amount as string,
+    'automatic_payment_methods[allow_redirects]': 'never',
+    'automatic_payment_methods[enabled]': 'true',
+    confirm: 'true',
+    currency: request.currency as string,
+    shared_payment_granted_token: spt,
+  })
+  for (const [key, value] of Object.entries(metadata)) {
+    body.set(`metadata[${key}]`, value)
+  }
+
+  const response = await fetch('https://api.stripe.com/v1/payment_intents', {
+    method: 'POST',
+    headers: {
+      Authorization: `Basic ${btoa(`${secretKey}:`)}`,
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Idempotency-Key': `mppx_${challenge.id}_${spt}`,
+    },
+    body,
+  })
+
+  if (!response.ok) throw new VerificationFailedError({ reason: 'Stripe PaymentIntent failed' })
+  return (await response.json()) as { id: string; status: string }
+}
+
+/** @internal */
+function buildAnalytics(parameters: { credential: Credential.Credential }): Record<string, string> {
+  const { credential } = parameters
+  const { challenge } = credential
+  return {
+    mpp_version: '1',
+    mpp_is_mpp: 'true',
+    mpp_intent: challenge.intent,
+    mpp_challenge_id: challenge.id,
+    mpp_server_id: challenge.realm,
+    ...(credential.source ? { mpp_client_id: credential.source } : {}),
+  }
+}

package/src/stripe/server/{MethodIntents.ts → Methods.ts}

@@ -1,7 +1,7 @@
 import { charge as charge_ } from './Charge.js'
 
 /**
- * Creates a Stripe `charge` method intent for usage on the server.
+ * Creates a Stripe `charge` method for usage on the server.
  *
  * @example
  * ```ts
@@ -19,6 +19,6 @@ export function stripe<const parameters extends stripe.Parameters>(parameters: p
 export namespace stripe {
   export type Parameters = charge_.Parameters
 
-  /** Creates a Stripe `charge` method intent for SPT-based payments. */
+  /** Creates a Stripe `charge` method for SPT-based payments. */
   export const charge = charge_
 }

package/src/stripe/server/index.ts

@@ -1,2 +1,2 @@
 export { charge } from './Charge.js'
-export { stripe } from './MethodIntents.js'
+export { stripe } from './Methods.js'

package/src/tempo/{Intents.test.ts → Methods.test.ts}

@@ -1,22 +1,22 @@
-import { MethodIntents } from 'mppx/tempo'
+import { Methods } from 'mppx/tempo'
 import { describe, expect, expectTypeOf, test } from 'vitest'
 
 describe('charge', () => {
-  test('has correct name and method', () => {
-    expect(MethodIntents.charge.name).toBe('charge')
-    expect(MethodIntents.charge.method).toBe('tempo')
+  test('has correct name and intent', () => {
+    expect(Methods.charge.intent).toBe('charge')
+    expect(Methods.charge.name).toBe('tempo')
   })
 
-  test('types: name is literal', () => {
-    expectTypeOf(MethodIntents.charge.name).toEqualTypeOf<'charge'>()
+  test('types: intent is literal', () => {
+    expectTypeOf(Methods.charge.intent).toEqualTypeOf<'charge'>()
   })
 
-  test('types: method is literal', () => {
-    expectTypeOf(MethodIntents.charge.method).toEqualTypeOf<'tempo'>()
+  test('types: name is literal', () => {
+    expectTypeOf(Methods.charge.name).toEqualTypeOf<'tempo'>()
   })
 
   test('schema: validates valid request', () => {
-    const result = MethodIntents.charge.schema.request.safeParse({
+    const result = Methods.charge.schema.request.safeParse({
       amount: '1',
       currency: '0x20c0000000000000000000000000000000000001',
       decimals: 6,
@@ -27,7 +27,7 @@ describe('charge', () => {
   })
 
   test('schema: validates request with methodDetails', () => {
-    const result = MethodIntents.charge.schema.request.safeParse({
+    const result = Methods.charge.schema.request.safeParse({
       amount: '1',
       currency: '0x20c0000000000000000000000000000000000001',
       decimals: 6,
@@ -40,7 +40,7 @@ describe('charge', () => {
   })
 
   test('schema: validates request with memo', () => {
-    const result = MethodIntents.charge.schema.request.safeParse({
+    const result = Methods.charge.schema.request.safeParse({
       amount: '1',
       currency: '0x20c0000000000000000000000000000000000001',
       decimals: 6,
@@ -52,14 +52,14 @@ describe('charge', () => {
   })
 
   test('schema: rejects invalid request', () => {
-    const result = MethodIntents.charge.schema.request.safeParse({
+    const result = Methods.charge.schema.request.safeParse({
       amount: '1',
     })
     expect(result.success).toBe(false)
   })
 
   test('schema: validates transaction payload', () => {
-    const result = MethodIntents.charge.schema.credential.payload.safeParse({
+    const result = Methods.charge.schema.credential.payload.safeParse({
       signature: '0x76f90100000000000000000000000000000000000000000000000000000000000000000000',
       type: 'transaction',
     })
@@ -67,7 +67,7 @@ describe('charge', () => {
   })
 
   test('schema: validates hash payload', () => {
-    const result = MethodIntents.charge.schema.credential.payload.safeParse({
+    const result = Methods.charge.schema.credential.payload.safeParse({
       hash: '0x1a2b3c4d5e6f7890abcdef1234567890abcdef1234567890abcdef1234567890',
       type: 'hash',
     })
@@ -75,7 +75,7 @@ describe('charge', () => {
   })
 
   test('schema: rejects invalid payload type', () => {
-    const result = MethodIntents.charge.schema.credential.payload.safeParse({
+    const result = Methods.charge.schema.credential.payload.safeParse({
       signature: '0x...',
       type: 'keyAuthorization',
     })

package/src/tempo/{Intents.ts → Methods.ts}

@@ -1,6 +1,7 @@
 import type { Account } from 'viem'
-import * as Intent from '../Intent.js'
-import * as MethodIntent from '../MethodIntent.js'
+import { parseUnits } from 'viem'
+import * as Expires from '../Expires.js'
+import * as Method from '../Method.js'
 import * as z from '../zod.js'
 
 /**
@@ -8,8 +9,9 @@ import * as z from '../zod.js'
  *
  * @see https://github.com/tempoxyz/payment-auth-spec/blob/main/specs/methods/tempo/draft-tempo-charge-00.md
  */
-export const charge = MethodIntent.fromIntent(Intent.charge, {
-  method: 'tempo',
+export const charge = Method.from({
+  name: 'tempo',
+  intent: 'charge',
   schema: {
     credential: {
       payload: z.discriminatedUnion('type', [
@@ -17,9 +19,15 @@ export const charge = MethodIntent.fromIntent(Intent.charge, {
         z.object({ signature: z.signature(), type: z.literal('transaction') }),
       ]),
     },
-    request: {
-      methodDetails: z.object({
+    request: z.pipe(
+      z.object({
+        amount: z.amount(),
         chainId: z.optional(z.number()),
+        currency: z.string(),
+        decimals: z.number(),
+        description: z.optional(z.string()),
+        expires: z._default(z.datetime(), () => Expires.minutes(5)),
+        externalId: z.optional(z.string()),
         feePayer: z.optional(
           z.pipe(
             z.union([z.boolean(), z.custom<Account>()]),
@@ -27,9 +35,22 @@ export const charge = MethodIntent.fromIntent(Intent.charge, {
           ),
         ),
         memo: z.optional(z.hash()),
+        recipient: z.optional(z.string()),
       }),
-      requires: ['decimals', 'recipient'],
-    },
+      z.transform(({ amount, chainId, decimals, feePayer, memo, ...rest }) => ({
+        ...rest,
+        amount: parseUnits(amount, decimals).toString(),
+        ...(chainId !== undefined || feePayer !== undefined || memo !== undefined
+          ? {
+              methodDetails: {
+                ...(chainId !== undefined && { chainId }),
+                ...(feePayer !== undefined && { feePayer }),
+                ...(memo !== undefined && { memo }),
+              },
+            }
+          : {}),
+      })),
+    ),
   },
 })
 
@@ -39,26 +60,27 @@ export const charge = MethodIntent.fromIntent(Intent.charge, {
  * Uses cumulative vouchers over a payment channel. Credential payloads
  * are a discriminated union on `action`: open, topUp, voucher, close.
  */
-export const session = MethodIntent.fromIntent(Intent.session, {
-  method: 'tempo',
+export const session = Method.from({
+  name: 'tempo',
+  intent: 'session',
   schema: {
     credential: {
       payload: z.discriminatedUnion('action', [
         z.object({
           action: z.literal('open'),
-          type: z.literal('transaction'),
-          channelId: z.hash(),
-          transaction: z.signature(),
           authorizedSigner: z.optional(z.string()),
+          channelId: z.hash(),
           cumulativeAmount: z.amount(),
           signature: z.signature(),
+          transaction: z.signature(),
+          type: z.literal('transaction'),
         }),
         z.object({
           action: z.literal('topUp'),
-          type: z.literal('transaction'),
+          additionalDeposit: z.amount(),
           channelId: z.hash(),
           transaction: z.signature(),
-          additionalDeposit: z.amount(),
+          type: z.literal('transaction'),
         }),
         z.object({
           action: z.literal('voucher'),
@@ -74,20 +96,53 @@ export const session = MethodIntent.fromIntent(Intent.session, {
         }),
       ]),
     },
-    request: {
-      methodDetails: z.object({
-        escrowContract: z.string(),
-        channelId: z.optional(z.hash()),
-        minVoucherDelta: z.optional(z.amount()),
+    request: z.pipe(
+      z.object({
+        amount: z.amount(),
         chainId: z.optional(z.number()),
+        channelId: z.optional(z.hash()),
+        currency: z.string(),
+        decimals: z.number(),
+        escrowContract: z.optional(z.string()),
         feePayer: z.optional(
           z.pipe(
             z.union([z.boolean(), z.custom<Account>()]),
             z.transform((v): boolean => (typeof v === 'object' ? true : v)),
           ),
         ),
+        minVoucherDelta: z.optional(z.amount()),
+        recipient: z.optional(z.string()),
+        suggestedDeposit: z.optional(z.amount()),
+        unitType: z.string(),
       }),
-      requires: ['decimals', 'recipient', 'currency'],
-    },
+      z.transform(
+        ({
+          amount,
+          chainId,
+          channelId,
+          decimals,
+          escrowContract,
+          feePayer,
+          minVoucherDelta,
+          suggestedDeposit,
+          ...rest
+        }) => ({
+          ...rest,
+          amount: parseUnits(amount, decimals).toString(),
+          ...(suggestedDeposit
+            ? {
+                suggestedDeposit: parseUnits(suggestedDeposit, decimals).toString(),
+              }
+            : {}),
+          methodDetails: {
+            escrowContract,
+            ...(channelId !== undefined && { channelId }),
+            ...(minVoucherDelta !== undefined && { minVoucherDelta }),
+            ...(chainId !== undefined && { chainId }),
+            ...(feePayer !== undefined && { feePayer }),
+          },
+        }),
+      ),
+    ),
   },
 })

package/src/tempo/client/ChannelOps.ts

@@ -1,7 +1,7 @@
 /**
  * Shared client-side channel operations.
  *
- * Provides the low-level helpers that both `session()` (MethodIntent plugin)
+ * Provides the low-level helpers that both `session()`
  * and `sessionManager()` (orchestrator) rely on: escrow resolution, channel
  * ID computation, on-chain open/voucher/close payload construction, channel
  * recovery from on-chain state, and credential serialization.

package/src/tempo/client/Charge.ts

@@ -3,13 +3,13 @@ import { prepareTransactionRequest, signTransaction } from 'viem/actions'
 import { tempo as tempo_chain } from 'viem/chains'
 import { Actions } from 'viem/tempo'
 import * as Credential from '../../Credential.js'
-import * as MethodIntent from '../../MethodIntent.js'
+import * as Method from '../../Method.js'
 import * as Account from '../../viem/Account.js'
 import * as Client from '../../viem/Client.js'
 import * as z from '../../zod.js'
 import * as Attribution from '../Attribution.js'
-import * as Intents from '../Intents.js'
 import * as defaults from '../internal/defaults.js'
+import * as Methods from '../Methods.js'
 
 /**
  * Creates a Tempo charge method intent for usage on the client.
@@ -33,7 +33,7 @@ export function charge(parameters: charge.Parameters = {}) {
   })
   const getAccount = Account.getResolver({ account: parameters.account })
 
-  return MethodIntent.toClient(Intents.charge, {
+  return Method.toClient(Methods.charge, {
     context: z.object({
       account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
     }),

package/src/tempo/client/{MethodIntents.ts → Methods.ts}

@@ -3,7 +3,7 @@ import { session as sessionIntent_ } from './Session.js'
 import { sessionManager as session_ } from './SessionManager.js'
 
 /**
- * Creates both Tempo `charge` and `session` client method intents from shared parameters.
+ * Creates both Tempo `charge` and `session` client methods from shared parameters.
  *
  * @example
  * ```ts
@@ -21,7 +21,7 @@ export function tempo(parameters: tempo.Parameters = {}) {
 export namespace tempo {
   export type Parameters = charge_.Parameters & sessionIntent_.Parameters
 
-  /** Creates a Tempo `charge` client method intent for one-time TIP-20 token transfers. */
+  /** Creates a Tempo `charge` client method for one-time TIP-20 token transfers. */
   export const charge = charge_
   /** Creates a client-side streaming session for managing payment channels. */
   export const session = session_

package/src/tempo/client/Session.ts

@@ -2,12 +2,12 @@ import type { Hex } from 'ox'
 import { type Address, parseUnits, type Account as viem_Account } from 'viem'
 import { tempo as tempo_chain } from 'viem/chains'
 import type * as Challenge from '../../Challenge.js'
-import * as MethodIntent from '../../MethodIntent.js'
+import * as Method from '../../Method.js'
 import * as Account from '../../viem/Account.js'
 import * as Client from '../../viem/Client.js'
 import * as z from '../../zod.js'
-import * as Intents from '../Intents.js'
 import * as defaults from '../internal/defaults.js'
+import * as Methods from '../Methods.js'
 import type { StreamCredentialPayload } from '../stream/Types.js'
 import { signVoucher } from '../stream/Voucher.js'
 import {
@@ -35,7 +35,7 @@ export const streamContextSchema = z.object({
 export type StreamContext = z.infer<typeof streamContextSchema>
 
 /**
- * Creates a session payment MethodIntent plugin for use with `Mppx.create()`.
+ * Creates a session payment method for use with `Mppx.create()`.
  *
  * Supports both auto mode (set `deposit` to manage channels automatically)
  * and manual mode (pass `context.action` to control each step).
@@ -330,7 +330,7 @@ export function session(parameters: session.Parameters = {}) {
     return serializeCredential(challenge, payload, chainId, account)
   }
 
-  return MethodIntent.toClient(Intents.session, {
+  return Method.toClient(Methods.session, {
     context: streamContextSchema,
 
     async createCredential({ challenge, context }) {

package/src/tempo/client/SessionManager.ts

@@ -38,7 +38,7 @@ export type PaymentResponse = Response & {
  * Creates a session manager that handles the full client payment lifecycle:
  * channel open, incremental vouchers, SSE streaming, and channel close.
  *
- * Internally delegates to the `session()` MethodIntent plugin for all
+ * Internally delegates to the `session()` method for all
  * channel state management and credential creation, and to `Fetch.from`
  * for the 402 challenge/retry flow.
  *
@@ -75,8 +75,9 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
   const wrappedFetch = Fetch.from({
     fetch: fetchFn,
     methods: [method],
-    onChallenge(c) {
-      lastChallenge = c
+    onChallenge: async (challenge, _helpers) => {
+      lastChallenge = challenge
+      return undefined
     },
   })
 
@@ -150,10 +151,15 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
           ...fetchInit.headers,
           Accept: 'text/event-stream',
         },
+        ...(signal ? { signal } : {}),
       }
 
       const response = await doFetch(input, sseInit)
 
+      // Snapshot the challenge at SSE open time so concurrent
+      // calls don't overwrite it.
+      const sseChallenge = lastChallenge
+
       if (!response.body) throw new Error('Response has no body.')
 
       const reader = response.body.getReader()
@@ -186,13 +192,13 @@ export function sessionManager(parameters: sessionManager.Parameters): SessionMa
                   break
 
                 case 'payment-need-voucher': {
-                  if (!channel || !lastChallenge) break
+                  if (!channel || !sseChallenge) break
                   const required = BigInt(event.data.requiredCumulative)
                   channel.cumulativeAmount =
                     channel.cumulativeAmount > required ? channel.cumulativeAmount : required
 
                   const credential = await method.createCredential({
-                    challenge: lastChallenge as never,
+                    challenge: sseChallenge as never,
                     context: {
                       action: 'voucher',
                       channelId: channel.channelId,

package/src/tempo/client/index.ts

@@ -1,5 +1,5 @@
 export { charge } from './Charge.js'
-export { tempo } from './MethodIntents.js'
+export { tempo } from './Methods.js'
 export { session } from './Session.js'
 export type { PaymentResponse, SessionManager } from './SessionManager.js'
 export { sessionManager } from './SessionManager.js'

package/src/tempo/index.ts

@@ -1,2 +1,2 @@
-export * as MethodIntents from './Intents.js'
+export * as Methods from './Methods.js'
 export * as Stream from './stream/index.js'

package/src/tempo/internal/defaults.ts

@@ -11,7 +11,7 @@ export const escrowContract = {
 export const testnetChainId = 42431
 
 /**
- * Default token decimals for TIP-20 stablecoins (e.g. alphaUSD).
+ * Default token decimals for TIP-20 stablecoins (e.g. pathUSD).
  *
  * All TIP-20 tokens on Tempo use 6 decimals, so there is no risk of
  * client/server mismatch within the Tempo ecosystem. Other chains and