@pepu-chain/sdk 0.0.0-stage → 0.2.1

package/dist/server.d.cts

@@ -0,0 +1,208 @@
+import { Hex, Hash, Address, AbiFunction, Abi } from 'viem';
+
+/**
+ * SERVER-ONLY helpers (`@pepu-chain/sdk/server`). Nothing here holds a secret,
+ * but these run on a backend that does hold Privy's app secret and
+ * authorization key; keep this entry point out of client bundles. No module
+ * in `src/` imports the `./server` barrel (enforced by a test). This file is the pure policy builder; it is re-exported from `@pepu-chain/sdk/session` and `@pepu-chain/sdk/server`.
+ */
+/**
+ * Privy rejects policy and rule names of 50 characters or more. Its published
+ * OpenAPI spec says `maxLength: 50`, but the live validator says "must be
+ * fewer than 50 characters", so the real limit is 49 (measured on a real
+ * `POST /policies` 400). Using 49 is safe under both readings.
+ */
+declare const PRIVY_POLICY_NAME_MAX_LENGTH = 49;
+/** Throws if `value` is over {@link PRIVY_POLICY_NAME_MAX_LENGTH}; returns it otherwise. */
+declare function assertWithinPolicyNameLimit(value: string, field: string): string;
+type SessionPolicyCondition = {
+    field_source: "ethereum_transaction";
+    field: "to" | "value";
+    operator: "eq";
+    value: string;
+} | {
+    field_source: "ethereum_calldata";
+    field: "function_name";
+    abi: AbiFunction[];
+    operator: "eq";
+    value: string;
+} | {
+    field_source: "system";
+    field: "current_unix_timestamp";
+    operator: "lte";
+    value: string;
+};
+interface SessionPolicyRule {
+    name: string;
+    method: "eth_signTransaction";
+    action: "ALLOW";
+    conditions: SessionPolicyCondition[];
+}
+/** Body for `privy.policies().create(...)`. */
+interface SessionPolicy {
+    version: "1.0";
+    name: string;
+    chain_type: "ethereum";
+    rules: SessionPolicyRule[];
+}
+interface BuildSessionPolicyParams {
+    /** The one contract the session may call. */
+    contractAddress: Address;
+    /** The function(s) the session may call, as ABI function fragments. At least one. */
+    functions: readonly AbiFunction[];
+    /** Unix seconds after which Privy's engine denies every request. */
+    expiresAtUnixSeconds: number;
+    /** Optional dashboard label; must be at most 49 characters. */
+    name?: string;
+}
+/**
+ * Build the scoped Privy session-signer policy: ONE `ALLOW` rule per function,
+ * each requiring `to` equals the contract, calldata decodes to that function,
+ * `value` is exactly zero, and the clock is before expiry. Privy ANDs the
+ * conditions in a rule, ORs the rules, and denies by default.
+ *
+ * Refuses to build an unscoped policy: it throws on an invalid contract
+ * address, no functions, a non-function ABI item, or a bad expiry. Names are
+ * checked against {@link PRIVY_POLICY_NAME_MAX_LENGTH}. The method is
+ * `eth_signTransaction` (a rule for `eth_sendTransaction` never matches the
+ * sign-and-broadcast flow).
+ *
+ * The scope is enforced by Privy's backend policy engine, not on-chain.
+ */
+declare function buildSessionPolicy({ contractAddress, functions, expiresAtUnixSeconds, name, }: BuildSessionPolicyParams): SessionPolicy;
+/** The unsigned legacy transaction body Privy's `eth_signTransaction` takes (snake_case, hex quantities). */
+interface PrivyUnsignedTransaction {
+    readonly to: Address;
+    readonly data: Hex;
+    readonly value: Hex;
+    readonly chain_id: number;
+    readonly type: 0;
+    readonly nonce: number;
+    readonly gas_limit: Hex;
+    readonly gas_price: Hex;
+}
+/** What Privy's `signTransaction` returns, or just the raw hex. */
+type SignedTransactionLike = Hex | {
+    signed_transaction: string;
+};
+/** Minimal viem client surface needed to broadcast. */
+interface BroadcastClient {
+    sendRawTransaction(args: {
+        serializedTransaction: Hex;
+    }): Promise<Hash>;
+}
+/** Minimal viem client surface needed to resolve nonce/gas and broadcast. */
+interface SignAndBroadcastClient extends BroadcastClient {
+    getTransactionCount(args: {
+        address: Address;
+        blockTag: "pending";
+    }): Promise<number>;
+    estimateGas(args: {
+        account: Address;
+        to: Address;
+        data: Hex;
+        value: bigint;
+    }): Promise<bigint>;
+    getGasPrice(): Promise<bigint>;
+}
+/** Estimate plus 20%: Nitro gas estimates can undershoot slightly. */
+declare function withGasLimitBuffer(estimatedGas: bigint): bigint;
+/**
+ * Broadcast a raw signed transaction (from Privy `eth_signTransaction`) to
+ * PEPU through a viem client and return the transaction hash. Accepts the raw
+ * hex or Privy's `{ signed_transaction }` object. A failure here is a failed
+ * TRANSACTION (revert, nonce race), not proof the session signer is gone.
+ */
+declare function broadcastSignedTransaction(client: BroadcastClient, signed: SignedTransactionLike): Promise<Hash>;
+interface SignAndBroadcastParams {
+    client: SignAndBroadcastClient;
+    /** The wallet that signs (the session-signer wallet's address). */
+    from: Address;
+    to: Address;
+    /** Pre-encoded calldata, or use `abi` + `functionName` + `args`. */
+    data?: Hex;
+    abi?: Abi;
+    functionName?: string;
+    args?: readonly unknown[];
+    /** Native value in wei. Default 0n. */
+    value?: bigint;
+    chainId: number;
+    /**
+     * Performs the signing, e.g. a call to
+     * `privy.wallets().ethereum().signTransaction(walletId, { params: { transaction }, authorization_context })`
+     * and returns its result. Injected so this package has no Privy dependency.
+     */
+    sign: (transaction: PrivyUnsignedTransaction) => Promise<SignedTransactionLike>;
+}
+/**
+ * The full sign-with-Privy, broadcast-yourself flow: resolve nonce (pending),
+ * gas (+20%) and gas price against PEPU's RPC, build the unsigned legacy
+ * transaction, hand it to `sign`, then broadcast the result and return the hash.
+ * Privy's server-side `eth_sendTransaction` rejects chain 97741, which is why
+ * this exists.
+ */
+declare function signAndBroadcast(params: SignAndBroadcastParams): Promise<Hash>;
+/** Default session length when `SESSION_DURATION_MINUTES` is unset or invalid. */
+declare const DEFAULT_SESSION_MINUTES = 15;
+/** Upper bound for a session: 24 hours. Larger requests are clamped. */
+declare const MAX_SESSION_MINUTES = 1440;
+/**
+ * Parse a session duration (an env value or number) into minutes: anything
+ * missing, non-numeric, zero or negative falls back to
+ * {@link DEFAULT_SESSION_MINUTES}; anything above {@link MAX_SESSION_MINUTES} is clamped.
+ * Lifted from templates/game-app/lib/env.server.ts.
+ *
+ * @example
+ * resolveSessionMinutes(process.env.SESSION_DURATION_MINUTES); // 15 when unset
+ * resolveSessionMinutes("99999"); // 1440
+ */
+declare function resolveSessionMinutes(raw: string | number | null | undefined): number;
+/**
+ * The unix-seconds expiry for a session that starts at `nowSeconds` and lasts
+ * `minutes`. Whole seconds, rounded down.
+ *
+ * @example
+ * sessionExpiry(1_700_000_000, 15); // 1_700_000_900
+ */
+declare function sessionExpiry(nowSeconds: number, minutes: number): number;
+/** One callable function in a session's scope, ready for a consent screen. */
+interface SessionScopeFunction {
+    name: string;
+    /** e.g. `tap()` or `transfer(address,uint256)`. */
+    signature: string;
+    /** 4-byte selector. */
+    selector: Hex;
+    /** Always `"0"`: a session call never carries native value. */
+    valueWei: "0";
+}
+/** What a session may do, as plain data for a consent screen. */
+interface SessionScope {
+    contractAddress: Address;
+    functions: SessionScopeFunction[];
+    expiresAtUnixSeconds: number;
+}
+/**
+ * Consent-screen data for a session: the one contract, each allowed function
+ * (name, signature, selector), zero value, and the expiry. Throws on an
+ * invalid address or an empty or non-function list, same as {@link buildSessionPolicy}.
+ *
+ * @example
+ * const scope = describeSessionScope({ contractAddress, functions: [tapAbi], expiresAtUnixSeconds });
+ * scope.functions[0]?.signature; // "tap()"
+ */
+declare function describeSessionScope(p: {
+    contractAddress: Address;
+    functions: readonly AbiFunction[];
+    expiresAtUnixSeconds: number;
+}): SessionScope;
+/**
+ * The mandatory honest statements about who enforces a session's limits. Show
+ * the one for the mode in use on the consent screen. Adapted from
+ * templates/game-app/components/session-consent-screen.tsx.
+ *
+ * @example
+ * <p>{SESSION_TRUST_NOTICE["privy-offchain"]}</p>
+ */
+declare const SESSION_TRUST_NOTICE: Record<"privy-offchain" | "kernel-onchain", string>;
+
+export { type BroadcastClient, type BuildSessionPolicyParams, DEFAULT_SESSION_MINUTES, MAX_SESSION_MINUTES, PRIVY_POLICY_NAME_MAX_LENGTH, type PrivyUnsignedTransaction, SESSION_TRUST_NOTICE, type SessionPolicy, type SessionPolicyCondition, type SessionPolicyRule, type SessionScope, type SessionScopeFunction, type SignAndBroadcastClient, type SignAndBroadcastParams, type SignedTransactionLike, assertWithinPolicyNameLimit, broadcastSignedTransaction, buildSessionPolicy, describeSessionScope, resolveSessionMinutes, sessionExpiry, signAndBroadcast, withGasLimitBuffer };

