@pepu-chain/sdk 0.0.0-stage → 0.2.0

package/dist/calls-BRPjKgjl.d.cts

@@ -0,0 +1,70 @@
+import { Address, Hex, TransactionReceipt } from 'viem';
+import { C as Call } from './types-BilBTDqK.cjs';
+
+/** A call in the exact `{ to, value, data }` shape smart-account clients take. */
+interface EncodedCall {
+    to: Address;
+    value: bigint;
+    data: Hex;
+}
+/**
+ * Normalize {@link Call}s: encode `abi`/`functionName`/`args` into `data`,
+ * default `value` to 0 and `data` to `0x`. Throws a PepuError for an empty
+ * list or an ambiguous call.
+ *
+ * @example
+ * normalizeCalls([{ to, abi: tapScoreAbi, functionName: "tap" }]);
+ */
+declare function normalizeCalls(calls: readonly Call[]): EncodedCall[];
+/**
+ * Read who paid and how much from a bundle transaction receipt's
+ * `UserOperationEvent` (EntryPoint v0.7). Returns `null` when the receipt has
+ * no event for `sender`.
+ *
+ * @example
+ * const paid = userOpEventFromReceipt(receipt, smartAccountAddress);
+ */
+declare function userOpEventFromReceipt(receipt: Pick<TransactionReceipt, "logs">, sender: Address): {
+    userOpHash: Hex;
+    paymaster: Address | null;
+    actualGasCost: bigint;
+    success: boolean;
+} | null;
+/** One UserOperationEvent from a bundle receipt. */
+interface UserOpEvent {
+    sender: Address;
+    userOpHash: Hex;
+    nonce: bigint;
+    /** The paymaster the EntryPoint charged, or `null` when the account paid for itself. */
+    paymaster: Address | null;
+    actualGasCost: bigint;
+    actualGasUsed: bigint;
+    success: boolean;
+}
+/**
+ * Every `UserOperationEvent` in a receipt, without knowing the sender. A
+ * bundle can carry several operations; use this to inspect them all (for
+ * example when you only have a transaction hash). Pure.
+ *
+ * @example
+ * const events = userOpEventsFromReceipt(receipt);
+ * events.map((e) => [e.sender, e.success]);
+ */
+declare function userOpEventsFromReceipt(receipt: Pick<TransactionReceipt, "logs">): UserOpEvent[];
+/**
+ * The ERC-7579 `execute(bytes32 mode, bytes executionCalldata)` callData a
+ * Kernel v3 account puts in a UserOperation. One call uses single mode
+ * (callType 0x00, packed `target ++ value ++ data`); several use batch mode
+ * (callType 0x01, ABI-encoded `Execution[]`). Pure: needs no live account. It
+ * is the same bytes `account.encodeCalls(calls)` returns for a Kernel v3.1
+ * account (`toPepuKernelAccount`, `@pepu-chain/sdk/aa/kernel`).
+ *
+ * Calls take either raw `data` or `abi` + `functionName` (+ `args`), like
+ * `sendSponsored`. Throws a PepuError for an empty list or ambiguous call.
+ *
+ * @example
+ * const callData = encodeKernelExecute([{ to: tapScore, abi: tapScoreAbi, functionName: "tap" }]);
+ */
+declare function encodeKernelExecute(calls: readonly Call[]): Hex;
+
+export { type EncodedCall as E, type UserOpEvent as U, userOpEventsFromReceipt as a, encodeKernelExecute as e, normalizeCalls as n, userOpEventFromReceipt as u };

package/dist/calls-z_EQOtFb.d.ts

