aavegotchi-cli 0.1.0

package/dist/commands/bootstrap.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBootstrapCommand = runBootstrapCommand;
+const args_1 = require("../args");
+const chains_1 = require("../chains");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const rpc_1 = require("../rpc");
+const signer_1 = require("../signer");
+function getRequiredProfileName(ctx) {
+    const fromFlag = (0, args_1.getFlagString)(ctx.args.flags, "profile");
+    const profile = fromFlag || ctx.globals.profile;
+    if (!profile) {
+        throw new errors_1.CliError("MISSING_PROFILE", "Bootstrap requires --profile <name>.", 2);
+    }
+    return profile;
+}
+function buildSignerConfig(ctx, signerInput) {
+    const signer = (0, signer_1.parseSigner)(signerInput);
+    if (signer.type === "remote") {
+        const address = (0, args_1.getFlagString)(ctx.args.flags, "signer-address");
+        const authEnvVar = (0, args_1.getFlagString)(ctx.args.flags, "signer-auth-env-var");
+        return {
+            ...signer,
+            ...(address ? { address: address } : {}),
+            ...(authEnvVar ? { authEnvVar } : {}),
+        };
+    }
+    if (signer.type === "ledger") {
+        const address = (0, args_1.getFlagString)(ctx.args.flags, "signer-address");
+        const bridgeCommandEnvVar = (0, args_1.getFlagString)(ctx.args.flags, "signer-bridge-env-var");
+        return {
+            ...signer,
+            ...(address ? { address: address } : {}),
+            ...(bridgeCommandEnvVar ? { bridgeCommandEnvVar } : {}),
+        };
+    }
+    return signer;
+}
+async function runBootstrapCommand(ctx) {
+    const profileName = getRequiredProfileName(ctx);
+    const chainInput = (0, args_1.getFlagString)(ctx.args.flags, "chain");
+    const rpcFlag = (0, args_1.getFlagString)(ctx.args.flags, "rpc-url");
+    const signerInput = (0, args_1.getFlagString)(ctx.args.flags, "signer") || "readonly";
+    const policyName = (0, args_1.getFlagString)(ctx.args.flags, "policy") || "default";
+    const skipSignerCheck = (0, args_1.getFlagBoolean)(ctx.args.flags, "skip-signer-check");
+    const chain = (0, chains_1.resolveChain)(chainInput);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, rpcFlag);
+    const preflight = await (0, rpc_1.runRpcPreflight)(chain, rpcUrl);
+    const signer = buildSignerConfig(ctx, signerInput);
+    let signerSummary = {
+        signerType: signer.type,
+        backendStatus: "not-checked",
+    };
+    if (!skipSignerCheck) {
+        const signerRuntime = await (0, signer_1.resolveSignerRuntime)(signer, preflight.client, rpcUrl, (0, chains_1.toViemChain)(chain, rpcUrl));
+        signerSummary = signerRuntime.summary;
+    }
+    const now = new Date().toISOString();
+    const config = (0, config_1.loadConfig)();
+    const existingProfile = config.profiles[profileName];
+    const profile = {
+        name: profileName,
+        chain: chain.key,
+        chainId: preflight.chainId,
+        rpcUrl,
+        signer,
+        policy: policyName,
+        createdAt: existingProfile?.createdAt || now,
+        updatedAt: now,
+    };
+    const withProfile = (0, config_1.upsertProfile)(config, profile);
+    const withPolicy = withProfile.policies[policyName]
+        ? withProfile
+        : (0, config_1.upsertPolicy)(withProfile, (0, config_1.createDefaultPolicy)(policyName, now));
+    // Validate policy existence after potential creation.
+    (0, config_1.getPolicyOrThrow)(withPolicy, policyName);
+    const activated = (0, config_1.setActiveProfile)(withPolicy, profileName);
+    const configPath = (0, config_1.saveConfig)(activated);
+    return {
+        message: "Bootstrap completed.",
+        profile: {
+            name: profile.name,
+            chain: profile.chain,
+            chainId: profile.chainId,
+            rpcUrl: profile.rpcUrl,
+            signer: profile.signer,
+            policy: profile.policy,
+        },
+        rpc: {
+            blockNumber: preflight.blockNumber,
+            chainName: preflight.chainName,
+        },
+        signer: signerSummary,
+        configPath,
+    };
+}

