mppx 0.8.17 → 0.8.18

package/src/tempo/client/Charge.ts

@@ -1,271 +0,0 @@
-import type * as Hex from 'ox/Hex'
-import type { Address } from 'viem'
-import {
-  prepareTransactionRequest,
-  sendCallsSync,
-  signTypedData,
-  signTransaction,
-} from 'viem/actions'
-import { Actions } from 'viem/tempo'
-import { tempo as tempo_chain } from 'viem/tempo/chains'
-
-import * as Credential from '../../Credential.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 AutoSwap from '../internal/auto-swap.js'
-import * as Charge_internal from '../internal/charge.js'
-import * as defaults from '../internal/defaults.js'
-import * as Proof from '../internal/proof.js'
-import * as Methods from '../Methods.js'
-import type * as AccountResolution from './ResolveAccount.js'
-
-/** Runtime context accepted by the Tempo charge client method. */
-export type ChargeContext = {
-  account?: Account.getResolver.Parameters['account'] | undefined
-  autoSwap?: AutoSwap.resolve.Value | undefined
-  mode?: Methods.ChargeMode | undefined
-}
-
-const chargeContextSchema = z.object({
-  account: z.optional(z.custom<ChargeContext['account']>()),
-  autoSwap: z.optional(z.custom<ChargeContext['autoSwap']>()),
-  mode: z.optional(z.enum(Methods.chargeModes)),
-})
-
-/**
- * Creates a Tempo charge method intent for usage on the client.
- *
- * @example
- * ```ts
- * import { tempo } from 'mppx/client'
- * import { privateKeyToAccount } from 'viem/accounts'
- *
- * const charge = tempo.charge({
- *   account: privateKeyToAccount('0x...'),
- * })
- * ```
- */
-export function charge(parameters: charge.Parameters = {}) {
-  const { clientId } = parameters
-  const getClient = Client.getResolver({
-    chain: tempo_chain,
-    getClient: parameters.getClient,
-    rpcUrl: defaults.rpcUrl,
-  })
-  const getAccount = Account.getResolver({ account: parameters.account })
-
-  return Method.toClient(Methods.charge, {
-    context: chargeContextSchema,
-
-    async createCredential({ challenge, context }) {
-      // Chain pinning: reject a challenge whose chain ID conflicts with the
-      // pinned one, and sign on the pin when the challenge omits a chain ID.
-      const challengeChainId = challenge.request.methodDetails?.chainId
-      if (
-        parameters.expectedChainId !== undefined &&
-        challengeChainId !== undefined &&
-        challengeChainId !== parameters.expectedChainId
-      )
-        throw new Error(
-          `Chain ID mismatch: expected ${parameters.expectedChainId}, got ${challengeChainId}.`,
-        )
-      const resolvedChainId = challengeChainId ?? parameters.expectedChainId
-      const client = await getClient({ chainId: resolvedChainId })
-      const chainId = resolvedChainId ?? client.chain?.id
-      if (chainId === undefined)
-        throw new Error('No `chainId` provided. Pass a chain ID in the challenge or client.')
-
-      const { request } = challenge
-      const { amount, methodDetails } = request
-      const supportedModes = (methodDetails?.supportedModes as
-        | readonly Methods.ChargeMode[]
-        | undefined) ?? ['pull', 'push']
-      const defaultAccount = getAccount(client, context)
-
-      // Zero-amount: sign EIP-712 typed data instead of creating a transaction.
-      if (BigInt(amount) === 0n) {
-        const signature = await signTypedData(client, {
-          account: defaultAccount,
-          // `account` here is the signing account; the proof's bound payer is
-          // `account.address` (echoed in the credential `source` below).
-          ...Proof.typedData({
-            account: defaultAccount.address,
-            chainId,
-            challengeId: challenge.id,
-            realm: challenge.realm,
-          }),
-        })
-        return Credential.serialize({
-          challenge,
-          payload: { signature, type: 'proof' },
-          source: Proof.proofSource({ address: defaultAccount.address, chainId }),
-        })
-      }
-
-      const currency = request.currency as Address
-      if (parameters.expectedRecipients) {
-        const allowed = new Set(parameters.expectedRecipients.map((a) => a.toLowerCase()))
-        const splits = methodDetails?.splits as readonly { recipient: string }[] | undefined
-        if (splits) {
-          for (const split of splits) {
-            if (!allowed.has(split.recipient.toLowerCase()))
-              throw new Error(`Unexpected split recipient: ${split.recipient}`)
-          }
-        }
-      }
-      const memo = methodDetails?.memo
-        ? (methodDetails.memo as Hex.Hex)
-        : Attribution.encode({ challengeId: challenge.id, clientId, serverId: challenge.realm })
-      const transfers = Charge_internal.getTransfers({
-        amount,
-        methodDetails: {
-          ...methodDetails,
-          memo,
-        },
-        recipient: request.recipient as Address,
-      })
-      const transferCalls = transfers.map(
-        (transfer): AccountResolution.ResolveAccountCall =>
-          Actions.token.transfer.call(client, {
-            amount: BigInt(transfer.amount),
-            ...(transfer.memo && { memo: transfer.memo as Hex.Hex }),
-            to: transfer.recipient as Address,
-            token: currency,
-          }),
-      )
-
-      const autoSwap = AutoSwap.resolve(
-        context?.autoSwap ?? parameters.autoSwap,
-        AutoSwap.defaultCurrencies,
-      )
-
-      const account =
-        (await parameters.resolveAccount?.({
-          account: defaultAccount,
-          chainId,
-          operation: {
-            kind: 'executeCalls',
-            ...(autoSwap ? {} : { calls: transferCalls }),
-          },
-        })) ?? defaultAccount
-
-      const mode = (() => {
-        const explicitMode = context?.mode ?? parameters.mode
-        if (explicitMode) {
-          if (!supportedModes.includes(explicitMode))
-            throw new Error(`Challenge does not support ${explicitMode} mode.`)
-          return explicitMode
-        }
-
-        const preferredMode = account.type === 'json-rpc' ? 'push' : 'pull'
-        if (supportedModes.includes(preferredMode)) return preferredMode
-        return supportedModes[0]!
-      })()
-
-      const swapCalls = autoSwap
-        ? await AutoSwap.findCalls(client, {
-            account: account.address,
-            amountOut: BigInt(amount),
-            tokenOut: currency,
-            tokenIn: autoSwap.tokenIn,
-            slippage: autoSwap.slippage,
-          })
-        : undefined
-
-      const calls = [...(swapCalls ?? []), ...transferCalls]
-
-      const validBefore = (() => {
-        const defaultExpiry = Math.floor(Date.now() / 1000) + 25
-        if (!challenge.expires) return defaultExpiry
-        const challengeExpiry = Math.floor(new Date(challenge.expires).getTime() / 1000)
-        return Math.min(defaultExpiry, challengeExpiry)
-      })()
-
-      if (mode === 'push') {
-        const { receipts } = await sendCallsSync(client, {
-          account,
-          calls: calls as never,
-          experimental_fallback: true,
-        })
-        const hash = receipts?.[0]?.transactionHash
-        if (!hash) throw new Error('No transaction receipt returned.')
-        return Credential.serialize({
-          challenge,
-          payload: { hash, type: 'hash' },
-          source: Proof.proofSource({ address: account.address, chainId }),
-        })
-      }
-
-      const prepared = await prepareTransactionRequest(client, {
-        account,
-        calls,
-        nonceKey: 'expiring',
-        validBefore,
-      } as never)
-      // Estimate before enabling fee-payer mode so Tempo includes sender
-      // signature and access-key verification costs in the gas budget.
-      prepared.gas = (prepared.gas ?? 0n) + 5_000n
-      if (methodDetails?.feePayer) {
-        const sponsored = prepared as Record<string, unknown>
-        delete sponsored.feePayerSignature
-        delete sponsored.feeToken
-        sponsored.feePayer = true
-      }
-      const signature = await signTransaction(client, prepared as never)
-
-      return Credential.serialize({
-        challenge,
-        payload: { signature, type: 'transaction' },
-        source: Proof.proofSource({ address: account.address, chainId }),
-      })
-    },
-  })
-}
-
-export declare namespace charge {
-  type AutoSwap = AutoSwap.resolve.Value
-  type Context = ChargeContext
-  type ResolveAccount = AccountResolution.ResolveAccount
-  type ResolveAccountInfo = AccountResolution.ResolveAccountInfo
-
-  type Parameters = {
-    /**
-     * Automatically swap from a fallback currency (pathUsd, USDC.e) via the
-     * Tempo DEX when the user lacks sufficient balance of the target currency.
-     *
-     * @default false
-     */
-    autoSwap?: AutoSwap | undefined
-    /** Client identifier used to derive the client fingerprint in attribution memos. */
-    clientId?: string | undefined
-    /**
-     * Chain ID this client is willing to pay on. When set, the client rejects
-     * any challenge whose `methodDetails.chainId` differs, and signs on this
-     * chain when the challenge omits a chain ID.
-     */
-    expectedChainId?: number | undefined
-    /**
-     * Allowlist of expected split recipient addresses. When set, the client
-     * rejects any challenge whose split recipients are not in this list.
-     */
-    expectedRecipients?: readonly Address[] | undefined
-    /**
-     * Controls how the charge transaction is submitted.
-     *
-     * - `'push'`: Client broadcasts the transaction and sends the tx hash to the server.
-     * - `'pull'`: Client signs the transaction and sends the serialized tx to the server for broadcast.
-     *
-     * If the server advertises `supportedModes`, this setting must be one of
-     * the supported values for the challenge.
-     *
-     * @default `'push'` for JSON-RPC accounts, `'pull'` for local accounts.
-     */
-    mode?: Methods.ChargeMode | undefined
-    /** Selects the account that signs this charge after the challenge and chain are known. */
-    resolveAccount?: ResolveAccount | undefined
-  } & Account.getResolver.Parameters &
-    Client.getResolver.Parameters
-}

