@pepu-chain/sdk 0.0.0-stage → 0.2.0

package/dist/api-Dz4sCHH_.d.ts

@@ -0,0 +1,654 @@
+import { Address, Hex, WalletClient, Account, Chain, PublicClient, Hash } from 'viem';
+
+/** A transaction a wallet (or smart account batch) can send. */
+interface PaymasterCall {
+    to: Address;
+    data: Hex;
+    value: bigint;
+    /** Solidity signature, for logs and UIs. */
+    function: string;
+}
+/** The EIP-712 `ProjectClaim` attestation returned by `POST /v2/projects/verify`. */
+interface ProjectClaimAttestation {
+    appId: string;
+    newOwner: Address;
+    nonce: string | bigint;
+    deadline: string | bigint;
+    signature: Hex;
+}
+interface PaymasterAddressOption {
+    /** v2 paymaster address. Defaults to the registry's `paymasterV2` entry once it is deployed. */
+    paymaster?: Address | undefined;
+}
+/**
+ * Resolve the v2 paymaster address: explicit option first, then the registry. Throws
+ * `CONFIG_MISSING_ENV` (never guesses an address) when neither is available.
+ *
+ * @example
+ * ```ts
+ * const paymaster = resolvePaymasterV2Address("0x1111111111111111111111111111111111111111");
+ * ```
+ */
+declare function resolvePaymasterV2Address(explicit?: Address): Address;
+/**
+ * `projectId = keccak256(bytes(appId))`. The app id is used exactly as given, so it is case-sensitive:
+ * Privy app ids are lower-case cuids, and a different case is a different project.
+ *
+ * @example
+ * ```ts
+ * const projectId = computeProjectId("clx0example0app0id");
+ * ```
+ */
+declare function computeProjectId(appId: string): Hex;
+/** Plan name for {@link computeProjectId}. */
+declare const getProjectId: typeof computeProjectId;
+/** State of a project, read from the paymaster contract. */
+interface ProjectState {
+    projectId: Hex;
+    paymaster: Address;
+    /** `null` when unclaimed. */
+    owner: Address | null;
+    claimed: boolean;
+    paused: boolean;
+    /** Deposited, unspent wei. Deposit-only: this can only be spent as gas, never withdrawn. */
+    balance: bigint;
+    dailyLimit: bigint;
+    senderDailyLimit: bigint;
+    /** Spent in the current UTC day (0 when the stored day is stale). */
+    spentToday: bigint;
+    /** Day index (unix seconds / 86400) the stored `spentToday` belongs to. */
+    spentDay: number;
+    /** True when claimed and both limits are set. Targets are checked via `targetsAllowed`. */
+    limitsConfigured: boolean;
+    /**
+     * Pending timelocked claim, or `null`: a re-claim of an owned project, or (when `claimed` is false) the first
+     * claim of a project that already holds funds. Finish it with {@link encodeExecuteReclaim} after `executableAt`.
+     */
+    pendingReclaim: {
+        newOwner: Address;
+        executableAt: number;
+        signer: Address;
+    } | null;
+    /** Address proposed in a two-step ownership transfer, or `null`. */
+    pendingOwner: Address | null;
+    /** Present when `checkTargets` was passed: allowed flag per address (checksummed keys). */
+    targetsAllowed?: Record<Address, boolean>;
+}
+interface ReadProjectOptions extends PaymasterAddressOption {
+    /** Also check these destinations against the on-chain allowlist (one `isTargetAllowed` read each). */
+    checkTargets?: readonly Address[];
+    /** Clock override for the day rollover (tests). Milliseconds. */
+    now?: () => number;
+}
+/**
+ * Read a project's on-chain state: owner, pause flag, balance, limits, pending re-claim and pending owner.
+ *
+ * @example
+ * ```ts
+ * const p = await readProject(publicClient, computeProjectId(appId), { paymaster });
+ * if (!p.claimed) console.log("claim it first");
+ * ```
+ */
+declare function readProject(client: Pick<PublicClient, "readContract">, projectId: Hex, options?: ReadProjectOptions): Promise<ProjectState>;
+/**
+ * Encode `depositFor(projectId)` with native PEPU as `value`. ONE-WAY: nothing can ever withdraw the deposit,
+ * and the id is `keccak256` of a case-sensitive app id, so a typo deposits into a project nobody can claim.
+ * Prefer {@link depositFor}, which checks the project is claimed first.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeDeposit(computeProjectId(appId), 10n ** 18n, { paymaster });
+ * ```
+ */
+declare function encodeDeposit(projectId: Hex, amountWei: bigint, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `claimProject(Claim)`. The attestation fixes the owner; anyone may submit the transaction. The claim
+ * sets ONLY the owner: follow with {@link configureProject}'s three calls, because nothing is sponsorable
+ * until `setTargets`, `setDailyLimit` and `setSenderDailyLimit` have run. If the project already holds deposited
+ * funds the claim is PENDING for the on-chain admin change delay (>= 48h): the contract owner or manager can cancel
+ * it, and anyone finishes it with {@link encodeExecuteReclaim}.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeClaimProject(attestation, { paymaster });
+ * await walletClient.sendTransaction({ to: tx.to, data: tx.data });
+ * ```
+ */
+declare function encodeClaimProject(attestation: ProjectClaimAttestation, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `reclaimProject(Claim)`: a timelocked (>= 48h) re-claim of an already-owned project. The current owner
+ * can cancel it ({@link encodeCancelReclaim}); anyone can finish it after the delay ({@link encodeExecuteReclaim}).
+ *
+ * @example
+ * ```ts
+ * const tx = encodeReclaimProject(attestation, { paymaster });
+ * ```
+ */
+declare function encodeReclaimProject(attestation: ProjectClaimAttestation, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Pick `claimProject` or `reclaimProject` from a `/v2/projects/verify` result (its `action` field) and encode it.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeClaimFromVerification(verified, { paymaster });
+ * ```
+ */
+declare function encodeClaimFromVerification(verified: {
+    action: "claimProject" | "reclaimProject";
+    attestation: ProjectClaimAttestation;
+}, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `executeReclaim(projectId)`: completes a pending claim or re-claim once its delay has passed (and before it
+ * expires, 30 days later).
+ *
+ * @example
+ * ```ts
+ * const tx = encodeExecuteReclaim(projectId, { paymaster });
+ * ```
+ */
+declare function encodeExecuteReclaim(projectId: Hex, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `cancelReclaim(projectId)`: the current owner cancels a pending re-claim, ONCE per new owner (a second
+ * attested re-claim by the same new owner cannot be cancelled). For a pending FIRST claim of an unowned project the
+ * contract owner or manager cancels instead.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeCancelReclaim(projectId, { paymaster });
+ * ```
+ */
+declare function encodeCancelReclaim(projectId: Hex, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `setTargets(projectId, targets, allowed)`: add or remove destination contracts the project sponsors
+ * (at most 50 per call). Owner only.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeSetTargets(projectId, [counter], true, { paymaster });
+ * ```
+ */
+declare function encodeSetTargets(projectId: Hex, targets: readonly Address[], allowed: boolean, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `setDailyLimit(projectId, limitWei)`: the project's total daily gas budget. Owner only. Must be above
+ * zero; a contract-side zero limit means nothing can be spent, and tightening is instant.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeSetDailyLimit(projectId, 5n * 10n ** 18n, { paymaster });
+ * ```
+ */
+declare function encodeSetDailyLimit(projectId: Hex, limitWei: bigint, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `setSenderDailyLimit(projectId, limitWei)`: the per-wallet daily gas limit. Owner only.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeSetSenderDailyLimit(projectId, 10n ** 17n, { paymaster });
+ * ```
+ */
+declare function encodeSetSenderDailyLimit(projectId: Hex, limitWei: bigint, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `setPaused(projectId, paused)`. Pausing takes effect immediately; it is the project's emergency stop.
+ *
+ * @example
+ * ```ts
+ * const stop = encodeSetPaused(projectId, true, { paymaster });
+ * ```
+ */
+declare function encodeSetPaused(projectId: Hex, paused: boolean, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `proposeProjectOwner(projectId, newOwner)`: step one of the two-step ownership transfer. The new
+ * owner must then call {@link encodeAcceptProjectOwnership}.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeProposeProjectOwner(projectId, newOwner, { paymaster });
+ * ```
+ */
+declare function encodeProposeProjectOwner(projectId: Hex, newOwner: Address, options?: PaymasterAddressOption): PaymasterCall;
+/**
+ * Encode `acceptProjectOwnership(projectId)`: step two of the ownership transfer, sent by the proposed owner.
+ *
+ * @example
+ * ```ts
+ * const tx = encodeAcceptProjectOwnership(projectId, { paymaster });
+ * ```
+ */
+declare function encodeAcceptProjectOwnership(projectId: Hex, options?: PaymasterAddressOption): PaymasterCall;
+interface ConfigureProjectParams extends PaymasterAddressOption {
+    /** Give `appId` or `projectId`. */
+    appId?: string;
+    projectId?: Hex;
+    /** Destination contracts to sponsor (the on-chain allowlist). 1 to 50. */
+    targets: readonly Address[];
+    /** Total daily budget, wei. */
+    dailyLimitWei: bigint;
+    /** Per-wallet daily budget, wei. */
+    senderDailyLimitWei: bigint;
+}
+/**
+ * The three post-claim configuration calls, in order: `setTargets(allowed = true)`, `setDailyLimit`,
+ * `setSenderDailyLimit`. A project spends nothing until all three have run. All three are owner-only calls to
+ * the same contract, so a smart account or batched wallet can send them in one transaction; an EOA sends them
+ * one after another with {@link sendPaymasterCalls}.
+ *
+ * @example
+ * ```ts
+ * const { calls } = configureProject({
+ *   appId, paymaster,
+ *   targets: [counter],
+ *   dailyLimitWei: 5n * 10n ** 18n,
+ *   senderDailyLimitWei: 10n ** 17n,
+ * });
+ * await smartAccountClient.sendUserOperation({ calls: calls.map(({ to, data, value }) => ({ to, data, value })) });
+ * ```
+ */
+declare function configureProject(params: ConfigureProjectParams): {
+    projectId: Hex;
+    calls: PaymasterCall[];
+};
+type SendingWallet = Pick<WalletClient, "sendTransaction"> & {
+    account?: Account | undefined;
+    chain?: Chain | undefined;
+};
+/**
+ * Send prepared calls one after another from a wallet client, returning the hashes. When `publicClient` is
+ * given it waits for each receipt first (so a later call is not sent after an earlier one failed). The
+ * transaction `value` is exactly the call's value; nothing else is added.
+ *
+ * @example
+ * ```ts
+ * const hashes = await sendPaymasterCalls(walletClient, calls, { publicClient });
+ * ```
+ */
+declare function sendPaymasterCalls(walletClient: SendingWallet, calls: readonly PaymasterCall[], options?: {
+    publicClient?: Pick<PublicClient, "waitForTransactionReceipt">;
+}): Promise<Hash[]>;
+interface DepositForParams extends PaymasterAddressOption {
+    walletClient: SendingWallet;
+    /** Give `appId` or `projectId`. */
+    appId?: string;
+    projectId?: Hex;
+    amountWei: bigint;
+    /**
+     * Default true: read the project first and refuse when it has no owner, which catches a mistyped (case-sensitive)
+     * app id before funds go to a project nobody controls. Needs `publicClient`. Pass false to fund a project its
+     * owner has not claimed yet (deposits are credited and become spendable after the claim and configuration).
+     */
+    requireClaimed?: boolean;
+    publicClient?: Pick<PublicClient, "readContract">;
+}
+/**
+ * Deposit native PEPU into a project with the caller's wallet. ONE-WAY: nobody can withdraw it afterwards, and
+ * anyone may deposit into any project. By default it first confirms the project is claimed.
+ *
+ * @example
+ * ```ts
+ * const hash = await depositFor({ walletClient, publicClient, appId, amountWei: 10n ** 18n, paymaster });
+ * ```
+ */
+declare function depositFor(params: DepositForParams): Promise<Hash>;
+
+/**
+ * REST client for the PEPU paymaster policy service: v1 (`/sponsor`, ERC-7677 at `/paymaster/<token>`) and
+ * v2 (`/v2/*`, tiered, on-chain projects). Isomorphic (plain `fetch`), so it is safe in a browser EXCEPT for
+ * the claim attestation call that carries a Privy app secret, which lives in `@pepu-chain/sdk/paymaster/server`.
+ *
+ * Contract: services/paymaster/policy-service/openapi.yaml and SPONSORSHIP-SPEC.md. Credentials: a server key
+ * (`ppk_...`, secret, any wallet) and a client token (`ppt_...`, publishable, bound to allowed origins).
+ */
+/** A quantity as the service accepts it: `0x` hex or bigint (converted for you). */
+type Quantity = Hex | bigint;
+/** The UserOperation fields `POST /sponsor` and `POST /v2/sponsor` read (EntryPoint v0.7, unpacked). */
+interface SponsorUserOp {
+    sender: Address;
+    nonce: Quantity;
+    factory?: Address;
+    factoryData?: Hex;
+    callData: Hex;
+    callGasLimit: Quantity;
+    verificationGasLimit: Quantity;
+    preVerificationGas: Quantity;
+    maxFeePerGas: Quantity;
+    maxPriorityFeePerGas: Quantity;
+}
+interface SponsorApproval {
+    status: "approved";
+    chainId: number;
+    paymaster: Address;
+    paymasterVerificationGasLimit: Hex;
+    paymasterPostOpGasLimit: Hex;
+    paymasterData: Hex;
+    validUntil: number;
+    validAfter: number;
+    /** EntryPoint's canonical userOpHash. */
+    userOpHash: Hex;
+    /** v2 only. */
+    sponsor?: {
+        kind: "project" | "free";
+        sponsorId: Hex;
+        projectKey: string;
+    };
+    /** v2 only: worst-case cost, decimal wei. */
+    maxCostWei?: string;
+}
+interface SponsorDenial {
+    status: "denied";
+    /** Machine-readable reason, see {@link PAYMASTER_DENIAL_REASONS}. */
+    reason: string;
+    message: string;
+    /** v2: per-tier reasons when both tiers were tried. */
+    detail?: {
+        project?: string;
+        free?: string;
+    };
+}
+type SponsorResult = SponsorApproval | SponsorDenial;
+/** Credentials for a sponsor call. */
+interface SponsorAuth {
+    /** The project's server key (`ppk_`) or client token (`ppt_`). Sent as `X-Api-Key`. */
+    apiKey: string;
+    /** The user's Privy access token. REQUIRED by v1 and by the v2 free tier. Sent as `Authorization: Bearer`. */
+    privyAccessToken?: string;
+    /** Origin header, for server-side calls with a client token (browsers set it themselves). */
+    origin?: string;
+}
+interface V2LoginResult {
+    token: string;
+    address: Address;
+    /** ISO timestamp. */
+    expiresAt: string;
+}
+type V2ConfigResponse = Record<string, unknown>;
+type V2FreeTierInfo = Record<string, unknown>;
+interface V2ContractInfo {
+    address: Address;
+    chainId: number;
+    entryPoint: Address;
+    abi: readonly unknown[];
+}
+/** `POST /v2/projects/prepare` response: a transaction for the owner's wallet to send. */
+interface PreparedTx {
+    chainId: number;
+    to: Address;
+    data: Hex;
+    /** Decimal wei string. */
+    value: string;
+    function: string;
+    description: string;
+}
+type Wei = string;
+type Bytes32 = Hex;
+/** Body of `POST /v2/projects/prepare`. */
+type PrepareRequest = {
+    action: "claimProject" | "reclaimProject";
+    attestation: SerializedAttestation;
+} | {
+    action: "depositFor";
+    projectId: Bytes32;
+    amountWei: Wei;
+} | {
+    action: "executeReclaim" | "cancelReclaim" | "acceptProjectOwnership";
+    projectId: Bytes32;
+} | {
+    action: "setTargets";
+    projectId: Bytes32;
+    targets: Address[];
+    allowed: boolean;
+} | {
+    action: "setDailyLimit" | "setSenderDailyLimit";
+    projectId: Bytes32;
+    limitWei: Wei;
+} | {
+    action: "setPaused";
+    projectId: Bytes32;
+    paused: boolean;
+} | {
+    action: "proposeProjectOwner";
+    projectId: Bytes32;
+    newOwner: Address;
+};
+/** Attestation in the service's wire format (decimal strings). */
+interface SerializedAttestation {
+    appId: string;
+    newOwner: Address;
+    nonce: string;
+    deadline: string;
+    signature: Hex;
+}
+interface RegisterProjectRequest {
+    /** Give `projectId` or `appId` (the id is keccak256(appId)). */
+    projectId?: Bytes32;
+    appId?: string;
+    perUserDailyCapWei?: Wei;
+    /** Opt in: refuse wallets without a verified Privy token. Default false (any wallet). */
+    requireIdentity?: boolean;
+    /** Plain origins (scheme://host[:port], http only for localhost). Max 20. None means server-key only. */
+    allowedOrigins?: string[];
+}
+interface RegisterProjectResponse {
+    /** Publishable client token (`ppt_...`), shown once. */
+    token: string;
+    /** ERC-7677 URL embedding the client token. */
+    paymasterUrl: string;
+    /** SECRET server key (`ppk_...`), shown once. Backend only. */
+    serverKey?: string;
+}
+interface ProjectSettings {
+    perUserDailyCapWei?: Wei;
+    requireIdentity?: boolean;
+    allowedOrigins?: string[];
+}
+interface ProjectDetail {
+    projectId: Bytes32;
+    appId: string | null;
+    indexed: boolean;
+    owner: Address;
+    onchain: {
+        balance: Wei;
+        spendable: Wei;
+        outstandingApprovals: Wei;
+        paused: boolean;
+        dailyLimit: Wei;
+        senderDailyLimit: Wei;
+        spentToday: Wei;
+        dailyRemaining: Wei;
+    };
+    adminChangeDelaySeconds: number | null;
+    allowlist: Address[] | null;
+    offchain: Record<string, unknown> | null;
+    usage24h: {
+        ops: number;
+        projectFundedWei: Wei;
+        freeTierFundedWei: Wei;
+    } | null;
+    contract: {
+        address: Address;
+        chainId: number;
+    };
+}
+/** Options for the low-level request escape hatch. */
+interface V2RequestOptions {
+    body?: unknown;
+    query?: Record<string, string | number | undefined>;
+    /** Send the stored SIWE session as a bearer token. Default false. */
+    session?: boolean;
+    /**
+     * Never put the service's message into thrown errors (only the HTTP status and error code). Set for calls whose
+     * request body holds a secret.
+     */
+    quietErrors?: boolean;
+}
+interface CreatePaymasterApiOptions {
+    /**
+     * Policy-service base URL (no trailing path). Defaults to `PEPU_PAYMASTER_URL` /
+     * `NEXT_PUBLIC_PEPU_PAYMASTER_URL`, then the hosted default once it exists.
+     */
+    baseUrl?: string;
+    /** Fetch implementation (tests, custom agents). Defaults to global `fetch`. */
+    fetch?: typeof fetch;
+    /** Environment for URL resolution. Defaults to `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** Request timeout in milliseconds. Default 15000. */
+    timeoutMs?: number;
+    /** Start with an existing SIWE session token. */
+    sessionToken?: string;
+}
+interface PaymasterApiV1 {
+    /** `POST /sponsor`. Needs the user's Privy access token and the app API key. */
+    sponsor(userOp: SponsorUserOp, auth: SponsorAuth): Promise<SponsorResult>;
+    /** `GET /health`. */
+    health(): Promise<{
+        status: string;
+    }>;
+    /** ERC-7677 URL for this service (`<base>/paymaster/<token>`). */
+    erc7677Url(appToken: string): string;
+}
+interface PaymasterApiV2 {
+    /** `POST /v2/sponsor`. Denials are returned (not thrown); use {@link assertApproved}. */
+    sponsor(userOp: SponsorUserOp, auth: SponsorAuth): Promise<SponsorResult>;
+    /** ERC-7677 URL for this service (`<base>/v2/paymaster/<token>`). */
+    erc7677Url(appToken: string): string;
+    config(): Promise<V2ConfigResponse>;
+    contract(): Promise<V2ContractInfo>;
+    freeTier(): Promise<V2FreeTierInfo>;
+    auth: {
+        nonce(): Promise<{
+            nonce: string;
+            expiresAt: string;
+        }>;
+        /** Stores the returned session token on this client. */
+        login(message: string, signature: Hex): Promise<V2LoginResult>;
+        logout(): Promise<void>;
+    };
+    /** `GET /v2/me`: the session address. */
+    me(): Promise<{
+        address: Address;
+    }>;
+    /**
+     * Full SIWE sign-in: nonce, EIP-4361 message, your signature, login. The session lasts 1 hour and is stored
+     * on this client.
+     */
+    loginWithWallet(sign: (message: string) => Promise<Hex>, o: LoginWithWalletOptions): Promise<V2LoginResult>;
+    /** Current session token, if signed in. */
+    getSessionToken(): string | null;
+    setSessionToken(token: string | null): void;
+    projects: {
+        /** `POST /v2/projects/prepare`: calldata for the owner's wallet. Sends nothing. */
+        prepare(request: PrepareRequest): Promise<PreparedTx>;
+        /** `POST /v2/projects`: index a claimed project and get its credentials. */
+        register(request: RegisterProjectRequest): Promise<RegisterProjectResponse>;
+        list(): Promise<{
+            projects: unknown[];
+            onchainUnindexed?: unknown[];
+        }>;
+        get(projectId: Hex): Promise<ProjectDetail>;
+        rotateClientToken(projectId: Hex): Promise<{
+            token: string;
+            paymasterUrl: string;
+            note?: string;
+        }>;
+        rotateServerKey(projectId: Hex): Promise<{
+            serverKey: string;
+            note?: string;
+        }>;
+        updateSettings(projectId: Hex, settings: ProjectSettings): Promise<Record<string, unknown>>;
+        usage(projectId: Hex, q?: {
+            limit?: number;
+            before?: number;
+        }): Promise<Record<string, unknown>>;
+        events(projectId: Hex, q?: {
+            fromBlock?: number;
+            limit?: number;
+        }): Promise<{
+            projectId: Hex;
+            events: unknown[];
+        }>;
+        allowlist(projectId: Hex): Promise<{
+            projectId: Hex;
+            source: string;
+            targets: Address[];
+        }>;
+    };
+    /**
+     * Low-level call to any `/v2` path, with the same error mapping. Used by `@pepu-chain/sdk/paymaster/server`
+     * for `POST /v2/projects/verify`. Prefer the typed methods.
+     */
+    request<T>(method: "GET" | "POST" | "PATCH", path: string, options?: V2RequestOptions): Promise<T>;
+}
+interface PaymasterApi {
+    /** Resolved base URL, no trailing slash. */
+    readonly baseUrl: string;
+    v1: PaymasterApiV1;
+    v2: PaymasterApiV2;
+}
+interface LoginWithWalletOptions {
+    /** The signing wallet's address. */
+    address: Address;
+    /** SIWE domain; must be one of the service's `SIWE_DOMAINS` (for example `app.example.com`). */
+    domain: string;
+    /** SIWE `uri`. Default `https://<domain>`. */
+    uri?: string;
+    /** Chain id in the message. Default 97741. */
+    chainId?: number;
+    statement?: string;
+    /** Message lifetime in seconds (service maximum is 600 by default). Default 300. */
+    lifetimeSeconds?: number;
+    now?: () => number;
+}
+/** `"client"` for `ppt_` tokens, `"server"` for `ppk_` keys, otherwise `null`. Never inspects beyond the prefix. */
+declare function credentialKind(credential: string): "client" | "server" | null;
+interface BuildErc7677UrlOptions {
+    /** Policy-service base URL. */
+    baseUrl: string;
+    /** Client token (`ppt_`, browser-safe) or server key (`ppk_`, secret). */
+    token: string;
+    /** Default 2. v1 serves `/paymaster/<token>`, v2 serves `/v2/paymaster/<token>`. */
+    version?: 1 | 2;
+}
+/**
+ * Build the ERC-7677 paymaster URL for a project credential (paste it into a Privy "Paymaster URL" or pass it
+ * to a viem paymaster client). Refuses a server key (`ppk_`) in a browser, because the URL embeds it.
+ *
+ * @example
+ * ```ts
+ * const url = buildErc7677Url({ baseUrl: "https://paymaster.example.com", token: "ppt_abc" });
+ * // https://paymaster.example.com/v2/paymaster/ppt_abc
+ * ```
+ */
+declare function buildErc7677Url(options: BuildErc7677UrlOptions): string;
+/**
+ * The hosted ERC-7677 URL for a project credential: `<hosted base>/v2/paymaster/<token>`.
+ * Pass the project's client token (`ppt_`, browser-safe); a server key is refused in a browser.
+ *
+ * @example
+ * const url = hostedErc7677Url("ppt_abc");
+ * // https://paymaster.pepeunchained.com/v2/paymaster/ppt_abc
+ */
+declare function hostedErc7677Url(token: string): string;
+/**
+ * Turn a sponsor result into the approval, or throw the mapped {@link PepuPaymasterError}
+ * (`project_not_claimed_onchain` becomes `PAYMASTER_PROJECT_NOT_CLAIMED`, and so on).
+ *
+ * @example
+ * ```ts
+ * const approval = assertApproved(await api.v2.sponsor(userOp, { apiKey }));
+ * ```
+ */
+declare function assertApproved(result: SponsorResult): SponsorApproval;
+/**
+ * Create the paymaster REST client.
+ *
+ * @example
+ * ```ts
+ * const api = createPaymasterApi({ baseUrl: "https://paymaster.example.com" });
+ * const free = await api.v2.freeTier();
+ * const result = await api.v2.sponsor(userOp, { apiKey: process.env.PEPU_SERVER_KEY!, privyAccessToken });
+ * if (result.status === "denied") console.log(result.reason);
+ * ```
+ */
+declare function createPaymasterApi(options?: CreatePaymasterApiOptions): PaymasterApi;
+/** Serialize a typed attestation into the wire format for `projects.prepare`. */
+declare function serializeAttestation(a: ProjectClaimAttestation): SerializedAttestation;
+
+export { resolvePaymasterV2Address as $, createPaymasterApi as A, type BuildErc7677UrlOptions as B, type ConfigureProjectParams as C, type DepositForParams as D, credentialKind as E, depositFor as F, encodeAcceptProjectOwnership as G, encodeCancelReclaim as H, encodeClaimFromVerification as I, encodeClaimProject as J, encodeDeposit as K, type LoginWithWalletOptions as L, encodeExecuteReclaim as M, encodeProposeProjectOwner as N, encodeReclaimProject as O, type ProjectClaimAttestation as P, type Quantity as Q, type ReadProjectOptions as R, type SerializedAttestation as S, encodeSetDailyLimit as T, encodeSetPaused as U, type V2ConfigResponse as V, encodeSetSenderDailyLimit as W, encodeSetTargets as X, getProjectId as Y, hostedErc7677Url as Z, readProject as _, type PaymasterApi as a, sendPaymasterCalls as a0, serializeAttestation as a1, type CreatePaymasterApiOptions as b, type PaymasterAddressOption as c, type PaymasterApiV1 as d, type PaymasterApiV2 as e, type PaymasterCall as f, type PrepareRequest as g, type PreparedTx as h, type ProjectDetail as i, type ProjectSettings as j, type ProjectState as k, type RegisterProjectRequest as l, type RegisterProjectResponse as m, type SponsorApproval as n, type SponsorAuth as o, type SponsorDenial as p, type SponsorResult as q, type SponsorUserOp as r, type V2ContractInfo as s, type V2FreeTierInfo as t, type V2LoginResult as u, type V2RequestOptions as v, assertApproved as w, buildErc7677Url as x, computeProjectId as y, configureProject as z };