package/dist/commands/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCommandPath = exports.executeCommand = void 0;
+var command_runner_1 = require("../command-runner");
+Object.defineProperty(exports, "executeCommand", { enumerable: true, get: function () { return command_runner_1.executeCommand; } });
+Object.defineProperty(exports, "normalizeCommandPath", { enumerable: true, get: function () { return command_runner_1.normalizeCommandPath; } });

package/dist/commands/mapped.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMappedFunction = findMappedFunction;
+exports.listMappedCommandsForRoot = listMappedCommandsForRoot;
+exports.runMappedDomainCommand = runMappedDomainCommand;
+const errors_1 = require("../errors");
+const onchain_1 = require("./onchain");
+const MAPPED_WRITE_COMMANDS = {
+    "lending create": "addGotchiLending",
+    "lending agree": "agreeGotchiLending",
+    "token approve": "approve",
+    "gotchi xp claim-batch": "batchDropClaimXPDrop",
+    "baazaar listing batch-execute": "batchExecuteERC1155Listing",
+    "realm harvest batch": "batchHarvest",
+    "token bridge": "bridge",
+    "baazaar buy-now": "buyNow",
+    "auction buy-now": "buyNow",
+    "auction cancel": "cancelAuction",
+    "baazaar cancel-erc1155": "cancelERC1155Listing",
+    "baazaar cancel-erc721": "cancelERC721Listing",
+    "lending cancel": "cancelGotchiLending",
+    "forge claim": "claim",
+    "portal claim": "claimAavegotchi",
+    "lending claim-end": "claimAndEndGotchiLending",
+    "forge queue claim": "claimForgeQueueItems",
+    "auction bid": "commitBid",
+    "gotchi-points convert-alchemica": "convertAlchemica",
+    "auction create": "createAuction",
+    "lending whitelist create": "createWhitelist",
+    "staking unstake-destroy": "decreaseAndDestroy",
+    "staking enter-underlying": "enterWithUnderlying",
+    "gotchi equip-delegated": "equipDelegatedWearables",
+    "forge craft": "forgeWearables",
+    "staking leave-underlying": "leaveToUnderlying",
+    "portal open": "openPortals",
+    "forge speedup": "reduceQueueTime",
+    "inventory transfer": "safeTransferFrom",
+    "token set-approval-for-all": "setApprovalForAll",
+    "forge smelt": "smeltWearables",
+    "gotchi spend-skill-points": "spendSkillPoints",
+    "baazaar swap-buy-now": "swapAndBuyNow",
+    "auction swap-bid": "swapAndCommitBid",
+    "lending transfer-escrow": "transferEscrow",
+    "baazaar update-erc1155": "updateERC1155ListingPriceAndQuantity",
+    "lending whitelist update": "updateWhitelist",
+    "gotchi feed": "useConsumables",
+    "staking withdraw-pool": "withdrawFromPool",
+};
+function findMappedFunction(commandPath) {
+    const key = commandPath.join(" ");
+    return MAPPED_WRITE_COMMANDS[key];
+}
+function listMappedCommandsForRoot(root) {
+    return Object.keys(MAPPED_WRITE_COMMANDS).filter((entry) => entry.startsWith(`${root} `));
+}
+async function runMappedDomainCommand(ctx) {
+    const key = ctx.commandPath.join(" ");
+    const method = MAPPED_WRITE_COMMANDS[key];
+    if (!method) {
+        const candidates = listMappedCommandsForRoot(ctx.commandPath[0]);
+        throw new errors_1.CliError("COMMAND_NOT_IMPLEMENTED", `Mapped command '${key}' is not defined.`, 2, {
+            command: key,
+            availableForRoot: candidates,
+        });
+    }
+    const result = await (0, onchain_1.runOnchainSendWithFunction)(ctx, method, key);
+    return {
+        mappedMethod: method,
+        result,
+    };
+}

package/dist/commands/onchain.js

