aavegotchi-cli 0.1.0

package/dist/journal.js

@@ -0,0 +1,377 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JournalStore = void 0;
+const fs = __importStar(require("fs"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+function mapRow(row) {
+    return {
+        id: Number(row.id),
+        idempotencyKey: String(row.idempotency_key),
+        profileName: String(row.profile_name),
+        chainId: Number(row.chain_id),
+        command: String(row.command),
+        toAddress: String(row.to_address),
+        fromAddress: String(row.from_address),
+        valueWei: String(row.value_wei),
+        dataHex: String(row.data_hex),
+        nonce: Number(row.nonce),
+        gasLimit: String(row.gas_limit),
+        maxFeePerGasWei: String(row.max_fee_per_gas_wei),
+        maxPriorityFeePerGasWei: String(row.max_priority_fee_per_gas_wei),
+        txHash: String(row.tx_hash),
+        status: String(row.status),
+        errorCode: String(row.error_code),
+        errorMessage: String(row.error_message),
+        receiptJson: String(row.receipt_json),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function clone(entry) {
+    return JSON.parse(JSON.stringify(entry));
+}
+function createEntry(id, params, timestamp) {
+    return {
+        id,
+        idempotencyKey: params.idempotencyKey,
+        profileName: params.profileName,
+        chainId: params.chainId,
+        command: params.command,
+        toAddress: params.toAddress,
+        fromAddress: params.fromAddress,
+        valueWei: params.valueWei,
+        dataHex: params.dataHex,
+        nonce: params.nonce,
+        gasLimit: params.gasLimit,
+        maxFeePerGasWei: params.maxFeePerGasWei,
+        maxPriorityFeePerGasWei: params.maxPriorityFeePerGasWei,
+        txHash: "",
+        status: params.status,
+        errorCode: "",
+        errorMessage: "",
+        receiptJson: "",
+        createdAt: timestamp,
+        updatedAt: timestamp,
+    };
+}
+class JournalStore {
+    dbPath;
+    fallbackPath;
+    db;
+    fallback = { nextId: 1, entries: [] };
+    constructor(path) {
+        this.dbPath = path;
+        this.fallbackPath = `${path}.json`;
+        try {
+            this.db = new better_sqlite3_1.default(path);
+            this.db.pragma("journal_mode = WAL");
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tx_journal (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          idempotency_key TEXT NOT NULL UNIQUE,
+          profile_name TEXT NOT NULL,
+          chain_id INTEGER NOT NULL,
+          command TEXT NOT NULL,
+          to_address TEXT NOT NULL,
+          from_address TEXT NOT NULL DEFAULT '',
+          value_wei TEXT NOT NULL DEFAULT '0',
+          data_hex TEXT NOT NULL DEFAULT '0x',
+          nonce INTEGER NOT NULL DEFAULT -1,
+          gas_limit TEXT NOT NULL DEFAULT '',
+          max_fee_per_gas_wei TEXT NOT NULL DEFAULT '',
+          max_priority_fee_per_gas_wei TEXT NOT NULL DEFAULT '',
+          tx_hash TEXT NOT NULL DEFAULT '',
+          status TEXT NOT NULL,
+          error_code TEXT NOT NULL DEFAULT '',
+          error_message TEXT NOT NULL DEFAULT '',
+          receipt_json TEXT NOT NULL DEFAULT '',
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_tx_journal_tx_hash ON tx_journal(tx_hash);
+        CREATE INDEX IF NOT EXISTS idx_tx_journal_status ON tx_journal(status);
+      `);
+        }
+        catch {
+            this.db = undefined;
+            this.loadFallback();
+        }
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+        }
+    }
+    loadFallback() {
+        if (!fs.existsSync(this.fallbackPath)) {
+            this.fallback = { nextId: 1, entries: [] };
+            return;
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.fallbackPath, "utf8"));
+            this.fallback = parsed;
+        }
+        catch {
+            this.fallback = { nextId: 1, entries: [] };
+        }
+    }
+    saveFallback() {
+        fs.writeFileSync(this.fallbackPath, `${JSON.stringify(this.fallback, null, 2)}\n`, "utf8");
+    }
+    getByIdempotencyKeyFallback(idempotencyKey) {
+        const found = this.fallback.entries.find((entry) => entry.idempotencyKey === idempotencyKey);
+        return found ? clone(found) : undefined;
+    }
+    getByTxHashFallback(txHash) {
+        const found = this.fallback.entries.find((entry) => entry.txHash === txHash);
+        return found ? clone(found) : undefined;
+    }
+    upsertPrepared(params) {
+        const timestamp = new Date().toISOString();
+        if (!this.db) {
+            const existingIndex = this.fallback.entries.findIndex((entry) => entry.idempotencyKey === params.idempotencyKey);
+            if (existingIndex >= 0) {
+                const existing = this.fallback.entries[existingIndex];
+                this.fallback.entries[existingIndex] = {
+                    ...existing,
+                    ...createEntry(existing.id, params, existing.createdAt),
+                    createdAt: existing.createdAt,
+                    updatedAt: timestamp,
+                };
+            }
+            else {
+                this.fallback.entries.push(createEntry(this.fallback.nextId++, params, timestamp));
+            }
+            this.saveFallback();
+            return this.getByIdempotencyKeyFallback(params.idempotencyKey);
+        }
+        const statement = this.db.prepare(`
+      INSERT INTO tx_journal (
+        idempotency_key,
+        profile_name,
+        chain_id,
+        command,
+        to_address,
+        from_address,
+        value_wei,
+        data_hex,
+        nonce,
+        gas_limit,
+        max_fee_per_gas_wei,
+        max_priority_fee_per_gas_wei,
+        status,
+        created_at,
+        updated_at
+      ) VALUES (
+        @idempotencyKey,
+        @profileName,
+        @chainId,
+        @command,
+        @toAddress,
+        @fromAddress,
+        @valueWei,
+        @dataHex,
+        @nonce,
+        @gasLimit,
+        @maxFeePerGasWei,
+        @maxPriorityFeePerGasWei,
+        @status,
+        @createdAt,
+        @updatedAt
+      )
+      ON CONFLICT(idempotency_key) DO UPDATE SET
+        profile_name = excluded.profile_name,
+        chain_id = excluded.chain_id,
+        command = excluded.command,
+        to_address = excluded.to_address,
+        from_address = excluded.from_address,
+        value_wei = excluded.value_wei,
+        data_hex = excluded.data_hex,
+        nonce = excluded.nonce,
+        gas_limit = excluded.gas_limit,
+        max_fee_per_gas_wei = excluded.max_fee_per_gas_wei,
+        max_priority_fee_per_gas_wei = excluded.max_priority_fee_per_gas_wei,
+        status = excluded.status,
+        updated_at = excluded.updated_at
+    `);
+        statement.run({
+            ...params,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        });
+        const entry = this.getByIdempotencyKey(params.idempotencyKey);
+        if (!entry) {
+            throw new Error("Journal write failed");
+        }
+        return entry;
+    }
+    markSubmitted(params) {
+        if (!this.db) {
+            const existing = this.fallback.entries.find((entry) => entry.idempotencyKey === params.idempotencyKey);
+            if (!existing) {
+                throw new Error("Journal update failed");
+            }
+            existing.txHash = params.txHash;
+            existing.status = params.status;
+            existing.errorCode = params.errorCode;
+            existing.errorMessage = params.errorMessage;
+            existing.updatedAt = new Date().toISOString();
+            this.saveFallback();
+            return clone(existing);
+        }
+        this.db
+            .prepare(`
+      UPDATE tx_journal
+      SET tx_hash = @txHash,
+          status = @status,
+          error_code = @errorCode,
+          error_message = @errorMessage,
+          updated_at = @updatedAt
+      WHERE idempotency_key = @idempotencyKey
+    `)
+            .run({
+            ...params,
+            updatedAt: new Date().toISOString(),
+        });
+        const entry = this.getByIdempotencyKey(params.idempotencyKey);
+        if (!entry) {
+            throw new Error("Journal update failed");
+        }
+        return entry;
+    }
+    markConfirmed(idempotencyKey, receiptJson) {
+        if (!this.db) {
+            const existing = this.fallback.entries.find((entry) => entry.idempotencyKey === idempotencyKey);
+            if (!existing) {
+                throw new Error("Journal confirmation update failed");
+            }
+            existing.status = "confirmed";
+            existing.receiptJson = receiptJson;
+            existing.updatedAt = new Date().toISOString();
+            this.saveFallback();
+            return clone(existing);
+        }
+        this.db
+            .prepare(`
+      UPDATE tx_journal
+      SET status = 'confirmed',
+          receipt_json = @receiptJson,
+          updated_at = @updatedAt
+      WHERE idempotency_key = @idempotencyKey
+    `)
+            .run({
+            idempotencyKey,
+            receiptJson,
+            updatedAt: new Date().toISOString(),
+        });
+        const entry = this.getByIdempotencyKey(idempotencyKey);
+        if (!entry) {
+            throw new Error("Journal confirmation update failed");
+        }
+        return entry;
+    }
+    markFailed(idempotencyKey, errorCode, errorMessage) {
+        if (!this.db) {
+            const existing = this.fallback.entries.find((entry) => entry.idempotencyKey === idempotencyKey);
+            if (!existing) {
+                return undefined;
+            }
+            existing.status = "failed";
+            existing.errorCode = errorCode;
+            existing.errorMessage = errorMessage;
+            existing.updatedAt = new Date().toISOString();
+            this.saveFallback();
+            return clone(existing);
+        }
+        this.db
+            .prepare(`
+      UPDATE tx_journal
+      SET status = 'failed',
+          error_code = @errorCode,
+          error_message = @errorMessage,
+          updated_at = @updatedAt
+      WHERE idempotency_key = @idempotencyKey
+    `)
+            .run({
+            idempotencyKey,
+            errorCode,
+            errorMessage,
+            updatedAt: new Date().toISOString(),
+        });
+        return this.getByIdempotencyKey(idempotencyKey);
+    }
+    getByIdempotencyKey(idempotencyKey) {
+        if (!this.db) {
+            return this.getByIdempotencyKeyFallback(idempotencyKey);
+        }
+        const row = this.db
+            .prepare("SELECT * FROM tx_journal WHERE idempotency_key = ? LIMIT 1")
+            .get(idempotencyKey);
+        if (!row) {
+            return undefined;
+        }
+        return mapRow(row);
+    }
+    getByTxHash(txHash) {
+        if (!this.db) {
+            return this.getByTxHashFallback(txHash);
+        }
+        const row = this.db
+            .prepare("SELECT * FROM tx_journal WHERE tx_hash = ? LIMIT 1")
+            .get(txHash);
+        if (!row) {
+            return undefined;
+        }
+        return mapRow(row);
+    }
+    listRecent(limit = 20) {
+        if (!this.db) {
+            return this.fallback.entries
+                .slice()
+                .sort((a, b) => b.id - a.id)
+                .slice(0, limit)
+                .map((entry) => clone(entry));
+        }
+        const rows = this.db
+            .prepare("SELECT * FROM tx_journal ORDER BY id DESC LIMIT ?")
+            .all(limit);
+        return rows.map((row) => mapRow(row));
+    }
+}
+exports.JournalStore = JournalStore;

package/dist/keychain.js

@@ -0,0 +1,198 @@
+"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.keychainImportFromEnv = keychainImportFromEnv;
+exports.keychainList = keychainList;
+exports.keychainRemove = keychainRemove;
+exports.keychainResolvePrivateKey = keychainResolvePrivateKey;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const accounts_1 = require("viem/accounts");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+function nowIso() {
+    return new Date().toISOString();
+}
+function createDefaultFile() {
+    return {
+        schemaVersion: 1,
+        entries: {},
+    };
+}
+function getPassphrase() {
+    const value = process.env.AGCLI_KEYCHAIN_PASSPHRASE;
+    if (!value || value.length < 8) {
+        throw new errors_1.CliError("MISSING_KEYCHAIN_PASSPHRASE", "Set AGCLI_KEYCHAIN_PASSPHRASE (8+ chars) to use keychain signer backend.", 2);
+    }
+    return value;
+}
+function deriveKey(passphrase, saltHex) {
+    return crypto.scryptSync(passphrase, Buffer.from(saltHex, "hex"), 32);
+}
+function encryptPrivateKey(privateKey, passphrase) {
+    const iv = crypto.randomBytes(12);
+    const salt = crypto.randomBytes(16);
+    const key = deriveKey(passphrase, salt.toString("hex"));
+    const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+    const ciphertext = Buffer.concat([cipher.update(privateKey, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+        ivHex: iv.toString("hex"),
+        saltHex: salt.toString("hex"),
+        tagHex: tag.toString("hex"),
+        ciphertextHex: ciphertext.toString("hex"),
+    };
+}
+function decryptPrivateKey(entry, passphrase) {
+    const key = deriveKey(passphrase, entry.saltHex);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(entry.ivHex, "hex"));
+    decipher.setAuthTag(Buffer.from(entry.tagHex, "hex"));
+    const plaintext = Buffer.concat([
+        decipher.update(Buffer.from(entry.ciphertextHex, "hex")),
+        decipher.final(),
+    ]).toString("utf8");
+    if (!/^0x[0-9a-fA-F]{64}$/.test(plaintext)) {
+        throw new errors_1.CliError("INVALID_PRIVATE_KEY", "Decrypted keychain secret is not a valid private key.", 2);
+    }
+    return plaintext;
+}
+function loadKeychainFile(customHome) {
+    const keychainPath = (0, config_1.resolveKeychainPath)(customHome);
+    if (!fs.existsSync(keychainPath)) {
+        return createDefaultFile();
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(keychainPath, "utf8"));
+    }
+    catch {
+        throw new errors_1.CliError("INVALID_KEYCHAIN", `Keychain file is not valid JSON: ${keychainPath}`, 2);
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        parsed.schemaVersion !== 1 ||
+        typeof parsed.entries !== "object") {
+        throw new errors_1.CliError("INVALID_KEYCHAIN", `Unsupported keychain format: ${keychainPath}`, 2);
+    }
+    return parsed;
+}
+function saveKeychainFile(file, customHome) {
+    const home = (0, config_1.resolveAgcliHome)(customHome);
+    const keychainPath = (0, config_1.resolveKeychainPath)(customHome);
+    fs.mkdirSync(home, { recursive: true });
+    const tmpPath = `${keychainPath}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(file, null, 2)}\n`, "utf8");
+    fs.renameSync(tmpPath, keychainPath);
+    return keychainPath;
+}
+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);
+    }
+    return value;
+}
+function keychainImportFromEnv(accountId, envVar, customHome) {
+    if (!/^[A-Za-z0-9._-]+$/.test(accountId)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "account-id may only contain letters, numbers, dot, underscore, dash.", 2);
+    }
+    if (!/^[A-Z_][A-Z0-9_]*$/.test(envVar)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "private-key-env must be an uppercase env var name.", 2);
+    }
+    const privateKeyRaw = process.env[envVar];
+    if (!privateKeyRaw) {
+        throw new errors_1.CliError("MISSING_SIGNER_SECRET", `Missing environment variable '${envVar}'.`, 2);
+    }
+    const privateKey = parsePrivateKey(privateKeyRaw, `Environment variable '${envVar}'`);
+    const account = (0, accounts_1.privateKeyToAccount)(privateKey);
+    const address = account.address.toLowerCase();
+    const passphrase = getPassphrase();
+    const encrypted = encryptPrivateKey(privateKey, passphrase);
+    const file = loadKeychainFile(customHome);
+    const existing = file.entries[accountId];
+    const timestamp = nowIso();
+    file.entries[accountId] = {
+        accountId,
+        address,
+        ...encrypted,
+        createdAt: existing?.createdAt || timestamp,
+        updatedAt: timestamp,
+    };
+    const keychainPath = saveKeychainFile(file, customHome);
+    return {
+        accountId,
+        address,
+        keychainPath,
+    };
+}
+function keychainList(customHome) {
+    const file = loadKeychainFile(customHome);
+    return Object.values(file.entries)
+        .sort((a, b) => a.accountId.localeCompare(b.accountId))
+        .map((entry) => ({
+        accountId: entry.accountId,
+        address: entry.address,
+        updatedAt: entry.updatedAt,
+    }));
+}
+function keychainRemove(accountId, customHome) {
+    const file = loadKeychainFile(customHome);
+    const removed = Boolean(file.entries[accountId]);
+    if (removed) {
+        delete file.entries[accountId];
+    }
+    const keychainPath = saveKeychainFile(file, customHome);
+    return {
+        accountId,
+        removed,
+        keychainPath,
+    };
+}
+function keychainResolvePrivateKey(accountId, customHome) {
+    const file = loadKeychainFile(customHome);
+    const entry = file.entries[accountId];
+    if (!entry) {
+        throw new errors_1.CliError("KEYCHAIN_ENTRY_NOT_FOUND", `No keychain entry for '${accountId}'.`, 2);
+    }
+    const passphrase = getPassphrase();
+    const privateKey = decryptPrivateKey(entry, passphrase);
+    const account = (0, accounts_1.privateKeyToAccount)(privateKey);
+    if (account.address.toLowerCase() !== entry.address.toLowerCase()) {
+        throw new errors_1.CliError("KEYCHAIN_ADDRESS_MISMATCH", `Decrypted key does not match stored address for '${accountId}'.`, 2);
+    }
+    return {
+        privateKey,
+        address: entry.address.toLowerCase(),
+    };
+}

package/dist/logger.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeLogger = initializeLogger;
+exports.getLogger = getLogger;
+const pino_1 = __importDefault(require("pino"));
+let cached = (0, pino_1.default)({ level: "silent" });
+function initializeLogger(globals) {
+    const level = process.env.AGCLI_LOG_LEVEL || (globals.mode === "agent" ? "warn" : "info");
+    cached = (0, pino_1.default)({
+        level,
+        base: undefined,
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    });
+}
+function getLogger() {
+    return cached;
+}