@baliola/smart-account-sdk 0.3.1

package/dist/types-BcsdeCby.d.ts

@@ -0,0 +1,25 @@
+//#region src/auth/types.d.ts
+/** Rejection reasons returned by baliola-auth `/api/api-keys/validate` when `valid: false`. */
+type ApiKeyInvalidReason = "not_found" | "revoked" | "expired" | "wrong_module" | "module_inactive" | "origin_not_allowed" | "quota_exceeded" | "rate_limited";
+interface ApiKeyQuota {
+  limitType: "periodic" | "lifetime";
+  period: "day" | "month" | "year";
+  /** Per-period (or lifetime) limit. `null` when uncapped. */
+  callLimit: number | null;
+  /** Remaining calls in the current period (or total). `null` when uncapped. */
+  callsRemaining: number | null;
+  /** ISO 8601 timestamp when the current period resets. */
+  periodResetsAt: string;
+}
+/** Validated key info — what the SDK exposes on `client.apiKey` after construction. */
+interface ApiKeyInfo {
+  /** UUID of the API key record itself. */
+  id: string;
+  /** UUID of the baliola account that owns this key. */
+  accountId: string;
+  /** Module slug the key is minted against (always `"smart-account"` for this SDK). */
+  module: string;
+  quota: ApiKeyQuota;
+}
+//#endregion
+export { ApiKeyInvalidReason as n, ApiKeyQuota as r, ApiKeyInfo as t };

package/dist/types-CD0TvpY4.d.ts

@@ -0,0 +1,60 @@
+import { Account, Address, Hex, PublicClient } from "viem";
+
+//#region ../shared/src/user-op/types.d.ts
+/**
+ * IUserOperation in the "unpacked" JSON-RPC wire form (ERC-4337 v0.7).
+ * This is what clients submit via eth_sendUserOperation.
+ */
+interface IUserOperation {
+  sender: Address;
+  nonce: bigint;
+  factory?: Address;
+  factoryData?: Hex;
+  callData: Hex;
+  callGasLimit: bigint;
+  verificationGasLimit: bigint;
+  preVerificationGas: bigint;
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+  paymaster?: Address;
+  paymasterVerificationGasLimit?: bigint;
+  paymasterPostOpGasLimit?: bigint;
+  paymasterData?: Hex;
+  signature: Hex;
+}
+//#endregion
+//#region src/accounts/types.d.ts
+/**
+ * Raw call tuple — identical to viem's `sendTransaction` input.
+ * `value` defaults to `0n` when omitted. `data` defaults to `"0x"`.
+ */
+type Call = {
+  to: Address;
+  value?: bigint;
+  data?: Hex;
+};
+/** Viem `Account` narrowed to require `signMessage` (EIP-191 signing). */
+type SigningAccount = Account & {
+  signMessage: NonNullable<Account["signMessage"]>;
+};
+/**
+ * A Smart Account instance bundles the counterfactual `sender` address,
+ * the first-use `factory` + `factoryData`, and the EIP-191 signing closure
+ * over `userOpHash`.
+ */
+interface ISmartAccount {
+  readonly address: Address;
+  readonly owner: SigningAccount;
+  readonly factory: Address;
+  readonly factoryData: Hex;
+  readonly entryPoint: Address;
+  readonly nonceKey: bigint;
+  readonly chainId: number;
+  isDeployed(publicClient: PublicClient): Promise<boolean>;
+  markDeployed(): void;
+  signUserOperation(op: IUserOperation): Promise<Hex>;
+  encodeCalls(calls: Call[]): Hex;
+  getNonce(publicClient: PublicClient): Promise<bigint>;
+}
+//#endregion
+export { IUserOperation as i, ISmartAccount as n, SigningAccount as r, Call as t };

package/dist/validateApiKey-lUfEM5W0.js