package/src/tempo/client/Methods.ts

@@ -1,45 +0,0 @@
-import {
-  session as sessionLegacyIntent_,
-  sessionManager as sessionLegacy_,
-} from '../legacy/client/index.js'
-import { session as sessionMethod_ } from '../session/client/Session.js'
-import { sessionManager as session_ } from '../session/client/SessionManager.js'
-import { charge as charge_ } from './Charge.js'
-import { subscription as subscription_ } from './Subscription.js'
-
-const sessionClient = Object.assign(sessionMethod_, { manager: session_ })
-const sessionLegacyClient = Object.assign(sessionLegacy_, { method: sessionLegacyIntent_ })
-
-/** Creates a TIP-1034 client method, with explicit managed lifecycle helpers attached. */
-export { sessionClient as session }
-
-/**
- * Creates the common Tempo `charge` and `session` client methods from shared parameters.
- *
- * @example
- * ```ts
- * import { Mppx, tempo } from 'mppx/client'
- *
- * const mppx = Mppx.create({
- *   methods: [tempo.common({ account })],
- * })
- * ```
- */
-export function tempo(parameters: tempo.Parameters = {}) {
-  return [charge_(parameters), sessionClient(parameters)] as const
-}
-
-export namespace tempo {
-  export type Parameters = charge_.Parameters & sessionMethod_.Parameters
-
-  /** Creates a Tempo `charge` client method for one-time TIP-20 token transfers. */
-  export const charge = charge_
-  /** Creates the common Tempo `charge` and `session` client methods from shared parameters. */
-  export const common = tempo
-  /** Creates a TIP-1034 client method for Mppx registration. Use `tempo.session.manager()` for direct lifecycle control. */
-  export const session = sessionClient
-  /** @deprecated Use `tempo.session()` for the TIP-1034 session client method. */
-  export const sessionLegacy = sessionLegacyClient
-  /** Creates a Tempo `subscription` client method for recurring TIP-20 payments. */
-  export const subscription = subscription_
-}