@@ -0,0 +1,215 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOnchainCallCommand = runOnchainCallCommand;
+exports.runOnchainSendWithFunction = runOnchainSendWithFunction;
+exports.runOnchainSendCommand = runOnchainSendCommand;
+const fs = __importStar(require("fs"));
+const viem_1 = require("viem");
+const args_1 = require("../args");
+const chains_1 = require("../chains");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const rpc_1 = require("../rpc");
+const tx_engine_1 = require("../tx-engine");
+function requireFlag(value, name) {
+    if (!value) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", `${name} is required.`, 2);
+    }
+    return value;
+}
+function parseArgsJson(value) {
+    if (!value) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--args-json must be valid JSON.", 2);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--args-json must be a JSON array.", 2);
+    }
+    return parsed;
+}
+function parseAbiFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new errors_1.CliError("ABI_NOT_FOUND", `ABI file not found: ${filePath}`, 2);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        throw new errors_1.CliError("INVALID_ABI", `ABI file is not valid JSON: ${filePath}`, 2);
+    }
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (typeof parsed === "object" && parsed !== null && "abi" in parsed && Array.isArray(parsed.abi)) {
+        return parsed.abi;
+    }
+    throw new errors_1.CliError("INVALID_ABI", `ABI file must be an array or object containing 'abi'.`, 2);
+}
+function parseValueWei(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (!/^\d+$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--value-wei must be an integer string.", 2, {
+            value,
+        });
+    }
+    return BigInt(value);
+}
+function parseTimeoutMs(value) {
+    if (!value) {
+        return 120000;
+    }
+    const timeout = Number(value);
+    if (!Number.isInteger(timeout) || timeout <= 0) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--timeout-ms must be a positive integer.", 2, {
+            value,
+        });
+    }
+    return timeout;
+}
+function parseAddress(value, flagName) {
+    if (!value || !/^0x[a-fA-F0-9]{40}$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${flagName} must be an EVM address.`, 2, {
+            value,
+        });
+    }
+    return value.toLowerCase();
+}
+async function runOnchainCallCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const profileName = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    const profile = (0, config_1.getProfileOrThrow)(config, profileName);
+    const chain = (0, chains_1.resolveChain)(profile.chain);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, (0, args_1.getFlagString)(ctx.args.flags, "rpc-url") || profile.rpcUrl);
+    const abiFile = requireFlag((0, args_1.getFlagString)(ctx.args.flags, "abi-file"), "--abi-file");
+    const abi = parseAbiFile(abiFile);
+    const address = parseAddress((0, args_1.getFlagString)(ctx.args.flags, "address"), "--address");
+    const functionName = requireFlag((0, args_1.getFlagString)(ctx.args.flags, "function"), "--function");
+    const args = parseArgsJson((0, args_1.getFlagString)(ctx.args.flags, "args-json"));
+    const preflight = await (0, rpc_1.runRpcPreflight)(chain, rpcUrl);
+    const calldata = (0, viem_1.encodeFunctionData)({
+        abi,
+        functionName,
+        args,
+    });
+    const callResult = await preflight.client.call({
+        to: address,
+        data: calldata,
+    });
+    if (!callResult.data) {
+        throw new errors_1.CliError("EMPTY_CALL_RESULT", "Call returned no data.", 2);
+    }
+    const decoded = (0, viem_1.decodeFunctionResult)({
+        abi,
+        functionName,
+        data: callResult.data,
+    });
+    return {
+        chainId: chain.chainId,
+        rpcUrl,
+        address,
+        functionName,
+        args,
+        result: decoded,
+    };
+}
+async function runOnchainSendWithFunction(ctx, forcedFunctionName, commandOverride) {
+    const config = (0, config_1.loadConfig)();
+    const profileName = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    const profile = (0, config_1.getProfileOrThrow)(config, profileName);
+    const policy = (0, config_1.getPolicyOrThrow)(config, profile.policy);
+    const chain = (0, chains_1.resolveChain)(profile.chain);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, (0, args_1.getFlagString)(ctx.args.flags, "rpc-url") || profile.rpcUrl);
+    const abiFile = requireFlag((0, args_1.getFlagString)(ctx.args.flags, "abi-file"), "--abi-file");
+    const abi = parseAbiFile(abiFile);
+    const address = parseAddress((0, args_1.getFlagString)(ctx.args.flags, "address"), "--address");
+    const functionName = forcedFunctionName || requireFlag((0, args_1.getFlagString)(ctx.args.flags, "function"), "--function");
+    const args = parseArgsJson((0, args_1.getFlagString)(ctx.args.flags, "args-json"));
+    const valueWei = parseValueWei((0, args_1.getFlagString)(ctx.args.flags, "value-wei"));
+    const data = (0, viem_1.encodeFunctionData)({
+        abi,
+        functionName,
+        args,
+    });
+    const noncePolicyRaw = (0, args_1.getFlagString)(ctx.args.flags, "nonce-policy") || "safe";
+    if (!["safe", "replace", "manual"].includes(noncePolicyRaw)) {
+        throw new errors_1.CliError("INVALID_NONCE_POLICY", `Unsupported nonce policy '${noncePolicyRaw}'.`, 2);
+    }
+    const nonceRaw = (0, args_1.getFlagString)(ctx.args.flags, "nonce");
+    const nonce = nonceRaw ? Number(nonceRaw) : undefined;
+    if (nonceRaw && (!Number.isInteger(nonce) || (nonce !== undefined && nonce < 0))) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--nonce must be a non-negative integer.", 2, {
+            value: nonceRaw,
+        });
+    }
+    const waitForReceipt = (0, args_1.getFlagBoolean)(ctx.args.flags, "wait");
+    const intent = {
+        idempotencyKey: (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key"),
+        profileName: profile.name,
+        chainId: profile.chainId,
+        rpcUrl,
+        signer: profile.signer,
+        policy,
+        to: address,
+        data,
+        valueWei,
+        noncePolicy: noncePolicyRaw,
+        nonce,
+        waitForReceipt,
+        timeoutMs: parseTimeoutMs((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms")),
+        command: commandOverride || `onchain send ${functionName}`,
+    };
+    const result = await (0, tx_engine_1.executeTxIntent)(intent, chain);
+    return {
+        profile: profile.name,
+        chainId: chain.chainId,
+        address,
+        functionName,
+        args,
+        result,
+    };
+}
+async function runOnchainSendCommand(ctx) {
+    return runOnchainSendWithFunction(ctx);
+}

package/dist/commands/policy.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPolicyListCommand = runPolicyListCommand;
+exports.runPolicyShowCommand = runPolicyShowCommand;
+exports.runPolicyUpsertCommand = runPolicyUpsertCommand;
+const args_1 = require("../args");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+function parseIntegerString(value, flag) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!/^\d+$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${flag} must be an integer string.`, 2, {
+            value,
+        });
+    }
+    return value;
+}
+function parseAllowlist(value) {
+    if (!value) {
+        return undefined;
+    }
+    const addresses = value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => entry.toLowerCase());
+    if (addresses.some((entry) => !/^0x[a-f0-9]{40}$/.test(entry))) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--allowed-to expects comma-separated EVM addresses.", 2);
+    }
+    return addresses;
+}
+async function runPolicyListCommand() {
+    const config = (0, config_1.loadConfig)();
+    return {
+        policies: Object.values(config.policies).sort((a, b) => a.name.localeCompare(b.name)),
+    };
+}
+async function runPolicyShowCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const policyName = (0, args_1.getFlagString)(ctx.args.flags, "policy") || "default";
+    const policy = config.policies[policyName];
+    if (!policy) {
+        throw new errors_1.CliError("POLICY_NOT_FOUND", `Policy '${policyName}' does not exist.`, 2);
+    }
+    return {
+        policy,
+    };
+}
+async function runPolicyUpsertCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const policyName = (0, args_1.getFlagString)(ctx.args.flags, "policy") || "default";
+    const timestamp = new Date().toISOString();
+    const existing = config.policies[policyName] || (0, config_1.createDefaultPolicy)(policyName, timestamp);
+    const updated = {
+        ...existing,
+        name: policyName,
+        maxValueWei: parseIntegerString((0, args_1.getFlagString)(ctx.args.flags, "max-value-wei"), "--max-value-wei") ?? existing.maxValueWei,
+        maxGasLimit: parseIntegerString((0, args_1.getFlagString)(ctx.args.flags, "max-gas-limit"), "--max-gas-limit") ?? existing.maxGasLimit,
+        maxFeePerGasWei: parseIntegerString((0, args_1.getFlagString)(ctx.args.flags, "max-fee-per-gas-wei"), "--max-fee-per-gas-wei") ??
+            existing.maxFeePerGasWei,
+        maxPriorityFeePerGasWei: parseIntegerString((0, args_1.getFlagString)(ctx.args.flags, "max-priority-fee-per-gas-wei"), "--max-priority-fee-per-gas-wei") ??
+            existing.maxPriorityFeePerGasWei,
+        allowedTo: parseAllowlist((0, args_1.getFlagString)(ctx.args.flags, "allowed-to")) ?? existing.allowedTo,
+        updatedAt: timestamp,
+    };
+    const merged = (0, config_1.upsertPolicy)(config, updated);
+    const configPath = (0, config_1.saveConfig)(merged);
+    return {
+        message: `Policy '${policyName}' updated.`,
+        policy: updated,
+        configPath,
+    };
+}

