@baliola/smart-account-sdk 0.3.1

package/dist/clients/index.d.ts

@@ -0,0 +1,86 @@
+import { i as IUserOperation, n as ISmartAccount } from "../types-CD0TvpY4.js";
+import { n as MacChainName } from "../index-BVqNo3O0.js";
+import { C as CreateBundlerClientParams, S as BundlerClient, d as watchUserOperations, h as getUserOperationReceipt, p as waitForUserOperationReceipt, t as BoundWriteContract, w as createBundlerClient, y as estimateUserOperationGas } from "../writeContract-CdcmYmx0.js";
+import { t as ApiKeyInfo } from "../types-BcsdeCby.js";
+import { Address, Hex, PublicClient, Transport } from "viem";
+
+//#region src/clients/bundlerUrls.d.ts
+declare const DEFAULT_BUNDLER_URLS: Record<MacChainName, string>;
+interface ResolveBundlerTransportParams {
+  chainName: MacChainName;
+  bundlerTransport?: Transport;
+  bundlerUrl?: string;
+}
+/**
+ * Resolve a bundler `Transport` from optional caller overrides. Precedence:
+ * explicit `bundlerTransport` > explicit `bundlerUrl` > default chain URL.
+ */
+declare function resolveBundlerTransport(p: ResolveBundlerTransportParams): Transport;
+//#endregion
+//#region src/clients/createSmartAccountClient.d.ts
+interface CreateSmartAccountClientParams {
+  account: ISmartAccount;
+  chain: MacChainName;
+  /** Customer API key (`baliola_key_…` or `baliola_secret_…`). Required. */
+  apiKey: string;
+  /** baliola-auth base URL override. Defaults to the registered host for the chain. */
+  authUrl?: string;
+  /** Chain RPC transport. Defaults to `http()` against the chain's built-in RPC URL. */
+  transport?: Transport;
+  /** Full viem `Transport` for the bundler. */
+  bundlerTransport?: Transport;
+  /** Bundler URL override. */
+  bundlerUrl?: string;
+  /** Paymaster address override. Defaults to the chain's registered Gas Allowance Pool. */
+  paymasterAddress?: Address;
+}
+type SdkActions = {
+  account: ISmartAccount;
+  apiKey: ApiKeyInfo;
+  writeContract: BoundWriteContract;
+  estimateUserOperationGas: (params: Parameters<typeof estimateUserOperationGas>[1]) => ReturnType<typeof estimateUserOperationGas>;
+  getUserOperationReceipt: (params: Parameters<typeof getUserOperationReceipt>[1]) => ReturnType<typeof getUserOperationReceipt>;
+  waitForUserOperationReceipt: (params: Parameters<typeof waitForUserOperationReceipt>[1]) => ReturnType<typeof waitForUserOperationReceipt>;
+  watchUserOperations: (params: Parameters<typeof watchUserOperations>[1]) => ReturnType<typeof watchUserOperations>;
+};
+type PublicClientBase = Omit<PublicClient, "sendTransaction" | "account">;
+type SmartAccountClient = PublicClientBase & SdkActions;
+/**
+ * Compose a Smart Account client from an account, a chain string, and an
+ * API key. Eagerly validates the key against baliola-auth before returning —
+ * fail-fast on revoked / expired / quota-exhausted keys via
+ * `ApiKeyInvalidError`, or `BaliolaAuthUnreachableError` if the auth service
+ * itself can't be reached.
+ *
+ * Zero-config: pass only `account` + `chain` + `apiKey` and the SDK resolves
+ * the chain RPC, the bundler URL, the auth URL, and the paymaster automatically.
+ */
+declare function createSmartAccountClient(params: CreateSmartAccountClientParams): Promise<SmartAccountClient>;
+//#endregion
+//#region src/clients/rpcCodec.d.ts
+/**
+ * JSON-RPC wire shape for ERC-4337 v0.7 `eth_sendUserOperation`.
+ * Bigints are hex-encoded; optional fields are omitted when absent,
+ * except the paymaster trio, which must travel together once paymaster is set.
+ */
+interface RpcUserOperation {
+  sender: Hex;
+  nonce: Hex;
+  factory?: Hex;
+  factoryData?: Hex;
+  callData: Hex;
+  callGasLimit: Hex;
+  verificationGasLimit: Hex;
+  preVerificationGas: Hex;
+  maxFeePerGas: Hex;
+  maxPriorityFeePerGas: Hex;
+  paymaster?: Hex;
+  paymasterVerificationGasLimit?: Hex;
+  paymasterPostOpGasLimit?: Hex;
+  paymasterData?: Hex;
+  signature: Hex;
+}
+declare function toRpcUserOp(op: IUserOperation): RpcUserOperation;
+declare function fromRpcUserOp(rpc: RpcUserOperation): IUserOperation;
+//#endregion
+export { BundlerClient, CreateBundlerClientParams, CreateSmartAccountClientParams, DEFAULT_BUNDLER_URLS, ResolveBundlerTransportParams, RpcUserOperation, SmartAccountClient, createBundlerClient, createSmartAccountClient, fromRpcUserOp, resolveBundlerTransport, toRpcUserOp };