package/src/tempo/client/ResolveAccount.ts

@@ -1,46 +0,0 @@
-import type * as Hex from 'ox/Hex'
-import type { Account, Address } from 'viem'
-
-import type { MaybePromise } from '../../internal/types.js'
-
-/** Resolves the account that should satisfy an mppx account operation. */
-export type ResolveAccount = (info: ResolveAccountInfo) => MaybePromise<Account | undefined>
-
-/** Account-resolution details for a client credential operation. */
-export type ResolveAccountInfo = {
-  /** Account mppx will use when the hook returns `undefined`. */
-  account: Account
-  /** EIP-155 chain ID used for the operation. */
-  chainId: number
-  /** Capability the selected account must satisfy. */
-  operation: ResolveAccountOperation
-}
-
-/** Capability an mppx-selected account must satisfy. */
-export type ResolveAccountOperation =
-  | {
-      kind: 'executeCalls'
-      /**
-       * Exact EVM calls the selected account will execute.
-       *
-       * Omitted when the calls depend on which account is selected, such as
-       * account-balance-dependent auto-swap routing.
-       */
-      calls?: readonly ResolveAccountCall[] | undefined
-    }
-  | {
-      kind: 'authorizePaymentChannel'
-      /**
-       * Signer required by an existing reusable channel. Omitted when opening
-       * a new channel or when no existing channel has fixed a signer yet.
-       */
-      authority?: Address | undefined
-    }
-
-/** EVM call data used by account resolvers for scoped account selection. */
-export type ResolveAccountCall = {
-  /** Contract address being called. */
-  to: Address
-  /** Calldata being sent. */
-  data: Hex.Hex
-}

