@deserialize/multi-vm-wallet 1.2.441 → 1.3.0

package/dist/evm/index.js

@@ -16,4 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./evm"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./smartWallet"), exports);
+// Note: AA service types are re-exported through smartWallet.types.ts
+// Direct AA service exports would cause duplicate export errors
 //# sourceMappingURL=index.js.map

package/dist/evm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../utils/evm/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAqB;AACrB,0CAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../utils/evm/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAqB;AACrB,0CAAuB;AACvB,gDAA6B;AAE7B,sEAAsE;AACtE,gEAAgE"}

package/dist/evm/smartWallet.d.ts

@@ -0,0 +1,265 @@
+/**
+ * EVM Smart Wallet Implementation
+ *
+ * Provides Account Abstraction (EIP-4337) and EIP-7702 capabilities to EVMChainWallet.
+ * This class wraps the AA service and provides a clean API for smart wallet features.
+ */
+import { Chain, Hex } from "viem";
+import { Balance } from "../types";
+import { SmartWalletOptions, SmartWalletTransactionResult, Call, SessionKeyInfo, SessionKeyPermissionRule, SessionKeyApprovalOptions, SessionKeyUsageOptions, ModuleInstallOptions, ModuleUninstallOptions, MultiSigConfig, SmartAccountInfo, ModuleType } from "./smartWallet.types";
+/**
+ * EVMSmartWallet - Smart wallet capabilities for EVM chains
+ *
+ * Provides:
+ * - EIP-7702 account delegation
+ * - Batch transactions (pay gas once for multiple operations)
+ * - Session keys with granular permissions
+ * - Module management (validators, hooks, executors)
+ * - Gas sponsorship (paymasters)
+ * - Multi-signature support
+ * - Account recovery
+ */
+export declare class EVMSmartWallet {
+    private aaService;
+    private kernelAccount;
+    private ownerAccount;
+    private chain;
+    private options;
+    private sessionAccount;
+    private paymasterConfig;
+    private bundlerUrl;
+    constructor(privateKey: string, chain: Chain, bundlerUrl: string, options?: SmartWalletOptions);
+    /**
+     * Initialize the smart wallet
+     * Creates the Kernel account and sets up delegation if needed
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the smart account address
+     */
+    getAddress(): Hex;
+    /**
+     * Get smart account information
+     */
+    getAccountInfo(): Promise<SmartAccountInfo>;
+    /**
+     * Get smart account balance
+     */
+    getBalance(): Promise<Balance>;
+    /**
+     * Check if account is delegated
+     */
+    isAccountDelegated(): Promise<boolean>;
+    /**
+     * Send a single transaction via UserOperation
+     *
+     * @param to - Recipient address
+     * @param value - ETH value in wei
+     * @param data - Optional calldata
+     * @returns Transaction result with UserOp hash
+     *
+     * @example
+     * await smartWallet.sendTransaction(
+     *   '0xRecipient',
+     *   parseEther('0.1'),
+     *   '0x'
+     * );
+     */
+    sendTransaction(to: Hex, value?: bigint, data?: Hex): Promise<SmartWalletTransactionResult>;
+    /**
+     * Send multiple transactions in a single UserOperation
+     * This is one of the main advantages of smart accounts - pay gas ONLY ONCE!
+     *
+     * @param calls - Array of calls to execute
+     * @returns Transaction result
+     *
+     * @example
+     * await smartWallet.sendBatchTransaction([
+     *   { to: recipient1, value: parseEther('0.1'), data: '0x' },
+     *   { to: recipient2, value: parseEther('0.2'), data: '0x' },
+     *   { to: usdcAddress, value: 0n, data: transferCalldata }
+     * ]);
+     */
+    sendBatchTransaction(calls: Call[]): Promise<SmartWalletTransactionResult>;
+    /**
+     * Prepare a call for batching
+     * Helper method to create Call objects
+     */
+    prepareCall(to: Hex, value?: bigint, data?: Hex): Call;
+    /**
+     * Generate a new session key
+     * The private key should be stored securely by the agent
+     *
+     * @returns Session key info with private key, address, and signer
+     *
+     * @example
+     * const sessionKey = await smartWallet.generateSessionKey();
+     * console.log('Address:', sessionKey.address);
+     * // Store sessionKey.privateKey securely
+     */
+    generateSessionKey(): Promise<SessionKeyInfo>;
+    /**
+     * Recreate session key from stored private key
+     *
+     * @param privateKey - Session key private key
+     * @returns Session key info
+     *
+     * @example
+     * const sessionKey = await smartWallet.recreateSessionKey(storedPrivateKey);
+     */
+    recreateSessionKey(privateKey: Hex): Promise<SessionKeyInfo>;
+    /**
+     * Create session key approval (Owner side)
+     * Owner approves a session key with specific permissions
+     *
+     * @param options - Approval options with session key address and permissions
+     * @returns Serialized approval string to share with agent
+     *
+     * @example
+     * const approval = await smartWallet.approveSessionKey({
+     *   sessionKeyAddress: '0x...',
+     *   permissions: [
+     *     smartWallet.createUSDCPermission(USDC_ADDRESS, '100')
+     *   ]
+     * });
+     */
+    approveSessionKey(options: SessionKeyApprovalOptions): Promise<string>;
+    /**
+     * Use session key for transactions (Agent side)
+     * Agent deserializes the approval and can send transactions with session key
+     *
+     * @param options - Session key usage options with approval and signer
+     *
+     * @example
+     * const sessionKey = await smartWallet.recreateSessionKey(privateKey);
+     * await smartWallet.useSessionKey({
+     *   approval,
+     *   sessionKeySigner: sessionKey.signer
+     * });
+     * // Now can send transactions with session key permissions
+     */
+    useSessionKey(options: SessionKeyUsageOptions): Promise<void>;
+    /**
+     * Clear session key (revert to owner account)
+     */
+    clearSessionKey(): void;
+    /**
+     * Check if using session key
+     */
+    isUsingSessionKey(): boolean;
+    /**
+     * Create USDC transfer permission
+     *
+     * @param usdcAddress - USDC contract address
+     * @param maxAmount - Maximum USDC amount (in USDC units, e.g., "10" for 10 USDC)
+     * @returns Permission rule
+     */
+    createUSDCPermission(usdcAddress: Hex, maxAmount: string): SessionKeyPermissionRule;
+    /**
+     * Create ETH transfer permission
+     *
+     * @param maxValue - Maximum ETH value (in ether units, e.g., "0.1" for 0.1 ETH)
+     * @returns Permission rule
+     */
+    createETHPermission(maxValue: string): SessionKeyPermissionRule;
+    /**
+     * Install a module on the smart account
+     *
+     * @param options - Module installation options
+     * @returns Transaction result
+     *
+     * @example
+     * await smartWallet.installModule({
+     *   moduleType: 'validator',
+     *   moduleAddress: '0x...',
+     *   initData: '0x...'
+     * });
+     */
+    installModule(options: ModuleInstallOptions): Promise<SmartWalletTransactionResult>;
+    /**
+     * Uninstall a module from the smart account
+     *
+     * @param options - Module uninstallation options
+     * @returns Transaction result
+     */
+    uninstallModule(options: ModuleUninstallOptions): Promise<SmartWalletTransactionResult>;
+    /**
+     * Check if a module is installed
+     *
+     * @param moduleType - Type of module
+     * @param moduleAddress - Module contract address
+     * @returns Whether the module is installed
+     */
+    isModuleInstalled(moduleType: ModuleType, moduleAddress: Hex): Promise<boolean>;
+    /**
+     * Prepare module installation call (for batching)
+     *
+     * @param options - Module installation options
+     * @returns Call object for batch transaction
+     */
+    prepareInstallModule(options: ModuleInstallOptions): Call;
+    /**
+     * Prepare module uninstallation call (for batching)
+     *
+     * @param options - Module uninstallation options
+     * @returns Call object for batch transaction
+     */
+    prepareUninstallModule(options: ModuleUninstallOptions): Call;
+    /**
+     * Enable multi-signature validation
+     *
+     * @param config - Multi-sig configuration with owners and threshold
+     * @returns Transaction result
+     *
+     * @example
+     * await smartWallet.enableMultiSig({
+     *   owners: [owner1, owner2, owner3],
+     *   threshold: 2 // 2 of 3 required
+     * });
+     */
+    enableMultiSig(config: MultiSigConfig): Promise<SmartWalletTransactionResult>;
+    /**
+     * Set paymaster for gas sponsorship
+     *
+     * @param paymasterUrl - Paymaster service URL
+     *
+     * @example
+     * smartWallet.setPaymaster('https://api.pimlico.io/v2/sepolia/paymaster');
+     */
+    setPaymaster(paymasterUrl: string, context?: any): void;
+    /**
+     * Clear paymaster (user pays gas)
+     */
+    clearPaymaster(): void;
+    /**
+     * Check if paymaster is configured
+     */
+    hasPaymaster(): boolean;
+    /**
+     * Get bundler information
+     */
+    getBundlerInfo(): {
+        provider: string;
+        url: string;
+    };
+    /**
+     * Send sponsored batch transaction where another wallet pays gas fees
+     * Requires smart wallet to be initialized
+     *
+     * @param calls - Array of calls to execute
+     * @param feePayerPrivateKey - Private key of the wallet paying gas fees
+     * @returns Transaction result with userOpHash and transactionHash
+     *
+     * @example
+     * // Send ETH transfer with sponsor paying gas
+     * const result = await smartWallet.sendSponsoredBatchTransaction(
+     *   [{ to: recipient, value: parseEther('0.1') }],
+     *   sponsorPrivateKey
+     * );
+     */
+    sendSponsoredBatchTransaction(calls: Call[], feePayerPrivateKey: Hex): Promise<SmartWalletTransactionResult>;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+}