@@ -0,0 +1,68 @@
+import { n as BaliolaAuthUnreachableError, t as ApiKeyInvalidError } from "./base-v7RyiDFz.js";
+//#region src/auth/authUrls.ts
+/**
+* Default baliola-auth base URLs per MAC chain. The SDK appends
+* `/api/api-keys/validate` to whatever URL is configured.
+*/
+const DEFAULT_AUTH_URLS = {
+	macTestnet: "https://baliola-auth.baliola.dev",
+	macMainnet: "https://auth.baliola.io"
+};
+/**
+* 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.
+*/
+function resolveAuthUrl(chainName, override) {
+	return (override ?? DEFAULT_AUTH_URLS[chainName]).replace(/\/+$/, "");
+}
+//#endregion
+//#region src/auth/validateApiKey.ts
+const SDK_SERVICE_LABEL = "smart-account-sdk";
+const MODULE = "smart-account";
+/**
+* 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.
+*/
+async function validateApiKey(params) {
+	const url = `${params.authUrl}/api/api-keys/validate`;
+	let res;
+	try {
+		res = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${params.apiKey}`
+			},
+			body: JSON.stringify({
+				requiredModule: MODULE,
+				service: SDK_SERVICE_LABEL
+			})
+		});
+	} catch (cause) {
+		throw new BaliolaAuthUnreachableError(url, cause);
+	}
+	if (res.status === 401) throw new ApiKeyInvalidError("not_found");
+	if (!res.ok) throw new BaliolaAuthUnreachableError(url, /* @__PURE__ */ new Error(`HTTP ${res.status}`));
+	let body;
+	try {
+		body = await res.json();
+	} catch (cause) {
+		throw new BaliolaAuthUnreachableError(url, cause);
+	}
+	const data = body.data;
+	if (!data.valid) throw new ApiKeyInvalidError(data.reason, data.retryAfterSeconds);
+	return {
+		id: data.apiKeyId,
+		accountId: data.accountId,
+		module: data.module,
+		quota: data.quota
+	};
+}
+//#endregion
+export { DEFAULT_AUTH_URLS as n, resolveAuthUrl as r, validateApiKey as t };

package/dist/writeContract-AyQox2dQ.js

@@ -0,0 +1,371 @@
+import { t as entryPointAbi } from "./abi-ziHt832n.js";
+import { a as UserOperationReceiptTimeoutError } from "./base-v7RyiDFz.js";
+import { decodeEventLog, defineChain, encodeFunctionData, getAbiItem, hexToBigInt, numberToHex, toEventSelector } from "viem";
+import "viem/accounts";
+//#region src/actions/buildDraft.ts
+/**
+* Draft gas anchors. MAC's Substrate Frontier EVM runs the bundler's
+* `eth_estimateUserOperationGas` path through `EntryPointSimulations` via
+* `eth_call`, and the simulation fails if the packed `accountGasLimits` are
+* zero. Seeding the draft with generous values lets the simulation complete
+* and come back with precise estimates that replace these on submit.
+*
+* Values mirror `bundler/scripts/demo-userop.ts`, which has validated
+* against live MAC Testnet end-to-end.
+*/
+const DRAFT_CALL_GAS_LIMIT = 200000n;
+const DRAFT_VERIFICATION_GAS_LIMIT = 900000n;
+const DRAFT_PRE_VERIFICATION_GAS = 150000n;
+const DRAFT_GAS_ANCHORS = {
+	callGasLimit: DRAFT_CALL_GAS_LIMIT,
+	verificationGasLimit: DRAFT_VERIFICATION_GAS_LIMIT,
+	preVerificationGas: DRAFT_PRE_VERIFICATION_GAS,
+	paymasterVerificationGasLimit: 200000n,
+	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.
+*/
+const DUMMY_SIGNATURE = "0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000011b";
+/**
+* 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).
+*/
+async function buildDraftUserOp(ctx, calls, overrides = {}) {
+	const callData = overrides.callData ?? ctx.account.encodeCalls(calls);
+	const [nonce, deployed] = await Promise.all([overrides.nonce !== void 0 ? Promise.resolve(overrides.nonce) : ctx.account.getNonce(ctx.publicClient), ctx.account.isDeployed(ctx.publicClient)]);
+	const needsFactory = overrides.factory === void 0 ? !deployed : true;
+	const factory = overrides.factory ?? (needsFactory ? ctx.account.factory : void 0);
+	const factoryData = factory ? overrides.factoryData ?? ctx.account.factoryData : void 0;
+	const gasPrice = overrides.maxFeePerGas ?? overrides.maxPriorityFeePerGas ?? await ctx.publicClient.getGasPrice();
+	const draft = {
+		sender: ctx.account.address,
+		nonce,
+		callData,
+		callGasLimit: overrides.callGasLimit ?? DRAFT_CALL_GAS_LIMIT,
+		verificationGasLimit: overrides.verificationGasLimit ?? DRAFT_VERIFICATION_GAS_LIMIT,
+		preVerificationGas: overrides.preVerificationGas ?? DRAFT_PRE_VERIFICATION_GAS,
+		maxFeePerGas: overrides.maxFeePerGas ?? gasPrice,
+		maxPriorityFeePerGas: overrides.maxPriorityFeePerGas ?? gasPrice,
+		signature: overrides.signature ?? "0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000011b"
+	};
+	if (factory) {
+		draft.factory = factory;
+		draft.factoryData = factoryData ?? "0x";
+	}
+	return draft;
+}
+//#endregion
+//#region src/clients/rpcCodec.ts
+function toRpcUserOp(op) {
+	const rpc = {
+		sender: op.sender,
+		nonce: numberToHex(op.nonce),
+		callData: op.callData,
+		callGasLimit: numberToHex(op.callGasLimit),
+		verificationGasLimit: numberToHex(op.verificationGasLimit),
+		preVerificationGas: numberToHex(op.preVerificationGas),
+		maxFeePerGas: numberToHex(op.maxFeePerGas),
+		maxPriorityFeePerGas: numberToHex(op.maxPriorityFeePerGas),
+		signature: op.signature
+	};
+	if (op.factory) {
+		rpc.factory = op.factory;
+		rpc.factoryData = op.factoryData ?? "0x";
+	}
+	if (op.paymaster) {
+		rpc.paymaster = op.paymaster;
+		rpc.paymasterVerificationGasLimit = numberToHex(op.paymasterVerificationGasLimit ?? 0n);
+		rpc.paymasterPostOpGasLimit = numberToHex(op.paymasterPostOpGasLimit ?? 0n);
+		rpc.paymasterData = op.paymasterData ?? "0x";
+	}
+	return rpc;
+}
+function fromRpcUserOp(rpc) {
+	const op = {
+		sender: rpc.sender,
+		nonce: hexToBigInt(rpc.nonce),
+		callData: rpc.callData,
+		callGasLimit: hexToBigInt(rpc.callGasLimit),
+		verificationGasLimit: hexToBigInt(rpc.verificationGasLimit),
+		preVerificationGas: hexToBigInt(rpc.preVerificationGas),
+		maxFeePerGas: hexToBigInt(rpc.maxFeePerGas),
+		maxPriorityFeePerGas: hexToBigInt(rpc.maxPriorityFeePerGas),
+		signature: rpc.signature
+	};
+	if (rpc.factory) {
+		op.factory = rpc.factory;
+		op.factoryData = rpc.factoryData ?? "0x";
+	}
+	if (rpc.paymaster) {
+		op.paymaster = rpc.paymaster;
+		op.paymasterVerificationGasLimit = hexToBigInt(rpc.paymasterVerificationGasLimit ?? "0x0");
+		op.paymasterPostOpGasLimit = hexToBigInt(rpc.paymasterPostOpGasLimit ?? "0x0");
+		op.paymasterData = rpc.paymasterData ?? "0x";
+	}
+	return op;
+}
+//#endregion
+//#region src/actions/estimateUserOperationGas.ts
+/**
+* Low-level estimate that skips paymaster resolution — callers that want
+* the full `{ calls, overrides }` surface should use the higher-level
+* `estimateUserOperationGas` action below.
+*/
+async function estimateUserOpGasRaw(ctx, op) {
+	const rpc = toRpcUserOp(op);
+	const raw = await ctx.bundler.request("eth_estimateUserOperationGas", [rpc, ctx.entryPoint]);
+	const estimate = {
+		callGasLimit: hexToBigInt(raw.callGasLimit),
+		verificationGasLimit: hexToBigInt(raw.verificationGasLimit),
+		preVerificationGas: hexToBigInt(raw.preVerificationGas)
+	};
+	if (raw.paymasterVerificationGasLimit !== void 0) estimate.paymasterVerificationGasLimit = hexToBigInt(raw.paymasterVerificationGasLimit);
+	if (raw.paymasterPostOpGasLimit !== void 0) estimate.paymasterPostOpGasLimit = hexToBigInt(raw.paymasterPostOpGasLimit);
+	return estimate;
+}
+async function estimateUserOperationGas(ctx, params) {
+	const draft = await buildDraftUserOp(ctx, params.calls, params.overrides);
+	return estimateUserOpGasRaw(ctx, params.paymasterFields ? {
+		...draft,
+		...params.paymasterFields
+	} : draft);
+}
+defineChain({
+	id: 20017,
+	name: "MAC Testnet",
+	nativeCurrency: {
+		name: "Kepeng Testnet",
+		symbol: "KPGBT",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://collator1.baliola.dev"] } },
+	testnet: true
+});
+defineChain({
+	id: 20016,
+	name: "MAC",
+	nativeCurrency: {
+		name: "Kepeng",
+		symbol: "KPGB",
+		decimals: 18
+	},
+	rpcUrls: { default: { http: ["https://collator4-mac.baliola.io"] } },
+	testnet: false
+});
+getAbiItem({
+	abi: entryPointAbi,
+	name: "UserOperationEvent"
+});
+/**
+* Slice receipt logs for one userop's execution frame: all logs between the
+* BeforeExecution marker (or the prior UserOperationEvent) and this op's
+* UserOperationEvent.
+*/
+function sliceUserOpLogs(receiptLogs, userOpHash) {
+	const beforeExecutionTopic = toEventSelector("BeforeExecution()");
+	const userOpEventTopic = toEventSelector("UserOperationEvent(bytes32,address,address,uint256,bool,uint256,uint256)");
+	let startIdx = -1;
+	for (let i = 0; i < receiptLogs.length; i++) {
+		const log = receiptLogs[i];
+		if (!log) continue;
+		if (log.topics[0] === beforeExecutionTopic) {
+			startIdx = i;
+			continue;
+		}
+		if (log.topics[0] === userOpEventTopic) {
+			if (log.topics[1] === userOpHash) return receiptLogs.slice(startIdx + 1, i);
+			startIdx = i;
+		}
+	}
+	return [];
+}
+//#endregion
+//#region src/actions/getUserOperationReceipt.ts
+async function getUserOperationReceipt(ctx, { userOpHash }) {
+	const raw = await ctx.bundler.request("eth_getUserOperationReceipt", [userOpHash]);
+	if (!raw) return null;
+	return decodeReceipt(raw, userOpHash);
+}
+function decodeReceipt(raw, userOpHash) {
+	const tx = raw.receipt;
+	const bundleLogs = tx.logs ?? [];
+	const preSliced = raw.logs ?? [];
+	const logs = preSliced.length > 0 ? preSliced : sliceUserOpLogs(bundleLogs, userOpHash);
+	const receipt = {
+		userOpHash: raw.userOpHash,
+		sender: raw.sender,
+		nonce: hexToBigInt(raw.nonce),
+		success: raw.success,
+		actualGasUsed: hexToBigInt(raw.actualGasUsed),
+		actualGasCost: hexToBigInt(raw.actualGasCost),
+		txHash: tx.transactionHash,
+		blockNumber: typeof tx.blockNumber === "bigint" ? tx.blockNumber : hexToBigInt(tx.blockNumber),
+		blockHash: tx.blockHash,
+		logs
+	};
+	if (raw.paymaster) receipt.paymaster = raw.paymaster;
+	if (raw.reason) receipt.reason = raw.reason;
+	return receipt;
+}
+//#endregion
+//#region src/actions/waitForUserOperationReceipt.ts
+const DEFAULT_TIMEOUT_MS = 6e4;
+const DEFAULT_POLL_MS = 1e3;
+async function waitForUserOperationReceipt(ctx, params) {
+	const timeout = params.timeout ?? DEFAULT_TIMEOUT_MS;
+	const pollingInterval = params.pollingInterval ?? DEFAULT_POLL_MS;
+	const deadline = Date.now() + timeout;
+	while (true) {
+		if (params.signal?.aborted) throw params.signal.reason ?? /* @__PURE__ */ new Error("aborted");
+		const receipt = await getUserOperationReceipt(ctx, { userOpHash: params.userOpHash });
+		if (receipt) return receipt;
+		if (Date.now() >= deadline) throw new UserOperationReceiptTimeoutError(params.userOpHash, timeout);
+		await sleep(pollingInterval, params.signal);
+	}
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason ?? /* @__PURE__ */ new Error("aborted"));
+		};
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/actions/watchUserOperations.ts
+const userOperationEventAbiItem = getAbiItem({
+	abi: entryPointAbi,
+	name: "UserOperationEvent"
+});
+function watchUserOperations(ctx, params) {
+	const sender = params.sender ?? (params.userOpHash ? void 0 : ctx.account.address);
+	const args = {};
+	if (sender) args.sender = sender;
+	if (params.userOpHash) args.userOpHash = params.userOpHash;
+	return ctx.publicClient.watchEvent({
+		address: ctx.entryPoint,
+		event: userOperationEventAbiItem,
+		args,
+		onLogs(logs) {
+			for (const log of logs) try {
+				const match = decodeMatch(log);
+				params.onUserOp(match);
+			} catch (err) {
+				params.onError?.(err);
+			}
+		},
+		...params.onError ? { onError: params.onError } : {}
+	});
+}
+function decodeMatch(log) {
+	const args = decodeEventLog({
+		abi: entryPointAbi,
+		eventName: "UserOperationEvent",
+		data: log.data,
+		topics: log.topics
+	}).args;
+	return {
+		userOpHash: args.userOpHash,
+		sender: args.sender,
+		paymaster: args.paymaster,
+		nonce: args.nonce,
+		success: args.success,
+		actualGasCost: args.actualGasCost,
+		actualGasUsed: args.actualGasUsed,
+		log
+	};
+}
+//#endregion
+//#region src/actions/sendUserOperation.ts
+/**
+* Internal engine: build draft → resolve paymaster → estimate gas → sign → submit.
+* Public callers use `writeContract`; this stays internal so we own the lifecycle.
+*/
+async function sendUserOperation(ctx, { calls, overrides }) {
+	const draft = await buildDraftUserOp(ctx, calls, overrides);
+	const paymasterFields = overrides?.paymasterFields ?? await ctx.paymaster({
+		userOp: draft,
+		entryPoint: ctx.entryPoint,
+		chainId: ctx.account.chainId
+	});
+	const withPaymaster = {
+		...draft,
+		...paymasterFields,
+		paymasterVerificationGasLimit: paymasterFields.paymasterVerificationGasLimit ?? DRAFT_GAS_ANCHORS.paymasterVerificationGasLimit,
+		paymasterPostOpGasLimit: paymasterFields.paymasterPostOpGasLimit ?? DRAFT_GAS_ANCHORS.paymasterPostOpGasLimit
+	};
+	const estimate = await estimateUserOpGasRaw(ctx, withPaymaster);
+	const final = {
+		...withPaymaster,
+		callGasLimit: overrides?.callGasLimit ?? estimate.callGasLimit,
+		verificationGasLimit: overrides?.verificationGasLimit ?? estimate.verificationGasLimit,
+		preVerificationGas: overrides?.preVerificationGas ?? estimate.preVerificationGas,
+		paymasterVerificationGasLimit: overrides?.paymasterVerificationGasLimit ?? paymasterFields.paymasterVerificationGasLimit ?? estimate.paymasterVerificationGasLimit ?? DRAFT_GAS_ANCHORS.paymasterVerificationGasLimit,
+		paymasterPostOpGasLimit: overrides?.paymasterPostOpGasLimit ?? paymasterFields.paymasterPostOpGasLimit ?? estimate.paymasterPostOpGasLimit ?? DRAFT_GAS_ANCHORS.paymasterPostOpGasLimit
+	};
+	final.signature = await ctx.account.signUserOperation(final);
+	return ctx.bundler.request("eth_sendUserOperation", [toRpcUserOp(final), ctx.entryPoint]);
+}
+//#endregion
+//#region src/actions/writeContract.ts
+function isTypedCall(entry) {
+	return "abi" in entry;
+}
+function normalizeEntry(entry) {
+	if (isTypedCall(entry)) {
+		const data = encodeFunctionData({
+			abi: entry.abi,
+			functionName: entry.functionName,
+			args: entry.args
+		});
+		return entry.value !== void 0 ? {
+			to: entry.address,
+			value: entry.value,
+			data
+		} : {
+			to: entry.address,
+			data
+		};
+	}
+	return entry;
+}
+async function writeContractImpl(ctx, input, overrides) {
+	const entries = Array.isArray(input) ? input : [input];
+	if (entries.length === 0) throw new Error("writeContract: input array must not be empty");
+	return sendUserOperation(ctx, {
+		calls: entries.map(normalizeEntry),
+		overrides
+	});
+}
+function writeContract(ctx, input, overrides) {
+	return writeContractImpl(ctx, input, overrides);
+}
+/** Build a context-bound `writeContract` for use on `SmartAccountClient`. */
+function bindWriteContract(ctx) {
+	function bound(input, overrides) {
+		return writeContractImpl(ctx, input, overrides);
+	}
+	return bound;
+}
+//#endregion
+export { getUserOperationReceipt as a, estimateUserOperationGas as c, DRAFT_GAS_ANCHORS as d, DUMMY_SIGNATURE as f, waitForUserOperationReceipt as i, fromRpcUserOp as l, writeContract as n, sliceUserOpLogs as o, buildDraftUserOp as p, watchUserOperations as r, estimateUserOpGasRaw as s, bindWriteContract as t, toRpcUserOp as u };