aavegotchi-cli 0.2.0 → 0.2.2

package/dist/signer.js

@@ -9,6 +9,9 @@ const errors_1 = require("./errors");
 const keychain_1 = require("./keychain");
 const REMOTE_SIGN_ADDRESS_PATH = "/address";
 const REMOTE_SIGN_TX_PATH = "/sign-transaction";
+const BANKR_DEFAULT_API_URL = "https://api.bankr.bot";
+const BANKR_AGENT_ME_PATH = "/agent/me";
+const BANKR_AGENT_SUBMIT_PATH = "/agent/submit";
 function parsePrivateKey(value, hint) {
     if (!/^0x[0-9a-fA-F]{64}$/.test(value)) {
         throw new errors_1.CliError("INVALID_PRIVATE_KEY", `${hint} is not a valid private key.`, 2);
@@ -77,6 +80,111 @@ function buildRemoteHeaders(signer) {
     }
     return headers;
 }
+function requireEnvVarName(value, context) {
+    if (!/^[A-Z_][A-Z0-9_]*$/.test(value)) {
+        throw new errors_1.CliError("INVALID_SIGNER_SPEC", `Invalid ${context} env var '${value}'.`, 2);
+    }
+    return value;
+}
+function resolveBankrApiUrl(signer) {
+    return (signer.apiUrl || BANKR_DEFAULT_API_URL).replace(/\/+$/, "");
+}
+function buildBankrHeaders(signer) {
+    const envVar = signer.apiKeyEnvVar || "BANKR_API_KEY";
+    const token = process.env[envVar];
+    if (!token) {
+        throw new errors_1.CliError("MISSING_SIGNER_SECRET", `Missing environment variable '${envVar}'.`, 2);
+    }
+    return {
+        "content-type": "application/json",
+        "x-api-key": token,
+    };
+}
+async function fetchBankrJson(url, init) {
+    let response;
+    try {
+        response = await fetch(url, init);
+    }
+    catch (error) {
+        throw new errors_1.CliError("BANKR_API_UNREACHABLE", "Failed to connect to Bankr API.", 2, {
+            url,
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+    const text = await response.text();
+    let parsed = {};
+    if (text) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = text;
+        }
+    }
+    if (!response.ok) {
+        throw new errors_1.CliError("BANKR_API_HTTP_ERROR", `Bankr API responded with HTTP ${response.status}.`, 2, {
+            url,
+            status: response.status,
+            body: parsed,
+        });
+    }
+    return parsed;
+}
+function parseBankrAddressCandidate(candidate) {
+    if (typeof candidate !== "string") {
+        return undefined;
+    }
+    if (!/^0x[a-fA-F0-9]{40}$/.test(candidate)) {
+        return undefined;
+    }
+    return candidate.toLowerCase();
+}
+async function resolveBankrAddress(signer, headers) {
+    if (signer.address) {
+        return ensureAddress(signer.address, "bankr signer address");
+    }
+    const apiUrl = resolveBankrApiUrl(signer);
+    const response = (await fetchBankrJson(addDefaultPaths(apiUrl, BANKR_AGENT_ME_PATH), {
+        method: "GET",
+        headers,
+    }));
+    const direct = parseBankrAddressCandidate(response.walletAddress) ||
+        parseBankrAddressCandidate(response.address) ||
+        parseBankrAddressCandidate(response.agent?.walletAddress) ||
+        parseBankrAddressCandidate(response.agent?.address);
+    if (direct) {
+        return direct;
+    }
+    if (Array.isArray(response.wallets)) {
+        const evmWallet = response.wallets.find((wallet) => wallet.chain === "evm");
+        const evmAddress = parseBankrAddressCandidate(evmWallet?.address) || parseBankrAddressCandidate(evmWallet?.walletAddress);
+        if (evmAddress) {
+            return evmAddress;
+        }
+        for (const wallet of response.wallets) {
+            const anyAddress = parseBankrAddressCandidate(wallet.address) || parseBankrAddressCandidate(wallet.walletAddress);
+            if (anyAddress) {
+                return anyAddress;
+            }
+        }
+    }
+    throw new errors_1.CliError("BANKR_API_PROTOCOL_ERROR", "Bankr /agent/me response missing wallet address.", 2, {
+        keys: Object.keys(response),
+    });
+}
+function parseBankrSubmitHash(response) {
+    if (typeof response !== "object" || response === null) {
+        return undefined;
+    }
+    const root = response;
+    const nested = typeof root.result === "object" && root.result !== null ? root.result : undefined;
+    return (parseTxHash(root.transactionHash) ||
+        parseTxHash(root.txHash) ||
+        parseTxHash(root.hash) ||
+        parseTxHash(nested?.transactionHash) ||
+        parseTxHash(nested?.txHash) ||
+        parseTxHash(nested?.hash));
+}
 async function resolveRemoteAddress(signer, headers) {
     if (signer.address) {
         return ensureAddress(signer.address, "remote signer address");
@@ -175,6 +283,47 @@ function parseSignerLedgerSpec(value) {
     }
     return signer;
 }
+function parseSignerBankrSpec(value) {
+    if (value === "bankr") {
+        return { type: "bankr" };
+    }
+    const body = value.slice("bankr:".length).trim();
+    const signer = {
+        type: "bankr",
+    };
+    if (!body) {
+        return signer;
+    }
+    if (!body.includes("|")) {
+        if (/^0x[a-fA-F0-9]{40}$/.test(body)) {
+            signer.address = ensureAddress(body, "bankr signer address");
+            return signer;
+        }
+        if (/^[A-Z_][A-Z0-9_]*$/.test(body)) {
+            signer.apiKeyEnvVar = requireEnvVarName(body, "bankr api key");
+            return signer;
+        }
+        if (/^https?:\/\//i.test(body)) {
+            signer.apiUrl = body;
+            return signer;
+        }
+        throw new errors_1.CliError("INVALID_SIGNER_SPEC", `Invalid bankr signer format '${value}'.`, 2);
+    }
+    const [addressPart, apiKeyEnvVarPart, apiUrlPart] = body.split("|").map((entry) => entry.trim());
+    if (addressPart) {
+        signer.address = ensureAddress(addressPart, "bankr signer address");
+    }
+    if (apiKeyEnvVarPart) {
+        signer.apiKeyEnvVar = requireEnvVarName(apiKeyEnvVarPart, "bankr api key");
+    }
+    if (apiUrlPart) {
+        if (!/^https?:\/\//i.test(apiUrlPart)) {
+            throw new errors_1.CliError("INVALID_SIGNER_SPEC", `Invalid bankr API URL in '${value}'.`, 2);
+        }
+        signer.apiUrl = apiUrlPart;
+    }
+    return signer;
+}
 function parseSigner(value) {
     if (!value || value === "readonly") {
         return { type: "readonly" };
@@ -205,7 +354,10 @@ function parseSigner(value) {
     if (value.startsWith("remote:")) {
         return parseSignerRemoteSpec(value);
     }
-    throw new errors_1.CliError("INVALID_SIGNER_SPEC", `Unsupported signer '${value}'. Use readonly, env:<ENV_VAR>, keychain:<id>, ledger[:path|address|bridgeEnv], or remote:<url|address|authEnv>.`, 2);
+    if (value === "bankr" || value.startsWith("bankr:")) {
+        return parseSignerBankrSpec(value);
+    }
+    throw new errors_1.CliError("INVALID_SIGNER_SPEC", `Unsupported signer '${value}'. Use readonly, env:<ENV_VAR>, keychain:<id>, ledger[:path|address|bridgeEnv], remote:<url|address|authEnv>, or bankr[:address|apiKeyEnv|apiUrl].`, 2);
 }
 async function resolveSignerRuntime(signer, publicClient, rpcUrl, chain, customHome) {
     if (signer.type === "readonly") {
@@ -307,6 +459,44 @@ async function resolveSignerRuntime(signer, publicClient, rpcUrl, chain, customH
             },
         };
     }
+    if (signer.type === "bankr") {
+        const apiUrl = resolveBankrApiUrl(signer);
+        const headers = buildBankrHeaders(signer);
+        const address = await resolveBankrAddress(signer, headers);
+        const summary = await resolveBalanceSummary("bankr", publicClient, address);
+        return {
+            summary,
+            sendTransaction: async (request) => {
+                const payload = {
+                    transaction: {
+                        chainId: request.chain.id,
+                        from: address,
+                        to: request.to,
+                        data: request.data,
+                        value: request.value?.toString() || "0",
+                        gas: request.gas.toString(),
+                        nonce: request.nonce,
+                        maxFeePerGas: request.maxFeePerGas?.toString(),
+                        maxPriorityFeePerGas: request.maxPriorityFeePerGas?.toString(),
+                    },
+                    waitForConfirmation: false,
+                    description: "Submitted via aavegotchi-cli",
+                };
+                const response = await fetchBankrJson(addDefaultPaths(apiUrl, BANKR_AGENT_SUBMIT_PATH), {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(payload),
+                });
+                const txHash = parseBankrSubmitHash(response);
+                if (txHash) {
+                    return txHash;
+                }
+                throw new errors_1.CliError("BANKR_API_PROTOCOL_ERROR", "Bankr submit response missing transaction hash.", 2, {
+                    response,
+                });
+            },
+        };
+    }
     const bridgeEnvVar = signer.bridgeCommandEnvVar || "AGCLI_LEDGER_BRIDGE_CMD";
     const bridgeCommand = process.env[bridgeEnvVar];
     if (!bridgeCommand) {

package/dist/tx-engine.js

@@ -72,9 +72,10 @@ async function waitForConfirmation(intent, ctx, txHash) {
 async function executeTxIntent(intent, chain, customHome) {
     const idempotencyKey = (0, idempotency_1.resolveIdempotencyKey)(intent);
     const journal = new journal_1.JournalStore((0, config_1.resolveJournalPath)(customHome));
+    const dryRun = Boolean(intent.dryRun);
     try {
         const preflight = await (0, rpc_1.runRpcPreflight)(chain, intent.rpcUrl);
-        const existing = journal.getByIdempotencyKey(idempotencyKey);
+        const existing = dryRun ? undefined : journal.getByIdempotencyKey(idempotencyKey);
         if (existing && existing.status === "confirmed") {
             return mapJournalToResult(existing);
         }
@@ -91,7 +92,13 @@ async function executeTxIntent(intent, chain, customHome) {
         }
         const viemChain = (0, chains_1.toViemChain)(chain, intent.rpcUrl);
         const signerRuntime = await (0, signer_1.resolveSignerRuntime)(intent.signer, preflight.client, intent.rpcUrl, viemChain, customHome);
-        if (!signerRuntime.summary.canSign || !signerRuntime.sendTransaction || !signerRuntime.summary.address) {
+        if (!signerRuntime.summary.address) {
+            throw new errors_1.CliError("MISSING_SIGNER_ADDRESS", "Signer address is required for simulation and transaction execution.", 2, {
+                signerType: signerRuntime.summary.signerType,
+                backendStatus: signerRuntime.summary.backendStatus,
+            });
+        }
+        if (!dryRun && (!signerRuntime.summary.canSign || !signerRuntime.sendTransaction)) {
             throw new errors_1.CliError("READONLY_SIGNER", "Selected signer cannot submit transactions.", 2, {
                 signerType: signerRuntime.summary.signerType,
                 backendStatus: signerRuntime.summary.backendStatus,
@@ -125,7 +132,7 @@ async function executeTxIntent(intent, chain, customHome) {
         const maxPriorityFeePerGas = feeEstimate.maxPriorityFeePerGas;
         const balanceWei = await preflight.client.getBalance({ address: fromAddress });
         const requiredWei = (intent.valueWei || 0n) + gasLimit * (maxFeePerGas || 0n);
-        if (balanceWei < requiredWei) {
+        if (!dryRun && balanceWei < requiredWei) {
             throw new errors_1.CliError("INSUFFICIENT_FUNDS_PRECHECK", "Account balance is below estimated transaction requirement.", 2, {
                 from: fromAddress,
                 balanceWei: balanceWei.toString(),
@@ -147,6 +154,31 @@ async function executeTxIntent(intent, chain, customHome) {
             existing,
         };
         const nonce = await resolveNonce(intent, ctx, fromAddress);
+        if (dryRun) {
+            return {
+                idempotencyKey,
+                from: fromAddress,
+                to: toAddress,
+                nonce,
+                gasLimit: gasLimit.toString(),
+                maxFeePerGasWei: maxFeePerGas?.toString(),
+                maxPriorityFeePerGasWei: maxPriorityFeePerGas?.toString(),
+                status: "simulated",
+                dryRun: true,
+                simulation: {
+                    requiredWei: requiredWei.toString(),
+                    balanceWei: balanceWei.toString(),
+                    signerCanSign: signerRuntime.summary.canSign,
+                    noncePolicy: intent.noncePolicy,
+                },
+            };
+        }
+        if (!signerRuntime.sendTransaction) {
+            throw new errors_1.CliError("READONLY_SIGNER", "Selected signer cannot submit transactions.", 2, {
+                signerType: signerRuntime.summary.signerType,
+                backendStatus: signerRuntime.summary.backendStatus,
+            });
+        }
         journal.upsertPrepared({
             idempotencyKey,
             profileName: intent.profileName,
@@ -208,14 +240,18 @@ async function executeTxIntent(intent, chain, customHome) {
     }
     catch (error) {
         if (error instanceof errors_1.CliError) {
-            journal.markFailed(idempotencyKey, error.code, error.message);
+            if (!dryRun) {
+                journal.markFailed(idempotencyKey, error.code, error.message);
+            }
             throw error;
         }
         const unknown = new errors_1.CliError("TX_EXECUTION_FAILED", "Transaction execution failed.", 1, {
             correlationId: (0, crypto_1.randomUUID)(),
             message: error instanceof Error ? error.message : String(error),
         });
-        journal.markFailed(idempotencyKey, unknown.code, unknown.message);
+        if (!dryRun) {
+            journal.markFailed(idempotencyKey, unknown.code, unknown.message);
+        }
         throw unknown;
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aavegotchi-cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Agent-first CLI for automating Aavegotchi app and onchain workflows",
   "license": "MIT",
   "repository": {
@@ -30,6 +30,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "parity:check": "node scripts/check-parity.mjs",
+    "smoke:write-dryrun": "bash scripts/smoke-write-dryrun.sh",
     "ag": "tsx src/index.ts",
     "prepack": "npm run build",
     "bootstrap:smoke": "AGCLI_HOME=/tmp/agcli-smoke tsx src/index.ts bootstrap --mode agent --profile smoke --chain base --signer readonly --json"