@pepu-chain/sdk 0.0.0-stage → 0.2.0

package/dist/status-CmOsyPmO.d.cts

@@ -0,0 +1,295 @@
+import { Address, PublicClient, Transport, Hex } from 'viem';
+import { P as PepuChain } from './chains-DK13zGIp.cjs';
+import { a as PepuBundlerError } from './errors-CgX1vNj7.cjs';
+
+/** Minimal fetch signature, so tests and non-browser hosts can inject one. */
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+interface ProbeOptions {
+    fetch?: FetchLike;
+    /** Per-request timeout. Default 8000. */
+    timeoutMs?: number;
+}
+interface BundlerProbeResult {
+    ok: boolean;
+    chainId?: number;
+    entryPoints?: Address[];
+    /** `true` when the method exists (any answer but "method not found"). */
+    supportedMethods?: Record<string, boolean>;
+    latencyMs: number;
+    error?: PepuBundlerError;
+}
+interface PaymasterProbeResult {
+    ok: boolean;
+    /** `GET <origin>/health` answered `{ status: "ok" }`. */
+    health?: boolean;
+    /** Body of `GET <origin>/v2/free-tier` when the service exposes it. */
+    freeTier?: unknown;
+    /**
+     * The URL answered a `pm_getPaymasterStubData` call with a stub result. A
+     * JSON-RPC denial (no credential, unknown sender) is NOT a stub result:
+     * the endpoint is alive and speaks ERC-7677, but the probe has no
+     * credential, so this stays `false`.
+     */
+    erc7677StubOk?: boolean;
+    latencyMs: number;
+    error?: PepuBundlerError;
+}
+/**
+ * Probe a bundler URL: `eth_chainId`, `eth_supportedEntryPoints` and a
+ * capability check of the methods PEPU apps use (a method answered with
+ * anything but "method not found" counts as supported; nothing is sent
+ * on-chain). Never throws for network trouble; returns `ok: false` with a
+ * `BUNDLER_UNREACHABLE` error. Throws `CONFIG_BAD_URL` for a malformed URL.
+ *
+ * @example
+ * const r = await probeBundler("https://bundler.example.com");
+ * if (!r.ok) console.log(r.error?.hint);
+ */
+declare function probeBundler(url: string, o?: ProbeOptions): Promise<BundlerProbeResult>;
+/**
+ * Probe a paymaster URL: the service base (`https://paymaster.pepeunchained.com`) or the ERC-7677 endpoint
+ * (`https://host/v2/paymaster/<token>`).
+ * Checks `GET <origin>/health`, `GET <origin>/v2/free-tier`, and whether the URL
+ * answers JSON-RPC `pm_getPaymasterStubData`. `ok` means the service is alive:
+ * health is ok, or the URL spoke valid JSON-RPC. The URL (which can embed a
+ * token) never appears in the returned error.
+ *
+ * @example
+ * const r = await probePaymaster(process.env.PEPU_PAYMASTER_URL!);
+ * console.log(r.ok, r.freeTier);
+ */
+declare function probePaymaster(url: string, o?: ProbeOptions): Promise<PaymasterProbeResult>;
+/**
+ * The paymaster's EntryPoint v0.7 deposit in wei. A drop across a UserOperation
+ * is the proof that it was sponsored. Defaults to PEPU's deployed paymaster.
+ *
+ * @example
+ * const before = await getPaymasterDeposit(publicClient);
+ */
+declare function getPaymasterDeposit(client: PublicClient, paymaster?: Address): Promise<bigint>;
+
+/**
+ * Canonical keys for contracts tracked by this registry. Adding a new key
+ * here (and a corresponding entry per chain below) is not a breaking
+ * change for consumers that read the registry through {@link getContract}
+ * or {@link listContracts}.
+ */
+type PepuContractName = "create2Factory" | "multicall3" | "permit2" | "entryPoint06" | "entryPoint07" | "kernelFactory" | "kernelMetaFactory" | "ecdsaValidator" | "paymaster" | "kernelImplementation" | "kernelEcdsaSignerModule" | "kernelCallPolicyV004" | "kernelTimestampPolicy" | "tapScore" | "paymasterV1" | "paymasterV2";
+/** A contract that is confirmed live on-chain at `address`. */
+interface DeployedContract {
+    readonly status: "deployed";
+    /** Human-readable name, for logging/UI. */
+    readonly name: string;
+    /** Verified contract address. */
+    readonly address: Address;
+    /** Optional short note, e.g. how the address was verified. */
+    readonly notes?: string;
+    /**
+     * ISO date (YYYY-MM-DD) on which the address was last confirmed to have
+     * bytecode via `eth_getCode` against the PEPU mainnet RPC. Re-run
+     * `node packages/sdk/scripts/live-check.mjs` to refresh.
+     */
+    readonly verifiedAt?: string;
+    /**
+     * True when the contract still has bytecode but must not be used (for example
+     * the v1 paymaster, whose EntryPoint deposit was withdrawn). Never route new
+     * work to a retired contract.
+     */
+    readonly retired?: true;
+}
+/**
+ * A contract that is not yet deployed on this chain. Deliberately has no
+ * `address` field — callers must not be able to accidentally read a
+ * placeholder value and treat it as real. Use {@link getContract} /
+ * {@link isDeployed} to narrow before reading an address.
+ */
+interface PendingContract {
+    readonly status: "pending";
+    /** Human-readable name, for logging/UI. */
+    readonly name: string;
+    /** Why this contract has no verified address yet. */
+    readonly reason: string;
+}
+type ContractEntry = DeployedContract | PendingContract;
+/** Per-chain contract catalog, keyed by {@link PepuContractName}. */
+type PepuContractRegistry = Readonly<Record<PepuContractName, ContractEntry>>;
+/**
+ * Contract registry, keyed by chain id. Tracked as independent per-chain
+ * entries because deployments happen per-chain and have already diverged:
+ * mainnet has the CREATE2 deployer, a PEPU-specific Multicall3, the
+ * canonical Permit2, the full ZeroDev Kernel v3 AA stack (EntryPoint
+ * v0.6/v0.7, Kernel factory/meta-factory, ECDSA validator), and a
+ * project-deployed, funded verifying paymaster. Testnet has only the
+ * CREATE2 deployer — everything else is `status: "pending"` because
+ * testnet is out of scope for this package (no faucet exists to fund
+ * verification there).
+ *
+ * Note on the paymaster specifically: `status: "deployed"` here means the
+ * contract has live bytecode and a real EntryPoint deposit — it does NOT
+ * mean gas sponsorship is usable by an application. See
+ * `getSponsorshipStatus` in `./aa/status.js`, which is the single source of
+ * truth for that separate question.
+ */
+declare const pepuContracts: Readonly<Record<number, PepuContractRegistry>>;
+/** Look up one contract entry for a chain id. Returns `undefined` if the chain isn't in the registry. */
+declare function getContract(chainId: number, name: PepuContractName): ContractEntry | undefined;
+/** List all tracked contract entries for a chain id, in registry order. */
+declare function listContracts(chainId: number): readonly ContractEntry[];
+/** Narrow a {@link ContractEntry} to {@link DeployedContract}. */
+declare function isDeployed(entry: ContractEntry | undefined): entry is DeployedContract;
+/** One row of the address table returned by {@link getPepuAddresses}. */
+interface PepuAddressRow {
+    readonly key: PepuContractName;
+    readonly name: string;
+    readonly status: "deployed" | "pending";
+    /** Present only when `status` is `"deployed"`. */
+    readonly address?: Address;
+    /** ISO date of the last `eth_getCode` check, when known. */
+    readonly verifiedAt?: string;
+    /** True for a deployed contract that is retired and must not be used (the v1 paymaster). */
+    readonly retired?: true;
+    /** Notes (deployed) or reason (pending). */
+    readonly note: string;
+}
+/**
+ * The full supporting-contract table for a chain, flattened for docs and
+ * MCP rendering. Pending entries carry no `address`.
+ *
+ * @example
+ * ```ts
+ * const rows = getPepuAddresses(); // mainnet by default
+ * const live = rows.filter((r) => r.status === "deployed");
+ * ```
+ */
+declare function getPepuAddresses(chainId?: number): readonly PepuAddressRow[];
+
+/**
+ * The account-abstraction contracts a Kernel v3 smart account needs,
+ * narrowed to their {@link DeployedContract} form for a given chain.
+ * Returns `undefined` if any one of them isn't deployed on that chain
+ * (today: everything except mainnet, `97741`) — this package never fabricates
+ * a partial/best-effort bundle.
+ */
+interface PepuKernelStack {
+    readonly entryPoint06: DeployedContract;
+    readonly entryPoint07: DeployedContract;
+    readonly kernelFactory: DeployedContract;
+    readonly kernelMetaFactory: DeployedContract;
+    readonly ecdsaValidator: DeployedContract;
+}
+/**
+ * Look up every AA contract this package knows about for `chainId`, already
+ * narrowed to {@link DeployedContract}. Returns `undefined` unless *all* five
+ * are deployed on that chain (today, only PEPU mainnet qualifies) — a caller
+ * building a Kernel account needs every one of them, so a partial result
+ * would just move the "is this actually usable" check into every caller.
+ *
+ * This is a convenience grouping over `getContract` from `./contracts.js`;
+ * it doesn't add any address or fact that registry doesn't already have.
+ */
+declare function getPepuKernelStack(chainId: number): PepuKernelStack | undefined;
+/**
+ * Legacy static gas-sponsorship status for PEPU. **Always reports
+ * unavailable** (it never probes). Sponsorship is PROVEN end to end on PEPU
+ * mainnet through the hosted bundler and paymaster service (a zero-balance
+ * Kernel smart account transacted, paid for by the paymaster); use
+ * `checkSponsorship()` for the live answer. This function
+ * exists so nothing downstream (this package, `@pepu-chain/mcp`, an app)
+ * has to independently invent an "is sponsorship on?" check, and so that
+ * check can't silently start lying once this file changes.
+ *
+ * Do not treat the presence of `kernelFactory`/`ecdsaValidator`/`paymaster`
+ * addresses in {@link getPepuKernelStack} / the contract registry as
+ * sponsorship support — those let you build and deploy a Kernel account and
+ * send its UserOperations through a normal `eth_sendTransaction`-style flow
+ * (self-paying its own gas via the EntryPoint deposit), which is a real,
+ * working feature; sponsoring that gas needs a funded project or free-tier token.
+ */
+interface SponsorshipStatus {
+    readonly available: false;
+    readonly reason: string;
+    /**
+     * Extension point for a future bundler/paymaster integration. Passing a
+     * URL here does **not** make sponsorship available — `available` stays
+     * `false` regardless — this field only exists so a caller can start
+     * wiring a URL through their own config today and have this function
+     * start using it later without an API change.
+     */
+    readonly bundlerUrl?: string;
+}
+/** Options for {@link getSponsorshipStatus}. */
+interface GetSponsorshipStatusOptions {
+    /** See {@link SponsorshipStatus.bundlerUrl}. Not yet used for anything. */
+    readonly bundlerUrl?: string;
+}
+/**
+ * @deprecated Always reports `available: false`. Use `checkSponsorship()` (live
+ * bundler and paymaster probe) from `@pepu-chain/sdk`. Kept for 0.1 callers.
+ */
+declare function getSponsorshipStatus(options?: GetSponsorshipStatusOptions): SponsorshipStatus;
+/**
+ * Compute (or confirm) the counterfactual address of a Kernel v3 smart
+ * account via the verified factory's `getAddress(data, salt)` — a thin,
+ * typed pass-through, not a re-implementation.
+ *
+ * Deliberately does **not** build `data` (Kernel v3.1's `initialize(...)`
+ * calldata: root validator, hook, validator data, hook data, init config)
+ * for you. A hand-rolled encoding here would be a second, unverified copy of
+ * the byte layout that ZeroDev's SDK already produces (and that has been
+ * exercised against PEPU's factory through the sponsored-transaction run),
+ * which is exactly the kind of invented encoding this package's rules
+ * forbid for addresses. Build `data` with ZeroDev's
+ * `@zerodev/sdk` (or by hand from the public Kernel v3 contracts source),
+ * then pass the result here.
+ */
+declare function getKernelAccountAddress(client: PublicClient<Transport, PepuChain>, factory: Pick<DeployedContract, "address">, args: {
+    readonly data: Hex;
+    readonly salt: Hex;
+}): Promise<Address>;
+/** Live sponsorship report from {@link checkSponsorship}. */
+interface SponsorshipReport {
+    /** True only when a bundler and a paymaster are configured and both answer. */
+    available: boolean;
+    /** `direct` when you bring your own bundler and paymaster URLs; `none` when nothing is configured. */
+    transport: "direct" | "none";
+    bundler: {
+        configured: boolean;
+        probe?: BundlerProbeResult;
+    };
+    paymaster: {
+        configured: boolean;
+        probe?: PaymasterProbeResult;
+        depositWei?: bigint;
+    };
+    /** One sentence for a human or an agent. */
+    reason: string;
+    /** Concrete next steps, empty when `available`. */
+    fixes: string[];
+}
+/** Options for {@link checkSponsorship}. */
+interface CheckSponsorshipOptions {
+    bundlerUrl?: string;
+    paymasterUrl?: string;
+    env?: Record<string, string | undefined>;
+    fetch?: FetchLike;
+    /** When given, also read the paymaster's EntryPoint deposit. */
+    publicClient?: PublicClient;
+    /** Paymaster contract to read the deposit of. Defaults to PEPU's deployed paymaster. */
+    paymasterAddress?: Address;
+    timeoutMs?: number;
+}
+/**
+ * Live gas-sponsorship status. Resolves the bundler and paymaster URLs from
+ * options, env, then the hosted defaults (bundler.pepeunchained.com and the paymaster
+ * service base; with no token URL the service is probed at its base), probes both,
+ * and optionally reads the paymaster deposit. Never throws for an
+ * unreachable service; it reports `available: false` with `fixes`.
+ * Replaces the hard-coded {@link getSponsorshipStatus}.
+ *
+ * @example
+ * const s = await checkSponsorship({ publicClient });
+ * if (!s.available) console.log(s.reason, s.fixes);
+ */
+declare function checkSponsorship(options?: CheckSponsorshipOptions): Promise<SponsorshipReport>;
+
+export { type BundlerProbeResult as B, type CheckSponsorshipOptions as C, type DeployedContract as D, type FetchLike as F, type GetSponsorshipStatusOptions as G, type PaymasterProbeResult as P, type SponsorshipReport as S, type PepuKernelStack as a, type ProbeOptions as b, type SponsorshipStatus as c, checkSponsorship as d, getPaymasterDeposit as e, getPepuKernelStack as f, getKernelAccountAddress as g, getSponsorshipStatus as h, probePaymaster as i, type ContractEntry as j, type PendingContract as k, type PepuAddressRow as l, type PepuContractName as m, type PepuContractRegistry as n, getContract as o, probeBundler as p, getPepuAddresses as q, isDeployed as r, listContracts as s, pepuContracts as t };

