@baliola/smart-account-sdk 0.3.1

package/dist/accounts/index.d.ts

@@ -0,0 +1,20 @@
+import { n as ISmartAccount, r as SigningAccount, t as Call } from "../types-CD0TvpY4.js";
+import { n as MacChainName } from "../index-BVqNo3O0.js";
+import { Account, Hex, PublicClient, Transport } from "viem";
+
+//#region src/accounts/encodeCalls.d.ts
+declare function encodeCalls(calls: Call[]): Hex;
+//#endregion
+//#region src/accounts/toSmartAccount.d.ts
+type OwnerInput = Account | Hex;
+interface ToSmartAccountParams {
+  owner: OwnerInput;
+  chain: MacChainName;
+  salt?: bigint;
+  nonceKey?: bigint;
+  transport?: Transport;
+  publicClient?: PublicClient;
+}
+declare function toSmartAccount(params: ToSmartAccountParams): Promise<ISmartAccount>;
+//#endregion
+export { Call, ISmartAccount, SigningAccount, ToSmartAccountParams, encodeCalls, toSmartAccount };

package/dist/accounts/index.js

@@ -0,0 +1,2 @@
+import { n as encodeCalls, t as toSmartAccount } from "../accounts-Bw0IrOJ1.js";
+export { encodeCalls, toSmartAccount };

package/dist/accounts-Bw0IrOJ1.js