package/dist/server.d.ts

@@ -0,0 +1,208 @@
+import { Hex, Hash, Address, AbiFunction, Abi } from 'viem';
+
+/**
+ * SERVER-ONLY helpers (`@pepu-chain/sdk/server`). Nothing here holds a secret,
+ * but these run on a backend that does hold Privy's app secret and
+ * authorization key; keep this entry point out of client bundles. No module
+ * in `src/` imports the `./server` barrel (enforced by a test). This file is the pure policy builder; it is re-exported from `@pepu-chain/sdk/session` and `@pepu-chain/sdk/server`.
+ */
+/**
+ * Privy rejects policy and rule names of 50 characters or more. Its published
+ * OpenAPI spec says `maxLength: 50`, but the live validator says "must be
+ * fewer than 50 characters", so the real limit is 49 (measured on a real
+ * `POST /policies` 400). Using 49 is safe under both readings.
+ */
+declare const PRIVY_POLICY_NAME_MAX_LENGTH = 49;
+/** Throws if `value` is over {@link PRIVY_POLICY_NAME_MAX_LENGTH}; returns it otherwise. */
+declare function assertWithinPolicyNameLimit(value: string, field: string): string;
+type SessionPolicyCondition = {
+    field_source: "ethereum_transaction";
+    field: "to" | "value";
+    operator: "eq";
+    value: string;
+} | {
+    field_source: "ethereum_calldata";
+    field: "function_name";
+    abi: AbiFunction[];
+    operator: "eq";
+    value: string;
+} | {
+    field_source: "system";
+    field: "current_unix_timestamp";
+    operator: "lte";
+    value: string;
+};
+interface SessionPolicyRule {
+    name: string;
+    method: "eth_signTransaction";
+    action: "ALLOW";
+    conditions: SessionPolicyCondition[];
+}
+/** Body for `privy.policies().create(...)`. */
+interface SessionPolicy {
+    version: "1.0";
+    name: string;
+    chain_type: "ethereum";
+    rules: SessionPolicyRule[];
+}
+interface BuildSessionPolicyParams {
+    /** The one contract the session may call. */
+    contractAddress: Address;
+    /** The function(s) the session may call, as ABI function fragments. At least one. */
+    functions: readonly AbiFunction[];
+    /** Unix seconds after which Privy's engine denies every request. */
+    expiresAtUnixSeconds: number;
+    /** Optional dashboard label; must be at most 49 characters. */
+    name?: string;
+}
+/**
+ * Build the scoped Privy session-signer policy: ONE `ALLOW` rule per function,
+ * each requiring `to` equals the contract, calldata decodes to that function,
+ * `value` is exactly zero, and the clock is before expiry. Privy ANDs the
+ * conditions in a rule, ORs the rules, and denies by default.
+ *
+ * Refuses to build an unscoped policy: it throws on an invalid contract
+ * address, no functions, a non-function ABI item, or a bad expiry. Names are
+ * checked against {@link PRIVY_POLICY_NAME_MAX_LENGTH}. The method is
+ * `eth_signTransaction` (a rule for `eth_sendTransaction` never matches the
+ * sign-and-broadcast flow).
+ *
+ * The scope is enforced by Privy's backend policy engine, not on-chain.
+ */
+declare function buildSessionPolicy({ contractAddress, functions, expiresAtUnixSeconds, name, }: BuildSessionPolicyParams): SessionPolicy;
+/** The unsigned legacy transaction body Privy's `eth_signTransaction` takes (snake_case, hex quantities). */
+interface PrivyUnsignedTransaction {
+    readonly to: Address;
+    readonly data: Hex;
+    readonly value: Hex;
+    readonly chain_id: number;
+    readonly type: 0;
+    readonly nonce: number;
+    readonly gas_limit: Hex;
+    readonly gas_price: Hex;
+}
+/** What Privy's `signTransaction` returns, or just the raw hex. */
+type SignedTransactionLike = Hex | {
+    signed_transaction: string;
+};
+/** Minimal viem client surface needed to broadcast. */
+interface BroadcastClient {
+    sendRawTransaction(args: {
+        serializedTransaction: Hex;
+    }): Promise<Hash>;
+}
+/** Minimal viem client surface needed to resolve nonce/gas and broadcast. */
+interface SignAndBroadcastClient extends BroadcastClient {
+    getTransactionCount(args: {
+        address: Address;
+        blockTag: "pending";
+    }): Promise<number>;
+    estimateGas(args: {
+        account: Address;
+        to: Address;
+        data: Hex;
+        value: bigint;
+    }): Promise<bigint>;
+    getGasPrice(): Promise<bigint>;
+}
+/** Estimate plus 20%: Nitro gas estimates can undershoot slightly. */
+declare function withGasLimitBuffer(estimatedGas: bigint): bigint;
+/**
+ * Broadcast a raw signed transaction (from Privy `eth_signTransaction`) to
+ * PEPU through a viem client and return the transaction hash. Accepts the raw
+ * hex or Privy's `{ signed_transaction }` object. A failure here is a failed
+ * TRANSACTION (revert, nonce race), not proof the session signer is gone.
+ */
+declare function broadcastSignedTransaction(client: BroadcastClient, signed: SignedTransactionLike): Promise<Hash>;
+interface SignAndBroadcastParams {
+    client: SignAndBroadcastClient;
+    /** The wallet that signs (the session-signer wallet's address). */
+    from: Address;
+    to: Address;
+    /** Pre-encoded calldata, or use `abi` + `functionName` + `args`. */
+    data?: Hex;
+    abi?: Abi;
+    functionName?: string;
+    args?: readonly unknown[];
+    /** Native value in wei. Default 0n. */
+    value?: bigint;
+    chainId: number;
+    /**
+     * Performs the signing, e.g. a call to
+     * `privy.wallets().ethereum().signTransaction(walletId, { params: { transaction }, authorization_context })`
+     * and returns its result. Injected so this package has no Privy dependency.
+     */
+    sign: (transaction: PrivyUnsignedTransaction) => Promise<SignedTransactionLike>;
+}
+/**
+ * The full sign-with-Privy, broadcast-yourself flow: resolve nonce (pending),
+ * gas (+20%) and gas price against PEPU's RPC, build the unsigned legacy
+ * transaction, hand it to `sign`, then broadcast the result and return the hash.
+ * Privy's server-side `eth_sendTransaction` rejects chain 97741, which is why
+ * this exists.
+ */
+declare function signAndBroadcast(params: SignAndBroadcastParams): Promise<Hash>;
+/** Default session length when `SESSION_DURATION_MINUTES` is unset or invalid. */
+declare const DEFAULT_SESSION_MINUTES = 15;
+/** Upper bound for a session: 24 hours. Larger requests are clamped. */
+declare const MAX_SESSION_MINUTES = 1440;
+/**
+ * Parse a session duration (an env value or number) into minutes: anything
+ * missing, non-numeric, zero or negative falls back to
+ * {@link DEFAULT_SESSION_MINUTES}; anything above {@link MAX_SESSION_MINUTES} is clamped.
+ * Lifted from templates/game-app/lib/env.server.ts.
+ *
+ * @example
+ * resolveSessionMinutes(process.env.SESSION_DURATION_MINUTES); // 15 when unset
+ * resolveSessionMinutes("99999"); // 1440
+ */
+declare function resolveSessionMinutes(raw: string | number | null | undefined): number;
+/**
+ * The unix-seconds expiry for a session that starts at `nowSeconds` and lasts
+ * `minutes`. Whole seconds, rounded down.
+ *
+ * @example
+ * sessionExpiry(1_700_000_000, 15); // 1_700_000_900
+ */
+declare function sessionExpiry(nowSeconds: number, minutes: number): number;
+/** One callable function in a session's scope, ready for a consent screen. */
+interface SessionScopeFunction {
+    name: string;
+    /** e.g. `tap()` or `transfer(address,uint256)`. */
+    signature: string;
+    /** 4-byte selector. */
+    selector: Hex;
+    /** Always `"0"`: a session call never carries native value. */
+    valueWei: "0";
+}
+/** What a session may do, as plain data for a consent screen. */
+interface SessionScope {
+    contractAddress: Address;
+    functions: SessionScopeFunction[];
+    expiresAtUnixSeconds: number;
+}
+/**
+ * Consent-screen data for a session: the one contract, each allowed function
+ * (name, signature, selector), zero value, and the expiry. Throws on an
+ * invalid address or an empty or non-function list, same as {@link buildSessionPolicy}.
+ *
+ * @example
+ * const scope = describeSessionScope({ contractAddress, functions: [tapAbi], expiresAtUnixSeconds });
+ * scope.functions[0]?.signature; // "tap()"
+ */
+declare function describeSessionScope(p: {
+    contractAddress: Address;
+    functions: readonly AbiFunction[];
+    expiresAtUnixSeconds: number;
+}): SessionScope;
+/**
+ * The mandatory honest statements about who enforces a session's limits. Show
+ * the one for the mode in use on the consent screen. Adapted from
+ * templates/game-app/components/session-consent-screen.tsx.
+ *
+ * @example
+ * <p>{SESSION_TRUST_NOTICE["privy-offchain"]}</p>
+ */
+declare const SESSION_TRUST_NOTICE: Record<"privy-offchain" | "kernel-onchain", string>;
+
+export { type BroadcastClient, type BuildSessionPolicyParams, DEFAULT_SESSION_MINUTES, MAX_SESSION_MINUTES, PRIVY_POLICY_NAME_MAX_LENGTH, type PrivyUnsignedTransaction, SESSION_TRUST_NOTICE, type SessionPolicy, type SessionPolicyCondition, type SessionPolicyRule, type SessionScope, type SessionScopeFunction, type SignAndBroadcastClient, type SignAndBroadcastParams, type SignedTransactionLike, assertWithinPolicyNameLimit, broadcastSignedTransaction, buildSessionPolicy, describeSessionScope, resolveSessionMinutes, sessionExpiry, signAndBroadcast, withGasLimitBuffer };