@@ -0,0 +1,70 @@
+import { Address, Hex, TransactionReceipt } from 'viem';
+import { C as Call } from './types-BilBTDqK.js';
+
+/** A call in the exact `{ to, value, data }` shape smart-account clients take. */
+interface EncodedCall {
+    to: Address;
+    value: bigint;
+    data: Hex;
+}
+/**
+ * Normalize {@link Call}s: encode `abi`/`functionName`/`args` into `data`,
+ * default `value` to 0 and `data` to `0x`. Throws a PepuError for an empty
+ * list or an ambiguous call.
+ *
+ * @example
+ * normalizeCalls([{ to, abi: tapScoreAbi, functionName: "tap" }]);
+ */
+declare function normalizeCalls(calls: readonly Call[]): EncodedCall[];
+/**
+ * Read who paid and how much from a bundle transaction receipt's
+ * `UserOperationEvent` (EntryPoint v0.7). Returns `null` when the receipt has
+ * no event for `sender`.
+ *
+ * @example
+ * const paid = userOpEventFromReceipt(receipt, smartAccountAddress);
+ */
+declare function userOpEventFromReceipt(receipt: Pick<TransactionReceipt, "logs">, sender: Address): {
+    userOpHash: Hex;
+    paymaster: Address | null;
+    actualGasCost: bigint;
+    success: boolean;
+} | null;
+/** One UserOperationEvent from a bundle receipt. */
+interface UserOpEvent {
+    sender: Address;
+    userOpHash: Hex;
+    nonce: bigint;
+    /** The paymaster the EntryPoint charged, or `null` when the account paid for itself. */
+    paymaster: Address | null;
+    actualGasCost: bigint;
+    actualGasUsed: bigint;
+    success: boolean;
+}
+/**
+ * Every `UserOperationEvent` in a receipt, without knowing the sender. A
+ * bundle can carry several operations; use this to inspect them all (for
+ * example when you only have a transaction hash). Pure.
+ *
+ * @example
+ * const events = userOpEventsFromReceipt(receipt);
+ * events.map((e) => [e.sender, e.success]);
+ */
+declare function userOpEventsFromReceipt(receipt: Pick<TransactionReceipt, "logs">): UserOpEvent[];
+/**
+ * The ERC-7579 `execute(bytes32 mode, bytes executionCalldata)` callData a
+ * Kernel v3 account puts in a UserOperation. One call uses single mode
+ * (callType 0x00, packed `target ++ value ++ data`); several use batch mode
+ * (callType 0x01, ABI-encoded `Execution[]`). Pure: needs no live account. It
+ * is the same bytes `account.encodeCalls(calls)` returns for a Kernel v3.1
+ * account (`toPepuKernelAccount`, `@pepu-chain/sdk/aa/kernel`).
+ *
+ * Calls take either raw `data` or `abi` + `functionName` (+ `args`), like
+ * `sendSponsored`. Throws a PepuError for an empty list or ambiguous call.
+ *
+ * @example
+ * const callData = encodeKernelExecute([{ to: tapScore, abi: tapScoreAbi, functionName: "tap" }]);
+ */
+declare function encodeKernelExecute(calls: readonly Call[]): Hex;
+
+export { type EncodedCall as E, type UserOpEvent as U, userOpEventsFromReceipt as a, encodeKernelExecute as e, normalizeCalls as n, userOpEventFromReceipt as u };

package/dist/chains-DK13zGIp.d.cts