package/dist/commands/profile.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProfileListCommand = runProfileListCommand;
+exports.runProfileShowCommand = runProfileShowCommand;
+exports.runProfileUseCommand = runProfileUseCommand;
+exports.runProfileExportCommand = runProfileExportCommand;
+const args_1 = require("../args");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+function resolveProfileSelection(ctx) {
+    return (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+}
+async function runProfileListCommand() {
+    const config = (0, config_1.loadConfig)();
+    const profiles = Object.values(config.profiles)
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((profile) => ({
+        name: profile.name,
+        chain: profile.chain,
+        chainId: profile.chainId,
+        rpcUrl: profile.rpcUrl,
+        policy: profile.policy,
+        signerType: profile.signer.type,
+        active: config.activeProfile === profile.name,
+        updatedAt: profile.updatedAt,
+    }));
+    return {
+        activeProfile: config.activeProfile || null,
+        profiles,
+    };
+}
+async function runProfileShowCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const requestedProfile = resolveProfileSelection(ctx);
+    const profile = (0, config_1.getProfileOrThrow)(config, requestedProfile);
+    const policy = (0, config_1.getPolicyOrThrow)(config, profile.policy);
+    return {
+        activeProfile: config.activeProfile || null,
+        profile,
+        policy,
+    };
+}
+async function runProfileUseCommand(ctx) {
+    const selectedProfile = resolveProfileSelection(ctx);
+    if (!selectedProfile) {
+        throw new errors_1.CliError("MISSING_PROFILE", "profile use requires --profile <name>.", 2);
+    }
+    const config = (0, config_1.loadConfig)();
+    const updated = (0, config_1.setActiveProfile)(config, selectedProfile);
+    const configPath = (0, config_1.saveConfig)(updated);
+    return {
+        message: `Active profile set to '${selectedProfile}'.`,
+        activeProfile: selectedProfile,
+        configPath,
+    };
+}
+async function runProfileExportCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const requestedProfile = resolveProfileSelection(ctx);
+    const profile = (0, config_1.getProfileOrThrow)(config, requestedProfile);
+    const policy = (0, config_1.getPolicyOrThrow)(config, profile.policy);
+    return {
+        exportedAt: new Date().toISOString(),
+        profile,
+        policy,
+    };
+}

