abstractionkit 0.3.5 → 0.3.8

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { AbiCoder, JsonRpcProvider, TypedDataEncoder, Wallet, encodeRlp, ethers, getAddress, getBytes, hashMessage, hexlify, id, isAddress, keccak256, solidityPacked, solidityPackedKeccak256, toBeArray } from "ethers";
+import { AbiCoder, TypedDataEncoder, Wallet, encodeRlp, ethers, getAddress, getBytes, hashMessage, hexlify, id, isAddress, keccak256, solidityPacked, solidityPackedKeccak256, toBeArray } from "ethers";
 //#region src/errors.ts
 /**
 * Maps JSON-RPC numeric error codes to human-readable {@link BundlerErrorCode} values.
@@ -18,6 +18,16 @@ const BundlerErrorCodeDict = {
 	"-32521": "EXECUTION_REVERTED"
 };
 /**
+* Maps JSON-RPC numeric error codes to human-readable {@link JsonRpcErrorCode} values.
+*/
+const JsonRpcErrorDict = {
+	"-32700": "PARSE_ERROR",
+	"-32600": "INVALID_REQUEST",
+	"-32601": "METHOD_NOT_FOUND",
+	"-32602": "INVALID_PARAMS",
+	"-32603": "INTERNAL_ERROR"
+};
+/**
 * Custom error class for the AbstractionKit SDK. Wraps bundler, JSON-RPC,
 * and general errors with a structured code, optional numeric errno, and
 * arbitrary JSON-serializable context.
@@ -72,164 +82,164 @@ function ensureError(value) {
 	return /* @__PURE__ */ new Error(`This value was thrown as is, not through an Error: ${stringified}`);
 }
 //#endregion