package/dist/clients/index.js

@@ -0,0 +1,3 @@
+import { l as fromRpcUserOp, u as toRpcUserOp } from "../writeContract-AyQox2dQ.js";
+import { i as resolveBundlerTransport, n as createBundlerClient, r as DEFAULT_BUNDLER_URLS, t as createSmartAccountClient } from "../clients-B17dl_fh.js";
+export { DEFAULT_BUNDLER_URLS, createBundlerClient, createSmartAccountClient, fromRpcUserOp, resolveBundlerTransport, toRpcUserOp };

package/dist/clients-B17dl_fh.js

@@ -0,0 +1,134 @@
+import { t as deployments } from "./deployments-D4U_osAQ.js";
+import { resolveChain } from "./chains/index.js";
+import { a as getUserOperationReceipt, c as estimateUserOperationGas, i as waitForUserOperationReceipt, r as watchUserOperations, t as bindWriteContract } from "./writeContract-AyQox2dQ.js";
+import { r as PaymasterConfigError } from "./base-v7RyiDFz.js";
+import { r as resolveAuthUrl, t as validateApiKey } from "./validateApiKey-lUfEM5W0.js";
+import { t as classifyBundlerError } from "./classifyBundlerError-BqFLORNt.js";
+import { createPublicClient, http, isAddress } from "viem";
+//#region src/clients/bundlerUrls.ts
+const DEFAULT_BUNDLER_URLS = {
+	macTestnet: "https://bundler-testnet.baliola.dev/rpc",
+	macMainnet: "https://bundler-mainnet.baliola.io/rpc"
+};
+/**
+* Resolve a bundler `Transport` from optional caller overrides. Precedence:
+* explicit `bundlerTransport` > explicit `bundlerUrl` > default chain URL.
+*/
+function resolveBundlerTransport(p) {
+	if (p.bundlerTransport) return p.bundlerTransport;
+	return http(p.bundlerUrl ?? DEFAULT_BUNDLER_URLS[p.chainName]);
+}
+//#endregion
+//#region src/clients/createBundlerClient.ts
+/**
+* Thin JSON-RPC wrapper over a viem `Transport`. Speaks the ERC-4337 v0.7
+* bundler methods without pulling in the rest of viem's client surface,
+* because the bundler endpoint is a different service than the chain RPC.
+*
+* Every error thrown out of `request` is first classified into a typed
+* SDK error (`InvalidUserOperationError`, `UserOperationRejectedError`,
+* `BundlerUnreachableError`, or one of the `UserOperationRevertError`
+* subclasses for AA-code reverts). Callers never see a raw viem error.
+*/
+function createBundlerClient({ transport, chain }) {
+	const bound = transport({
+		chain,
+		retryCount: 0
+	});
+	return { async request(method, params) {
+		try {
+			return await bound.request({
+				method,
+				params
+			});
+		} catch (err) {
+			throw classifyBundlerError(err);
+		}
+	} };
+}
+//#endregion
+//#region src/paymaster/resolvePaymaster.ts
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+* Look up the GAP address for a chain via the `aliases.gasAllowancePool`
+* layer emitted by `shared/scripts/codegen-addresses.ts`. Returns `null`
+* when the chain has no alias.
+*/
+function lookupGasAllowancePool(chainId) {
+	const chainDeployments = deployments[chainId];
+	if (!chainDeployments) return null;
+	return chainDeployments.aliases?.gasAllowancePool ?? null;
+}
+/**
+* Build a `PaymasterResolver` from an optional override.
+*
+* - `paymasterAddress` omitted → uses the chain's registered Gas Allowance Pool.
+* - `paymasterAddress` provided → validates checksum + non-zero, uses it verbatim.
+* - Neither override nor a registered GAP → throws `PaymasterConfigError` at construction.
+*
+* SDK always uses a paymaster. Self-funded mode is not supported on the public API.
+*/
+function resolvePaymaster(paymasterAddress, chainId) {
+	if (paymasterAddress !== void 0) {
+		if (!isAddress(paymasterAddress)) throw new PaymasterConfigError("invalid_address", `paymasterAddress is not a valid address: ${paymasterAddress}`);
+		if (paymasterAddress.toLowerCase() === ZERO_ADDRESS) throw new PaymasterConfigError("zero_address", "paymasterAddress cannot be the zero address");
+	}
+	const address = paymasterAddress ?? lookupGasAllowancePool(chainId);
+	if (!address) throw new PaymasterConfigError("no_registered_paymaster", `No paymaster address registered for chain id ${chainId}`);
+	return async () => ({
+		paymaster: address,
+		paymasterData: "0x"
+	});
+}
+//#endregion
+//#region src/clients/createSmartAccountClient.ts
+function bindActions(ctx) {
+	return {
+		writeContract: bindWriteContract(ctx),
+		estimateUserOperationGas: (p) => estimateUserOperationGas(ctx, p),
+		getUserOperationReceipt: (p) => getUserOperationReceipt(ctx, p),
+		waitForUserOperationReceipt: (p) => waitForUserOperationReceipt(ctx, p),
+		watchUserOperations: (p) => watchUserOperations(ctx, p)
+	};
+}
+/**
+* Compose a Smart Account client from an account, a chain string, and an
+* API key. Eagerly validates the key against baliola-auth before returning —
+* fail-fast on revoked / expired / quota-exhausted keys via
+* `ApiKeyInvalidError`, or `BaliolaAuthUnreachableError` if the auth service
+* itself can't be reached.
+*
+* Zero-config: pass only `account` + `chain` + `apiKey` and the SDK resolves
+* the chain RPC, the bundler URL, the auth URL, and the paymaster automatically.
+*/
+async function createSmartAccountClient(params) {
+	const chain = resolveChain(params.chain);
+	const paymaster = resolvePaymaster(params.paymasterAddress, chain.id);
+	const apiKey = await validateApiKey({
+		authUrl: resolveAuthUrl(params.chain, params.authUrl),
+		apiKey: params.apiKey
+	});
+	const publicClient = createPublicClient({
+		chain,
+		transport: params.transport ?? http()
+	});
+	const bundler = createBundlerClient({ transport: resolveBundlerTransport({
+		chainName: params.chain,
+		bundlerTransport: params.bundlerTransport,
+		bundlerUrl: params.bundlerUrl
+	}) });
+	const ctx = {
+		account: params.account,
+		publicClient,
+		bundler,
+		entryPoint: params.account.entryPoint,
+		paymaster
+	};
+	return Object.assign(publicClient, {
+		account: params.account,
+		apiKey,
+		...bindActions(ctx)
+	});
+}
+//#endregion
+export { resolveBundlerTransport as i, createBundlerClient as n, DEFAULT_BUNDLER_URLS as r, createSmartAccountClient as t };

