@pepu-chain/sdk 0.0.0-stage → 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,2398 @@
+import { P as PepuChain } from './chains-DK13zGIp.cjs';
+export { a as PepuChainId, i as isPepuChain, p as pepuChains, b as pepuMainnet, c as pepuTestnet } from './chains-DK13zGIp.cjs';
+import { j as ContractEntry, D as DeployedContract } from './status-CmOsyPmO.cjs';
+export { C as CheckSponsorshipOptions, G as GetSponsorshipStatusOptions, k as PendingContract, l as PepuAddressRow, m as PepuContractName, n as PepuContractRegistry, a as PepuKernelStack, S as SponsorshipReport, c as SponsorshipStatus, d as checkSponsorship, o as getContract, g as getKernelAccountAddress, q as getPepuAddresses, f as getPepuKernelStack, h as getSponsorshipStatus, r as isDeployed, s as listContracts, t as pepuContracts } from './status-CmOsyPmO.cjs';
+import { Address, Transport, PublicClient, Abi, EIP1193Provider, AddEthereumChainParameter, TransactionRequest, Hex, ContractFunctionParameters, MulticallReturnType, TypedDataDomain } from 'viem';
+export { erc20Abi, erc721Abi } from 'viem';
+export { B as BuildPaymasterRequestOptions, E as Erc7677UserOperation, P as PaymasterContext, a as PaymasterDataRequest, b as PaymasterDataResult, c as PaymasterRpcError, d as PaymasterRpcParams, e as PaymasterRpcResponse, f as PaymasterStubDataRequest, g as PaymasterStubDataResult, h as buildPaymasterContext, i as buildPaymasterDataRequest, j as buildPaymasterStubDataRequest } from './erc7677-DOW58QBE.cjs';
+export { E as ErrorCatalogEntry, d as ErrorExplanation, e as PEPU_ERRORS_DOCS_URL, f as PEPU_ERROR_CATALOG, g as PepuAuthError, a as PepuBundlerError, h as PepuChainError, i as PepuConfigError, P as PepuError, c as PepuErrorCode, j as PepuErrorOptions, b as PepuPaymasterError, k as PepuPolicyError, l as PepuSessionError, m as errorDocsUrl, n as explainError, o as getErrorEntry, t as toErrorBody, p as toErrorResponse, q as toPepuError } from './errors-CgX1vNj7.cjs';
+
+/**
+ * PepuSwap is PEPU's flagship DEX and a Uniswap V3 fork. This registry is
+ * deliberately separate from {@link pepuContracts} in `contracts.ts`:
+ * `pepuContracts` tracks *chain infrastructure* (things any app might rely
+ * on — Multicall3, the AA stack), while this tracks *one specific
+ * application's* deployment. Mixing the two would make `pepuContracts`
+ * ambiguous about what counts as "the chain" versus "a dapp on the chain."
+ *
+ * Mainnet only — PepuSwap has no testnet deployment, and testnet (97740) is
+ * out of scope for this package regardless (no faucet exists to fund
+ * verification there).
+ *
+ * Every address below was independently verified on 2026-09-24 with both
+ * an `eth_getCode` check (non-empty bytecode) and a successful `eth_call`
+ * against a real function — see the doc comment on that contract's ABI file
+ * in `./abi/` for the exact call and response. Two addresses
+ * (`multicallNonCanonical`, `permit2NonCanonical`) are PepuSwap-specific
+ * overrides of otherwise-canonical contracts; do not confuse them with
+ * {@link pepuContracts}'s `multicall3`/`permit2` entries, which track the
+ * *canonical* versions of those same standards.
+ */
+type PepuSwapContractName = "v3Factory" | "swapRouter02" | "universalRouter" | "positionManager" | "quoterV2" | "tickLens" | "v3Migrator" | "v3Staker" | "multicallNonCanonical" | "permit2NonCanonical";
+declare const pepuSwapContracts: Readonly<Record<number, Readonly<Record<PepuSwapContractName, ContractEntry>>>>;
+/** Look up one PepuSwap contract entry for a chain id. */
+declare function getPepuSwapContract(chainId: number, name: PepuSwapContractName): ContractEntry | undefined;
+/** List every tracked PepuSwap contract entry for a chain id, in registry order. */
+declare function listPepuSwapContracts(chainId: number): readonly ContractEntry[];
+
+/**
+ * Shape mirrors the `TokenInfo` definition in the Uniswap Token List
+ * schema (https://uniswap.org/tokenlist.schema.json). Kept as a local
+ * type (rather than importing one from `@uniswap/token-lists`) so
+ * consumers of `@pepu-chain/sdk` never need that package installed just to
+ * typecheck.
+ */
+interface PepuTokenInfo {
+    readonly chainId: number;
+    readonly address: Address;
+    readonly name: string;
+    readonly symbol: string;
+    readonly decimals: number;
+    readonly logoURI?: string;
+    readonly tags?: readonly string[];
+}
+/** Shape mirrors the top-level Uniswap Token List schema. */
+interface PepuTokenList {
+    readonly name: string;
+    readonly timestamp: string;
+    readonly version: {
+        readonly major: number;
+        readonly minor: number;
+        readonly patch: number;
+    };
+    readonly tokens: readonly PepuTokenInfo[];
+    readonly keywords?: readonly string[];
+}
+/**
+ * Canonical Pepe Unchained V2 token list, conforming to the Uniswap Token
+ * List schema (see `test/tokens.test.ts` for schema validation against a
+ * vendored copy of https://uniswap.org/tokenlist.schema.json).
+ *
+ * Deliberately minimal: every entry below is a token address independently
+ * verified on-chain (see each entry's inline note), not copied from docs or
+ * a third-party list without cross-checking. No other token address met
+ * that bar at the time this list was written, and none are included here
+ * as placeholders. See the README's "Known gaps" section.
+ *
+ * There is no verified token address for testnet (chain 97740) yet, so
+ * this list currently only covers mainnet.
+ */
+declare const pepuTokenList: PepuTokenList;
+
+/**
+ * Create a viem `PublicClient` for a Pepe Unchained V2 chain, defaulting
+ * its transport to the chain's first `rpcUrls.default.http` entry.
+ *
+ * Pass `transport` to use a different RPC endpoint (e.g. an authenticated
+ * provider URL) while keeping the rest of the chain definition.
+ */
+declare function getPublicClient(chain: PepuChain, options?: {
+    transport?: Transport;
+}): PublicClient<Transport, PepuChain>;
+
+/** Resource types supported by Blockscout's URL scheme. */
+type ExplorerResourceType = "tx" | "address" | "token" | "block";
+/**
+ * Build a Blockscout explorer URL for a transaction hash, address, token
+ * address, or block (by number or hash) on a Pepe Unchained V2 chain.
+ *
+ * Throws if the given chain has no `blockExplorers.default` configured
+ * (this is currently the case for {@link pepuTestnet} — see `chains.ts`
+ * for why).
+ */
+declare function explorerUrl(chain: PepuChain, type: ExplorerResourceType, value: string | number): string;
+/** Build a transaction-page URL. Shorthand for `explorerUrl(chain, "tx", hash)`. */
+declare function txUrl(chain: PepuChain, hash: string): string;
+/** Build an address-page URL. Shorthand for `explorerUrl(chain, "address", address)`. */
+declare function addressUrl(chain: PepuChain, address: string): string;
+/** Build a token-page URL. Shorthand for `explorerUrl(chain, "token", address)`. */
+declare function tokenUrl(chain: PepuChain, address: string): string;
+/** Build a block-page URL, by block number or block hash. Shorthand for `explorerUrl(chain, "block", value)`. */
+declare function blockUrl(chain: PepuChain, blockNumberOrHash: string | number): string;
+/**
+ * Convenience bundle of explorer links. pepuscan (Blockscout) has no UserOp
+ * pages, so a UserOperation is linked through its bundle `tx` and its
+ * `sender` (the smart account address).
+ *
+ * @example
+ * ```ts
+ * explorerLinks({ tx: "0xabc", sender: "0xdef" });
+ * // { tx: "https://pepuscan.com/tx/0xabc", sender: "https://pepuscan.com/address/0xdef" }
+ * ```
+ */
+declare function explorerLinks(o: {
+    tx?: string;
+    address?: string;
+    sender?: string;
+    token?: string;
+    block?: bigint | number | string;
+}, chain?: PepuChain): {
+    tx?: string;
+    address?: string;
+    sender?: string;
+    token?: string;
+    block?: string;
+};
+
+/**
+ * A minimal client for pepuscan's (Blockscout's) public REST API —
+ * deliberately narrow: **verified-ABI and token-metadata reads only**.
+ * Blockscout's API surface is large (transaction history, logs, internal
+ * txs, NFTs, account-abstraction data, ...); re-wrapping all of it here
+ * would duplicate `@pepu-chain/mcp` (the Blockscout MCP server), which is the
+ * right place for that. This client exists only for the two lookups a
+ * dapp commonly needs synchronously and that this package's own ABI/token
+ * modules can't provide (an address this package hasn't independently
+ * verified, or a token not yet in {@link pepuTokenList}).
+ *
+ * Uses the platform `fetch` (Node 18+, every evergreen browser) — no HTTP
+ * client dependency.
+ */
+interface PepuscanClient {
+    /**
+     * Fetch a contract's verified ABI from pepuscan. Resolves `null` if the
+     * contract is not verified (a 404 from Blockscout's
+     * `/v2/smart-contracts/{address}`) rather than throwing, since "not
+     * verified" is an expected, ordinary result — not an error.
+     */
+    getVerifiedAbi(address: Address): Promise<Abi | null>;
+    /**
+     * Fetch a token's on-chain metadata from pepuscan
+     * (`/v2/tokens/{address}`). Resolves `null` if pepuscan has no record of
+     * the address as a token (a 404) — the address may still be a valid
+     * contract; it just isn't a token Blockscout has indexed as one.
+     */
+    getTokenMetadata(address: Address): Promise<PepuscanTokenMetadata | null>;
+}
+/** Token metadata as reported by pepuscan's `/v2/tokens/{address}`. */
+interface PepuscanTokenMetadata {
+    readonly address: Address;
+    readonly name: string | null;
+    readonly symbol: string | null;
+    /** `null` for token types that don't have a fixed decimals field (e.g. most ERC-721s). */
+    readonly decimals: number | null;
+    readonly totalSupply: string | null;
+    /** Blockscout's token type string, e.g. `"ERC-20"`, `"ERC-721"`, `"ERC-1155"`. */
+    readonly type: string | null;
+}
+/**
+ * Create a {@link PepuscanClient} bound to a {@link PepuChain}'s configured
+ * Blockscout API URL (`chain.blockExplorers.default.apiUrl`). Throws
+ * immediately if the chain has none configured (currently
+ * {@link pepuTestnet} — see `chains.ts`) rather than deferring the failure
+ * to the first call.
+ */
+declare function createPepuscanClient(chain: PepuChain): PepuscanClient;
+
+/**
+ * Build the parameter object for an EIP-3085 `wallet_addEthereumChain`
+ * request from a {@link PepuChain}, so callers don't have to hand-assemble
+ * (and risk mistyping) `chainId` hex encoding, `nativeCurrency`, RPC URLs,
+ * and explorer URLs themselves.
+ *
+ * Omits `blockExplorerUrls` entirely when the chain has no configured
+ * explorer (currently {@link pepuTestnet} — see `chains.ts`) rather than
+ * sending an empty array or a guessed URL.
+ */
+declare function toAddEthereumChainParameter(chain: PepuChain): AddEthereumChainParameter;
+/**
+ * Switch an EIP-1193 provider (e.g. `window.ethereum`) to a
+ * {@link PepuChain}, adding it first via `wallet_addEthereumChain` if the
+ * wallet doesn't already recognize the chain (error code `4902` per
+ * EIP-3326) — the two-step dance almost every dapp ends up hand-rolling.
+ *
+ * If you already have a viem `WalletClient`, its own `switchChain`/`addChain`
+ * actions work the same way at the RPC level; this helper is for the plainer
+ * "I just have an injected provider" case and does the fallback viem's
+ * `switchChain` alone does not (see `viem/actions`' `switchChain.js` — it
+ * only ever sends `wallet_switchEthereumChain`).
+ *
+ * Rethrows any other error unchanged (e.g. the user rejecting either
+ * prompt), and rethrows the original switch error if the wallet doesn't
+ * report the standard `4902` code for an unrecognized chain — some wallets
+ * are known to deviate from the EIP-3326 error code, and this helper does
+ * not attempt to paper over that.
+ */
+declare function switchOrAddPepuChain(provider: EIP1193Provider, chain: PepuChain): Promise<void>;
+
+/**
+ * PEPU's two-part Nitro gas price, read live from the `ArbGasInfo`
+ * precompile (`0x...6C`, fixed on every Arbitrum Orbit/Nitro chain). See
+ * {@link explainDualFeeModel} for what each field means and why, on PEPU
+ * specifically, one of them is currently zero.
+ */
+interface NitroFeeBreakdown {
+    /**
+     * L2 execution price, in wei per gas unit. This is `perArbGasTotal` from
+     * `getPricesInWei()` — `perArbGasBase` (the network's floor) plus
+     * `perArbGasCongestion` (demand surcharge, `0` when the chain isn't
+     * congested). Tracks the block's own `baseFeePerGas`.
+     */
+    readonly l2PricePerGasWei: bigint;
+    /**
+     * L1 data-posting price, in wei per L1-calldata-unit (`perL1CalldataUnit`
+     * from `getPricesInWei()`). Verified `0` on PEPU mainnet as of
+     * 2026-09-24 — see {@link explainDualFeeModel}.
+     */
+    readonly l1PricePerCalldataUnitWei: bigint;
+    /**
+     * `ArbGasInfo`'s own estimate of the L1 base fee it would need to post
+     * data at, in wei. Verified `0` on PEPU mainnet as of 2026-09-24,
+     * consistent with `l1PricePerCalldataUnitWei` being `0`.
+     */
+    readonly l1BaseFeeEstimateWei: bigint;
+}
+/**
+ * Read the current {@link NitroFeeBreakdown} from the `ArbGasInfo`
+ * precompile. One `eth_call` (`getPricesInWei()`) plus one more
+ * (`getL1BaseFeeEstimate()`) — no caching, since these can change block to
+ * block under load.
+ */
+declare function getNitroFeeBreakdown(client: PublicClient<Transport, PepuChain>): Promise<NitroFeeBreakdown>;
+/** Plain-English explanation of Arbitrum Nitro's dual-fee model, as it currently behaves on PEPU. */
+interface DualFeeModelExplanation {
+    readonly summary: string;
+    readonly l2ExecutionFee: string;
+    readonly l1DataPostingFee: string;
+    readonly pepuStatus: string;
+}
+/**
+ * Explain Arbitrum Nitro's dual-fee gas model in plain English, including
+ * how it currently behaves on PEPU specifically (verified live against
+ * mainnet 2026-09-24 — see the doc comment on `arbGasInfoAbi` in
+ * `./abi/arbGasInfo.ts` for the exact call and response this is based on).
+ *
+ * This is a static explanation (no network call) — pair it with
+ * {@link getNitroFeeBreakdown} for live numbers.
+ */
+declare function explainDualFeeModel(): DualFeeModelExplanation;
+/** Result of {@link estimateTransactionCost}. */
+interface TransactionCostEstimate {
+    /** Estimated gas units, from `client.estimateGas`. */
+    readonly gas: bigint;
+    /** L2 execution price per gas unit, in wei, used for this estimate. */
+    readonly gasPriceWei: bigint;
+    /** `gas * gasPriceWei`, in wei. Does not include an L1 data-posting fee — see {@link explainDualFeeModel}. */
+    readonly costWei: bigint;
+    /** {@link costWei} formatted with {@link formatPepu}, for direct display. */
+    readonly costFormatted: string;
+}
+/**
+ * Estimate a transaction's PEPU cost: `client.estimateGas(request)` for the
+ * gas units, multiplied by the current L2 execution price
+ * (`getNitroFeeBreakdown`'s `l2PricePerGasWei`, which tracks the latest
+ * block's `baseFeePerGas`).
+ *
+ * Deliberately excludes any L1 data-posting fee — see
+ * {@link explainDualFeeModel} for why that component reads as `0` on PEPU
+ * today, and re-derive this estimate if that ever changes.
+ */
+declare function estimateTransactionCost(client: PublicClient<Transport, PepuChain>, request: TransactionRequest & {
+    account?: Address;
+}): Promise<TransactionCostEstimate>;
+/** Options for {@link formatPepu}. */
+interface FormatPepuOptions {
+    /**
+     * Maximum fractional digits to keep after trimming trailing zeros.
+     * Default `8` — high enough that typical PEPU gas costs (a low-value
+     * token at a 12,500 gwei base fee) don't round down to `"0"`, which is
+     * exactly the failure mode a default ETH-style 4-decimal formatter hits
+     * here.
+     */
+    readonly maxDecimals?: number;
+    /** Append `" PEPU"` to the result. Default `true`. */
+    readonly suffix?: boolean;
+}
+/**
+ * Format a wei amount as PEPU, tuned for a low-value token on a chain with
+ * a comparatively large (12,500 gwei) base fee — see
+ * {@link explainDualFeeModel}. Plain `formatEther`-style formatting (a
+ * handful of decimal places, as is reasonable for ETH) collapses typical
+ * PEPU amounts to `"0.0000"`; this keeps up to `maxDecimals` significant
+ * fractional digits instead, trimming only trailing zeros.
+ *
+ * This is a display formatter, not an arbitrary-precision one — it does
+ * not round-trip back to the exact wei value, and is not meant to.
+ */
+declare function formatPepu(wei: bigint, options?: FormatPepuOptions): string;
+/**
+ * Format any token amount (smallest unit) as a short decimal string, for any
+ * `decimals`. Truncates (never rounds) to `maxFractionDigits` (default 4) and
+ * trims trailing zeros, like {@link formatPepu} but without the PEPU suffix and
+ * 18-decimals assumption. Display only: it does not round-trip.
+ *
+ * @example
+ * formatUnitsCompact(1_234_567n, 6); // "1.2345"
+ * formatUnitsCompact(5n * 10n ** 18n, 18); // "5"
+ */
+declare function formatUnitsCompact(value: bigint, decimals: number, maxFractionDigits?: number): string;
+/**
+ * Format a wei-per-gas price for display, with an explicit note that
+ * PEPU's baseline (~12,500 gwei) is not a congestion spike — see
+ * {@link explainDualFeeModel}. Bare "N gwei" output, without that context,
+ * is exactly the naive formatting this package's brief calls out as
+ * misleading for PEPU.
+ */
+declare function formatPepuGasPrice(weiPerGas: bigint): string;
+/**
+ * Default safety margin applied on top of a raw gas estimate before
+ * {@link maxSendableAmount} computes its answer, in basis points
+ * (`2000` = 20%).
+ *
+ * Why a margin at all: the L2 price behind {@link estimateTransactionCost}
+ * (`ArbGasInfo.getPricesInWei().perArbGasTotal`) is read live and tracks
+ * the *current* block's `baseFeePerGas`. A "max send" button estimates
+ * cost, fills `balance - cost` into the amount field, and then waits for
+ * the user to review and confirm — by the time the signed transaction
+ * actually lands, at least one block (often more, if the user pauses to
+ * look at the number) has passed, and the price can have moved in that
+ * gap. Spending every last wei on `value` against a stale estimate is
+ * exactly the failure this button exists to prevent: a transaction that
+ * reverts for insufficient funds after the user was told this amount was
+ * safe.
+ *
+ * Why 20% specifically: this repo already uses a 20% margin for the
+ * sibling problem of gas-*limit* drift between estimate and execution
+ * (`templates/game-app/lib/tap-transaction.ts`'s `withGasLimitBuffer`),
+ * and that figure — a standard, conservative buffer used broadly across
+ * production transaction-sending code, not one tuned from measured PEPU
+ * data — is reused here for gas-*price* drift for the same reason. Two
+ * things make being generous here cheap specifically on PEPU: (1) this
+ * package has only ever observed PEPU's base fee sitting flat at a
+ * 12,500 gwei floor with a `0` congestion surcharge (see
+ * {@link explainDualFeeModel}), so the realistic gap this margin covers
+ * is currently close to zero; and (2) PEPU is a low-value token, so 20%
+ * of an already-tiny gas cost is an even tinier absolute amount left
+ * unspent. If PEPU's fee market ever becomes genuinely congested
+ * (`perArbGasCongestion` reading nonzero), re-derive this default from
+ * observed volatility rather than assuming 20% still covers it.
+ */
+declare const DEFAULT_MAX_SEND_MARGIN_BPS = 2000;
+/** Options for {@link maxSendableAmount}. */
+interface MaxSendableAmountOptions {
+    /** Client to estimate gas against. */
+    readonly client: PublicClient<Transport, PepuChain>;
+    /**
+     * The sender's address — used as `estimateGas`'s `account`, and (when
+     * {@link MaxSendableAmountOptions.to} is omitted) as the estimate's
+     * destination too. See `to`'s doc comment.
+     */
+    readonly from: Address;
+    /**
+     * The transfer's real destination, if the user has typed one in yet.
+     * Estimating against the *actual* recipient matters whenever it's a
+     * contract with a `receive()`/`fallback()` that does real work — a
+     * generic placeholder address would silently under-estimate that case.
+     *
+     * Omit this (or don't call {@link maxSendableAmount} at all yet — the
+     * caller decides when a "recipient" is valid enough to estimate
+     * against) before the user has entered a recipient. This function then
+     * falls back to estimating a self-transfer (`to: from`), the best
+     * available stand-in for "a plain native transfer to *some* EOA," which
+     * is what most PEPU sends are.
+     */
+    readonly to?: Address;
+    /**
+     * The sender's current native balance, in wei (e.g. from wagmi's
+     * `useBalance` or viem's `getBalance`).
+     */
+    readonly balanceWei: bigint;
+    /**
+     * Safety margin on top of the raw estimated cost, in basis points.
+     * Default {@link DEFAULT_MAX_SEND_MARGIN_BPS} — see its doc comment for
+     * why 20%. Must be an integer in `[0, 10000]`.
+     */
+    readonly marginBps?: number;
+}
+/**
+ * Result of {@link maxSendableAmount} — a discriminated union on `status`
+ * so callers can't accidentally read `amountWei` off a result where there
+ * isn't one.
+ */
+type MaxSendableAmountResult = {
+    readonly status: "ok";
+    /** The amount safe to fill into a "Max" field: `balanceWei - totalReservedWei`. Always `> 0n`. */
+    readonly amountWei: bigint;
+    /** The gas estimate this result was computed from. */
+    readonly estimate: TransactionCostEstimate;
+    /** The safety margin on top of `estimate.costWei`, in wei. */
+    readonly marginWei: bigint;
+    /** `estimate.costWei + marginWei` — the total withheld from `balanceWei`. */
+    readonly totalReservedWei: bigint;
+} | {
+    /** `balanceWei` was `0` (or negative) — nothing to size a transfer from, no network call was made. */
+    readonly status: "zero-balance";
+    /** Human-readable explanation, safe to render directly. */
+    readonly reason: string;
+} | {
+    /** `balanceWei` doesn't cover even `estimate.costWei` plus the margin — a "max" send would be `<= 0`. */
+    readonly status: "insufficient-for-gas";
+    /** Human-readable explanation, safe to render directly. */
+    readonly reason: string;
+    /** The gas estimate this result was computed from. */
+    readonly estimate: TransactionCostEstimate;
+    /** `estimate.costWei + marginWei` — what the balance would have needed to cover. */
+    readonly totalReservedWei: bigint;
+};
+/**
+ * Compute the largest amount a sender can put in a native transfer's
+ * `value` and still expect it to succeed: `balance - estimatedCost -
+ * safetyMargin`.
+ *
+ * This is deliberately not `balance - gasLimit * gasPrice` computed by
+ * hand — see {@link explainDualFeeModel} for why that naive formula is
+ * wrong on an Arbitrum Nitro chain like PEPU in general (a second,
+ * L1-data-posting fee component can apply on top of L2 execution). In
+ * practice this function sidesteps the whole question by never
+ * reimplementing Nitro's fee math itself: it hands the real transfer off
+ * to {@link estimateTransactionCost}, which calls the chain's own
+ * `eth_estimateGas` (Nitro-aware by construction — the node, not this
+ * package, knows its own fee model) and reads the live L2 price from the
+ * `ArbGasInfo` precompile. If PEPU ever starts charging a nonzero L1
+ * component too, `estimateTransactionCost` documents exactly where that
+ * would need to be added, and this function inherits the fix for free.
+ *
+ * THE CIRCULARITY THIS AVOIDS: the whole point of this call is to
+ * discover what the max `value` should be, so it can't estimate gas
+ * using that unknown value. It also can't reuse `balanceWei` as a stand-in
+ * `value` for the estimate — most RPCs simulate `eth_estimateGas` against
+ * the sender's real current balance, and a `value` equal to the full
+ * balance leaves exactly `0` left over to cover the fee with, so the
+ * simulation would itself fail with "insufficient funds" instead of
+ * returning a usable number. Instead, this estimates with a nominal `1n`
+ * wei placeholder. That's a safe stand-in because, for a plain native
+ * transfer (no calldata), gas usage doesn't depend on *how much* value
+ * moves — only on whether `to` has code that reacts to receiving value at
+ * all, which `1n` (any nonzero amount) already exercises. The one case
+ * this can still under-estimate: a recipient contract whose
+ * `receive()`/`fallback()` branches on the exact `msg.value` it got
+ * (e.g. cheaper for small amounts, pricier for large ones) — an inherent
+ * limit of estimating "the max" before the max is known, not specific to
+ * this implementation.
+ *
+ * Handles the edge cases a naive subtraction gets wrong:
+ * - `balanceWei <= 0n` → `{ status: "zero-balance" }`, no network call.
+ * - `balanceWei` covers less than `estimate.costWei` plus the margin →
+ *   `{ status: "insufficient-for-gas" }` rather than a negative or `0`
+ *   amount.
+ * - Estimation itself failing (bad RPC, reverting recipient, etc.) →
+ *   this function does not catch that; the returned promise rejects with
+ *   whatever `estimateTransactionCost`/`client.estimateGas` threw, so a
+ *   caller can show the real reason instead of silently falling back to a
+ *   guess.
+ *
+ * NOT WIRED INTO `templates/consumer-app`: that template's send form
+ * dropped its "Max" button rather than consume this helper. The reason
+ * isn't a bug here — it's that Privy's transaction confirmation modal
+ * runs its own, separately-implemented pre-flight balance check before
+ * signing, and on PEPU that check has been observed to be over-conservative
+ * enough to reject a transfer this function correctly sized as affordable
+ * (e.g. a 0.7748 PEPU balance refused for a 0.2625 PEPU transfer). Since
+ * Privy's modal has the final say on whether the transaction goes out, a
+ * "Max" fill computed by this function can still bounce there, which makes
+ * the button promise something the wallet UI can't reliably deliver. This
+ * function stays correct and is still the right tool for any PEPU wallet
+ * UI that isn't routing its send flow through Privy's modal — just don't
+ * assume the absence of a "Max" button in that one template means this
+ * helper is unused or unmaintained.
+ */
+declare function maxSendableAmount(options: MaxSendableAmountOptions): Promise<MaxSendableAmountResult>;
+
+/**
+ * Arbitrum Nitro's `ArbGasInfo` precompile — lives at the same fixed address
+ * on every Arbitrum Orbit/Nitro chain, including PEPU. Exposes the L2
+ * execution / L1 data-posting fee breakdown that {@link explainDualFeeModel}
+ * (`../gas.js`) describes.
+ *
+ * Verified live against PEPU mainnet 2026-09-24 via `eth_call`:
+ * - `getPricesInWei()` returns `(perL2Tx: 0, perL1CalldataUnit: 0,
+ *   perStorageAllocation: 250000000000000000, perArbGasBase: 12500000000000,
+ *   perArbGasCongestion: 0, perArbGasTotal: 12500000000000)`. `perArbGasBase`
+ *   / `perArbGasTotal` (12,500 gwei) match the block's own `baseFeePerGas`
+ *   at the same height, and `perL1CalldataUnit` is `0` — see the module doc
+ *   on `../gas.js` for what that means for PEPU's L1 data-posting fee today.
+ * - `getL1BaseFeeEstimate()` returns `0`, consistent with the same reading.
+ */
+declare const arbGasInfoAbi: readonly [{
+    readonly name: "getPricesInWei";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "perL2Tx";
+    }, {
+        readonly type: "uint256";
+        readonly name: "perL1CalldataUnit";
+    }, {
+        readonly type: "uint256";
+        readonly name: "perStorageAllocation";
+    }, {
+        readonly type: "uint256";
+        readonly name: "perArbGasBase";
+    }, {
+        readonly type: "uint256";
+        readonly name: "perArbGasCongestion";
+    }, {
+        readonly type: "uint256";
+        readonly name: "perArbGasTotal";
+    }];
+}, {
+    readonly name: "getL1BaseFeeEstimate";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "getMinimumGasPrice";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+/**
+ * Fixed address of the `ArbGasInfo` precompile. Identical on every
+ * Arbitrum Orbit/Nitro chain (it's a precompile, not a deployed contract),
+ * confirmed responding on PEPU mainnet as noted above.
+ */
+declare const ARB_GAS_INFO_ADDRESS: "0x000000000000000000000000000000000000006C";
+
+/**
+ * ERC-4337 EntryPoint v0.7 ABI — the subset a dapp actually needs to manage
+ * a smart account's gas deposit and read its nonce, at the canonical address
+ * `0x0000000071727De22E5E9d8BAf0edAc6f37da032` (deployed on PEPU mainnet
+ * only; see `pepuContracts.entryPoint07` in `../contracts.js`).
+ *
+ * This is NOT the full `IEntryPoint` interface (no `handleOps`,
+ * `simulateValidation`, etc.) — those are normally called by a bundler, and
+ * PEPU has no publicly hosted bundler yet (see `getSponsorshipStatus` in
+ * `../aa/status.js`). This ABI only covers deposit/nonce management, which works
+ * today with a plain viem wallet client and no bundler at all.
+ *
+ * Verified live against mainnet 2026-09-24 via `eth_call`:
+ * - `getNonce(address,uint192)` for the zero address/key returns `0`.
+ * - `balanceOf(address)` for the zero address returns `0`.
+ * - `getDepositInfo(address)` for the zero address returns a 5-word
+ *   (all-zero) tuple, matching the v0.7 `DepositInfo` struct shape
+ *   `(uint256 deposit, bool staked, uint96 stake, uint32 unstakeDelaySec,
+ *   uint48 withdrawTime)` field-for-field.
+ * `depositTo`/`withdrawTo` share the same `IStakeManager` interface as the
+ * verified `getDepositInfo`/`balanceOf` pair and are standard across every
+ * EntryPoint version; they were not separately simulated (both mutate
+ * state, and simulating a withdrawal from an empty deposit would only prove
+ * it reverts, not that it works).
+ */
+declare const entryPointV07Abi: readonly [{
+    readonly name: "getNonce";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "sender";
+    }, {
+        readonly type: "uint192";
+        readonly name: "key";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "nonce";
+    }];
+}, {
+    readonly name: "balanceOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "depositTo";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "withdrawTo";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "withdrawAddress";
+    }, {
+        readonly type: "uint256";
+        readonly name: "withdrawAmount";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "getDepositInfo";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint256";
+            readonly name: "deposit";
+        }, {
+            readonly type: "bool";
+            readonly name: "staked";
+        }, {
+            readonly type: "uint96";
+            readonly name: "stake";
+        }, {
+            readonly type: "uint32";
+            readonly name: "unstakeDelaySec";
+        }, {
+            readonly type: "uint48";
+            readonly name: "withdrawTime";
+        }];
+        readonly name: "info";
+    }];
+}, {
+    readonly name: "Deposited";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "totalDeposit";
+    }];
+}, {
+    readonly name: "Withdrawn";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "account";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "withdrawAddress";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+}];
+
+/**
+ * ZeroDev Kernel v3 ECDSA validator module ABI, at
+ * `0x845ADb2C711129d4f3966735eD98a9F09fC4cE57` (deployed on PEPU mainnet
+ * only; see `pepuContracts.ecdsaValidator` in `../contracts.js`). This is
+ * the ERC-7579 validator module that lets a Kernel account be controlled by
+ * a plain ECDSA key (the common case — a Privy/embedded-wallet EOA signs
+ * UserOperations on behalf of the smart account).
+ *
+ * Verified live against mainnet 2026-09-24 via `eth_call`:
+ * - `ecdsaValidatorStorage(address)`, called with the zero address, returns
+ *   `address(0)` — the expected result for a kernel account that was never
+ *   registered, and confirmation the getter itself works.
+ * - `isModuleType(1)` returns `true`. `1` is the ERC-7579 `MODULE_TYPE_VALIDATOR`
+ *   constant, so this independently confirms the contract both implements
+ *   the standard ERC-7579 `IModule` interface and self-reports as a
+ *   validator module — not just a contract that happens to expose a
+ *   same-named storage getter.
+ *
+ * `onInstall`/`onUninstall` are part of the same ERC-7579 `IModule`
+ * interface `isModuleType` confirmed this contract implements; they take a
+ * non-trivial `bytes` payload (the encoded owner address) and mutate state,
+ * so — like EntryPoint's `depositTo`/`withdrawTo` — they were not
+ * separately simulated. Included because a Kernel account's installation
+ * flow calls them, so a caller building that flow needs the selectors.
+ */
+declare const kernelEcdsaValidatorAbi: readonly [{
+    readonly name: "ecdsaValidatorStorage";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "kernel";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }];
+}, {
+    readonly name: "isModuleType";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "moduleTypeId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "isInitialized";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "kernel";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "onInstall";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "data";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "onUninstall";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "data";
+    }];
+    readonly outputs: readonly [];
+}];
+/**
+ * ERC-7579 module type IDs (EIP-7579 §Module Types). `isModuleType` on any
+ * conforming module — including {@link kernelEcdsaValidatorAbi}'s contract,
+ * confirmed live above — is called with one of these.
+ */
+declare const ERC7579_MODULE_TYPE: {
+    readonly validator: 1n;
+    readonly executor: 2n;
+    readonly fallback: 3n;
+    readonly hook: 4n;
+};
+
+/**
+ * ZeroDev Kernel v3 account factory ABI, at
+ * `0xaac5D4240AF87249B3f71BC8E4A2cae074A3E419` (deployed on PEPU mainnet
+ * only; see `pepuContracts.kernelFactory` in `../contracts.js`).
+ *
+ * Verified live against mainnet 2026-09-24 via `eth_call`:
+ * - `implementation()` returns `0xbAC849bB641841b44E965fb01A4Bf5F074F84B4d` —
+ *   ZeroDev's Kernel v3.1 singleton implementation address, deployed at the
+ *   same address on every chain that has it via CREATE2.
+ * - `getAddress(bytes,bytes32)`, called with empty `data` and a zero salt,
+ *   returns a computed address without reverting.
+ * - `createAccount(bytes,bytes32)`, simulated (not sent) with the same
+ *   empty `data` and zero salt via `eth_call`, returns the **same** address
+ *   `getAddress` computed for those inputs — exactly the counterfactual-
+ *   address behavior a CREATE2 account factory is supposed to have.
+ *
+ * What this package does NOT ship: a helper that encodes the `data`
+ * argument (Kernel v3.1's `initialize(...)` calldata — root validator,
+ * hook, validator data, hook data, init config). No account has ever been
+ * created through this factory on PEPU yet (its transaction history is
+ * empty as of the verification date above), so there was nothing on-chain
+ * to check a hand-rolled encoding against, and guessing one here would be
+ * exactly the kind of invented byte layout this package's rules forbid.
+ * Use ZeroDev's own `@zerodev/sdk` (or the public Kernel contracts source)
+ * to build that payload, then pass the resulting bytes into
+ * `getAddress`/`createAccount` from this ABI.
+ */
+declare const kernelFactoryAbi: readonly [{
+    readonly name: "implementation";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "getAddress";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "data";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "salt";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "createAccount";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "data";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "salt";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}];
+/**
+ * The verified Kernel v3.1 singleton implementation address that
+ * `kernelFactoryAbi`'s `implementation()` resolves to on PEPU mainnet. Same
+ * address ZeroDev uses across every chain that has this Kernel version.
+ */
+declare const KERNEL_V3_1_IMPLEMENTATION_ADDRESS: "0xbAC849bB641841b44E965fb01A4Bf5F074F84B4d";
+
+/**
+ * PepuSwap's own multicall contract, at
+ * `0x927af2a6B76d2d8206d93004463F8C122701383B` on mainnet (see
+ * `pepuSwapContracts.multicallNonCanonical` in `../dex.js`). **Not**
+ * Multicall3 and not interchangeable with `pepuContracts.multicall3` — see
+ * that entry's notes.
+ *
+ * A first pass at verifying this contract tried a Multicall2-style
+ * `getBlockNumber()` probe, which reverted, and concluded no ABI could be
+ * shipped for it. That probe used the wrong function name: pepuscan
+ * (Blockscout) has this contract verified as Uniswap's
+ * `UniswapInterfaceMulticall` — "a fork of Multicall2 specifically tailored
+ * for the Uniswap Interface" — which exposes `getCurrentBlockTimestamp()`
+ * and `getEthBalance(address)` instead of Multicall2's `getBlockNumber()`/
+ * `getEthBalance()` pair, plus a `multicall(Call[])` that returns
+ * `(blockNumber, Result[])` rather than Multicall3's `(success, returnData)[]`
+ * shape (its `Call`/`Result` structs also carry a per-call `gasLimit`/
+ * `gasUsed`, which neither Multicall2 nor Multicall3 do the same way) — so
+ * it is not a drop-in for either.
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - The ABI below is exactly what pepuscan reports as this contract's
+ *   verified source-matched interface.
+ * - `getCurrentBlockTimestamp()` returns a value equal to the current
+ *   block's own `timestamp` (checked against the same block via
+ *   `eth_getBlockByNumber`).
+ * - `getEthBalance(0x0)` returns a live, non-zero value (the zero address's
+ *   real native-PEPU balance).
+ *
+ * `multicall(Call[])` was not independently simulated (it needs real
+ * `target`/`callData` values per call to return a meaningful result); the
+ * two verified getters above are enough to confirm this is a genuine,
+ * matching deployment of the verified source, not a same-address
+ * coincidence.
+ */
+declare const pepuSwapMulticallAbi: readonly [{
+    readonly name: "getCurrentBlockTimestamp";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "timestamp";
+    }];
+}, {
+    readonly name: "getEthBalance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "addr";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "balance";
+    }];
+}, {
+    readonly name: "multicall";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "target";
+        }, {
+            readonly type: "uint256";
+            readonly name: "gasLimit";
+        }, {
+            readonly type: "bytes";
+            readonly name: "callData";
+        }];
+        readonly name: "calls";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "blockNumber";
+    }, {
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "bool";
+            readonly name: "success";
+        }, {
+            readonly type: "uint256";
+            readonly name: "gasUsed";
+        }, {
+            readonly type: "bytes";
+            readonly name: "returnData";
+        }];
+        readonly name: "returnData";
+    }];
+}];
+
+/**
+ * PepuSwap's own Permit2 deployment, at
+ * `0xB461c05f76d7f919FF7A3Df2B0D2593F56538b4B` on mainnet (see
+ * `pepuSwapContracts.permit2` in `../dex.js`).
+ *
+ * **This is NOT the canonical Permit2** (`0x000000000022D473030F116dDEE9F6B43aC78BA3`).
+ * The canonical address is now also deployed on PEPU (see
+ * `pepuContracts.permit2` in `../contracts.js`, `status: "deployed"`), but
+ * PepuSwap's own frontend was built against this separate, earlier
+ * deployment and overrides the canonical address specifically for chain
+ * 97741 to point at this contract instead. The two are different contracts
+ * with different EIP-712 domains — do not assume a generic
+ * canonical-Permit2-aware tool (e.g. a library that hardcodes the canonical
+ * address) will interoperate with PepuSwap using it; approvals made against
+ * one are not visible to the other.
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 18,306 bytes of bytecode.
+ * - `DOMAIN_SEPARATOR()` returns a live 32-byte value without reverting —
+ *   confirming this contract implements Permit2's standard EIP-712 domain
+ *   separator getter, consistent with a genuine (if non-canonical) Permit2
+ *   deployment.
+ *
+ * `allowance`/`approve`/`permit` are Permit2's standard signatures; not
+ * separately simulated here (each needs a real token/owner/spender to
+ * return a meaningful result). Kept intentionally minimal — this package
+ * does not ship a full Permit2 ABI, only enough to recognize and read from
+ * this specific deployment.
+ */
+declare const pepuSwapPermit2Abi: readonly [{
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint160";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint48";
+        readonly name: "expiration";
+    }, {
+        readonly type: "uint48";
+        readonly name: "nonce";
+    }];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint160";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint48";
+        readonly name: "expiration";
+    }];
+    readonly outputs: readonly [];
+}];
+
+/**
+ * PepuSwap's `NonfungiblePositionManager` ABI subset, at
+ * `0xe2060CbdE18b5e765c86e5Cd6EE68AF209a9faa7` on mainnet (see
+ * `pepuSwapContracts.positionManager` in `../dex.js`). LP positions on
+ * PepuSwap are ERC-721 tokens minted by this contract — on pepuscan they
+ * show up as "Launchpad V3 Positions NFT" / `UNI-V3-POS`.
+ *
+ * Extends viem's own {@link erc721Abi} (this contract genuinely is an
+ * ERC-721) with the one PepuSwap/Uniswap-V3-specific read, `positions`.
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 24,384 bytes of bytecode.
+ * - `factory()` returns the verified `pepuSwapV3FactoryAbi` address.
+ * - `WETH9()` returns the verified WPEPU address.
+ *
+ * `positions(tokenId)` is the standard Uniswap V3 signature; not
+ * independently simulated here since it requires a minted `tokenId`; the
+ * verified getters above confirm this is a genuine, matching deployment.
+ */
+declare const pepuSwapPositionManagerAbi: readonly [{
+    readonly type: "event";
+    readonly name: "Approval";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "ApprovalForAll";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Transfer";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "getApproved";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "isApprovedForAll";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "operator";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "ownerOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "safeTransferFrom";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "safeTransferFrom";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "id";
+        readonly type: "uint256";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "setApprovalForAll";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenByIndex";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenByIndex";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "index";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "tokenURI";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transferFrom";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "factory";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "WETH9";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "positions";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint96";
+        readonly name: "nonce";
+    }, {
+        readonly type: "address";
+        readonly name: "operator";
+    }, {
+        readonly type: "address";
+        readonly name: "token0";
+    }, {
+        readonly type: "address";
+        readonly name: "token1";
+    }, {
+        readonly type: "uint24";
+        readonly name: "fee";
+    }, {
+        readonly type: "int24";
+        readonly name: "tickLower";
+    }, {
+        readonly type: "int24";
+        readonly name: "tickUpper";
+    }, {
+        readonly type: "uint128";
+        readonly name: "liquidity";
+    }, {
+        readonly type: "uint256";
+        readonly name: "feeGrowthInside0LastX128";
+    }, {
+        readonly type: "uint256";
+        readonly name: "feeGrowthInside1LastX128";
+    }, {
+        readonly type: "uint128";
+        readonly name: "tokensOwed0";
+    }, {
+        readonly type: "uint128";
+        readonly name: "tokensOwed1";
+    }];
+}];
+
+/**
+ * PepuSwap's `QuoterV2` ABI subset, at
+ * `0xd647b2D80b48e93613Aa6982b85f8909578b4829` on mainnet (see
+ * `pepuSwapContracts.quoterV2` in `../dex.js`).
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 8,273 bytes of bytecode.
+ * - `factory()` returns the verified `pepuSwapV3FactoryAbi` address.
+ * - `WETH9()` returns the verified WPEPU address.
+ *
+ * `quoteExactInputSingle`/`quoteExactOutputSingle` are QuoterV2's standard
+ * signatures. Like the router's swap functions, they weren't independently
+ * simulated here (a quote needs a real, liquid pool + valid amounts to
+ * return a meaningful result, not just "doesn't revert"); the two verified
+ * getters above confirm this is a genuine, matching QuoterV2 deployment.
+ * QuoterV2 is gas-inefficient by design (it's meant to be called off-chain
+ * via `eth_call`, e.g. through `client.simulateContract`) — never send it a
+ * real transaction.
+ */
+declare const pepuSwapQuoterAbi: readonly [{
+    readonly name: "factory";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "WETH9";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "quoteExactInputSingle";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "tokenIn";
+        }, {
+            readonly type: "address";
+            readonly name: "tokenOut";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountIn";
+        }, {
+            readonly type: "uint24";
+            readonly name: "fee";
+        }, {
+            readonly type: "uint160";
+            readonly name: "sqrtPriceLimitX96";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountOut";
+    }, {
+        readonly type: "uint160";
+        readonly name: "sqrtPriceX96After";
+    }, {
+        readonly type: "uint32";
+        readonly name: "initializedTicksCrossed";
+    }, {
+        readonly type: "uint256";
+        readonly name: "gasEstimate";
+    }];
+}, {
+    readonly name: "quoteExactOutputSingle";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "tokenIn";
+        }, {
+            readonly type: "address";
+            readonly name: "tokenOut";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount";
+        }, {
+            readonly type: "uint24";
+            readonly name: "fee";
+        }, {
+            readonly type: "uint160";
+            readonly name: "sqrtPriceLimitX96";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountIn";
+    }, {
+        readonly type: "uint160";
+        readonly name: "sqrtPriceX96After";
+    }, {
+        readonly type: "uint32";
+        readonly name: "initializedTicksCrossed";
+    }, {
+        readonly type: "uint256";
+        readonly name: "gasEstimate";
+    }];
+}];
+
+/**
+ * PepuSwap's `SwapRouter02` ABI subset, at
+ * `0x150c3F0f16C3D9EB34351d7af9c961FeDc97A0fb` on mainnet (see
+ * `pepuSwapContracts.swapRouter02` in `../dex.js`).
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 24,497 bytes of bytecode.
+ * - `factory()` returns `0x5984B8BF2d4dB9C0aCB1d7924762e4474D80C807` — the
+ *   independently-verified {@link pepuSwapV3FactoryAbi} address.
+ * - `WETH9()` returns `0xF9Cf4A16d26979b929Be7176bAc4e7084975FCB8` — the
+ *   independently-verified WPEPU address (see `../abi/wpepu.js`).
+ *
+ * `exactInputSingle`/`exactOutputSingle` are Uniswap's standard SwapRouter02
+ * signatures (unchanged across the many chains that run this exact
+ * contract); they were not separately simulated because a real swap needs a
+ * funded, approved caller. The two verified read functions above confirm
+ * this is a genuine, matching SwapRouter02 deployment rather than a
+ * same-address coincidence.
+ */
+declare const pepuSwapRouterAbi: readonly [{
+    readonly name: "factory";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "WETH9";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "exactInputSingle";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "tokenIn";
+        }, {
+            readonly type: "address";
+            readonly name: "tokenOut";
+        }, {
+            readonly type: "uint24";
+            readonly name: "fee";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountIn";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountOutMinimum";
+        }, {
+            readonly type: "uint160";
+            readonly name: "sqrtPriceLimitX96";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountOut";
+    }];
+}, {
+    readonly name: "exactOutputSingle";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "tokenIn";
+        }, {
+            readonly type: "address";
+            readonly name: "tokenOut";
+        }, {
+            readonly type: "uint24";
+            readonly name: "fee";
+        }, {
+            readonly type: "address";
+            readonly name: "recipient";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountOut";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountInMaximum";
+        }, {
+            readonly type: "uint160";
+            readonly name: "sqrtPriceLimitX96";
+        }];
+        readonly name: "params";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amountIn";
+    }];
+}, {
+    readonly name: "multicall";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "deadline";
+    }, {
+        readonly type: "bytes[]";
+        readonly name: "data";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bytes[]";
+        readonly name: "results";
+    }];
+}];
+
+/**
+ * PepuSwap's `TickLens` ABI, at
+ * `0x4EB8aA84c066f9bf210eAfE33B30AE49BfafD9a6` on mainnet (see
+ * `pepuSwapContracts.tickLens` in `../dex.js`). `TickLens` is stateless
+ * (it takes a pool address as an argument to every call rather than storing
+ * one), so it has no zero-argument getter to probe.
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 1,385 bytes of bytecode.
+ * - `getPopulatedTicksInWord(pool, wordPosition)` was called against the
+ *   real WPEPU/USDT 0.3% pool (`0x4bE3Af53800AADE09201654CD76D55063c7bdE70`)
+ *   at the word position derived from that pool's own live `slot0().tick`
+ *   and `tickSpacing()`. It returned successfully (an empty populated-ticks
+ *   array for that particular word, which is itself a valid, non-reverting
+ *   result) — confirming the exact function selector against a real pool.
+ */
+declare const pepuSwapTickLensAbi: readonly [{
+    readonly name: "getPopulatedTicksInWord";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }, {
+        readonly type: "int16";
+        readonly name: "tickBitmapIndex";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "int24";
+            readonly name: "tick";
+        }, {
+            readonly type: "int128";
+            readonly name: "liquidityNet";
+        }, {
+            readonly type: "uint128";
+            readonly name: "liquidityGross";
+        }];
+        readonly name: "populatedTicks";
+    }];
+}];
+
+/**
+ * PepuSwap's `UniversalRouter` ABI, at
+ * `0x0dE72b751b77d3c74fB96C5fAd0320Cd8d133d36` on mainnet (see
+ * `pepuSwapContracts.universalRouter` in `../dex.js`). UniversalRouter is a
+ * command-dispatcher contract — almost everything routes through the one
+ * `execute` entrypoint below, with a `commands` byte-string selecting which
+ * internal actions run.
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 17,958 bytes of bytecode.
+ * - Unlike the other PepuSwap contracts, UniversalRouter does not expose
+ *   its configured Permit2/factory addresses through public getters (a
+ *   `PERMIT2()`/`V2_FACTORY()`/`V3_FACTORY()`/`poolManager()` probe all
+ *   reverted — expected, since a dispatcher contract with no matching
+ *   function selector just reverts, it doesn't imply anything is wrong).
+ * - Instead, `execute(bytes,bytes[],uint256)` was called directly via
+ *   `eth_call` with an empty `commands` byte-string, an empty `inputs`
+ *   array, and a far-future deadline. It returned successfully with no
+ *   revert — confirming the exact function selector Uniswap's
+ *   `UniversalRouter` uses, dispatched correctly with zero commands to run.
+ */
+declare const pepuSwapUniversalRouterAbi: readonly [{
+    readonly name: "execute";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "bytes";
+        readonly name: "commands";
+    }, {
+        readonly type: "bytes[]";
+        readonly name: "inputs";
+    }, {
+        readonly type: "uint256";
+        readonly name: "deadline";
+    }];
+    readonly outputs: readonly [];
+}];
+
+/**
+ * PepuSwap's Uniswap V3 core factory ABI, at
+ * `0x5984B8BF2d4dB9C0aCB1d7924762e4474D80C807` on mainnet (see
+ * `pepuSwapContracts.v3Factory` in `../dex.js`). PepuSwap is a Uniswap V3
+ * fork; this is a standard `UniswapV3Factory` ABI subset.
+ *
+ * Verified live against mainnet 2026-09-24:
+ * - `eth_getCode` returns 24,535 bytes of bytecode.
+ * - `owner()` returns a live, non-zero address.
+ * - `getPool(WPEPU, USDT, fee)` returns a real, non-zero pool address for
+ *   fee tiers 100/500/3000/10000, and that pool's own `token0()`/`token1()`
+ *   independently resolve to USDT/WPEPU.
+ * - Four independent contracts on this chain (SwapRouter02,
+ *   NonfungiblePositionManager, QuoterV2, V3Migrator, V3Staker) each
+ *   read their own `factory()` immutable and all five return this exact
+ *   address — see the notes on each of their ABI files.
+ */
+declare const pepuSwapV3FactoryAbi: readonly [{
+    readonly name: "owner";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "getPool";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "tokenA";
+    }, {
+        readonly type: "address";
+        readonly name: "tokenB";
+    }, {
+        readonly type: "uint24";
+        readonly name: "fee";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+}, {
+    readonly name: "feeAmountTickSpacing";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint24";
+        readonly name: "fee";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "int24";
+    }];
+}, {
+    readonly name: "createPool";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "tokenA";
+    }, {
+        readonly type: "address";
+        readonly name: "tokenB";
+    }, {
+        readonly type: "uint24";
+        readonly name: "fee";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+}, {
+    readonly name: "PoolCreated";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "token0";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "token1";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint24";
+        readonly name: "fee";
+        readonly indexed: true;
+    }, {
+        readonly type: "int24";
+        readonly name: "tickSpacing";
+    }, {
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+}];
+
+/**
+ * Minimal Uniswap V3 pool ABI for reading a PepuSwap pool's state — enough
+ * to price a pair and locate its liquidity, without the full swap/mint/burn
+ * surface.
+ *
+ * Verified live against mainnet 2026-09-24 against the real WPEPU/USDT
+ * 0.3% pool (`0x4bE3Af53800AADE09201654CD76D55063c7bdE70`, returned by
+ * `pepuSwapV3FactoryAbi`'s `getPool`):
+ * - `slot0()` decodes cleanly into the standard 7-field tuple (a live tick
+ *   of 372469 at the time of verification).
+ * - `tickSpacing()` returns `60`, the standard spacing for a 0.3% pool.
+ * - `token0()`/`token1()` return USDT/WPEPU respectively, matching the
+ *   factory's `getPool` inputs.
+ */
+declare const pepuSwapV3PoolAbi: readonly [{
+    readonly name: "token0";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "token1";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "fee";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint24";
+    }];
+}, {
+    readonly name: "tickSpacing";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "int24";
+    }];
+}, {
+    readonly name: "liquidity";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint128";
+    }];
+}, {
+    readonly name: "slot0";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint160";
+        readonly name: "sqrtPriceX96";
+    }, {
+        readonly type: "int24";
+        readonly name: "tick";
+    }, {
+        readonly type: "uint16";
+        readonly name: "observationIndex";
+    }, {
+        readonly type: "uint16";
+        readonly name: "observationCardinality";
+    }, {
+        readonly type: "uint16";
+        readonly name: "observationCardinalityNext";
+    }, {
+        readonly type: "uint8";
+        readonly name: "feeProtocol";
+    }, {
+        readonly type: "bool";
+        readonly name: "unlocked";
+    }];
+}];
+
+/**
+ * WPEPU (Wrapped Pepe Unchained) ABI.
+ *
+ * WPEPU is a WETH9-style wrapper around the native PEPU gas token, deployed
+ * at `0xF9Cf4A16d26979b929Be7176bAc4e7084975FCB8` on mainnet (see
+ * `pepuTokenList` in `../tokens.js`). This extends viem's own {@link erc20Abi}
+ * with the two WETH9-specific functions and their events, rather than
+ * re-declaring the ERC-20 surface from scratch.
+ *
+ * Verified live against mainnet on 2026-09-24:
+ * - `deposit()` and `withdraw(uint256)` both simulate successfully via
+ *   `eth_call` (a zero-value deposit and a zero-amount withdraw), confirming
+ *   both selectors exist and don't revert.
+ * - `decimals()` -> `18`, `symbol()` -> `"WPEPU"`, `name()` -> `"Wrapped PEPU"`.
+ * - The contract is verified on pepuscan against the canonical `WETH9`
+ *   source.
+ */
+declare const wpepuAbi: readonly [{
+    readonly type: "event";
+    readonly name: "Approval";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Transfer";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "allowance";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transfer";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transferFrom";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly name: "deposit";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "withdraw";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "Deposit";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "dst";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+}, {
+    readonly name: "Withdrawal";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "src";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }];
+}];
+
+/**
+ * Minimal Multicall3 ABI (aggregate3 plus the common read helpers). Same
+ * interface as canonical mds1/multicall3; on PEPU it lives at the
+ * PEPU-specific `0x9CE19273Ae9c24437DFF512E8DFCAed4E4B001bd`, never at the
+ * canonical `0xcA11...CA11`.
+ */
+declare const multicall3Abi: readonly [{
+    readonly name: "aggregate3";
+    readonly type: "function";
+    readonly stateMutability: "payable";
+    readonly inputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "target";
+        }, {
+            readonly type: "bool";
+            readonly name: "allowFailure";
+        }, {
+            readonly type: "bytes";
+            readonly name: "callData";
+        }];
+        readonly name: "calls";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly type: "bool";
+            readonly name: "success";
+        }, {
+            readonly type: "bytes";
+            readonly name: "returnData";
+        }];
+        readonly name: "returnData";
+    }];
+}, {
+    readonly name: "getEthBalance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "addr";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "balance";
+    }];
+}, {
+    readonly name: "getBlockNumber";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "blockNumber";
+    }];
+}, {
+    readonly name: "getChainId";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}];
+
+/**
+ * Canonical Permit2 ABI subset (AllowanceTransfer plus SignatureTransfer
+ * nonce reads). For the canonical `0x000000000022D473030F116dDEE9F6B43aC78BA3`
+ * deployed on PEPU. NOT PepuSwap's separate deployment (see `pepuSwapPermit2Abi`).
+ */
+declare const permit2Abi: readonly [{
+    readonly name: "DOMAIN_SEPARATOR";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "bytes32";
+    }];
+}, {
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint160";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint48";
+        readonly name: "expiration";
+    }, {
+        readonly type: "uint48";
+        readonly name: "nonce";
+    }];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint160";
+        readonly name: "amount";
+    }, {
+        readonly type: "uint48";
+        readonly name: "expiration";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "nonceBitmap";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "owner";
+    }, {
+        readonly type: "uint256";
+        readonly name: "wordPos";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "invalidateNonces";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "token";
+    }, {
+        readonly type: "address";
+        readonly name: "spender";
+    }, {
+        readonly type: "uint48";
+        readonly name: "newNonce";
+    }];
+    readonly outputs: readonly [];
+}];
+
+/**
+ * Hosted-URL swap point. The hosted PEPU bundler and paymaster service run at
+ * bundler.pepeunchained.com and paymaster.pepeunchained.com. Set here, the SDK,
+ * MCP server and docs flip together. Apps can still point at their own
+ * services with the env vars below.
+ *
+ * - `bundlerUrl` is a complete JSON-RPC URL.
+ * - `paymasterBaseUrl` is the paymaster SERVICE base (REST API, `/health`,
+ *   `/v2/free-tier`). It is NOT an ERC-7677 URL: v2 serves ERC-7677 at
+ *   `<base>/v2/paymaster/<client token>`, so build that with
+ *   `hostedErc7677Url` (or `buildErc7677Url`).
+ * - `paymasterUrl` is the default complete ERC-7677 URL. It stays `null`
+ *   because every ERC-7677 URL embeds a per-project token; set
+ *   `PEPU_PAYMASTER_URL` (or pass a token) to supply one.
+ */
+declare const PEPU_HOSTED: {
+    readonly bundlerUrl: string | null;
+    readonly paymasterBaseUrl: string | null;
+    readonly paymasterUrl: string | null;
+};
+/** Server-side (and script) environment variable names. */
+declare const PEPU_ENV: {
+    readonly bundlerUrl: "PEPU_BUNDLER_URL";
+    readonly paymasterUrl: "PEPU_PAYMASTER_URL";
+    readonly rpcUrl: "PEPU_RPC_URL";
+};
+/** Browser-exposed variants (Next.js `NEXT_PUBLIC_` convention). */
+declare const PEPU_PUBLIC_ENV: {
+    readonly bundlerUrl: "NEXT_PUBLIC_PEPU_BUNDLER_URL";
+    readonly paymasterUrl: "NEXT_PUBLIC_PEPU_PAYMASTER_URL";
+    readonly rpcUrl: "NEXT_PUBLIC_PEPU_RPC_URL";
+};
+interface ResolvePepuEndpointsOptions {
+    bundlerUrl?: string;
+    paymasterUrl?: string;
+    rpcUrl?: string;
+    /**
+     * Environment to read. Defaults to `process.env` when it exists. In browser
+     * bundles frameworks only inline literal `process.env.NEXT_PUBLIC_X`
+     * accesses, so pass them explicitly there.
+     */
+    env?: Record<string, string | undefined>;
+}
+interface PepuEndpoints {
+    rpcUrl: string;
+    bundlerUrl: string | null;
+    /** Complete ERC-7677 URL from the option or env, else `null` (it needs a project token). */
+    paymasterUrl: string | null;
+    /**
+     * Paymaster service base for the REST API, probes and ERC-7677 URL building.
+     * From the option or env (a full ERC-7677 URL is reduced to its base), else the hosted base.
+     */
+    paymasterBaseUrl: string | null;
+    /** Highest-precedence origin used for any of the three values. */
+    source: "explicit" | "env" | "hosted-default";
+}
+/** Strip a trailing `/v2/paymaster/<token>` or `/paymaster/<token>` and slashes, leaving the service base. */
+declare function paymasterBaseOf(url: string): string;
+/**
+ * Resolve endpoints. Precedence per value: explicit option, then env
+ * (server variable, then `NEXT_PUBLIC_` variable), then {@link PEPU_HOSTED}.
+ * Throws PepuConfigError (CONFIG_BAD_URL) naming the variable, never its value.
+ */
+declare function resolvePepuEndpoints(options?: ResolvePepuEndpointsOptions): PepuEndpoints;
+/** True once the hosted bundler and the hosted paymaster service have URLs in {@link PEPU_HOSTED}. */
+declare function isHostedSponsorshipLive(): boolean;
+/** The public free-tier state route on the hosted paymaster (`GET`, no credentials). */
+declare function hostedFreeTierUrl(): string;
+
+/** The canonical Multicall3 address, which is NOT deployed on PEPU. */
+declare const CANONICAL_MULTICALL3_ADDRESS: "0xcA11bde05977b3631167028862bE2a173976CA11";
+/**
+ * Guard: throws `MULTICALL3_CANONICAL_ADDRESS` if `address` is the canonical
+ * Multicall3 address (which has no code on PEPU).
+ *
+ * @example
+ * ```ts
+ * assertNotCanonicalMulticall3("0x9CE19273Ae9c24437DFF512E8DFCAed4E4B001bd"); // ok
+ * ```
+ */
+declare function assertNotCanonicalMulticall3(address: Address): void;
+/**
+ * The PEPU-specific Multicall3 registry entry. Never the canonical address.
+ *
+ * @example
+ * ```ts
+ * const { address } = getMulticall3(); // 0x9CE19273...01bd
+ * ```
+ */
+declare function getMulticall3(chainId?: number): DeployedContract;
+/**
+ * viem `multicall` pinned to the PEPU Multicall3 address.
+ *
+ * @example
+ * ```ts
+ * const [name, supply] = await pepuMulticall(client, [
+ *   { address: token, abi: erc20Abi, functionName: "name" },
+ *   { address: token, abi: erc20Abi, functionName: "totalSupply" },
+ * ], { allowFailure: false });
+ * ```
+ */
+declare function pepuMulticall<const T extends readonly ContractFunctionParameters[], A extends boolean = true>(client: PublicClient, calls: T, o?: {
+    allowFailure?: A;
+    blockNumber?: bigint;
+}): Promise<MulticallReturnType<T, A>>;
+/**
+ * ABI-encode a Multicall3 `aggregate3` call.
+ *
+ * @example
+ * ```ts
+ * const data = encodeAggregate3([{ target: token, callData: "0x18160ddd" }]);
+ * ```
+ */
+declare function encodeAggregate3(calls: readonly {
+    target: Address;
+    allowFailure?: boolean;
+    callData: Hex;
+}[]): Hex;
+/**
+ * Decode the return data of `aggregate3`.
+ *
+ * @example
+ * ```ts
+ * const results = decodeAggregate3Result(returnData);
+ * results[0]?.success;
+ * ```
+ */
+declare function decodeAggregate3Result(data: Hex): {
+    success: boolean;
+    returnData: Hex;
+}[];
+
+/**
+ * The canonical Permit2 registry entry (`0x000000000022D473...78BA3`).
+ *
+ * @example
+ * ```ts
+ * const { address } = getPermit2();
+ * ```
+ */
+declare function getPermit2(chainId?: number): DeployedContract;
+/**
+ * EIP-712 domain for canonical Permit2: name "Permit2" (no version).
+ *
+ * @example
+ * ```ts
+ * const domain = permit2Domain(); // { name: "Permit2", chainId: 97741, verifyingContract }
+ * ```
+ */
+declare function permit2Domain(chainId?: number): TypedDataDomain;
+/** Typed-data definition accepted by viem `signTypedData`. */
+interface Permit2TypedData<P extends string, M extends Record<string, unknown>> {
+    domain: TypedDataDomain;
+    types: Record<string, readonly {
+        name: string;
+        type: string;
+    }[]>;
+    primaryType: P;
+    message: M;
+}
+/**
+ * Typed data for Permit2 AllowanceTransfer `PermitSingle`.
+ *
+ * @example
+ * ```ts
+ * const td = buildPermitSingleTypedData({ token, amount: 1n, expiration: 1900000000, nonce: 0, spender, sigDeadline: 1900000000n });
+ * ```
+ */
+declare function buildPermitSingleTypedData(p: {
+    token: Address;
+    amount: bigint;
+    expiration: number;
+    nonce: number;
+    spender: Address;
+    sigDeadline: bigint;
+    chainId?: number;
+}): Permit2TypedData<"PermitSingle", {
+    details: {
+        token: Address;
+        amount: bigint;
+        expiration: number;
+        nonce: number;
+    };
+    spender: Address;
+    sigDeadline: bigint;
+}>;
+/**
+ * Typed data for Permit2 SignatureTransfer `PermitTransferFrom`.
+ *
+ * @example
+ * ```ts
+ * const td = buildPermitTransferFromTypedData({ token, amount: 1n, spender, nonce: 0n, deadline: 1900000000n });
+ * ```
+ */
+declare function buildPermitTransferFromTypedData(p: {
+    token: Address;
+    amount: bigint;
+    spender: Address;
+    nonce: bigint;
+    deadline: bigint;
+    chainId?: number;
+}): Permit2TypedData<"PermitTransferFrom", {
+    permitted: {
+        token: Address;
+        amount: bigint;
+    };
+    spender: Address;
+    nonce: bigint;
+    deadline: bigint;
+}>;
+/**
+ * Read the Permit2 AllowanceTransfer allowance for (owner, token, spender).
+ *
+ * @example
+ * ```ts
+ * const { amount, expiration, nonce } = await readPermit2Allowance(client, { owner, token, spender });
+ * ```
+ */
+declare function readPermit2Allowance(client: PublicClient, o: {
+    owner: Address;
+    token: Address;
+    spender: Address;
+}): Promise<{
+    amount: bigint;
+    expiration: number;
+    nonce: number;
+}>;
+
+export { ARB_GAS_INFO_ADDRESS, CANONICAL_MULTICALL3_ADDRESS, ContractEntry, DEFAULT_MAX_SEND_MARGIN_BPS, DeployedContract, type DualFeeModelExplanation, ERC7579_MODULE_TYPE, type ExplorerResourceType, type FormatPepuOptions, KERNEL_V3_1_IMPLEMENTATION_ADDRESS, type MaxSendableAmountOptions, type MaxSendableAmountResult, type NitroFeeBreakdown, PEPU_ENV, PEPU_HOSTED, PEPU_PUBLIC_ENV, PepuChain, type PepuEndpoints, type PepuSwapContractName, type PepuTokenInfo, type PepuTokenList, type PepuscanClient, type PepuscanTokenMetadata, type Permit2TypedData, type ResolvePepuEndpointsOptions, type TransactionCostEstimate, addressUrl, arbGasInfoAbi, assertNotCanonicalMulticall3, blockUrl, buildPermitSingleTypedData, buildPermitTransferFromTypedData, createPepuscanClient, decodeAggregate3Result, encodeAggregate3, entryPointV07Abi, estimateTransactionCost, explainDualFeeModel, explorerLinks, explorerUrl, formatPepu, formatPepuGasPrice, formatUnitsCompact, getMulticall3, getNitroFeeBreakdown, getPepuSwapContract, getPermit2, getPublicClient, hostedFreeTierUrl, isHostedSponsorshipLive, kernelEcdsaValidatorAbi, kernelFactoryAbi, listPepuSwapContracts, maxSendableAmount, multicall3Abi, paymasterBaseOf, pepuMulticall, pepuSwapContracts, pepuSwapMulticallAbi, pepuSwapPermit2Abi, pepuSwapPositionManagerAbi, pepuSwapQuoterAbi, pepuSwapRouterAbi, pepuSwapTickLensAbi, pepuSwapUniversalRouterAbi, pepuSwapV3FactoryAbi, pepuSwapV3PoolAbi, pepuTokenList, permit2Abi, permit2Domain, readPermit2Allowance, resolvePepuEndpoints, switchOrAddPepuChain, toAddEthereumChainParameter, tokenUrl, txUrl, wpepuAbi };