package/src/tempo/client/Subscription.test.ts

@@ -1,180 +0,0 @@
-import { Challenge, Credential } from 'mppx'
-import { KeyAuthorization } from 'ox/tempo'
-import { privateKeyToAccount } from 'viem/accounts'
-import { describe, expect, test } from 'vp/test'
-
-import * as Methods from '../Methods.js'
-import {
-  signSubscriptionKeyAuthorization,
-  transferWithMemoSelector,
-} from '../subscription/KeyAuthorization.js'
-import type { SubscriptionAccessKey } from '../subscription/Types.js'
-import { subscription } from './Subscription.js'
-
-const chainId = 4217
-const currency = '0x20c0000000000000000000000000000000000001'
-const recipient = '0x1234567890abcdef1234567890abcdef12345678'
-const selectedAccount = privateKeyToAccount(
-  '0x0000000000000000000000000000000000000000000000000000000000000001',
-)
-const accessAccount = privateKeyToAccount(
-  '0x0000000000000000000000000000000000000000000000000000000000000002',
-)
-const otherRootAccount = privateKeyToAccount(
-  '0x0000000000000000000000000000000000000000000000000000000000000003',
-)
-const accessKey = {
-  accessKeyAddress: accessAccount.address,
-  keyType: 'secp256k1',
-} as const satisfies SubscriptionAccessKey
-
-type SubscriptionRequest = ReturnType<typeof Methods.subscription.schema.request.parse>
-
-function secondsFromNow(milliseconds: number) {
-  return new Date(Math.ceil((Date.now() + milliseconds) / 1_000) * 1_000).toISOString()
-}
-
-function createChallenge(
-  overrides: Partial<Parameters<typeof Methods.subscription.schema.request.parse>[0]> = {},
-): Challenge.Challenge<SubscriptionRequest, 'subscription', 'tempo'> {
-  const request = Methods.subscription.schema.request.parse({
-    accessKey,
-    amount: '1',
-    chainId,
-    currency,
-    decimals: 6,
-    periodCount: '1',
-    periodUnit: 'day',
-    recipient,
-    subscriptionExpires: secondsFromNow(86_400_000),
-    ...overrides,
-  })
-  return Challenge.from({
-    id: 'test-challenge-id',
-    intent: 'subscription',
-    method: 'tempo',
-    realm: 'api.example.com',
-    request,
-  }) as Challenge.Challenge<SubscriptionRequest, 'subscription', 'tempo'>
-}
-
-describe('tempo.subscription client', () => {
-  test('uses Tempo testnet as the default subscription chain', async () => {
-    const challenge = createChallenge({ chainId: undefined })
-    const method = subscription({
-      account: selectedAccount,
-    })
-
-    const credential = Credential.deserialize(
-      await method.createCredential({ challenge, context: {} }),
-    )
-    const payload = Methods.subscription.schema.credential.payload.parse(credential.payload)
-    const authorization = KeyAuthorization.deserialize(payload.signature as `0x${string}`)
-
-    expect(authorization.chainId).toBe(42431n)
-  })
-
-  test('can reject subscription expiry from custom request validation', async () => {
-    const challenge = createChallenge({
-      subscriptionExpires: secondsFromNow(2 * 86_400_000),
-    })
-    const method = subscription({
-      account: selectedAccount,
-      validateRequest: (request) => {
-        const maxExpiry = Date.now() + 86_400_000
-        if (new Date(request.subscriptionExpires).getTime() > maxExpiry) {
-          throw new Error('subscription expiry too late')
-        }
-      },
-    })
-
-    await expect(method.createCredential({ challenge, context: {} })).rejects.toThrow(
-      'subscription expiry too late',
-    )
-  })
-
-  test('runs custom request validation before authorizing the access key', async () => {
-    const challenge = createChallenge()
-    const method = subscription({
-      account: selectedAccount,
-      validateRequest: () => {
-        throw new Error('unexpected subscription request')
-      },
-    })
-
-    await expect(method.createCredential({ challenge, context: {} })).rejects.toThrow(
-      'unexpected subscription request',
-    )
-  })
-
-  test('passes hex-encoded `scopes` and `limits` to wallet_authorizeAccessKey', async () => {
-    const challenge = createChallenge()
-    const keyAuthorization = await signSubscriptionKeyAuthorization({
-      accessKey,
-      account: selectedAccount,
-      chainId,
-      request: challenge.request,
-    })
-    if (!keyAuthorization) throw new Error('expected key authorization')
-
-    let capturedParams: Record<string, unknown> | undefined
-    const method = subscription({
-      account: selectedAccount.address,
-      getClient: async () =>
-        ({
-          request: async ({ params }: { params: readonly Record<string, unknown>[] }) => {
-            capturedParams = params[0]
-            return { keyAuthorization: KeyAuthorization.toRpc(keyAuthorization) }
-          },
-        }) as never,
-    })
-
-    await method.createCredential({ challenge, context: {} })
-
-    expect(capturedParams).toMatchObject({
-      address: accessKey.accessKeyAddress.toLowerCase(),
-      keyType: accessKey.keyType,
-      expiry: expect.any(Number),
-      limits: [
-        {
-          token: expect.stringMatching(/^0x[0-9a-fA-F]{40}$/),
-          limit: '0xf4240',
-          period: expect.any(Number),
-        },
-      ],
-      scopes: [
-        {
-          address: expect.stringMatching(/^0x[0-9a-fA-F]{40}$/),
-          selector: transferWithMemoSelector,
-          recipients: expect.any(Array),
-        },
-      ],
-    })
-    expect(capturedParams).not.toHaveProperty('allowedCalls')
-  })
-
-  test('rejects key authorizations signed by a different account', async () => {
-    const challenge = createChallenge()
-    const keyAuthorization = await signSubscriptionKeyAuthorization({
-      accessKey,
-      account: otherRootAccount,
-      chainId,
-      request: challenge.request,
-    })
-    if (!keyAuthorization) throw new Error('expected key authorization')
-
-    const method = subscription({
-      account: selectedAccount.address,
-      getClient: async () =>
-        ({
-          request: async () => ({
-            keyAuthorization: KeyAuthorization.toRpc(keyAuthorization),
-          }),
-        }) as never,
-    })
-
-    await expect(method.createCredential({ challenge, context: {} })).rejects.toThrow(
-      'keyAuthorization signer does not match the selected account',
-    )
-  })
-})

