abstractionkit 0.3.7 → 0.3.8

package/dist/index.iife.js

@@ -30,6 +30,16 @@ var abstractionkit = (function(exports, ethers) {
 		"-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.
@@ -84,164 +94,164 @@ var abstractionkit = (function(exports, ethers) {
 		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
 	/**
@@ -275,560 +285,456 @@ var abstractionkit = (function(exports, ethers) {
 		return PolygonChain;
 	}({});
 	//#endregion
-	//#region src/utils.ts
-	function buildDomainSeparator(chainId, entrypoint) {
-		return (0, ethers.keccak256)(ethers.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 = ethers.AbiCoder.defaultAbiCoder();
-		let userOperationHash;
-		if (entrypointAddress.toLowerCase() === "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789".toLowerCase()) {
-			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV6(useroperation));
-			userOperationHash = (0, ethers.keccak256)(abiCoder.encode([
-				"bytes32",
-				"address",
-				"uint256"
-			], [
-				packedUserOperationHash,
-				entrypointAddress,
-				chainId
-			]));
-		} else if (entrypointAddress.toLowerCase() === "0x0000000071727De22E5E9d8BAf0edAc6f37da032".toLowerCase()) {
-			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV7(useroperation));
-			userOperationHash = (0, ethers.keccak256)(abiCoder.encode([
-				"bytes32",
-				"address",
-				"uint256"
-			], [
-				packedUserOperationHash,
-				entrypointAddress,
-				chainId
-			]));
-		} else if (entrypointAddress.toLowerCase() === "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108".toLowerCase()) {
-			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV8(useroperation));
-			userOperationHash = (0, ethers.keccak256)(`0x1901${buildDomainSeparator(chainId, entrypointAddress).slice(2)}${packedUserOperationHash.slice(2)}`);
-		} else if (entrypointAddress.toLowerCase() === "0x433709009B8330FDa32311DF1C2AFA402eD8D009".toLowerCase()) {
-			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV9(useroperation));
-			userOperationHash = (0, ethers.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 (0, ethers.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" + ethers.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 = ethers.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 = ethers.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,
-			(0, ethers.keccak256)(useroperation.initCode),
-			(0, ethers.keccak256)(useroperation.callData),
-			useroperation.callGasLimit,
-			useroperation.verificationGasLimit,
-			useroperation.preVerificationGas,
-			useroperation.maxFeePerGas,
-			useroperation.maxPriorityFeePerGas,
-			(0, ethers.keccak256)(useroperation.paymasterAndData)
-		];
-		return ethers.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 = ethers.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,
-			(0, ethers.keccak256)(initCode),
-			(0, ethers.keccak256)(useroperation.callData),
-			accountGasLimits,
-			useroperation.preVerificationGas,
-			gasFees,
-			(0, ethers.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 = ethers.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,
-			(0, ethers.keccak256)(initCode),
-			(0, ethers.keccak256)(useroperation.callData),
-			accountGasLimits,
-			useroperation.preVerificationGas,
-			gasFees,
-			(0, ethers.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 + ethers.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 (0, ethers.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 ethers.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 = ethers.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 (0, ethers.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.
@@ -836,11 +742,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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");
 			}
 		}
 		/**
@@ -849,9 +755,9 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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");
 			}
 		}
 		/**
@@ -863,14 +769,15 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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),
@@ -880,7 +787,7 @@ var abstractionkit = (function(exports, ethers) {
 				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");
 			}
 		}
 		/**
@@ -891,9 +798,12 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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");
 			}
 		}
 		/**
@@ -903,31 +813,31 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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 });
 			}
 		}
 		/**
@@ -937,43 +847,233 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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;
@@ -983,7 +1083,7 @@ var abstractionkit = (function(exports, ethers) {
 	/**
 	* 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.
@@ -1206,45 +1306,540 @@ var abstractionkit = (function(exports, ethers) {
 		}
 		return encoded_access_list;
 	}
-	/** Converts a bigint to a Uint8Array of its big-endian byte representation. */
-	function bigintToBytes(bi) {
-		return (0, ethers.getBytes)((0, ethers.toBeArray)(bi));
+	/** Converts a bigint to a Uint8Array of its big-endian byte representation. */
+	function bigintToBytes(bi) {
+		return (0, ethers.getBytes)((0, ethers.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 (0, ethers.keccak256)(ethers.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 = ethers.AbiCoder.defaultAbiCoder();
+		let userOperationHash;
+		if (entrypointAddress.toLowerCase() === "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789".toLowerCase()) {
+			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV6(useroperation));
+			userOperationHash = (0, ethers.keccak256)(abiCoder.encode([
+				"bytes32",
+				"address",
+				"uint256"
+			], [
+				packedUserOperationHash,
+				entrypointAddress,
+				chainId
+			]));
+		} else if (entrypointAddress.toLowerCase() === "0x0000000071727De22E5E9d8BAf0edAc6f37da032".toLowerCase()) {
+			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV7(useroperation));
+			userOperationHash = (0, ethers.keccak256)(abiCoder.encode([
+				"bytes32",
+				"address",
+				"uint256"
+			], [
+				packedUserOperationHash,
+				entrypointAddress,
+				chainId
+			]));
+		} else if (entrypointAddress.toLowerCase() === "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108".toLowerCase()) {
+			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV8(useroperation));
+			userOperationHash = (0, ethers.keccak256)(`0x1901${buildDomainSeparator(chainId, entrypointAddress).slice(2)}${packedUserOperationHash.slice(2)}`);
+		} else if (entrypointAddress.toLowerCase() === "0x433709009B8330FDa32311DF1C2AFA402eD8D009".toLowerCase()) {
+			packedUserOperationHash = (0, ethers.keccak256)(createPackedUserOperationV9(useroperation));
+			userOperationHash = (0, ethers.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 = ethers.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 = ethers.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 = ethers.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 ethers.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,
+			(0, ethers.keccak256)(useroperation.initCode),
+			(0, ethers.keccak256)(useroperation.callData),
+			useroperation.callGasLimit,
+			useroperation.verificationGasLimit,
+			useroperation.preVerificationGas,
+			useroperation.maxFeePerGas,
+			useroperation.maxPriorityFeePerGas,
+			(0, ethers.keccak256)(useroperation.paymasterAndData)
+		];
+		return ethers.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 = ethers.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,
+			(0, ethers.keccak256)(initCode),
+			(0, ethers.keccak256)(useroperation.callData),
+			accountGasLimits,
+			useroperation.preVerificationGas,
+			gasFees,
+			(0, ethers.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 = ethers.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,
+			(0, ethers.keccak256)(initCode),
+			(0, ethers.keccak256)(useroperation.callData),
+			accountGasLimits,
+			useroperation.preVerificationGas,
+			gasFees,
+			(0, ethers.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 + ethers.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 (0, ethers.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
@@ -1452,6 +2047,29 @@ var abstractionkit = (function(exports, ethers) {
 				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 */
@@ -1481,6 +2099,46 @@ var abstractionkit = (function(exports, ethers) {
 			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.
 		*
@@ -1532,7 +2190,7 @@ var abstractionkit = (function(exports, ethers) {
 			}
 			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"]);
@@ -1634,7 +2292,7 @@ var abstractionkit = (function(exports, ethers) {
 				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);
@@ -1680,38 +2338,46 @@ var abstractionkit = (function(exports, ethers) {
 			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";
@@ -1755,7 +2421,7 @@ var abstractionkit = (function(exports, ethers) {
 		* @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);
 		}
 		/**
@@ -1941,7 +2607,7 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		async createRevokeDelegationRawTransaction(chainId, eoaPrivateKey, providerRpc, overrides = {}) {
 			if (new ethers.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 = {};
@@ -2005,14 +2671,14 @@ var abstractionkit = (function(exports, ethers) {
 		/**
 		* 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();
 		}
@@ -2560,7 +3226,8 @@ var abstractionkit = (function(exports, ethers) {
 	* @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,
@@ -2589,11 +3256,53 @@ var abstractionkit = (function(exports, ethers) {
 			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
@@ -2819,7 +3528,7 @@ var abstractionkit = (function(exports, ethers) {
 		* ```
 		*/
 		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
@@ -3203,11 +3912,11 @@ var abstractionkit = (function(exports, ethers) {
 		/**
 		* 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);
 		}
 		/**
@@ -3390,7 +4099,7 @@ var abstractionkit = (function(exports, ethers) {
 				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;
@@ -3913,7 +4622,7 @@ var abstractionkit = (function(exports, ethers) {
 					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
@@ -3996,7 +4705,7 @@ var abstractionkit = (function(exports, ethers) {
 					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
@@ -4124,10 +4833,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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 ethers.AbiCoder.defaultAbiCoder().decode(["address[]"], getOwnersResult)[0];
 		}
 		/**
@@ -4137,10 +4847,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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 = ethers.AbiCoder.defaultAbiCoder().decode(["uint256"], getThresholdResult);
 			return Number(decodedCalldata[0]);
 		}
@@ -4159,10 +4870,11 @@ var abstractionkit = (function(exports, ethers) {
 				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 = ethers.AbiCoder.defaultAbiCoder().decode(["address[]", "address"], getModulesResult);
 				return [decodedCalldata[0], decodedCalldata[1]];
@@ -4178,10 +4890,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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 ethers.AbiCoder.defaultAbiCoder().decode(["bool"], isModuleEnabledResult)[0];
 		}
 		/**
@@ -4248,7 +4961,7 @@ var abstractionkit = (function(exports, ethers) {
 				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 ethers.AbiCoder.defaultAbiCoder().decode(["bool"], isModuleEnabledResult)[0];
 		}
 		static createSafeWebAuthnSignerProxyDeployedByteCode(signer, eip7212WebAuthnPrecompileVerifier, eip7212WebAuthnContractVerifier, webAuthnSignerSingleton) {
@@ -4368,7 +5081,7 @@ var abstractionkit = (function(exports, ethers) {
 	* @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.7") {
+	function generateOnChainIdentifier(project, platform = "Web", tool = "abstractionkit", toolVersion = "0.3.8") {
 		const identifierPrefix = "5afe";
 		const identifierVersion = "00";
 		const projectHash = (0, ethers.keccak256)(`0x${Buffer.from(project, "utf8").toString("hex")}`).slice(-20);
@@ -4631,10 +5344,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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];
 		}
@@ -4656,10 +5370,11 @@ var abstractionkit = (function(exports, ethers) {
 				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 {
@@ -4711,10 +5426,11 @@ var abstractionkit = (function(exports, ethers) {
 				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 {
@@ -4799,13 +5515,19 @@ var abstractionkit = (function(exports, ethers) {
 				"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 {
@@ -4957,10 +5679,11 @@ var abstractionkit = (function(exports, ethers) {
 				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];
 		}
@@ -4972,10 +5695,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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 {
@@ -5003,10 +5727,11 @@ var abstractionkit = (function(exports, ethers) {
 				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]);
@@ -5032,10 +5757,11 @@ var abstractionkit = (function(exports, ethers) {
 				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]);
@@ -5050,10 +5776,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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]);
@@ -5066,10 +5793,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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]);
@@ -5082,10 +5810,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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]);
@@ -5098,10 +5827,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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];
 		}
@@ -5113,10 +5843,11 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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]);
@@ -6196,6 +6927,14 @@ var abstractionkit = (function(exports, ethers) {
 		* {@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
@@ -6272,17 +7011,26 @@ var abstractionkit = (function(exports, ethers) {
 		/**
 		* 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
@@ -6311,14 +7059,19 @@ var abstractionkit = (function(exports, ethers) {
 				const [root, proofs] = generateMerkleProofs(userOperationsHashes);
 				const merkleTreeRootHash = ethers.TypedDataEncoder.hash({ verifyingContract: this.safe4337ModuleAddress }, EIP712_MULTI_CHAIN_OPERATIONS_TYPE, { merkleTreeRoot: root });
 				const normalizedAddresses = signers.map((signer) => (0, ethers.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) => ({
@@ -6542,13 +7295,13 @@ var abstractionkit = (function(exports, ethers) {
 		/**
 		* 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();
 		}
@@ -6569,7 +7322,7 @@ var abstractionkit = (function(exports, ethers) {
 		* @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 = {};
@@ -6672,7 +7425,7 @@ var abstractionkit = (function(exports, ethers) {
 				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"]);
@@ -6807,7 +7560,7 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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;
@@ -6863,83 +7616,35 @@ var abstractionkit = (function(exports, ethers) {
 		* 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 = ethers.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
@@ -6965,7 +7670,7 @@ var abstractionkit = (function(exports, ethers) {
 			};
 			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
 			});
 		}
@@ -6976,7 +7681,7 @@ var abstractionkit = (function(exports, ethers) {
 		* @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);
 		}
 		/**
@@ -7104,8 +7809,8 @@ var abstractionkit = (function(exports, ethers) {
 		* {@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).
 		*/
@@ -7133,6 +7838,22 @@ var abstractionkit = (function(exports, ethers) {
 	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)
@@ -7202,8 +7923,8 @@ var abstractionkit = (function(exports, ethers) {
 		* {@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) {
@@ -7305,8 +8026,19 @@ var abstractionkit = (function(exports, ethers) {
 	* 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) */
@@ -7314,11 +8046,30 @@ var abstractionkit = (function(exports, ethers) {
 		/** 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.
@@ -7346,7 +8097,7 @@ var abstractionkit = (function(exports, ethers) {
 		}
 		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) });
 			}
@@ -7446,7 +8197,10 @@ var abstractionkit = (function(exports, ethers) {
 			}
 		}
 		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.
@@ -7455,7 +8209,7 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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) });
 			}
@@ -7522,7 +8276,7 @@ var abstractionkit = (function(exports, ethers) {
 			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;
@@ -7570,12 +8324,15 @@ var abstractionkit = (function(exports, ethers) {
 			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)
@@ -7759,8 +8516,19 @@ var abstractionkit = (function(exports, ethers) {
 	*/
 	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. */
@@ -7794,29 +8562,49 @@ var abstractionkit = (function(exports, ethers) {
 			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;
 		}
@@ -7840,12 +8628,15 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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) });
 			}
@@ -7856,12 +8647,15 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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) });
 			}
@@ -7876,7 +8670,10 @@ var abstractionkit = (function(exports, ethers) {
 		*/
 		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) });
 			}
@@ -7938,7 +8735,7 @@ var abstractionkit = (function(exports, ethers) {
 			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;
@@ -7978,11 +8775,14 @@ var abstractionkit = (function(exports, ethers) {
 		*   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}`);
@@ -8008,7 +8808,10 @@ var abstractionkit = (function(exports, ethers) {
 			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()
@@ -8185,7 +8988,7 @@ var abstractionkit = (function(exports, ethers) {
 			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;
@@ -8570,6 +9373,7 @@ var abstractionkit = (function(exports, ethers) {
 		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,
@@ -8593,6 +9397,8 @@ var abstractionkit = (function(exports, ethers) {
 		Erc7677Paymaster: () => Erc7677Paymaster,
 		ExperimentalAllowAllParallelPaymaster: () => ExperimentalAllowAllParallelPaymaster,
 		GasOption: () => GasOption,
+		HttpTransport: () => HttpTransport,
+		JsonRpcNode: () => JsonRpcNode,
 		Operation: () => Operation,
 		PolygonChain: () => PolygonChain,
 		SAFE_MESSAGE_MODULE_TYPE: () => SAFE_MESSAGE_MODULE_TYPE,
@@ -8610,6 +9416,7 @@ var abstractionkit = (function(exports, ethers) {
 		SmartAccountFactory: () => SmartAccountFactory,
 		SocialRecoveryModule: () => SocialRecoveryModule,
 		SocialRecoveryModuleGracePeriodSelector: () => SocialRecoveryModuleGracePeriodSelector,
+		TransportRpcError: () => TransportRpcError,
 		WebauthnDummySignerSignaturePair: () => WebauthnDummySignerSignaturePair,
 		WorldIdPermissionlessPaymaster: () => WorldIdPermissionlessPaymaster,
 		ZeroAddress: () => ZeroAddress,
@@ -8624,17 +9431,15 @@ var abstractionkit = (function(exports, ethers) {
 		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,
@@ -8652,6 +9457,7 @@ var abstractionkit = (function(exports, ethers) {
 	exports.ALLOWANCE_MODULE_V0_1_0_ADDRESS = ALLOWANCE_MODULE_V0_1_0_ADDRESS;
 	exports.AbstractionKitError = AbstractionKitError;
 	exports.AllowanceModule = AllowanceModule;
+	exports.BaseRpcTransport = BaseRpcTransport;
 	exports.BaseUserOperationDummyValues = BaseUserOperationDummyValues;
 	exports.Bundler = Bundler;
 	exports.CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS = CALIBUR_CANDIDE_V0_1_0_SINGLETON_ADDRESS;
@@ -8675,6 +9481,8 @@ var abstractionkit = (function(exports, ethers) {
 	exports.Erc7677Paymaster = Erc7677Paymaster;
 	exports.ExperimentalAllowAllParallelPaymaster = ExperimentalAllowAllParallelPaymaster;
 	exports.GasOption = GasOption;
+	exports.HttpTransport = HttpTransport;
+	exports.JsonRpcNode = JsonRpcNode;
 	exports.Operation = Operation;
 	exports.PolygonChain = PolygonChain;
 	exports.SAFE_MESSAGE_MODULE_TYPE = SAFE_MESSAGE_MODULE_TYPE;
@@ -8692,6 +9500,7 @@ var abstractionkit = (function(exports, ethers) {
 	exports.SmartAccountFactory = SmartAccountFactory;
 	exports.SocialRecoveryModule = SocialRecoveryModule;
 	exports.SocialRecoveryModuleGracePeriodSelector = SocialRecoveryModuleGracePeriodSelector;
+	exports.TransportRpcError = TransportRpcError;
 	exports.WebauthnDummySignerSignaturePair = WebauthnDummySignerSignaturePair;
 	exports.WorldIdPermissionlessPaymaster = WorldIdPermissionlessPaymaster;
 	exports.ZeroAddress = ZeroAddress;
@@ -8712,17 +9521,15 @@ var abstractionkit = (function(exports, ethers) {
 	exports.createUserOperationHash = createUserOperationHash;
 	exports.createWorldIdSignal = createWorldIdSignal;
 	exports.fetchAccountNonce = fetchAccountNonce;
-	exports.fetchGasPrice = fetchGasPrice;
 	exports.fromEthersWallet = fromEthersWallet;
 	exports.fromPrivateKey = fromPrivateKey;
 	exports.fromSafeWebauthn = fromSafeWebauthn;
 	exports.fromViem = fromViem;
 	exports.fromViemWalletClient = fromViemWalletClient;
-	exports.getBalanceOf = getBalanceOf;
-	exports.getDelegatedAddress = getDelegatedAddress;
-	exports.getDepositInfo = getDepositInfo;
 	exports.getFunctionSelector = getFunctionSelector;
 	exports.getSafeMessageEip712Data = getSafeMessageEip712Data;
+	exports.isEventfulTransport = isEventfulTransport;
+	exports.isHttpTransport = isHttpTransport;
 	exports.pubkeyCoordinatesFromJson = pubkeyCoordinatesFromJson;
 	exports.pubkeyCoordinatesToJson = pubkeyCoordinatesToJson;
 	exports.sendJsonRpcRequest = sendJsonRpcRequest;