@lunora/x402 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/pay/index.d.ts

@@ -1,5 +1,5 @@
-import { e as X402PayConfig } from "../packem_shared/config.d-CddwCiBm.js";
-export { type C as Caip2, D as DEFAULT_FACILITATOR_URL, m as DEFAULT_STABLECOIN_DECIMALS, type n as SpendPolicy, type o as SpendState, type X as X402CdpSignerConfig, type d as X402Network, type f as X402Price, type j as X402SignerConfig, p as assertBoundedPolicy, q as buildPaymentGuard, s as buildSpendPolicy, u as createSpendState, k as isEvmNetwork, l as isSvmNetwork, v as recordSpend, r as resolveFacilitatorUrl, t as toCaip2, w as usdToAtomic } from "../packem_shared/config.d-CddwCiBm.js";
+import { e as X402PayConfig } from "../packem_shared/config.d-Dki_2r9a.js";
+export { type A as AllowedAsset, type C as Caip2, m as DEFAULT_ALLOWED_ASSETS, D as DEFAULT_FACILITATOR_URL, n as DEFAULT_STABLECOIN_DECIMALS, type o as SpendPolicy, type p as SpendState, type X as X402CdpSignerConfig, type d as X402Network, type f as X402Price, type j as X402SignerConfig, q as assertBoundedPolicy, s as buildPaymentGuard, u as buildSpendPolicy, v as createSpendState, k as isEvmNetwork, l as isSvmNetwork, w as releaseSpendOnFailure, r as resolveFacilitatorUrl, t as toCaip2, x as usdToAtomic } from "../packem_shared/config.d-Dki_2r9a.js";
 import { x402Client } from '@x402/core/client';
 import { ClientSvmSigner } from '@x402/svm';
 import { PrivateKeyAccount } from 'viem/accounts';
@@ -8,70 +8,88 @@ import '@x402/core/http';
 import '@x402/core/types';
 /** Reads a secret by name; resolves `undefined` when unset. */
 type GetSecret = (name: string) => Promise<string | undefined> | string | undefined;
-/** How the wallet reads its key material — wired to `ctx.secrets.get` in an action. */
+/**
+ * How the wallet reads its key material — wired to `ctx.secrets.get` in an action.
+ * @experimental
+ */
 interface WalletDeps {
   /** Read a secret (e.g. a private key) by name; `undefined` when unset. */
   readonly getSecret: GetSecret;
 }
 /**
-* Resolve a viem `LocalAccount` from a raw private key. The key may be given with
-* or without the `0x` prefix. The account is a structural `ClientEvmSigner`
-* (`address` + `signTypedData`), so `@x402/evm` accepts it directly.
-*/
+ * Resolve a viem `LocalAccount` from a raw private key. The key may be given with
+ * or without the `0x` prefix. The account is a structural `ClientEvmSigner`
+ * (`address` + `signTypedData`), so `@x402/evm` accepts it directly.
+ * @experimental
+ */
 declare const resolveEvmAccount: (privateKey: string) => Promise<PrivateKeyAccount>;
 /**
-* Resolve a `@solana/kit` `KeyPairSigner` from a raw Solana secret key. The secret
-* may be given as a JSON byte array (`[12,34,…]`, the `solana-keygen` keyfile
-* format) or as a base58 string. A 64-byte value is a full secret key (seed ‖
-* public key); a 32-byte value is the seed alone. The returned signer is a
-* structural `ClientSvmSigner` (`TransactionSigner`), so `@x402/svm` accepts it.
-*/
+ * Resolve a `@solana/kit` `KeyPairSigner` from a raw Solana secret key. The secret
+ * may be given as a JSON byte array (`[12,34,…]`, the `solana-keygen` keyfile
+ * format) or as a base58 string. A 64-byte value is a full secret key (seed ‖
+ * public key); a 32-byte value is the seed alone. The returned signer is a
+ * structural `ClientSvmSigner` (`TransactionSigner`), so `@x402/svm` accepts it.
+ * @experimental
+ */
 declare const resolveSvmSigner: (secret: string) => Promise<ClientSvmSigner>;
 /**
-* Register the scheme family the configured network needs on `client`, wired to
-* the agent signer. Dispatches on network family (EVM vs SVM) and on custody —
-* `"signer"` (a signer the caller already built; registered directly, no secret
-* read), `"raw-key"` (a `ctx.secrets` private key → viem account on EVM or a
-* `@solana/kit` keypair on SVM), or `"cdp"` (a Coinbase-managed wallet via
-* `@coinbase/cdp-sdk`).
-*/
+ * Register the scheme family the configured network needs on `client`, wired to
+ * the agent signer. Dispatches on network family (EVM vs SVM) and on custody —
+ * `"signer"` (a signer the caller already built; registered directly, no secret
+ * read), `"raw-key"` (a `ctx.secrets` private key → viem account on EVM or a
+ * `@solana/kit` keypair on SVM), or `"cdp"` (a Coinbase-managed wallet via
+ * `@coinbase/cdp-sdk`).
+ * @experimental
+ */
 declare const registerWallet: (client: x402Client, config: X402PayConfig, deps: WalletDeps) => Promise<void>;