@@ -0,0 +1,229 @@
+import { n as simpleAccountAbi, r as simpleAccountFactoryAbi, t as entryPointAbi } from "./abi-ziHt832n.js";
+import { t as deployments } from "./deployments-D4U_osAQ.js";
+import { resolveChain } from "./chains/index.js";
+import { concat, createPublicClient, encodeAbiParameters, encodeFunctionData, http, isHex, keccak256, pad, toHex } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+//#region src/accounts/encodeCalls.ts
+function encodeCalls(calls) {
+	if (calls.length === 0) throw new Error("encodeCalls requires at least one call");
+	if (calls.length === 1) {
+		const call = calls[0];
+		return encodeFunctionData({
+			abi: simpleAccountAbi,
+			functionName: "execute",
+			args: [
+				call.to,
+				call.value ?? 0n,
+				call.data ?? "0x"
+			]
+		});
+	}
+	return encodeFunctionData({
+		abi: simpleAccountAbi,
+		functionName: "executeBatch",
+		args: [
+			calls.map((c) => c.to),
+			calls.map((c) => c.value ?? 0n),
+			calls.map((c) => c.data ?? "0x")
+		]
+	});
+}
+//#endregion
+//#region ../shared/src/user-op/hash.ts
+/**
+* v0.7 EntryPoint.getUserOpHash equivalent:
+*
+*   inner = keccak256(abi.encode(
+*     sender, nonce,
+*     keccak256(initCode), keccak256(callData),
+*     accountGasLimits, preVerificationGas, gasFees,
+*     keccak256(paymasterAndData)
+*   ))
+*   userOpHash = keccak256(abi.encode(inner, entryPoint, chainId))
+*/
+function userOpHash(op, entryPoint, chainId) {
+	return keccak256(encodeAbiParameters([
+		{
+			name: "inner",
+			type: "bytes32"
+		},
+		{
+			name: "entryPoint",
+			type: "address"
+		},
+		{
+			name: "chainId",
+			type: "uint256"
+		}
+	], [
+		keccak256(encodeAbiParameters([
+			{
+				name: "sender",
+				type: "address"
+			},
+			{
+				name: "nonce",
+				type: "uint256"
+			},
+			{
+				name: "hashInitCode",
+				type: "bytes32"
+			},
+			{
+				name: "hashCallData",
+				type: "bytes32"
+			},
+			{
+				name: "accountGasLimits",
+				type: "bytes32"
+			},
+			{
+				name: "preVerificationGas",
+				type: "uint256"
+			},
+			{
+				name: "gasFees",
+				type: "bytes32"
+			},
+			{
+				name: "hashPaymasterAndData",
+				type: "bytes32"
+			}
+		], [
+			op.sender,
+			op.nonce,
+			keccak256(op.initCode),
+			keccak256(op.callData),
+			op.accountGasLimits,
+			op.preVerificationGas,
+			op.gasFees,
+			keccak256(op.paymasterAndData)
+		])),
+		entryPoint,
+		chainId
+	]));
+}
+//#endregion
+//#region ../shared/src/user-op/pack.ts
+const UINT128_MASK = (1n << 128n) - 1n;
+function packUints(high, low) {
+	if (high < 0n || high > UINT128_MASK) throw new Error(`high out of uint128 range: ${high}`);
+	if (low < 0n || low > UINT128_MASK) throw new Error(`low out of uint128 range: ${low}`);
+	return concat([pad(toHex(high), { size: 16 }), pad(toHex(low), { size: 16 })]);
+}
+function packInitCode(factory, factoryData) {
+	if (!factory || factory === "0x") return "0x";
+	return concat([factory, factoryData ?? "0x"]);
+}
+function packPaymasterAndData(paymaster, verificationGasLimit, postOpGasLimit, data) {
+	if (!paymaster || paymaster === "0x") return "0x";
+	const vgl = pad(toHex(verificationGasLimit ?? 0n), { size: 16 });
+	const pog = pad(toHex(postOpGasLimit ?? 0n), { size: 16 });
+	const extra = data && data !== "0x" ? data : "0x";
+	return extra === "0x" ? concat([
+		paymaster,
+		vgl,
+		pog
+	]) : concat([
+		paymaster,
+		vgl,
+		pog,
+		extra
+	]);
+}
+function pack(op) {
+	return {
+		sender: op.sender,
+		nonce: op.nonce,
+		initCode: packInitCode(op.factory, op.factoryData),
+		callData: op.callData,
+		accountGasLimits: packUints(op.verificationGasLimit, op.callGasLimit),
+		preVerificationGas: op.preVerificationGas,
+		gasFees: packUints(op.maxPriorityFeePerGas, op.maxFeePerGas),
+		paymasterAndData: packPaymasterAndData(op.paymaster, op.paymasterVerificationGasLimit, op.paymasterPostOpGasLimit, op.paymasterData),
+		signature: op.signature
+	};
+}
+//#endregion
+//#region src/accounts/toSmartAccount.ts
+const PRIVATE_KEY_HEX_LENGTH = 66;
+function lookupDeployment(chainId) {
+	const chainDeployments = deployments[chainId];
+	if (!chainDeployments) throw new Error(`toSmartAccount: no deployment found for chain id ${chainId}`);
+	const entryPoint = chainDeployments["01-EntryPoint"]?.EntryPoint;
+	const factory = chainDeployments["02-AccountFactory"]?.SimpleAccountFactory;
+	if (!entryPoint || !factory) throw new Error(`toSmartAccount: chain ${chainId} is missing EntryPoint or SimpleAccountFactory`);
+	return {
+		factory,
+		entryPoint
+	};
+}
+function resolveOwner(input) {
+	const account = typeof input === "string" ? fromPrivateKeyHex(input) : input;
+	if (!account.signMessage) throw new Error("toSmartAccount: owner Account must implement signMessage");
+	return account;
+}
+function fromPrivateKeyHex(input) {
+	if (!isHex(input) || input.length !== PRIVATE_KEY_HEX_LENGTH) throw new Error("toSmartAccount: owner hex must be a 32-byte 0x-prefixed private key");
+	return privateKeyToAccount(input);
+}
+async function toSmartAccount(params) {
+	const chain = resolveChain(params.chain);
+	const salt = params.salt ?? 0n;
+	const nonceKey = params.nonceKey ?? 0n;
+	const owner = resolveOwner(params.owner);
+	const { factory, entryPoint } = lookupDeployment(chain.id);
+	const address = await (params.publicClient ?? createPublicClient({
+		chain,
+		transport: params.transport ?? http()
+	})).readContract({
+		address: factory,
+		abi: simpleAccountFactoryAbi,
+		functionName: "getAddress",
+		args: [owner.address, salt]
+	});
+	const factoryData = encodeFunctionData({
+		abi: simpleAccountFactoryAbi,
+		functionName: "createAccount",
+		args: [owner.address, salt]
+	});
+	let deployedCache = false;
+	return {
+		address,
+		owner,
+		factory,
+		factoryData,
+		entryPoint,
+		nonceKey,
+		chainId: chain.id,
+		async isDeployed(client) {
+			if (deployedCache) return true;
+			const code = await client.getCode({ address });
+			if (code && code !== "0x") {
+				deployedCache = true;
+				return true;
+			}
+			return false;
+		},
+		markDeployed() {
+			deployedCache = true;
+		},
+		async signUserOperation(op) {
+			const hash = userOpHash(pack(op), entryPoint, BigInt(chain.id));
+			return owner.signMessage({ message: { raw: hash } });
+		},
+		encodeCalls(calls) {
+			return encodeCalls(calls);
+		},
+		async getNonce(client) {
+			return await client.readContract({
+				address: entryPoint,
+				abi: entryPointAbi,
+				functionName: "getNonce",
+				args: [address, nonceKey]
+			});
+		}
+	};
+}
+//#endregion
+export { encodeCalls as n, toSmartAccount as t };