package/dist/deployments-D4U_osAQ.js

@@ -0,0 +1,10 @@
+//#region ../shared/src/contracts/deployments.ts
+const deployments = { 20017: {
+	"01-EntryPoint": { EntryPoint: "0x0000000071727De22E5E9d8BAf0edAc6f37da032" },
+	"02-AccountFactory": { SimpleAccountFactory: "0x76A91436B13Cd7CcE2692B304a880b5DaE5C01D2" },
+	"03-Paymaster": { TestPaymasterAcceptAll: "0xC52d9d729377b74cB5baD5df83D26CC9b0Bd10dB" },
+	"04-Counter": { TestCounter: "0xF8a4300Bd6400ED8BA1023569BaACD3559A93243" },
+	aliases: { gasAllowancePool: "0xC52d9d729377b74cB5baD5df83D26CC9b0Bd10dB" }
+} };
+//#endregion
+export { deployments as t };

package/dist/errors/index.d.ts

@@ -0,0 +1,136 @@
+import { n as ApiKeyInvalidReason } from "../types-BcsdeCby.js";
+
+//#region src/errors/base.d.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`.
+ */
+declare class SmartAccountSDKError extends Error {
+  readonly code: string;
+  readonly detail?: string;
+  readonly userOp?: unknown;
+  readonly cause?: unknown;
+  constructor(message: string, options: {
+    code: string;
+    detail?: string;
+    userOp?: unknown;
+    cause?: unknown;
+  });
+}
+declare class UserOperationReceiptTimeoutError extends SmartAccountSDKError {
+  readonly userOpHash: string;
+  readonly timeoutMs: number;
+  constructor(userOpHash: string, timeoutMs: number);
+}
+type PaymasterConfigReason = "invalid_address" | "zero_address" | "no_registered_paymaster";
+/**
+ * Thrown at SDK construction when the paymaster configuration is unusable.
+ * The user-facing message is generic; `reason` + `detail` carry the dev info.
+ */
+declare class PaymasterConfigError extends SmartAccountSDKError {
+  readonly reason: PaymasterConfigReason;
+  constructor(reason: PaymasterConfigReason, detail?: string);
+}
+/**
+ * Thrown by `createSmartAccountClient` when baliola-auth rejects the API key.
+ * `reason` is the strict enum string; `message` is the matching user copy.
+ */
+declare class ApiKeyInvalidError extends SmartAccountSDKError {
+  readonly reason: ApiKeyInvalidReason;
+  readonly retryAfterSeconds?: number;
+  constructor(reason: ApiKeyInvalidReason, retryAfterSeconds?: number);
+}
+/**
+ * Thrown when baliola-auth is unreachable — fetch rejection, 5xx, or
+ * unparseable body. Distinct from `ApiKeyInvalidError`, which covers
+ * structured rejections.
+ */
+declare class BaliolaAuthUnreachableError extends SmartAccountSDKError {
+  readonly url: string;
+  constructor(url: string, cause: unknown);
+}
+//#endregion
+//#region src/errors/aaError.d.ts
+interface RevertErrorOptions {
+  code: string;
+  detail?: string;
+  userOp?: unknown;
+  cause?: unknown;
+}
+/**
+ * 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.
+ */
+declare class UserOperationRevertError extends SmartAccountSDKError {
+  constructor(message: string, options: RevertErrorOptions);
+}
+/** AA1x — Smart Account factory / `initCode` deployment failures. */
+declare class AccountFactoryError extends UserOperationRevertError {}
+/** AA2x — account's `validateUserOp` rejection (prefund, signature, nonce). */
+declare class AccountValidationError extends UserOperationRevertError {}
+/** AA3x — Gas Allowance Pool's `validatePaymasterUserOp` rejection. */
+declare class PaymasterValidationError extends UserOperationRevertError {}
+/** AA9x — EntryPoint bundle-frame invariants. Rarely reached by app code. */
+declare class BundleFrameError extends UserOperationRevertError {}
+//#endregion
+//#region src/errors/bundlerError.d.ts
+interface BundlerErrorOptions {
+  code: string;
+  detail?: string;
+  userOp?: unknown;
+  cause?: unknown;
+}
+/** Base class for every error originating from the bundler's JSON-RPC surface. */
+declare class BundlerRpcError extends SmartAccountSDKError {
+  constructor(message: string, options: BundlerErrorOptions);
+}
+/** `-32602` — bundler rejected the params (invalid UserOp shape, fee too low, etc.). */
+declare class InvalidUserOperationError extends BundlerRpcError {}
+/** `-32500` and kin — bundler accepted the shape but dropped the op on submit. */
+declare class UserOperationRejectedError extends BundlerRpcError {}
+/** Network or transport failure reaching the bundler — not an on-chain rejection. */
+declare class BundlerUnreachableError extends BundlerRpcError {}
+//#endregion
+//#region src/errors/classifyBundlerError.d.ts
+/**
+ * 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`.
+ */
+declare function classifyBundlerError(err: unknown, userOp?: unknown): Error;
+//#endregion
+//#region src/errors/mapAaCode.d.ts
+interface AaCodeMatch {
+  /** The matched AA code (e.g. "AA24"). */
+  code: string;
+  /** The error subclass for the code's bucket, or the base for unknown codes. */
+  ctor: typeof UserOperationRevertError;
+}
+/**
+ * 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`.
+ */
+declare function mapAaCode(message: string): AaCodeMatch | null;
+//#endregion
+export { AaCodeMatch, AccountFactoryError, AccountValidationError, ApiKeyInvalidError, BaliolaAuthUnreachableError, BundleFrameError, BundlerErrorOptions, BundlerRpcError, BundlerUnreachableError, InvalidUserOperationError, PaymasterConfigError, PaymasterConfigReason, PaymasterValidationError, RevertErrorOptions, SmartAccountSDKError, UserOperationReceiptTimeoutError, UserOperationRejectedError, UserOperationRevertError, classifyBundlerError, mapAaCode };

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+import { a as UserOperationReceiptTimeoutError, i as SmartAccountSDKError, n as BaliolaAuthUnreachableError, r as PaymasterConfigError, t as ApiKeyInvalidError } from "../base-v7RyiDFz.js";
+import { a as BundleFrameError, c as BundlerRpcError, d as UserOperationRejectedError, i as AccountValidationError, l as BundlerUnreachableError, n as mapAaCode, o as PaymasterValidationError, r as AccountFactoryError, s as UserOperationRevertError, t as classifyBundlerError, u as InvalidUserOperationError } from "../classifyBundlerError-BqFLORNt.js";
+export { AccountFactoryError, AccountValidationError, ApiKeyInvalidError, BaliolaAuthUnreachableError, BundleFrameError, BundlerRpcError, BundlerUnreachableError, InvalidUserOperationError, PaymasterConfigError, PaymasterValidationError, SmartAccountSDKError, UserOperationReceiptTimeoutError, UserOperationRejectedError, UserOperationRevertError, classifyBundlerError, mapAaCode };

