shogun-core 6.2.3 → 6.3.0

package/dist/src/plugins/smartwallet/smartWalletPlugin.js

@@ -0,0 +1,824 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { BasePlugin } from "../base.js";
+import { ethers } from "ethers";
+// Smart Wallet ABIs
+var SMART_WALLET_FACTORY_ABI = [
+    "function createWallet(address owner, uint256 requiredSignatures, uint256 requiredGuardians) external returns (address wallet)",
+    "function createWalletWithGuardians(address owner, address[] memory guardians, uint256 requiredSignatures, uint256 requiredGuardians) external returns (address wallet)",
+    "function getOwnerWallets(address owner) external view returns (address[] memory)",
+    "event WalletCreated(address indexed wallet, address indexed owner, uint256 indexed walletIndex)",
+];
+var SMART_WALLET_ABI = [
+    // Signer management
+    "function addSigner(address signer) external",
+    "function removeSigner(address signer) external",
+    "function setRequiredSignatures(uint256 requiredSignatures) external",
+    "function signers(address) external view returns (bool)",
+    "function requiredSignatures() external view returns (uint256)",
+    "function owner() external view returns (address)",
+    // Guardian management
+    "function addGuardian(address guardian) external",
+    "function removeGuardian(address guardian) external",
+    "function setRequiredGuardians(uint256 requiredGuardians) external",
+    "function guardians(address) external view returns (bool)",
+    "function requiredGuardians() external view returns (uint256)",
+    // Execution
+    "function execute(address target, bytes calldata data, uint256 value) external returns (bool success, bytes memory returnData)",
+    "function executeBatch(address[] memory targets, bytes[] memory data, uint256[] memory values) external returns (bool[] memory results)",
+    // Multi-sig
+    "function proposeExecution(address target, bytes calldata data) external returns (uint256 proposalId)",
+    "function approveProposal(uint256 proposalId) external",
+    "function getProposal(uint256 proposalId) external view returns (address target, bytes memory data, address proposer, uint256 approvals, bool executed)",
+    "function hasApprovedProposal(uint256 proposalId, address signer) external view returns (bool)",
+    // Recovery
+    "function initiateRecovery(address newOwner) external",
+    "function approveRecovery() external",
+    "function executeRecovery() external",
+    "function getRecoveryRequest() external view returns (address newOwner, uint256 unlockTime, uint256 approvals)",
+    "function hasApprovedRecovery(address guardian) external view returns (bool)",
+    "event SignerAdded(address indexed signer)",
+    "event GuardianAdded(address indexed guardian)",
+    "event ExecutionExecuted(uint256 indexed proposalId, bool success)",
+    "event RecoveryExecuted(address indexed newOwner)",
+];
+/**
+ * Smart Wallet Plugin for Shogun Core
+ * Provides integration with Smart Wallet contracts for account abstraction
+ */
+var SmartWalletPlugin = /** @class */ (function (_super) {
+    __extends(SmartWalletPlugin, _super);
+    function SmartWalletPlugin(config) {
+        if (config === void 0) { config = {}; }
+        var _this = _super.call(this) || this;
+        _this.name = "smartwallet";
+        _this.version = "1.0.0";
+        _this.description = "Smart Wallet integration for Shogun Core with multi-sig and social recovery";
+        _this.factoryContract = null;
+        _this.signer = null;
+        _this.config = __assign({ enabled: true, defaultRequiredSignatures: 1, defaultRequiredGuardians: 2 }, config);
+        return _this;
+    }
+    /**
+     * Initialize the plugin
+     */
+    SmartWalletPlugin.prototype.initialize = function (core) {
+        _super.prototype.initialize.call(this, core);
+        if (!this.config.enabled) {
+            console.log("[SmartWallet] Plugin disabled");
+            return;
+        }
+        try {
+            // Initialize provider and signer
+            this.initProvider();
+            // Initialize factory contract if address is provided
+            if (this.config.factoryAddress) {
+                this.initFactoryContract();
+            }
+            console.log("[SmartWallet] Plugin initialized successfully");
+        }
+        catch (error) {
+            console.error("[SmartWallet] Initialization failed:", error.message);
+        }
+    };
+    /**
+     * Destroy the plugin and cleanup resources
+     */
+    SmartWalletPlugin.prototype.destroy = function () {
+        this.factoryContract = null;
+        this.signer = null;
+        _super.prototype.destroy.call(this);
+        console.log("[SmartWallet] Plugin destroyed");
+    };
+    /**
+     * Initialize provider and signer
+     */
+    SmartWalletPlugin.prototype.initProvider = function () {
+        if (typeof window !== "undefined" && window.ethereum) {
+            var provider = new ethers.BrowserProvider(window.ethereum);
+            // Try to get signer from config, otherwise request from browser
+            if (this.config.privateKey) {
+                this.signer = new ethers.Wallet(this.config.privateKey, provider);
+            }
+            else {
+                // Will be set when user connects wallet or provides private key
+                this.signer = null;
+                console.log("[SmartWallet] No private key provided. Use connectWallet() or setSigner() first.");
+            }
+        }
+    };
+    /**
+     * Set signer with private key or wallet instance
+     * This should be called after deriving the EOA from seed phrase
+     */
+    SmartWalletPlugin.prototype.setSigner = function (privateKeyOrAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var provider;
+            var _a;
+            return __generator(this, function (_b) {
+                try {
+                    if (!((_a = this.signer) === null || _a === void 0 ? void 0 : _a.provider)) {
+                        provider = new ethers.BrowserProvider(window.ethereum);
+                        this.signer = new ethers.Wallet(privateKeyOrAddress, provider);
+                    }
+                    else {
+                        this.signer = new ethers.Wallet(privateKeyOrAddress, this.signer.provider);
+                    }
+                    console.log("[SmartWallet] Signer updated");
+                }
+                catch (error) {
+                    console.error("[SmartWallet] Failed to set signer:", error.message);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Connect to MetaMask or other injected provider
+     */
+    SmartWalletPlugin.prototype.connectWallet = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var provider, _a, _b, _c, _d, error_1;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _e.trys.push([0, 6, , 7]);
+                        if (!(typeof window !== "undefined" && window.ethereum)) return [3 /*break*/, 4];
+                        provider = new ethers.BrowserProvider(window.ethereum);
+                        return [4 /*yield*/, provider.send("eth_requestAccounts", [])];
+                    case 1:
+                        _e.sent();
+                        _a = this;
+                        return [4 /*yield*/, provider.getSigner()];
+                    case 2:
+                        _a.signer = _e.sent();
+                        _c = (_b = console).log;
+                        _d = ["[SmartWallet] Connected to wallet:"];
+                        return [4 /*yield*/, this.signer.getAddress()];
+                    case 3:
+                        _c.apply(_b, _d.concat([_e.sent()]));
+                        return [3 /*break*/, 5];
+                    case 4: throw new Error("No Ethereum provider found");
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        error_1 = _e.sent();
+                        console.error("[SmartWallet] Failed to connect wallet:", error_1.message);
+                        throw error_1;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Initialize factory contract
+     */
+    SmartWalletPlugin.prototype.initFactoryContract = function () {
+        if (!this.config.factoryAddress || !this.signer) {
+            console.warn("[SmartWallet] Factory address or signer not available");
+            return;
+        }
+        this.factoryContract = new ethers.Contract(this.config.factoryAddress, SMART_WALLET_FACTORY_ABI, this.signer);
+    };
+    /**
+     * Ensure signer is available
+     */
+    SmartWalletPlugin.prototype.assertSigner = function () {
+        if (!this.signer) {
+            throw new Error("Signer not available. Please connect a wallet.");
+        }
+        return this.signer;
+    };
+    /**
+     * Ensure factory is initialized
+     */
+    SmartWalletPlugin.prototype.assertFactory = function () {
+        if (!this.factoryContract) {
+            throw new Error("SmartWallet factory not initialized. Please deploy factory first.");
+        }
+        return this.factoryContract;
+    };
+    // ============================================ Wallet Creation ============================================
+    SmartWalletPlugin.prototype.createWallet = function (owner, requiredSignatures, requiredGuardians) {
+        return __awaiter(this, void 0, void 0, function () {
+            var factory, sig, reqSig, reqGuard, tx, receipt, event_1, walletAddress, error_2;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 3, , 4]);
+                        factory = this.assertFactory();
+                        sig = this.assertSigner();
+                        reqSig = (_a = requiredSignatures !== null && requiredSignatures !== void 0 ? requiredSignatures : this.config.defaultRequiredSignatures) !== null && _a !== void 0 ? _a : 1;
+                        reqGuard = (_b = requiredGuardians !== null && requiredGuardians !== void 0 ? requiredGuardians : this.config.defaultRequiredGuardians) !== null && _b !== void 0 ? _b : 2;
+                        return [4 /*yield*/, factory.createWallet(owner, reqSig, reqGuard)];
+                    case 1:
+                        tx = _c.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _c.sent();
+                        event_1 = receipt.logs.find(function (log) {
+                            return log.topics[0] === ethers.id("WalletCreated(address,address,uint256)");
+                        });
+                        walletAddress = event_1
+                            ? ethers.getAddress("0x" + event_1.topics[1].slice(-40))
+                            : null;
+                        return [2 /*return*/, {
+                                success: true,
+                                walletAddress: walletAddress || undefined,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_2 = _c.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_2.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.createWalletWithGuardians = function (owner, guardians, requiredSignatures, requiredGuardians) {
+        return __awaiter(this, void 0, void 0, function () {
+            var factory, reqSig, reqGuard, tx, receipt, event_2, walletAddress, error_3;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 3, , 4]);
+                        factory = this.assertFactory();
+                        reqSig = (_a = requiredSignatures !== null && requiredSignatures !== void 0 ? requiredSignatures : this.config.defaultRequiredSignatures) !== null && _a !== void 0 ? _a : 1;
+                        reqGuard = (_b = requiredGuardians !== null && requiredGuardians !== void 0 ? requiredGuardians : this.config.defaultRequiredGuardians) !== null && _b !== void 0 ? _b : 2;
+                        return [4 /*yield*/, factory.createWalletWithGuardians(owner, guardians, reqSig, reqGuard)];
+                    case 1:
+                        tx = _c.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _c.sent();
+                        event_2 = receipt.logs.find(function (log) {
+                            return log.topics[0] === ethers.id("WalletCreated(address,address,uint256)");
+                        });
+                        walletAddress = event_2
+                            ? ethers.getAddress("0x" + event_2.topics[1].slice(-40))
+                            : null;
+                        return [2 /*return*/, {
+                                success: true,
+                                walletAddress: walletAddress || undefined,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_3 = _c.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_3.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================ Wallet Management ============================================
+    SmartWalletPlugin.prototype.getWalletInfo = function (walletAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, _a, owner, requiredSig, requiredGuard, currentSigner, isSigner, error_4;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, Promise.all([
+                                walletContract.owner(),
+                                walletContract.requiredSignatures(),
+                                walletContract.requiredGuardians(),
+                                this.assertSigner().getAddress(),
+                            ])];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 4]), owner = _a[0], requiredSig = _a[1], requiredGuard = _a[2], currentSigner = _a[3];
+                        return [4 /*yield*/, walletContract.signers(currentSigner)];
+                    case 2:
+                        isSigner = _b.sent();
+                        return [2 /*return*/, {
+                                address: walletAddress,
+                                owner: owner,
+                                isSigner: isSigner,
+                                requiredSignatures: Number(requiredSig),
+                                requiredGuardians: Number(requiredGuard),
+                            }];
+                    case 3:
+                        error_4 = _b.sent();
+                        console.error("[SmartWallet] Error getting wallet info:", error_4);
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.getOwnerWallets = function (ownerAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var factory, wallets, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        factory = this.assertFactory();
+                        return [4 /*yield*/, factory.getOwnerWallets(ownerAddress)];
+                    case 1:
+                        wallets = _a.sent();
+                        return [2 /*return*/, wallets];
+                    case 2:
+                        error_5 = _a.sent();
+                        console.error("[SmartWallet] Error getting owner wallets:", error_5);
+                        return [2 /*return*/, []];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================ Signer Management ============================================
+    SmartWalletPlugin.prototype.addSigner = function (walletAddress, signer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.addSigner(signer)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_6 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_6.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.removeSigner = function (walletAddress, signer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.removeSigner(signer)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_7 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_7.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.setRequiredSignatures = function (walletAddress, required) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.setRequiredSignatures(required)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_8 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_8.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================ Guardian Management ============================================
+    SmartWalletPlugin.prototype.addGuardian = function (walletAddress, guardian) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_9;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.addGuardian(guardian)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_9 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_9.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.removeGuardian = function (walletAddress, guardian) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_10;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.removeGuardian(guardian)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_10 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_10.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================ Execution ============================================
+    SmartWalletPlugin.prototype.executeTransaction = function (walletAddress_1, target_1, data_1) {
+        return __awaiter(this, arguments, void 0, function (walletAddress, target, data, value) {
+            var walletContract, tx, receipt, error_11;
+            if (value === void 0) { value = "0"; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.execute(target, data, value)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_11 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_11.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.executeBatch = function (walletAddress, targets, dataArray, values) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_12;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.executeBatch(targets, dataArray, values)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_12 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_12.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================ Multi-Sig ============================================
+    SmartWalletPlugin.prototype.proposeExecution = function (walletAddress, target, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_13;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.proposeExecution(target, data)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_13 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_13.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.approveProposal = function (walletAddress, proposalId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_14;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.approveProposal(proposalId)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_14 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_14.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.getProposalInfo = function (walletAddress, proposalId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var provider, walletContract, _a, target, data, proposer, approvals, executed, error_15;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        provider = this.assertSigner().provider || ethers.getDefaultProvider();
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, provider);
+                        return [4 /*yield*/, walletContract.getProposal(proposalId)];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 5]), target = _a[0], data = _a[1], proposer = _a[2], approvals = _a[3], executed = _a[4];
+                        return [2 /*return*/, {
+                                proposalId: proposalId,
+                                target: target,
+                                proposer: proposer,
+                                approvals: Number(approvals),
+                                executed: executed,
+                            }];
+                    case 2:
+                        error_15 = _b.sent();
+                        console.error("[SmartWallet] Error getting proposal info:", error_15);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // ============================================ Recovery ============================================
+    SmartWalletPlugin.prototype.initiateRecovery = function (walletAddress, newOwner) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_16;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.initiateRecovery(newOwner)];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_16 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_16.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.approveRecovery = function (walletAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_17;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.approveRecovery()];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_17 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_17.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.executeRecovery = function (walletAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletContract, tx, receipt, error_18;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
+                        return [4 /*yield*/, walletContract.executeRecovery()];
+                    case 1:
+                        tx = _a.sent();
+                        return [4 /*yield*/, tx.wait()];
+                    case 2:
+                        receipt = _a.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                transactionHash: receipt.hash,
+                            }];
+                    case 3:
+                        error_18 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                error: error_18.message,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SmartWalletPlugin.prototype.getRecoveryRequest = function (walletAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var provider, walletContract, _a, newOwner, unlockTime, approvals, error_19;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        provider = this.assertSigner().provider || ethers.getDefaultProvider();
+                        walletContract = new ethers.Contract(walletAddress, SMART_WALLET_ABI, provider);
+                        return [4 /*yield*/, walletContract.getRecoveryRequest()];
+                    case 1:
+                        _a = __read.apply(void 0, [_b.sent(), 3]), newOwner = _a[0], unlockTime = _a[1], approvals = _a[2];
+                        return [2 /*return*/, {
+                                newOwner: newOwner,
+                                unlockTime: Number(unlockTime),
+                                approvals: Number(approvals),
+                            }];
+                    case 2:
+                        error_19 = _b.sent();
+                        console.error("[SmartWallet] Error getting recovery request:", error_19);
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return SmartWalletPlugin;
+}(BasePlugin));
+export { SmartWalletPlugin };