package/dist/commands/rpc.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRpcCheckCommand = runRpcCheckCommand;
+const args_1 = require("../args");
+const chains_1 = require("../chains");
+const config_1 = require("../config");
+const rpc_1 = require("../rpc");
+const signer_1 = require("../signer");
+async function runRpcCheckCommand(ctx) {
+    const profileName = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    const skipSignerCheck = (0, args_1.getFlagBoolean)(ctx.args.flags, "skip-signer-check");
+    const config = (0, config_1.loadConfig)();
+    const profile = (0, config_1.getProfileOrThrow)(config, profileName);
+    const chain = (0, chains_1.resolveChain)(profile.chain);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, (0, args_1.getFlagString)(ctx.args.flags, "rpc-url") || profile.rpcUrl);
+    const preflight = await (0, rpc_1.runRpcPreflight)(chain, rpcUrl);
+    const signer = skipSignerCheck
+        ? { signerType: profile.signer.type, backendStatus: "not-checked", canSign: false }
+        : (await (0, signer_1.resolveSignerRuntime)(profile.signer, preflight.client, rpcUrl, (0, chains_1.toViemChain)(chain, rpcUrl))).summary;
+    return {
+        profile: profile.name,
+        chain: profile.chain,
+        chainId: preflight.chainId,
+        chainName: preflight.chainName,
+        blockNumber: preflight.blockNumber,
+        rpcUrl,
+        signer,
+    };
+}

