@absol-labs/agent 0.11.0 → 0.12.0-rc.2

package/src/wallet/lifecycle.ts

@@ -1,5 +1,12 @@
+import { networkForChainId } from "@absol-labs/sdk";
 import { erc20Abi, type Address } from "viem";
 
+import {
+  defaultNetwork,
+  describeAllowedNetworks,
+  networkFunding,
+} from "../network.js";
+
 /**
  * Agent wallet lifecycle helpers (metrik-agent#65).
  *
@@ -21,7 +28,7 @@ import { erc20Abi, type Address } from "viem";
 
 /** Native gas balance + USDC balance for one address. */
 export interface WalletBalances {
-  /** Native token balance (ETH on Base/Base Sepolia), in wei. */
+  /** Native gas-token balance, in its smallest unit (the network's `gasToken.decimals`). */
   readonly nativeWei: bigint;
   /** USDC balance, in atomic units (6 decimals). */
   readonly usdcAtomic: bigint;
@@ -63,10 +70,21 @@ export async function getWalletBalances(
 
 /** Human-facing pointers to fund a freshly created/restored testnet wallet. */
 export interface FaucetHint {
+  /** The Coinbase CDP faucet's name for the network (e.g. what `requestCdpFaucet` sends). */
   readonly network: string;
-  /** Coinbase CDP faucet — funds native ETH (and, on some networks, USDC) for a CDP-managed address. */
+  /** The registry id of the network the hint is for. */
+  readonly networkId: string;
+  /**
+   * The network's gas token, from the registry's gas-token metadata. NOT always
+   * ETH: where gas is the settlement token, it is USDC and
+   * {@link FaucetHint.gasIsSettlementToken} is `true`.
+   */
+  readonly gasToken: string;
+  /** Whether gas is paid in the same token streams settle in (one balance to fund). */
+  readonly gasIsSettlementToken: boolean;
+  /** Coinbase CDP faucet — funds the gas token (and, on some networks, USDC) for a CDP-managed address. */
   readonly cdpFaucetUrl: string;
-  /** Circle's own Base Sepolia USDC faucet — an alternative USDC source that doesn't require a CDP account. */
+  /** Circle's USDC faucet for the network — a USDC source that doesn't require a CDP account. */
   readonly usdcFaucetUrl: string;
   /** How to request the same funds programmatically from a CDP wallet — see {@link requestCdpFaucet}. */
   readonly programmaticHint: string;
@@ -75,28 +93,42 @@ export interface FaucetHint {
 export class UnsupportedFaucetChainError extends Error {
   constructor(chainId: number) {
     super(
-      `no known testnet faucet for chainId ${chainId} (Metrik is Base Sepolia (84532) only)`,
+      `no known testnet faucet for chainId ${chainId} (registered testnets: ${describeAllowedNetworks({ testnetOnly: true })})`,
     );
     this.name = "UnsupportedFaucetChainError";
   }
 }
 
-const BASE_SEPOLIA_CHAIN_ID = 84532;
+const CDP_FAUCET_URL = "https://portal.cdp.coinbase.com/products/faucet";
 
-const BASE_SEPOLIA_FAUCET_HINT: FaucetHint = {
-  network: "base-sepolia",
-  cdpFaucetUrl: "https://portal.cdp.coinbase.com/products/faucet",
-  usdcFaucetUrl: "https://faucet.circle.com",
-  programmaticHint:
-    "requestCdpFaucet({ cdp, address, token: 'eth' | 'usdc' }) — subject to a 24h per-address rate limit",
-};
-
-/** A faucet hint for the given chain. Only Base Sepolia (84532) is supported — Metrik is testnet-only, single-chain. */
+/**
+ * A faucet hint for the given chain, read from the network registry (gas token)
+ * plus the agent's funding catalogue (faucet URLs). Only a registered TESTNET
+ * with a known CDP faucet has one; anything else throws
+ * {@link UnsupportedFaucetChainError}.
+ */
 export function faucetHint(chainId: number): FaucetHint {
-  if (chainId !== BASE_SEPOLIA_CHAIN_ID) {
+  const network = networkForChainId(chainId);
+  if (network === undefined || !network.testnet) {
+    throw new UnsupportedFaucetChainError(chainId);
+  }
+  const funding = networkFunding(network);
+  if (funding.cdpNetwork === null || funding.usdcFaucetUrl === null) {
     throw new UnsupportedFaucetChainError(chainId);
   }
-  return BASE_SEPOLIA_FAUCET_HINT;
+  const gasToken = network.gasToken.symbol;
+  const tokens = network.gasToken.isSettlementToken
+    ? "'usdc'"
+    : `'${gasToken.toLowerCase()}' | 'usdc'`;
+  return {
+    network: funding.cdpNetwork,
+    networkId: network.id,
+    gasToken,
+    gasIsSettlementToken: network.gasToken.isSettlementToken,
+    cdpFaucetUrl: CDP_FAUCET_URL,
+    usdcFaucetUrl: funding.usdcFaucetUrl,
+    programmaticHint: `requestCdpFaucet({ cdp, address, token: ${tokens} }) — subject to a 24h per-address rate limit`,
+  };
 }
 
 export type FaucetToken = "eth" | "usdc";
@@ -116,7 +148,7 @@ export interface RequestCdpFaucetOptions {
   readonly cdp: CdpFaucetClientLike;
   readonly address: Address;
   readonly token: FaucetToken;
-  /** Default `"base-sepolia"`. */
+  /** CDP faucet network name. Default: the registry's default network's CDP name. */
   readonly network?: string;
 }
 
@@ -145,7 +177,10 @@ export async function requestCdpFaucet(
   try {
     const result = await options.cdp.evm.requestFaucet({
       address: options.address,
-      network: options.network ?? "base-sepolia",
+      network:
+        options.network ??
+        networkFunding(defaultNetwork()).cdpNetwork ??
+        defaultNetwork().id,
       token: options.token,
     });
     return { requested: true, txHash: result.transactionHash };

package/src/wallet/privy-broker-server.ts

@@ -20,12 +20,15 @@ import {
   type AutonomousWalletProvision,
 } from "./autonomous-wallet-broker.js";
 import {
+  PRIVY_BROKER_CAIP2,
+  PRIVY_BROKER_CHAIN_ID,
   PrivySessionBroker,
   PrivySessionBrokerError,
   type PrivyBrokerProvider,
   type PrivyBrokerSession,
   type PrivyBrokerSessionStore,
 } from "./privy-session-broker.js";
+import { defaultNetwork } from "../network.js";
 
 const serverEnvSchema = z.object({
   PRIVY_APP_ID: z.string().min(1),
@@ -56,7 +59,7 @@ const rpcSchema = z.object({
 const autonomousProofSchema = z.object({
   version: z.literal(1),
   appId: z.string().min(1).max(200),
-  chainId: z.literal(84532),
+  chainId: z.literal(PRIVY_BROKER_CHAIN_ID),
   publicKey: z.string().min(1).max(1_024),
   nonce: z.string().min(16).max(256),
   issuedAt: z.number().int().safe(),
@@ -64,7 +67,7 @@ const autonomousProofSchema = z.object({
 });
 const autonomousProvisionSchema = z.object({
   appId: z.string().min(1).max(200),
-  chainId: z.literal(84532),
+  chainId: z.literal(PRIVY_BROKER_CHAIN_ID),
   publicKey: z.string().min(1).max(1_024),
   proof: autonomousProofSchema,
   idempotencyKey: z.string().min(16).max(256),
@@ -92,7 +95,32 @@ export async function startPrivyBrokerServer(
     appId: config.PRIVY_APP_ID,
     appSecret: config.PRIVY_APP_SECRET,
   });
-  const metrik = MetrikClient.baseSepolia();
+  // One read-only client per escrow: the current one, and a legacy one when an
+  // exit targets it (V2 and V3 share the getStream tuple).
+  const network = defaultNetwork();
+  const clients = new Map<string, MetrikClient>();
+  const clientFor = (escrow?: `0x${string}`): MetrikClient => {
+    const key = (escrow ?? network.escrow.address).toLowerCase();
+    let client = clients.get(key);
+    if (client === undefined) {
+      client = MetrikClient.forNetwork(
+        network,
+        escrow === undefined ? {} : { escrow },
+      );
+      clients.set(key, client);
+    }
+    return client;
+  };
+  const brokerStreamReader = {
+    getStream: async (streamId: Hex, escrow?: `0x${string}`) => {
+      const stream = await clientFor(escrow).getStreamV2(streamId);
+      return {
+        buyer: stream.buyer,
+        serviceRef: stream.serviceRef,
+        status: stream.status,
+      };
+    },
+  };
   const provider = createPrivyProvider(client);
   const autonomousBroker = new AutonomousWalletBroker({
     appId: config.PRIVY_APP_ID,
@@ -102,31 +130,13 @@ export async function startPrivyBrokerServer(
       config.METRIK_PRIVY_AUTONOMOUS_STORE ??
         `${config.METRIK_PRIVY_SESSION_STORE}.autonomous`,
     ),
-    streamReader: {
-      getStream: async (streamId) => {
-        const stream = await metrik.getStreamV2(streamId);
-        return {
-          buyer: stream.buyer,
-          serviceRef: stream.serviceRef,
-          status: stream.status,
-        };
-      },
-    },
+    streamReader: brokerStreamReader,
   });
   const broker = new PrivySessionBroker({
     provider,
     store: new JsonPrivyBrokerSessionStore(config.METRIK_PRIVY_SESSION_STORE),
     authorizationPrivateKey,
-    streamReader: {
-      getStream: async (streamId) => {
-        const stream = await metrik.getStreamV2(streamId);
-        return {
-          buyer: stream.buyer,
-          serviceRef: stream.serviceRef,
-          status: stream.status,
-        };
-      },
-    },
+    streamReader: brokerStreamReader,
   });
   const allowedOrigins = new Set(
     config.METRIK_PRIVY_ALLOWED_ORIGINS.split(",").map((value) => value.trim()),
@@ -150,7 +160,7 @@ export async function startPrivyBrokerServer(
           appId: config.PRIVY_APP_ID,
           keyQuorumId: config.PRIVY_KEY_QUORUM_ID,
           policyId: config.PRIVY_POLICY_ID,
-          chainId: 84532,
+          chainId: PRIVY_BROKER_CHAIN_ID,
           maxTotalUsdcAtomic: "1000000",
           maxRatePerSecondAtomic: "1000",
           maxDurationSeconds: 3600,
@@ -431,7 +441,7 @@ function createPrivyProvider(client: PrivyClient): PrivyBrokerProvider {
         .wallets()
         .ethereum()
         .sendTransaction(input.walletId, {
-          caip2: "eip155:84532",
+          caip2: PRIVY_BROKER_CAIP2,
           params: { transaction: input.transaction as never },
           sponsor: input.sponsor,
           authorization_context: {

package/src/wallet/privy-session-broker.ts

@@ -1,6 +1,5 @@
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 
-import { streamEscrowV2Abi } from "@absol-labs/shared";
 import {
   decodeFunctionData,
   getAddress,
@@ -22,13 +21,25 @@ import {
   invocationCapabilityDomainVersion,
   invocationCapabilitySchema,
 } from "../capability/invocation-capability.js";
-
-export const PRIVY_BROKER_CHAIN_ID = 84532;
-export const PRIVY_BROKER_CAIP2 = "eip155:84532" as const;
-export const PRIVY_BROKER_ESCROW =
-  "0x0f09f36Ccc05A7c9882F438721C08De314dFd46C" as const;
-export const PRIVY_BROKER_USDC =
-  "0x036CbD53842c5426634e7929541eC2318f3dCF7e" as const;
+import { defaultNetwork } from "../network.js";
+import {
+  BROKER_EXIT_METHODS,
+  brokerEscrowPolicy,
+  decodeEscrowCall,
+  escrowRole,
+  type BrokerEscrowPolicy,
+} from "./broker-escrows.js";
+
+/**
+ * The deployment a Privy broker polices: the registry's default network. Its
+ * Privy policy allowlists exactly this escrow and this USDC, so these are read
+ * once from the `@absol-labs/sdk` network registry, never written as literals.
+ */
+const BROKER_NETWORK = defaultNetwork();
+export const PRIVY_BROKER_CHAIN_ID: number = BROKER_NETWORK.chain.id;
+export const PRIVY_BROKER_CAIP2: `eip155:${number}` = BROKER_NETWORK.caip2;
+export const PRIVY_BROKER_ESCROW: `0x${string}` = BROKER_NETWORK.escrow.address;
+export const PRIVY_BROKER_USDC: `0x${string}` = BROKER_NETWORK.usdc.address;
 export const PRIVY_POLICY_MAX_TOTAL_USDC = 1_000_000n;
 export const PRIVY_POLICY_MAX_RATE_USDC = 1_000n;
 export const PRIVY_POLICY_MAX_DURATION_SECONDS = 3_600;
@@ -83,7 +94,15 @@ export interface PrivyBrokerProvider {
 }
 
 export interface BrokerStreamReader {
-  getStream(streamId: Hex): Promise<{
+  /**
+   * Read a stream. `escrow` names the escrow the transaction targets (the
+   * current one, or a legacy one for an exit); readers that serve only one
+   * escrow may ignore it.
+   */
+  getStream(
+    streamId: Hex,
+    escrow?: Address,
+  ): Promise<{
     readonly buyer: Address;
     readonly serviceRef: Hex;
     readonly status: "active" | "closed";
@@ -151,8 +170,14 @@ export class PrivySessionBroker {
       readonly streamReader: BrokerStreamReader;
       readonly authorizationPrivateKey: string;
       readonly nowSeconds?: () => number;
+      /** Current + legacy escrows. Default: from the registries (see `./broker-escrows.ts`). */
+      readonly escrows?: BrokerEscrowPolicy;
     },
-  ) {}
+  ) {
+    this.escrows = dependencies.escrows ?? brokerEscrowPolicy(BROKER_NETWORK);
+  }
+
+  private readonly escrows: BrokerEscrowPolicy;
 
   async createSession(input: CreatePrivyBrokerSessionInput): Promise<{
     readonly sessionId: string;
@@ -276,11 +301,13 @@ export class PrivySessionBroker {
     const to = getAddress(transaction.to);
     const data = transaction.data as Hex;
 
+    const role = escrowRole(this.escrows, to);
     if (to.toLowerCase() === PRIVY_BROKER_USDC.toLowerCase()) {
-      assertBoundedApproval(data, session.signedMandate);
-    } else if (to.toLowerCase() === PRIVY_BROKER_ESCROW.toLowerCase()) {
-      const decoded = decodeFunctionData({ abi: streamEscrowV2Abi, data });
-      if (decoded.functionName === "openStream") {
+      // The approval spender must be the CURRENT escrow, never a legacy one.
+      assertBoundedApproval(data, session.signedMandate, this.escrows.current);
+    } else if (role !== null) {
+      const decoded = decodeEscrowCall(data);
+      if (decoded.functionName === "openStream" && role === "current") {
         const [operator, , deposit, rate, duration] = decoded.args;
         const decision = await checkMandate(
           session.signedMandate,
@@ -307,14 +334,13 @@ export class PrivySessionBroker {
         });
         return hash;
       }
-      if (
-        decoded.functionName !== "close" &&
-        decoded.functionName !== "reclaim" &&
-        decoded.functionName !== "reclaimUnverified"
-      ) {
+      // A legacy escrow is exit-only: openStream falls through to here too.
+      if (!BROKER_EXIT_METHODS.has(decoded.functionName)) {
         throw new PrivySessionBrokerError(
           "policy-denied",
-          "escrow method is not allowed for an agent session",
+          role === "legacy"
+            ? "only close, reclaim and reclaimUnverified are allowed on a legacy escrow"
+            : "escrow method is not allowed for an agent session",
         );
       }
       const owner = await verifyMandateOwnerSignature(session.signedMandate);
@@ -324,8 +350,11 @@ export class PrivySessionBroker {
           "mandate owner signature is invalid",
         );
       }
-      const streamId = decoded.args[0];
-      const stream = await this.dependencies.streamReader.getStream(streamId);
+      const streamId = (decoded.args as readonly unknown[])[0] as Hex;
+      const stream = await this.dependencies.streamReader.getStream(
+        streamId,
+        to,
+      );
       if (stream.buyer.toLowerCase() !== session.address.toLowerCase()) {
         throw new PrivySessionBrokerError(
           "policy-denied",
@@ -375,7 +404,7 @@ export class PrivySessionBroker {
       Number(domain.chainId) !== PRIVY_BROKER_CHAIN_ID ||
       typeof domain.verifyingContract !== "string" ||
       domain.verifyingContract.toLowerCase() !==
-        PRIVY_BROKER_ESCROW.toLowerCase() ||
+        this.escrows.current.toLowerCase() ||
       typedDataRecord.primaryType !== "InvocationCapability"
     ) {
       throw new PrivySessionBrokerError(
@@ -563,7 +592,11 @@ function assertMandateWithinPrivyPolicy(signed: SignedSpendMandate): void {
   }
 }
 
-function assertBoundedApproval(data: Hex, signed: SignedSpendMandate): void {
+function assertBoundedApproval(
+  data: Hex,
+  signed: SignedSpendMandate,
+  currentEscrow: Address,
+): void {
   const decoded = decodeFunctionData({
     abi: [
       {
@@ -581,7 +614,7 @@ function assertBoundedApproval(data: Hex, signed: SignedSpendMandate): void {
   });
   const [spender, amount] = decoded.args;
   if (
-    spender.toLowerCase() !== PRIVY_BROKER_ESCROW.toLowerCase() ||
+    spender.toLowerCase() !== currentEscrow.toLowerCase() ||
     amount > signed.mandate.maxPerStreamUsdc
   ) {
     throw new PrivySessionBrokerError(

package/src/wallet/privy-session-provider.ts

@@ -1,6 +1,7 @@
 import { getAddress, type Address, type Hex } from "viem";
 import { z } from "zod";
 
+import { defaultNetwork } from "../network.js";
 import type { PrivyEip1193Provider } from "./provider.js";
 
 const jsonRpcResponseSchema = z.object({
@@ -21,6 +22,8 @@ export interface PrivySessionProviderConfig {
   readonly sessionToken: string;
   readonly address: Address;
   readonly rpcUrl?: string;
+  /** Chain the session signs on. Default: the registry's default network. */
+  readonly chainId?: number;
   readonly fetchImpl?: typeof fetch;
 }
 
@@ -34,7 +37,7 @@ export class PrivySessionProviderError extends Error {
 /**
  * EIP-1193 provider for a policy-bound Metrik/Privy headless session.
  * Signing and writes go only to the broker; public read RPCs go directly to
- * Base Sepolia and never receive the session token.
+ * the network's public RPC and never receive the session token.
  */
 export function createPrivySessionProvider(
   config: PrivySessionProviderConfig,
@@ -42,12 +45,13 @@ export function createPrivySessionProvider(
   const fetchImpl = config.fetchImpl ?? fetch;
   const address = getAddress(config.address);
   const brokerUrl = new URL("/v1/rpc", requireHttpsBase(config.brokerUrl));
-  const rpcUrl = config.rpcUrl ?? "https://base-sepolia-rpc.publicnode.com";
+  const rpcUrl = config.rpcUrl ?? defaultNetwork().rpcUrls[0];
+  const chainIdHex = `0x${(config.chainId ?? defaultNetwork().chain.id).toString(16)}`;
   let rpcId = 0;
 
   return {
     async request({ method, params = [] }) {
-      if (method === "eth_chainId") return "0x14a34";
+      if (method === "eth_chainId") return chainIdHex;
       if (method === "eth_accounts" || method === "eth_requestAccounts") {
         return [address];
       }

package/src/wallet/provider.ts

@@ -1,4 +1,7 @@
-import { type StreamProofClientConfig } from "@absol-labs/sdk";
+import {
+  networkForChainId,
+  type StreamProofClientConfig,
+} from "@absol-labs/sdk";
 // `@coinbase/cdp-sdk` is an OPTIONAL peer dependency: TYPES only here (erased at
 // compile time), the runtime module via `loadCdpSdk()` at the point of first use.
 // This module IS reachable from the package barrel, so a value import here would
@@ -26,6 +29,7 @@ import {
   VerifiedStreamAgentClient,
   type AgentSdkClientFactory,
 } from "../sdk/client.js";
+import { defaultNetwork, requireNetworkForChainId } from "../network.js";
 
 const privateKeySchema = z
   .string()
@@ -165,7 +169,7 @@ export async function resolveAgentWallet(
   }
 
   if ("privy" in input) {
-    const chainId = input.privy.chainId ?? BASE_SEPOLIA_CHAIN_ID;
+    const chainId = input.privy.chainId ?? defaultNetwork().chain.id;
     const account = await createPrivyEmbeddedAccount(input.privy);
     return {
       source: "privy",
@@ -214,7 +218,7 @@ export async function createPrivyEmbeddedAccount(
   config: PrivyEmbeddedWalletConfig,
 ): Promise<Account> {
   validatePrivyConfig(config);
-  const chainId = config.chainId ?? BASE_SEPOLIA_CHAIN_ID;
+  const chainId = config.chainId ?? defaultNetwork().chain.id;
   await assertPrivySession(config, chainId);
 
   const account = {
@@ -357,8 +361,6 @@ async function defaultCdpClientFactory(
   });
 }
 
-const BASE_SEPOLIA_CHAIN_ID = 84532;
-
 function validatePrivyConfig(config: PrivyEmbeddedWalletConfig): void {
   if (config.appId.trim() === "") {
     throw new PrivyEmbeddedWalletError(
@@ -372,14 +374,17 @@ function validatePrivyConfig(config: PrivyEmbeddedWalletConfig): void {
       "Privy wallet address is invalid",
     );
   }
-  if (
-    config.chainId !== undefined &&
-    config.chainId !== BASE_SEPOLIA_CHAIN_ID
-  ) {
-    throw new PrivyEmbeddedWalletError(
-      "invalid-config",
-      `Metrik Privy wallets support Base Sepolia chain ID ${BASE_SEPOLIA_CHAIN_ID} only`,
-    );
+  if (config.chainId !== undefined) {
+    // A registered TESTNET network only: the wallet signs with a key the
+    // browser holds and Metrik settles real value on a mainnet.
+    try {
+      requireNetworkForChainId(config.chainId, { testnetOnly: true });
+    } catch (error) {
+      throw new PrivyEmbeddedWalletError(
+        "invalid-config",
+        `Metrik Privy wallets support registered testnet networks only: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 }
 
@@ -406,7 +411,7 @@ async function assertPrivySession(
   if (chainId !== expectedChainId) {
     throw new PrivyEmbeddedWalletError(
       "chain-mismatch",
-      `Privy wallet chain ID ${chainId} is not Base Sepolia (${expectedChainId})`,
+      `Privy wallet chain ID ${chainId} is not ${networkForChainId(expectedChainId)?.name ?? "the configured network"} (${expectedChainId})`,
     );
   }
   if (
@@ -441,7 +446,7 @@ async function requestPrivy(
 function createCheckedPrivyProvider(
   config: PrivyEmbeddedWalletConfig,
 ): PrivyEip1193Provider {
-  const expectedChainId = config.chainId ?? BASE_SEPOLIA_CHAIN_ID;
+  const expectedChainId = config.chainId ?? defaultNetwork().chain.id;
   return {
     request: async (args) => {
       if (args.method === "eth_sendTransaction") {

package/src/x402/facilitator.ts

@@ -8,8 +8,9 @@
  * facilitator. See `docs/x402.md` for the full explanation of why Metrik's
  * metered-stream settlement does not fit any shipped x402 scheme.
  *
- * The `X402*` / `x402*` exports at the bottom of this file are deprecated
- * aliases of the canonical names, kept so existing consumers keep working.
+ * The directory name is historical. The deprecated `X402*` / `x402*` alias
+ * exports that used to live here were removed with the x402 v1 integration
+ * (metrik-agent#115); only the canonical names below are exported.
  */
 import type { StreamProofClientConfig } from "@absol-labs/sdk";
 import { z } from "zod";
@@ -442,44 +443,3 @@ function reviveBigInts(value: unknown): unknown {
 
   return value;
 }
-
-/* -------------------------------------------------------------------------- */
-/* Deprecated `x402`-flavoured aliases.                                        */
-/*                                                                             */
-/* These names are misleading — this flow is Metrik-native and not x402 (see   */
-/* `docs/x402.md`). They are retained as aliases bound to the SAME values and  */
-/* class objects as the canonical exports above, so existing consumers and     */
-/* `instanceof` checks keep working. Prefer the canonical names.               */
-/* -------------------------------------------------------------------------- */
-
-export {
-  /** @deprecated Use {@link METRIK_STREAM_SCHEME}. This flow is not x402. */
-  METRIK_STREAM_SCHEME as X402_SCHEME,
-  /** @deprecated Use {@link VerifiedStreamFacilitator}. This flow is not x402. */
-  VerifiedStreamFacilitator as VerifiedStreamX402Facilitator,
-  /** @deprecated Use {@link StreamPayloadError}. Same class object. */
-  StreamPayloadError as X402PayloadError,
-  /** @deprecated Use {@link SpendControlUnavailableError}. Same class object. */
-  SpendControlUnavailableError as X402SpendControlUnavailableError,
-  /** @deprecated Use {@link streamChallengeSchema}. */
-  streamChallengeSchema as x402StreamChallengeSchema,
-  /** @deprecated Use {@link streamOpenPayloadSchema}. */
-  streamOpenPayloadSchema as x402OpenPayloadSchema,
-  /** @deprecated Use {@link encodeStreamPayloadHeader}. */
-  encodeStreamPayloadHeader as encodeX402PayloadHeader,
-  /** @deprecated Use {@link parseStreamPayloadHeader}. */
-  parseStreamPayloadHeader as parseX402PayloadHeader,
-  /** @deprecated Use {@link parseStreamChallengeJson}. */
-  parseStreamChallengeJson as parseX402ChallengeJson,
-};
-
-export type {
-  /** @deprecated Use {@link StreamFacilitator}. This flow is not x402. */
-  StreamFacilitator as X402Facilitator,
-  /** @deprecated Use {@link StreamChallenge}. */
-  StreamChallenge as X402StreamChallenge,
-  /** @deprecated Use {@link StreamOpenPayload}. */
-  StreamOpenPayload as X402OpenPayload,
-  /** @deprecated Use {@link ConsumedHttpsResponseProofInput}. */
-  ConsumedHttpsResponseProofInput as X402ConsumedHttpsResponseProofInput,
-};