package/dist/status-DwkkOrGQ.d.ts

@@ -0,0 +1,295 @@
+import { Address, PublicClient, Transport, Hex } from 'viem';
+import { P as PepuChain } from './chains-DK13zGIp.js';
+import { a as PepuBundlerError } from './errors-CgX1vNj7.js';
+
+/** Minimal fetch signature, so tests and non-browser hosts can inject one. */
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+interface ProbeOptions {
+    fetch?: FetchLike;
+    /** Per-request timeout. Default 8000. */
+    timeoutMs?: number;
+}
+interface BundlerProbeResult {
+    ok: boolean;
+    chainId?: number;
+    entryPoints?: Address[];
+    /** `true` when the method exists (any answer but "method not found"). */
+    supportedMethods?: Record<string, boolean>;
+    latencyMs: number;
+    error?: PepuBundlerError;
+}
+interface PaymasterProbeResult {
+    ok: boolean;
+    /** `GET <origin>/health` answered `{ status: "ok" }`. */
+    health?: boolean;
+    /** Body of `GET <origin>/v2/free-tier` when the service exposes it. */
+    freeTier?: unknown;
+    /**
+     * The URL answered a `pm_getPaymasterStubData` call with a stub result. A
+     * JSON-RPC denial (no credential, unknown sender) is NOT a stub result:
+     * the endpoint is alive and speaks ERC-7677, but the probe has no
+     * credential, so this stays `false`.
+     */
+    erc7677StubOk?: boolean;
+    latencyMs: number;
+    error?: PepuBundlerError;
+}
+/**
+ * Probe a bundler URL: `eth_chainId`, `eth_supportedEntryPoints` and a
+ * capability check of the methods PEPU apps use (a method answered with
+ * anything but "method not found" counts as supported; nothing is sent
+ * on-chain). Never throws for network trouble; returns `ok: false` with a
+ * `BUNDLER_UNREACHABLE` error. Throws `CONFIG_BAD_URL` for a malformed URL.
+ *
+ * @example
+ * const r = await probeBundler("https://bundler.example.com");
+ * if (!r.ok) console.log(r.error?.hint);
+ */
+declare function probeBundler(url: string, o?: ProbeOptions): Promise<BundlerProbeResult>;
+/**
+ * Probe a paymaster URL: the service base (`https://paymaster.pepeunchained.com`) or the ERC-7677 endpoint
+ * (`https://host/v2/paymaster/<token>`).
+ * Checks `GET <origin>/health`, `GET <origin>/v2/free-tier`, and whether the URL
+ * answers JSON-RPC `pm_getPaymasterStubData`. `ok` means the service is alive:
+ * health is ok, or the URL spoke valid JSON-RPC. The URL (which can embed a
+ * token) never appears in the returned error.
+ *
+ * @example
+ * const r = await probePaymaster(process.env.PEPU_PAYMASTER_URL!);
+ * console.log(r.ok, r.freeTier);
+ */
+declare function probePaymaster(url: string, o?: ProbeOptions): Promise<PaymasterProbeResult>;
+/**
+ * The paymaster's EntryPoint v0.7 deposit in wei. A drop across a UserOperation
+ * is the proof that it was sponsored. Defaults to PEPU's deployed paymaster.
+ *
+ * @example
+ * const before = await getPaymasterDeposit(publicClient);
+ */
+declare function getPaymasterDeposit(client: PublicClient, paymaster?: Address): Promise<bigint>;
+
+/**
+ * Canonical keys for contracts tracked by this registry. Adding a new key
+ * here (and a corresponding entry per chain below) is not a breaking
+ * change for consumers that read the registry through {@link getContract}
+ * or {@link listContracts}.
+ */
+type PepuContractName = "create2Factory" | "multicall3" | "permit2" | "entryPoint06" | "entryPoint07" | "kernelFactory" | "kernelMetaFactory" | "ecdsaValidator" | "paymaster" | "kernelImplementation" | "kernelEcdsaSignerModule" | "kernelCallPolicyV004" | "kernelTimestampPolicy" | "tapScore" | "paymasterV1" | "paymasterV2";
+/** A contract that is confirmed live on-chain at `address`. */
+interface DeployedContract {
+    readonly status: "deployed";
+    /** Human-readable name, for logging/UI. */
+    readonly name: string;
+    /** Verified contract address. */
+    readonly address: Address;
+    /** Optional short note, e.g. how the address was verified. */
+    readonly notes?: string;
+    /**
+     * ISO date (YYYY-MM-DD) on which the address was last confirmed to have
+     * bytecode via `eth_getCode` against the PEPU mainnet RPC. Re-run
+     * `node packages/sdk/scripts/live-check.mjs` to refresh.
+     */
+    readonly verifiedAt?: string;
+    /**
+     * True when the contract still has bytecode but must not be used (for example
+     * the v1 paymaster, whose EntryPoint deposit was withdrawn). Never route new
+     * work to a retired contract.
+     */
+    readonly retired?: true;
+}
+/**
+ * A contract that is not yet deployed on this chain. Deliberately has no
+ * `address` field — callers must not be able to accidentally read a
+ * placeholder value and treat it as real. Use {@link getContract} /
+ * {@link isDeployed} to narrow before reading an address.
+ */
+interface PendingContract {
+    readonly status: "pending";
+    /** Human-readable name, for logging/UI. */
+    readonly name: string;
+    /** Why this contract has no verified address yet. */
+    readonly reason: string;
+}
+type ContractEntry = DeployedContract | PendingContract;
+/** Per-chain contract catalog, keyed by {@link PepuContractName}. */
+type PepuContractRegistry = Readonly<Record<PepuContractName, ContractEntry>>;
+/**
+ * Contract registry, keyed by chain id. Tracked as independent per-chain
+ * entries because deployments happen per-chain and have already diverged:
+ * mainnet has the CREATE2 deployer, a PEPU-specific Multicall3, the
+ * canonical Permit2, the full ZeroDev Kernel v3 AA stack (EntryPoint
+ * v0.6/v0.7, Kernel factory/meta-factory, ECDSA validator), and a
+ * project-deployed, funded verifying paymaster. Testnet has only the
+ * CREATE2 deployer — everything else is `status: "pending"` because
+ * testnet is out of scope for this package (no faucet exists to fund
+ * verification there).
+ *
+ * Note on the paymaster specifically: `status: "deployed"` here means the
+ * contract has live bytecode and a real EntryPoint deposit — it does NOT
+ * mean gas sponsorship is usable by an application. See
+ * `getSponsorshipStatus` in `./aa/status.js`, which is the single source of
+ * truth for that separate question.
+ */
+declare const pepuContracts: Readonly<Record<number, PepuContractRegistry>>;
+/** Look up one contract entry for a chain id. Returns `undefined` if the chain isn't in the registry. */
+declare function getContract(chainId: number, name: PepuContractName): ContractEntry | undefined;
+/** List all tracked contract entries for a chain id, in registry order. */
+declare function listContracts(chainId: number): readonly ContractEntry[];
+/** Narrow a {@link ContractEntry} to {@link DeployedContract}. */
+declare function isDeployed(entry: ContractEntry | undefined): entry is DeployedContract;
+/** One row of the address table returned by {@link getPepuAddresses}. */
+interface PepuAddressRow {
+    readonly key: PepuContractName;
+    readonly name: string;
+    readonly status: "deployed" | "pending";
+    /** Present only when `status` is `"deployed"`. */
+    readonly address?: Address;
+    /** ISO date of the last `eth_getCode` check, when known. */
+    readonly verifiedAt?: string;
+    /** True for a deployed contract that is retired and must not be used (the v1 paymaster). */
+    readonly retired?: true;
+    /** Notes (deployed) or reason (pending). */
+    readonly note: string;
+}
+/**
+ * The full supporting-contract table for a chain, flattened for docs and
+ * MCP rendering. Pending entries carry no `address`.
+ *
+ * @example
+ * ```ts
+ * const rows = getPepuAddresses(); // mainnet by default
+ * const live = rows.filter((r) => r.status === "deployed");
+ * ```
+ */
+declare function getPepuAddresses(chainId?: number): readonly PepuAddressRow[];
+
+/**
+ * The account-abstraction contracts a Kernel v3 smart account needs,
+ * narrowed to their {@link DeployedContract} form for a given chain.
+ * Returns `undefined` if any one of them isn't deployed on that chain
+ * (today: everything except mainnet, `97741`) — this package never fabricates
+ * a partial/best-effort bundle.
+ */
+interface PepuKernelStack {
+    readonly entryPoint06: DeployedContract;
+    readonly entryPoint07: DeployedContract;
+    readonly kernelFactory: DeployedContract;
+    readonly kernelMetaFactory: DeployedContract;
+    readonly ecdsaValidator: DeployedContract;
+}
+/**
+ * Look up every AA contract this package knows about for `chainId`, already
+ * narrowed to {@link DeployedContract}. Returns `undefined` unless *all* five
+ * are deployed on that chain (today, only PEPU mainnet qualifies) — a caller
+ * building a Kernel account needs every one of them, so a partial result
+ * would just move the "is this actually usable" check into every caller.
+ *
+ * This is a convenience grouping over `getContract` from `./contracts.js`;
+ * it doesn't add any address or fact that registry doesn't already have.
+ */
+declare function getPepuKernelStack(chainId: number): PepuKernelStack | undefined;
+/**
+ * Legacy static gas-sponsorship status for PEPU. **Always reports
+ * unavailable** (it never probes). Sponsorship is PROVEN end to end on PEPU
+ * mainnet through the hosted bundler and paymaster service (a zero-balance
+ * Kernel smart account transacted, paid for by the paymaster); use
+ * `checkSponsorship()` for the live answer. This function
+ * exists so nothing downstream (this package, `@pepu-chain/mcp`, an app)
+ * has to independently invent an "is sponsorship on?" check, and so that
+ * check can't silently start lying once this file changes.
+ *
+ * Do not treat the presence of `kernelFactory`/`ecdsaValidator`/`paymaster`
+ * addresses in {@link getPepuKernelStack} / the contract registry as
+ * sponsorship support — those let you build and deploy a Kernel account and
+ * send its UserOperations through a normal `eth_sendTransaction`-style flow
+ * (self-paying its own gas via the EntryPoint deposit), which is a real,
+ * working feature; sponsoring that gas needs a funded project or free-tier token.
+ */
+interface SponsorshipStatus {
+    readonly available: false;
+    readonly reason: string;
+    /**
+     * Extension point for a future bundler/paymaster integration. Passing a
+     * URL here does **not** make sponsorship available — `available` stays
+     * `false` regardless — this field only exists so a caller can start
+     * wiring a URL through their own config today and have this function
+     * start using it later without an API change.
+     */
+    readonly bundlerUrl?: string;
+}
+/** Options for {@link getSponsorshipStatus}. */
+interface GetSponsorshipStatusOptions {
+    /** See {@link SponsorshipStatus.bundlerUrl}. Not yet used for anything. */
+    readonly bundlerUrl?: string;
+}
+/**
+ * @deprecated Always reports `available: false`. Use `checkSponsorship()` (live
+ * bundler and paymaster probe) from `@pepu-chain/sdk`. Kept for 0.1 callers.
+ */
+declare function getSponsorshipStatus(options?: GetSponsorshipStatusOptions): SponsorshipStatus;
+/**
+ * Compute (or confirm) the counterfactual address of a Kernel v3 smart
+ * account via the verified factory's `getAddress(data, salt)` — a thin,
+ * typed pass-through, not a re-implementation.
+ *
+ * Deliberately does **not** build `data` (Kernel v3.1's `initialize(...)`
+ * calldata: root validator, hook, validator data, hook data, init config)
+ * for you. A hand-rolled encoding here would be a second, unverified copy of
+ * the byte layout that ZeroDev's SDK already produces (and that has been
+ * exercised against PEPU's factory through the sponsored-transaction run),
+ * which is exactly the kind of invented encoding this package's rules
+ * forbid for addresses. Build `data` with ZeroDev's
+ * `@zerodev/sdk` (or by hand from the public Kernel v3 contracts source),
+ * then pass the result here.
+ */
+declare function getKernelAccountAddress(client: PublicClient<Transport, PepuChain>, factory: Pick<DeployedContract, "address">, args: {
+    readonly data: Hex;
+    readonly salt: Hex;
+}): Promise<Address>;
+/** Live sponsorship report from {@link checkSponsorship}. */
+interface SponsorshipReport {
+    /** True only when a bundler and a paymaster are configured and both answer. */
+    available: boolean;
+    /** `direct` when you bring your own bundler and paymaster URLs; `none` when nothing is configured. */
+    transport: "direct" | "none";
+    bundler: {
+        configured: boolean;
+        probe?: BundlerProbeResult;
+    };
+    paymaster: {
+        configured: boolean;
+        probe?: PaymasterProbeResult;
+        depositWei?: bigint;
+    };
+    /** One sentence for a human or an agent. */
+    reason: string;
+    /** Concrete next steps, empty when `available`. */
+    fixes: string[];
+}
+/** Options for {@link checkSponsorship}. */
+interface CheckSponsorshipOptions {
+    bundlerUrl?: string;
+    paymasterUrl?: string;
+    env?: Record<string, string | undefined>;
+    fetch?: FetchLike;
+    /** When given, also read the paymaster's EntryPoint deposit. */
+    publicClient?: PublicClient;
+    /** Paymaster contract to read the deposit of. Defaults to PEPU's deployed paymaster. */
+    paymasterAddress?: Address;
+    timeoutMs?: number;
+}
+/**
+ * Live gas-sponsorship status. Resolves the bundler and paymaster URLs from
+ * options, env, then the hosted defaults (bundler.pepeunchained.com and the paymaster
+ * service base; with no token URL the service is probed at its base), probes both,
+ * and optionally reads the paymaster deposit. Never throws for an
+ * unreachable service; it reports `available: false` with `fixes`.
+ * Replaces the hard-coded {@link getSponsorshipStatus}.
+ *
+ * @example
+ * const s = await checkSponsorship({ publicClient });
+ * if (!s.available) console.log(s.reason, s.fixes);
+ */
+declare function checkSponsorship(options?: CheckSponsorshipOptions): Promise<SponsorshipReport>;
+
+export { type BundlerProbeResult as B, type CheckSponsorshipOptions as C, type DeployedContract as D, type FetchLike as F, type GetSponsorshipStatusOptions as G, type PaymasterProbeResult as P, type SponsorshipReport as S, type PepuKernelStack as a, type ProbeOptions as b, type SponsorshipStatus as c, checkSponsorship as d, getPaymasterDeposit as e, getPepuKernelStack as f, getKernelAccountAddress as g, getSponsorshipStatus as h, probePaymaster as i, type ContractEntry as j, type PendingContract as k, type PepuAddressRow as l, type PepuContractName as m, type PepuContractRegistry as n, getContract as o, probeBundler as p, getPepuAddresses as q, isDeployed as r, listContracts as s, pepuContracts as t };