package/dist/actions/index.d.ts

@@ -0,0 +1,37 @@
+import { i as IUserOperation, t as Call } from "../types-CD0TvpY4.js";
+import { _ as EstimateUserOperationGasParams, a as WriteContractOverrides, b as SmartAccountActionContext, c as UnwatchFn, d as watchUserOperations, f as WaitForUserOperationReceiptParams, g as sliceUserOpLogs, h as getUserOperationReceipt, i as WriteContractInput, l as UserOperationEventMatch, m as GetUserOperationReceiptParams, n as RawCall, o as bindWriteContract, p as waitForUserOperationReceipt, r as TypedCall, s as writeContract, t as BoundWriteContract, u as WatchUserOperationsParams, v as estimateUserOpGasRaw, x as UserOperationGasEstimate, y as estimateUserOperationGas } from "../writeContract-CdcmYmx0.js";
+import { Hex } from "viem";
+
+//#region src/actions/buildDraft.d.ts
+declare const DRAFT_GAS_ANCHORS: {
+  readonly callGasLimit: 200000n;
+  readonly verificationGasLimit: 900000n;
+  readonly preVerificationGas: 150000n;
+  readonly paymasterVerificationGasLimit: 200000n;
+  readonly paymasterPostOpGasLimit: 100000n;
+};
+/**
+ * 65-byte dummy signature used during `eth_estimateUserOperationGas`.
+ *
+ * SimpleAccount's `_validateSignature` calls OpenZeppelin 5.0.2's
+ * `ECDSA.recover(hash, signature)`, which enforces EIP-2 low-`s` (reverts
+ * when `s > n/2`) and rejects zero-recovery. A naive dummy like `0xfa * 64`
+ * has a high `s` and causes the simulation to revert before the account
+ * can return `SIG_VALIDATION_FAILED`.
+ *
+ * This dummy uses `r = 1`, `s = 1`, `v = 27` — all within OZ's accepted
+ * ranges. `ecrecover` returns a valid, non-zero address that almost
+ * certainly is not the owner, so the account returns
+ * `SIG_VALIDATION_FAILED` cleanly and the simulator produces gas numbers.
+ */
+declare const DUMMY_SIGNATURE: Hex;
+/**
+ * Build an unsigned, un-paymastered, pre-estimate UserOperation from raw
+ * calls. Gas limits are seeded to generous defaults so the bundler's
+ * estimator can simulate through MAC's Frontier EVM and return precise
+ * values; fee fields default to the chain's `gasPrice` (MAC reports legacy
+ * pricing, so `maxFee` and `maxPriorityFee` are equal).
+ */
+declare function buildDraftUserOp(ctx: SmartAccountActionContext, calls: Call[], overrides?: Partial<IUserOperation>): Promise<IUserOperation>;
+//#endregion
+export { BoundWriteContract, DRAFT_GAS_ANCHORS, DUMMY_SIGNATURE, EstimateUserOperationGasParams, GetUserOperationReceiptParams, RawCall, SmartAccountActionContext, TypedCall, UnwatchFn, UserOperationEventMatch, UserOperationGasEstimate, WaitForUserOperationReceiptParams, WatchUserOperationsParams, WriteContractInput, WriteContractOverrides, bindWriteContract, buildDraftUserOp, estimateUserOpGasRaw, estimateUserOperationGas, getUserOperationReceipt, sliceUserOpLogs, waitForUserOperationReceipt, watchUserOperations, writeContract };

