@sequence0/sdk 1.0.2 → 1.1.0

package/dist/erc4337/account.js

@@ -0,0 +1,810 @@
+"use strict";
+/**
+ * ERC-4337 Account Abstraction — Sequence0Account
+ *
+ * A smart account backed by FROST threshold signing. Enables gas-sponsored
+ * transactions, batch calls, and programmable transaction validation --
+ * all secured by the decentralized Sequence0 signing network.
+ *
+ * The account uses a Schnorr signature verifier on-chain: the FROST group
+ * public key is the account's "owner", and every UserOperation is signed
+ * by t-of-n agents producing a BIP-340 Schnorr signature.
+ *
+ * @example
+ * ```typescript
+ * import { Sequence0Account } from '@sequence0/sdk';
+ *
+ * // Create a new AA wallet backed by FROST
+ * const account = await Sequence0Account.create({
+ *   threshold: 16,
+ *   committeeSize: 24,
+ *   chain: 'ethereum',
+ *   ownerPrivateKey: '0x...',
+ * });
+ *
+ * // Get the counterfactual address (before deployment)
+ * console.log('Address:', account.getAddress());
+ *
+ * // Send a transaction via UserOperation
+ * const txHash = await account.sendTransaction({
+ *   to: '0xRecipient...',
+ *   value: BigInt('1000000000000000000'), // 1 ETH
+ * });
+ *
+ * // Batch multiple calls
+ * const txHash2 = await account.sendBatchTransaction([
+ *   { to: '0xTokenA', data: '0xa9059cbb...' },
+ *   { to: '0xTokenB', data: '0xa9059cbb...' },
+ * ]);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequence0Account = void 0;
+const client_1 = require("../core/client");
+const errors_1 = require("../utils/errors");
+const ethers_1 = require("ethers");
+const types_1 = require("./types");
+// ── Constants ──
+/** Function selector: execute(address dest, uint256 value, bytes func) */
+const EXECUTE_SELECTOR = '0xb61d27f6';
+/** Function selector: executeBatch(address[] dest, uint256[] value, bytes[] func) */
+const EXECUTE_BATCH_SELECTOR = '0x34fcd5be';
+/** Function selector: createAccount(bytes groupPublicKey) */
+const CREATE_ACCOUNT_SELECTOR_HASH = 'createAccount(bytes)';
+/** Function selector: getNonce(address sender, uint192 key) on EntryPoint */
+const GET_NONCE_SELECTOR = '0x35567e1a';
+// ── Account Class ──
+class Sequence0Account {
+    constructor(params) {
+        /** Whether the account has been deployed on-chain */
+        this.deployed = false;
+        this.accountAddress = params.accountAddress;
+        this.groupPublicKey = params.groupPublicKey;
+        this.walletId = params.walletId;
+        this.s0 = params.s0;
+        this.chain = params.chain;
+        this.chainId = params.chainId;
+        this.entryPoint = params.entryPoint;
+        this.factory = params.factory;
+        this.provider = params.provider;
+        this.bundlerUrl = params.bundlerUrl;
+        this.deployed = params.deployed;
+    }
+    // ────────────────────────────────────────────────
+    //  Static Factory
+    // ────────────────────────────────────────────────
+    /**
+     * Create a new ERC-4337 smart account backed by FROST threshold signing.
+     *
+     * This performs a DKG ceremony to create a new FROST wallet, then
+     * derives the counterfactual smart account address using CREATE2.
+     * The account is not deployed on-chain until the first UserOperation
+     * is sent (initCode handles deployment).
+     *
+     * @param options - Account creation options
+     * @returns A new Sequence0Account instance
+     *
+     * @example
+     * ```typescript
+     * const account = await Sequence0Account.create({
+     *   threshold: 16,
+     *   committeeSize: 24,
+     *   chain: 'ethereum',
+     *   ownerPrivateKey: '0x...',
+     * });
+     * ```
+     */
+    static async create(options) {
+        const network = options.network || 'mainnet';
+        const chain = options.chain || 'ethereum';
+        const chainId = types_1.CHAIN_IDS[chain];
+        if (!chainId) {
+            throw new errors_1.ChainError(`Unsupported chain for ERC-4337: '${chain}'. ` +
+                `Supported chains: ${Object.keys(types_1.CHAIN_IDS).join(', ')}`, chain);
+        }
+        const entryPoint = options.entryPoint || types_1.ENTRYPOINT_V07_ADDRESS;
+        const factory = options.factory || types_1.FACTORY_ADDRESSES[network] || types_1.FACTORY_ADDRESSES.mainnet;
+        const bundlerUrl = options.bundlerUrl || types_1.DEFAULT_BUNDLER_URLS[chain] || '';
+        if (!bundlerUrl) {
+            throw new errors_1.Sequence0Error(`No default bundler URL for chain '${chain}'. ` +
+                'Provide a bundlerUrl in options.');
+        }
+        // Initialize the Sequence0 SDK
+        const s0 = new client_1.Sequence0({
+            network,
+            agentUrl: options.agentUrl,
+            ownerPrivateKey: options.ownerPrivateKey,
+        });
+        // Create a FROST wallet via DKG ceremony
+        const wallet = await s0.createWallet({
+            chain: chain,
+            threshold: { t: options.threshold, n: options.committeeSize },
+            curve: 'secp256k1',
+        });
+        const groupPublicKey = wallet.address; // The FROST group verifying key (hex)
+        const walletId = wallet.walletId;
+        // Compute the counterfactual smart account address
+        const accountAddress = computeCounterfactualAddress(factory, groupPublicKey, entryPoint);
+        // Set up RPC provider
+        const rpcUrl = options.rpcUrl || getDefaultRpcUrl(chain);
+        const provider = new ethers_1.JsonRpcProvider(rpcUrl);
+        // Check if already deployed
+        const code = await provider.getCode(accountAddress);
+        const deployed = code !== '0x' && code !== '0x0';
+        return new Sequence0Account({
+            accountAddress,
+            groupPublicKey,
+            walletId,
+            s0,
+            chain,
+            chainId,
+            entryPoint,
+            factory,
+            provider,
+            bundlerUrl,
+            deployed,
+        });
+    }
+    /**
+     * Reconnect to an existing Sequence0 AA wallet by its wallet ID and group public key.
+     *
+     * Use this when you have previously created an account and want to
+     * reconnect without running DKG again.
+     *
+     * @param walletId - The Sequence0 wallet ID
+     * @param groupPublicKey - The FROST group public key (hex)
+     * @param options - Account options (chain, network, etc.)
+     * @returns A Sequence0Account instance
+     */
+    static async fromExisting(walletId, groupPublicKey, options) {
+        const network = options.network || 'mainnet';
+        const chain = options.chain || 'ethereum';
+        const chainId = types_1.CHAIN_IDS[chain];
+        if (!chainId) {
+            throw new errors_1.ChainError(`Unsupported chain: '${chain}'`, chain);
+        }
+        const entryPoint = options.entryPoint || types_1.ENTRYPOINT_V07_ADDRESS;
+        const factory = options.factory || types_1.FACTORY_ADDRESSES[network] || types_1.FACTORY_ADDRESSES.mainnet;
+        const bundlerUrl = options.bundlerUrl || types_1.DEFAULT_BUNDLER_URLS[chain] || '';
+        const s0 = new client_1.Sequence0({
+            network,
+            agentUrl: options.agentUrl,
+            ownerPrivateKey: options.ownerPrivateKey,
+        });
+        const accountAddress = computeCounterfactualAddress(factory, groupPublicKey, entryPoint);
+        const rpcUrl = options.rpcUrl || getDefaultRpcUrl(chain);
+        const provider = new ethers_1.JsonRpcProvider(rpcUrl);
+        const code = await provider.getCode(accountAddress);
+        const deployed = code !== '0x' && code !== '0x0';
+        return new Sequence0Account({
+            accountAddress,
+            groupPublicKey,
+            walletId,
+            s0,
+            chain,
+            chainId,
+            entryPoint,
+            factory,
+            provider,
+            bundlerUrl,
+            deployed,
+        });
+    }
+    // ────────────────────────────────────────────────
+    //  Getters
+    // ────────────────────────────────────────────────
+    /**
+     * Get the smart account address (counterfactual or deployed).
+     *
+     * This address is deterministic: it is derived from the FROST group
+     * public key and the factory address via CREATE2. It is known before
+     * the account is deployed on-chain.
+     */
+    getAddress() {
+        return this.accountAddress;
+    }
+    /** Get the FROST wallet ID */
+    getWalletId() {
+        return this.walletId;
+    }
+    /** Get the FROST group public key */
+    getGroupPublicKey() {
+        return this.groupPublicKey;
+    }
+    /** Get the target chain name */
+    getChain() {
+        return this.chain;
+    }
+    /** Get the target chain ID */
+    getChainId() {
+        return this.chainId;
+    }
+    /** Check if the account has been deployed on-chain */
+    isDeployed() {
+        return this.deployed;
+    }
+    // ────────────────────────────────────────────────
+    //  Send Transactions
+    // ────────────────────────────────────────────────
+    /**
+     * Build, sign, and submit a single transaction as a UserOperation.
+     *
+     * If the account is not yet deployed, the initCode is automatically
+     * included to deploy it in the same transaction.
+     *
+     * @param tx - Transaction to execute
+     * @returns Transaction hash from the bundler
+     *
+     * @example
+     * ```typescript
+     * const txHash = await account.sendTransaction({
+     *   to: '0xRecipient',
+     *   value: BigInt('1000000000000000000'), // 1 ETH
+     * });
+     * ```
+     */
+    async sendTransaction(tx) {
+        const callData = encodeExecute(tx);
+        return this.buildSignAndSubmit(callData);
+    }
+    /**
+     * Build, sign, and submit multiple calls as a single batched UserOperation.
+     *
+     * All calls are executed atomically in a single transaction.
+     * If any call reverts, the entire batch reverts.
+     *
+     * @param txs - Array of transactions to batch
+     * @returns Transaction hash from the bundler
+     *
+     * @example
+     * ```typescript
+     * const txHash = await account.sendBatchTransaction([
+     *   { to: '0xTokenA', data: '0xa9059cbb...' }, // ERC-20 transfer
+     *   { to: '0xTokenB', data: '0xa9059cbb...' }, // Another transfer
+     * ]);
+     * ```
+     */
+    async sendBatchTransaction(txs) {
+        if (txs.length === 0) {
+            throw new errors_1.Sequence0Error('Cannot send empty batch transaction');
+        }
+        if (txs.length === 1) {
+            return this.sendTransaction(txs[0]);
+        }
+        const callData = encodeExecuteBatch(txs);
+        return this.buildSignAndSubmit(callData);
+    }
+    // ────────────────────────────────────────────────
+    //  Message Signing
+    // ────────────────────────────────────────────────
+    /**
+     * Sign an arbitrary message using the FROST threshold signing network.
+     *
+     * The message is hashed with EIP-191 prefix before signing.
+     * The resulting signature is a 64-byte Schnorr signature.
+     *
+     * @param message - Message to sign (string or bytes)
+     * @returns Hex-encoded Schnorr signature
+     *
+     * @example
+     * ```typescript
+     * const sig = await account.signMessage('Hello from Sequence0 AA!');
+     * ```
+     */
+    async signMessage(message) {
+        const msgBytes = typeof message === 'string'
+            ? new TextEncoder().encode(message)
+            : message;
+        // EIP-191 prefix
+        const prefix = `\x19Ethereum Signed Message:\n${msgBytes.length}`;
+        const prefixed = new Uint8Array([
+            ...new TextEncoder().encode(prefix),
+            ...msgBytes,
+        ]);
+        // keccak256 hash
+        const hash = (0, ethers_1.keccak256)(prefixed);
+        const hashHex = hash.startsWith('0x') ? hash.slice(2) : hash;
+        // Sign via FROST
+        return this.s0.signAndWait(this.walletId, hashHex);
+    }
+    // ────────────────────────────────────────────────
+    //  UserOperation Building
+    // ────────────────────────────────────────────────
+    /**
+     * Build a UserOperation without signing or submitting.
+     *
+     * Useful for gas estimation or inspection before submission.
+     *
+     * @param callData - Encoded call data for the account
+     * @returns A PackedUserOperation (without signature)
+     */
+    async buildUserOp(callData) {
+        // Get nonce from EntryPoint
+        const nonce = await this.getNonce();
+        // Get fee data from the chain
+        const feeData = await this.provider.getFeeData();
+        const maxFeePerGas = feeData.maxFeePerGas || 30000000000n;
+        const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas || 1500000000n;
+        // Build init code if not deployed
+        let initCode = '0x';
+        if (!this.deployed) {
+            initCode = this.computeInitCode();
+        }
+        // Default gas limits (will be refined by bundler estimation)
+        const callGasLimit = 200000n;
+        const verificationGasLimit = this.deployed ? 100000n : 500000n; // Higher for deployment
+        const preVerificationGas = 50000n;
+        // Pack gas fields into bytes32
+        const accountGasLimits = packGasLimits(verificationGasLimit, callGasLimit);
+        const gasFees = packGasFees(maxPriorityFeePerGas, maxFeePerGas);
+        return {
+            sender: this.accountAddress,
+            nonce: '0x' + nonce.toString(16),
+            initCode,
+            callData,
+            accountGasLimits,
+            preVerificationGas: '0x' + preVerificationGas.toString(16),
+            gasFees,
+            paymasterAndData: '0x',
+            signature: '0x',
+        };
+    }
+    /**
+     * Submit a pre-built and signed UserOperation to a bundler.
+     *
+     * @param userOp - The signed UserOperation
+     * @param bundlerUrl - Optional bundler URL override
+     * @returns UserOperation hash from the bundler
+     */
+    async submitUserOp(userOp, bundlerUrl) {
+        const url = bundlerUrl || this.bundlerUrl;
+        if (!url) {
+            throw new errors_1.Sequence0Error('No bundler URL configured');
+        }
+        const response = await bundlerRpc(url, 'eth_sendUserOperation', [
+            userOpToRpc(userOp),
+            this.entryPoint,
+        ]);
+        // Mark as deployed after first successful submission
+        if (!this.deployed && userOp.initCode !== '0x') {
+            this.deployed = true;
+        }
+        return response;
+    }
+    /**
+     * Estimate gas for a UserOperation via the bundler.
+     *
+     * @param userOp - The UserOperation to estimate
+     * @param bundlerUrl - Optional bundler URL override
+     * @returns Gas estimates
+     */
+    async estimateUserOpGas(userOp, bundlerUrl) {
+        const url = bundlerUrl || this.bundlerUrl;
+        if (!url) {
+            throw new errors_1.Sequence0Error('No bundler URL configured');
+        }
+        return bundlerRpc(url, 'eth_estimateUserOperationGas', [userOpToRpc(userOp), this.entryPoint]);
+    }
+    /**
+     * Get the receipt for a submitted UserOperation.
+     *
+     * @param userOpHash - The UserOperation hash from submitUserOp
+     * @param bundlerUrl - Optional bundler URL override
+     * @returns Receipt if the UserOp has been included, null otherwise
+     */
+    async getUserOpReceipt(userOpHash, bundlerUrl) {
+        const url = bundlerUrl || this.bundlerUrl;
+        if (!url) {
+            throw new errors_1.Sequence0Error('No bundler URL configured');
+        }
+        try {
+            return await bundlerRpc(url, 'eth_getUserOperationReceipt', [userOpHash]);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Wait for a UserOperation to be included on-chain.
+     *
+     * Polls the bundler for the receipt until it appears or timeout.
+     *
+     * @param userOpHash - The UserOperation hash
+     * @param timeoutMs - Timeout in milliseconds (default: 60000)
+     * @param pollIntervalMs - Poll interval (default: 2000)
+     * @returns The UserOperation receipt
+     */
+    async waitForUserOp(userOpHash, timeoutMs = 60000, pollIntervalMs = 2000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const receipt = await this.getUserOpReceipt(userOpHash);
+            if (receipt) {
+                return receipt;
+            }
+            await sleep(pollIntervalMs);
+        }
+        throw new errors_1.Sequence0Error(`UserOperation ${userOpHash} was not included within ${timeoutMs}ms`);
+    }
+    // ────────────────────────────────────────────────
+    //  Balance & Info
+    // ────────────────────────────────────────────────
+    /**
+     * Get the native token balance of the smart account.
+     *
+     * @returns Balance in wei as a string
+     */
+    async getBalance() {
+        const balance = await this.provider.getBalance(this.accountAddress);
+        return balance.toString();
+    }
+    /**
+     * Get account information summary.
+     */
+    info() {
+        return {
+            address: this.accountAddress,
+            walletId: this.walletId,
+            groupPublicKey: this.groupPublicKey,
+            chain: this.chain,
+            chainId: this.chainId,
+            entryPoint: this.entryPoint,
+            factory: this.factory,
+            deployed: this.deployed,
+        };
+    }
+    /**
+     * Clean up resources.
+     */
+    destroy() {
+        this.s0.destroy();
+    }
+    // ────────────────────────────────────────────────
+    //  Internal
+    // ────────────────────────────────────────────────
+    /**
+     * Build, sign, and submit a UserOperation.
+     */
+    async buildSignAndSubmit(callData) {
+        // Build the unsigned UserOperation
+        const userOp = await this.buildUserOp(callData);
+        // Estimate gas via bundler (optional, improves success rate)
+        try {
+            const gasEstimate = await this.estimateUserOpGas(userOp);
+            if (gasEstimate.callGasLimit) {
+                const callGas = BigInt(gasEstimate.callGasLimit);
+                const verifyGas = BigInt(gasEstimate.verificationGasLimit);
+                userOp.accountGasLimits = packGasLimits(verifyGas, callGas);
+            }
+            if (gasEstimate.preVerificationGas) {
+                userOp.preVerificationGas = gasEstimate.preVerificationGas;
+            }
+        }
+        catch {
+            // Use default gas estimates if bundler estimation fails
+        }
+        // Compute the UserOperation hash
+        const userOpHash = computeUserOpHash(userOp, this.entryPoint, this.chainId);
+        // Sign the hash via FROST
+        const hashHex = userOpHash.startsWith('0x') ? userOpHash.slice(2) : userOpHash;
+        const signature = await this.s0.signAndWait(this.walletId, hashHex);
+        // Encode the FROST signature for on-chain verification
+        userOp.signature = encodeSchnorrSignature(signature);
+        // Submit to bundler
+        return this.submitUserOp(userOp);
+    }
+    /**
+     * Get the current nonce from the EntryPoint contract.
+     */
+    async getNonce() {
+        try {
+            // eth_call to EntryPoint.getNonce(sender, key)
+            // key = 0 for the default nonce sequence
+            const senderPadded = this.accountAddress.slice(2).toLowerCase().padStart(64, '0');
+            const keyPadded = '0'.padStart(64, '0');
+            const calldata = GET_NONCE_SELECTOR + senderPadded + keyPadded;
+            const result = await this.provider.call({
+                to: this.entryPoint,
+                data: calldata,
+            });
+            if (!result || result === '0x')
+                return 0n;
+            return BigInt(result);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    /**
+     * Compute the initCode for first-time account deployment.
+     *
+     * initCode = factoryAddress (20 bytes) + createAccount(groupPublicKey) calldata
+     */
+    computeInitCode() {
+        const pubkeyHex = this.groupPublicKey.startsWith('0x')
+            ? this.groupPublicKey.slice(2)
+            : this.groupPublicKey;
+        // Compute function selector
+        const selectorBytes = (0, ethers_1.keccak256)(new TextEncoder().encode(CREATE_ACCOUNT_SELECTOR_HASH));
+        const selector = selectorBytes.slice(0, 10); // 0x + 4 bytes
+        // ABI-encode: offset(32) + length(32) + padded_data
+        const pubkeyBytes = hexToBytes(pubkeyHex);
+        const paddedLen = Math.ceil(pubkeyBytes.length / 32) * 32;
+        const offsetHex = '0000000000000000000000000000000000000000000000000000000000000020';
+        const lengthHex = pubkeyBytes.length.toString(16).padStart(64, '0');
+        const dataHex = pubkeyHex.padEnd(paddedLen * 2, '0');
+        const factoryHex = this.factory.startsWith('0x')
+            ? this.factory.slice(2)
+            : this.factory;
+        return '0x' + factoryHex + selector.slice(2) + offsetHex + lengthHex + dataHex;
+    }
+}
+exports.Sequence0Account = Sequence0Account;
+// ────────────────────────────────────────────────
+//  Pure Utility Functions
+// ────────────────────────────────────────────────
+/**
+ * Compute the counterfactual smart account address using CREATE2.
+ *
+ * address = keccak256(0xff + factory + salt + keccak256(initCode))[12:]
+ *
+ * The salt is derived from the group public key.
+ */
+function computeCounterfactualAddress(factory, groupPublicKey, _entryPoint) {
+    // The salt is the keccak256 of the group public key
+    const pubkeyHex = groupPublicKey.startsWith('0x')
+        ? groupPublicKey.slice(2)
+        : groupPublicKey;
+    const salt = (0, ethers_1.keccak256)(hexToBytes(pubkeyHex));
+    // For counterfactual address computation, we use a simplified approach:
+    // The actual address depends on the factory's CREATE2 implementation.
+    // This computes: keccak256(0xff || factory || salt || initCodeHash)
+    // where initCodeHash would be the hash of the account's creation code.
+    //
+    // In practice, the factory contract pre-computes this for us.
+    // For now, we use a deterministic derivation from the factory + pubkey.
+    const factoryHex = factory.startsWith('0x') ? factory.slice(2) : factory;
+    const saltHex = salt.startsWith('0x') ? salt.slice(2) : salt;
+    // Prefix: 0xff
+    const payload = '0xff' + factoryHex + saltHex;
+    const hash = (0, ethers_1.keccak256)(hexToBytes(payload));
+    // Take last 20 bytes
+    const addressHex = hash.startsWith('0x') ? hash.slice(26) : hash.slice(24);
+    return '0x' + addressHex;
+}
+/**
+ * Compute the ERC-4337 userOpHash.
+ *
+ * userOpHash = keccak256(
+ *   keccak256(pack(userOp)),
+ *   entryPoint,
+ *   chainId
+ * )
+ */
+function computeUserOpHash(userOp, entryPoint, chainId) {
+    // Step 1: Hash dynamic fields
+    const initCodeHash = (0, ethers_1.keccak256)(hexToBytes(userOp.initCode || '0x'));
+    const callDataHash = (0, ethers_1.keccak256)(hexToBytes(userOp.callData || '0x'));
+    const paymasterHash = (0, ethers_1.keccak256)(hexToBytes(userOp.paymasterAndData || '0x'));
+    // Step 2: Pack the UserOp fields
+    const senderPadded = userOp.sender.slice(2).toLowerCase().padStart(64, '0');
+    const noncePadded = padHex(userOp.nonce, 64);
+    const initCodeHashHex = initCodeHash.startsWith('0x') ? initCodeHash.slice(2) : initCodeHash;
+    const callDataHashHex = callDataHash.startsWith('0x') ? callDataHash.slice(2) : callDataHash;
+    const accountGasHex = padHex(userOp.accountGasLimits, 64);
+    const preVerGasHex = padHex(userOp.preVerificationGas, 64);
+    const gasFeesHex = padHex(userOp.gasFees, 64);
+    const paymasterHashHex = paymasterHash.startsWith('0x') ? paymasterHash.slice(2) : paymasterHash;
+    const packed = senderPadded +
+        noncePadded +
+        initCodeHashHex +
+        callDataHashHex +
+        accountGasHex +
+        preVerGasHex +
+        gasFeesHex +
+        paymasterHashHex;
+    const packedHash = (0, ethers_1.keccak256)(hexToBytes('0x' + packed));
+    // Step 3: Final hash
+    const entryPointPadded = entryPoint.slice(2).toLowerCase().padStart(64, '0');
+    const chainIdHex = chainId.toString(16).padStart(64, '0');
+    const packedHashHex = packedHash.startsWith('0x') ? packedHash.slice(2) : packedHash;
+    const finalInput = packedHashHex + entryPointPadded + chainIdHex;
+    return (0, ethers_1.keccak256)(hexToBytes('0x' + finalInput));
+}
+/**
+ * Encode a FROST Schnorr signature for on-chain verification.
+ *
+ * The FROST aggregate signature is serialized as JSON containing the
+ * R point and z scalar. We extract R_x (32 bytes) and z (32 bytes)
+ * for the on-chain Schnorr verifier.
+ *
+ * If the signature is already a raw 64-byte hex string, it is used as-is.
+ */
+function encodeSchnorrSignature(signatureHex) {
+    const sig = signatureHex.startsWith('0x') ? signatureHex.slice(2) : signatureHex;
+    // If already 64 bytes (128 hex chars), it's a raw Schnorr signature
+    if (sig.length === 128) {
+        return '0x' + sig;
+    }
+    // Try to parse as JSON (serialized FROST signature)
+    try {
+        const bytes = hexToBytes(sig);
+        const text = new TextDecoder().decode(bytes);
+        const parsed = JSON.parse(text);
+        // Extract R_x and z from the FROST signature structure
+        if (parsed.R && parsed.z) {
+            const rHex = parsed.R.startsWith('0x') ? parsed.R.slice(2) : parsed.R;
+            const zHex = parsed.z.startsWith('0x') ? parsed.z.slice(2) : parsed.z;
+            // R might be a compressed point (33 bytes) -- take x coordinate
+            const rBytes = rHex.length === 66 ? rHex.slice(2) : rHex;
+            return '0x' + rBytes.padStart(64, '0') + zHex.padStart(64, '0');
+        }
+    }
+    catch {
+        // Not JSON, try other formats
+    }
+    // If 65 bytes (130 hex chars), might be ECDSA-style R+S+V -- take first 64 bytes
+    if (sig.length === 130) {
+        return '0x' + sig.slice(0, 128);
+    }
+    // Return as-is with 0x prefix
+    return '0x' + sig;
+}
+/**
+ * Encode a single execute() call for the smart account.
+ *
+ * execute(address dest, uint256 value, bytes func)
+ */
+function encodeExecute(tx) {
+    const dest = tx.to.slice(2).toLowerCase().padStart(64, '0');
+    const value = (tx.value ? BigInt(tx.value) : 0n).toString(16).padStart(64, '0');
+    const funcData = tx.data
+        ? (tx.data.startsWith('0x') ? tx.data.slice(2) : tx.data)
+        : '';
+    // Dynamic bytes: offset + length + padded data
+    const offset = (3 * 32).toString(16).padStart(64, '0'); // 3 words = 96 bytes
+    const funcLen = (funcData.length / 2).toString(16).padStart(64, '0');
+    const paddedFunc = funcData.padEnd(Math.ceil(funcData.length / 64) * 64, '0');
+    return EXECUTE_SELECTOR + dest + value + offset + funcLen + paddedFunc;
+}
+/**
+ * Encode a batch executeBatch() call for the smart account.
+ *
+ * executeBatch(address[] dest, uint256[] values, bytes[] func)
+ */
+function encodeExecuteBatch(txs) {
+    const count = txs.length;
+    // We need to ABI-encode three dynamic arrays: address[], uint256[], bytes[]
+    // Layout: selector + offset_dest + offset_values + offset_func + data...
+    // Compute offsets (each is 32 bytes from the start of the params)
+    const headerWords = 3; // 3 offset words
+    const destArrayWords = 1 + count; // length + count addresses
+    const valuesArrayWords = 1 + count; // length + count uint256s
+    const destOffset = headerWords * 32;
+    const valuesOffset = destOffset + destArrayWords * 32;
+    const funcOffset = valuesOffset + valuesArrayWords * 32;
+    let result = EXECUTE_BATCH_SELECTOR;
+    // Offsets
+    result += destOffset.toString(16).padStart(64, '0');
+    result += valuesOffset.toString(16).padStart(64, '0');
+    result += funcOffset.toString(16).padStart(64, '0');
+    // address[] dest
+    result += count.toString(16).padStart(64, '0');
+    for (const tx of txs) {
+        result += tx.to.slice(2).toLowerCase().padStart(64, '0');
+    }
+    // uint256[] values
+    result += count.toString(16).padStart(64, '0');
+    for (const tx of txs) {
+        const val = tx.value ? BigInt(tx.value) : 0n;
+        result += val.toString(16).padStart(64, '0');
+    }
+    // bytes[] func
+    result += count.toString(16).padStart(64, '0');
+    // Compute offsets for each bytes element (relative to array data start)
+    const funcDataParts = [];
+    let currentOffset = count * 32; // skip the offset words
+    for (const tx of txs) {
+        result += currentOffset.toString(16).padStart(64, '0');
+        const data = tx.data
+            ? (tx.data.startsWith('0x') ? tx.data.slice(2) : tx.data)
+            : '';
+        const paddedData = data.padEnd(Math.ceil(Math.max(data.length, 1) / 64) * 64, '0');
+        const dataWords = 1 + paddedData.length / 64; // length word + padded data
+        currentOffset += dataWords * 32;
+        funcDataParts.push(data);
+    }
+    // Encode each bytes element
+    for (const data of funcDataParts) {
+        const dataLen = data.length / 2;
+        result += dataLen.toString(16).padStart(64, '0');
+        if (data.length > 0) {
+            result += data.padEnd(Math.ceil(data.length / 64) * 64, '0');
+        }
+    }
+    return result;
+}
+/** Convert a UserOperation to the RPC format expected by bundlers */
+function userOpToRpc(userOp) {
+    return {
+        sender: userOp.sender,
+        nonce: userOp.nonce,
+        initCode: userOp.initCode || '0x',
+        callData: userOp.callData,
+        accountGasLimits: userOp.accountGasLimits,
+        preVerificationGas: userOp.preVerificationGas,
+        gasFees: userOp.gasFees,
+        paymasterAndData: userOp.paymasterAndData || '0x',
+        signature: userOp.signature,
+    };
+}
+/** Make a JSON-RPC call to a bundler */
+async function bundlerRpc(url, method, params) {
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            method,
+            params,
+            id: Date.now(),
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new errors_1.Sequence0Error(`Bundler request failed: HTTP ${response.status} - ${text}`);
+    }
+    const json = await response.json();
+    if (json.error) {
+        throw new errors_1.Sequence0Error(`Bundler error: ${json.error.message} (code: ${json.error.code})`);
+    }
+    return json.result;
+}
+/** Pack gas limits into bytes32: verificationGasLimit (16 bytes) || callGasLimit (16 bytes) */
+function packGasLimits(verificationGasLimit, callGasLimit) {
+    const verify = verificationGasLimit.toString(16).padStart(32, '0');
+    const call = callGasLimit.toString(16).padStart(32, '0');
+    return '0x' + verify + call;
+}
+/** Pack gas fees into bytes32: maxPriorityFeePerGas (16 bytes) || maxFeePerGas (16 bytes) */
+function packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
+    const priority = maxPriorityFeePerGas.toString(16).padStart(32, '0');
+    const max = maxFeePerGas.toString(16).padStart(32, '0');
+    return '0x' + priority + max;
+}
+/** Pad a hex string to a given length (removing 0x prefix) */
+function padHex(hex, length) {
+    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+    return clean.padStart(length, '0');
+}
+/** Hex string to Uint8Array */
+function hexToBytes(hex) {
+    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (clean.length === 0)
+        return new Uint8Array(0);
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+/** Get default RPC URL for a chain */
+function getDefaultRpcUrl(chain) {
+    const urls = {
+        ethereum: 'https://eth.llamarpc.com',
+        polygon: 'https://polygon-rpc.com',
+        bsc: 'https://bsc-dataseed.binance.org',
+        avalanche: 'https://api.avax.network/ext/bc/C/rpc',
+        arbitrum: 'https://arb1.arbitrum.io/rpc',
+        optimism: 'https://mainnet.optimism.io',
+        base: 'https://mainnet.base.org',
+        scroll: 'https://rpc.scroll.io',
+        linea: 'https://rpc.linea.build',
+        mantle: 'https://rpc.mantle.xyz',
+        blast: 'https://rpc.blast.io',
+    };
+    return urls[chain] || urls.ethereum;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=account.js.map