package/dist/store-CjmLgp9g.d.cts

@@ -0,0 +1,64 @@
+import { Address, Hex } from 'viem';
+
+/**
+ * Server-side session records for the Kernel (on-chain) session flow, keyed by
+ * Privy user id. Ported from templates/sponsored-session-app/lib/session-store.ts.
+ *
+ * WHAT IS STORED: the session private key (a hot key whose power is limited
+ * ON-CHAIN by the call and timestamp policies until `validUntil`) and the
+ * public approval. The owner's key never reaches the server.
+ *
+ * PRODUCTION: {@link createMemoryStore} is DEV-GRADE. It is lost on every
+ * restart (the user simply starts a new session) and is not shared between
+ * serverless instances. A production deployment must implement
+ * {@link SessionStore} on a persistent database or KV AND keep
+ * `sessionPrivateKey` encrypted at rest (KMS or an envelope key). Nothing else
+ * in the SDK changes.
+ */
+interface SessionRecord {
+    userId: string;
+    ownerAddress: Address;
+    kernelAddress: Address;
+    /** The session key's private half. Encrypt it at rest in any persistent store. */
+    sessionPrivateKey: Hex;
+    sessionKeyAddress: Address;
+    permissionId: string;
+    /** Unix seconds. The on-chain permission is invalid at and after this time. */
+    validUntil: number;
+    /** Present once the owner has signed the grant. */
+    approval: string | null;
+    /** Number of successful sponsored actions in this session. */
+    actions: number;
+}
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Pluggable storage for {@link SessionRecord}s. Every method may be sync or
+ * async. `tryLock` must be atomic per user: it returns `false` when an action
+ * is already running for that user (a multi-instance deployment needs a
+ * distributed lock, for example a Redis `SET NX PX`).
+ */
+interface SessionStore {
+    get(userId: string): MaybePromise<SessionRecord | undefined>;
+    set(record: SessionRecord): MaybePromise<void>;
+    delete(userId: string): MaybePromise<void>;
+    tryLock(userId: string): MaybePromise<boolean>;
+    unlock(userId: string): MaybePromise<void>;
+}
+/**
+ * An in-memory {@link SessionStore} for development and tests. DEV-GRADE: not
+ * persistent, not shared across instances, and the session key is held in
+ * plaintext in process memory. Production needs an encrypted persistent store.
+ *
+ * @example
+ * const store = createMemoryStore();
+ */
+declare function createMemoryStore(): SessionStore;
+/**
+ * True while the on-chain permission is still valid: approved and before expiry.
+ *
+ * @example
+ * isLive(record, Math.floor(Date.now() / 1000));
+ */
+declare function isLive(record: SessionRecord, nowSeconds: number): boolean;
+
+export { type SessionStore as S, type SessionRecord as a, createMemoryStore as c, isLive as i };