package/dist/actions/index.js

@@ -0,0 +1,2 @@
+import { a as getUserOperationReceipt, c as estimateUserOperationGas, d as DRAFT_GAS_ANCHORS, f as DUMMY_SIGNATURE, i as waitForUserOperationReceipt, n as writeContract, o as sliceUserOpLogs, p as buildDraftUserOp, r as watchUserOperations, s as estimateUserOpGasRaw, t as bindWriteContract } from "../writeContract-AyQox2dQ.js";
+export { DRAFT_GAS_ANCHORS, DUMMY_SIGNATURE, bindWriteContract, buildDraftUserOp, estimateUserOpGasRaw, estimateUserOperationGas, getUserOperationReceipt, sliceUserOpLogs, waitForUserOperationReceipt, watchUserOperations, writeContract };

package/dist/auth/index.d.ts

@@ -0,0 +1,35 @@
+import { n as MacChainName } from "../index-BVqNo3O0.js";
+import { n as ApiKeyInvalidReason, r as ApiKeyQuota, t as ApiKeyInfo } from "../types-BcsdeCby.js";
+
+//#region src/auth/authUrls.d.ts
+/**
+ * Default baliola-auth base URLs per MAC chain. The SDK appends
+ * `/api/api-keys/validate` to whatever URL is configured.
+ */
+declare const DEFAULT_AUTH_URLS: Record<MacChainName, string>;
+/**
+ * Resolve the auth base URL for a chain, honoring an optional override
+ * (e.g. `http://localhost:8000` during dev). Trailing slashes are stripped
+ * so the caller can append a path safely.
+ */
+declare function resolveAuthUrl(chainName: MacChainName, override?: string): string;
+//#endregion
+//#region src/auth/validateApiKey.d.ts
+interface ValidateApiKeyParams {
+  /** Auth base URL — `<baliola-auth host>`, without `/api/...`. */
+  authUrl: string;
+  /** Customer key (`baliola_key_…` or `baliola_secret_…`). */
+  apiKey: string;
+}
+/**
+ * Validate a customer API key against `baliola-auth` and return the resolved
+ * key info on success. Throws `ApiKeyInvalidError` on a structured rejection
+ * (`valid: false` or `401`), and `BaliolaAuthUnreachableError` on network /
+ * transport failures (fetch rejection, non-2xx 5xx, unparseable body).
+ *
+ * One successful call charges one quota unit against the key — callers should
+ * cache the resulting client rather than re-invoking the factory.
+ */
+declare function validateApiKey(params: ValidateApiKeyParams): Promise<ApiKeyInfo>;
+//#endregion
+export { ApiKeyInfo, ApiKeyInvalidReason, ApiKeyQuota, DEFAULT_AUTH_URLS, ValidateApiKeyParams, resolveAuthUrl, validateApiKey };

package/dist/auth/index.js

@@ -0,0 +1,2 @@
+import { n as DEFAULT_AUTH_URLS, r as resolveAuthUrl, t as validateApiKey } from "../validateApiKey-lUfEM5W0.js";
+export { DEFAULT_AUTH_URLS, resolveAuthUrl, validateApiKey };

package/dist/base-v7RyiDFz.js

