arc402-cli 1.4.17 → 1.4.19

package/dist/commands/wallet.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -1224,6 +1257,216 @@ function registerWalletCommands(program) {
             printOpenShellHint();
         }
     });
+    // ─── onboard ───────────────────────────────────────────────────────────────
+    //
+    // Post-deploy ceremony: register on PolicyEngine, set velocity limit,
+    // 5 category spend limits, and whitelist 4 protocol contracts.
+    // Runs in ONE WalletConnect session. Idempotent — skips steps already done.
+    wallet.command("onboard")
+        .description("Post-deploy onboarding: PolicyEngine registration, velocity limit, category limits, and contract whitelisting in one WalletConnect session")
+        .option("--velocity-limit <eth>", "Velocity limit in ETH (rolling window)", "0.05")
+        .option("--hardware", "Hardware wallet mode: show raw wc: URI only")
+        .action(async (opts) => {
+        const config = (0, config_1.loadConfig)();
+        if (!config.walletContractAddress) {
+            console.error(colors_1.c.failure + " " + colors_1.c.red("No walletContractAddress in config. Run `arc402 wallet deploy` first."));
+            process.exit(1);
+        }
+        if (!config.walletConnectProjectId) {
+            console.error(colors_1.c.failure + " " + colors_1.c.red("WalletConnect not configured. Run `arc402 config set walletConnectProjectId <id>`."));
+            process.exit(1);
+        }
+        const walletAddress = config.walletContractAddress;
+        const policyAddress = config.policyEngineAddress ?? POLICY_ENGINE_DEFAULT;
+        const chainId = config.network === "base-mainnet" ? 8453 : 84532;
+        const provider = new ethers_1.ethers.JsonRpcProvider(config.rpcUrl);
+        // Resolve protocol contracts to whitelist
+        const handshakeAddress = config.handshakeAddress ??
+            config_1.NETWORK_DEFAULTS[config.network]?.handshakeAddress ??
+            "0x4F5A38Bb746d7E5d49d8fd26CA6beD141Ec2DDb3";
+        const protocolContracts = [
+            { address: config.serviceAgreementAddress ?? config_1.NETWORK_DEFAULTS[config.network]?.serviceAgreementAddress ?? "", name: "ServiceAgreement" },
+            { address: config.computeAgreementAddress ?? config_1.NETWORK_DEFAULTS[config.network]?.computeAgreementAddress ?? "", name: "ComputeAgreement" },
+            { address: config.subscriptionAgreementAddress ?? config_1.NETWORK_DEFAULTS[config.network]?.subscriptionAgreementAddress ?? "", name: "SubscriptionAgreement" },
+            { address: handshakeAddress, name: "Handshake" },
+        ].filter(pc => pc.address && pc.address !== "");
+        // Pre-check on-chain state to count pending txs and decide what to skip
+        const checkSpin = (0, spinner_1.startSpinner)("Checking onboarding state…");
+        let needsRegister = true;
+        let needsDefiAccess = true;
+        let needsVelocity = true;
+        const categoryNeeds = {};
+        const whitelistNeeds = {};
+        try {
+            const govContract = new ethers_1.ethers.Contract(policyAddress, abis_1.POLICY_ENGINE_GOVERNANCE_ABI, provider);
+            const limitsContract = new ethers_1.ethers.Contract(policyAddress, abis_1.POLICY_ENGINE_LIMITS_ABI, provider);
+            const ownerContract = new ethers_1.ethers.Contract(walletAddress, abis_1.ARC402_WALLET_OWNER_ABI, provider);
+            try {
+                const registeredOwner = await govContract.walletOwners(walletAddress);
+                needsRegister = registeredOwner === ethers_1.ethers.ZeroAddress;
+            }
+            catch { /* assume needs */ }
+            try {
+                const defiEnabled = await govContract.defiAccessEnabled(walletAddress);
+                needsDefiAccess = !defiEnabled;
+            }
+            catch { /* assume needs */ }
+            try {
+                const velocity = await ownerContract.velocityLimit();
+                needsVelocity = velocity === 0n;
+            }
+            catch { /* assume needs */ }
+            for (const { name } of ONBOARDING_CATEGORIES) {
+                try {
+                    const existing = await limitsContract.categoryLimits(walletAddress, name);
+                    categoryNeeds[name] = existing === 0n;
+                }
+                catch {
+                    categoryNeeds[name] = true;
+                }
+            }
+            for (const pc of protocolContracts) {
+                try {
+                    const isWL = await govContract.isContractWhitelisted(walletAddress, pc.address);
+                    whitelistNeeds[pc.name] = !isWL;
+                }
+                catch {
+                    whitelistNeeds[pc.name] = true;
+                }
+            }
+            checkSpin.succeed("State checked");
+        }
+        catch (e) {
+            checkSpin.fail(`State check failed: ${e instanceof Error ? e.message : String(e)}`);
+            process.exit(1);
+        }
+        // Count pending transactions
+        let pendingTxCount = 0;
+        if (needsRegister)
+            pendingTxCount++;
+        if (needsDefiAccess)
+            pendingTxCount++;
+        if (needsVelocity)
+            pendingTxCount++;
+        for (const { name } of ONBOARDING_CATEGORIES) {
+            if (categoryNeeds[name])
+                pendingTxCount++;
+        }
+        for (const pc of protocolContracts) {
+            if (whitelistNeeds[pc.name])
+                pendingTxCount++;
+        }
+        if (pendingTxCount === 0) {
+            console.log(" " + colors_1.c.success + " Wallet already fully onboarded — nothing to do.");
+            return;
+        }
+        console.log(" " + colors_1.c.dim(`◈ ${pendingTxCount} transaction(s) pending — your phone will need to approve each.`));
+        // Telegram notification before first tx
+        const telegramOpts = config.telegramBotToken && config.telegramChatId
+            ? { botToken: config.telegramBotToken, chatId: config.telegramChatId, threadId: config.telegramThreadId }
+            : undefined;
+        // Connect WalletConnect ONCE — reuse session for all txs
+        const { client, session, account } = await (0, walletconnect_1.connectPhoneWallet)(config.walletConnectProjectId, chainId, config, { telegramOpts, prompt: `Approve ${pendingTxCount} wallet onboarding transaction(s)`, hardware: !!opts.hardware });
+        const networkName = chainId === 8453 ? "Base" : "Base Sepolia";
+        const shortAddr = `${account.slice(0, 6)}...${account.slice(-5)}`;
+        console.log("\n" + colors_1.c.success + colors_1.c.white(` Connected: ${shortAddr} on ${networkName}`));
+        if (telegramOpts) {
+            await (0, telegram_notify_1.sendTelegramMessage)({
+                botToken: telegramOpts.botToken,
+                chatId: telegramOpts.chatId,
+                threadId: telegramOpts.threadId,
+                text: `◈ arc402 wallet onboard: ${pendingTxCount} txs pending for ${shortAddr}`,
+            });
+        }
+        const sendTx = async (call, description) => {
+            const txSpin = (0, spinner_1.startSpinner)(description);
+            const hash = await (0, walletconnect_1.sendTransactionWithSession)(client, session, account, chainId, call);
+            await provider.waitForTransaction(hash, 1);
+            txSpin.succeed(description);
+            return hash;
+        };
+        const executeIface = new ethers_1.ethers.Interface(abis_1.ARC402_WALLET_EXECUTE_ABI);
+        const govIface = new ethers_1.ethers.Interface(abis_1.POLICY_ENGINE_GOVERNANCE_ABI);
+        const limitsIface = new ethers_1.ethers.Interface(abis_1.POLICY_ENGINE_LIMITS_ABI);
+        const ownerIface = new ethers_1.ethers.Interface(abis_1.ARC402_WALLET_OWNER_ABI);
+        console.log("\n" + colors_1.c.dim("── Onboarding ceremony ────────────────────────────────────────"));
+        // 1. registerWallet
+        if (needsRegister) {
+            const registerCalldata = govIface.encodeFunctionData("registerWallet", [walletAddress, account]);
+            await sendTx({
+                to: walletAddress,
+                data: executeIface.encodeFunctionData("executeContractCall", [{
+                        target: policyAddress,
+                        data: registerCalldata,
+                        value: 0n,
+                        minReturnValue: 0n,
+                        maxApprovalAmount: 0n,
+                        approvalToken: ethers_1.ethers.ZeroAddress,
+                    }]),
+                value: "0x0",
+            }, "registerWallet on PolicyEngine");
+        }
+        else {
+            console.log(" " + colors_1.c.success + colors_1.c.dim(" registerWallet — already done"));
+        }
+        // 2. enableDefiAccess
+        if (needsDefiAccess) {
+            await sendTx({
+                to: policyAddress,
+                data: govIface.encodeFunctionData("enableDefiAccess", [walletAddress]),
+                value: "0x0",
+            }, "enableDefiAccess on PolicyEngine");
+        }
+        else {
+            console.log(" " + colors_1.c.success + colors_1.c.dim(" enableDefiAccess — already done"));
+        }
+        // 3. setVelocityLimit
+        if (needsVelocity) {
+            const velocityEth = opts.velocityLimit || "0.05";
+            await sendTx({
+                to: walletAddress,
+                data: ownerIface.encodeFunctionData("setVelocityLimit", [ethers_1.ethers.parseEther(velocityEth)]),
+                value: "0x0",
+            }, `setVelocityLimit: ${velocityEth} ETH`);
+        }
+        else {
+            console.log(" " + colors_1.c.success + colors_1.c.dim(" setVelocityLimit — already set"));
+        }
+        // 4–8. Category limits
+        for (const { name, amountEth } of ONBOARDING_CATEGORIES) {
+            if (categoryNeeds[name]) {
+                await sendTx({
+                    to: policyAddress,
+                    data: limitsIface.encodeFunctionData("setCategoryLimitFor", [walletAddress, name, ethers_1.ethers.parseEther(amountEth)]),
+                    value: "0x0",
+                }, `setCategoryLimitFor: ${name} → ${amountEth} ETH`);
+            }
+            else {
+                console.log(" " + colors_1.c.success + colors_1.c.dim(` setCategoryLimitFor(${name}) — already set`));
+            }
+        }
+        // 9+. Whitelist protocol contracts
+        for (const pc of protocolContracts) {
+            if (whitelistNeeds[pc.name]) {
+                await sendTx({
+                    to: policyAddress,
+                    data: govIface.encodeFunctionData("whitelistContract", [walletAddress, pc.address]),
+                    value: "0x0",
+                }, `whitelistContract: ${pc.name}`);
+            }
+            else {
+                console.log(" " + colors_1.c.success + colors_1.c.dim(` whitelistContract(${pc.name}) — already done`));
+            }
+        }
+        console.log(colors_1.c.dim("── Onboarding complete ─────────────────────────────────────────"));
+        console.log("\n " + colors_1.c.success + colors_1.c.white(" Wallet onboarding complete"));
+        (0, tree_1.renderTree)([
+            { label: "Wallet", value: walletAddress },
+            { label: "Owner", value: account },
+            { label: "Velocity Limit", value: (opts.velocityLimit || "0.05") + " ETH" },
+            { label: "Contracts Whitelisted", value: protocolContracts.length.toString(), last: true },
+        ]);
+    });
     // ─── send ──────────────────────────────────────────────────────────────────
     wallet.command("send <address> <amount>")
         .description("Send ETH from configured wallet (amount: '0.001eth' or wei)")