package/dist/commands/signer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSignerCheckCommand = runSignerCheckCommand;
+exports.runSignerKeychainImportCommand = runSignerKeychainImportCommand;
+exports.runSignerKeychainListCommand = runSignerKeychainListCommand;
+exports.runSignerKeychainRemoveCommand = runSignerKeychainRemoveCommand;
+const args_1 = require("../args");
+const chains_1 = require("../chains");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const keychain_1 = require("../keychain");
+const rpc_1 = require("../rpc");
+const signer_1 = require("../signer");
+async function runSignerCheckCommand(ctx) {
+    const config = (0, config_1.loadConfig)();
+    const profileName = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    const profile = (0, config_1.getProfileOrThrow)(config, profileName);
+    const chain = (0, chains_1.resolveChain)(profile.chain);
+    const rpcUrl = (0, chains_1.resolveRpcUrl)(chain, (0, args_1.getFlagString)(ctx.args.flags, "rpc-url") || profile.rpcUrl);
+    const preflight = await (0, rpc_1.runRpcPreflight)(chain, rpcUrl);
+    const runtime = await (0, signer_1.resolveSignerRuntime)(profile.signer, preflight.client, rpcUrl, (0, chains_1.toViemChain)(chain, rpcUrl));
+    return {
+        profile: profile.name,
+        chainId: chain.chainId,
+        signer: runtime.summary,
+    };
+}
+async function runSignerKeychainImportCommand(ctx) {
+    const accountId = (0, args_1.getFlagString)(ctx.args.flags, "account-id");
+    const privateKeyEnv = (0, args_1.getFlagString)(ctx.args.flags, "private-key-env") || "AGCLI_PRIVATE_KEY";
+    if (!accountId) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", "signer keychain import requires --account-id.", 2);
+    }
+    const imported = (0, keychain_1.keychainImportFromEnv)(accountId, privateKeyEnv);
+    return {
+        message: `Imported keychain entry '${imported.accountId}'.`,
+        ...imported,
+    };
+}
+async function runSignerKeychainListCommand() {
+    return {
+        entries: (0, keychain_1.keychainList)(),
+    };
+}
+async function runSignerKeychainRemoveCommand(ctx) {
+    const accountId = (0, args_1.getFlagString)(ctx.args.flags, "account-id");
+    if (!accountId) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", "signer keychain remove requires --account-id.", 2);
+    }
+    return (0, keychain_1.keychainRemove)(accountId);
+}

package/dist/commands/stubs.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDomainStubRoot = isDomainStubRoot;
+exports.runDomainStubCommand = runDomainStubCommand;
+const errors_1 = require("../errors");
+const SUPPORTED_STUB_ROOTS = [
+    "gotchi",
+    "portal",
+    "wearables",
+    "items",
+    "inventory",
+    "baazaar",
+    "auction",
+    "lending",
+    "staking",
+    "gotchi-points",
+    "realm",
+    "alchemica",
+    "forge",
+    "token",
+];
+function isDomainStubRoot(root) {
+    return SUPPORTED_STUB_ROOTS.includes(root);
+}
+async function runDomainStubCommand(ctx) {
+    const command = ctx.commandPath.join(" ");
+    throw new errors_1.CliError("COMMAND_NOT_IMPLEMENTED", `Command '${command}' is planned but not implemented yet.`, 2, {
+        command,
+        hint: "If this is a mapped onchain write, pass full subcommand plus --abi-file/--address/--args-json.",
+        plannedRoots: SUPPORTED_STUB_ROOTS,
+    });
+}