@@ -0,0 +1,104 @@
+//#region src/errors/base.ts
+/**
+* Root class for every error thrown from inside the SDK.
+*
+* **Opinionated message convention**: `err.message` is always written for an
+* end user — short, polite, and safe to surface directly in product UI. The
+* machine-readable discriminators live on:
+*  - `err.code` — internal tag or AA-code string
+*  - `err.reason` — typed enum on errors that have one
+*  - `err.detail` — optional technical sentence for developer logs
+*  - `err.cause` — the underlying transport / library error
+*
+* Translate or rebrand `err.message` only when you need a different tone or
+* locale; you can always rebuild your own copy from `err.code` / `err.reason`.
+*/
+var SmartAccountSDKError = class extends Error {
+	code;
+	detail;
+	userOp;
+	cause;
+	constructor(message, options) {
+		super(message);
+		this.name = new.target.name;
+		this.code = options.code;
+		if (options.detail !== void 0) this.detail = options.detail;
+		if (options.userOp !== void 0) this.userOp = options.userOp;
+		if (options.cause !== void 0) this.cause = options.cause;
+	}
+};
+var UserOperationReceiptTimeoutError = class extends SmartAccountSDKError {
+	userOpHash;
+	timeoutMs;
+	constructor(userOpHash, timeoutMs) {
+		super("Your transaction is taking longer than expected. Please check the block explorer or try again.", {
+			code: "RECEIPT_TIMEOUT",
+			detail: `Timed out after ${timeoutMs}ms waiting for ${userOpHash}`
+		});
+		this.userOpHash = userOpHash;
+		this.timeoutMs = timeoutMs;
+	}
+};
+const PAYMASTER_CONFIG_MESSAGES = {
+	invalid_address: "Gas sponsorship address is invalid. Please contact support.",
+	zero_address: "Gas sponsorship address is invalid. Please contact support.",
+	no_registered_paymaster: "Gas sponsorship isn't available for this network. Please contact support."
+};
+/**
+* Thrown at SDK construction when the paymaster configuration is unusable.
+* The user-facing message is generic; `reason` + `detail` carry the dev info.
+*/
+var PaymasterConfigError = class extends SmartAccountSDKError {
+	reason;
+	constructor(reason, detail) {
+		super(PAYMASTER_CONFIG_MESSAGES[reason], {
+			code: "PAYMASTER_CONFIG",
+			detail
+		});
+		this.reason = reason;
+	}
+};
+const API_KEY_MESSAGES = {
+	not_found: "Invalid API key. Please check your credentials.",
+	revoked: "This API key has been revoked. Please generate a new one.",
+	expired: "This API key has expired. Please generate a new one.",
+	wrong_module: "This API key isn't authorized for this app.",
+	module_inactive: "This service is currently unavailable. Please try again later.",
+	origin_not_allowed: "This domain isn't allowed to use this API key.",
+	quota_exceeded: "You've hit the request limit. Please try again later.",
+	rate_limited: "Too many requests. Please slow down and try again."
+};
+/**
+* Thrown by `createSmartAccountClient` when baliola-auth rejects the API key.
+* `reason` is the strict enum string; `message` is the matching user copy.
+*/
+var ApiKeyInvalidError = class extends SmartAccountSDKError {
+	reason;
+	retryAfterSeconds;
+	constructor(reason, retryAfterSeconds) {
+		super(API_KEY_MESSAGES[reason], {
+			code: "API_KEY_INVALID",
+			detail: `baliola-auth rejected the key (reason=${reason})`
+		});
+		this.reason = reason;
+		if (retryAfterSeconds !== void 0) this.retryAfterSeconds = retryAfterSeconds;
+	}
+};
+/**
+* Thrown when baliola-auth is unreachable — fetch rejection, 5xx, or
+* unparseable body. Distinct from `ApiKeyInvalidError`, which covers
+* structured rejections.
+*/
+var BaliolaAuthUnreachableError = class extends SmartAccountSDKError {
+	url;
+	constructor(url, cause) {
+		super("Authentication service is temporarily unavailable. Please try again in a moment.", {
+			code: "AUTH_UNREACHABLE",
+			detail: `Failed to reach baliola-auth at ${url}`,
+			cause
+		});
+		this.url = url;
+	}
+};
+//#endregion
+export { UserOperationReceiptTimeoutError as a, SmartAccountSDKError as i, BaliolaAuthUnreachableError as n, PaymasterConfigError as r, ApiKeyInvalidError as t };

package/dist/chains/index.d.ts

@@ -0,0 +1,2 @@
+import { a as resolveChain, i as macTestnet, n as MacChainName, r as macMainnet, t as MAC_CHAINS } from "../index-BVqNo3O0.js";
+export { MAC_CHAINS, MacChainName, macMainnet, macTestnet, resolveChain };

package/dist/chains/index.js