@@ -1355,6 +1598,64 @@ function registerWalletCommands(program) {
             console.log(`Daily limit for ${opts.category} set to ${opts.amount} ETH (12/24h rolling window)`);
         }
     });
+    walletPolicy.command("init")
+        .description("Set all 5 default spending limits in one WalletConnect session (1 phone connection, 5 approvals)")
+        .option("--general <eth>", "General limit", "0.001")
+        .option("--hire <eth>", "Hire limit", "0.1")
+        .option("--compute <eth>", "Compute limit", "0.05")
+        .option("--research <eth>", "Research limit", "0.05")
+        .option("--protocol <eth>", "Protocol limit", "0.1")
+        .action(async (opts) => {
+        const config = (0, config_1.loadConfig)();
+        const policyAddress = config.policyEngineAddress ?? POLICY_ENGINE_DEFAULT;
+        const chainId = config.network === "base-mainnet" ? 8453 : 84532;
+        const walletAddr = config.walletContractAddress;
+        if (!walletAddr) {
+            console.error("walletContractAddress not set. Run `arc402 wallet deploy` first.");
+            process.exit(1);
+        }
+        if (!config.walletConnectProjectId) {
+            console.error("walletConnectProjectId not set.");
+            process.exit(1);
+        }
+        const categories = [
+            { name: "general", amount: opts.general },
+            { name: "hire", amount: opts.hire },
+            { name: "compute", amount: opts.compute },
+            { name: "research", amount: opts.research },
+            { name: "protocol", amount: opts.protocol },
+        ];
+        const policyInterface = new ethers_1.ethers.Interface(abis_1.POLICY_ENGINE_LIMITS_ABI);
+        const provider = new ethers_1.ethers.JsonRpcProvider(config.rpcUrl);
+        const telegramOpts = config.telegramBotToken && config.telegramChatId ? {
+            botToken: config.telegramBotToken,
+            chatId: config.telegramChatId,
+            threadId: config.telegramThreadId,
+        } : undefined;
+        console.log(colors_1.c.white("\n◈ Spend limit init — 1 connection, 5 approvals\n"));
+        console.log(colors_1.c.dim("  Connect once — MetaMask will prompt 5 times in sequence."));
+        // Connect once, reuse session for all 5 txs
+        const { client, session, account } = await (0, walletconnect_1.connectPhoneWallet)(config.walletConnectProjectId, chainId, config, { telegramOpts, prompt: "Connect wallet for spend limit setup (5 approvals)" });
+        for (const cat of categories) {
+            const amount = ethers_1.ethers.parseEther(cat.amount);
+            const data = policyInterface.encodeFunctionData("setCategoryLimitFor", [walletAddr, cat.name, amount]);
+            console.log(colors_1.c.dim(`\n  Setting ${cat.name} → ${cat.amount} ETH...`));
+            // Send Telegram notification for each
+            if (telegramOpts) {
+                const { sendTelegramMessage: sendTg } = await Promise.resolve().then(() => __importStar(require("../telegram-notify.js")));
+                await sendTg({ ...telegramOpts, text: `Approve spend limit: ${cat.name} → ${cat.amount} ETH` });
+            }
+            const txHash = await (0, walletconnect_1.sendTransactionWithSession)(client, session, account, chainId, {
+                to: policyAddress,
+                data,
+                value: "0x0",
+            });
+            console.log(colors_1.c.dim(`  Submitted: ${txHash}`));
+            await provider.waitForTransaction(txHash);
+            console.log(colors_1.c.success + colors_1.c.white(` ${cat.name} → ${cat.amount} ETH`));
+        }
+        console.log(colors_1.c.white("\n✓ All 5 spend limits set.\n"));
+    });
     walletPolicy.command("set <policyId>")
         .description("Set the active policy ID on ARC402Wallet (phone wallet signs via WalletConnect)")
         .action(async (policyId) => {