-//#region src/constants.ts
-/** The Ethereum zero address (0x0000...0000), used as a placeholder for empty/null addresses */
-const ZeroAddress = "0x0000000000000000000000000000000000000000";
-/** EntryPoint v0.9 contract address */
-const ENTRYPOINT_V9 = "0x433709009B8330FDa32311DF1C2AFA402eD8D009";
-/** EntryPoint v0.8 contract address */
-const ENTRYPOINT_V8 = "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
-/** EntryPoint v0.7 contract address */
-const ENTRYPOINT_V7 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
-/** EntryPoint v0.6 contract address */
-const ENTRYPOINT_V6 = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
-/** Safe L2 singleton v1.5.0 address and init hash */
-const Safe_L2_V1_5_0 = {
-	singletonAddress: "0xEdd160fEBBD92E350D4D398fb636302fccd67C7e",
-	singletonInitHash: "0x1b94aebb5a7df6dff11d93589204a6bbc99b4b8c9014bf1d386d006c2c17a881"
-};
-/** Safe L2 singleton v1.4.1 address and init hash */
-const Safe_L2_V1_4_1 = {
-	singletonAddress: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
-	singletonInitHash: "0xe298282cefe913ab5d282047161268a8222e4bd4ed106300c547894bbefd31ee"
+//#region src/transport/Transport.ts
+/**
+* Default {@link ProviderRpcError} implementation. {@link BaseRpcTransport}
+* throws this automatically when a JSON-RPC envelope returns
+* `{ error: { code, message, data } }`.
+*/
+var TransportRpcError = class extends Error {
+	code;
+	data;
+	/**
+	* @param code - Numeric JSON-RPC error code (e.g. -32601 for METHOD_NOT_FOUND)
+	* @param message - Human-readable error description
+	* @param data - Optional additional data returned by the RPC server
+	*/
+	constructor(code, message, data) {
+		super(message);
+		this.name = "TransportRpcError";
+		this.code = code;
+		this.data = data;
+	}
 };
-/** Default placeholder values for gas estimation before actual values are known */
-const BaseUserOperationDummyValues = {
-	sender: ZeroAddress,
-	nonce: 0n,
-	callData: "0x",
-	callGasLimit: 0n,
-	verificationGasLimit: 0n,
-	preVerificationGas: 0n,
-	maxFeePerGas: 0n,
-	maxPriorityFeePerGas: 0n,
-	signature: "0x"
+/**
+* Narrowing helper for {@link EventfulTransport}.
+*
+* @param transport - Any transport to test
+* @returns `true` when both `on` and `removeListener` methods are present
+*/
+function isEventfulTransport(transport) {
+	const t = transport;
+	return typeof t.on === "function" && typeof t.removeListener === "function";
+}
+//#endregion
+//#region src/transport/BaseRpcTransport.ts
+/**
+* Optional convenience base class for users writing new wire-level
+* {@link Transport} backends (WebSocket, IPC, custom HTTP, in-process mock,
+* etc.). Handles JSON-RPC framing, id assignment, bigint serialization, and
+* standard error parsing so subclasses implement only the byte-level
+* `send(envelope, options)` hook.
+*
+* Users who already have a {@link Transport} in hand (window.ethereum, viem
+* `WalletClient`, ethers `Eip1193Provider`-shaped object, etc.) do NOT need
+* this class — they pass their object directly.
+*
+* @example
+* ```ts
+* class WebSocketTransport extends BaseRpcTransport {
+*   protected async send(envelope) {
+*     // serialize envelope to JSON, send over the socket, await response
+*     return JSON.parse(await this.socket.sendAndAwait(JSON.stringify(envelope)));
+*   }
+* }
+* ```
+*/
+var BaseRpcTransport = class BaseRpcTransport {
+	nextId = 1;
+	/**
+	* Build a JSON-RPC envelope, delegate the wire I/O to the subclass's
+	* {@link BaseRpcTransport.send} method, and parse the response.
+	*
+	* @throws {@link TransportRpcError} when the response contains an `error` field
+	* @throws {@link TransportRpcError} (code -32603) when the response is malformed
+	*/
+	async request(args, options) {
+		const envelope = {
+			jsonrpc: "2.0",
+			id: this.nextId++,
+			method: args.method,
+			params: args.params
+		};
+		const raw = await this.send(envelope, options);
+		return BaseRpcTransport.parseResponse(raw);
+	}
+	/**
+	* Serialize a JSON-RPC envelope to a string, converting bigint values to
+	* `0x`-prefixed hex strings (preserving the historical SDK behavior).
+	*/
+	static serializeEnvelope(envelope) {
+		return JSON.stringify(envelope, (_key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value);
+	}
+	/**
+	* Parse a decoded JSON-RPC response. Returns the `result` field on success
+	* or throws a {@link TransportRpcError} on error / malformed response.
+	*/
+	static parseResponse(raw) {
+		if (raw == null || typeof raw !== "object") throw new TransportRpcError(-32603, "malformed JSON-RPC response", raw);
+		const response = raw;
+		if ("error" in response) {
+			const { code, message, data } = response.error;
+			throw new TransportRpcError(code, message, data);
+		}
+		if ("result" in response) return response.result;
+		throw new TransportRpcError(-32603, "malformed JSON-RPC response", raw);
+	}
 };
-/** EIP-712 primary type string used when signing Safe UserOperations. */
-const EIP712_SAFE_OPERATION_PRIMARY_TYPE = "SafeOp";
-/** EIP-712 type definition for Safe UserOperation signing (EntryPoint v0.6) */
-const EIP712_SAFE_OPERATION_V6_TYPE = { SafeOp: [
-	{
-		type: "address",
-		name: "safe"
-	},
-	{
-		type: "uint256",
-		name: "nonce"
-	},
-	{
-		type: "bytes",
-		name: "initCode"
-	},
-	{
-		type: "bytes",
-		name: "callData"
-	},
-	{
-		type: "uint256",
-		name: "callGasLimit"
-	},
-	{
-		type: "uint256",
-		name: "verificationGasLimit"
-	},
-	{
-		type: "uint256",
-		name: "preVerificationGas"
-	},
-	{
-		type: "uint256",
-		name: "maxFeePerGas"
-	},
-	{
-		type: "uint256",
-		name: "maxPriorityFeePerGas"
-	},
-	{
-		type: "bytes",
-		name: "paymasterAndData"
-	},
-	{
-		type: "uint48",
-		name: "validAfter"
-	},
-	{
-		type: "uint48",
-		name: "validUntil"
-	},
-	{
-		type: "address",
-		name: "entryPoint"
+//#endregion
+//#region src/transport/HttpTransport.ts
+/**
+* Default concrete {@link Transport}: POSTs JSON-RPC envelopes to an HTTP
+* endpoint. Used by every URL-string call site once a string is normalized
+* into a transport.
+*
+* @example
+* ```ts
+* const t = new HttpTransport("https://api.candide.dev/public/v3/11155111");
+* const chainId = await t.request<string>({ method: "eth_chainId" });
+*
+* // With auth headers and a custom fetch:
+* const t2 = new HttpTransport("https://...", {
+*   headers: { Authorization: `Bearer ${token}` },
+*   fetch: myFetchWithRetry,
+* });
+* ```
+*/
+var HttpTransport = class HttpTransport extends BaseRpcTransport {
+	/** Endpoint URL this transport POSTs to. */
+	url;
+	/** Options passed at construction time. */
+	options;
+	/**
+	* @param url - JSON-RPC endpoint URL (bundler, paymaster, or node)
+	* @param options - Optional fetch override and static headers
+	*/
+	constructor(url, options = {}) {
+		super();
+		this.url = url;
+		this.options = options;
 	}
-] };
-/** EIP-712 type definition for Safe UserOperation signing (EntryPoint v0.7) */
-const EIP712_SAFE_OPERATION_V7_TYPE = { SafeOp: [
-	{
-		type: "address",
-		name: "safe"
-	},
-	{
-		type: "uint256",
-		name: "nonce"
-	},
-	{
-		type: "bytes",
-		name: "initCode"
-	},
-	{
-		type: "bytes",
-		name: "callData"
-	},
-	{
-		type: "uint128",
-		name: "verificationGasLimit"
-	},
-	{
-		type: "uint128",
-		name: "callGasLimit"
-	},
-	{
-		type: "uint256",
-		name: "preVerificationGas"
-	},
-	{
-		type: "uint128",
-		name: "maxPriorityFeePerGas"
-	},
-	{
-		type: "uint128",
-		name: "maxFeePerGas"
-	},
-	{
-		type: "bytes",
-		name: "paymasterAndData"
-	},
-	{
-		type: "uint48",
-		name: "validAfter"
-	},
-	{
-		type: "uint48",
-		name: "validUntil"
-	},
-	{
-		type: "address",
-		name: "entryPoint"
+	async send(envelope, options) {
+		const headers = {
+			...this.options.headers ?? {},
+			"Content-Type": "application/json"
+		};
+		const body = HttpTransport.serializeEnvelope(envelope);
+		return await (await (this.options.fetch ?? globalThis.fetch)(this.url, {
+			method: "POST",
+			headers,
+			body,
+			redirect: "follow",
+			signal: options?.signal
+		})).json();
 	}
-] };
-/** EIP-712 primary type string used when signing multi-chain Safe operations. */
-const EIP712_MULTI_CHAIN_OPERATIONS_PRIMARY_TYPE = "MerkleTreeRoot";
-/** EIP-712 type definition for multi-chain Safe operations using Merkle tree roots */
-const EIP712_MULTI_CHAIN_OPERATIONS_TYPE = { MerkleTreeRoot: [{
-	type: "bytes32",
-	name: "merkleTreeRoot"
-}] };
-/** Default address for the secp256r1 (P-256) precompile used by WebAuthn verification */
-const DEFAULT_SECP256R1_PRECOMPILE_ADDRESS = "0x0000000000000000000000000000000000000100";
-/** Uniswap Calibur singleton v1.0.0 (EntryPoint v0.8) */
-const CALIBUR_UNISWAP_V1_0_0_SINGLETON_ADDRESS = "0x000000009B1D0aF20D8C6d0A44e162d11F9b8f00";
-/** Candide Calibur singleton v0.1.0 (EntryPoint v0.9, unaudited) */
-const CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS = "0x71032285A847c4311Eb7ec2E7A636aB94A9805Aa";
+};
+/**
+* Narrowing helper for {@link HttpTransport}. Useful for code that wants to
+* read the underlying URL — e.g. when serializing a configured Bundler for
+* logging or diagnostics.
+*
+* @example
+* ```ts
+* if (isHttpTransport(bundler.transport)) {
+*   console.log("Bundler URL:", bundler.transport.url);
+* }
+* ```
+*/
+function isHttpTransport(transport) {
+	return transport instanceof HttpTransport;
+}
 //#endregion
 //#region src/types.ts
 /**
@@ -263,560 +273,456 @@ let PolygonChain = /* @__PURE__ */ function(PolygonChain) {
 	return PolygonChain;
 }({});
 //#endregion
-//#region src/utils.ts
-function buildDomainSeparator(chainId, entrypoint) {
-	return keccak256(AbiCoder.defaultAbiCoder().encode(["(bytes32,bytes32,bytes32,uint256,address)"], [[
-		"0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f",
-		"0x364da28a5c92bcc87fe97c8813a6c6b8a3a049b0ea0a328fcb0b4f0e00337586",
-		"0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6",
-		chainId,
-		entrypoint
-	]]));
+//#region src/transport/normalize.ts
+/**
+* Recursively convert any `bigint` values inside an RPC param to `0x`-prefixed
+* hex strings, descending into arrays and plain objects. Other values pass
+* through unchanged.
+*
+* Required for user-supplied {@link Transport} implementations that don't go
+* through {@link BaseRpcTransport.serializeEnvelope} (EIP-1193 providers, viem
+* clients, etc.) and would otherwise see raw `bigint`s in `params`. Mirrors the
+* normalization done in {@link sendJsonRpcRequest}.
+*
+* @internal
+*/
+function normalizeRpcValue(value) {
+	if (typeof value === "bigint") return `0x${value.toString(16)}`;
+	if (Array.isArray(value)) return value.map(normalizeRpcValue);
+	if (value !== null && typeof value === "object") {
+		const out = {};
+		for (const [k, v] of Object.entries(value)) out[k] = normalizeRpcValue(v);
+		return out;
+	}
+	return value;
 }
 /**
-* Compute the UserOperation hash for any supported EntryPoint version.
-* This hash is what gets signed by the account owner(s).
-* Automatically selects the correct packing format based on the entrypoint address.
+* Wrap a {@link Transport} so every outbound `request` has its `params`
+* normalized (bigints → 0x-hex) before delegation. Idempotent: wrapping an
+* already-normalizing transport is harmless because the second pass sees only
+* strings.
 *
-* @param useroperation - UserOperation to hash
-* @param entrypointAddress - EntryPoint contract address (determines hash format)
-* @param chainId - Target chain ID
-* @returns The UserOperation hash as a hex string
+* Applied once at each service boundary (Bundler, CandidePaymaster,
+* Erc7677Paymaster, JsonRpcNode, …) so normalization is impossible to forget
+* per-method. Required for user-supplied transports (EIP-1193 providers, viem
+* clients, etc.) that don't route through {@link BaseRpcTransport.serializeEnvelope}.
+*
+* @internal
 */
-function createUserOperationHash(useroperation, entrypointAddress, chainId) {
-	let packedUserOperationHash;
-	const abiCoder = AbiCoder.defaultAbiCoder();
-	let userOperationHash;
-	if (entrypointAddress.toLowerCase() === "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789".toLowerCase()) {
-		packedUserOperationHash = keccak256(createPackedUserOperationV6(useroperation));
-		userOperationHash = keccak256(abiCoder.encode([
-			"bytes32",
-			"address",
-			"uint256"
-		], [
-			packedUserOperationHash,
-			entrypointAddress,
-			chainId
-		]));
-	} else if (entrypointAddress.toLowerCase() === "0x0000000071727De22E5E9d8BAf0edAc6f37da032".toLowerCase()) {
-		packedUserOperationHash = keccak256(createPackedUserOperationV7(useroperation));
-		userOperationHash = keccak256(abiCoder.encode([
-			"bytes32",
-			"address",
-			"uint256"
-		], [
-			packedUserOperationHash,
-			entrypointAddress,
-			chainId
-		]));
-	} else if (entrypointAddress.toLowerCase() === "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108".toLowerCase()) {
-		packedUserOperationHash = keccak256(createPackedUserOperationV8(useroperation));
-		userOperationHash = keccak256(`0x1901${buildDomainSeparator(chainId, entrypointAddress).slice(2)}${packedUserOperationHash.slice(2)}`);
-	} else if (entrypointAddress.toLowerCase() === "0x433709009B8330FDa32311DF1C2AFA402eD8D009".toLowerCase()) {
-		packedUserOperationHash = keccak256(createPackedUserOperationV9(useroperation));
-		userOperationHash = keccak256(`0x1901${buildDomainSeparator(chainId, entrypointAddress).slice(2)}${packedUserOperationHash.slice(2)}`);
-	} else throw new RangeError(`unsupported entrypoint address: ${entrypointAddress}`);
-	return userOperationHash;
+function normalizingTransport(inner) {
+	return { request(args, options) {
+		const params = args.params == null ? args.params : normalizeRpcValue(args.params);
+		return inner.request({
+			method: args.method,
+			params
+		}, options);
+	} };
 }
+//#endregion
+//#region src/transport/JsonRpcNode.ts
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 /**
-* @internal
-* Reconstruct the packed `initCode` field for an EntryPoint v0.8/v0.9
-* UserOperation. When `eip7702Auth.address` is set, the EIP-7702 delegatee
-* address replaces the factory address in initCode (only `factoryData` is
-* concatenated). Otherwise, behaves like v0.7 (`factory + factoryData`).
+* High-level service class for the JSON-RPC node methods abstractionkit reads
+* from. Intentionally NOT a general Ethereum client — only exposes the
+* methods the SDK actually uses. For broader functionality, drop down to
+* `.transport` and call `request({ method, params })` directly, or use a
+* dedicated library like viem / ethers.
 *
-* Shared by {@link createPackedUserOperationV8} /
-* {@link createPackedUserOperationV9} and Simple7702Account's typed-data
-* builder. Not part of the public API; only `export`ed for cross-module
-* use within the package and not re-exported from `src/abstractionkit.ts`.
+* Like {@link Bundler} and the paymaster classes, `JsonRpcNode` itself
+* implements {@link Transport} so it can be passed back into any Transport
+* position.
 *
-* @param useroperation - V8 or V9 UserOperation to read fields from
-* @returns Hex-encoded initCode
+* @example
+* ```ts
+* const node = new JsonRpcNode("https://ethereum-sepolia.publicnode.com");
+* const id = await node.chainId();
+* const code = await node.getCode("0x...");
+*
+* // Also a Transport — can be slotted in:
+* const bundler = new Bundler(node);  // bundler will speak through this node
+* ```
 */
-function buildPackedInitCodeV8V9(useroperation) {
-	if (useroperation.factory == null) return "0x";
-	const eip7702Auth = useroperation.eip7702Auth;
-	return (eip7702Auth != null && eip7702Auth.address != null ? eip7702Auth.address : useroperation.factory) + (useroperation.factoryData != null ? useroperation.factoryData.slice(2) : "");
-}
+var JsonRpcNode = class JsonRpcNode {
+	/**
+	* The raw transport the user passed in (or {@link HttpTransport} when a URL
+	* string was passed). Exposed for introspection — reading `.url`,
+	* `isHttpTransport(...)` checks, passing it back into another service.
+	*
+	* Calls made directly on this field (`node.transport.request(...)`) go
+	* to the raw transport and skip SDK-level behavior like bigint param
+	* normalization. For SDK-pipeline behavior, use {@link JsonRpcNode.request}
+	* or the typed methods.
+	*/
+	transport;
+	/** Normalizing wrapper around {@link transport}, used for every SDK-outbound call. */
+	outbound;
+	/**
+	* @param rpc - Node JSON-RPC endpoint URL, or any {@link Transport}
+	*/
+	constructor(rpc) {
+		this.transport = typeof rpc === "string" ? new HttpTransport(rpc) : rpc;
+		this.outbound = normalizingTransport(this.transport);
+	}
+	/**
+	* Normalize any acceptable input into a {@link JsonRpcNode}. Used at every
+	* public-API widening site (in account / paymaster classes). When the
+	* input is already a `JsonRpcNode`, the same instance is returned by
+	* reference, so a user's preconstructed `JsonRpcNode` is never re-wrapped.
+	*
+	* @param input - URL string, Transport, or existing JsonRpcNode
+	*/
+	static from(input) {
+		return input instanceof JsonRpcNode ? input : new JsonRpcNode(input);
+	}
+	/**
+	* Transport delegate. Routes through the normalizing wrapper so `bigint`
+	* values in `params` are converted to `0x`-hex before reaching
+	* user-supplied transports that don't go through
+	* {@link BaseRpcTransport.serializeEnvelope}. Lets a `JsonRpcNode` itself
+	* slot into any other transport position.
+	*/
+	request(args, options) {
+		return this.outbound.request(args, options);
+	}
+	/**
+	* `eth_chainId`. Returns the hex-encoded chain id (e.g. `"0xaa36a7"` for
+	* Sepolia).
+	*/
+	async chainId(options) {
+		try {
+			const result = await this.outbound.request({ method: "eth_chainId" }, options);
+			if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_chainId returned ill formed data", { context: JSON.stringify(result) });
+			return result;
+		} catch (err) {
+			throw translateNodeError(err, "eth_chainId");
+		}
+	}
+	/**
+	* `eth_blockNumber`. Returns the latest block number as a bigint.
+	*/
+	async blockNumber(options) {
+		try {
+			const result = await this.outbound.request({ method: "eth_blockNumber" }, options);
+			if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_blockNumber returned ill formed data", { context: JSON.stringify(result) });
+			return BigInt(result);
+		} catch (err) {
+			throw translateNodeError(err, "eth_blockNumber");
+		}
+	}
+	/**
+	* `eth_getCode`. Returns the deployed bytecode at `address` at the given
+	* block tag (default `"latest"`).
+	*/
+	async getCode(address, blockTag = "latest", options) {
+		try {
+			const result = await this.outbound.request({
+				method: "eth_getCode",
+				params: [address, blockTag]
+			}, options);
+			if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_getCode returned ill formed data", { context: JSON.stringify(result) });
+			return result;
+		} catch (err) {
+			throw translateNodeError(err, "eth_getCode");
+		}
+	}
+	/**
+	* `eth_call`. Executes a read-only call against `to` and returns the raw
+	* return data as a hex string. Supports state overrides via the optional
+	* third parameter.
+	*/
+	async call(tx, blockTag = "latest", stateOverrides, options) {
+		const params = stateOverrides == null ? [tx, blockTag] : [
+			tx,
+			blockTag,
+			stateOverrides
+		];
+		try {
+			const result = await this.outbound.request({
+				method: "eth_call",
+				params
+			}, options);
+			if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_call returned ill formed data", { context: JSON.stringify(result) });
+			return result;
+		} catch (err) {
+			throw translateNodeError(err, "eth_call");
+		}
+	}
+	/**
+	* `eth_getTransactionCount`. Returns the transaction count (account nonce
+	* at the EOA level — not the EntryPoint nonce; see
+	* {@link JsonRpcNode.getEntryPointNonce}) as a bigint.
+	*/
+	async getTransactionCount(address, blockTag = "latest", options) {
+		try {
+			const result = await this.outbound.request({
+				method: "eth_getTransactionCount",
+				params: [address, blockTag]
+			}, options);
+			if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_getTransactionCount returned ill formed data", { context: JSON.stringify(result) });
+			return BigInt(result);
+		} catch (err) {
+			throw translateNodeError(err, "eth_getTransactionCount");
+		}
+	}
+	/**
+	* Fetch current gas prices and apply a level multiplier.
+	*
+	* Tries `eth_maxPriorityFeePerGas` + `eth_gasPrice` first (EIP-1559),
+	* falling back to `eth_gasPrice` alone if the priority-fee method is
+	* unsupported, and finally to a 1 gwei floor multiplied by `gasLevel`.
+	*
+	* @param gasLevel - {@link GasOption} multiplier (default: Medium = 1.2x)
+	* @returns `[maxFeePerGas, maxPriorityFeePerGas]` as bigints
+	*/
+	async getFeeData(gasLevel = GasOption.Medium, options) {
+		try {
+			let gasPrice = null;
+			let maxPriorityFeePerGas = null;
+			try {
+				const result = await this.outbound.request({ method: "eth_gasPrice" }, options);
+				if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_gasPrice returned ill formed data", { context: JSON.stringify(result) });
+				gasPrice = BigInt(result);
+			} catch (err) {
+				if (!isMethodNotSupportedError(err)) throw err;
+			}
+			try {
+				const result = await this.outbound.request({ method: "eth_maxPriorityFeePerGas" }, options);
+				if (typeof result !== "string") throw new AbstractionKitError("BAD_DATA", "eth_maxPriorityFeePerGas returned ill formed data", { context: JSON.stringify(result) });
+				maxPriorityFeePerGas = BigInt(result);
+			} catch (err) {
+				if (!isMethodNotSupportedError(err)) throw err;
+			}
+			let maxFeePerGas;
+			let priorityFee;
+			if (gasPrice != null && maxPriorityFeePerGas != null) {
+				maxFeePerGas = scaleBigIntByGasLevel(gasPrice, gasLevel);
+				priorityFee = scaleBigIntByGasLevel(maxPriorityFeePerGas, gasLevel);
+			} else if (gasPrice != null) {
+				maxFeePerGas = scaleBigIntByGasLevel(gasPrice, gasLevel);
+				priorityFee = maxFeePerGas;
+			} else {
+				maxFeePerGas = scaleBigIntByGasLevel(1000000000n, gasLevel);
+				priorityFee = maxFeePerGas;
+			}
+			if (maxFeePerGas === 0n) maxFeePerGas = 1n;
+			if (priorityFee === 0n) priorityFee = 1n;
+			if (priorityFee > maxFeePerGas) maxFeePerGas = priorityFee;
+			return [maxFeePerGas, priorityFee];
+		} catch (err) {
+			throw translateNodeError(err, "getFeeData");
+		}
+	}
+	/**
+	* Check whether an address is EIP-7702-delegated and return the delegatee
+	* address. EIP-7702-delegated accounts have bytecode of the form
+	* `0xef0100<20-byte-delegatee>` per the spec.
+	*
+	* @returns The checksummed delegatee address, or `null` if not delegated
+	*/
+	async getDelegatedAddress(accountAddress, options) {
+		const code = (await this.getCode(accountAddress, "latest", options)).toLowerCase();
+		if (code.length === 48 && code.startsWith("0xef0100")) return getAddress(`0x${code.slice(8)}`);
+		return null;
+	}
+	/**
+	* Fetch the smart account's nonce from the EntryPoint contract via
+	* `eth_call`. This is the 4337 nonce (an EntryPoint-managed counter with
+	* 192-bit parallel keys), not the EOA `eth_getTransactionCount`.
+	*
+	* @param entryPoint - EntryPoint contract address
+	* @param account - Smart account address
+	* @param key - Nonce key as a `bigint` (default `0n`). Different keys allow
+	*   parallel nonce channels. `bigint` so the full `uint192` range is
+	*   representable (a JS `number` would cap at 2^53−1).
+	*/
+	async getEntryPointNonce(entryPoint, account, key = 0n, options) {
+		const data = "0x35567e1a" + AbiCoder.defaultAbiCoder().encode(["address", "uint192"], [account, key]).slice(2);
+		const callResult = await this.call({
+			from: ZERO_ADDRESS,
+			to: entryPoint,
+			data
+		}, "latest", void 0, options);
+		try {
+			return BigInt(callResult);
+		} catch (err) {
+			throw new AbstractionKitError("BAD_DATA", "getNonce returned ill formed data", {
+				cause: ensureError(err),
+				context: callResult
+			});
+		}
+	}
+	/**
+	* Get the EntryPoint deposit balance for an address.
+	*
+	* @returns The deposit balance in wei as a bigint
+	*/
+	async getEntryPointDeposit(address, entryPoint, options) {
+		return (await this.getEntryPointDepositInfo(address, entryPoint, options)).deposit;
+	}
+	/**
+	* Get the full {@link DepositInfo} for an address from the EntryPoint
+	* contract.
+	*/
+	async getEntryPointDepositInfo(address, entryPoint, options) {
+		const getDepositInfoSelector = "0x5287ce12";
+		const abiCoder = AbiCoder.defaultAbiCoder();
+		const data = getDepositInfoSelector + abiCoder.encode(["address"], [address]).slice(2);
+		const callResult = await this.call({
+			from: ZERO_ADDRESS,
+			to: entryPoint,
+			data
+		}, "latest", void 0, options);
+		try {
+			const decoded = abiCoder.decode([
+				"uint256",
+				"bool",
+				"uint112",
+				"uint32",
+				"uint48"
+			], callResult);
+			if (decoded.length !== 5) throw new AbstractionKitError("BAD_DATA", "getDepositInfo returned ill formed data", { context: JSON.stringify(decoded) });
+			return {
+				deposit: BigInt(decoded[0]),
+				staked: Boolean(decoded[1]),
+				stake: BigInt(decoded[2]),
+				unstakeDelaySec: BigInt(decoded[3]),
+				withdrawTime: BigInt(decoded[4])
+			};
+		} catch (err) {
+			if (err instanceof AbstractionKitError) throw err;
+			throw new AbstractionKitError("BAD_DATA", "getDepositInfo returned ill formed data", { cause: ensureError(err) });
+		}
+	}
+};
 /**
-* @internal
-* Reconstruct the packed `paymasterAndData` field from a UserOperation's
-* separate paymaster fields. Returns `0x` when no paymaster is set.
+* Apply a fractional `gasLevel` multiplier (e.g. 1.2 = 120%) to a `bigint`
+* gas price without going through JS number precision.
 *
-* For EntryPoint v0.9, when `paymasterData` ends with the parallel-paymaster
-* signature magic suffix (`0x22e325a297439656`), the embedded signature is
-* stripped so the userOpHash does not commit to the paymaster's signature
-* over itself. Pass `stripV9PaymasterSig=false` to preserve the wire format.
+* The naive `BigInt(Math.ceil(Number(value) * gasLevel))` truncates any
+* `value` above `Number.MAX_SAFE_INTEGER` (2^53 − 1 ≈ 9.0 × 10^15 wei),
+* which is well within the range a chain can legitimately report
+* (especially on testnets, fork networks, or anomalous mainnet spikes).
 *
-* Shared by v7/v8/v9 packers and Simple7702Account's typed-data builder.
-* Not part of the public API; only `export`ed for cross-module use within
-* the package and not re-exported from `src/abstractionkit.ts`.
+* Approach: scale the multiplier into integer space (three-decimal precision
+* — sufficient for `GasOption` and any reasonable custom value), do the
+* multiplication in `BigInt`, then ceiling-divide back down. Preserves the
+* original `Math.ceil(...)` rounding behavior bit-for-bit on small values.
 *
-* @param useroperation - V7/V8/V9 UserOperation to read fields from
-* @param stripV9PaymasterSig - Whether to strip the v0.9 paymaster signature suffix
-* @returns Hex-encoded paymasterAndData
+* @internal
 */
-function buildPaymasterAndData(useroperation, stripV9PaymasterSig = false) {
-	if (useroperation.paymaster == null) return "0x";
-	const abiCoder = AbiCoder.defaultAbiCoder();
-	let paymasterAndData = useroperation.paymaster;
-	if (useroperation.paymasterVerificationGasLimit != null) paymasterAndData += abiCoder.encode(["uint128"], [useroperation.paymasterVerificationGasLimit]).slice(34);
-	if (useroperation.paymasterPostOpGasLimit != null) paymasterAndData += abiCoder.encode(["uint128"], [useroperation.paymasterPostOpGasLimit]).slice(34);
-	if (useroperation.paymasterData != null) {
-		const PAYMASTER_SIG_MAGIC = "22e325a297439656";
-		if (stripV9PaymasterSig && useroperation.paymasterData.toLowerCase().endsWith(PAYMASTER_SIG_MAGIC)) {
-			const sigLenHex = useroperation.paymasterData.slice(useroperation.paymasterData.length - 16 - 4, useroperation.paymasterData.length - 16);
-			const sigLen = parseInt(sigLenHex, 16);
-			const prefixEnd = useroperation.paymasterData.length - 16 - 4 - sigLen * 2;
-			paymasterAndData += useroperation.paymasterData.slice(0, prefixEnd).replaceAll("0x", "") + PAYMASTER_SIG_MAGIC;
-		} else paymasterAndData += useroperation.paymasterData.slice(2);
-	}
-	return paymasterAndData;
+function scaleBigIntByGasLevel(value, gasLevel) {
+	const scale = 1000n;
+	return (value * BigInt(Math.round(gasLevel * Number(scale))) + scale - 1n) / scale;
 }
 /**
-* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.6 format).
-* Bytes fields (initCode, callData, paymasterAndData) are keccak256-hashed before packing.
+* Detect whether an error indicates the JSON-RPC method itself is not
+* implemented by the node. Used by {@link JsonRpcNode.getFeeData} to fall
+* back gracefully on chains that don't expose EIP-1559 fee methods, while
+* still surfacing transport, auth, and parse errors to the caller.
 *
-* @param useroperation - UserOperation to pack
-* @returns ABI-encoded packed UserOperation as a hex string
+* @internal
 */
-function createPackedUserOperationV6(useroperation) {
-	const useroperationValuesArrayWithHashedByteValues = [
-		useroperation.sender,
-		useroperation.nonce,
-		keccak256(useroperation.initCode),
-		keccak256(useroperation.callData),
-		useroperation.callGasLimit,
-		useroperation.verificationGasLimit,
-		useroperation.preVerificationGas,
-		useroperation.maxFeePerGas,
-		useroperation.maxPriorityFeePerGas,
-		keccak256(useroperation.paymasterAndData)
-	];
-	return AbiCoder.defaultAbiCoder().encode([
-		"address",
-		"uint256",
-		"bytes32",
-		"bytes32",
-		"uint256",
-		"uint256",
-		"uint256",
-		"uint256",
-		"uint256",
-		"bytes32"
-	], useroperationValuesArrayWithHashedByteValues);
+function isMethodNotSupportedError(err) {
+	if (err?.code === -32601) return true;
+	const message = err?.message?.toLowerCase() ?? "";
+	return message.includes("method not found") || message.includes("not supported") || message.includes("unsupported");
 }
 /**
-* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.7 format).
-* Reconstructs initCode, accountGasLimits, gasFees, and paymasterAndData from separate fields.
+* Translate a transport-level error (or already-wrapped {@link AbstractionKitError})
+* into the `NODE_ERROR` outer / specific inner shape used by {@link JsonRpcNode}.
 *
-* @param useroperation - UserOperation to pack
-* @returns ABI-encoded packed UserOperation as a hex string
-*/
-function createPackedUserOperationV7(useroperation) {
-	const abiCoder = AbiCoder.defaultAbiCoder();
-	let initCode = "0x";
-	if (useroperation.factory != null) {
-		initCode = useroperation.factory;
-		if (useroperation.factoryData != null) initCode += useroperation.factoryData.slice(2);
-	}
-	const accountGasLimits = "0x" + abiCoder.encode(["uint128"], [useroperation.verificationGasLimit]).slice(34) + abiCoder.encode(["uint128"], [useroperation.callGasLimit]).slice(34);
-	const gasFees = "0x" + abiCoder.encode(["uint128"], [useroperation.maxPriorityFeePerGas]).slice(34) + abiCoder.encode(["uint128"], [useroperation.maxFeePerGas]).slice(34);
-	const paymasterAndData = buildPaymasterAndData(useroperation);
-	const useroperationValuesArrayWithHashedByteValues = [
-		useroperation.sender,
-		useroperation.nonce,
-		keccak256(initCode),
-		keccak256(useroperation.callData),
-		accountGasLimits,
-		useroperation.preVerificationGas,
-		gasFees,
-		keccak256(paymasterAndData)
-	];
-	return abiCoder.encode([
-		"address",
-		"uint256",
-		"bytes32",
-		"bytes32",
-		"bytes32",
-		"uint256",
-		"bytes32",
-		"bytes32"
-	], useroperationValuesArrayWithHashedByteValues);
-}
-/**
-* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.9 format).
+* - `AbstractionKitError` passes through unchanged (already domain-translated).
+* - {@link ProviderRpcError} with a known JSON-RPC code → inner code from
+*   {@link JsonRpcErrorDict}.
+* - Anything else → inner `UNKNOWN_ERROR`.
 *
-* @param useroperation - UserOperation to pack
-* @returns ABI-encoded packed UserOperation as a hex string
+* @internal
 */
-function createPackedUserOperationV9(useroperation) {
-	return baseCreatePackedUserOperationV8V9(useroperation, true);
+function translateNodeError(err, method) {
+	if (err instanceof AbstractionKitError) return err;
+	const code = err?.code;
+	const codeString = code != null ? String(code) : "";
+	const innerCode = codeString in JsonRpcErrorDict ? JsonRpcErrorDict[codeString] : "UNKNOWN_ERROR";
+	const error = ensureError(err);
+	return new AbstractionKitError("NODE_ERROR", `node ${method} rpc call failed`, {
+		cause: new AbstractionKitError(innerCode, error.message, { errno: code }),
+		errno: code
+	});
 }
+//#endregion
+//#region src/Bundler.ts
 /**
-* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.8 format).
+* JSON-RPC client for an ERC-4337 bundler.
 *
-* @param useroperation - UserOperation to pack
-* @returns ABI-encoded packed UserOperation as a hex string
+* Accepts either a URL string (wrapped automatically in {@link HttpTransport})
+* or any {@link Transport} — including a viem client, an EIP-1193 wallet
+* provider, an in-process mock, or a user-composed fallback/retry transport.
+*
+* The class itself implements {@link Transport}, so a `Bundler` can be passed
+* back into any other Transport position.
+*
+* Candide bundler endpoints:
+* - `https://api.candide.dev/api/v3/{chainId}/{apiKey}` (authenticated)
+* - `https://api.candide.dev/public/v3/{chainId}` (public)
+*
+* @example URL string (most common)
+* ```ts
+* const bundler = new Bundler("https://api.candide.dev/public/v3/11155111");
+* const receipt = await bundler.getUserOperationReceipt(userOpHash);
+* ```
+*
+* @example Custom transport (composed retry behavior)
+* ```ts
+* const retryingTransport: Transport = {
+*   async request(args, options) {
+*     for (let i = 0; i < 3; i++) {
+*       try { return await inner.request(args, options); }
+*       catch (e) { if (i === 2) throw e; await sleep(2 ** i * 100); }
+*     }
+*   },
+* };
+* const bundler = new Bundler(retryingTransport);
+* ```
 */
-function createPackedUserOperationV8(useroperation) {
-	return baseCreatePackedUserOperationV8V9(useroperation, false);
-}
-/**
-* Shared packer for EntryPoint v0.8 and v0.9 UserOperations.
-* @param useroperation - UserOperation to pack
-* @param is_v9 - If true, strips the paymaster signature suffix (v0.9-specific)
-* @returns ABI-encoded packed UserOperation as a hex string
-*/
-function baseCreatePackedUserOperationV8V9(useroperation, is_v9) {
-	const abiCoder = AbiCoder.defaultAbiCoder();
-	const initCode = buildPackedInitCodeV8V9(useroperation);
-	const accountGasLimits = "0x" + abiCoder.encode(["uint128"], [useroperation.verificationGasLimit]).slice(34) + abiCoder.encode(["uint128"], [useroperation.callGasLimit]).slice(34);
-	const gasFees = "0x" + abiCoder.encode(["uint128"], [useroperation.maxPriorityFeePerGas]).slice(34) + abiCoder.encode(["uint128"], [useroperation.maxFeePerGas]).slice(34);
-	const paymasterAndData = buildPaymasterAndData(useroperation, is_v9);
-	const useroperationValuesArrayWithHashedByteValues = [
-		"0x29a0bca4af4be3421398da00295e58e6d7de38cb492214754cb6a47507dd6f8e",
-		useroperation.sender,
-		useroperation.nonce,
-		keccak256(initCode),
-		keccak256(useroperation.callData),
-		accountGasLimits,
-		useroperation.preVerificationGas,
-		gasFees,
-		keccak256(paymasterAndData)
-	];
-	return abiCoder.encode([
-		"bytes32",
-		"address",
-		"uint256",
-		"bytes32",
-		"bytes32",
-		"bytes32",
-		"uint256",
-		"bytes32",
-		"bytes32"
-	], useroperationValuesArrayWithHashedByteValues);
-}
-/**
-* Encode a function call into ABI-encoded calldata.
-*
-* @param functionSelector - 4-byte hex function selector (e.g., "0xa9059cbb" for ERC-20 transfer)
-* @param functionInputAbi - Array of ABI type strings (e.g., ["address", "uint256"])
-* @param functionInputParameters - Array of parameter values matching the ABI types
-* @returns ABI-encoded calldata as a hex string (selector + encoded parameters)
-*
-* @example
-* const transferCallData = createCallData(
-*   "0xa9059cbb",
-*   ["address", "uint256"],
-*   ["0xRecipientAddress", 1000000n],
-* );
-*/
-function createCallData(functionSelector, functionInputAbi, functionInputParameters) {
-	return functionSelector + AbiCoder.defaultAbiCoder().encode(functionInputAbi, functionInputParameters).slice(2);
-}
-/**
-* Send a JSON-RPC request to the specified endpoint.
-* Automatically converts bigint values to hex strings in the request body.
-*
-* @param rpcUrl - The JSON-RPC endpoint URL (bundler, node, or paymaster)
-* @param method - The JSON-RPC method name (e.g., "eth_call", "eth_sendUserOperation")
-* @param params - The JSON-RPC parameters
-* @param headers - Custom HTTP headers (defaults to Content-Type: application/json)
-* @param paramsKeyName - Key name for the params field (defaults to "params")
-* @returns The result field from the JSON-RPC response
-* @throws AbstractionKitError if the RPC returns an error
-*/
-async function sendJsonRpcRequest(rpcUrl, method, params, headers = { "Content-Type": "application/json" }, paramsKeyName = "params") {
-	const requestOptions = {
-		method: "POST",
-		headers,
-		body: JSON.stringify({
-			method,
-			[paramsKeyName]: params,
-			id: Date.now(),
-			jsonrpc: "2.0"
-		}, (_key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value),
-		redirect: "follow"
-	};
-	const response = await (await fetch(rpcUrl, requestOptions)).json();
-	if ("result" in response) return response.result;
-	else if ("simulation_results" in response) return response.simulation_results;
-	else {
-		const err = response.error;
-		const codeString = String(err.code);
-		if (codeString in BundlerErrorCodeDict) throw new AbstractionKitError(BundlerErrorCodeDict[codeString], err.message, {
-			errno: err.code,
-			context: {
-				url: rpcUrl,
-				requestOptions: JSON.stringify(requestOptions)
-			}
-		});
-		else throw new AbstractionKitError("UNKNOWN_ERROR", err.message, {
-			errno: err.code,
-			context: {
-				url: rpcUrl,
-				requestOptions: JSON.stringify(requestOptions)
-			}
-		});
-	}
-}
-/**
-* Get a 4-byte function selector from a Solidity-style function signature.
-* Computed as the first 4 bytes of keccak256(signature).
-* @param functionSignature - Solidity-style function signature, e.g. "mint(address)"
-* @returns Function selector as a 0x-prefixed 10-character hex string
-*
-* @example
-* getFunctionSelector("getNonce(address,uint192)"); // "0x35567e1a"
-*/
-function getFunctionSelector(functionSignature) {
-	return id(functionSignature).slice(0, 10);
-}
-/**
-* Fetch the account's nonce from the EntryPoint contract.
-*
-* @param rpcUrl - Ethereum JSON-RPC node URL
-* @param entryPoint - EntryPoint contract address
-* @param account - Smart account address to query
-* @param key - Nonce key (default 0). Different keys allow parallel nonce channels.
-* @returns The current nonce as a bigint
-* @throws AbstractionKitError with code "BAD_DATA" if the nonce call fails
-*/
-async function fetchAccountNonce(rpcUrl, entryPoint, account, key = 0) {
-	const params = [{
-		from: "0x0000000000000000000000000000000000000000",
-		to: entryPoint,
-		data: createCallData(getFunctionSelector("getNonce(address,uint192)"), ["address", "uint192"], [account, key])
-	}, "latest"];
-	try {
-		const nonce = await sendJsonRpcRequest(rpcUrl, "eth_call", params);
-		if (typeof nonce === "string") try {
-			return BigInt(nonce);
-		} catch (err) {
-			throw new AbstractionKitError("BAD_DATA", "getNonce returned ill formed data", { cause: ensureError(err) });
-		}
-		else throw new AbstractionKitError("BAD_DATA", "getNonce returned ill formed data", { context: JSON.stringify(nonce) });
-	} catch (err) {
-		throw new AbstractionKitError("BAD_DATA", "getNonce failed", { cause: ensureError(err) });
-	}
-}
-/**
-* Fetch current gas prices from a JSON-RPC node.
-* Applies a gas level multiplier to adjust for faster or cheaper inclusion.
-*
-* @param provideRpc - Ethereum JSON-RPC node URL
-* @param gasLevel - Gas price multiplier (default: GasOption.Medium = 1.2x)
-* @returns A tuple of [maxFeePerGas, maxPriorityFeePerGas] as bigints
-*/
-async function fetchGasPrice(provideRpc, gasLevel = GasOption.Medium) {
-	try {
-		const feeData = await new JsonRpcProvider(provideRpc).getFeeData();
-		let maxFeePerGas;
-		let maxPriorityFeePerGas;
-		if (feeData.maxFeePerGas != null && feeData.maxPriorityFeePerGas != null) {
-			maxFeePerGas = BigInt(Math.ceil(Number(feeData.maxFeePerGas) * gasLevel));
-			maxPriorityFeePerGas = BigInt(Math.ceil(Number(feeData.maxPriorityFeePerGas) * gasLevel));
-		} else if (feeData.gasPrice != null) {
-			maxFeePerGas = BigInt(Math.ceil(Number(feeData.gasPrice) * gasLevel));
-			maxPriorityFeePerGas = maxFeePerGas;
-		} else {
-			maxFeePerGas = BigInt(Math.ceil(1e9 * gasLevel));
-			maxPriorityFeePerGas = maxFeePerGas;
-		}
-		if (maxFeePerGas === 0n) maxFeePerGas = 1n;
-		if (maxPriorityFeePerGas === 0n) maxPriorityFeePerGas = 1n;
-		return [maxFeePerGas, maxPriorityFeePerGas];
-	} catch (err) {
-		throw new AbstractionKitError("BAD_DATA", "fetching gas prices from node failed.", { cause: ensureError(err) });
-	}
-}
-/**
-* Fetch current gas prices from the Polygon Gas Station API.
-*
-* @param polygonChain - Target Polygon chain (Mainnet, Amoy, etc.)
-* @param gasLevel - Gas price level (Slow, Medium, Fast)
-* @returns A tuple of [maxFeePerGas, maxPriorityFeePerGas] as bigints
-*/
-async function fetchGasPricePolygon(polygonChain, gasLevel = GasOption.Medium) {
-	const gasStationUrl = `https://gasstation.polygon.technology/${polygonChain}`;
-	try {
-		const response = await (await fetch(gasStationUrl)).json();
-		let gasPrice;
-		if (gasLevel === GasOption.Slow) gasPrice = response.safeLow;
-		else if (gasLevel === GasOption.Medium) gasPrice = response.standard;
-		else gasPrice = response.fast;
-		let maxFeePerGas = BigInt(Math.ceil(Number(gasPrice.maxFee) * 1e9));
-		let maxPriorityFeePerGas = BigInt(Math.ceil(Number(gasPrice.maxPriorityFee) * 1e9));
-		if (maxFeePerGas === 0n) maxFeePerGas = 1n;
-		if (maxPriorityFeePerGas === 0n) maxPriorityFeePerGas = 1n;
-		return [maxFeePerGas, maxPriorityFeePerGas];
-	} catch (err) {
-		const error = ensureError(err);
-		throw new AbstractionKitError("BAD_DATA", `fetching gas prices from ${gasStationUrl} failed.`, { cause: error });
-	}
-}
-/**
-* Calculate the maximum gas cost (in wei) that a UserOperation could consume.
-* Uses different formulas for v0.6 (with paymaster multiplier) and v0.7+ UserOperations.
-*
-* @param useroperation - The UserOperation to calculate the max gas cost for
-* @returns Maximum possible gas cost in wei as a bigint
-*/
-function calculateUserOperationMaxGasCost(useroperation) {
-	if ("initCode" in useroperation) {
-		const mul = useroperation.paymasterAndData !== "0x" && useroperation.paymasterAndData != null ? 3n : 0n;
-		return (useroperation.callGasLimit + useroperation.verificationGasLimit * mul + useroperation.preVerificationGas) * useroperation.maxFeePerGas;
-	} else return (useroperation.verificationGasLimit + useroperation.callGasLimit + (useroperation.paymasterVerificationGasLimit ?? 0n) + (useroperation.paymasterPostOpGasLimit ?? 0n) + useroperation.preVerificationGas) * useroperation.maxFeePerGas;
-}
-/**
-* Get the deposit balance of an address in the EntryPoint contract.
-*
-* @param nodeRpcUrl - Ethereum JSON-RPC node URL
-* @param address - Address to query the deposit for
-* @param entrypointAddress - EntryPoint contract address
-* @returns The deposit balance as a bigint
-*/
-async function getBalanceOf(nodeRpcUrl, address, entrypointAddress) {
-	return (await getDepositInfo(nodeRpcUrl, address, entrypointAddress)).deposit;
-}
-/**
-* Get the full deposit info of an address from the EntryPoint contract.
-*
-* @param nodeRpcUrl - Ethereum JSON-RPC node URL
-* @param address - Address to query
-* @param entrypointAddress - EntryPoint contract address
-* @returns DepositInfo with deposit, staked, stake, unstakeDelaySec, withdrawTime
-*/
-async function getDepositInfo(nodeRpcUrl, address, entrypointAddress) {
-	const params = {
-		from: "0x0000000000000000000000000000000000000000",
-		to: entrypointAddress,
-		data: createCallData("0x5287ce12", ["address"], [address])
-	};
-	try {
-		const depositInfoRequestResult = await sendEthCallRequest(nodeRpcUrl, params, "latest");
-		const decodedCalldata = AbiCoder.defaultAbiCoder().decode([
-			"uint256",
-			"bool",
-			"uint112",
-			"uint32",
-			"uint48"
-		], depositInfoRequestResult);
-		if (decodedCalldata.length === 5) try {
-			return {
-				deposit: BigInt(decodedCalldata[0]),
-				staked: Boolean(decodedCalldata[1]),
-				stake: BigInt(decodedCalldata[2]),
-				unstakeDelaySec: BigInt(decodedCalldata[3]),
-				withdrawTime: BigInt(decodedCalldata[4])
-			};
-		} catch (err) {
-			throw new AbstractionKitError("BAD_DATA", "getDepositInfo returned ill formed data", { cause: ensureError(err) });
-		}
-		else throw new AbstractionKitError("BAD_DATA", "getDepositInfo returned ill formed data", { context: JSON.stringify(decodedCalldata) });
-	} catch (err) {
-		throw new AbstractionKitError("BAD_DATA", "getDepositInfo failed", { cause: ensureError(err) });
-	}
-}
-/**
-* Send an eth_call JSON-RPC request with optional state overrides.
-*
-* @param nodeRpcUrl - Ethereum JSON-RPC node URL
-* @param ethCallTransaction - The call transaction parameters
-* @param blockNumber - Block number or "latest"
-* @param stateOverrides - Optional state overrides for the call
-* @returns The call result as a hex string
-*/
-async function sendEthCallRequest(nodeRpcUrl, ethCallTransaction, blockNumber, stateOverrides) {
-	let params = [];
-	if (stateOverrides == null) params = [ethCallTransaction, blockNumber];
-	else params = [
-		ethCallTransaction,
-		blockNumber,
-		stateOverrides
-	];
-	try {
-		const data = await sendJsonRpcRequest(nodeRpcUrl, "eth_call", params);
-		if (typeof data === "string") try {
-			return data;
-		} catch (err) {
-			throw new AbstractionKitError("BAD_DATA", "eth_call returned ill formed data", { cause: ensureError(err) });
-		}
-		else throw new AbstractionKitError("BAD_DATA", "eth_call returned ill formed data", { context: JSON.stringify(data) });
-	} catch (err) {
-		throw new AbstractionKitError("BAD_DATA", "eth_call failed", { cause: ensureError(err) });
+var Bundler = class Bundler {
+	/**
+	* The raw transport the user passed in (or {@link HttpTransport} when a URL
+	* string was passed). Exposed for introspection — reading `.url`,
+	* `isHttpTransport(...)` checks, passing it back into another service.
+	*
+	* Calls made directly on this field (`bundler.transport.request(...)`) go
+	* to the raw transport and skip SDK-level behavior like bigint param
+	* normalization. For SDK-pipeline behavior, use {@link Bundler.request} or
+	* the typed methods.
+	*/
+	transport;
+	/** Normalizing wrapper around {@link transport}, used for every SDK-outbound call. */
+	outbound;
+	/**
+	* @param rpc - Bundler JSON-RPC endpoint URL, or any {@link Transport}.
+	*/
+	constructor(rpc) {
+		this.transport = typeof rpc === "string" ? new HttpTransport(rpc) : rpc;
+		this.outbound = normalizingTransport(this.transport);
 	}
-}
-/**
-* Send an eth_getCode JSON-RPC request to check deployed bytecode.
-*
-* @param nodeRpcUrl - Ethereum JSON-RPC node URL
-* @param contractAddress - Contract address to query
-* @param blockNumber - Block number or "latest"
-* @returns The deployed bytecode as a hex string
-*/
-async function sendEthGetCodeRequest(nodeRpcUrl, contractAddress, blockNumber) {
-	const params = [contractAddress, blockNumber];
-	try {
-		const data = await sendJsonRpcRequest(nodeRpcUrl, "eth_getCode", params);
-		if (typeof data === "string") try {
-			return data;
-		} catch (err) {
-			throw new AbstractionKitError("BAD_DATA", "eth_getCode returned ill formed data", { cause: ensureError(err) });
-		}
-		else throw new AbstractionKitError("BAD_DATA", "eth_getCode returned ill formed data", { context: JSON.stringify(data) });
-	} catch (err) {
-		throw new AbstractionKitError("BAD_DATA", "eth_getCode failed", { cause: ensureError(err) });
+	/**
+	* Normalize any acceptable input into a `Bundler`. When the input is
+	* already a `Bundler` instance, it is returned by reference (so a user's
+	* pre-constructed Bundler is never re-wrapped and its transport is
+	* reused for follow-up calls like {@link SendUseroperationResponse.included}).
+	*
+	* @param input - URL string, Transport, or existing Bundler
+	*/
+	static from(input) {
+		return input instanceof Bundler ? input : new Bundler(input);
 	}
-}
-/**
-* Check if an address is delegated via EIP-7702 and return the delegatee address.
-* EIP-7702 delegated accounts have bytecode in the format `0xef0100` + 20-byte address.
-*
-* @param accountAddress - The address to check
-* @param providerRpc - Ethereum JSON-RPC node URL
-* @returns The checksummed delegatee address, or `null` if not delegated
-*/
-async function getDelegatedAddress(accountAddress, providerRpc) {
-	const code = (await sendEthGetCodeRequest(providerRpc, accountAddress, "latest")).toLowerCase();
-	if (code.length === 48 && code.startsWith("0xef0100")) return getAddress(`0x${code.slice(8)}`);
-	return null;
-}
-/**
-* Fetch gas prices using either the Polygon Gas Station or a standard JSON-RPC node.
-*
-* @param providerRpc - Ethereum JSON-RPC node URL (used if polygonGasStation is null)
-* @param polygonGasStation - Polygon chain to use for gas station (takes priority)
-* @param gasLevel - Gas price multiplier (default: GasOption.Medium)
-* @returns A tuple of [maxFeePerGas, maxPriorityFeePerGas] as bigints
-*/
-async function handlefetchGasPrice(providerRpc, polygonGasStation, gasLevel = GasOption.Medium) {
-	let maxFeePerGas;
-	let maxPriorityFeePerGas;
-	if (polygonGasStation != null) [maxFeePerGas, maxPriorityFeePerGas] = await fetchGasPricePolygon(polygonGasStation, gasLevel);
-	else if (providerRpc != null) [maxFeePerGas, maxPriorityFeePerGas] = await fetchGasPrice(providerRpc, gasLevel);
-	else throw new AbstractionKitError("BAD_DATA", "providerRpc can't be null if maxFeePerGas and maxPriorityFeePerGas are not overridden");
-	return [maxFeePerGas, maxPriorityFeePerGas];
-}
-//#endregion
-//#region src/Bundler.ts
-/**
-* JSON-RPC client for an ERC-4337 bundler.
-*
-* Candide bundler endpoints:
-* - `https://api.candide.dev/api/v3/{chainId}/{apiKey}` (authenticated)
-* - `https://api.candide.dev/public/v3/{chainId}` (public)
-*
-* @example
-* const bundler = new Bundler("https://api.candide.dev/public/v3/11155111");
-* const receipt = await bundler.getUserOperationReceipt(userOpHash);
-*/
-var Bundler = class {
-	rpcUrl;
-	/** @param rpcUrl - The bundler JSON-RPC endpoint URL */
-	constructor(rpcUrl) {
-		this.rpcUrl = rpcUrl;
+	/**
+	* Transport delegate. Forwards directly to the underlying
+	* {@link Transport.request}. Lets a `Bundler` itself slot into any other
+	* transport position.
+	*/
+	request(args, options) {
+		return this.outbound.request(args, options);
 	}
 	/**
 	* Get the bundler's chain ID.
@@ -824,11 +730,11 @@ var Bundler = class {
 	*/
 	async chainId() {
 		try {
-			const chainId = await sendJsonRpcRequest(this.rpcUrl, "eth_chainId", []);
-			if (typeof chainId === "string") return chainId;
-			else throw new AbstractionKitError("BAD_DATA", "bundler eth_chainId rpc call failed");
+			const chainId = await this.outbound.request({ method: "eth_chainId" });
+			if (typeof chainId !== "string") throw new AbstractionKitError("BAD_DATA", "bundler eth_chainId rpc call failed");
+			return chainId;
 		} catch (err) {
-			throw new AbstractionKitError("BUNDLER_ERROR", "bundler eth_chainId rpc call failed", { cause: ensureError(err) });
+			throw translateBundlerError(err, "eth_chainId");
 		}
 	}
 	/**
@@ -837,9 +743,9 @@ var Bundler = class {
 	*/
 	async supportedEntryPoints() {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, "eth_supportedEntryPoints", []);
+			return await this.outbound.request({ method: "eth_supportedEntryPoints" });
 		} catch (err) {
-			throw new AbstractionKitError("BUNDLER_ERROR", "bundler eth_supportedEntryPoints rpc call failed", { cause: ensureError(err) });
+			throw translateBundlerError(err, "eth_supportedEntryPoints");
 		}
 	}
 	/**
@@ -851,14 +757,15 @@ var Bundler = class {
 	*/
 	async estimateUserOperationGas(useroperation, entrypointAddress, state_override_set) {
 		try {
-			let jsonRpcResult = {};
-			if (typeof state_override_set === "undefined") jsonRpcResult = await sendJsonRpcRequest(this.rpcUrl, "eth_estimateUserOperationGas", [useroperation, entrypointAddress]);
-			else jsonRpcResult = await sendJsonRpcRequest(this.rpcUrl, "eth_estimateUserOperationGas", [
+			const params = state_override_set == null ? [useroperation, entrypointAddress] : [
 				useroperation,
 				entrypointAddress,
 				state_override_set
-			]);
-			const res = jsonRpcResult;
+			];
+			const res = await this.outbound.request({
+				method: "eth_estimateUserOperationGas",
+				params
+			});
 			const gasEstimationResult = {
 				callGasLimit: BigInt(res.callGasLimit),
 				preVerificationGas: BigInt(res.preVerificationGas),
@@ -868,7 +775,7 @@ var Bundler = class {
 			if (res.paymasterPostOpGasLimit != null) gasEstimationResult.paymasterPostOpGasLimit = BigInt(res.paymasterPostOpGasLimit);
 			return gasEstimationResult;
 		} catch (err) {
-			throw new AbstractionKitError("BUNDLER_ERROR", "bundler eth_estimateUserOperationGas rpc call failed", { cause: ensureError(err) });
+			throw translateBundlerError(err, "eth_estimateUserOperationGas");
 		}
 	}
 	/**
@@ -879,9 +786,12 @@ var Bundler = class {
 	*/
 	async sendUserOperation(useroperation, entrypointAddress) {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, "eth_sendUserOperation", [useroperation, entrypointAddress]);
+			return await this.outbound.request({
+				method: "eth_sendUserOperation",
+				params: [useroperation, entrypointAddress]
+			});
 		} catch (err) {
-			throw new AbstractionKitError("BUNDLER_ERROR", "bundler eth_sendUserOperation rpc call failed", { cause: ensureError(err) });
+			throw translateBundlerError(err, "eth_sendUserOperation");
 		}
 	}
 	/**
@@ -891,31 +801,31 @@ var Bundler = class {
 	*/
 	async getUserOperationReceipt(useroperationhash) {
 		try {
-			const res = await sendJsonRpcRequest(this.rpcUrl, "eth_getUserOperationReceipt", [useroperationhash]);
-			if (res != null) {
-				const userOperationReceipt = {
-					...res.receipt,
-					blockNumber: BigInt(res.receipt.blockNumber),
-					cumulativeGasUsed: BigInt(res.receipt.cumulativeGasUsed),
-					gasUsed: BigInt(res.receipt.gasUsed),
-					transactionIndex: BigInt(res.receipt.transactionIndex),
-					effectiveGasPrice: res.receipt.effectiveGasPrice == null ? void 0 : BigInt(res.receipt.effectiveGasPrice),
-					logs: JSON.stringify(res.receipt.logs)
-				};
-				return {
-					...res,
-					nonce: BigInt(res.nonce),
-					actualGasCost: BigInt(res.actualGasCost),
-					actualGasUsed: BigInt(res.actualGasUsed),
-					logs: JSON.stringify(res.logs),
-					receipt: userOperationReceipt
-				};
-			} else return null;
-		} catch (err) {
-			throw new AbstractionKitError("BUNDLER_ERROR", "bundler eth_getUserOperationReceipt rpc call failed", {
-				cause: ensureError(err),
-				context: { useroperationhash }
+			const jsonRpcResult = await this.outbound.request({
+				method: "eth_getUserOperationReceipt",
+				params: [useroperationhash]
 			});
+			if (jsonRpcResult == null) return null;
+			const res = jsonRpcResult;
+			const userOperationReceipt = {
+				...res.receipt,
+				blockNumber: BigInt(res.receipt.blockNumber),
+				cumulativeGasUsed: BigInt(res.receipt.cumulativeGasUsed),
+				gasUsed: BigInt(res.receipt.gasUsed),
+				transactionIndex: BigInt(res.receipt.transactionIndex),
+				effectiveGasPrice: res.receipt.effectiveGasPrice == null ? void 0 : BigInt(res.receipt.effectiveGasPrice),
+				logs: JSON.stringify(res.receipt.logs)
+			};
+			return {
+				...res,
+				nonce: BigInt(res.nonce),
+				actualGasCost: BigInt(res.actualGasCost),
+				actualGasUsed: BigInt(res.actualGasUsed),
+				logs: JSON.stringify(res.logs),
+				receipt: userOperationReceipt
+			};
+		} catch (err) {
+			throw translateBundlerError(err, "eth_getUserOperationReceipt", { useroperationhash });
 		}
 	}
 	/**
@@ -925,43 +835,233 @@ var Bundler = class {
 	*/
 	async getUserOperationByHash(useroperationhash) {
 		try {
-			const res = await sendJsonRpcRequest(this.rpcUrl, "eth_getUserOperationByHash", [useroperationhash]);
-			if (res != null) return {
-				...res,
-				blockNumber: res.blockNumber == null ? null : BigInt(res.blockNumber)
+			const jsonRpcResult = await this.outbound.request({
+				method: "eth_getUserOperationByHash",
+				params: [useroperationhash]
+			});
+			if (jsonRpcResult == null) return null;
+			return {
+				...jsonRpcResult,
+				blockNumber: jsonRpcResult.blockNumber == null ? null : BigInt(jsonRpcResult.blockNumber)
 			};
-			else return null;
 		} catch (err) {
-			throw new AbstractionKitError("BUNDLER_ERROR", "bundler eth_getUserOperationByHash rpc call failed", {
-				cause: ensureError(err),
-				context: { useroperationhash }
-			});
+			throw translateBundlerError(err, "eth_getUserOperationByHash", { useroperationhash });
 		}
 	}
 };
-//#endregion
-//#region src/signer/negotiate.ts
 /**
-* Pick the best mutually-supported signing scheme for one signer against an
-* account's accepted schemes. Later in the `accepted` array = lower preference;
-* the account ranks by preference.
+* Translate a transport-level error (or already-wrapped
+* {@link AbstractionKitError}) into the `BUNDLER_ERROR` outer / specific
+* 4337-code inner shape used by {@link Bundler}.
 *
-* Throws a detailed {@link AbstractionKitError} if no scheme overlaps,
-* citing the signer's address, what the account accepts, and what the
-* signer can do.
+* - `AbstractionKitError` passes through unchanged (already domain-translated).
+* - {@link ProviderRpcError} with a known 4337 code → inner code from
+*   {@link BundlerErrorCodeDict}.
+* - Anything else → inner `UNKNOWN_ERROR`.
+*
+* @internal
 */
-function pickScheme(signer, accepted, context) {
-	const signerCan = [];
-	if (typeof signer.signTypedData === "function") signerCan.push("typedData");
-	if (typeof signer.signHash === "function") signerCan.push("hash");
-	for (const scheme of accepted) if (signerCan.includes(scheme)) return scheme;
-	throw new AbstractionKitError("BAD_DATA", buildMismatchMessage({
-		accountName: context.accountName,
-		signerIndex: context.signerIndex,
-		signerAddress: signer.address,
-		accepted,
-		signerCan
-	}));
+function translateBundlerError(err, method, context) {
+	if (err instanceof AbstractionKitError) {
+		if (err.code === "BUNDLER_ERROR") return err;
+		return new AbstractionKitError("BUNDLER_ERROR", `bundler ${method} rpc call failed`, {
+			cause: err,
+			errno: err.errno,
+			context
+		});
+	}
+	const code = err?.code;
+	const codeString = code != null ? String(code) : "";
+	const innerCode = codeString in BundlerErrorCodeDict ? BundlerErrorCodeDict[codeString] : "UNKNOWN_ERROR";
+	const error = ensureError(err);
+	return new AbstractionKitError("BUNDLER_ERROR", `bundler ${method} rpc call failed`, {
+		cause: new AbstractionKitError(innerCode, error.message, { errno: code }),
+		errno: code,
+		context
+	});
+}
+//#endregion
+//#region src/constants.ts
+/** The Ethereum zero address (0x0000...0000), used as a placeholder for empty/null addresses */
+const ZeroAddress = "0x0000000000000000000000000000000000000000";
+/** EntryPoint v0.9 contract address */
+const ENTRYPOINT_V9 = "0x433709009B8330FDa32311DF1C2AFA402eD8D009";
+/** EntryPoint v0.8 contract address */
+const ENTRYPOINT_V8 = "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
+/** EntryPoint v0.7 contract address */
+const ENTRYPOINT_V7 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+/** EntryPoint v0.6 contract address */
+const ENTRYPOINT_V6 = "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";
+/** Safe L2 singleton v1.5.0 address and init hash */
+const Safe_L2_V1_5_0 = {
+	singletonAddress: "0xEdd160fEBBD92E350D4D398fb636302fccd67C7e",
+	singletonInitHash: "0x1b94aebb5a7df6dff11d93589204a6bbc99b4b8c9014bf1d386d006c2c17a881"
+};
+/** Safe L2 singleton v1.4.1 address and init hash */
+const Safe_L2_V1_4_1 = {
+	singletonAddress: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
+	singletonInitHash: "0xe298282cefe913ab5d282047161268a8222e4bd4ed106300c547894bbefd31ee"
+};
+/** Default placeholder values for gas estimation before actual values are known */
+const BaseUserOperationDummyValues = {
+	sender: ZeroAddress,
+	nonce: 0n,
+	callData: "0x",
+	callGasLimit: 0n,
+	verificationGasLimit: 0n,
+	preVerificationGas: 0n,
+	maxFeePerGas: 0n,
+	maxPriorityFeePerGas: 0n,
+	signature: "0x"
+};
+/** EIP-712 primary type string used when signing Safe UserOperations. */
+const EIP712_SAFE_OPERATION_PRIMARY_TYPE = "SafeOp";
+/** EIP-712 type definition for Safe UserOperation signing (EntryPoint v0.6) */
+const EIP712_SAFE_OPERATION_V6_TYPE = { SafeOp: [
+	{
+		type: "address",
+		name: "safe"
+	},
+	{
+		type: "uint256",
+		name: "nonce"
+	},
+	{
+		type: "bytes",
+		name: "initCode"
+	},
+	{
+		type: "bytes",
+		name: "callData"
+	},
+	{
+		type: "uint256",
+		name: "callGasLimit"
+	},
+	{
+		type: "uint256",
+		name: "verificationGasLimit"
+	},
+	{
+		type: "uint256",
+		name: "preVerificationGas"
+	},
+	{
+		type: "uint256",
+		name: "maxFeePerGas"
+	},
+	{
+		type: "uint256",
+		name: "maxPriorityFeePerGas"
+	},
+	{
+		type: "bytes",
+		name: "paymasterAndData"
+	},
+	{
+		type: "uint48",
+		name: "validAfter"
+	},
+	{
+		type: "uint48",
+		name: "validUntil"
+	},
+	{
+		type: "address",
+		name: "entryPoint"
+	}
+] };
+/** EIP-712 type definition for Safe UserOperation signing (EntryPoint v0.7) */
+const EIP712_SAFE_OPERATION_V7_TYPE = { SafeOp: [
+	{
+		type: "address",
+		name: "safe"
+	},
+	{
+		type: "uint256",
+		name: "nonce"
+	},
+	{
+		type: "bytes",
+		name: "initCode"
+	},
+	{
+		type: "bytes",
+		name: "callData"
+	},
+	{
+		type: "uint128",
+		name: "verificationGasLimit"
+	},
+	{
+		type: "uint128",
+		name: "callGasLimit"
+	},
+	{
+		type: "uint256",
+		name: "preVerificationGas"
+	},
+	{
+		type: "uint128",
+		name: "maxPriorityFeePerGas"
+	},
+	{
+		type: "uint128",
+		name: "maxFeePerGas"
+	},
+	{
+		type: "bytes",
+		name: "paymasterAndData"
+	},
+	{
+		type: "uint48",
+		name: "validAfter"
+	},
+	{
+		type: "uint48",
+		name: "validUntil"
+	},
+	{
+		type: "address",
+		name: "entryPoint"
+	}
+] };
+/** EIP-712 primary type string used when signing multi-chain Safe operations. */
+const EIP712_MULTI_CHAIN_OPERATIONS_PRIMARY_TYPE = "MerkleTreeRoot";
+/** EIP-712 type definition for multi-chain Safe operations using Merkle tree roots */
+const EIP712_MULTI_CHAIN_OPERATIONS_TYPE = { MerkleTreeRoot: [{
+	type: "bytes32",
+	name: "merkleTreeRoot"
+}] };
+/** Default address for the secp256r1 (P-256) precompile used by WebAuthn verification */
+const DEFAULT_SECP256R1_PRECOMPILE_ADDRESS = "0x0000000000000000000000000000000000000100";
+/** Uniswap Calibur singleton v1.0.0 (EntryPoint v0.8) */
+const CALIBUR_UNISWAP_V1_0_0_SINGLETON_ADDRESS = "0x000000009B1D0aF20D8C6d0A44e162d11F9b8f00";
+/** Candide Calibur singleton v0.1.0 (EntryPoint v0.9, unaudited) */
+const CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS = "0x71032285A847c4311Eb7ec2E7A636aB94A9805Aa";
+//#endregion
+//#region src/signer/negotiate.ts
+/**
+* Pick the best mutually-supported signing scheme for one signer against an
+* account's accepted schemes. Later in the `accepted` array = lower preference;
+* the account ranks by preference.
+*
+* Throws a detailed {@link AbstractionKitError} if no scheme overlaps,
+* citing the signer's address, what the account accepts, and what the
+* signer can do.
+*/
+function pickScheme(signer, accepted, context) {
+	const signerCan = [];
+	if (typeof signer.signTypedData === "function") signerCan.push("typedData");
+	if (typeof signer.signHash === "function") signerCan.push("hash");
+	for (const scheme of accepted) if (signerCan.includes(scheme)) return scheme;
+	throw new AbstractionKitError("BAD_DATA", buildMismatchMessage({
+		accountName: context.accountName,
+		signerIndex: context.signerIndex,
+		signerAddress: signer.address,
+		accepted,
+		signerCan
+	}));
 }
 function buildMismatchMessage(params) {
 	const { accountName, signerIndex, signerAddress, accepted, signerCan } = params;
@@ -971,7 +1071,7 @@ function buildMismatchMessage(params) {
 /**
 * Invoke a signer for one scheme. Keeps the dispatch in one place so the
 * account-side code stays linear. `typedData` is optional: accounts that
-* only accept the `"hash"` scheme (Simple7702, Calibur) pass just `hash`.
+* only accept the `"hash"` scheme can pass just `hash`.
 *
 * `context` is always forwarded to the signer so power-user implementations
 * can inspect the userOp.
@@ -1194,45 +1294,540 @@ function encodeAccessList(access_list) {
 	}
 	return encoded_access_list;
 }
-/** Converts a bigint to a Uint8Array of its big-endian byte representation. */
-function bigintToBytes(bi) {
-	return getBytes(toBeArray(bi));
+/** Converts a bigint to a Uint8Array of its big-endian byte representation. */
+function bigintToBytes(bi) {
+	return getBytes(toBeArray(bi));
+}
+/**
+* Parse a raw ECDSA signature into its components.
+* Supports standard 65-byte (r + s + v) and EIP-2098 64-byte compact formats.
+* @param rawSig - Hex string: 128 chars (EIP-2098 compact), or 130/132 chars (standard with 0x prefix)
+* @returns An object with yParity (0 or 1), r, and s components
+*/
+function parseRawSignature(rawSig) {
+	const sig = rawSig.startsWith("0x") ? rawSig.slice(2) : rawSig;
+	if (sig.length !== 128 && sig.length !== 130) throw new RangeError(`invalid signature length: expected 128 (EIP-2098 compact) or 130 (standard) hex chars, got ${sig.length}`);
+	const r = BigInt(`0x${sig.slice(0, 64)}`);
+	if (sig.length === 128) {
+		const yParityAndS = BigInt(`0x${sig.slice(64, 128)}`);
+		return {
+			yParity: Number(yParityAndS >> 255n & 1n),
+			r,
+			s: yParityAndS & (1n << 255n) - 1n
+		};
+	}
+	const s = BigInt(`0x${sig.slice(64, 128)}`);
+	const v = parseInt(sig.slice(128, 130), 16);
+	if (v !== 0 && v !== 1 && v !== 27 && v !== 28) throw new RangeError(`invalid signature v value: ${v}`);
+	return {
+		yParity: v >= 27 ? v - 27 : v,
+		r,
+		s
+	};
+}
+/**
+* Converts a bigint to a 0x-prefixed hex string with even-length padding.
+* @param value - The bigint value to convert.
+* @returns The hex string representation (e.g., "0x01", "0xff").
+*/
+function bigintToHex(value) {
+	const hex = value.toString(16);
+	return hex.length % 2 ? `0x0${hex}` : `0x${hex}`;
+}
+//#endregion
+//#region src/utils.ts
+function buildDomainSeparator(chainId, entrypoint) {
+	return keccak256(AbiCoder.defaultAbiCoder().encode(["(bytes32,bytes32,bytes32,uint256,address)"], [[
+		"0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f",
+		"0x364da28a5c92bcc87fe97c8813a6c6b8a3a049b0ea0a328fcb0b4f0e00337586",
+		"0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6",
+		chainId,
+		entrypoint
+	]]));
+}
+/**
+* Compute the UserOperation hash for any supported EntryPoint version.
+* This hash is what gets signed by the account owner(s).
+* Automatically selects the correct packing format based on the entrypoint address.
+*
+* @param useroperation - UserOperation to hash
+* @param entrypointAddress - EntryPoint contract address (determines hash format)
+* @param chainId - Target chain ID
+* @returns The UserOperation hash as a hex string
+*/
+function createUserOperationHash(useroperation, entrypointAddress, chainId) {
+	let packedUserOperationHash;
+	const abiCoder = AbiCoder.defaultAbiCoder();
+	let userOperationHash;
+	if (entrypointAddress.toLowerCase() === "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789".toLowerCase()) {
+		packedUserOperationHash = keccak256(createPackedUserOperationV6(useroperation));
+		userOperationHash = keccak256(abiCoder.encode([
+			"bytes32",
+			"address",
+			"uint256"
+		], [
+			packedUserOperationHash,
+			entrypointAddress,
+			chainId
+		]));
+	} else if (entrypointAddress.toLowerCase() === "0x0000000071727De22E5E9d8BAf0edAc6f37da032".toLowerCase()) {
+		packedUserOperationHash = keccak256(createPackedUserOperationV7(useroperation));
+		userOperationHash = keccak256(abiCoder.encode([
+			"bytes32",
+			"address",
+			"uint256"
+		], [
+			packedUserOperationHash,
+			entrypointAddress,
+			chainId
+		]));
+	} else if (entrypointAddress.toLowerCase() === "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108".toLowerCase()) {
+		packedUserOperationHash = keccak256(createPackedUserOperationV8(useroperation));
+		userOperationHash = keccak256(`0x1901${buildDomainSeparator(chainId, entrypointAddress).slice(2)}${packedUserOperationHash.slice(2)}`);
+	} else if (entrypointAddress.toLowerCase() === "0x433709009B8330FDa32311DF1C2AFA402eD8D009".toLowerCase()) {
+		packedUserOperationHash = keccak256(createPackedUserOperationV9(useroperation));
+		userOperationHash = keccak256(`0x1901${buildDomainSeparator(chainId, entrypointAddress).slice(2)}${packedUserOperationHash.slice(2)}`);
+	} else throw new RangeError(`unsupported entrypoint address: ${entrypointAddress}`);
+	return userOperationHash;
+}
+/**
+* @internal
+* Reconstruct the packed `initCode` field for an EntryPoint v0.8/v0.9
+* UserOperation. When `eip7702Auth.address` is set, the EIP-7702 delegatee
+* address replaces the factory address in initCode (only `factoryData` is
+* concatenated). Otherwise, behaves like v0.7 (`factory + factoryData`).
+*
+* Shared by {@link createPackedUserOperationV8} /
+* {@link createPackedUserOperationV9} and Simple7702Account's typed-data
+* builder. Not part of the public API; only `export`ed for cross-module
+* use within the package and not re-exported from `src/abstractionkit.ts`.
+*
+* @param useroperation - V8 or V9 UserOperation to read fields from
+* @returns Hex-encoded initCode
+*/
+function buildPackedInitCodeV8V9(useroperation) {
+	if (useroperation.factory == null) return "0x";
+	const eip7702Auth = useroperation.eip7702Auth;
+	return (eip7702Auth != null && eip7702Auth.address != null ? eip7702Auth.address : useroperation.factory) + (useroperation.factoryData != null ? useroperation.factoryData.slice(2) : "");
+}
+/**
+* @internal
+* Pack `(verificationGasLimit, callGasLimit)` into a single `bytes32`
+* (two uint128 values, big-endian). Matches the on-chain
+* `PackedUserOperation.accountGasLimits` layout used by EntryPoint v0.7+.
+*/
+function packAccountGasLimits(verificationGasLimit, callGasLimit) {
+	const abiCoder = AbiCoder.defaultAbiCoder();
+	return "0x" + abiCoder.encode(["uint128"], [verificationGasLimit]).slice(34) + abiCoder.encode(["uint128"], [callGasLimit]).slice(34);
+}
+/**
+* @internal
+* Pack `(maxPriorityFeePerGas, maxFeePerGas)` into a single `bytes32`
+* (two uint128 values, big-endian). Matches the on-chain
+* `PackedUserOperation.gasFees` layout used by EntryPoint v0.7+.
+*/
+function packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
+	const abiCoder = AbiCoder.defaultAbiCoder();
+	return "0x" + abiCoder.encode(["uint128"], [maxPriorityFeePerGas]).slice(34) + abiCoder.encode(["uint128"], [maxFeePerGas]).slice(34);
+}
+/**
+* @internal
+* Reconstruct the packed `paymasterAndData` field from a UserOperation's
+* separate paymaster fields. Returns `0x` when no paymaster is set.
+*
+* For EntryPoint v0.9, when `paymasterData` ends with the parallel-paymaster
+* signature magic suffix (`0x22e325a297439656`), the embedded signature is
+* stripped so the userOpHash does not commit to the paymaster's signature
+* over itself. Pass `stripV9PaymasterSig=false` to preserve the wire format.
+*
+* Shared by v7/v8/v9 packers and Simple7702Account's typed-data builder.
+* Not part of the public API; only `export`ed for cross-module use within
+* the package and not re-exported from `src/abstractionkit.ts`.
+*
+* @param useroperation - V7/V8/V9 UserOperation to read fields from
+* @param stripV9PaymasterSig - Whether to strip the v0.9 paymaster signature suffix
+* @returns Hex-encoded paymasterAndData
+*/
+function buildPaymasterAndData(useroperation, stripV9PaymasterSig = false) {
+	if (useroperation.paymaster == null) return "0x";
+	const abiCoder = AbiCoder.defaultAbiCoder();
+	let paymasterAndData = useroperation.paymaster;
+	if (useroperation.paymasterVerificationGasLimit != null) paymasterAndData += abiCoder.encode(["uint128"], [useroperation.paymasterVerificationGasLimit]).slice(34);
+	if (useroperation.paymasterPostOpGasLimit != null) paymasterAndData += abiCoder.encode(["uint128"], [useroperation.paymasterPostOpGasLimit]).slice(34);
+	if (useroperation.paymasterData != null) {
+		const PAYMASTER_SIG_MAGIC = "22e325a297439656";
+		if (stripV9PaymasterSig && useroperation.paymasterData.toLowerCase().endsWith(PAYMASTER_SIG_MAGIC)) {
+			const sigLenHex = useroperation.paymasterData.slice(useroperation.paymasterData.length - 16 - 4, useroperation.paymasterData.length - 16);
+			const sigLen = parseInt(sigLenHex, 16);
+			const prefixEnd = useroperation.paymasterData.length - 16 - 4 - sigLen * 2;
+			paymasterAndData += useroperation.paymasterData.slice(0, prefixEnd).replaceAll("0x", "") + PAYMASTER_SIG_MAGIC;
+		} else paymasterAndData += useroperation.paymasterData.slice(2);
+	}
+	return paymasterAndData;
+}
+/**
+* Build the EIP-712 typed data payload for a UserOperation under the
+* EntryPoint v0.8 / v0.9 domain. The digest of the returned payload equals
+* the `userOpHash` from {@link createUserOperationHash}, so signing it via
+* `signTypedData` produces a signature that validates against the same hash
+* as raw ECDSA over the `userOpHash`.
+*
+* Shared by EIP-7702 accounts (Simple7702, Calibur). Earlier EntryPoints
+* define the userOpHash differently and don't fit this typed-data shape.
+*
+* @param userOperation - Unsigned UserOperation to wrap
+* @param entrypointAddress - The EntryPoint contract address (must be v0.8 or v0.9)
+* @param chainId - Target chain ID (must match the chain that will validate the signature)
+* @returns EIP-712 {@link TypedData} payload ready for `signTypedData`
+* @throws {AbstractionKitError} if `entrypointAddress` is not v0.8 / v0.9
+*/
+function getUserOperationEip712DataV8V9(userOperation, entrypointAddress, chainId) {
+	const ep = entrypointAddress.toLowerCase();
+	const isV9 = ep === ENTRYPOINT_V9.toLowerCase();
+	if (ep !== "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108".toLowerCase() && !isV9) throw new AbstractionKitError("BAD_DATA", `getUserOperationEip712Data supports EntryPoint v0.8 / v0.9 only; got ${entrypointAddress}. Earlier EntryPoints define the userOpHash differently and require raw-hash signing.`);
+	const initCode = buildPackedInitCodeV8V9(userOperation);
+	const accountGasLimits = packAccountGasLimits(userOperation.verificationGasLimit, userOperation.callGasLimit);
+	const gasFees = packGasFees(userOperation.maxPriorityFeePerGas, userOperation.maxFeePerGas);
+	const paymasterAndData = buildPaymasterAndData(userOperation, isV9);
+	return {
+		domain: {
+			name: "ERC4337",
+			version: "1",
+			chainId,
+			verifyingContract: entrypointAddress
+		},
+		types: { PackedUserOperation: [
+			{
+				name: "sender",
+				type: "address"
+			},
+			{
+				name: "nonce",
+				type: "uint256"
+			},
+			{
+				name: "initCode",
+				type: "bytes"
+			},
+			{
+				name: "callData",
+				type: "bytes"
+			},
+			{
+				name: "accountGasLimits",
+				type: "bytes32"
+			},
+			{
+				name: "preVerificationGas",
+				type: "uint256"
+			},
+			{
+				name: "gasFees",
+				type: "bytes32"
+			},
+			{
+				name: "paymasterAndData",
+				type: "bytes"
+			}
+		] },
+		primaryType: "PackedUserOperation",
+		message: {
+			sender: userOperation.sender,
+			nonce: userOperation.nonce,
+			initCode,
+			callData: userOperation.callData,
+			accountGasLimits,
+			preVerificationGas: userOperation.preVerificationGas,
+			gasFees,
+			paymasterAndData
+		}
+	};
+}
+/**
+* Compute the EIP-712 digest of a UserOperation under the EntryPoint
+* v0.8 / v0.9 domain. For these EntryPoints this digest IS the
+* `userOpHash` ({@link createUserOperationHash}).
+*
+* @param userOperation - Unsigned UserOperation to hash
+* @param entrypointAddress - The EntryPoint contract address (must be v0.8 or v0.9)
+* @param chainId - Target chain ID
+* @returns The EIP-712 digest as a hex string
+* @throws {AbstractionKitError} if `entrypointAddress` is not v0.8 / v0.9
+*/
+function getUserOperationEip712HashV8V9(userOperation, entrypointAddress, chainId) {
+	const data = getUserOperationEip712DataV8V9(userOperation, entrypointAddress, chainId);
+	return TypedDataEncoder.hash(data.domain, data.types, data.message);
+}
+/**
+* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.6 format).
+* Bytes fields (initCode, callData, paymasterAndData) are keccak256-hashed before packing.
+*
+* @param useroperation - UserOperation to pack
+* @returns ABI-encoded packed UserOperation as a hex string
+*/
+function createPackedUserOperationV6(useroperation) {
+	const useroperationValuesArrayWithHashedByteValues = [
+		useroperation.sender,
+		useroperation.nonce,
+		keccak256(useroperation.initCode),
+		keccak256(useroperation.callData),
+		useroperation.callGasLimit,
+		useroperation.verificationGasLimit,
+		useroperation.preVerificationGas,
+		useroperation.maxFeePerGas,
+		useroperation.maxPriorityFeePerGas,
+		keccak256(useroperation.paymasterAndData)
+	];
+	return AbiCoder.defaultAbiCoder().encode([
+		"address",
+		"uint256",
+		"bytes32",
+		"bytes32",
+		"uint256",
+		"uint256",
+		"uint256",
+		"uint256",
+		"uint256",
+		"bytes32"
+	], useroperationValuesArrayWithHashedByteValues);
+}
+/**
+* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.7 format).
+* Reconstructs initCode, accountGasLimits, gasFees, and paymasterAndData from separate fields.
+*
+* @param useroperation - UserOperation to pack
+* @returns ABI-encoded packed UserOperation as a hex string
+*/
+function createPackedUserOperationV7(useroperation) {
+	const abiCoder = AbiCoder.defaultAbiCoder();
+	let initCode = "0x";
+	if (useroperation.factory != null) {
+		initCode = useroperation.factory;
+		if (useroperation.factoryData != null) initCode += useroperation.factoryData.slice(2);
+	}
+	const accountGasLimits = packAccountGasLimits(useroperation.verificationGasLimit, useroperation.callGasLimit);
+	const gasFees = packGasFees(useroperation.maxPriorityFeePerGas, useroperation.maxFeePerGas);
+	const paymasterAndData = buildPaymasterAndData(useroperation);
+	const useroperationValuesArrayWithHashedByteValues = [
+		useroperation.sender,
+		useroperation.nonce,
+		keccak256(initCode),
+		keccak256(useroperation.callData),
+		accountGasLimits,
+		useroperation.preVerificationGas,
+		gasFees,
+		keccak256(paymasterAndData)
+	];
+	return abiCoder.encode([
+		"address",
+		"uint256",
+		"bytes32",
+		"bytes32",
+		"bytes32",
+		"uint256",
+		"bytes32",
+		"bytes32"
+	], useroperationValuesArrayWithHashedByteValues);
+}
+/**
+* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.9 format).
+*
+* @param useroperation - UserOperation to pack
+* @returns ABI-encoded packed UserOperation as a hex string
+*/
+function createPackedUserOperationV9(useroperation) {
+	return baseCreatePackedUserOperationV8V9(useroperation, true);
+}
+/**
+* ABI-encode and pack a UserOperation for hashing (EntryPoint v0.8 format).
+*
+* @param useroperation - UserOperation to pack
+* @returns ABI-encoded packed UserOperation as a hex string
+*/
+function createPackedUserOperationV8(useroperation) {
+	return baseCreatePackedUserOperationV8V9(useroperation, false);
+}
+/**
+* Shared packer for EntryPoint v0.8 and v0.9 UserOperations.
+* @param useroperation - UserOperation to pack
+* @param is_v9 - If true, strips the paymaster signature suffix (v0.9-specific)
+* @returns ABI-encoded packed UserOperation as a hex string
+*/
+function baseCreatePackedUserOperationV8V9(useroperation, is_v9) {
+	const abiCoder = AbiCoder.defaultAbiCoder();
+	const initCode = buildPackedInitCodeV8V9(useroperation);
+	const accountGasLimits = packAccountGasLimits(useroperation.verificationGasLimit, useroperation.callGasLimit);
+	const gasFees = packGasFees(useroperation.maxPriorityFeePerGas, useroperation.maxFeePerGas);
+	const paymasterAndData = buildPaymasterAndData(useroperation, is_v9);
+	const useroperationValuesArrayWithHashedByteValues = [
+		"0x29a0bca4af4be3421398da00295e58e6d7de38cb492214754cb6a47507dd6f8e",
+		useroperation.sender,
+		useroperation.nonce,
+		keccak256(initCode),
+		keccak256(useroperation.callData),
+		accountGasLimits,
+		useroperation.preVerificationGas,
+		gasFees,
+		keccak256(paymasterAndData)
+	];
+	return abiCoder.encode([
+		"bytes32",
+		"address",
+		"uint256",
+		"bytes32",
+		"bytes32",
+		"bytes32",
+		"uint256",
+		"bytes32",
+		"bytes32"
+	], useroperationValuesArrayWithHashedByteValues);
+}
+/**
+* Encode a function call into ABI-encoded calldata.
+*
+* @param functionSelector - 4-byte hex function selector (e.g., "0xa9059cbb" for ERC-20 transfer)
+* @param functionInputAbi - Array of ABI type strings (e.g., ["address", "uint256"])
+* @param functionInputParameters - Array of parameter values matching the ABI types
+* @returns ABI-encoded calldata as a hex string (selector + encoded parameters)
+*
+* @example
+* const transferCallData = createCallData(
+*   "0xa9059cbb",
+*   ["address", "uint256"],
+*   ["0xRecipientAddress", 1000000n],
+* );
+*/
+function createCallData(functionSelector, functionInputAbi, functionInputParameters) {
+	return functionSelector + AbiCoder.defaultAbiCoder().encode(functionInputAbi, functionInputParameters).slice(2);
+}
+/**
+* Send a JSON-RPC 2.0 request to the specified endpoint.
+*
+* **External escape hatch.** Most SDK consumers should use one of the
+* high-level service classes ({@link Bundler}, {@link CandidePaymaster},
+* {@link Erc7677Paymaster}, {@link JsonRpcNode}) which translate errors into
+* the SDK's domain vocabulary. This function is intentionally low-level: it
+* speaks plain JSON-RPC and throws {@link TransportRpcError}
+* (an EIP-1193-shaped `ProviderRpcError`) on RPC errors.
+*
+* Two execution modes:
+* - **URL string:** issues a `fetch` POST directly. Supports custom `headers`
+*   and a custom `paramsKeyName` for non-standard servers (e.g. APIs that
+*   expect `"simulations"` instead of `"params"`).
+* - **Transport / JsonRpcNode:** delegates to `.request({ method, params })`.
+*   `headers` and `paramsKeyName` are ignored (those concerns belong to the
+*   transport implementation).
+*
+* Automatically serializes `bigint` values in `params` as `0x`-prefixed hex.
+*
+* @param rpc - JSON-RPC endpoint URL, {@link Transport}, or {@link JsonRpcNode}
+* @param method - The JSON-RPC method name (e.g., `"eth_call"`)
+* @param params - The JSON-RPC parameters
+* @param headers - Custom HTTP headers (URL inputs only; default Content-Type: application/json)
+* @param paramsKeyName - Override the params key in the envelope (URL inputs only; default `"params"`)
+* @returns The `result` (or non-standard equivalent) field from the JSON-RPC response
+* @throws {@link TransportRpcError} when the response contains an `error` field
+*/
+async function sendJsonRpcRequest(rpc, method, params, headers = { "Content-Type": "application/json" }, paramsKeyName = "params") {
+	const normalizedParams = JSON.parse(JSON.stringify(params, (_key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value));
+	if (typeof rpc !== "string") return JsonRpcNode.from(rpc).request({
+		method,
+		params: normalizedParams
+	});
+	const raw = JSON.stringify({
+		method,
+		[paramsKeyName]: normalizedParams,
+		id: Date.now(),
+		jsonrpc: "2.0"
+	});
+	const response = await (await fetch(rpc, {
+		method: "POST",
+		headers,
+		body: raw,
+		redirect: "follow"
+	})).json();
+	if ("result" in response) return response.result;
+	const err = response.error;
+	throw new TransportRpcError(err.code, err.message);
+}
+/**
+* Get a 4-byte function selector from a Solidity-style function signature.
+* Computed as the first 4 bytes of keccak256(signature).
+* @param functionSignature - Solidity-style function signature, e.g. "mint(address)"
+* @returns Function selector as a 0x-prefixed 10-character hex string
+*
+* @example
+* getFunctionSelector("getNonce(address,uint192)"); // "0x35567e1a"
+*/
+function getFunctionSelector(functionSignature) {
+	return id(functionSignature).slice(0, 10);
+}
+/**
+* Fetch the account's nonce from the EntryPoint contract.
+*
+* Equivalent to `JsonRpcNode.from(rpc).getEntryPointNonce(entryPoint, account, key)`.
+* Kept as a top-level export for backward compatibility with existing call
+* sites; the first parameter widens from `string` to
+* `string | Transport | JsonRpcNode` so users can pass a configured transport
+* (with custom headers, retries, etc.) without restructuring their code.
+*
+* @param rpc - Ethereum JSON-RPC node URL, {@link Transport}, or {@link JsonRpcNode}
+* @param entryPoint - EntryPoint contract address
+* @param account - Smart account address to query
+* @param key - Nonce key (default 0). Different keys allow parallel nonce channels.
+* @returns The current nonce as a bigint
+*/
+async function fetchAccountNonce(rpc, entryPoint, account, key = 0) {
+	return JsonRpcNode.from(rpc).getEntryPointNonce(entryPoint, account, BigInt(key));
 }
 /**
-* Parse a raw ECDSA signature into its components.
-* Supports standard 65-byte (r + s + v) and EIP-2098 64-byte compact formats.
-* @param rawSig - Hex string: 128 chars (EIP-2098 compact), or 130/132 chars (standard with 0x prefix)
-* @returns An object with yParity (0 or 1), r, and s components
+* Fetch current gas prices from the Polygon Gas Station API.
+*
+* @param polygonChain - Target Polygon chain (Mainnet, Amoy, etc.)
+* @param gasLevel - Gas price level (Slow, Medium, Fast)
+* @returns A tuple of [maxFeePerGas, maxPriorityFeePerGas] as bigints
 */
-function parseRawSignature(rawSig) {
-	const sig = rawSig.startsWith("0x") ? rawSig.slice(2) : rawSig;
-	if (sig.length !== 128 && sig.length !== 130) throw new RangeError(`invalid signature length: expected 128 (EIP-2098 compact) or 130 (standard) hex chars, got ${sig.length}`);
-	const r = BigInt(`0x${sig.slice(0, 64)}`);
-	if (sig.length === 128) {
-		const yParityAndS = BigInt(`0x${sig.slice(64, 128)}`);
-		return {
-			yParity: Number(yParityAndS >> 255n & 1n),
-			r,
-			s: yParityAndS & (1n << 255n) - 1n
-		};
+async function fetchGasPricePolygon(polygonChain, gasLevel = GasOption.Medium) {
+	const gasStationUrl = `https://gasstation.polygon.technology/${polygonChain}`;
+	try {
+		const response = await (await fetch(gasStationUrl)).json();
+		let gasPrice;
+		if (gasLevel === GasOption.Slow) gasPrice = response.safeLow;
+		else if (gasLevel === GasOption.Medium) gasPrice = response.standard;
+		else gasPrice = response.fast;
+		let maxFeePerGas = BigInt(Math.ceil(Number(gasPrice.maxFee) * 1e9));
+		let maxPriorityFeePerGas = BigInt(Math.ceil(Number(gasPrice.maxPriorityFee) * 1e9));
+		if (maxFeePerGas === 0n) maxFeePerGas = 1n;
+		if (maxPriorityFeePerGas === 0n) maxPriorityFeePerGas = 1n;
+		return [maxFeePerGas, maxPriorityFeePerGas];
+	} catch (err) {
+		const error = ensureError(err);
+		throw new AbstractionKitError("BAD_DATA", `fetching gas prices from ${gasStationUrl} failed.`, { cause: error });
 	}
-	const s = BigInt(`0x${sig.slice(64, 128)}`);
-	const v = parseInt(sig.slice(128, 130), 16);
-	if (v !== 0 && v !== 1 && v !== 27 && v !== 28) throw new RangeError(`invalid signature v value: ${v}`);
-	return {
-		yParity: v >= 27 ? v - 27 : v,
-		r,
-		s
-	};
 }
 /**
-* Converts a bigint to a 0x-prefixed hex string with even-length padding.
-* @param value - The bigint value to convert.
-* @returns The hex string representation (e.g., "0x01", "0xff").
+* Calculate the maximum gas cost (in wei) that a UserOperation could consume.
+* Uses different formulas for v0.6 (with paymaster multiplier) and v0.7+ UserOperations.
+*
+* @param useroperation - The UserOperation to calculate the max gas cost for
+* @returns Maximum possible gas cost in wei as a bigint
 */
-function bigintToHex(value) {
-	const hex = value.toString(16);
-	return hex.length % 2 ? `0x0${hex}` : `0x${hex}`;
+function calculateUserOperationMaxGasCost(useroperation) {
+	if ("initCode" in useroperation) {
+		const mul = useroperation.paymasterAndData !== "0x" && useroperation.paymasterAndData != null ? 3n : 0n;
+		return (useroperation.callGasLimit + useroperation.verificationGasLimit * mul + useroperation.preVerificationGas) * useroperation.maxFeePerGas;
+	} else return (useroperation.verificationGasLimit + useroperation.callGasLimit + (useroperation.paymasterVerificationGasLimit ?? 0n) + (useroperation.paymasterPostOpGasLimit ?? 0n) + useroperation.preVerificationGas) * useroperation.maxFeePerGas;
+}
+/**
+* @internal
+* Internal dispatcher: routes to the Polygon Gas Station when a chain is
+* provided, otherwise delegates to {@link JsonRpcNode.getFeeData}. Used by
+* the account classes when assembling base UserOperation gas fields.
+*/
+async function handlefetchGasPrice(providerRpc, polygonGasStation, gasLevel = GasOption.Medium) {
+	if (polygonGasStation != null) return fetchGasPricePolygon(polygonGasStation, gasLevel);
+	if (providerRpc != null) return JsonRpcNode.from(providerRpc).getFeeData(gasLevel);
+	throw new AbstractionKitError("BAD_DATA", "providerRpc can't be null if maxFeePerGas and maxPriorityFeePerGas are not overridden");
 }
 //#endregion
 //#region src/account/SendUseroperationResponse.ts
@@ -1440,6 +2035,29 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 			hookData
 		]);
 	}
+	/**
+	* Format a raw EIP-712 signature (from `signTypedData` over the payload
+	* returned by {@link getUserOperationEip712Data}) into Calibur's
+	* `userOp.signature` layout. Provided for API parity with Safe's
+	* `formatEip712SingleSignatureToUseroperationSignature`.
+	*
+	* Under EntryPoint v0.8 / v0.9 the userOpHash IS the EIP-712 digest of
+	* the PackedUserOperation, so a raw-hash signature and a typed-data
+	* signature are byte-identical for deterministic-ECDSA signers; this
+	* method is therefore equivalent to {@link wrapSignature} with the same
+	* `keyHash` / `hookData`. The default `keyHash` is the root-key hash
+	* (`bytes32(0)`), which selects the EOA's own secp256k1 key.
+	*
+	* @param signature - Raw ECDSA signature (65 bytes, hex-encoded) from
+	*   `signTypedData` over the payload from {@link getUserOperationEip712Data}
+	* @param overrides - Optional `keyHash` / `hookData` overrides
+	* @returns Hex-encoded wrapped signature ready for `userOp.signature`
+	*/
+	static formatEip712SingleSignatureToUseroperationSignature(signature, overrides = {}) {
+		const keyHash = overrides.keyHash ?? ROOT_KEY_HASH;
+		const hookData = overrides.hookData ?? "0x";
+		return Calibur7702Account.wrapSignature(keyHash, signature, hookData);
+	}
 	/** The EntryPoint contract address this account targets */
 	entrypointAddress;
 	/** The Calibur singleton (delegatee) contract address */
@@ -1469,6 +2087,46 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 		return createUserOperationHash(userOperation, this.entrypointAddress, chainId);
 	}
 	/**
+	* Build the EIP-712 typed data payload for a UserOperation under the
+	* EntryPoint v0.8 / v0.9 domain. Useful for wallets that can only sign
+	* typed data (`eth_signTypedData_v4`) — the digest of the returned payload
+	* equals the `userOpHash`, so a typed-data signature over it produces a
+	* wrapped Calibur signature that validates against the same hash on-chain.
+	*
+	* Intended for the secp256k1 key path (root key or any registered
+	* secondary secp256k1 key), since `eth_signTypedData_v4` only produces
+	* secp256k1 signatures. P-256 and WebAuthn-P256 keys sign with their
+	* own primitives — for those, use {@link getUserOperationEip712Hash}
+	* (the digest), which is the value-to-be-signed regardless of key type.
+	*
+	* @param userOperation - Unsigned UserOperation to wrap
+	* @param chainId - Target chain ID
+	* @param overrides - Override the entrypoint address (defaults to EntryPoint v0.8)
+	* @returns EIP-712 {@link TypedData} payload ready for `signTypedData`
+	* @throws {AbstractionKitError} if the target EntryPoint is not v0.8 / v0.9.
+	*/
+	static getUserOperationEip712Data(userOperation, chainId, overrides = {}) {
+		return getUserOperationEip712DataV8V9(userOperation, overrides.entrypointAddress ?? "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108", chainId);
+	}
+	/**
+	* Compute the EIP-712 digest of a UserOperation under the EntryPoint
+	* v0.8 / v0.9 domain. For these EntryPoints this digest IS the
+	* `userOpHash`; the wrapped Calibur signature is verified against this
+	* hash on-chain.
+	*
+	* Universal across Calibur key types: secp256k1 and P-256 keys sign
+	* this digest directly, each with their own signing primitive.
+	*
+	* @param userOperation - Unsigned UserOperation to hash
+	* @param chainId - Target chain ID
+	* @param overrides - Override the entrypoint address (defaults to EntryPoint v0.8)
+	* @returns The EIP-712 digest as a hex string
+	* @throws {AbstractionKitError} if the target EntryPoint is not v0.8 / v0.9.
+	*/
+	static getUserOperationEip712Hash(userOperation, chainId, overrides = {}) {
+		return getUserOperationEip712HashV8V9(userOperation, overrides.entrypointAddress ?? "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108", chainId);
+	}
+	/**
 	* Encode calldata for `executeUserOp(bytes)` with BatchedCall format.
 	* All transactions (even single ones) go through the same BatchedCall path.
 	*
@@ -1520,7 +2178,7 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 		}
 		let skipEip7702Auth = false;
 		let delegationCheckOp = null;
-		if (overrides.eip7702Auth != null && providerRpc != null) delegationCheckOp = getDelegatedAddress(this.accountAddress, providerRpc).catch(() => null);
+		if (overrides.eip7702Auth != null && providerRpc != null) delegationCheckOp = JsonRpcNode.from(providerRpc).getDelegatedAddress(this.accountAddress).catch(() => null);
 		if (overrides.eip7702Auth != null && eip7702AuthNonce == null) {
 			let eip7702AuthNonceOp;
 			if (providerRpc != null) eip7702AuthNonceOp = sendJsonRpcRequest(providerRpc, "eth_getTransactionCount", [this.accountAddress, "latest"]);
@@ -1622,7 +2280,7 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 			userOperation.maxPriorityFeePerGas = 0n;
 			const userOperationToEstimate = { ...userOperation };
 			userOperationToEstimate.signature = overrides.dummySignature ?? Calibur7702Account.dummySignature;
-			const estimation = await new Bundler(bundlerRpc).estimateUserOperationGas(userOperationToEstimate, this.entrypointAddress, overrides.state_override_set);
+			const estimation = await Bundler.from(bundlerRpc).estimateUserOperationGas(userOperationToEstimate, this.entrypointAddress, overrides.state_override_set);
 			preVerificationGas = BigInt(estimation.preVerificationGas);
 			verificationGasLimit = BigInt(estimation.verificationGasLimit);
 			callGasLimit = BigInt(estimation.callGasLimit);
@@ -1668,38 +2326,46 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 		return Calibur7702Account.wrapSignature(keyHash, ecdsaSig, hookData);
 	}
 	/**
-	* Schemes Calibur accepts from a Signer. Only raw-hash ECDSA, since
-	* the account verifies a plain signature over the userOp hash, then
-	* wraps with `(keyHash, signature, hookData)`.
+	* Schemes Calibur accepts from a Signer. EntryPoint v0.8/v0.9 introduced
+	* an EIP-712 domain at the EntryPoint contract, and the userOpHash IS the
+	* EIP-712 digest of the PackedUserOperation under that domain — so signing
+	* the typed data and signing the raw hash produce signatures that verify
+	* against the same `userOpHash` (and recover to the same signer address).
+	* Deterministic-ECDSA signers (ethers, viem, MetaMask) yield byte-identical
+	* bytes; signers that differ in `s` / `v` normalization still validate the
+	* same on-chain.
+	*
+	* `typedData` is listed first so JSON-RPC wallets that can only sign typed
+	* data work without a separate code path; `hash` remains a valid fallback
+	* for local-key signers.
 	*/
-	static ACCEPTED_SIGNING_SCHEMES = ["hash"];
+	static ACCEPTED_SIGNING_SCHEMES = ["typedData", "hash"];
 	/**
-	* Sign a UserOperation using an {@link ExternalSigner}. Calibur only
-	* accepts raw-hash ECDSA; signers without `signHash` fail offline with
-	* an actionable error.
-	*
-	* For signing with a raw private-key string, use the sync
-	* {@link signUserOperation} method, or wrap explicitly with
-	* `fromPrivateKey(pk)`. For secondary (non-root) keys, pass the key
-	* hash via `overrides.keyHash`.
+	* Sign a UserOperation with an {@link AkSigner}. The signer can implement
+	* either `signTypedData` (preferred — JSON-RPC wallets, viem `WalletClient`)
+	* or `signHash` (local keys, hardware wallets). Both schemes produce
+	* signatures that validate against the same `userOpHash` because the
+	* v0.8 / v0.9 userOpHash IS the EIP-712 digest of the PackedUserOperation
+	* (deterministic-ECDSA signers yield byte-identical bytes).
 	*
-	* @example
-	* import { fromViem, fromEthersWallet } from "abstractionkit";
-	* userOp.signature = await account.signUserOperationWithSigner(
-	*   userOp, fromViem(privateKeyToAccount(pk)), chainId,
-	* );
+	* Signers that implement neither method fail offline with an actionable
+	* error.
 	*/
 	async signUserOperationWithSigner(userOperation, signer, chainId, overrides = {}) {
-		const signature = await invokeSigner(signer, pickScheme(signer, Calibur7702Account.ACCEPTED_SIGNING_SCHEMES, {
+		const scheme = pickScheme(signer, Calibur7702Account.ACCEPTED_SIGNING_SCHEMES, {
 			accountName: "Calibur (raw ECDSA over userOpHash)",
 			signerIndex: 0
-		}), {
-			hash: createUserOperationHash(userOperation, this.entrypointAddress, chainId),
-			context: {
-				userOperation,
-				chainId,
-				entryPoint: this.entrypointAddress
-			}
+		});
+		const hash = createUserOperationHash(userOperation, this.entrypointAddress, chainId);
+		const context = {
+			userOperation,
+			chainId,
+			entryPoint: this.entrypointAddress
+		};
+		const signature = await invokeSigner(signer, scheme, {
+			hash,
+			typedData: scheme === "typedData" ? Calibur7702Account.getUserOperationEip712Data(userOperation, chainId, { entrypointAddress: this.entrypointAddress }) : void 0,
+			context
 		});
 		const keyHash = overrides.keyHash ?? ROOT_KEY_HASH;
 		const hookData = overrides.hookData ?? "0x";
@@ -1743,7 +2409,7 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 	* @returns A {@link SendUseroperationResponse} that can be used to wait for inclusion
 	*/
 	async sendUserOperation(userOperation, bundlerRpc) {
-		const bundler = new Bundler(bundlerRpc);
+		const bundler = Bundler.from(bundlerRpc);
 		return new SendUseroperationResponse(await bundler.sendUserOperation(userOperation, this.entrypointAddress), bundler, this.entrypointAddress);
 	}
 	/**
@@ -1929,7 +2595,7 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 	*/
 	async createRevokeDelegationRawTransaction(chainId, eoaPrivateKey, providerRpc, overrides = {}) {
 		if (new Wallet(eoaPrivateKey).address.toLowerCase() !== this.accountAddress.toLowerCase()) throw new AbstractionKitError("BAD_DATA", `eoaPrivateKey does not match accountAddress (${this.accountAddress})`);
-		const delegatedTo = await getDelegatedAddress(this.accountAddress, providerRpc);
+		const delegatedTo = await JsonRpcNode.from(providerRpc).getDelegatedAddress(this.accountAddress);
 		if (delegatedTo === null) throw new AbstractionKitError("BAD_DATA", "Account is not delegated — nothing to revoke");
 		if (delegatedTo.toLowerCase() !== this.delegateeAddress.toLowerCase()) throw new AbstractionKitError("BAD_DATA", "Account is delegated to a different address (" + delegatedTo + "), not " + this.delegateeAddress + " — use the correct account class to revoke");
 		const results = {};
@@ -1993,14 +2659,14 @@ var Calibur7702Account = class Calibur7702Account extends SmartAccount {
 	/**
 	* Check if this EOA is delegated to this account's singleton (delegatee).
 	* Returns `false` if not delegated at all or delegated to a different
-	* singleton. Use the standalone {@link getDelegatedAddress} utility to
-	* get the raw delegatee address regardless of which singleton it is.
+	* singleton. Use {@link JsonRpcNode.getDelegatedAddress} to get the raw
+	* delegatee address regardless of which singleton it is.
 	*
 	* @param providerRpc - JSON-RPC endpoint
 	* @returns True if the account is delegated to `this.delegateeAddress`
 	*/
 	async isDelegatedToThisAccount(providerRpc) {
-		const address = await getDelegatedAddress(this.accountAddress, providerRpc);
+		const address = await JsonRpcNode.from(providerRpc).getDelegatedAddress(this.accountAddress);
 		if (address === null) return false;
 		return address.toLowerCase() === this.delegateeAddress.toLowerCase();
 	}
@@ -2548,7 +3214,8 @@ async function simulateSenderCallDataWithTenderly(tenderlyAccountSlug, tenderlyP
 * @returns The simulation results from Tenderly.
 */
 async function callTenderlySimulateBundle(tenderlyAccountSlug, tenderlyProjectSlug, tenderlyAccessKey, transactions) {
-	return await sendJsonRpcRequest("https://api.tenderly.co/api/v1/account/" + tenderlyAccountSlug + "/project/" + tenderlyProjectSlug + "/simulate-bundle", "tenderly_simulateBundle", transactions.map((transaction) => {
+	const tenderlyUrl = "https://api.tenderly.co/api/v1/account/" + tenderlyAccountSlug + "/project/" + tenderlyProjectSlug + "/simulate-bundle";
+	const simulations = transactions.map((transaction) => {
 		const transactionObject = {
 			network_id: transaction.chainId.toString(),
 			save: transaction.save ?? true,
@@ -2577,11 +3244,53 @@ async function callTenderlySimulateBundle(tenderlyAccountSlug, tenderlyProjectSl
 		if (transaction.generateAccessList != null) transactionObject.generate_access_list = transaction.generateAccessList;
 		if (transaction.accessList != null) transactionObject.access_list = transaction.accessList;
 		return transactionObject;
-	}), {
+	});
+	const headers = {
 		Accept: "application/json",
 		"Content-Type": "application/json",
 		"X-Access-Key": tenderlyAccessKey
-	}, "simulations");
+	};
+	const body = JSON.stringify({
+		method: "tenderly_simulateBundle",
+		simulations,
+		id: Date.now(),
+		jsonrpc: "2.0"
+	}, (_key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value);
+	let response;
+	try {
+		response = await fetch(tenderlyUrl, {
+			method: "POST",
+			headers,
+			body,
+			redirect: "follow"
+		});
+	} catch (err) {
+		const e = ensureError(err);
+		throw new AbstractionKitError("TENDERLY_NETWORK_ERROR", `tenderly_simulateBundle network error: ${e.message}`, { cause: e });
+	}
+	if (!response.ok) throw new AbstractionKitError("TENDERLY_HTTP_ERROR", `tenderly_simulateBundle HTTP ${response.status}: ${response.statusText}`, {
+		errno: response.status,
+		context: {
+			status: response.status,
+			statusText: response.statusText
+		}
+	});
+	const responseText = await response.text();
+	let json;
+	try {
+		json = JSON.parse(responseText);
+	} catch (err) {
+		const e = ensureError(err);
+		throw new AbstractionKitError("TENDERLY_INVALID_JSON", `tenderly_simulateBundle returned invalid JSON: ${e.message}`, {
+			cause: e,
+			context: { responseText }
+		});
+	}
+	if (json.simulation_results != null) return json.simulation_results;
+	throw new AbstractionKitError("TENDERLY_SIMULATION_ERROR", "tenderly_simulateBundle failed", {
+		errno: json.error?.code,
+		context: JSON.stringify(json)
+	});
 }
 //#endregion
 //#region src/account/Safe/multisend.ts
@@ -2807,7 +3516,7 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 	* ```
 	*/
 	static async isDeployed(accountAddress, nodeRpcUrl) {
-		return (await sendEthGetCodeRequest(nodeRpcUrl, accountAddress, "latest")).length > 2;
+		return (await JsonRpcNode.from(nodeRpcUrl).getCode(accountAddress, "latest")).length > 2;
 	}
 	/**
 	* encode calldata for a single MetaTransaction to be executed by Safe account
@@ -3191,11 +3900,11 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 	/**
 	* sends a useroperation to a bundler rpc
 	* @param userOperation - useroperation to send
-	* @param bundlerRpc - bundler rpc to send useroperation
+	* @param bundlerRpc - bundler rpc URL, {@link Transport}, or pre-constructed {@link Bundler}
 	* @returns promise with SendUseroperationResponse
 	*/
 	async sendUserOperation(userOperation, bundlerRpc) {
-		const bundler = new Bundler(bundlerRpc);
+		const bundler = Bundler.from(bundlerRpc);
 		return new SendUseroperationResponse(await bundler.sendUserOperation(userOperation, this.entrypointAddress), bundler, this.entrypointAddress);
 	}
 	/**
@@ -3378,7 +4087,7 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 			validUntil,
 			isMultiChainSignature: overrides.isMultiChainSignature
 		});
-		const bundler = new Bundler(bundlerRpc);
+		const bundler = Bundler.from(bundlerRpc);
 		const inputMaxFeePerGas = userOperation.maxFeePerGas;
 		const inputMaxPriorityFeePerGas = userOperation.maxPriorityFeePerGas;
 		userOperation.maxFeePerGas = 0n;
@@ -3901,7 +4610,7 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 				webAuthnSignerSingleton: overrides.webAuthnSignerSingleton,
 				webAuthnSignerProxyCreationCode
 			});
-			if ((await sendEthGetCodeRequest(nodeRpcUrl, newOwnerT, "latest")).length < 3) deployNewOwnerSignerMetaTransaction = SafeAccount.createDeployWebAuthnVerifierMetaTransaction(newOwner.x, newOwner.y, {
+			if ((await JsonRpcNode.from(nodeRpcUrl).getCode(newOwnerT, "latest")).length < 3) deployNewOwnerSignerMetaTransaction = SafeAccount.createDeployWebAuthnVerifierMetaTransaction(newOwner.x, newOwner.y, {
 				eip7212WebAuthnPrecompileVerifier: overrides.eip7212WebAuthnPrecompileVerifier,
 				eip7212WebAuthnContractVerifier: overrides.eip7212WebAuthnContractVerifier,
 				webAuthnSignerFactory: overrides.webAuthnSignerFactory
@@ -3984,7 +4693,7 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 				webAuthnSignerProxyCreationCode
 			});
 			if (overrides.nodeRpcUrl == null) throw new RangeError("overrides.nodeRpcUrl can't be null if adding a webauthn owner");
-			if ((await sendEthGetCodeRequest(overrides.nodeRpcUrl, newOwnerT, "latest")).length < 3) deployNewOwnerSignerMetaTransaction = SafeAccount.createDeployWebAuthnVerifierMetaTransaction(newOwner.x, newOwner.y, {
+			if ((await JsonRpcNode.from(overrides.nodeRpcUrl).getCode(newOwnerT, "latest")).length < 3) deployNewOwnerSignerMetaTransaction = SafeAccount.createDeployWebAuthnVerifierMetaTransaction(newOwner.x, newOwner.y, {
 				eip7212WebAuthnPrecompileVerifier: overrides.eip7212WebAuthnPrecompileVerifier,
 				eip7212WebAuthnContractVerifier: overrides.eip7212WebAuthnContractVerifier,
 				webAuthnSignerFactory: overrides.webAuthnSignerFactory
@@ -4112,10 +4821,11 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 	*/
 	async getOwners(nodeRpcUrl) {
 		const callData = createCallData(getFunctionSelector("getOwners()"), [], []);
-		const getOwnersResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.accountAddress,
 			data: callData
-		}, "latest");
+		};
+		const getOwnersResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		return AbiCoder.defaultAbiCoder().decode(["address[]"], getOwnersResult)[0];
 	}
 	/**
@@ -4125,10 +4835,11 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 	*/
 	async getThreshold(nodeRpcUrl) {
 		const callData = createCallData("0xe75235b8", [], []);
-		const getThresholdResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.accountAddress,
 			data: callData
-		}, "latest");
+		};
+		const getThresholdResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		const decodedCalldata = AbiCoder.defaultAbiCoder().decode(["uint256"], getThresholdResult);
 		return Number(decodedCalldata[0]);
 	}
@@ -4147,10 +4858,11 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 			let pageSize = overrides.pageSize;
 			if (pageSize == null) pageSize = 10n;
 			const callData = createCallData("0xcc2f8452", ["address", "uint256"], [start, pageSize]);
-			const getModulesResult = await sendEthCallRequest(nodeRpcUrl, {
+			const ethCallParams = {
 				to: this.accountAddress,
 				data: callData
-			}, "latest");
+			};
+			const getModulesResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 			if (getModulesResult === "0x") throw new AbstractionKitError("BAD_DATA", "getModules returned an empty result, the target account is probably not deployed yet.");
 			const decodedCalldata = AbiCoder.defaultAbiCoder().decode(["address[]", "address"], getModulesResult);
 			return [decodedCalldata[0], decodedCalldata[1]];
@@ -4166,10 +4878,11 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 	*/
 	async isModuleEnabled(nodeRpcUrl, moduleAddress) {
 		const callData = createCallData(getFunctionSelector("isModuleEnabled(address)"), ["address"], [moduleAddress]);
-		const isModuleEnabledResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.accountAddress,
 			data: callData
-		}, "latest");
+		};
+		const isModuleEnabledResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		return AbiCoder.defaultAbiCoder().decode(["bool"], isModuleEnabledResult)[0];
 	}
 	/**
@@ -4236,7 +4949,7 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 			data: callData
 		};
 		const deployedByteCode = SafeAccount.createSafeWebAuthnSignerProxyDeployedByteCode(signer, eip7212WebAuthnPrecompileVerifier, eip7212WebAuthnContractVerifier, webAuthnSignerSingleton);
-		const isModuleEnabledResult = await sendEthCallRequest(nodeRpcUrl, ethCallParams, "latest", { [arbitraryAddress]: { code: deployedByteCode } });
+		const isModuleEnabledResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest", { [arbitraryAddress]: { code: deployedByteCode } });
 		return AbiCoder.defaultAbiCoder().decode(["bool"], isModuleEnabledResult)[0];
 	}
 	static createSafeWebAuthnSignerProxyDeployedByteCode(signer, eip7212WebAuthnPrecompileVerifier, eip7212WebAuthnContractVerifier, webAuthnSignerSingleton) {
@@ -4356,7 +5069,7 @@ var SafeAccount = class SafeAccount extends SmartAccount {
 * @param toolVersion - tool version; defaults to the current abstractionkit version
 * @returns the on-chain identifier as a hex string (not 0x prefixed)
 */
-function generateOnChainIdentifier(project, platform = "Web", tool = "abstractionkit", toolVersion = "0.3.5") {
+function generateOnChainIdentifier(project, platform = "Web", tool = "abstractionkit", toolVersion = "0.3.8") {
 	const identifierPrefix = "5afe";
 	const identifierVersion = "00";
 	const projectHash = keccak256(`0x${Buffer.from(project, "utf8").toString("hex")}`).slice(-20);
@@ -4619,10 +5332,11 @@ var AllowanceModule = class AllowanceModule extends SafeModule {
 	*/
 	async getTokens(nodeRpcUrl, safeAddress, delegate) {
 		const callData = createCallData("0x8d0e8e1d", ["address", "address"], [safeAddress, delegate]);
-		const tokens = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const tokens = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(tokens, "getTokens");
 		return this.abiCoder.decode(["address[]"], tokens)[0];
 	}
@@ -4644,10 +5358,11 @@ var AllowanceModule = class AllowanceModule extends SafeModule {
 			delegate,
 			token
 		]);
-		const tokenAllowance = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const tokenAllowance = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(tokenAllowance, "getTokenAllowance");
 		const allowance = this.abiCoder.decode(["uint256[5]"], tokenAllowance)[0];
 		return {
@@ -4699,10 +5414,11 @@ var AllowanceModule = class AllowanceModule extends SafeModule {
 			start,
 			pageSize
 		]);
-		const delegates = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const delegates = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(delegates, "getDelegates");
 		const decodedCalldata = this.abiCoder.decode(["address[]", "uint48"], delegates);
 		return {
@@ -4787,13 +5503,19 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 			"address",
 			"address[]",
 			"uint256",
-			"(address,bytes)",
+			"(address,bytes)[]",
 			"bool"
 		], [
 			accountAddress,
 			newOwners,
 			newThreshold,
-			signaturePairList.map((signaturePair) => [signaturePair.signer, signaturePair.signature]),
+			[...signaturePairList].sort((a, b) => {
+				const aSigner = BigInt(a.signer);
+				const bSigner = BigInt(b.signer);
+				if (aSigner < bSigner) return -1;
+				if (aSigner > bSigner) return 1;
+				throw new AbstractionKitError("BAD_DATA", `Duplicate signer in recovery signaturePairList: ${a.signer}`);
+			}).map((signaturePair) => [signaturePair.signer, signaturePair.signature]),
 			execute
 		]);
 		return {
@@ -4945,10 +5667,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 			newThreshold,
 			nonce
 		]);
-		const recoveryHashResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const recoveryHashResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(recoveryHashResult, "getRecoveryHash");
 		return this.abiCoder.decode(["bytes32"], recoveryHashResult)[0];
 	}
@@ -4960,10 +5683,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 	*/
 	async getRecoveryRequest(nodeRpcUrl, accountAddress) {
 		const callData = createCallData("0x4f9a28b9", ["address"], [accountAddress]);
-		const recoveryRequestResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const recoveryRequestResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(recoveryRequestResult, "getRecoveryRequest");
 		const decodedCalldata = this.abiCoder.decode(["(uint256,uint256,uint64,address[])"], recoveryRequestResult);
 		return {
@@ -4991,10 +5715,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 			newOwners,
 			newThreshold
 		]);
-		const recoveryApprovalResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const recoveryApprovalResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(recoveryApprovalResult, "getRecoveryApprovals");
 		const decodedCalldata = this.abiCoder.decode(["uint256"], recoveryApprovalResult);
 		return BigInt(decodedCalldata[0]);
@@ -5020,10 +5745,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 			newOwners,
 			newThreshold
 		]);
-		const hasGuardianApprovedResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const hasGuardianApprovedResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(hasGuardianApprovedResult, "hasGuardianApproved");
 		const decodedCalldata = this.abiCoder.decode(["bool"], hasGuardianApprovedResult);
 		return Boolean(decodedCalldata[0]);
@@ -5038,10 +5764,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 	*/
 	async isGuardian(nodeRpcUrl, accountAddress, guardian) {
 		const callData = createCallData("0xd4ee9734", ["address", "address"], [accountAddress, guardian]);
-		const isGuardianResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const isGuardianResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(isGuardianResult, "isGuardian");
 		const decodedCalldata = this.abiCoder.decode(["bool"], isGuardianResult);
 		return Boolean(decodedCalldata[0]);
@@ -5054,10 +5781,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 	*/
 	async guardiansCount(nodeRpcUrl, accountAddress) {
 		const callData = createCallData("0xc026e7ee", ["address"], [accountAddress]);
-		const guardiansCountResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const guardiansCountResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(guardiansCountResult, "guardiansCount");
 		const decodedCalldata = this.abiCoder.decode(["uint256"], guardiansCountResult);
 		return BigInt(decodedCalldata[0]);
@@ -5070,10 +5798,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 	*/
 	async threshold(nodeRpcUrl, accountAddress) {
 		const callData = createCallData("0xc86ec2bf", ["address"], [accountAddress]);
-		const thresholdResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const thresholdResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(thresholdResult, "threshold");
 		const decodedCalldata = this.abiCoder.decode(["uint256"], thresholdResult);
 		return BigInt(decodedCalldata[0]);
@@ -5086,10 +5815,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 	*/
 	async getGuardians(nodeRpcUrl, accountAddress) {
 		const callData = createCallData("0xf18858ab", ["address"], [accountAddress]);
-		const getGuardiansResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const getGuardiansResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(getGuardiansResult, "threshold");
 		return this.abiCoder.decode(["address[]"], getGuardiansResult)[0];
 	}
@@ -5101,10 +5831,11 @@ var SocialRecoveryModule = class SocialRecoveryModule extends SafeModule {
 	*/
 	async nonce(nodeRpcUrl, accountAddress) {
 		const callData = createCallData("0x70ae92d2", ["address"], [accountAddress]);
-		const nonceResult = await sendEthCallRequest(nodeRpcUrl, {
+		const ethCallParams = {
 			to: this.moduleAddress,
 			data: callData
-		}, "latest");
+		};
+		const nonceResult = await JsonRpcNode.from(nodeRpcUrl).call(ethCallParams, "latest");
 		this.checkForEmptyResultAndRevert(nonceResult, "threshold");
 		const decodedCalldata = this.abiCoder.decode(["uint256"], nonceResult);
 		return BigInt(decodedCalldata[0]);
@@ -6184,6 +6915,14 @@ var SafeMultiChainSigAccountV1 = class SafeMultiChainSigAccountV1 extends SafeAc
 	* {@link SafeAccountV0_3_0.signUserOperationWithSigners} for the full
 	* design rationale. Sets the multi-chain flag automatically.
 	*
+	* Note the chainId plumbing asymmetry vs the multi-op variant:
+	*   - **Singular** (this method): `chainId` is a positional argument.
+	*   - **Plural** ({@link signUserOperationsWithSigners}): `chainId` lives
+	*     inside each `UserOperationToSign` element, since each op may
+	*     target a different chain.
+	* Pick the variant that matches your bundle shape; don't pass the same
+	* chainId twice.
+	*
 	* @param userOperation - UserOperation to sign
 	* @param signers - one ExternalSigner per owner (any order)
 	* @param chainId - target chain id
@@ -6260,17 +6999,26 @@ var SafeMultiChainSigAccountV1 = class SafeMultiChainSigAccountV1 extends SafeAc
 	/**
 	* Sign a list of UserOperations with a single multi-chain signature. Each
 	* signer signs the Merkle root of the UserOperation EIP-712 hashes via
-	* raw-hash signing; `signTypedData` isn't exposed because the Merkle root
-	* is opaque and has no meaningful typed-data display.
+	* either `signTypedData` (the root is wrapped in an EIP-712 `MerkleTreeRoot`
+	* message) or raw-hash signing; both schemes produce signatures that
+	* validate against the same on-chain digest.
 	*
 	* Signers always receive {@link MultiOpSignContext}. The built-in adapters
-	* `fromPrivateKey`, `fromViem`, and `fromEthersWallet` return
-	* `Signer<unknown>` and work here without retyping; `fromViemWalletClient`
-	* does **not** — it only exposes `signTypedData`, so {@link pickScheme}
-	* rejects it offline. User-defined single-op signers
-	* (`Signer<SignContext>`) also don't work — they'd receive a context shape
+	* `fromPrivateKey`, `fromViem`, `fromEthersWallet`, and `fromViemWalletClient`
+	* all work here without retyping (`fromViemWalletClient` will sign the
+	* typed-data Merkle wrapper). User-defined single-op signers
+	* (`Signer<SignContext>`) still don't work — they'd receive a context shape
 	* they didn't declare.
 	*
+	* Note the chainId plumbing asymmetry vs the single-op variant:
+	*   - **Plural** (this method): each `UserOperationToSign` carries its
+	*     own `chainId`, since a multichain bundle's ops target different
+	*     chains.
+	*   - **Singular** ({@link signUserOperationWithSigners}): `chainId` is
+	*     a positional argument.
+	* For a length-1 bundle on this method, set `chainId` on the single
+	* element rather than reaching for the singular variant.
+	*
 	* @param userOperationsToSign - UserOperations + chain IDs + validity windows
 	* @param signers - one Signer per owner (any order; sorted by address on-chain)
 	* @returns one signature per input UserOperation, in the same order
@@ -6299,19 +7047,25 @@ var SafeMultiChainSigAccountV1 = class SafeMultiChainSigAccountV1 extends SafeAc
 			const [root, proofs] = generateMerkleProofs(userOperationsHashes);
 			const merkleTreeRootHash = TypedDataEncoder.hash({ verifyingContract: this.safe4337ModuleAddress }, EIP712_MULTI_CHAIN_OPERATIONS_TYPE, { merkleTreeRoot: root });
 			const normalizedAddresses = signers.map((signer) => getAddress(signer.address));
-			signers.forEach((signer, i) => {
-				pickScheme(signer, ["hash"], {
-					accountName: "SafeMultiChainSigAccountV1 (multi-op Merkle root)",
-					signerIndex: i
-				});
-			});
-			const signatures = await Promise.all(signers.map((signer) => invokeSigner(signer, "hash", {
+			const typedDataForBundle = {
+				domain: { verifyingContract: this.safe4337ModuleAddress },
+				types: EIP712_MULTI_CHAIN_OPERATIONS_TYPE,
+				primaryType: EIP712_MULTI_CHAIN_OPERATIONS_PRIMARY_TYPE,
+				message: { merkleTreeRoot: root }
+			};
+			const schemes = signers.map((signer, i) => pickScheme(signer, ["typedData", "hash"], {
+				accountName: "SafeMultiChainSigAccountV1 (multi-op Merkle root)",
+				signerIndex: i
+			}));
+			const signatures = await Promise.all(signers.map((signer, i) => invokeSigner(signer, schemes[i], {
 				hash: merkleTreeRootHash,
+				typedData: typedDataForBundle,
 				context
 			})));
 			const signerSignaturePairs = signers.map((_signer, i) => ({
 				signer: normalizedAddresses[i],
-				signature: signatures[i]
+				signature: signatures[i],
+				isContractSignature: signers[i].type === "contract"
 			}));
 			const userOpSignatures = [];
 			userOperationsToSign.forEach((uopToSign, index) => {
@@ -6338,9 +7092,16 @@ var SafeMultiChainSigAccountV1 = class SafeMultiChainSigAccountV1 extends SafeAc
 		}
 	}
 	/**
-	* Compute the EIP-712 hash of a multi-chain Merkle tree root for a set of UserOperations.
-	* This hash is what signers sign to approve multiple cross-chain operations at once.
-	* @param userOperationsToSignsToSign - list of UserOperations with their target chain IDs
+	* Compute the EIP-712 Merkle root wrapper digest that owners sign once
+	* across all UserOperations in a multi-chain bundle.
+	*
+	* Requires length≥2. For a single UserOperation use
+	* {@link SafeMultiChainSigAccountV1.getUserOperationEip712Hash} (the on-chain
+	* `merkleTreeDepth == 0` branch verifies against the per-op SafeOp digest,
+	* not a Merkle wrapper, so signing the wrapper for length=1 produces bytes
+	* the contract rejects with AA24).
+	*
+	* @param userOperationsToSignsToSign - list of UserOperations with their target chain IDs (length ≥ 2)
 	* @param overrides - optional overrides for the Safe 4337 module address
 	* @returns the EIP-712 hash as a hex string
 	*/
@@ -6351,12 +7112,25 @@ var SafeMultiChainSigAccountV1 = class SafeMultiChainSigAccountV1 extends SafeAc
 	/**
 	* Get the EIP-712 typed data components for a multi-chain Merkle tree root.
 	* Returns the domain, types, and message value needed for signing or hashing.
-	* @param userOperationsToSignsToSign - list of UserOperations with their target chain IDs
+	*
+	* Requires length≥2. For a single UserOperation use
+	* {@link SafeMultiChainSigAccountV1.getUserOperationEip712Data} (or
+	* {@link SafeMultiChainSigAccountV1.getUserOperationEip712Hash}): those
+	* multichain-class overrides default `safe4337ModuleAddress` to
+	* `DEFAULT_SAFE_4337_MODULE_ADDRESS`. The on-chain depth=0 path verifies
+	* against the per-op SafeOp digest, not a Merkle wrapper, so signing the
+	* wrapper for length=1 produces bytes the contract rejects with AA24. The
+	* parent `SafeAccount.getUserOperationEip712Data_V9` /
+	* `getUserOperationEip712Hash_V9` helpers default to a different module and
+	* would hash against the wrong verifying contract unless
+	* `overrides.safe4337ModuleAddress` is supplied explicitly.
+	*
+	* @param userOperationsToSignsToSign - list of UserOperations with their target chain IDs (length ≥ 2)
 	* @param overrides - optional overrides for the Safe 4337 module address
 	* @returns an object with domain, types, and messageValue for EIP-712 signing
 	*/
 	static getMultiChainSingleSignatureUserOperationsEip712Data(userOperationsToSign, overrides = {}) {
-		if (userOperationsToSign.length < 1) throw new RangeError("There should be at least one userOperationsToSign");
+		if (userOperationsToSign.length < 2) throw new RangeError("Multi-chain Merkle wrapper helpers require >= 2 userOperations. For a single UserOperation, use SafeMultiChainSigAccountV1.getUserOperationEip712Data or SafeMultiChainSigAccountV1.getUserOperationEip712Hash (these multichain-class overrides default safe4337ModuleAddress to DEFAULT_SAFE_4337_MODULE_ADDRESS, the multi-chain module). The on-chain depth=0 path verifies against the per-op SafeOp digest, not a Merkle wrapper. If calling the parent SafeAccount.getUserOperationEip712Data_V9 / getUserOperationEip712Hash_V9 helpers directly, you must pass overrides.safe4337ModuleAddress = SafeMultiChainSigAccountV1.DEFAULT_SAFE_4337_MODULE_ADDRESS explicitly so signatures hash the correct verifying contract.");
 		const safe4337ModuleAddress = overrides.safe4337ModuleAddress ?? SafeMultiChainSigAccountV1.DEFAULT_SAFE_4337_MODULE_ADDRESS;
 		const userOperationsHashes = [];
 		userOperationsToSign.forEach((userOperationsToSign, _index) => {
@@ -6509,13 +7283,13 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 	/**
 	* Check if this EOA is delegated to the expected delegatee address via EIP-7702.
 	* Returns `true` only when delegated to `this.delegateeAddress`.
-	* Use `getDelegatedAddress()` directly to get the raw delegatee address.
+	* Use `JsonRpcNode.getDelegatedAddress()` directly to get the raw delegatee address.
 	*
 	* @param providerRpc - Ethereum JSON-RPC node URL
 	* @returns `true` if delegated to the expected address, `false` otherwise
 	*/
 	async isDelegatedToThisAccount(providerRpc) {
-		const address = await getDelegatedAddress(this.accountAddress, providerRpc);
+		const address = await JsonRpcNode.from(providerRpc).getDelegatedAddress(this.accountAddress);
 		if (address === null) return false;
 		return address.toLowerCase() === this.delegateeAddress.toLowerCase();
 	}
@@ -6536,7 +7310,7 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 	* @returns Signed raw transaction hex, ready for `eth_sendRawTransaction`
 	*/
 	async createRevokeDelegationTransaction(eoaPrivateKey, providerRpc, overrides = {}) {
-		const delegatedTo = await getDelegatedAddress(this.accountAddress, providerRpc);
+		const delegatedTo = await JsonRpcNode.from(providerRpc).getDelegatedAddress(this.accountAddress);
 		if (delegatedTo === null) throw new AbstractionKitError("BAD_DATA", "Account is not delegated — nothing to revoke");
 		if (delegatedTo.toLowerCase() !== this.delegateeAddress.toLowerCase()) throw new AbstractionKitError("BAD_DATA", "Account is delegated to a different address (" + delegatedTo + "), not " + this.delegateeAddress + " — use the correct account class to revoke");
 		const results = {};
@@ -6639,7 +7413,7 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 			eip7702AuthNonce = overrides.eip7702Auth.nonce ?? null;
 		}
 		let delegationCheckOp = null;
-		if (overrides.eip7702Auth != null && providerRpc != null) delegationCheckOp = getDelegatedAddress(this.accountAddress, providerRpc).catch(() => null);
+		if (overrides.eip7702Auth != null && providerRpc != null) delegationCheckOp = JsonRpcNode.from(providerRpc).getDelegatedAddress(this.accountAddress).catch(() => null);
 		if (overrides.eip7702Auth != null && eip7702AuthNonce == null) {
 			let eip7702AuthNonceOp;
 			if (providerRpc != null) eip7702AuthNonceOp = sendJsonRpcRequest(providerRpc, "eth_getTransactionCount", [this.accountAddress, "latest"]);
@@ -6774,7 +7548,7 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 	*/
 	async baseEstimateUserOperationGas(userOperation, bundlerRpc, overrides = {}) {
 		userOperation.signature = overrides.dummySignature ?? BaseSimple7702Account.dummySignature;
-		const bundler = new Bundler(bundlerRpc);
+		const bundler = Bundler.from(bundlerRpc);
 		const inputMaxFeePerGas = userOperation.maxFeePerGas;
 		const inputMaxPriorityFeePerGas = userOperation.maxPriorityFeePerGas;
 		userOperation.maxFeePerGas = 0n;
@@ -6830,83 +7604,35 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 	* Deterministic-ECDSA signers yield byte-identical signatures; signers
 	* that differ in `s` / `v` normalization still validate the same on-chain.
 	*
-	* Common use cases beyond direct signing:
-	*   - Inspect / log the typed data the wallet will display.
-	*   - Render a custom confirmation UI before delegating to a wallet's
-	*     `signTypedData`.
-	*   - Drive non-`ExternalSigner`-shaped signers (HSM, MPC service,
-	*     backend signing pipelines).
+	* The base class defaults to EntryPoint v0.8; subclasses
+	* ({@link Simple7702AccountV09}) override with their own default.
 	*
 	* @param userOperation - Unsigned UserOperation to wrap
 	* @param chainId - Target chain ID (must match the chain that will validate
 	*   the signature)
+	* @param overrides - Override the entrypoint address
 	* @returns EIP-712 {@link TypedData} payload ready for `signTypedData`
-	* @throws {AbstractionKitError} if this account targets an EntryPoint
-	*   version other than v0.8 / v0.9. Earlier EntryPoints define the
-	*   userOpHash differently and require raw-hash signing.
-	*/
-	getUserOperationEip712TypedData(userOperation, chainId) {
-		const ep = this.entrypointAddress.toLowerCase();
-		const isV9 = ep === ENTRYPOINT_V9.toLowerCase();
-		if (ep !== "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108".toLowerCase() && !isV9) throw new AbstractionKitError("BAD_DATA", `getUserOperationEip712TypedData supports EntryPoint v0.8 / v0.9 only; this account targets ${this.entrypointAddress}. Use signUserOperation (raw-hash ECDSA) for earlier EntryPoint versions.`);
-		const abiCoder = AbiCoder.defaultAbiCoder();
-		const initCode = buildPackedInitCodeV8V9(userOperation);
-		const accountGasLimits = "0x" + abiCoder.encode(["uint128"], [userOperation.verificationGasLimit]).slice(34) + abiCoder.encode(["uint128"], [userOperation.callGasLimit]).slice(34);
-		const gasFees = "0x" + abiCoder.encode(["uint128"], [userOperation.maxPriorityFeePerGas]).slice(34) + abiCoder.encode(["uint128"], [userOperation.maxFeePerGas]).slice(34);
-		const paymasterAndData = buildPaymasterAndData(userOperation, isV9);
-		return {
-			domain: {
-				name: "ERC4337",
-				version: "1",
-				chainId,
-				verifyingContract: this.entrypointAddress
-			},
-			types: { PackedUserOperation: [
-				{
-					name: "sender",
-					type: "address"
-				},
-				{
-					name: "nonce",
-					type: "uint256"
-				},
-				{
-					name: "initCode",
-					type: "bytes"
-				},
-				{
-					name: "callData",
-					type: "bytes"
-				},
-				{
-					name: "accountGasLimits",
-					type: "bytes32"
-				},
-				{
-					name: "preVerificationGas",
-					type: "uint256"
-				},
-				{
-					name: "gasFees",
-					type: "bytes32"
-				},
-				{
-					name: "paymasterAndData",
-					type: "bytes"
-				}
-			] },
-			primaryType: "PackedUserOperation",
-			message: {
-				sender: userOperation.sender,
-				nonce: userOperation.nonce,
-				initCode,
-				callData: userOperation.callData,
-				accountGasLimits,
-				preVerificationGas: userOperation.preVerificationGas,
-				gasFees,
-				paymasterAndData
-			}
-		};
+	* @throws {AbstractionKitError} if the target EntryPoint is not v0.8 / v0.9.
+	*/
+	static getUserOperationEip712Data(userOperation, chainId, overrides = {}) {
+		return getUserOperationEip712DataV8V9(userOperation, overrides.entrypointAddress ?? "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108", chainId);
+	}
+	/**
+	* Compute the EIP-712 digest of a UserOperation under the EntryPoint
+	* v0.8 / v0.9 domain. For these EntryPoints this digest IS the
+	* `userOpHash` ({@link createUserOperationHash}); signing it with raw
+	* ECDSA or via `signTypedData` over the data from
+	* {@link getUserOperationEip712Data} produces a signature that validates
+	* against the same hash on-chain.
+	*
+	* @param userOperation - Unsigned UserOperation to hash
+	* @param chainId - Target chain ID
+	* @param overrides - Override the entrypoint address (defaults to EntryPoint v0.8)
+	* @returns The EIP-712 digest as a hex string
+	* @throws {AbstractionKitError} if the target EntryPoint is not v0.8 / v0.9.
+	*/
+	static getUserOperationEip712Hash(userOperation, chainId, overrides = {}) {
+		return getUserOperationEip712HashV8V9(userOperation, overrides.entrypointAddress ?? "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108", chainId);
 	}
 	/**
 	* Sign a UserOperation with an {@link AkSigner}. The signer can implement
@@ -6932,7 +7658,7 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 		};
 		return invokeSigner(signer, scheme, {
 			hash,
-			typedData: scheme === "typedData" ? this.getUserOperationEip712TypedData(useroperation, chainId) : void 0,
+			typedData: scheme === "typedData" ? BaseSimple7702Account.getUserOperationEip712Data(useroperation, chainId, { entrypointAddress: this.entrypointAddress }) : void 0,
 			context
 		});
 	}
@@ -6943,7 +7669,7 @@ var BaseSimple7702Account = class BaseSimple7702Account extends SmartAccount {
 	* @returns A {@link SendUseroperationResponse} that can be used to wait for inclusion
 	*/
 	async baseSendUserOperation(userOperation, bundlerRpc) {
-		const bundler = new Bundler(bundlerRpc);
+		const bundler = Bundler.from(bundlerRpc);
 		return new SendUseroperationResponse(await bundler.sendUserOperation(userOperation, this.entrypointAddress), bundler, this.entrypointAddress);
 	}
 	/**
@@ -7071,8 +7797,8 @@ var Simple7702Account = class Simple7702Account extends BaseSimple7702Account {
 	* {@link signUserOperation} method, or wrap explicitly with
 	* `fromPrivateKey(pk)`.
 	*
-	* @see {@link BaseSimple7702Account.getUserOperationEip712TypedData} for
-	*   the lower-level escape hatch when you need the typed data outside the
+	* @see {@link BaseSimple7702Account.getUserOperationEip712Data} for the
+	*   lower-level escape hatch when you need the typed data outside the
 	*   dispatcher (e.g., to render a custom confirmation UI or feed an HSM
 	*   that doesn't fit the {@link ExternalSigner} shape).
 	*/
@@ -7100,6 +7826,22 @@ var Simple7702Account = class Simple7702Account extends BaseSimple7702Account {
 var Simple7702AccountV09 = class Simple7702AccountV09 extends BaseSimple7702Account {
 	static DEFAULT_DELEGATEE_ADDRESS = "0xa46cc63eBF4Bd77888AA327837d20b23A63a56B5";
 	/**
+	* Build the EIP-712 typed data payload for a {@link UserOperationV9}
+	* under the EntryPoint v0.9 domain. See
+	* {@link BaseSimple7702Account.getUserOperationEip712Data} for the
+	* full semantics; this override just defaults `entrypointAddress` to v0.9.
+	*/
+	static getUserOperationEip712Data(userOperation, chainId, overrides = {}) {
+		return BaseSimple7702Account.getUserOperationEip712Data(userOperation, chainId, { entrypointAddress: overrides.entrypointAddress ?? "0x433709009B8330FDa32311DF1C2AFA402eD8D009" });
+	}
+	/**
+	* Compute the EIP-712 digest of a {@link UserOperationV9} under the
+	* EntryPoint v0.9 domain. Defaults `entrypointAddress` to v0.9.
+	*/
+	static getUserOperationEip712Hash(userOperation, chainId, overrides = {}) {
+		return BaseSimple7702Account.getUserOperationEip712Hash(userOperation, chainId, { entrypointAddress: overrides.entrypointAddress ?? "0x433709009B8330FDa32311DF1C2AFA402eD8D009" });
+	}
+	/**
 	* @param accountAddress - The EOA address that will be delegated via EIP-7702
 	* @param overrides - Optional overrides for entrypoint and delegatee addresses
 	* @param overrides.entrypointAddress - Custom EntryPoint address (defaults to EntryPoint v0.9)
@@ -7169,8 +7911,8 @@ var Simple7702AccountV09 = class Simple7702AccountV09 extends BaseSimple7702Acco
 	* {@link signUserOperation} method, or wrap explicitly with
 	* `fromPrivateKey(pk)`.
 	*
-	* @see {@link BaseSimple7702Account.getUserOperationEip712TypedData} for
-	*   the lower-level escape hatch when you need the typed data outside the
+	* @see {@link BaseSimple7702Account.getUserOperationEip712Data} for the
+	*   lower-level escape hatch when you need the typed data outside the
 	*   dispatcher.
 	*/
 	async signUserOperationWithSigner(useroperation, signer, chainId) {
@@ -7272,8 +8014,19 @@ const TOKENS_REQUIRING_ALLOWANCE_RESET$1 = ["0xdac17f958d2ee523a2206206994597c13
 * const { userOperation: sponsoredOp } = await paymaster.createSponsorPaymasterUserOperation(userOp, bundlerRpcUrl);
 */
 var CandidePaymaster = class CandidePaymaster extends Paymaster {
-	/** The paymaster JSON-RPC endpoint URL */
-	rpcUrl;
+	/**
+	* The raw transport the user passed in (or {@link HttpTransport} when a URL
+	* string was passed). Exposed for introspection — reading `.url`,
+	* `isHttpTransport(...)` checks, passing it back into another service.
+	*
+	* Calls made directly on this field (`paymaster.transport.request(...)`)
+	* go to the raw transport and skip SDK-level behavior like bigint param
+	* normalization. For SDK-pipeline behavior, use
+	* {@link CandidePaymaster.request} or the typed methods.
+	*/
+	transport;
+	/** Normalizing wrapper around {@link transport}, used for every SDK-outbound call. */
+	outbound;
 	/** Cached token/metadata per EntryPoint address (lowercase keys) */
 	entrypointData = /* @__PURE__ */ new Map();
 	/** Per-entrypoint initialization promises (lowercase keys) */
@@ -7281,11 +8034,30 @@ var CandidePaymaster = class CandidePaymaster extends Paymaster {
 	/** Cached chain ID (hex string), resolved from URL or pm_chainId RPC */
 	chainId = null;
 	chainIdPromise = null;
-	/** @param rpcUrl - The Candide paymaster JSON-RPC endpoint URL */
-	constructor(rpcUrl) {
+	/**
+	* @param rpc - The Candide paymaster JSON-RPC endpoint URL, or any {@link Transport}.
+	*   When a URL string is passed, the chain id is inferred from the URL path
+	*   when possible; otherwise it's resolved lazily via `pm_chainId`.
+	*/
+	constructor(rpc) {
 		super();
-		this.rpcUrl = rpcUrl;
-		this.chainId = CandidePaymaster.extractChainIdFromUrl(rpcUrl);
+		this.transport = typeof rpc === "string" ? new HttpTransport(rpc) : rpc;
+		this.outbound = normalizingTransport(this.transport);
+		this.chainId = typeof rpc === "string" ? CandidePaymaster.extractChainIdFromUrl(rpc) : null;
+	}
+	/**
+	* Normalize any acceptable input into a `CandidePaymaster`. Returns the
+	* input by reference when it's already a `CandidePaymaster`.
+	*/
+	static from(input) {
+		return input instanceof CandidePaymaster ? input : new CandidePaymaster(input);
+	}
+	/**
+	* Transport delegate. Forwards directly to {@link Transport.request}, so a
+	* `CandidePaymaster` can be slotted into any other transport position.
+	*/
+	request(args, options) {
+		return this.outbound.request(args, options);
 	}
 	/**
 	* Extract chain ID from a Candide paymaster URL.
@@ -7313,7 +8085,7 @@ var CandidePaymaster = class CandidePaymaster extends Paymaster {
 	}
 	async fetchChainId() {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, "pm_chainId", []);
+			return await this.outbound.request({ method: "pm_chainId" });
 		} catch (err) {
 			throw new AbstractionKitError("PAYMASTER_ERROR", "pm_chainId failed", { cause: ensureError(err) });
 		}
@@ -7413,7 +8185,10 @@ var CandidePaymaster = class CandidePaymaster extends Paymaster {
 		}
 	}
 	async fetchSupportedTokensRpc(entrypoint) {
-		return await sendJsonRpcRequest(this.rpcUrl, "pm_supportedERC20Tokens", [entrypoint]);
+		return await this.outbound.request({
+			method: "pm_supportedERC20Tokens",
+			params: [entrypoint]
+		});
 	}
 	/**
 	* Get the EntryPoint addresses supported by this paymaster.
@@ -7422,7 +8197,7 @@ var CandidePaymaster = class CandidePaymaster extends Paymaster {
 	*/
 	async getSupportedEntrypoints() {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, "pm_supportedEntryPoints", []);
+			return await this.outbound.request({ method: "pm_supportedEntryPoints" });
 		} catch (err) {
 			throw new AbstractionKitError("PAYMASTER_ERROR", "pm_supportedEntryPoints failed", { cause: ensureError(err) });
 		}
@@ -7489,7 +8264,7 @@ var CandidePaymaster = class CandidePaymaster extends Paymaster {
 		let callGasLimit = userOp.callGasLimit;
 		if (overrides.preVerificationGas == null || overrides.verificationGasLimit == null || overrides.callGasLimit == null) {
 			if (bundlerRpc == null) throw new AbstractionKitError("BAD_DATA", "bundlerRpc can't be null if preVerificationGas,verificationGasLimit and callGasLimit are not overridden");
-			const bundler = new Bundler(bundlerRpc);
+			const bundler = Bundler.from(bundlerRpc);
 			userOp.callGasLimit = 0n;
 			userOp.verificationGasLimit = 0n;
 			userOp.preVerificationGas = 0n;
@@ -7537,12 +8312,15 @@ var CandidePaymaster = class CandidePaymaster extends Paymaster {
 		try {
 			const entrypoint = overrides.entrypoint ?? this.resolveEntrypoint(smartAccount, userOperation);
 			const chainId = await this.getChainId();
-			const jsonRpcResult = await sendJsonRpcRequest(this.rpcUrl, "pm_getPaymasterData", [
-				userOperation,
-				entrypoint,
-				chainId,
-				context
-			]);
+			const jsonRpcResult = await this.outbound.request({
+				method: "pm_getPaymasterData",
+				params: [
+					userOperation,
+					entrypoint,
+					chainId,
+					context
+				]
+			});
 			return {
 				userOperation,
 				sponsorMetadata: this.applyPaymasterResult(userOperation, jsonRpcResult)
@@ -7726,8 +8504,19 @@ const TOKENS_REQUIRING_ALLOWANCE_RESET = ["0xdac17f958d2ee523a2206206994597c13d8
 */
 const CANDIDE_TOKEN_QUOTE_TTL_MS = 45e3;
 var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
-	/** The paymaster JSON-RPC endpoint URL */
-	rpcUrl;
+	/**
+	* The raw transport the user passed in (or {@link HttpTransport} when a URL
+	* string was passed). Exposed for introspection — reading `.url`,
+	* `isHttpTransport(...)` checks, passing it back into another service.
+	*
+	* Calls made directly on this field (`paymaster.transport.request(...)`)
+	* go to the raw transport and skip SDK-level behavior like bigint param
+	* normalization. For SDK-pipeline behavior, use
+	* {@link Erc7677Paymaster.request} or the typed methods.
+	*/
+	transport;
+	/** Normalizing wrapper around {@link transport}, used for every SDK-outbound call. */
+	outbound;
 	/** Cached chain ID (hex string). Passed via constructor or resolved from the bundler at first use. */
 	chainId;
 	/** Detected or explicitly set paymaster provider. `null` means no provider-specific features. */
@@ -7761,29 +8550,49 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 		return null;
 	}
 	/**
-	* @param rpcUrl - Paymaster JSON-RPC endpoint. Can be the same URL as the
-	*   bundler when the provider bundles both (Candide, Pimlico, Alchemy);
-	*   can also be a separate paymaster-only endpoint.
+	* @param rpc - Paymaster JSON-RPC endpoint URL, or any {@link Transport}.
+	*   Can be the same URL as the bundler when the provider bundles both
+	*   (Candide, Pimlico, Alchemy); can also be a separate paymaster-only
+	*   endpoint, or a fully custom transport.
 	* @param options
 	* @param options.chainId - Optional chain id as a bigint (e.g. `1n` for
 	*   mainnet). When provided, avoids a lookup at first use. Otherwise,
 	*   resolved from the bundler via `eth_chainId` on the first call.
 	* @param options.provider - Paymaster provider. `"auto"` (default) detects
-	*   from the RPC URL. Set explicitly to override, or `null` to disable.
+	*   from the RPC URL (only when a URL string is passed; non-string inputs
+	*   default to `null` unless overridden here). Set explicitly to override,
+	*   or `null` to disable provider-specific features.
 	*/
-	constructor(rpcUrl, options = {}) {
+	constructor(rpc, options = {}) {
 		super();
-		this.rpcUrl = rpcUrl;
+		this.transport = typeof rpc === "string" ? new HttpTransport(rpc) : rpc;
+		this.outbound = normalizingTransport(this.transport);
 		this.chainId = options.chainId != null ? `0x${options.chainId.toString(16)}` : null;
-		if (options.provider === void 0 || options.provider === "auto") this.provider = Erc7677Paymaster.detectProvider(rpcUrl);
+		if (options.provider === void 0 || options.provider === "auto") this.provider = typeof rpc === "string" ? Erc7677Paymaster.detectProvider(rpc) : null;
 		else this.provider = options.provider;
 	}
 	/**
+	* Normalize any acceptable input into an `Erc7677Paymaster`. Returns the
+	* input by reference when it's already an `Erc7677Paymaster` (in which
+	* case the second `options` argument is ignored — the existing instance's
+	* configuration is preserved).
+	*/
+	static from(input, options) {
+		return input instanceof Erc7677Paymaster ? input : new Erc7677Paymaster(input, options);
+	}
+	/**
+	* Transport delegate. Forwards directly to {@link Transport.request}, so
+	* an `Erc7677Paymaster` can be slotted into any other transport position.
+	*/
+	request(args, options) {
+		return this.outbound.request(args, options);
+	}
+	/**
 	* Resolve the chain id, querying the bundler if not provided at construction.
 	*/
 	async getChainId(bundlerRpc) {
 		if (this.chainId != null) return this.chainId;
-		const id = await new Bundler(bundlerRpc).chainId();
+		const id = await Bundler.from(bundlerRpc).chainId();
 		this.chainId = id;
 		return id;
 	}
@@ -7807,12 +8616,15 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 	*/
 	async getPaymasterStubData(userOperation, entrypoint, chainIdHex, context = {}) {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, "pm_getPaymasterStubData", [
-				userOperation,
-				entrypoint,
-				chainIdHex,
-				context
-			]);
+			return await this.outbound.request({
+				method: "pm_getPaymasterStubData",
+				params: [
+					userOperation,
+					entrypoint,
+					chainIdHex,
+					context
+				]
+			});
 		} catch (err) {
 			throw new AbstractionKitError("PAYMASTER_ERROR", "pm_getPaymasterStubData failed", { cause: ensureError(err) });
 		}
@@ -7823,12 +8635,15 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 	*/
 	async getPaymasterData(userOperation, entrypoint, chainIdHex, context = {}) {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, "pm_getPaymasterData", [
-				userOperation,
-				entrypoint,
-				chainIdHex,
-				context
-			]);
+			return await this.outbound.request({
+				method: "pm_getPaymasterData",
+				params: [
+					userOperation,
+					entrypoint,
+					chainIdHex,
+					context
+				]
+			});
 		} catch (err) {
 			throw new AbstractionKitError("PAYMASTER_ERROR", "pm_getPaymasterData failed", { cause: ensureError(err) });
 		}
@@ -7843,7 +8658,10 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 	*/
 	async sendRPCRequest(method, params = []) {
 		try {
-			return await sendJsonRpcRequest(this.rpcUrl, method, params);
+			return await this.outbound.request({
+				method,
+				params
+			});
 		} catch (err) {
 			throw new AbstractionKitError("PAYMASTER_ERROR", `sendRPCRequest(${method}) failed`, { cause: ensureError(err) });
 		}
@@ -7905,7 +8723,7 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 		let callGasLimit = userOp.callGasLimit;
 		if (overrides.preVerificationGas == null || overrides.verificationGasLimit == null || overrides.callGasLimit == null) {
 			if (bundlerRpc == null) throw new AbstractionKitError("BAD_DATA", "bundlerRpc can't be null if preVerificationGas, verificationGasLimit and callGasLimit are not overridden");
-			const bundler = new Bundler(bundlerRpc);
+			const bundler = Bundler.from(bundlerRpc);
 			userOp.callGasLimit = 0n;
 			userOp.verificationGasLimit = 0n;
 			userOp.preVerificationGas = 0n;
@@ -7945,11 +8763,14 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 	*   approval amount via `(exchangeRate * gasCostWei) / 10^18`.
 	*/
 	async fetchPimlicoTokenQuote(tokenAddress, entrypoint, chainIdHex) {
-		const quotes = (await sendJsonRpcRequest(this.rpcUrl, "pimlico_getTokenQuotes", [
-			{ tokens: [tokenAddress] },
-			entrypoint,
-			chainIdHex
-		]))?.quotes;
+		const quotes = (await this.outbound.request({
+			method: "pimlico_getTokenQuotes",
+			params: [
+				{ tokens: [tokenAddress] },
+				entrypoint,
+				chainIdHex
+			]
+		}))?.quotes;
 		if (!Array.isArray(quotes) || quotes.length === 0) throw new AbstractionKitError("PAYMASTER_ERROR", `pimlico_getTokenQuotes returned no quotes for token ${tokenAddress}`);
 		const quote = quotes.find((q) => q.token.toLowerCase() === tokenAddress.toLowerCase());
 		if (quote == null) throw new AbstractionKitError("PAYMASTER_ERROR", `pimlico_getTokenQuotes did not include token ${tokenAddress}`);
@@ -7975,7 +8796,10 @@ var Erc7677Paymaster = class Erc7677Paymaster extends Paymaster {
 		const cached = this.candideCache.get(key);
 		const isStale = cached != null && options.enforceTTL === true && Date.now() - cached.fetchedAt > CANDIDE_TOKEN_QUOTE_TTL_MS;
 		if (cached != null && !isStale) return cached.data;
-		const result = await sendJsonRpcRequest(this.rpcUrl, "pm_supportedERC20Tokens", [entrypoint]);
+		const result = await this.outbound.request({
+			method: "pm_supportedERC20Tokens",
+			params: [entrypoint]
+		});
 		this.candideCache.set(key, {
 			data: result,
 			fetchedAt: Date.now()
@@ -8152,7 +8976,7 @@ var WorldIdPermissionlessPaymaster = class extends Paymaster {
 		let verificationGasLimit = userOperation.verificationGasLimit;
 		let callGasLimit = userOperation.callGasLimit;
 		userOperation.preVerificationGas = 0n;
-		const estimation = await new Bundler(bundlerRpc).estimateUserOperationGas(userOperation, entrypointAddress, overrides.state_override_set);
+		const estimation = await Bundler.from(bundlerRpc).estimateUserOperationGas(userOperation, entrypointAddress, overrides.state_override_set);
 		if (preVerificationGas < estimation.preVerificationGas) preVerificationGas = estimation.preVerificationGas;
 		if (verificationGasLimit < estimation.verificationGasLimit) verificationGasLimit = estimation.verificationGasLimit;
 		if (callGasLimit < estimation.callGasLimit) callGasLimit = estimation.callGasLimit;
@@ -8315,8 +9139,8 @@ function coerceBigint(v, field) {
 */
 function pubkeyCoordinatesToJson(pubkey) {
 	return JSON.stringify({
-		x: "0x" + pubkey.x.toString(16),
-		y: "0x" + pubkey.y.toString(16)
+		x: `0x${pubkey.x.toString(16)}`,
+		y: `0x${pubkey.y.toString(16)}`
 	});
 }
 /**
@@ -8537,6 +9361,7 @@ var abstractionkit_exports = /* @__PURE__ */ __exportAll({
 	ALLOWANCE_MODULE_V0_1_0_ADDRESS: () => ALLOWANCE_MODULE_V0_1_0_ADDRESS,
 	AbstractionKitError: () => AbstractionKitError,
 	AllowanceModule: () => AllowanceModule,
+	BaseRpcTransport: () => BaseRpcTransport,
 	BaseUserOperationDummyValues: () => BaseUserOperationDummyValues,
 	Bundler: () => Bundler,
 	CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS: () => CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS,
@@ -8560,6 +9385,8 @@ var abstractionkit_exports = /* @__PURE__ */ __exportAll({
 	Erc7677Paymaster: () => Erc7677Paymaster,
 	ExperimentalAllowAllParallelPaymaster: () => ExperimentalAllowAllParallelPaymaster,
 	GasOption: () => GasOption,
+	HttpTransport: () => HttpTransport,
+	JsonRpcNode: () => JsonRpcNode,
 	Operation: () => Operation,
 	PolygonChain: () => PolygonChain,
 	SAFE_MESSAGE_MODULE_TYPE: () => SAFE_MESSAGE_MODULE_TYPE,
@@ -8577,6 +9404,7 @@ var abstractionkit_exports = /* @__PURE__ */ __exportAll({
 	SmartAccountFactory: () => SmartAccountFactory,
 	SocialRecoveryModule: () => SocialRecoveryModule,
 	SocialRecoveryModuleGracePeriodSelector: () => SocialRecoveryModuleGracePeriodSelector,
+	TransportRpcError: () => TransportRpcError,
 	WebauthnDummySignerSignaturePair: () => WebauthnDummySignerSignaturePair,
 	WorldIdPermissionlessPaymaster: () => WorldIdPermissionlessPaymaster,
 	ZeroAddress: () => ZeroAddress,
@@ -8591,17 +9419,15 @@ var abstractionkit_exports = /* @__PURE__ */ __exportAll({
 	createUserOperationHash: () => createUserOperationHash,
 	createWorldIdSignal: () => createWorldIdSignal,
 	fetchAccountNonce: () => fetchAccountNonce,
-	fetchGasPrice: () => fetchGasPrice,
 	fromEthersWallet: () => fromEthersWallet,
 	fromPrivateKey: () => fromPrivateKey,
 	fromSafeWebauthn: () => fromSafeWebauthn,
 	fromViem: () => fromViem,
 	fromViemWalletClient: () => fromViemWalletClient,
-	getBalanceOf: () => getBalanceOf,
-	getDelegatedAddress: () => getDelegatedAddress,
-	getDepositInfo: () => getDepositInfo,
 	getFunctionSelector: () => getFunctionSelector,
 	getSafeMessageEip712Data: () => getSafeMessageEip712Data,
+	isEventfulTransport: () => isEventfulTransport,
+	isHttpTransport: () => isHttpTransport,
 	pubkeyCoordinatesFromJson: () => pubkeyCoordinatesFromJson,
 	pubkeyCoordinatesToJson: () => pubkeyCoordinatesToJson,
 	sendJsonRpcRequest: () => sendJsonRpcRequest,
@@ -8616,6 +9442,6 @@ var abstractionkit_exports = /* @__PURE__ */ __exportAll({
 	webauthnSignatureFromAssertion: () => webauthnSignatureFromAssertion
 });
 //#endregion
-export { ALLOWANCE_MODULE_V0_1_0_ADDRESS, AbstractionKitError, AllowanceModule, BaseUserOperationDummyValues, Bundler, CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS, CALIBUR_UNISWAP_V1_0_0_SINGLETON_ADDRESS, Calibur7702Account, CaliburKeyType, CandidePaymaster, DEFAULT_SECP256R1_PRECOMPILE_ADDRESS, EIP712_MULTI_CHAIN_OPERATIONS_PRIMARY_TYPE, EIP712_MULTI_CHAIN_OPERATIONS_TYPE, EIP712_RECOVERY_MODULE_TYPE, EIP712_SAFE_OPERATION_PRIMARY_TYPE, EIP712_SAFE_OPERATION_V6_TYPE, EIP712_SAFE_OPERATION_V7_TYPE, ENTRYPOINT_V6, ENTRYPOINT_V7, ENTRYPOINT_V8, ENTRYPOINT_V9, EOADummySignerSignaturePair, EXECUTE_RECOVERY_PRIMARY_TYPE, Erc7677Paymaster, ExperimentalAllowAllParallelPaymaster, GasOption, Operation, PolygonChain, SAFE_MESSAGE_MODULE_TYPE, SAFE_MESSAGE_PRIMARY_TYPE, SafeAccountFactory, SafeAccountV0_2_0, SafeAccountV0_3_0, SafeAccountV1_5_0_M_0_3_0, SafeModuleExecutorFunctionSelector, SafeMultiChainSigAccountV1, SendUseroperationResponse, Simple7702Account, Simple7702AccountV09, SmartAccount, SmartAccountFactory, SocialRecoveryModule, SocialRecoveryModuleGracePeriodSelector, WebauthnDummySignerSignaturePair, WorldIdPermissionlessPaymaster, ZeroAddress, abstractionkit_exports as abstractionkit, calculateUserOperationMaxGasCost, callTenderlySimulateBundle, createAndSignEip7702DelegationAuthorization, createAndSignEip7702RawTransaction, createAndSignLegacyRawTransaction, createCallData, createEip7702DelegationAuthorizationHash, createEip7702TransactionHash, createUserOperationHash, createWorldIdSignal, fetchAccountNonce, fetchGasPrice, fromEthersWallet, fromPrivateKey, fromSafeWebauthn, fromViem, fromViemWalletClient, getBalanceOf, getDelegatedAddress, getDepositInfo, getFunctionSelector, getSafeMessageEip712Data, pubkeyCoordinatesFromJson, pubkeyCoordinatesToJson, sendJsonRpcRequest, shareTenderlySimulationAndCreateLink, signHash, simulateSenderCallDataWithTenderly, simulateSenderCallDataWithTenderlyAndCreateShareLink, simulateUserOperationCallDataWithTenderly, simulateUserOperationCallDataWithTenderlyAndCreateShareLink, simulateUserOperationWithTenderly, simulateUserOperationWithTenderlyAndCreateShareLink, webauthnSignatureFromAssertion };
+export { ALLOWANCE_MODULE_V0_1_0_ADDRESS, AbstractionKitError, AllowanceModule, BaseRpcTransport, BaseUserOperationDummyValues, Bundler, CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS, CALIBUR_UNISWAP_V1_0_0_SINGLETON_ADDRESS, Calibur7702Account, CaliburKeyType, CandidePaymaster, DEFAULT_SECP256R1_PRECOMPILE_ADDRESS, EIP712_MULTI_CHAIN_OPERATIONS_PRIMARY_TYPE, EIP712_MULTI_CHAIN_OPERATIONS_TYPE, EIP712_RECOVERY_MODULE_TYPE, EIP712_SAFE_OPERATION_PRIMARY_TYPE, EIP712_SAFE_OPERATION_V6_TYPE, EIP712_SAFE_OPERATION_V7_TYPE, ENTRYPOINT_V6, ENTRYPOINT_V7, ENTRYPOINT_V8, ENTRYPOINT_V9, EOADummySignerSignaturePair, EXECUTE_RECOVERY_PRIMARY_TYPE, Erc7677Paymaster, ExperimentalAllowAllParallelPaymaster, GasOption, HttpTransport, JsonRpcNode, Operation, PolygonChain, SAFE_MESSAGE_MODULE_TYPE, SAFE_MESSAGE_PRIMARY_TYPE, SafeAccountFactory, SafeAccountV0_2_0, SafeAccountV0_3_0, SafeAccountV1_5_0_M_0_3_0, SafeModuleExecutorFunctionSelector, SafeMultiChainSigAccountV1, SendUseroperationResponse, Simple7702Account, Simple7702AccountV09, SmartAccount, SmartAccountFactory, SocialRecoveryModule, SocialRecoveryModuleGracePeriodSelector, TransportRpcError, WebauthnDummySignerSignaturePair, WorldIdPermissionlessPaymaster, ZeroAddress, abstractionkit_exports as abstractionkit, calculateUserOperationMaxGasCost, callTenderlySimulateBundle, createAndSignEip7702DelegationAuthorization, createAndSignEip7702RawTransaction, createAndSignLegacyRawTransaction, createCallData, createEip7702DelegationAuthorizationHash, createEip7702TransactionHash, createUserOperationHash, createWorldIdSignal, fetchAccountNonce, fromEthersWallet, fromPrivateKey, fromSafeWebauthn, fromViem, fromViemWalletClient, getFunctionSelector, getSafeMessageEip712Data, isEventfulTransport, isHttpTransport, pubkeyCoordinatesFromJson, pubkeyCoordinatesToJson, sendJsonRpcRequest, shareTenderlySimulationAndCreateLink, signHash, simulateSenderCallDataWithTenderly, simulateSenderCallDataWithTenderlyAndCreateShareLink, simulateUserOperationCallDataWithTenderly, simulateUserOperationCallDataWithTenderlyAndCreateShareLink, simulateUserOperationWithTenderly, simulateUserOperationWithTenderlyAndCreateShareLink, webauthnSignatureFromAssertion };
 
 //# sourceMappingURL=index.mjs.map