@@ -0,0 +1,33 @@
+import { defineChain } from "viem";
+//#region src/chains/index.ts
+const macTestnet = defineChain({
+	id: 20017,
+	name: "MAC Testnet",
+	nativeCurrency: {
+		name: "Kepeng Testnet",
+		symbol: "KPGBT",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://collator1.baliola.dev"] } },
+	testnet: true
+});
+const macMainnet = defineChain({
+	id: 20016,
+	name: "MAC",
+	nativeCurrency: {
+		name: "Kepeng",
+		symbol: "KPGB",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://collator4-mac.baliola.io"] } },
+	testnet: false
+});
+const MAC_CHAINS = {
+	macTestnet,
+	macMainnet
+};
+function resolveChain(name) {
+	return MAC_CHAINS[name];
+}
+//#endregion
+export { MAC_CHAINS, macMainnet, macTestnet, resolveChain };

package/dist/classifyBundlerError-BqFLORNt.js

@@ -0,0 +1,161 @@
+import { i as SmartAccountSDKError } from "./base-v7RyiDFz.js";
+//#region src/errors/bundlerError.ts
+/** Base class for every error originating from the bundler's JSON-RPC surface. */
+var BundlerRpcError = class extends SmartAccountSDKError {
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+/** `-32602` — bundler rejected the params (invalid UserOp shape, fee too low, etc.). */
+var InvalidUserOperationError = class extends BundlerRpcError {};
+/** `-32500` and kin — bundler accepted the shape but dropped the op on submit. */
+var UserOperationRejectedError = class extends BundlerRpcError {};
+/** Network or transport failure reaching the bundler — not an on-chain rejection. */
+var BundlerUnreachableError = class extends BundlerRpcError {};
+//#endregion
+//#region src/errors/aaError.ts
+/**
+* Base class for errors produced when the EntryPoint or one of its
+* validation partners rejects a UserOperation. The `code` is the AA-code
+* string from the bundler (e.g. "AA24"); subclasses narrow by bucket.
+*/
+var UserOperationRevertError = class extends SmartAccountSDKError {
+	constructor(message, options) {
+		super(message, options);
+	}
+};
+/** AA1x — Smart Account factory / `initCode` deployment failures. */
+var AccountFactoryError = class extends UserOperationRevertError {};
+/** AA2x — account's `validateUserOp` rejection (prefund, signature, nonce). */
+var AccountValidationError = class extends UserOperationRevertError {};
+/** AA3x — Gas Allowance Pool's `validatePaymasterUserOp` rejection. */
+var PaymasterValidationError = class extends UserOperationRevertError {};
+/** AA9x — EntryPoint bundle-frame invariants. Rarely reached by app code. */
+var BundleFrameError = class extends UserOperationRevertError {};
+//#endregion
+//#region src/errors/mapAaCode.ts
+const AA_CODE = /AA\d\d/;
+const KNOWN_CODES = {
+	AA10: AccountFactoryError,
+	AA13: AccountFactoryError,
+	AA14: AccountFactoryError,
+	AA15: AccountFactoryError,
+	AA21: AccountValidationError,
+	AA22: AccountValidationError,
+	AA23: AccountValidationError,
+	AA24: AccountValidationError,
+	AA25: AccountValidationError,
+	AA26: AccountValidationError,
+	AA31: PaymasterValidationError,
+	AA32: PaymasterValidationError,
+	AA33: PaymasterValidationError,
+	AA34: PaymasterValidationError,
+	AA36: PaymasterValidationError,
+	AA90: BundleFrameError,
+	AA91: BundleFrameError,
+	AA92: BundleFrameError,
+	AA93: BundleFrameError,
+	AA94: BundleFrameError,
+	AA95: BundleFrameError,
+	AA96: BundleFrameError
+};
+/**
+* Classify a bundler revert message by its AA code. Returns both the
+* matched code string and the concrete subclass constructor, or `null`
+* when the message has no AA code at all. Callers instantiate `ctor`
+* with their own message/context and set `err.code = code`.
+*/
+function mapAaCode(message) {
+	const match = AA_CODE.exec(message);
+	if (!match) return null;
+	const code = match[0];
+	return {
+		code,
+		ctor: KNOWN_CODES[code] ?? UserOperationRevertError
+	};
+}
+//#endregion
+//#region src/errors/classifyBundlerError.ts
+/** Walk the `cause` chain and return the first numeric `code` found. */
+function findRpcCode(err) {
+	let cur = err;
+	while (cur !== null && cur !== void 0) {
+		const e = cur;
+		if (typeof e.code === "number") return e.code;
+		cur = e.cause;
+	}
+	return null;
+}
+/** Walk the `cause` chain for a network-level failure indicator. */
+function isNetworkFailure(err) {
+	let cur = err;
+	while (cur !== null && cur !== void 0) {
+		const e = cur;
+		if (e.name === "HttpRequestError") return true;
+		if (e.name === "TimeoutError") return true;
+		if (typeof e.code === "string") {
+			const c = e.code;
+			if (c === "ECONNREFUSED" || c === "UND_ERR_CONNECT_TIMEOUT" || c === "ECONNRESET") return true;
+		}
+		cur = e.cause;
+	}
+	return false;
+}
+function extractMessage(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+/**
+* Bucket-level, end-user-displayable copy for each AA code. The technical
+* revert reason is preserved in `err.cause.message` and the specific code
+* is on `err.code`.
+*/
+function userMessageForAaCode(aaCode) {
+	if (aaCode.startsWith("AA1")) return "We couldn't set up your smart account. Please try again.";
+	if (aaCode.startsWith("AA2")) return "Your transaction couldn't be authorized. Please try again.";
+	if (aaCode.startsWith("AA3")) return "Gas sponsorship was declined for this transaction. Please try again later.";
+	if (aaCode.startsWith("AA9")) return "Something went wrong submitting your transaction. Please try again.";
+	return "Your transaction couldn't be completed. Please try again.";
+}
+const USER_MESSAGE_INVALID_PARAMS = "Your transaction was rejected before submission. Please try again.";
+const USER_MESSAGE_REJECTED = "Your transaction was rejected by the network. Please try again.";
+const USER_MESSAGE_UNREACHABLE = "Couldn't reach the network. Please check your connection and try again.";
+const USER_MESSAGE_GENERIC_RPC = "Something went wrong submitting your transaction. Please try again.";
+/**
+* Classify a raw error from the bundler transport into a typed SDK error.
+*
+* - JSON-RPC `-32602` (invalid params) → `InvalidUserOperationError`
+* - JSON-RPC `-32500` (op rejected) → `UserOperationRejectedError`
+* - AA-code revert messages → corresponding `UserOperationRevertError` subclass
+* - Network failures (fetch error, timeout) → `BundlerUnreachableError`
+* - Anything else → `BundlerRpcError` base
+*
+* Returned errors carry an end-user-displayable `.message`; the original
+* technical message stays on `.cause.message`, and the typed `code` /
+* AA code is on `.code`.
+*/
+function classifyBundlerError(err, userOp) {
+	const technicalMessage = extractMessage(err);
+	const code = findRpcCode(err);
+	const codeStr = code !== null ? String(code) : "UNKNOWN";
+	const userOpCtx = userOp !== void 0 ? { userOp } : {};
+	const aa = mapAaCode(technicalMessage);
+	if (aa) return new aa.ctor(userMessageForAaCode(aa.code), {
+		code: aa.code,
+		detail: technicalMessage,
+		cause: err,
+		...userOpCtx
+	});
+	const rpcBase = {
+		code: codeStr,
+		detail: technicalMessage,
+		cause: err,
+		...userOpCtx
+	};
+	if (code === -32602) return new InvalidUserOperationError(USER_MESSAGE_INVALID_PARAMS, rpcBase);
+	if (code === -32500) return new UserOperationRejectedError(USER_MESSAGE_REJECTED, rpcBase);
+	if (isNetworkFailure(err)) return new BundlerUnreachableError(USER_MESSAGE_UNREACHABLE, rpcBase);
+	return new BundlerRpcError(USER_MESSAGE_GENERIC_RPC, rpcBase);
+}
+//#endregion
+export { BundleFrameError as a, BundlerRpcError as c, UserOperationRejectedError as d, AccountValidationError as i, BundlerUnreachableError as l, mapAaCode as n, PaymasterValidationError as o, AccountFactoryError as r, UserOperationRevertError as s, classifyBundlerError as t, InvalidUserOperationError as u };