package/dist/server.js

@@ -0,0 +1,8 @@
+import { assertServerOnly } from './chunk-W3JN3YIW.js';
+export { DEFAULT_SESSION_MINUTES, MAX_SESSION_MINUTES, PRIVY_POLICY_NAME_MAX_LENGTH, SESSION_TRUST_NOTICE, assertWithinPolicyNameLimit, broadcastSignedTransaction, buildSessionPolicy, describeSessionScope, resolveSessionMinutes, sessionExpiry, signAndBroadcast, withGasLimitBuffer } from './chunk-YKEWWQEJ.js';
+import './chunk-6DSZ4Z2N.js';
+
+// src/server.ts
+assertServerOnly("@pepu-chain/sdk/server");
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server.ts"],"names":[],"mappings":";;;;;AAEA,gBAAA,CAAiB,wBAAwB,CAAA","file":"server.js","sourcesContent":["import { assertServerOnly } from \"./internal/assert-server.js\";\n\nassertServerOnly(\"@pepu-chain/sdk/server\");\n\n/**\n * `@pepu-chain/sdk/server` is kept as a stable import path. It re-exports the\n * pure server-side helpers, which now live in `./session/policy.ts`. New\n * server code lives in `/privy/server`, `/session/server` and\n * `/paymaster/server`.\n */\nexport * from \"./session/policy.js\";\n"]}

