aavegotchi-cli 0.1.0 → 0.2.1

package/dist/commands/baazaar-subgraph.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBaazaarListingGetSubgraphCommand = runBaazaarListingGetSubgraphCommand;
+exports.runBaazaarListingActiveSubgraphCommand = runBaazaarListingActiveSubgraphCommand;
+exports.runBaazaarListingMineSubgraphCommand = runBaazaarListingMineSubgraphCommand;
+exports.runBaazaarListingSubgraphCommand = runBaazaarListingSubgraphCommand;
+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 normalize_1 = require("../subgraph/normalize");
+const queries_1 = require("../subgraph/queries");
+const sources_1 = require("../subgraph/sources");
+const client_1 = require("../subgraph/client");
+const DEFAULT_FIRST = 20;
+const MAX_FIRST = 200;
+const DEFAULT_SKIP = 0;
+const MAX_SKIP = 100000;
+const BAAZAAR_VERIFY_ABI = (0, viem_1.parseAbi)([
+    "function getERC721Listing(uint256 _listingId) view returns ((uint256 listingId,address seller,address erc721TokenAddress,uint256 erc721TokenId,uint256 category,uint256 priceInWei,uint256 timeCreated,uint256 timePurchased,bool cancelled,uint16[2] principalSplit,address affiliate,uint32 whitelistId))",
+    "function getERC1155Listing(uint256 _listingId) view returns ((uint256 listingId,address seller,address erc1155TokenAddress,uint256 erc1155TypeId,uint256 category,uint256 quantity,uint256 priceInWei,uint256 timeCreated,uint256 timeLastPurchased,uint256 sourceListingId,bool sold,bool cancelled,uint16[2] principalSplit,address affiliate,uint32 whitelistId))",
+]);
+function parseKind(value) {
+    if (!value) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", "--kind is required (erc721|erc1155).", 2);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "erc721" || normalized === "erc1155") {
+        return normalized;
+    }
+    throw new errors_1.CliError("INVALID_ARGUMENT", "--kind must be one of: erc721, erc1155.", 2, {
+        value,
+    });
+}
+function parseRawFlag(ctx) {
+    return (0, args_1.getFlagBoolean)(ctx.args.flags, "raw");
+}
+function parseTimeoutMs(value) {
+    if (!value) {
+        return undefined;
+    }
+    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 parseListingId(value, flagName) {
+    if (!value) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", `${flagName} is required.`, 2);
+    }
+    if (!/^\d+$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${flagName} must be an unsigned integer string.`, 2, {
+            value,
+        });
+    }
+    return value;
+}
+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 (0, normalize_1.toLowercaseAddress)(value);
+}
+function parseBoundedIntFlag(value, flagName, fallback, min, max) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${flagName} must be an integer between ${min} and ${max}.`, 2, {
+            value,
+        });
+    }
+    return parsed;
+}
+function parsePagination(ctx) {
+    const first = parseBoundedIntFlag((0, args_1.getFlagString)(ctx.args.flags, "first"), "--first", DEFAULT_FIRST, 1, MAX_FIRST);
+    const skip = parseBoundedIntFlag((0, args_1.getFlagString)(ctx.args.flags, "skip"), "--skip", DEFAULT_SKIP, 0, MAX_SKIP);
+    return {
+        first,
+        skip,
+    };
+}
+function parseCommonSubgraphOptions(ctx) {
+    const subgraphUrl = (0, args_1.getFlagString)(ctx.args.flags, "subgraph-url");
+    const allowUntrustedSubgraph = (0, args_1.getFlagBoolean)(ctx.args.flags, "allow-untrusted-subgraph");
+    if (allowUntrustedSubgraph && !subgraphUrl) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--allow-untrusted-subgraph requires --subgraph-url.", 2);
+    }
+    return {
+        source: "core-base",
+        timeoutMs: parseTimeoutMs((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms")),
+        authEnvVar: (0, args_1.getFlagString)(ctx.args.flags, "auth-env-var"),
+        subgraphUrl,
+        allowUntrustedSubgraph,
+    };
+}
+function parseVerifyOnchainFlag(ctx) {
+    return (0, args_1.getFlagBoolean)(ctx.args.flags, "verify-onchain");
+}
+function resolveReadRpcUrl(ctx) {
+    const explicitRpc = (0, args_1.getFlagString)(ctx.args.flags, "rpc-url");
+    if (explicitRpc) {
+        return explicitRpc;
+    }
+    const profileName = (0, args_1.getFlagString)(ctx.args.flags, "profile") || ctx.globals.profile;
+    if (profileName) {
+        const config = (0, config_1.loadConfig)();
+        const profile = (0, config_1.getProfileOrThrow)(config, profileName);
+        return profile.rpcUrl;
+    }
+    return (0, chains_1.resolveRpcUrl)((0, chains_1.resolveChain)("base"), undefined);
+}
+function createMismatchDiff(keys, subgraph, onchain) {
+    const diff = {};
+    for (const key of keys) {
+        if (subgraph[key] !== onchain[key]) {
+            diff[key] = {
+                subgraph: subgraph[key],
+                onchain: onchain[key],
+            };
+        }
+    }
+    return diff;
+}
+function withNormalizeContext(response, normalize) {
+    try {
+        return normalize();
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError && error.code === "SUBGRAPH_INVALID_RESPONSE") {
+            const extraDetails = error.details && typeof error.details === "object" ? error.details : {};
+            throw new errors_1.CliError(error.code, error.message, error.exitCode, {
+                source: response.source,
+                endpoint: response.endpoint,
+                queryName: response.queryName,
+                ...extraDetails,
+            });
+        }
+        throw error;
+    }
+}
+async function verifyErc721ListingOnchain(ctx, listing) {
+    const chain = (0, chains_1.resolveChain)("base");
+    const rpcUrl = resolveReadRpcUrl(ctx);
+    const preflight = await (0, rpc_1.runRpcPreflight)(chain, rpcUrl);
+    const onchainRaw = (await preflight.client.readContract({
+        address: sources_1.BASE_AAVEGOTCHI_DIAMOND,
+        abi: BAAZAAR_VERIFY_ABI,
+        functionName: "getERC721Listing",
+        args: [BigInt(listing.id)],
+    }));
+    const onchainProjection = {
+        id: onchainRaw.listingId.toString(),
+        seller: (0, normalize_1.toLowercaseAddress)(onchainRaw.seller),
+        erc721TokenAddress: (0, normalize_1.toLowercaseAddress)(onchainRaw.erc721TokenAddress),
+        tokenId: onchainRaw.erc721TokenId.toString(),
+        category: onchainRaw.category.toString(),
+        priceInWei: onchainRaw.priceInWei.toString(),
+        timeCreated: onchainRaw.timeCreated.toString(),
+        timePurchased: onchainRaw.timePurchased.toString(),
+        cancelled: onchainRaw.cancelled,
+    };
+    const subgraphProjection = {
+        id: listing.id,
+        seller: listing.seller,
+        erc721TokenAddress: listing.erc721TokenAddress,
+        tokenId: listing.tokenId,
+        category: listing.category,
+        priceInWei: listing.priceInWei,
+        timeCreated: listing.timeCreated,
+        timePurchased: listing.timePurchased,
+        cancelled: listing.cancelled,
+    };
+    const diff = createMismatchDiff(["id", "seller", "erc721TokenAddress", "tokenId", "category", "priceInWei", "timeCreated", "timePurchased", "cancelled"], subgraphProjection, onchainProjection);
+    if (Object.keys(diff).length > 0) {
+        throw new errors_1.CliError("SUBGRAPH_VERIFY_MISMATCH", "Subgraph listing does not match onchain snapshot.", 2, {
+            source: "core-base",
+            endpoint: "onchain-verify",
+            queryName: "baazaar.listing.get.erc721",
+            listingId: listing.id,
+            rpcUrl,
+            contractAddress: sources_1.BASE_AAVEGOTCHI_DIAMOND,
+            diff,
+        });
+    }
+    return {
+        verified: true,
+        rpcUrl,
+        chainId: preflight.chainId,
+        contractAddress: sources_1.BASE_AAVEGOTCHI_DIAMOND,
+    };
+}
+async function verifyErc1155ListingOnchain(ctx, listing) {
+    const chain = (0, chains_1.resolveChain)("base");
+    const rpcUrl = resolveReadRpcUrl(ctx);
+    const preflight = await (0, rpc_1.runRpcPreflight)(chain, rpcUrl);
+    const onchainRaw = (await preflight.client.readContract({
+        address: sources_1.BASE_AAVEGOTCHI_DIAMOND,
+        abi: BAAZAAR_VERIFY_ABI,
+        functionName: "getERC1155Listing",
+        args: [BigInt(listing.id)],
+    }));
+    const onchainProjection = {
+        id: onchainRaw.listingId.toString(),
+        seller: (0, normalize_1.toLowercaseAddress)(onchainRaw.seller),
+        erc1155TokenAddress: (0, normalize_1.toLowercaseAddress)(onchainRaw.erc1155TokenAddress),
+        erc1155TypeId: onchainRaw.erc1155TypeId.toString(),
+        category: onchainRaw.category.toString(),
+        quantity: onchainRaw.quantity.toString(),
+        priceInWei: onchainRaw.priceInWei.toString(),
+        timeCreated: onchainRaw.timeCreated.toString(),
+        sold: onchainRaw.sold,
+        cancelled: onchainRaw.cancelled,
+    };
+    const subgraphProjection = {
+        id: listing.id,
+        seller: listing.seller,
+        erc1155TokenAddress: listing.erc1155TokenAddress,
+        erc1155TypeId: listing.erc1155TypeId,
+        category: listing.category,
+        quantity: listing.quantity,
+        priceInWei: listing.priceInWei,
+        timeCreated: listing.timeCreated,
+        sold: listing.sold,
+        cancelled: listing.cancelled,
+    };
+    const diff = createMismatchDiff(["id", "seller", "erc1155TokenAddress", "erc1155TypeId", "category", "quantity", "priceInWei", "timeCreated", "sold", "cancelled"], subgraphProjection, onchainProjection);
+    if (Object.keys(diff).length > 0) {
+        throw new errors_1.CliError("SUBGRAPH_VERIFY_MISMATCH", "Subgraph listing does not match onchain snapshot.", 2, {
+            source: "core-base",
+            endpoint: "onchain-verify",
+            queryName: "baazaar.listing.get.erc1155",
+            listingId: listing.id,
+            rpcUrl,
+            contractAddress: sources_1.BASE_AAVEGOTCHI_DIAMOND,
+            diff,
+        });
+    }
+    return {
+        verified: true,
+        rpcUrl,
+        chainId: preflight.chainId,
+        contractAddress: sources_1.BASE_AAVEGOTCHI_DIAMOND,
+    };
+}
+async function runBaazaarListingGetSubgraphCommand(ctx) {
+    const kind = parseKind((0, args_1.getFlagString)(ctx.args.flags, "kind"));
+    const id = parseListingId((0, args_1.getFlagString)(ctx.args.flags, "id"), "--id");
+    const raw = parseRawFlag(ctx);
+    const verifyOnchain = parseVerifyOnchainFlag(ctx);
+    const common = parseCommonSubgraphOptions(ctx);
+    if (kind === "erc721") {
+        const response = await (0, client_1.executeSubgraphQuery)({
+            ...common,
+            queryName: "baazaar.listing.get.erc721",
+            query: queries_1.BAAZAAR_ERC721_LISTING_BY_ID_QUERY,
+            variables: { id },
+            raw,
+        });
+        const listing = response.data.erc721Listing
+            ? withNormalizeContext(response, () => (0, normalize_1.normalizeBaazaarErc721Listing)(response.data.erc721Listing))
+            : null;
+        const verification = verifyOnchain && listing ? await verifyErc721ListingOnchain(ctx, listing) : undefined;
+        return {
+            source: response.source,
+            endpoint: response.endpoint,
+            queryName: response.queryName,
+            listingKind: kind,
+            listing,
+            ...(verification ? { verification } : {}),
+            ...(raw ? { raw: response.raw } : {}),
+        };
+    }
+    const response = await (0, client_1.executeSubgraphQuery)({
+        ...common,
+        queryName: "baazaar.listing.get.erc1155",
+        query: queries_1.BAAZAAR_ERC1155_LISTING_BY_ID_QUERY,
+        variables: { id },
+        raw,
+    });
+    const listing = response.data.erc1155Listing
+        ? withNormalizeContext(response, () => (0, normalize_1.normalizeBaazaarErc1155Listing)(response.data.erc1155Listing))
+        : null;
+    const verification = verifyOnchain && listing ? await verifyErc1155ListingOnchain(ctx, listing) : undefined;
+    return {
+        source: response.source,
+        endpoint: response.endpoint,
+        queryName: response.queryName,
+        listingKind: kind,
+        listing,
+        ...(verification ? { verification } : {}),
+        ...(raw ? { raw: response.raw } : {}),
+    };
+}
+async function runBaazaarListingActiveSubgraphCommand(ctx) {
+    const kind = parseKind((0, args_1.getFlagString)(ctx.args.flags, "kind"));
+    const pagination = parsePagination(ctx);
+    const raw = parseRawFlag(ctx);
+    const common = parseCommonSubgraphOptions(ctx);
+    if (kind === "erc721") {
+        const response = await (0, client_1.executeSubgraphQuery)({
+            ...common,
+            queryName: "baazaar.listing.active.erc721",
+            query: queries_1.BAAZAAR_ACTIVE_ERC721_QUERY,
+            variables: pagination,
+            raw,
+        });
+        if (!Array.isArray(response.data.erc721Listings)) {
+            throw new errors_1.CliError("SUBGRAPH_INVALID_RESPONSE", "Expected erc721Listings to be an array.", 2, {
+                source: response.source,
+                endpoint: response.endpoint,
+                queryName: response.queryName,
+            });
+        }
+        const erc721Listings = response.data.erc721Listings;
+        return {
+            source: response.source,
+            endpoint: response.endpoint,
+            queryName: response.queryName,
+            listingKind: kind,
+            pagination,
+            listings: withNormalizeContext(response, () => (0, normalize_1.normalizeBaazaarErc721Listings)(erc721Listings)),
+            ...(raw ? { raw: response.raw } : {}),
+        };
+    }
+    const response = await (0, client_1.executeSubgraphQuery)({
+        ...common,
+        queryName: "baazaar.listing.active.erc1155",
+        query: queries_1.BAAZAAR_ACTIVE_ERC1155_QUERY,
+        variables: pagination,
+        raw,
+    });
+    if (!Array.isArray(response.data.erc1155Listings)) {
+        throw new errors_1.CliError("SUBGRAPH_INVALID_RESPONSE", "Expected erc1155Listings to be an array.", 2, {
+            source: response.source,
+            endpoint: response.endpoint,
+            queryName: response.queryName,
+        });
+    }
+    const erc1155Listings = response.data.erc1155Listings;
+    return {
+        source: response.source,
+        endpoint: response.endpoint,
+        queryName: response.queryName,
+        listingKind: kind,
+        pagination,
+        listings: withNormalizeContext(response, () => (0, normalize_1.normalizeBaazaarErc1155Listings)(erc1155Listings)),
+        ...(raw ? { raw: response.raw } : {}),
+    };
+}
+async function runBaazaarListingMineSubgraphCommand(ctx) {
+    const kind = parseKind((0, args_1.getFlagString)(ctx.args.flags, "kind"));
+    const seller = parseAddress((0, args_1.getFlagString)(ctx.args.flags, "seller"), "--seller");
+    const pagination = parsePagination(ctx);
+    const raw = parseRawFlag(ctx);
+    const common = parseCommonSubgraphOptions(ctx);
+    if (kind === "erc721") {
+        const response = await (0, client_1.executeSubgraphQuery)({
+            ...common,
+            queryName: "baazaar.listing.mine.erc721",
+            query: queries_1.BAAZAAR_MINE_ERC721_QUERY,
+            variables: {
+                seller,
+                ...pagination,
+            },
+            raw,
+        });
+        if (!Array.isArray(response.data.erc721Listings)) {
+            throw new errors_1.CliError("SUBGRAPH_INVALID_RESPONSE", "Expected erc721Listings to be an array.", 2, {
+                source: response.source,
+                endpoint: response.endpoint,
+                queryName: response.queryName,
+            });
+        }
+        const erc721Listings = response.data.erc721Listings;
+        return {
+            source: response.source,
+            endpoint: response.endpoint,
+            queryName: response.queryName,
+            listingKind: kind,
+            seller,
+            pagination,
+            listings: withNormalizeContext(response, () => (0, normalize_1.normalizeBaazaarErc721Listings)(erc721Listings)),
+            ...(raw ? { raw: response.raw } : {}),
+        };
+    }
+    const response = await (0, client_1.executeSubgraphQuery)({
+        ...common,
+        queryName: "baazaar.listing.mine.erc1155",
+        query: queries_1.BAAZAAR_MINE_ERC1155_QUERY,
+        variables: {
+            seller,
+            ...pagination,
+        },
+        raw,
+    });
+    if (!Array.isArray(response.data.erc1155Listings)) {
+        throw new errors_1.CliError("SUBGRAPH_INVALID_RESPONSE", "Expected erc1155Listings to be an array.", 2, {
+            source: response.source,
+            endpoint: response.endpoint,
+            queryName: response.queryName,
+        });
+    }
+    const erc1155Listings = response.data.erc1155Listings;
+    return {
+        source: response.source,
+        endpoint: response.endpoint,
+        queryName: response.queryName,
+        listingKind: kind,
+        seller,
+        pagination,
+        listings: withNormalizeContext(response, () => (0, normalize_1.normalizeBaazaarErc1155Listings)(erc1155Listings)),
+        ...(raw ? { raw: response.raw } : {}),
+    };
+}
+async function runBaazaarListingSubgraphCommand(ctx) {
+    const action = ctx.commandPath[2];
+    if (action === "get") {
+        return runBaazaarListingGetSubgraphCommand(ctx);
+    }
+    if (action === "active") {
+        return runBaazaarListingActiveSubgraphCommand(ctx);
+    }
+    if (action === "mine") {
+        return runBaazaarListingMineSubgraphCommand(ctx);
+    }
+    throw new errors_1.CliError("UNKNOWN_COMMAND", `Unknown command '${ctx.commandPath.join(" ")}'.`, 2);
+}