package/src/tempo/client/Subscription.ts

@@ -1,156 +0,0 @@
-import { Hex } from 'ox'
-import { KeyAuthorization } from 'ox/tempo'
-import { isAddressEqual, type Address } from 'viem'
-import { tempo as tempo_chain } from 'viem/tempo/chains'
-
-import * as Credential from '../../Credential.js'
-import type { MaybePromise } from '../../internal/types.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 defaults from '../internal/defaults.js'
-import * as Methods from '../Methods.js'
-import {
-  getSubscriptionScopes,
-  signSubscriptionKeyAuthorization,
-  toSubscriptionExpiryDate,
-  toSubscriptionExpirySeconds,
-  toSubscriptionPeriodSeconds,
-  verifySubscriptionKeyAuthorization,
-} from '../subscription/KeyAuthorization.js'
-import type { SubscriptionAccessKey } from '../subscription/Types.js'
-
-type SubscriptionRequest = ReturnType<typeof Methods.subscription.schema.request.parse>
-
-/** Context accepted by the Tempo subscription client method. */
-export const subscriptionContextSchema = z.object({
-  accessKey: z.optional(z.custom<SubscriptionAccessKey>()),
-  account: z.optional(z.custom<Account.getResolver.Parameters['account']>()),
-})
-
-/** Runtime context for creating a Tempo subscription credential. */
-export type SubscriptionContext = z.infer<typeof subscriptionContextSchema>
-
-/** Creates a Tempo subscription client method. */
-export function subscription(parameters: subscription.Parameters = {}) {
-  const getClient = Client.getResolver({
-    chain: tempo_chain,
-    getClient: parameters.getClient,
-    rpcUrl: defaults.rpcUrl,
-  })
-  const getAccount = Account.getResolver({ account: parameters.account })
-
-  return Method.toClient(Methods.subscription, {
-    context: subscriptionContextSchema,
-
-    async createCredential({ challenge, context }) {
-      const chainId = challenge.request.methodDetails?.chainId ?? defaults.chainId.testnet
-      const client = await getClient({ chainId })
-      const account = getAccount(client, context)
-      const accessKey =
-        context?.accessKey ?? parameters.accessKey ?? challenge.request.methodDetails?.accessKey
-      if (!accessKey) {
-        throw new Error(
-          'No `accessKey` provided. The subscription challenge must include `accessKey`, or the client must pass one to parameters/context.',
-        )
-      }
-
-      assertSubscriptionRequestRepresentable(challenge.request)
-      await parameters.validateRequest?.(challenge.request)
-
-      const keyAuthorization = await authorizeAccessKey(client, {
-        accessKey,
-        account,
-        chainId,
-        request: challenge.request,
-      } as never)
-
-      const verified = verifySubscriptionKeyAuthorization({
-        accessKey,
-        chainId,
-        payload: {
-          signature: KeyAuthorization.serialize(keyAuthorization as never),
-          type: 'keyAuthorization',
-        },
-        request: challenge.request,
-      })
-      if (!isAddressEqual(verified.source.address, account.address)) {
-        throw new Error('keyAuthorization signer does not match the selected account')
-      }
-
-      return Credential.serialize({
-        challenge,
-        payload: {
-          signature: KeyAuthorization.serialize(keyAuthorization as never),
-          type: 'keyAuthorization',
-        },
-        source: `did:pkh:eip155:${chainId}:${account.address.toLowerCase()}`,
-      })
-    },
-  })
-}
-
-async function authorizeAccessKey(
-  client: Awaited<ReturnType<ReturnType<typeof Client.getResolver>>>,
-  parameters: {
-    accessKey: SubscriptionAccessKey
-    account: Account.Account
-    chainId: number
-    request: Pick<
-      SubscriptionRequest,
-      'amount' | 'currency' | 'periodCount' | 'periodUnit' | 'recipient' | 'subscriptionExpires'
-    >
-  },
-) {
-  const { accessKey, account, chainId, request } = parameters
-
-  const local = await signSubscriptionKeyAuthorization({
-    accessKey,
-    account,
-    chainId,
-    request,
-  })
-  if (local) return local
-
-  const result = (await client.request({
-    method: 'wallet_authorizeAccessKey',
-    params: [
-      {
-        address: accessKey.accessKeyAddress,
-        expiry: toSubscriptionExpirySeconds(toSubscriptionExpiryDate(request.subscriptionExpires)),
-        keyType: accessKey.keyType,
-        limits: [
-          {
-            token: request.currency as Address,
-            limit: Hex.fromNumber(BigInt(request.amount)),
-            period: toSubscriptionPeriodSeconds(request),
-          },
-        ],
-        scopes: getSubscriptionScopes(request),
-      },
-    ],
-  } as never)) as {
-    keyAuthorization: Parameters<typeof KeyAuthorization.fromRpc>[0]
-  }
-
-  return KeyAuthorization.fromRpc(result.keyAuthorization)
-}
-
-function assertSubscriptionRequestRepresentable(request: SubscriptionRequest) {
-  toSubscriptionPeriodSeconds(request)
-  toSubscriptionExpirySeconds(toSubscriptionExpiryDate(request.subscriptionExpires))
-}
-
-export declare namespace subscription {
-  /** Parameters for creating a Tempo subscription credential. */
-  type Parameters = Account.getResolver.Parameters &
-    Client.getResolver.Parameters & {
-      accessKey?: SubscriptionAccessKey | undefined
-      validateRequest?:
-        | ((
-            request: ReturnType<typeof Methods.subscription.schema.request.parse>,
-          ) => MaybePromise<void>)
-        | undefined
-    }
-}