package/dist/session/kernel.cjs

@@ -0,0 +1,83 @@
+'use strict';
+/* @pepu-chain/peer-guard */(function(){var p=["@zerodev/sdk","@zerodev/permissions","@zerodev/ecdsa-validator"];for(var i=0;i<p.length;i++){try{require.resolve(p[i])}catch(e){if(e&&e.code==="MODULE_NOT_FOUND"){var m="@pepu-chain/sdk/session/kernel needs peer packages that are not installed: @zerodev/sdk @zerodev/permissions @zerodev/ecdsa-validator. Install with: npm i @zerodev/sdk @zerodev/permissions @zerodev/ecdsa-validator  (or let create-pepu-app scaffold everything).";var x=new Error(m);x.code="PEPU_MISSING_PEER";throw x}}}})();
+
+var chunkPHM3ZORG_cjs = require('../chunk-PHM3ZORG.cjs');
+var chunkNVOPDXTA_cjs = require('../chunk-NVOPDXTA.cjs');
+require('../chunk-7MNJF2OB.cjs');
+require('../chunk-AJS4UFQX.cjs');
+require('../chunk-A5LP2UCS.cjs');
+require('../chunk-WANILJZQ.cjs');
+var chunkJ3O2ZGG3_cjs = require('../chunk-J3O2ZGG3.cjs');
+require('../chunk-4GINFJO6.cjs');
+require('../chunk-VF3D6KLQ.cjs');
+require('../chunk-DPCZJLB3.cjs');
+require('../chunk-YQL7NISX.cjs');
+
+
+
+Object.defineProperty(exports, "CALL_POLICY_V0_0_4_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.CALL_POLICY_V0_0_4_ADDRESS; }
+});
+Object.defineProperty(exports, "SESSION_GAS_RESERVATION_PEPU", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.SESSION_GAS_RESERVATION_PEPU; }
+});
+Object.defineProperty(exports, "TIMESTAMP_POLICY_ADDRESS", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.TIMESTAMP_POLICY_ADDRESS; }
+});
+Object.defineProperty(exports, "approveKernelSession", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.approveKernelSession; }
+});
+Object.defineProperty(exports, "buildKernelSessionPolicies", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.buildKernelSessionPolicies; }
+});
+Object.defineProperty(exports, "createMemoryStore", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.createMemoryStore; }
+});
+Object.defineProperty(exports, "expectedPermissionId", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.expectedPermissionId; }
+});
+Object.defineProperty(exports, "generateSessionKey", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.generateSessionKey; }
+});
+Object.defineProperty(exports, "isLive", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.isLive; }
+});
+Object.defineProperty(exports, "loadKernelSessionAccount", {
+  enumerable: true,
+  get: function () { return chunkPHM3ZORG_cjs.loadKernelSessionAccount; }
+});
+Object.defineProperty(exports, "KERNEL_VERSION", {
+  enumerable: true,
+  get: function () { return chunkNVOPDXTA_cjs.KERNEL_VERSION; }
+});
+Object.defineProperty(exports, "getKernelAddress", {
+  enumerable: true,
+  get: function () { return chunkNVOPDXTA_cjs.getKernelAddress; }
+});
+Object.defineProperty(exports, "checkApproval", {
+  enumerable: true,
+  get: function () { return chunkJ3O2ZGG3_cjs.checkApproval; }
+});
+Object.defineProperty(exports, "describeKernelSessionScope", {
+  enumerable: true,
+  get: function () { return chunkJ3O2ZGG3_cjs.describeKernelSessionScope; }
+});
+Object.defineProperty(exports, "isCallInScope", {
+  enumerable: true,
+  get: function () { return chunkJ3O2ZGG3_cjs.isCallInScope; }
+});
+Object.defineProperty(exports, "parseApproval", {
+  enumerable: true,
+  get: function () { return chunkJ3O2ZGG3_cjs.parseApproval; }
+});
+//# sourceMappingURL=kernel.cjs.map
+//# sourceMappingURL=kernel.cjs.map