package/dist/commands/onchain.js

@@ -184,6 +184,10 @@ async function runOnchainSendWithFunction(ctx, forcedFunctionName, commandOverri
         });
     }
     const waitForReceipt = (0, args_1.getFlagBoolean)(ctx.args.flags, "wait");
+    const dryRun = (0, args_1.getFlagBoolean)(ctx.args.flags, "dry-run");
+    if (dryRun && waitForReceipt) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--dry-run cannot be combined with --wait.", 2);
+    }
     const intent = {
         idempotencyKey: (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key"),
         profileName: profile.name,
@@ -197,6 +201,7 @@ async function runOnchainSendWithFunction(ctx, forcedFunctionName, commandOverri
         noncePolicy: noncePolicyRaw,
         nonce,
         waitForReceipt,
+        dryRun,
         timeoutMs: parseTimeoutMs((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms")),
         command: commandOverride || `onchain send ${functionName}`,
     };

package/dist/commands/subgraph.js

@@ -0,0 +1,172 @@
+"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.runSubgraphListCommand = runSubgraphListCommand;
+exports.runSubgraphCheckCommand = runSubgraphCheckCommand;
+exports.runSubgraphQueryCommand = runSubgraphQueryCommand;
+const fs = __importStar(require("fs"));
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+const schemas_1 = require("../schemas");
+const client_1 = require("../subgraph/client");
+const queries_1 = require("../subgraph/queries");
+const sources_1 = require("../subgraph/sources");
+function parseTimeoutMs(value) {
+    if (!value) {
+        return undefined;
+    }
+    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 parseVariablesJson(value) {
+    if (!value) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new errors_1.CliError("INVALID_VARIABLES_JSON", "--variables-json must be valid JSON.", 2);
+    }
+    const result = schemas_1.subgraphVariablesSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new errors_1.CliError("INVALID_VARIABLES_JSON", "--variables-json must be a JSON object.", 2, {
+            issues: result.error.issues,
+        });
+    }
+    return result.data;
+}
+function readQueryFromInput(flags) {
+    const inline = (0, args_1.getFlagString)(flags, "query");
+    const queryFile = (0, args_1.getFlagString)(flags, "query-file");
+    if (!inline && !queryFile) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", "subgraph query requires --query or --query-file.", 2);
+    }
+    if (inline && queryFile) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "Provide only one of --query or --query-file.", 2);
+    }
+    if (inline) {
+        return inline;
+    }
+    const filePath = queryFile;
+    if (!fs.existsSync(filePath)) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", `Query file not found: ${filePath}`, 2);
+    }
+    const query = fs.readFileSync(filePath, "utf8").trim();
+    if (!query) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "Query file is empty.", 2, {
+            queryFile: filePath,
+        });
+    }
+    return query;
+}
+function parseRawFlag(ctx) {
+    return (0, args_1.getFlagBoolean)(ctx.args.flags, "raw");
+}
+function parseCommonRequestOptions(ctx) {
+    const subgraphUrl = (0, args_1.getFlagString)(ctx.args.flags, "subgraph-url");
+    const allowUntrustedSubgraph = (0, args_1.getFlagBoolean)(ctx.args.flags, "allow-untrusted-subgraph");
+    if (allowUntrustedSubgraph && !subgraphUrl) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--allow-untrusted-subgraph requires --subgraph-url.", 2);
+    }
+    return {
+        source: (0, sources_1.parseSubgraphSourceAlias)((0, args_1.getFlagString)(ctx.args.flags, "source")),
+        timeoutMs: parseTimeoutMs((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms")),
+        authEnvVar: (0, args_1.getFlagString)(ctx.args.flags, "auth-env-var"),
+        subgraphUrl,
+        allowUntrustedSubgraph,
+    };
+}
+async function runSubgraphListCommand() {
+    return {
+        sources: (0, sources_1.listSubgraphSources)(),
+    };
+}
+async function runSubgraphCheckCommand(ctx) {
+    const common = parseCommonRequestOptions(ctx);
+    const raw = parseRawFlag(ctx);
+    const response = await (0, client_1.executeSubgraphQuery)({
+        ...common,
+        queryName: "introspection",
+        query: queries_1.SUBGRAPH_INTROSPECTION_QUERY,
+        variables: {},
+        raw,
+    });
+    const fields = response.data.__schema?.queryType?.fields;
+    if (!Array.isArray(fields)) {
+        throw new errors_1.CliError("SUBGRAPH_INVALID_RESPONSE", "Introspection response missing query fields.", 2, {
+            source: response.source,
+            endpoint: response.endpoint,
+        });
+    }
+    const fieldNames = fields
+        .map((field) => field.name)
+        .filter((name) => typeof name === "string")
+        .sort((a, b) => a.localeCompare(b));
+    return {
+        source: response.source,
+        endpoint: response.endpoint,
+        queryName: response.queryName,
+        fieldCount: fieldNames.length,
+        fields: fieldNames,
+        ...(raw ? { raw: response.raw } : {}),
+    };
+}
+async function runSubgraphQueryCommand(ctx) {
+    const common = parseCommonRequestOptions(ctx);
+    const raw = parseRawFlag(ctx);
+    const query = readQueryFromInput(ctx.args.flags);
+    const variables = parseVariablesJson((0, args_1.getFlagString)(ctx.args.flags, "variables-json"));
+    const response = await (0, client_1.executeSubgraphQuery)({
+        ...common,
+        queryName: "custom",
+        query,
+        variables,
+        raw,
+    });
+    return {
+        source: response.source,
+        endpoint: response.endpoint,
+        queryName: response.queryName,
+        data: response.data,
+        ...(raw ? { raw: response.raw } : {}),
+    };
+}

package/dist/commands/tx.js

@@ -75,10 +75,14 @@ async function runTxSendCommand(ctx) {
     const nonceValue = (0, args_1.getFlagString)(ctx.args.flags, "nonce");
     const nonce = nonceValue ? parseNumberFlag(nonceValue, "--nonce", 0) : undefined;
     const waitForReceipt = (0, args_1.getFlagBoolean)(ctx.args.flags, "wait") || (0, args_1.getFlagBoolean)(ctx.args.flags, "confirm");
+    const dryRun = (0, args_1.getFlagBoolean)(ctx.args.flags, "dry-run");
     const timeoutMs = parseNumberFlag((0, args_1.getFlagString)(ctx.args.flags, "timeout-ms"), "--timeout-ms", 120000);
     if (noncePolicy === "manual" && nonce === undefined) {
         throw new errors_1.CliError("MISSING_NONCE", "--nonce is required when --nonce-policy=manual.", 2);
     }
+    if (dryRun && waitForReceipt) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--dry-run cannot be combined with --wait/--confirm.", 2);
+    }
     const intent = {
         idempotencyKey,
         profileName: profile.name,
@@ -92,6 +96,7 @@ async function runTxSendCommand(ctx) {
         noncePolicy,
         nonce,
         waitForReceipt,
+        dryRun,
         timeoutMs,
         command: "tx send",
     };

package/dist/output.js

@@ -69,7 +69,7 @@ Core commands:
   rpc check                          Verify RPC connectivity + signer backend health
 
 Tx commands:
-  tx send                            Send a raw EVM transaction with simulation + policy checks + journaling
+  tx send                            Send a raw EVM transaction (or simulate only with --dry-run)
   tx status                          Read tx status by idempotency key/hash or list recent
   tx resume                          Resume waiting for a previously submitted tx
   tx watch                           Poll journal until tx is confirmed
@@ -79,12 +79,18 @@ Automation commands:
 
 Power-user commands:
   onchain call                       Call any ABI function from --abi-file
-  onchain send                       Send any ABI function as a transaction
+  onchain send                       Send any ABI function as a transaction (or simulate with --dry-run)
+  subgraph list|check|query          List/check/query canonical Goldsky subgraphs
 
 Domain namespaces:
-  gotchi, portal, wearables, items, inventory, baazaar, lending, realm, alchemica, forge, token
+  gotchi, portal, wearables, items, inventory, baazaar, auction, lending, staking, gotchi-points, realm, alchemica, forge, token
   (many write flows are mapped to onchain send aliases; unmatched commands return typed not-implemented)
 
+Subgraph wrappers:
+  baazaar listing get|active|mine    Read Baazaar listing data from core-base subgraph
+  auction get|active|mine|bids|bids-mine
+                                     Read GBM auction/bid data from gbm-base subgraph
+
 Global flags:
   --mode <agent|human>               Agent mode implies --json --yes
   --json, -j                         Emit JSON envelope output
@@ -106,6 +112,10 @@ Examples:
   ag bootstrap --mode agent --profile prod --chain base --signer env:AGCLI_PRIVATE_KEY --json
   AGCLI_KEYCHAIN_PASSPHRASE=... AGCLI_PRIVATE_KEY=0x... ag signer keychain import --account-id bot --private-key-env AGCLI_PRIVATE_KEY --json
   ag tx send --profile prod --to 0xabc... --value-wei 1000000000000000 --wait --json
+  ag tx send --profile prod --to 0xabc... --value-wei 0 --dry-run --json
+  ag subgraph check --source core-base --json
+  ag baazaar listing active --kind erc721 --first 20 --json
+  ag auction active --first 20 --json
   ag lending create --profile prod --abi-file ./abis/GotchiLendingFacet.json --address 0xabc... --args-json '[...]' --json
   ag batch run --file ./plan.yaml --json
 `);