@@ -0,0 +1,235 @@
+import * as viem from 'viem';
+
+/**
+ * Pepe Unchained V2 — mainnet.
+ *
+ * Arbitrum Orbit / Nitro chain (ArbOS 51), hosted by Conduit, settling to
+ * Ethereum L1 via AnyTrust. Verified against the live RPC endpoint.
+ */
+declare const pepuMainnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PepuScan";
+            readonly url: "https://pepuscan.com";
+            readonly apiUrl: "https://pepuscan.com/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x9CE19273Ae9c24437DFF512E8DFCAed4E4B001bd";
+            readonly blockCreated: 10521048;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 97741;
+    name: "Pepe Unchained V2";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-mainnet-0.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Pepe Unchained V2 — testnet.
+ *
+ * Same stack as mainnet; used for development and faucet-funded testing.
+ */
+declare const pepuTestnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 97740;
+    name: "Pepe Unchained V2 Testnet";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-testnet-vn4qxxp9og.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+/** All Pepe Unchained V2 chain definitions, mainnet first. */
+declare const pepuChains: readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PepuScan";
+            readonly url: "https://pepuscan.com";
+            readonly apiUrl: "https://pepuscan.com/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x9CE19273Ae9c24437DFF512E8DFCAed4E4B001bd";
+            readonly blockCreated: 10521048;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 97741;
+    name: "Pepe Unchained V2";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-mainnet-0.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+}, {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 97740;
+    name: "Pepe Unchained V2 Testnet";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-testnet-vn4qxxp9og.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+}];
+/** Union type of the two Pepe Unchained V2 chain definitions. */
+type PepuChain = (typeof pepuChains)[number];
+/** The chain ids this package knows about — {@link pepuMainnet}'s and {@link pepuTestnet}'s. */
+type PepuChainId = PepuChain["id"];
+/**
+ * Type guard: is `chainId` one of PEPU's chain ids (mainnet `97741` or
+ * testnet `97740`)? Narrows `number` to {@link PepuChainId}, so a caller can
+ * use it to guard which chain-specific helper (`getContract`,
+ * `explorerUrl`, etc.) is safe to call without re-deriving the id list by
+ * hand each time.
+ */
+declare function isPepuChain(chainId: number): chainId is PepuChainId;
+
+export { type PepuChain as P, type PepuChainId as a, pepuMainnet as b, pepuTestnet as c, isPepuChain as i, pepuChains as p };

package/dist/chains-DK13zGIp.d.ts

@@ -0,0 +1,235 @@
+import * as viem from 'viem';
+
+/**
+ * Pepe Unchained V2 — mainnet.
+ *
+ * Arbitrum Orbit / Nitro chain (ArbOS 51), hosted by Conduit, settling to
+ * Ethereum L1 via AnyTrust. Verified against the live RPC endpoint.
+ */
+declare const pepuMainnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PepuScan";
+            readonly url: "https://pepuscan.com";
+            readonly apiUrl: "https://pepuscan.com/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x9CE19273Ae9c24437DFF512E8DFCAed4E4B001bd";
+            readonly blockCreated: 10521048;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 97741;
+    name: "Pepe Unchained V2";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-mainnet-0.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+/**
+ * Pepe Unchained V2 — testnet.
+ *
+ * Same stack as mainnet; used for development and faucet-funded testing.
+ */
+declare const pepuTestnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 97740;
+    name: "Pepe Unchained V2 Testnet";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-testnet-vn4qxxp9og.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+/** All Pepe Unchained V2 chain definitions, mainnet first. */
+declare const pepuChains: readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "PepuScan";
+            readonly url: "https://pepuscan.com";
+            readonly apiUrl: "https://pepuscan.com/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0x9CE19273Ae9c24437DFF512E8DFCAed4E4B001bd";
+            readonly blockCreated: 10521048;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 97741;
+    name: "Pepe Unchained V2";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-mainnet-0.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+}, {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 97740;
+    name: "Pepe Unchained V2 Testnet";
+    nativeCurrency: {
+        readonly name: "Pepe Unchained";
+        readonly symbol: "PEPU";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc-pepu-v2-testnet-vn4qxxp9og.t.conduit.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        client: viem.Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+}];
+/** Union type of the two Pepe Unchained V2 chain definitions. */
+type PepuChain = (typeof pepuChains)[number];
+/** The chain ids this package knows about — {@link pepuMainnet}'s and {@link pepuTestnet}'s. */
+type PepuChainId = PepuChain["id"];
+/**
+ * Type guard: is `chainId` one of PEPU's chain ids (mainnet `97741` or
+ * testnet `97740`)? Narrows `number` to {@link PepuChainId}, so a caller can
+ * use it to guard which chain-specific helper (`getContract`,
+ * `explorerUrl`, etc.) is safe to call without re-deriving the id list by
+ * hand each time.
+ */
+declare function isPepuChain(chainId: number): chainId is PepuChainId;
+
+export { type PepuChain as P, type PepuChainId as a, pepuMainnet as b, pepuTestnet as c, isPepuChain as i, pepuChains as p };