package/dist/index-BVqNo3O0.d.ts

@@ -0,0 +1,222 @@
+import * as _$viem from "viem";
+import { Chain } from "viem";
+
+//#region src/chains/index.d.ts
+declare const macTestnet: {
+  blockExplorers?: {
+    [key: string]: {
+      name: string;
+      url: string;
+      apiUrl?: string | undefined;
+    };
+    default: {
+      name: string;
+      url: string;
+      apiUrl?: string | undefined;
+    };
+  } | undefined | undefined;
+  blockTime?: number | undefined | undefined;
+  contracts?: {
+    [x: string]: _$viem.ChainContract | {
+      [sourceId: number]: _$viem.ChainContract | undefined;
+    } | undefined;
+    ensRegistry?: _$viem.ChainContract | undefined;
+    ensUniversalResolver?: _$viem.ChainContract | undefined;
+    multicall3?: _$viem.ChainContract | undefined;
+    erc6492Verifier?: _$viem.ChainContract | undefined;
+  } | undefined;
+  ensTlds?: readonly string[] | undefined;
+  id: 20017;
+  name: "MAC Testnet";
+  nativeCurrency: {
+    readonly name: "Kepeng Testnet";
+    readonly symbol: "KPGBT";
+    readonly decimals: 18;
+  };
+  experimental_preconfirmationTime?: number | undefined | undefined;
+  rpcUrls: {
+    readonly default: {
+      readonly http: readonly ["https://collator1.baliola.dev"];
+    };
+  };
+  sourceId?: number | undefined | undefined;
+  testnet: true;
+  custom?: Record<string, unknown> | undefined;
+  extendSchema?: Record<string, unknown> | undefined;
+  fees?: _$viem.ChainFees<undefined> | undefined;
+  formatters?: undefined;
+  prepareTransactionRequest?: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+    phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+  }) => Promise<_$viem.PrepareTransactionRequestParameters>) | [fn: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+    phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+  }) => Promise<_$viem.PrepareTransactionRequestParameters>) | undefined, options: {
+    runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+  }] | undefined;
+  serializers?: _$viem.ChainSerializers<undefined, _$viem.TransactionSerializable> | undefined;
+  verifyHash?: ((client: _$viem.Client, parameters: _$viem.VerifyHashActionParameters) => Promise<_$viem.VerifyHashActionReturnType>) | undefined;
+};
+declare const macMainnet: {
+  blockExplorers?: {
+    [key: string]: {
+      name: string;
+      url: string;
+      apiUrl?: string | undefined;
+    };
+    default: {
+      name: string;
+      url: string;
+      apiUrl?: string | undefined;
+    };
+  } | undefined | undefined;
+  blockTime?: number | undefined | undefined;
+  contracts?: {
+    [x: string]: _$viem.ChainContract | {
+      [sourceId: number]: _$viem.ChainContract | undefined;
+    } | undefined;
+    ensRegistry?: _$viem.ChainContract | undefined;
+    ensUniversalResolver?: _$viem.ChainContract | undefined;
+    multicall3?: _$viem.ChainContract | undefined;
+    erc6492Verifier?: _$viem.ChainContract | undefined;
+  } | undefined;
+  ensTlds?: readonly string[] | undefined;
+  id: 20016;
+  name: "MAC";
+  nativeCurrency: {
+    readonly name: "Kepeng";
+    readonly symbol: "KPGB";
+    readonly decimals: 18;
+  };
+  experimental_preconfirmationTime?: number | undefined | undefined;
+  rpcUrls: {
+    readonly default: {
+      readonly http: readonly ["https://collator4-mac.baliola.io"];
+    };
+  };
+  sourceId?: number | undefined | undefined;
+  testnet: false;
+  custom?: Record<string, unknown> | undefined;
+  extendSchema?: Record<string, unknown> | undefined;
+  fees?: _$viem.ChainFees<undefined> | undefined;
+  formatters?: undefined;
+  prepareTransactionRequest?: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+    phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+  }) => Promise<_$viem.PrepareTransactionRequestParameters>) | [fn: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+    phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+  }) => Promise<_$viem.PrepareTransactionRequestParameters>) | undefined, options: {
+    runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+  }] | undefined;
+  serializers?: _$viem.ChainSerializers<undefined, _$viem.TransactionSerializable> | undefined;
+  verifyHash?: ((client: _$viem.Client, parameters: _$viem.VerifyHashActionParameters) => Promise<_$viem.VerifyHashActionReturnType>) | undefined;
+};
+type MacChainName = "macTestnet" | "macMainnet";
+declare const MAC_CHAINS: {
+  readonly macTestnet: {
+    blockExplorers?: {
+      [key: string]: {
+        name: string;
+        url: string;
+        apiUrl?: string | undefined;
+      };
+      default: {
+        name: string;
+        url: string;
+        apiUrl?: string | undefined;
+      };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+      [x: string]: _$viem.ChainContract | {
+        [sourceId: number]: _$viem.ChainContract | undefined;
+      } | undefined;
+      ensRegistry?: _$viem.ChainContract | undefined;
+      ensUniversalResolver?: _$viem.ChainContract | undefined;
+      multicall3?: _$viem.ChainContract | undefined;
+      erc6492Verifier?: _$viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 20017;
+    name: "MAC Testnet";
+    nativeCurrency: {
+      readonly name: "Kepeng Testnet";
+      readonly symbol: "KPGBT";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://collator1.baliola.dev"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: _$viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<_$viem.PrepareTransactionRequestParameters>) | [fn: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<_$viem.PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: _$viem.ChainSerializers<undefined, _$viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: _$viem.Client, parameters: _$viem.VerifyHashActionParameters) => Promise<_$viem.VerifyHashActionReturnType>) | undefined;
+  };
+  readonly macMainnet: {
+    blockExplorers?: {
+      [key: string]: {
+        name: string;
+        url: string;
+        apiUrl?: string | undefined;
+      };
+      default: {
+        name: string;
+        url: string;
+        apiUrl?: string | undefined;
+      };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+      [x: string]: _$viem.ChainContract | {
+        [sourceId: number]: _$viem.ChainContract | undefined;
+      } | undefined;
+      ensRegistry?: _$viem.ChainContract | undefined;
+      ensUniversalResolver?: _$viem.ChainContract | undefined;
+      multicall3?: _$viem.ChainContract | undefined;
+      erc6492Verifier?: _$viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 20016;
+    name: "MAC";
+    nativeCurrency: {
+      readonly name: "Kepeng";
+      readonly symbol: "KPGB";
+      readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+      readonly default: {
+        readonly http: readonly ["https://collator4-mac.baliola.io"];
+      };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: _$viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<_$viem.PrepareTransactionRequestParameters>) | [fn: ((args: _$viem.PrepareTransactionRequestParameters, options: {
+      phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<_$viem.PrepareTransactionRequestParameters>) | undefined, options: {
+      runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: _$viem.ChainSerializers<undefined, _$viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: _$viem.Client, parameters: _$viem.VerifyHashActionParameters) => Promise<_$viem.VerifyHashActionReturnType>) | undefined;
+  };
+};
+declare function resolveChain(name: MacChainName): Chain;
+//#endregion
+export { resolveChain as a, macTestnet as i, MacChainName as n, macMainnet as r, MAC_CHAINS as t };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { n as ISmartAccount, r as SigningAccount, t as Call } from "./types-CD0TvpY4.js";
+import { a as resolveChain, i as macTestnet, n as MacChainName, r as macMainnet, t as MAC_CHAINS } from "./index-BVqNo3O0.js";
+import { ToSmartAccountParams, encodeCalls, toSmartAccount } from "./accounts/index.js";
+import { C as CreateBundlerClientParams, S as BundlerClient, _ 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, w as createBundlerClient, x as UserOperationGasEstimate, y as estimateUserOperationGas } from "./writeContract-CdcmYmx0.js";
+import { t as UserOperationReceipt } from "./receipt-Ceeclfnv.js";
+import { DRAFT_GAS_ANCHORS, DUMMY_SIGNATURE, buildDraftUserOp } from "./actions/index.js";
+import { n as ApiKeyInvalidReason, r as ApiKeyQuota, t as ApiKeyInfo } from "./types-BcsdeCby.js";
+import { DEFAULT_AUTH_URLS, ValidateApiKeyParams, resolveAuthUrl, validateApiKey } from "./auth/index.js";
+import { CreateSmartAccountClientParams, DEFAULT_BUNDLER_URLS, ResolveBundlerTransportParams, RpcUserOperation, SmartAccountClient, createSmartAccountClient, fromRpcUserOp, resolveBundlerTransport, toRpcUserOp } from "./clients/index.js";
+import { AaCodeMatch, AccountFactoryError, AccountValidationError, ApiKeyInvalidError, BaliolaAuthUnreachableError, BundleFrameError, BundlerErrorOptions, BundlerRpcError, BundlerUnreachableError, InvalidUserOperationError, PaymasterConfigError, PaymasterConfigReason, PaymasterValidationError, RevertErrorOptions, SmartAccountSDKError, UserOperationReceiptTimeoutError, UserOperationRejectedError, UserOperationRevertError, classifyBundlerError, mapAaCode } from "./errors/index.js";
+export { AaCodeMatch, AccountFactoryError, AccountValidationError, ApiKeyInfo, ApiKeyInvalidError, ApiKeyInvalidReason, ApiKeyQuota, BaliolaAuthUnreachableError, BoundWriteContract, BundleFrameError, BundlerClient, BundlerErrorOptions, BundlerRpcError, BundlerUnreachableError, Call, CreateBundlerClientParams, CreateSmartAccountClientParams, DEFAULT_AUTH_URLS, DEFAULT_BUNDLER_URLS, DRAFT_GAS_ANCHORS, DUMMY_SIGNATURE, EstimateUserOperationGasParams, GetUserOperationReceiptParams, ISmartAccount, InvalidUserOperationError, MAC_CHAINS, MacChainName, PaymasterConfigError, PaymasterConfigReason, PaymasterValidationError, RawCall, ResolveBundlerTransportParams, RevertErrorOptions, RpcUserOperation, SigningAccount, SmartAccountActionContext, SmartAccountClient, SmartAccountSDKError, ToSmartAccountParams, TypedCall, UnwatchFn, UserOperationEventMatch, UserOperationGasEstimate, UserOperationReceipt, UserOperationReceiptTimeoutError, UserOperationRejectedError, UserOperationRevertError, ValidateApiKeyParams, WaitForUserOperationReceiptParams, WatchUserOperationsParams, WriteContractInput, WriteContractOverrides, bindWriteContract, buildDraftUserOp, classifyBundlerError, createBundlerClient, createSmartAccountClient, encodeCalls, estimateUserOpGasRaw, estimateUserOperationGas, fromRpcUserOp, getUserOperationReceipt, macMainnet, macTestnet, mapAaCode, resolveAuthUrl, resolveBundlerTransport, resolveChain, sliceUserOpLogs, toRpcUserOp, toSmartAccount, validateApiKey, waitForUserOperationReceipt, watchUserOperations, writeContract };

package/dist/index.js

@@ -0,0 +1,12 @@
+import { n as encodeCalls, t as toSmartAccount } from "./accounts-Bw0IrOJ1.js";
+import { MAC_CHAINS, macMainnet, macTestnet, resolveChain } from "./chains/index.js";
+import { a as getUserOperationReceipt, c as estimateUserOperationGas, d as DRAFT_GAS_ANCHORS, f as DUMMY_SIGNATURE, i as waitForUserOperationReceipt, l as fromRpcUserOp, n as writeContract, o as sliceUserOpLogs, p as buildDraftUserOp, r as watchUserOperations, s as estimateUserOpGasRaw, t as bindWriteContract, u as toRpcUserOp } from "./writeContract-AyQox2dQ.js";
+import { a as UserOperationReceiptTimeoutError, i as SmartAccountSDKError, n as BaliolaAuthUnreachableError, r as PaymasterConfigError, t as ApiKeyInvalidError } from "./base-v7RyiDFz.js";
+import "./actions/index.js";
+import { n as DEFAULT_AUTH_URLS, r as resolveAuthUrl, t as validateApiKey } from "./validateApiKey-lUfEM5W0.js";
+import "./auth/index.js";
+import { i as resolveBundlerTransport, n as createBundlerClient, r as DEFAULT_BUNDLER_URLS, t as createSmartAccountClient } from "./clients-B17dl_fh.js";
+import { a as BundleFrameError, c as BundlerRpcError, d as UserOperationRejectedError, i as AccountValidationError, l as BundlerUnreachableError, n as mapAaCode, o as PaymasterValidationError, r as AccountFactoryError, s as UserOperationRevertError, t as classifyBundlerError, u as InvalidUserOperationError } from "./classifyBundlerError-BqFLORNt.js";
+import "./errors/index.js";
+import "./types/index.js";
+export { AccountFactoryError, AccountValidationError, ApiKeyInvalidError, BaliolaAuthUnreachableError, BundleFrameError, BundlerRpcError, BundlerUnreachableError, DEFAULT_AUTH_URLS, DEFAULT_BUNDLER_URLS, DRAFT_GAS_ANCHORS, DUMMY_SIGNATURE, InvalidUserOperationError, MAC_CHAINS, PaymasterConfigError, PaymasterValidationError, SmartAccountSDKError, UserOperationReceiptTimeoutError, UserOperationRejectedError, UserOperationRevertError, bindWriteContract, buildDraftUserOp, classifyBundlerError, createBundlerClient, createSmartAccountClient, encodeCalls, estimateUserOpGasRaw, estimateUserOperationGas, fromRpcUserOp, getUserOperationReceipt, macMainnet, macTestnet, mapAaCode, resolveAuthUrl, resolveBundlerTransport, resolveChain, sliceUserOpLogs, toRpcUserOp, toSmartAccount, validateApiKey, waitForUserOperationReceipt, watchUserOperations, writeContract };

package/dist/receipt-Ceeclfnv.d.ts

@@ -0,0 +1,24 @@
+import { Address, Hex, Log } from "viem";
+
+//#region src/types/receipt.d.ts
+/**
+ * Result of `waitForUserOperationReceipt` / `getUserOperationReceipt`.
+ * Carries both hashes — the ERC-4337 `userOpHash` and the on-chain
+ * `handleOps` `txHash` — and logs pre-sliced to this UserOp only.
+ */
+interface UserOperationReceipt {
+  userOpHash: Hex;
+  sender: Address;
+  nonce: bigint;
+  paymaster?: Address;
+  success: boolean;
+  reason?: string;
+  actualGasUsed: bigint;
+  actualGasCost: bigint;
+  txHash: Hex;
+  blockNumber: bigint;
+  blockHash: Hex;
+  logs: Log[];
+}
+//#endregion
+export { UserOperationReceipt as t };

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { t as UserOperationReceipt } from "../receipt-Ceeclfnv.js";
+export { UserOperationReceipt };

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};