package/dist/session/kernel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"kernel.cjs"}

package/dist/session/kernel.d.cts

@@ -0,0 +1,131 @@
+import { Policy } from '@zerodev/permissions';
+import { Address, PublicClient, Hex } from 'viem';
+import { KernelOwner, KernelSmartAccount } from '../aa/kernel.cjs';
+export { KERNEL_VERSION, getKernelAddress } from '../aa/kernel.cjs';
+import { K as KernelSessionCall } from '../scope-DBRkN7bR.cjs';
+export { A as ApprovalCheck, a as KernelSessionScope, P as ParsedApproval, c as checkApproval, d as describeKernelSessionScope, i as isCallInScope, p as parseApproval } from '../scope-DBRkN7bR.cjs';
+export { a as SessionRecord, S as SessionStore, c as createMemoryStore, i as isLive } from '../store-CjmLgp9g.cjs';
+import '@zerodev/sdk/types';
+import '@zerodev/sdk';
+import '../erc7677-DOW58QBE.cjs';
+import '../types-BilBTDqK.cjs';
+import '../calls-BRPjKgjl.cjs';
+
+/**
+ * `@pepu-chain/sdk/session/kernel`: on-chain session keys with ZeroDev Kernel
+ * permissions. Extracted from templates/sponsored-session-app/lib/{kernel,
+ * session-policy,approval}.ts and built on `toPepuKernelAccount`
+ * (`plugins.regular`).
+ *
+ * The scope is enforced ON-CHAIN by ZeroDev's policy contracts, which the
+ * user's Kernel account calls during UserOperation validation:
+ *
+ * - Call policy v0.0.4: only the listed targets and function selectors, with a
+ *   native value no larger than `valueLimit` (default 0).
+ * - Timestamp policy: the permission is invalid outside `validAfter`..`validUntil`.
+ *
+ * A UserOperation outside this scope is rejected by the EntryPoint itself, no
+ * matter who relays it or what the app backend does.
+ *
+ * Deployed on PEPU mainnet (eth_getCode verified 2026-10-02): Kernel v3.1
+ * factory 0xaac5D4240AF87249B3f71BC8E4A2cae074A3E419, ECDSA validator
+ * 0x845ADb2C711129d4f3966735eD98a9F09fC4cE57, ECDSA signer module
+ * 0x6A6F069E2a08c2468e7724Ab3250CdBFBA14D4FF, call policy v0.0.4 and the
+ * timestamp policy below. Call policy v0.0.5 is NOT deployed on PEPU, so the
+ * version is pinned.
+ *
+ * Optional peers: `@zerodev/sdk`, `@zerodev/permissions`, `@zerodev/ecdsa-validator`.
+ */
+/** Call policy v0.0.4. Pinned: v0.0.5 is not deployed on PEPU mainnet. */
+declare const CALL_POLICY_V0_0_4_ADDRESS: Address;
+/** ZeroDev timestamp policy on PEPU mainnet. */
+declare const TIMESTAMP_POLICY_ADDRESS: Address;
+/**
+ * Worst-case gas the paymaster policy service RESERVES per sponsored operation,
+ * measured on PEPU mainnet with the sponsored-session-app template: the first
+ * operation of a session (account deploy plus enabling the permission) about
+ * 20.5 PEPU, later operations about 6.9 PEPU. The real first-session cost was
+ * about 12.8 PEPU for two operations. Size per-user hourly and daily spend
+ * caps above these, or users hit `trailing-hour spend ... would exceed cap`
+ * after their first action.
+ */
+declare const SESSION_GAS_RESERVATION_PEPU: {
+    readonly firstOperation: 20.5;
+    readonly laterOperation: 6.9;
+};
+/**
+ * The on-chain policies for one session: call policy v0.0.4 plus the timestamp
+ * policy. Pure and deterministic given its input. Only the named function
+ * fragments go into the policy, which keeps the grant small.
+ *
+ * @example
+ * const policies = buildKernelSessionPolicies({
+ *   calls: [{ target: tapScore, abi: tapScoreAbi, functionName: "tap" }],
+ *   validUntil: Math.floor(Date.now() / 1000) + 900,
+ * });
+ */
+declare function buildKernelSessionPolicies(p: {
+    calls: readonly KernelSessionCall[];
+    validUntil: number;
+    validAfter?: number;
+}): Policy[];
+/**
+ * A fresh random session key. SERVER ONLY: the private key must never reach
+ * the browser. Only the address is sent to the owner for approval.
+ *
+ * @example
+ * const { privateKey, address } = generateSessionKey();
+ */
+declare function generateSessionKey(): {
+    privateKey: Hex;
+    address: Address;
+};
+/**
+ * The permission id the chain derives for this session key plus these
+ * policies. The server compares it with a browser-supplied approval.
+ *
+ * @example
+ * const permissionId = await expectedPermissionId({ publicClient, sessionKeyAddress, policies });
+ */
+declare function expectedPermissionId(p: {
+    publicClient: PublicClient;
+    sessionKeyAddress: Address;
+    policies: Policy[];
+}): Promise<string>;
+/**
+ * In the user's browser: the owner (the Privy embedded wallet, the only thing
+ * that can authorize a session) signs ONE EIP-712 message that enables a
+ * permission validator on their Kernel account. That signature is the whole
+ * grant. It names the session key's public address (never its private key)
+ * and the policies. The returned `approval` holds no secret: it is the enable
+ * signature plus the policy parameters, useless without the session key.
+ *
+ * @example
+ * const { approval, kernelAddress } = await approveKernelSession({
+ *   publicClient, owner: walletClient, sessionKeyAddress, policies,
+ * });
+ */
+declare function approveKernelSession(p: {
+    publicClient: PublicClient;
+    owner: KernelOwner;
+    sessionKeyAddress: Address;
+    policies: Policy[];
+}): Promise<{
+    approval: string;
+    kernelAddress: Address;
+}>;
+/**
+ * On the server: rebuild the session's Kernel account from the approval and
+ * the server-held session key (an ECDSA signer for that key). No owner
+ * signature is involved. Pass the result to `createPepuSponsoredClient`.
+ *
+ * @example
+ * const account = await loadKernelSessionAccount({ publicClient, approval, sessionPrivateKey });
+ */
+declare function loadKernelSessionAccount(p: {
+    publicClient: PublicClient;
+    approval: string;
+    sessionPrivateKey: Hex;
+}): Promise<KernelSmartAccount>;
+
+export { CALL_POLICY_V0_0_4_ADDRESS, KernelOwner, KernelSessionCall, KernelSmartAccount, SESSION_GAS_RESERVATION_PEPU, TIMESTAMP_POLICY_ADDRESS, approveKernelSession, buildKernelSessionPolicies, expectedPermissionId, generateSessionKey, loadKernelSessionAccount };