-/** A payment-enabled `fetch`: same signature as the platform `fetch`. */
+/**
+ * A payment-enabled `fetch`: same signature as the platform `fetch`.
+ * @experimental
+ */
 type PayFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-/** Dependencies for building a pay-rail fetch: secret access, plus an optional base `fetch` to wrap. */
+/**
+ * Dependencies for building a pay-rail fetch: secret access, plus an optional base `fetch` to wrap.
+ * @experimental
+ */
 interface X402PayDeps extends WalletDeps {
   /** The `fetch` to wrap (defaults to `globalThis.fetch`). Inject to test or to chain transports. */
   readonly fetch?: typeof globalThis.fetch;
 }
 /**
-* Build a payment-enabled `fetch` for `config`. Throws (before resolving a
-* signer) when `config.policy` is unbounded — an agent wallet is never built
-* with unlimited spend authority.
-*/
+ * Build a payment-enabled `fetch` for `config`. Throws (before resolving a
+ * signer) when `config.policy` is unbounded — an agent wallet is never built
+ * with unlimited spend authority.
+ * @experimental
+ */
 declare const createPayFetch: (config: X402PayConfig, deps: X402PayDeps) => Promise<PayFetch>;
-/** A configured pay rail: a payment-enabled `fetch` bounded by the spend policy. */
+/**
+ * A configured pay rail: a payment-enabled `fetch` bounded by the spend policy.
+ * @experimental
+ */
 interface X402Pay {
   /** A `fetch` that transparently pays for `402`-gated resources under the policy. */
   readonly fetch: PayFetch;
 }
 /**
-* Build a pay rail for `config`. The returned `fetch` answers `402` challenges by
-* signing and retrying, within `config.policy`. Throws (before touching the
-* signer) when the policy is unbounded.
-*/
+ * Build a pay rail for `config`. The returned `fetch` answers `402` challenges by
+ * signing and retrying, within `config.policy`. Throws (before touching the
+ * signer) when the policy is unbounded.
+ * @experimental
+ */
 declare const createX402Pay: (config: X402PayConfig, deps: X402PayDeps) => Promise<X402Pay>;
 /**
-* A synchronous, lazily-initialised pay rail — what codegen wires `ctx.x402` to.
-*
-* `buildCtx` must stay synchronous, but {@link createX402Pay} is async (it reads
-* the wallet secret and imports the signer). So this returns an {@link X402Pay}
-* immediately whose `fetch` builds the real rail on its **first** call and
-* memoises it: the viem/`@x402` signer imports + Secrets Store read are paid for
-* only when an action actually pays, and the single `SpendState` behind the
-* rail is shared across every payment for the lifetime of this ctx — so the
-* per-run cap scopes to the ctx, not to each request. A failed build (e.g. an
-* unbounded policy) is memoised too, keeping the rail deterministically
-* fail-closed.
-*/
+ * A synchronous, lazily-initialised pay rail — what codegen wires `ctx.x402` to.
+ *
+ * `buildCtx` must stay synchronous, but {@link createX402Pay} is async (it reads
+ * the wallet secret and imports the signer). So this returns an {@link X402Pay}
+ * immediately whose `fetch` builds the real rail on its **first** call and
+ * memoises it: the viem/`@x402` signer imports + Secrets Store read are paid for
+ * only when an action actually pays, and the single `SpendState` behind the
+ * rail is shared across every payment for the lifetime of this ctx — so the
+ * per-run cap scopes to the ctx, not to each request. A failed build (e.g. an
+ * unbounded policy) is memoised too, keeping the rail deterministically
+ * fail-closed.
+ * @experimental
+ */
 declare const lazyX402Pay: (config: X402PayConfig, deps: X402PayDeps) => X402Pay;
 export { type PayFetch, type WalletDeps, X402Pay, type X402PayConfig, type X402PayDeps, createPayFetch, createX402Pay, lazyX402Pay, registerWallet, resolveEvmAccount, resolveSvmSigner };

package/dist/pay/index.mjs

@@ -1,21 +1 @@
-import { createPayFetch } from '../packem_shared/createPayFetch-O2vkvM1v.mjs';
-export { DEFAULT_FACILITATOR_URL, resolveFacilitatorUrl } from '../packem_shared/DEFAULT_FACILITATOR_URL-Cbz6kIqa.mjs';
-export { isEvmNetwork, isSvmNetwork, toCaip2 } from '../packem_shared/EVM_NETWORKS-BhnYWUQ4.mjs';
-export { DEFAULT_STABLECOIN_DECIMALS, assertBoundedPolicy, buildPaymentGuard, buildSpendPolicy, createSpendState, recordSpend, usdToAtomic } from '../packem_shared/DEFAULT_STABLECOIN_DECIMALS-CSu5b5lD.mjs';
-export { registerWallet, resolveEvmAccount, resolveSvmSigner } from '../packem_shared/registerWallet-I4pVwq65.mjs';
-
-const createX402Pay = async (config, deps) => {
-  const fetch = await createPayFetch(config, deps);
-  return { fetch };
-};
-const lazyX402Pay = (config, deps) => {
-  let railPromise;
-  const fetch = async (input, init) => {
-    railPromise ??= createX402Pay(config, deps);
-    const rail = await railPromise;
-    return rail.fetch(input, init);
-  };
-  return { fetch };
-};
-
-export { createPayFetch, createX402Pay, lazyX402Pay };
+import{createPayFetch as c}from"../packem_shared/createPayFetch-B6A51xPI.mjs";import{DEFAULT_FACILITATOR_URL as S,resolveFacilitatorUrl as A}from"../packem_shared/DEFAULT_FACILITATOR_URL-lUtljfJI.mjs";import{isEvmNetwork as d,isSvmNetwork as y,toCaip2 as E}from"../packem_shared/EVM_NETWORKS-XOms9Rtk.mjs";import{DEFAULT_ALLOWED_ASSETS as f,DEFAULT_STABLECOIN_DECIMALS as u,assertBoundedPolicy as T,buildPaymentGuard as v,buildSpendPolicy as F,createSpendState as P,releaseSpendOnFailure as _,usdToAtomic as x}from"../packem_shared/DEFAULT_ALLOWED_ASSETS-BIIP_mdG.mjs";import{registerWallet as U,resolveEvmAccount as h,resolveSvmSigner as w}from"../packem_shared/registerWallet-Cu4qF5tj.mjs";const i=async(e,r)=>({fetch:await c(e,r)}),s=(e,r)=>{let t;return{fetch:async(o,a)=>(t??=i(e,r),(await t).fetch(o,a))}};export{f as DEFAULT_ALLOWED_ASSETS,S as DEFAULT_FACILITATOR_URL,u as DEFAULT_STABLECOIN_DECIMALS,T as assertBoundedPolicy,v as buildPaymentGuard,F as buildSpendPolicy,c as createPayFetch,P as createSpendState,i as createX402Pay,d as isEvmNetwork,y as isSvmNetwork,s as lazyX402Pay,U as registerWallet,_ as releaseSpendOnFailure,h as resolveEvmAccount,A as resolveFacilitatorUrl,w as resolveSvmSigner,E as toCaip2,x as usdToAtomic};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/x402",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.21",
   "description": "Agentic payments (x402) for Lunora: charge agents per request (charge rail) and let your agents pay x402-gated resources (pay rail)",
   "keywords": [
     "agents",
@@ -52,13 +52,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/errors": "1.0.0-alpha.4",
-    "@solana/kit": "5.5.1",
-    "@x402/core": "2.17.0",
-    "@x402/evm": "2.17.0",
-    "@x402/fetch": "2.17.0",
-    "@x402/svm": "2.17.0",
-    "viem": "2.54.1"
+    "@lunora/errors": "1.0.0-alpha.8",
+    "@solana/kit": "7.0.0",
+    "@x402/core": "2.19.0",
+    "@x402/evm": "2.19.0",
+    "@x402/fetch": "2.19.0",
+    "@x402/svm": "2.19.0",
+    "viem": "2.55.8"
   },
   "peerDependencies": {
     "@coinbase/cdp-sdk": ">=1.0.0",

package/dist/packem_shared/DEFAULT_FACILITATOR_URL-Cbz6kIqa.mjs

@@ -1,4 +0,0 @@
-const DEFAULT_FACILITATOR_URL = "https://x402.org/facilitator";
-const resolveFacilitatorUrl = (facilitator) => facilitator?.url ?? DEFAULT_FACILITATOR_URL;
-
-export { DEFAULT_FACILITATOR_URL, resolveFacilitatorUrl };

package/dist/packem_shared/DEFAULT_STABLECOIN_DECIMALS-CSu5b5lD.mjs

@@ -1,85 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { toCaip2 } from './EVM_NETWORKS-BhnYWUQ4.mjs';
-
-const USD_AMOUNT = /^\d+(?:\.\d+)?$/;
-const normaliseAddress = (address, network) => network.startsWith("eip155:") ? address.toLowerCase() : address;
-const DEFAULT_STABLECOIN_DECIMALS = 6;
-const createSpendState = () => {
-  let spent = 0n;
-  return {
-    add: (amount) => {
-      spent += amount;
-    },
-    get spentAtomic() {
-      return spent;
-    }
-  };
-};
-const usdToAtomic = (usd, decimals = DEFAULT_STABLECOIN_DECIMALS) => {
-  if (!Number.isInteger(decimals) || decimals < 0) {
-    throw new LunoraError("BAD_REQUEST", `x402 policy: decimals must be a non-negative integer, got ${String(decimals)}.`);
-  }
-  const raw = (typeof usd === "number" ? usd.toString() : usd).trim();
-  const unsigned = raw.startsWith("$") ? raw.slice(1) : raw;
-  if (!USD_AMOUNT.test(unsigned)) {
-    throw new LunoraError("BAD_REQUEST", `x402 policy: "${String(usd)}" is not a valid USD amount (use a plain decimal like "0.01").`);
-  }
-  const [whole = "0", fraction = ""] = unsigned.split(".");
-  const scaled = fraction.slice(0, decimals).padEnd(decimals, "0");
-  return BigInt(whole) * 10n ** BigInt(decimals) + BigInt(scaled === "" ? "0" : scaled);
-};
-const buildSpendPolicy = (policy) => {
-  const decimals = policy.decimals ?? DEFAULT_STABLECOIN_DECIMALS;
-  const maxPerCall = policy.maxPerCall === void 0 ? void 0 : usdToAtomic(policy.maxPerCall, decimals);
-  const allowedNetworks = policy.allowedNetworks?.map((network) => toCaip2(network));
-  const { allowedRecipients } = policy;
-  return (_version, requirements) => requirements.filter((requirement) => {
-    if (maxPerCall !== void 0 && BigInt(requirement.amount) > maxPerCall) {
-      return false;
-    }
-    if (allowedNetworks !== void 0 && !allowedNetworks.includes(requirement.network)) {
-      return false;
-    }
-    if (allowedRecipients !== void 0) {
-      const payTo = normaliseAddress(requirement.payTo, requirement.network);
-      return allowedRecipients.some((allowed) => normaliseAddress(allowed, requirement.network) === payTo);
-    }
-    return true;
-  });
-};
-const buildPaymentGuard = (policy, state) => {
-  const decimals = policy.decimals ?? DEFAULT_STABLECOIN_DECIMALS;
-  const maxPerRun = policy.maxPerRun === void 0 ? void 0 : usdToAtomic(policy.maxPerRun, decimals);
-  return async (context) => {
-    const requirement = context.selectedRequirements;
-    const amount = BigInt(requirement.amount);
-    if (maxPerRun !== void 0 && state.spentAtomic + amount > maxPerRun) {
-      return {
-        abort: true,
-        reason: `x402 policy: this payment (${requirement.amount}) would exceed the per-run cap (already spent ${state.spentAtomic.toString()}, cap ${maxPerRun.toString()}, in atomic base units).`
-      };
-    }
-    if (policy.onPaymentRequired !== void 0) {
-      const approved = await policy.onPaymentRequired(requirement);
-      if (!approved) {
-        return { abort: true, reason: "x402 policy: payment was declined by onPaymentRequired." };
-      }
-    }
-    return void 0;
-  };
-};
-const recordSpend = (state) => (context) => {
-  state.add(BigInt(context.selectedRequirements.amount));
-  return Promise.resolve();
-};
-const assertBoundedPolicy = (policy) => {
-  const bounded = policy.maxPerCall !== void 0 || policy.maxPerRun !== void 0 || (policy.allowedRecipients?.length ?? 0) > 0 || (policy.allowedNetworks?.length ?? 0) > 0 || policy.onPaymentRequired !== void 0;
-  if (!bounded) {
-    throw new LunoraError(
-      "FORBIDDEN",
-      "x402 pay: refusing to build a wallet with an unbounded spend policy. Set at least one of maxPerCall, maxPerRun, allowedRecipients, allowedNetworks, or onPaymentRequired."
-    );
-  }
-};
-
-export { DEFAULT_STABLECOIN_DECIMALS, assertBoundedPolicy, buildPaymentGuard, buildSpendPolicy, createSpendState, recordSpend, usdToAtomic };

package/dist/packem_shared/EVM_NETWORKS-BhnYWUQ4.mjs

@@ -1,26 +0,0 @@
-const NETWORK_TO_CAIP2 = {
-  arbitrum: "eip155:42161",
-  "arbitrum-sepolia": "eip155:421614",
-  base: "eip155:8453",
-  "base-sepolia": "eip155:84532",
-  ethereum: "eip155:1",
-  polygon: "eip155:137",
-  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
-};
-const EVM_NETWORKS = ["arbitrum", "arbitrum-sepolia", "base", "base-sepolia", "ethereum", "polygon"];
-const SVM_NETWORKS = ["solana", "solana-devnet"];
-const toCaip2 = (network) => {
-  const mapped = NETWORK_TO_CAIP2[network];
-  if (mapped !== void 0) {
-    return mapped;
-  }
-  if (network.includes(":")) {
-    return network;
-  }
-  throw new Error(`Unknown x402 network "${network}". Use a friendly name (${EVM_NETWORKS.join(", ")}, ${SVM_NETWORKS.join(", ")}) or a raw CAIP-2 id.`);
-};
-const isEvmNetwork = (network) => toCaip2(network).startsWith("eip155:");
-const isSvmNetwork = (network) => toCaip2(network).startsWith("solana:");
-
-export { EVM_NETWORKS, NETWORK_TO_CAIP2, SVM_NETWORKS, isEvmNetwork, isSvmNetwork, toCaip2 };

package/dist/packem_shared/config.d-CddwCiBm.d.mts

@@ -1,325 +0,0 @@
-import { ClientEvmSigner } from '@x402/evm';
-import { ClientSvmSigner } from '@x402/svm';
-import { ProcessSettleSuccessResponse } from '@x402/core/http';
-import { BeforePaymentCreationHook, PaymentPolicy, AfterPaymentCreationHook } from '@x402/core/client';
-import { PaymentRequirements } from '@x402/core/types';
-/**
-* A normalised record of one settled x402 payment. The settled `amount` is kept
-* as its exact on-chain atomic-unit string (USDC has 6 decimals) — never coerced
-* to a fractional-dollar number — so no precision is lost crossing the reporting
-* seam.
-*/
-interface X402Receipt {
-  /** Settled amount in the asset's atomic base units (USDC: 6 decimals), as an exact string. */
-  readonly amount: string;
-  /** The settled asset's contract / mint address (e.g. Base USDC). */
-  readonly asset: string;
-  /** The payer's wallet address, when the facilitator reports it. */
-  readonly from: string | undefined;
-  /** The settlement network as a CAIP-2 id (e.g. `eip155:8453`). */
-  readonly network: string;
-  /** The gated resource this payment bought (a URL, or a procedure's `file:function` id). */
-  readonly resource: string;
-  /** The payout wallet the funds settled to (the merchant recipient). */
-  readonly to: string;
-  /** When the receipt was produced (epoch milliseconds). */
-  readonly ts: number;
-  /** On-chain settlement transaction id / hash. */
-  readonly tx: string;
-}
-/**
-* A one-way, opt-in sink for settled-payment receipts. Wire it via
-* `config.onReceipt`. It is best-effort telemetry — the middleware fires it after
-* settlement, does not block the paid response on it, and swallows any error it
-* throws — so a sink must never rely on being awaited or on its failures
-* surfacing.
-*/
-type X402ReceiptSink = (receipt: X402Receipt) => Promise<void> | void;
-/**
-* Normalise a successful facilitator settlement into an {@link X402Receipt}.
-* `resource` (the gated URL or procedure id) and `ts` are supplied by the caller —
-* the settlement result carries neither. Prefers the actual settled `amount`
-* (present for `upto`-scheme partial settlements) and falls back to the route's
-* required amount for `exact`.
-*/
-declare const toReceipt: (settlement: ProcessSettleSuccessResponse, context: {
-  readonly resource: string;
-  readonly ts: number;
-}) => X402Receipt;
-/**
-* A row for `@lunora/payment`'s durable `events` table. Deliberately a plain
-* structural type — building one imports nothing from `@lunora/payment`, so the
-* rails stay decoupled.
-*/
-interface PaymentEventRow {
-  /** Epoch milliseconds the settlement was recorded. */
-  readonly processedAt: number;
-  /** The rail that produced the event. */
-  readonly provider: "x402";
-  /** The settlement tx hash — the natural unique event id (the table is unique on `(provider, providerEventId)`). */
-  readonly providerEventId: string;
-  /** The event kind, namespaced to the x402 rail. */
-  readonly type: "x402.settled";
-}
-/**
-* Shape a receipt as a row for `@lunora/payment`'s durable `events` table, so a
-* settled x402 payment shows in Studio's Payments panel (its recent-events card)
-* with ZERO coupling: this returns a plain object matching that table's
-* documented column contract (`provider` / `providerEventId` / `type` /
-* `processedAt`, unique on `(provider, providerEventId)`) and imports nothing
-* from `@lunora/payment`. Insert it from a mutation ctx:
-*
-* ```ts
-* onReceipt: (receipt) => ctx.db.insert("events", toPaymentEventRow(receipt)),
-* ```
-*
-* The source of truth for the column contract is `@lunora/payment`'s `events`
-* table (`packages/payment/src/schema.ts`). Amount / from / to / resource are
-* intentionally not on this row — that card renders none of them; read them off
-* the {@link X402Receipt} (e.g. into your own revenue table) if you need them.
-*/
-declare const toPaymentEventRow: (receipt: X402Receipt) => PaymentEventRow;
-/**
-* Network identity for `@lunora/x402`.
-*
-* `@x402/core` v2 speaks **CAIP-2** chain ids (`eip155:8453` for Base,
-* `solana:5eyk…` for Solana mainnet) — `type Network = ` `${string}:${string}` ``.
-* Lunora keeps ergonomic **friendly** names (`"base"`, `"base-sepolia"`) as the
-* public surface and maps them to CAIP-2 here, at the single seam where we hand a
-* network to the SDK. A raw CAIP-2 string is also accepted as a power-user escape
-* hatch (e.g. a chain we don't yet have a friendly alias for).
-*
-* The friendly set is intentionally scoped to chains `@x402/evm` / `@x402/svm`
-* can settle the ergonomic `price:"$0.01"` path on out of the box (i.e. chains in
-* their `DEFAULT_STABLECOINS` registry). Notably that excludes Optimism and
-* Avalanche today — advertising them would 500 at settlement — so they are not
-* friendly aliases; a caller who needs them can still pass a raw CAIP-2 id with an
-* explicit asset.
-*/
-/** A CAIP-2 chain identifier, e.g. `"eip155:8453"` (Base) or `"solana:5eyk…"`. */
-type Caip2 = `${string}:${string}`;
-/** Friendly network names Lunora maps to CAIP-2 for `@x402/core`. */
-type FriendlyNetwork = "arbitrum" | "arbitrum-sepolia" | "base" | "base-sepolia" | "ethereum" | "polygon" | "solana" | "solana-devnet";
-/**
-* A network Lunora can settle on: a {@link FriendlyNetwork} alias (mapped to
-* CAIP-2 internally) or a raw {@link Caip2} id for chains without a friendly name.
-*/
-type X402Network = Caip2 | FriendlyNetwork;
-/**
-* Friendly name → CAIP-2 id. Values verified against `@x402/evm` and `@x402/svm`
-* `DEFAULT_STABLECOINS` at 2.17.0. `base` / `base-sepolia` are the primary
-* prod / test pair.
-*/
-declare const NETWORK_TO_CAIP2: {
-  readonly arbitrum: "eip155:42161";
-  readonly "arbitrum-sepolia": "eip155:421614";
-  readonly base: "eip155:8453";
-  readonly "base-sepolia": "eip155:84532";
-  readonly ethereum: "eip155:1";
-  readonly polygon: "eip155:137";
-  readonly solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-  readonly "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
-};
-/** EVM friendly networks (signed via `@x402/evm` + viem). */
-declare const EVM_NETWORKS: readonly ["arbitrum", "arbitrum-sepolia", "base", "base-sepolia", "ethereum", "polygon"];
-/** Solana friendly networks (signed via `@x402/svm`). */
-declare const SVM_NETWORKS: readonly ["solana", "solana-devnet"];
-/**
-* Resolve a network to its CAIP-2 id. Friendly aliases are looked up; a value
-* that already looks like CAIP-2 (`namespace:reference`) passes through.
-*/
-declare const toCaip2: (network: X402Network) => Caip2;
-/** True when `network` settles on an EVM chain (viem signer path). */
-declare const isEvmNetwork: (network: X402Network) => boolean;
-/** True when `network` settles on Solana (`@x402/svm` signer path). */
-declare const isSvmNetwork: (network: X402Network) => boolean;
-/**
-* USDC — and every asset in `@x402/evm` / `@x402/svm`'s `DEFAULT_STABLECOINS` —
-* uses 6 decimals, so a USD price converts to atomic base units at `10 ** 6`.
-* Override per {@link SpendPolicy.decimals} only for a custom, non-6-decimal asset.
-*/
-declare const DEFAULT_STABLECOIN_DECIMALS = 6;
-/**
-* Spend limits and approval gates for an agent wallet. At least one bound must be
-* set — see {@link assertBoundedPolicy} — or the pay rail refuses to build.
-*
-* Caps are denominated in USD (the stablecoin's dollar value); addresses and
-* networks are matched against the requirement the server offers.
-*/
-interface SpendPolicy {
-  /** Network allowlist. When set, only these networks may be paid on. */
-  readonly allowedNetworks?: ReadonlyArray<X402Network>;
-  /** Recipient allowlist. When set, only these `payTo` addresses may be paid. */
-  readonly allowedRecipients?: ReadonlyArray<string>;
-  /** Stablecoin decimals for USD→atomic conversion (default {@link DEFAULT_STABLECOIN_DECIMALS}). */
-  readonly decimals?: number;
-  /** Hard ceiling on a single payment, in USD. */
-  readonly maxPerCall?: X402Price;
-  /** Hard ceiling on cumulative spend across this wallet's lifetime, in USD. */
-  readonly maxPerRun?: X402Price;
-  /**
-  * Approval gate. Called with the selected requirement before signing; return
-  * `false` (or reject) to refuse the payment. Use for human-in-the-loop or any
-  * dynamic rule the static caps can't express.
-  */
-  readonly onPaymentRequired?: (requirement: PaymentRequirements) => Promise<boolean> | boolean;
-}
-/** A running spend ledger the per-run cap is measured against; the guard reads it, the recorder adds to it. */
-interface SpendState {
-  /** Add a just-committed payment (atomic base units) to the total. */
-  readonly add: (amount: bigint) => void;
-  /** Cumulative spend so far, in atomic base units. */
-  readonly spentAtomic: bigint;
-}
-/** A fresh spend ledger. One per wallet instance; the guard + recorder share it. */
-declare const createSpendState: () => SpendState;
-/**
-* Convert a USD amount (`0.01`, `"0.01"`, or the `"$0.01"` shorthand) to atomic
-* stablecoin base units, exactly — parsed digit-by-digit so no binary-float drift
-* can round a cap the wrong way. Throws on a malformed amount (including
-* exponential notation like `"1e-7"`, which a decimal string never needs).
-*/
-declare const usdToAtomic: (usd: X402Price, decimals?: number) => bigint;
-/**
-* A `PaymentPolicy` that narrows the server's offered requirements to those a
-* bounded wallet may pay: within the per-call cap, to an allowed recipient, on an
-* allowed network. An empty result means the client cannot pay — fail-closed.
-*/
-declare const buildSpendPolicy: (policy: SpendPolicy) => PaymentPolicy;
-/**
-* A `BeforePaymentCreationHook` enforcing the stateful bounds the stateless
-* {@link buildSpendPolicy} filter can't: the cumulative per-run cap and the async
-* confirmation gate. Aborts (no signature) when either would be violated.
-*/
-declare const buildPaymentGuard: (policy: SpendPolicy, state: SpendState) => BeforePaymentCreationHook;
-/**
-* An `AfterPaymentCreationHook` that adds the just-created payment to `state`, so
-* the next {@link buildPaymentGuard} call measures the per-run cap against it.
-*/
-declare const recordSpend: (state: SpendState) => AfterPaymentCreationHook;
-/**
-* Guard at wallet-build time: refuse a policy with no bound whatsoever. Signing
-* money on an agent's behalf with unlimited spend authority is never the intent,
-* so this fails loudly rather than defaulting to unbounded.
-*/
-declare const assertBoundedPolicy: (policy: SpendPolicy) => void;
-/**
-* The public, Coinbase-operated facilitator (verify + settle). It needs no API
-* key. Override with a self-hosted or CDP facilitator via {@link FacilitatorConfig}.
-*/
-declare const DEFAULT_FACILITATOR_URL = "https://x402.org/facilitator";
-/** How to reach a facilitator's `/verify` + `/settle` endpoints. */
-interface FacilitatorConfig {
-  /** Extra headers for a private facilitator (e.g. a CDP bearer token). */
-  readonly headers?: Record<string, string>;
-  /** Base URL. Defaults to {@link DEFAULT_FACILITATOR_URL}. */
-  readonly url?: string;
-}
-/**
-* A resource's price, as a USD-denominated decimal string (`"0.01"`, or the
-* `"$0.01"` shorthand) or a number of dollars (`0.01`). The scheme resolves it
-* to the network's stablecoin base units (USDC has 6 decimals) at challenge
-* time. (Kept `number | string` rather than a `` `$${string}` `` template
-* member — the template is subsumed by `string`, so it only adds noise.)
-*/
-type X402Price = number | string;
-/** An EVM recipient address (the merchant wallet that receives settlement). */
-type EvmAddress = `0x${string}`;
-/** Recipient wallet the facilitator settles payments to, per network family. */
-interface X402Recipient {
-  /** EVM payout address (required for EVM networks). */
-  readonly evm?: EvmAddress;
-  /** Solana payout address, base58 (required for SVM networks). */
-  readonly svm?: string;
-}
-/**
-* Server-side (charge rail) config. The server needs only a **recipient
-* address** — no private key — because the facilitator performs settlement.
-*/
-interface X402ChargeConfig {
-  readonly facilitator?: FacilitatorConfig;
-  /** Network this resource settles on. */
-  readonly network: X402Network;
-  /**
-  * Opt-in, one-way telemetry sink fired once per settled payment. Best-effort:
-  * it runs after settlement, never blocks the paid response, and its errors are
-  * swallowed. Use it to mirror x402 revenue into a durable table / `@lunora/payment`'s
-  * `events` table (see `toPaymentEventRow`) so it surfaces in Studio.
-  */
-  readonly onReceipt?: X402ReceiptSink;
-  /** Default price for a gated resource; per-resource overrides win. */
-  readonly price: X402Price;
-  /** Payout wallet(s). */
-  readonly recipient: X402Recipient;
-}
-/**
-* Client-side (pay rail) config. The signer holds spending authority, so the
-* pay rail is ActionCtx-only and MUST be paired with a spend `policy` — the pay
-* rail refuses to build if the policy is unbounded.
-*/
-interface X402PayConfig {
-  /** Network to transact on. Determines the signer family (EVM vs SVM). */
-  readonly network: X402Network;
-  /** Mandatory spend limits + approval gates. An unbounded policy is refused. */
-  readonly policy: SpendPolicy;
-  /** How the agent wallet is custodied (raw key, a user-supplied signer, or CDP-managed). */
-  readonly signer: X402SignerConfig;
-}
-/**
-* CDP-managed wallet custody via `@coinbase/cdp-sdk` (an optional peer). The SDK
-* gets-or-creates a named server account and signs the x402 EIP-712 payment
-* authorization with it — no private key ever leaves Coinbase. Needs three CDP
-* credentials, read from `ctx.secrets` under names that default to the SDK's own
-* env-var names; override them if your secrets are named differently. (Note
-* `@coinbase/x402` is a facilitator-auth helper, not a signer provider — CDP
-* custody is `@coinbase/cdp-sdk`.) EVM only today; for CDP on Solana, build a
-* `@solana/kit` signer around your CDP account and pass it via the `"signer"`
-* escape hatch.
-*/
-interface X402CdpSignerConfig {
-  /** CDP account name to get-or-create and sign with. */
-  readonly account: string;
-  /** `ctx.secrets` name for the CDP API key id. Default `"CDP_API_KEY_ID"`. */
-  readonly apiKeyIdSecretName?: string;
-  /** `ctx.secrets` name for the CDP API key secret. Default `"CDP_API_KEY_SECRET"`. */
-  readonly apiKeySecretName?: string;
-  readonly type: "cdp";
-  /** `ctx.secrets` name for the CDP wallet secret. Default `"CDP_WALLET_SECRET"`. */
-  readonly walletSecretName?: string;
-}
-/**
-* Wallet custody for the pay rail — three shapes.
-*
-* `"raw-key"` resolves a private key from `ctx.secrets` (viem for EVM, a
-* `@solana/kit` keypair for Solana) — simplest, self-custodied.
-*
-* `"signer"` is the escape hatch: hand in a signer you already built — any
-* `@x402/evm` `ClientEvmSigner` (a viem account from Turnkey, Privy, an AWS/GCP
-* KMS `toAccount`, CDP's viem adapter, …) on an EVM network, or an `@x402/svm`
-* `ClientSvmSigner` (a `@solana/kit` `TransactionSigner`) on Solana. Adapt any
-* custody provider to the structural signer and pass it here; `@lunora/x402`
-* takes no dependency on the provider's SDK.
-*
-* `"cdp"` is a Coinbase-managed wallet via `@coinbase/cdp-sdk`
-* ({@link X402CdpSignerConfig}).
-*
-* Wired today: raw-key (EVM + SVM), the user-supplied signer (both families),
-* and CDP-managed EVM custody. CDP on Solana is not yet wired — use the escape
-* hatch.
-*/
-type X402SignerConfig = X402CdpSignerConfig | {
-  /** Name of the `ctx.secrets` entry holding the private key. */
-  readonly secretName: string;
-  readonly type: "raw-key";
-} | {
-  /**
-  * A pre-built signer you own: an EVM `ClientEvmSigner` (viem account) on
-  * an EVM network, or an SVM `ClientSvmSigner` (`@solana/kit`
-  * `TransactionSigner`) on Solana. Must match the config `network`'s family.
-  */
-  readonly signer: ClientEvmSigner | ClientSvmSigner;
-  readonly type: "signer";
-};
-/** Resolve a facilitator's base URL, applying the public default. */
-declare const resolveFacilitatorUrl: (facilitator?: FacilitatorConfig) => string;
-export { Caip2 as C, DEFAULT_FACILITATOR_URL as D, EVM_NETWORKS as E, FacilitatorConfig as F, NETWORK_TO_CAIP2 as N, PaymentEventRow as P, SVM_NETWORKS as S, X402CdpSignerConfig as X, EvmAddress as a, FriendlyNetwork as b, X402ChargeConfig as c, X402Network as d, X402PayConfig as e, X402Price as f, X402Receipt as g, X402ReceiptSink as h, X402Recipient as i, X402SignerConfig as j, isEvmNetwork as k, isSvmNetwork as l, DEFAULT_STABLECOIN_DECIMALS as m, SpendPolicy as n, SpendState as o, assertBoundedPolicy as p, buildPaymentGuard as q, resolveFacilitatorUrl as r, buildSpendPolicy as s, toCaip2 as t, createSpendState as u, recordSpend as v, usdToAtomic as w, toPaymentEventRow as x, toReceipt as y };