aavegotchi-cli 0.2.2 → 0.2.5

package/dist/commands/auction-bid.js

@@ -0,0 +1,815 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAuctionBidCommand = runAuctionBidCommand;
+exports.runAuctionBidUnbidCommand = runAuctionBidUnbidCommand;
+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 profile_env_1 = require("../profile-env");
+const rpc_1 = require("../rpc");
+const signer_1 = require("../signer");
+const normalize_1 = require("../subgraph/normalize");
+const client_1 = require("../subgraph/client");
+const queries_1 = require("../subgraph/queries");
+const sources_1 = require("../subgraph/sources");
+const tx_engine_1 = require("../tx-engine");
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const GHST_DECIMALS = 18;
+const BATCH_DEFAULT_FIRST = 200;
+const BATCH_MAX_FIRST = 200;
+// Canonical addresses from aavegotchi-base deployments.
+const GHST_BY_CHAIN_ID = {
+    8453: "0xcd2f22236dd9dfe2356d7c543161d4d260fd9bcb",
+    84532: "0xe97f36a00058aa7dfc4e85d23532c3f70453a7ae",
+};
+const GBM_DIAMOND_BY_CHAIN_ID = {
+    8453: sources_1.BASE_GBM_DIAMOND,
+    84532: "0x8572ce8ad6c9788bb6da3509117646047dd8b543",
+};
+const GBM_BID_WRITE_ABI = (0, viem_1.parseAbi)(["function commitBid(uint256,uint256,uint256,address,uint256,uint256,bytes)"]);
+const GBM_AUCTION_READ_ABI = (0, viem_1.parseAbi)([
+    "function getAuctionHighestBid(uint256 _auctionId) view returns (uint256)",
+    "function getAuctionHighestBidder(uint256 _auctionId) view returns (address)",
+    "function getContractAddress(uint256 _auctionId) view returns (address)",
+    "function getTokenId(uint256 _auctionId) view returns (uint256)",
+    "function getAuctionStartTime(uint256 _auctionId) view returns (uint256)",
+    "function getAuctionEndTime(uint256 _auctionId) view returns (uint256)",
+    "function getAuctionIncMin(uint256 _auctionId) view returns (uint64)",
+]);
+const ERC20_ABI = (0, viem_1.parseAbi)([
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address,address) view returns (uint256)",
+    "function approve(address,uint256) returns (bool)",
+]);
+function parseAddress(value, hint) {
+    if (typeof value !== "string" || !/^0x[a-fA-F0-9]{40}$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${hint} must be a valid EVM address.`, 2, { value });
+    }
+    return value.toLowerCase();
+}
+function parseAuctionId(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 parseNonNegativeBigint(value, label) {
+    if (!/^\d+$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${label} must be a non-negative integer string.`, 2, { value });
+    }
+    return BigInt(value);
+}
+function parseGhstAmount(value, label, allowZero = false) {
+    if (!/^\d+(\.\d{1,18})?$/.test(value)) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${label} must be a decimal GHST amount (up to 18 decimals).`, 2, {
+            value,
+        });
+    }
+    const parsed = (0, viem_1.parseUnits)(value, GHST_DECIMALS);
+    if (!allowZero && parsed <= 0n) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${label} must be greater than 0.`, 2, { value });
+    }
+    return parsed;
+}
+function parseAmountWeiFromFlags(flags, options) {
+    const weiRaw = (0, args_1.getFlagString)(flags, options.weiKey);
+    const ghstRaw = (0, args_1.getFlagString)(flags, options.ghstKey);
+    if (!weiRaw && !ghstRaw) {
+        throw new errors_1.CliError("MISSING_ARGUMENT", `${options.label} is required. Use --${options.ghstKey} <amount> or --${options.weiKey} <wei>.`, 2);
+    }
+    if (weiRaw && ghstRaw) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `Use either --${options.ghstKey} or --${options.weiKey}, not both.`, 2);
+    }
+    const parsed = weiRaw ? parseNonNegativeBigint(weiRaw, `--${options.weiKey}`) : parseGhstAmount(ghstRaw, `--${options.ghstKey}`);
+    if (!options.allowZero && parsed <= 0n) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", `${options.label} must be greater than 0.`, 2);
+    }
+    return parsed;
+}
+function parseOptionalExpectedHighestBid(flags) {
+    const expectedWei = (0, args_1.getFlagString)(flags, "expected-highest-bid-wei");
+    const expectedGhst = (0, args_1.getFlagString)(flags, "expected-highest-bid-ghst");
+    if (!expectedWei && !expectedGhst) {
+        return undefined;
+    }
+    if (expectedWei && expectedGhst) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "Use either --expected-highest-bid-ghst or --expected-highest-bid-wei, not both.", 2);
+    }
+    return expectedWei
+        ? parseNonNegativeBigint(expectedWei, "--expected-highest-bid-wei")
+        : parseGhstAmount(expectedGhst, "--expected-highest-bid-ghst", true);
+}
+function parseNoncePolicy(flags) {
+    const noncePolicy = (0, args_1.getFlagString)(flags, "nonce-policy") || "safe";
+    if (noncePolicy !== "safe" && noncePolicy !== "replace" && noncePolicy !== "manual") {
+        throw new errors_1.CliError("INVALID_NONCE_POLICY", `Unsupported nonce policy '${noncePolicy}'.`, 2);
+    }
+    return noncePolicy;
+}
+function parseNonce(flags) {
+    const raw = (0, args_1.getFlagString)(flags, "nonce");
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--nonce must be a non-negative integer.", 2, {
+            value: raw,
+        });
+    }
+    return parsed;
+}
+function parseTimeoutMs(flags) {
+    const raw = (0, args_1.getFlagString)(flags, "timeout-ms");
+    if (!raw) {
+        return 120000;
+    }
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--timeout-ms must be a positive integer.", 2, {
+            value: raw,
+        });
+    }
+    return parsed;
+}
+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 classifyRevert(message) {
+    const normalized = message.toLowerCase();
+    if (normalized.includes("allowance")) {
+        return {
+            reasonCode: "INSUFFICIENT_ALLOWANCE",
+            reason: "Allowance is below required amount for transferFrom.",
+        };
+    }
+    if ((normalized.includes("bid") && normalized.includes("low")) || normalized.includes("start bid")) {
+        return {
+            reasonCode: "BID_BELOW_START",
+            reason: "Bid amount is below minimum required value.",
+        };
+    }
+    if (normalized.includes("auction") &&
+        (normalized.includes("ended") ||
+            normalized.includes("not active") ||
+            normalized.includes("already") ||
+            normalized.includes("state"))) {
+        return {
+            reasonCode: "AUCTION_STATE_CHANGED",
+            reason: "Auction state changed between preflight and submit.",
+        };
+    }
+    return {
+        reasonCode: "UNKNOWN_REVERT",
+        reason: "Revert reason could not be classified.",
+    };
+}
+function throwPreflightError(reasonCode, message, checks, details) {
+    throw new errors_1.CliError(reasonCode, message, 2, {
+        reasonCode,
+        checks,
+        ...(details || {}),
+    });
+}
+function parseBatchIdempotencyKey(base, auctionId, amountWei) {
+    if (base) {
+        return `${base}:${auctionId}:${amountWei.toString()}`;
+    }
+    return `auction.bid-unbid:${auctionId}:${amountWei.toString()}`;
+}
+async function resolveBidContext(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 policy = (0, config_1.getPolicyOrThrow)(config, profile.policy);
+    const environment = (0, profile_env_1.applyProfileEnvironment)(profile);
+    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 signerRuntime = await (0, signer_1.resolveSignerRuntime)(profile.signer, preflight.client, rpcUrl, (0, chains_1.toViemChain)(chain, rpcUrl));
+    const signerAddress = signerRuntime.summary.address;
+    if (!signerAddress) {
+        throw new errors_1.CliError("MISSING_SIGNER_ADDRESS", "Signer address is required for auction bidding.", 2, {
+            signerType: signerRuntime.summary.signerType,
+            backendStatus: signerRuntime.summary.backendStatus,
+        });
+    }
+    const gbmDiamond = GBM_DIAMOND_BY_CHAIN_ID[chain.chainId];
+    const ghstToken = GHST_BY_CHAIN_ID[chain.chainId];
+    if (!gbmDiamond || !ghstToken) {
+        throw new errors_1.CliError("UNSUPPORTED_CHAIN", `auction bid currently supports chains ${Object.keys(GBM_DIAMOND_BY_CHAIN_ID).join(", ")}.`, 2, {
+            chainId: chain.chainId,
+        });
+    }
+    return {
+        profileName: profile.name,
+        policy,
+        chain,
+        rpcUrl,
+        signer: profile.signer,
+        signerAddress,
+        gbmDiamond,
+        ghstToken,
+        environment,
+    };
+}
+async function fetchAuctionFromSubgraph(auctionId) {
+    const response = await (0, client_1.executeSubgraphQuery)({
+        source: "gbm-base",
+        queryName: "auction.bid.preflight",
+        query: queries_1.GBM_AUCTION_BY_ID_QUERY,
+        variables: { id: auctionId },
+    });
+    if (!response.data.auction) {
+        throw new errors_1.CliError("AUCTION_NOT_FOUND", `Auction '${auctionId}' was not found in the GBM subgraph.`, 2, {
+            auctionId,
+            source: response.source,
+            endpoint: response.endpoint,
+        });
+    }
+    return (0, normalize_1.normalizeGbmAuction)(response.data.auction);
+}
+async function readOnchainSnapshot(bidContext, auctionId) {
+    const preflight = await (0, rpc_1.runRpcPreflight)(bidContext.chain, bidContext.rpcUrl);
+    const id = BigInt(auctionId);
+    const [highestBidWeiRaw, highestBidderRaw, contractAddressRaw, tokenIdRaw, startsAtRaw, endsAtRaw, incMinRaw] = await Promise.all([
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getAuctionHighestBid",
+            args: [id],
+        }),
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getAuctionHighestBidder",
+            args: [id],
+        }),
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getContractAddress",
+            args: [id],
+        }),
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getTokenId",
+            args: [id],
+        }),
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getAuctionStartTime",
+            args: [id],
+        }),
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getAuctionEndTime",
+            args: [id],
+        }),
+        preflight.client.readContract({
+            address: bidContext.gbmDiamond,
+            abi: GBM_AUCTION_READ_ABI,
+            functionName: "getAuctionIncMin",
+            args: [id],
+        }),
+    ]);
+    return {
+        auctionId,
+        highestBidWei: highestBidWeiRaw,
+        highestBidder: parseAddress(highestBidderRaw, "auction highest bidder"),
+        contractAddress: parseAddress(contractAddressRaw, "auction token contract"),
+        tokenId: tokenIdRaw,
+        startsAt: startsAtRaw,
+        endsAt: endsAtRaw,
+        incMin: incMinRaw,
+    };
+}
+function computeMinimumBidWei(snapshot, startBidPriceWei) {
+    if (snapshot.highestBidWei > 0n) {
+        const denominator = 10000n;
+        return (snapshot.highestBidWei * (denominator + snapshot.incMin)) / denominator;
+    }
+    return startBidPriceWei;
+}
+function mapSimulationError(error) {
+    if (error.code !== "SIMULATION_REVERT") {
+        return error;
+    }
+    const message = String(error.details?.message || "");
+    const classified = classifyRevert(message);
+    return new errors_1.CliError("AUCTION_BID_REVERT", "Auction bid simulation reverted.", 2, {
+        reasonCode: classified.reasonCode,
+        reason: classified.reason,
+        rawMessage: message,
+    });
+}
+async function runSingleBid(ctx, options) {
+    const dryRun = (0, args_1.getFlagBoolean)(ctx.args.flags, "dry-run");
+    const waitForReceipt = (0, args_1.getFlagBoolean)(ctx.args.flags, "wait");
+    const autoApprove = (0, args_1.getFlagBoolean)(ctx.args.flags, "auto-approve");
+    const requireUnbid = options?.forceRequireUnbid ?? (0, args_1.getFlagBoolean)(ctx.args.flags, "require-unbid");
+    const timeoutMs = parseTimeoutMs(ctx.args.flags);
+    const noncePolicy = parseNoncePolicy(ctx.args.flags);
+    const nonce = parseNonce(ctx.args.flags);
+    if (dryRun && waitForReceipt) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "--dry-run cannot be combined with --wait.", 2);
+    }
+    if (noncePolicy === "manual" && nonce === undefined) {
+        throw new errors_1.CliError("MISSING_NONCE", "--nonce is required when --nonce-policy=manual.", 2);
+    }
+    const auctionId = options?.forceAuctionId || parseAuctionId((0, args_1.getFlagString)(ctx.args.flags, "auction-id"), "--auction-id");
+    const amountWei = options?.forceAmountWei ||
+        parseAmountWeiFromFlags(ctx.args.flags, {
+            weiKey: "amount-wei",
+            ghstKey: "amount-ghst",
+            label: "Bid amount",
+        });
+    const expectedHighestBidWei = options?.forceExpectedHighestBidWei ?? parseOptionalExpectedHighestBid(ctx.args.flags);
+    const idempotencyKey = options?.forceIdempotencyKey || (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key");
+    const autoApproveMaxWei = (0, args_1.getFlagString)(ctx.args.flags, "auto-approve-max-wei")
+        ? parseNonNegativeBigint((0, args_1.getFlagString)(ctx.args.flags, "auto-approve-max-wei"), "--auto-approve-max-wei")
+        : (0, args_1.getFlagString)(ctx.args.flags, "auto-approve-max-ghst")
+            ? parseGhstAmount((0, args_1.getFlagString)(ctx.args.flags, "auto-approve-max-ghst"), "--auto-approve-max-ghst")
+            : undefined;
+    const bidContext = await resolveBidContext(ctx);
+    const subgraphAuction = await fetchAuctionFromSubgraph(auctionId);
+    const startBidPriceWei = parseNonNegativeBigint(subgraphAuction.startBidPrice || "0", "startBidPrice");
+    const quantity = parseNonNegativeBigint(subgraphAuction.quantity, "quantity");
+    const nowSec = BigInt(Math.floor(Date.now() / 1000));
+    const checks = [];
+    const onchainBefore = await readOnchainSnapshot(bidContext, auctionId);
+    const minimumBidWei = computeMinimumBidWei(onchainBefore, startBidPriceWei);
+    if (onchainBefore.startsAt <= nowSec && nowSec < onchainBefore.endsAt) {
+        checks.push({ check: "AUCTION_OPEN", status: "pass" });
+    }
+    else {
+        checks.push({
+            check: "AUCTION_OPEN",
+            status: "fail",
+            reasonCode: "AUCTION_NOT_OPEN",
+            details: {
+                nowSec: nowSec.toString(),
+                startsAt: onchainBefore.startsAt.toString(),
+                endsAt: onchainBefore.endsAt.toString(),
+            },
+        });
+        throwPreflightError("AUCTION_NOT_OPEN", "Auction is not currently open for bidding.", checks, {
+            auctionId,
+        });
+    }
+    if (requireUnbid) {
+        const unbid = onchainBefore.highestBidWei === 0n && onchainBefore.highestBidder === ZERO_ADDRESS;
+        if (!unbid) {
+            checks.push({
+                check: "REQUIRE_UNBID",
+                status: "fail",
+                reasonCode: "AUCTION_ALREADY_BID",
+                details: {
+                    highestBidWei: onchainBefore.highestBidWei.toString(),
+                    highestBidder: onchainBefore.highestBidder,
+                },
+            });
+            throwPreflightError("AUCTION_ALREADY_BID", "Auction already has a highest bid.", checks, {
+                auctionId,
+            });
+        }
+        checks.push({ check: "REQUIRE_UNBID", status: "pass" });
+    }
+    else {
+        checks.push({ check: "REQUIRE_UNBID", status: "skip" });
+    }
+    if (expectedHighestBidWei !== undefined) {
+        if (onchainBefore.highestBidWei !== expectedHighestBidWei) {
+            checks.push({
+                check: "EXPECTED_HIGHEST_BID",
+                status: "fail",
+                reasonCode: "EXPECTED_HIGHEST_BID_MISMATCH",
+                details: {
+                    expectedHighestBidWei: expectedHighestBidWei.toString(),
+                    currentHighestBidWei: onchainBefore.highestBidWei.toString(),
+                },
+            });
+            throwPreflightError("EXPECTED_HIGHEST_BID_MISMATCH", "Current highest bid does not match expected value.", checks, {
+                auctionId,
+            });
+        }
+        checks.push({ check: "EXPECTED_HIGHEST_BID", status: "pass" });
+    }
+    else {
+        checks.push({ check: "EXPECTED_HIGHEST_BID", status: "skip" });
+    }
+    if (amountWei >= minimumBidWei) {
+        checks.push({ check: "BID_MINIMUM", status: "pass" });
+    }
+    else {
+        checks.push({
+            check: "BID_MINIMUM",
+            status: "fail",
+            reasonCode: "BID_BELOW_START",
+            details: {
+                amountWei: amountWei.toString(),
+                minimumBidWei: minimumBidWei.toString(),
+                highestBidWei: onchainBefore.highestBidWei.toString(),
+                startBidPriceWei: startBidPriceWei.toString(),
+            },
+        });
+        throwPreflightError("BID_BELOW_START", "Bid amount is below the current minimum bid requirement.", checks, {
+            auctionId,
+        });
+    }
+    const preflight = await (0, rpc_1.runRpcPreflight)(bidContext.chain, bidContext.rpcUrl);
+    const [ghstBalanceWeiRaw, allowanceWeiRaw] = await Promise.all([
+        preflight.client.readContract({
+            address: bidContext.ghstToken,
+            abi: ERC20_ABI,
+            functionName: "balanceOf",
+            args: [bidContext.signerAddress],
+        }),
+        preflight.client.readContract({
+            address: bidContext.ghstToken,
+            abi: ERC20_ABI,
+            functionName: "allowance",
+            args: [bidContext.signerAddress, bidContext.gbmDiamond],
+        }),
+    ]);
+    const ghstBalanceWei = ghstBalanceWeiRaw;
+    const allowanceWei = allowanceWeiRaw;
+    if (ghstBalanceWei >= amountWei) {
+        checks.push({ check: "GHST_BALANCE", status: "pass" });
+    }
+    else {
+        checks.push({
+            check: "GHST_BALANCE",
+            status: "fail",
+            reasonCode: "INSUFFICIENT_GHST_BALANCE",
+            details: {
+                balanceWei: ghstBalanceWei.toString(),
+                requiredWei: amountWei.toString(),
+            },
+        });
+        throwPreflightError("INSUFFICIENT_GHST_BALANCE", "GHST balance is below bid amount.", checks, {
+            auctionId,
+            signer: bidContext.signerAddress,
+        });
+    }
+    let approval;
+    let approvalNeeded = allowanceWei < amountWei;
+    if (approvalNeeded) {
+        if (!autoApprove) {
+            checks.push({
+                check: "GHST_ALLOWANCE",
+                status: "fail",
+                reasonCode: "INSUFFICIENT_ALLOWANCE",
+                details: {
+                    allowanceWei: allowanceWei.toString(),
+                    requiredWei: amountWei.toString(),
+                },
+            });
+            throwPreflightError("INSUFFICIENT_ALLOWANCE", "GHST allowance is below bid amount. Re-run with --auto-approve to submit approve() automatically.", checks, {
+                auctionId,
+                ghstToken: bidContext.ghstToken,
+                spender: bidContext.gbmDiamond,
+            });
+        }
+        const approveAmountWei = autoApproveMaxWei ?? amountWei;
+        if (approveAmountWei < amountWei) {
+            throw new errors_1.CliError("AUTO_APPROVE_LIMIT_TOO_LOW", "auto-approve cap is below required bid amount.", 2, {
+                approveAmountWei: approveAmountWei.toString(),
+                requiredWei: amountWei.toString(),
+            });
+        }
+        checks.push({
+            check: "GHST_ALLOWANCE",
+            status: "auto-fixed",
+            reasonCode: "INSUFFICIENT_ALLOWANCE",
+            details: {
+                allowanceWei: allowanceWei.toString(),
+                requiredWei: amountWei.toString(),
+                approveAmountWei: approveAmountWei.toString(),
+            },
+        });
+        const approveData = (0, viem_1.encodeFunctionData)({
+            abi: ERC20_ABI,
+            functionName: "approve",
+            args: [bidContext.gbmDiamond, approveAmountWei],
+        });
+        const approveIntent = {
+            idempotencyKey: idempotencyKey ? `${idempotencyKey}:approve` : undefined,
+            profileName: bidContext.profileName,
+            chainId: bidContext.chain.chainId,
+            rpcUrl: bidContext.rpcUrl,
+            signer: bidContext.signer,
+            policy: bidContext.policy,
+            to: bidContext.ghstToken,
+            data: approveData,
+            noncePolicy: "safe",
+            waitForReceipt: dryRun ? false : true,
+            dryRun,
+            timeoutMs,
+            command: "auction approve-ghst",
+        };
+        try {
+            const approvalResult = await (0, tx_engine_1.executeTxIntent)(approveIntent, bidContext.chain);
+            approval = {
+                autoApprove: true,
+                approveAmountWei: approveAmountWei.toString(),
+                result: approvalResult,
+            };
+        }
+        catch (error) {
+            if (error instanceof errors_1.CliError) {
+                throw mapSimulationError(error);
+            }
+            throw error;
+        }
+    }
+    else {
+        checks.push({ check: "GHST_ALLOWANCE", status: "pass" });
+    }
+    if (!dryRun) {
+        const onchainBeforeSend = await readOnchainSnapshot(bidContext, auctionId);
+        if (onchainBeforeSend.highestBidWei !== onchainBefore.highestBidWei ||
+            onchainBeforeSend.highestBidder !== onchainBefore.highestBidder) {
+            throw new errors_1.CliError("AUCTION_STATE_CHANGED", "Auction state changed before submit; aborting.", 2, {
+                reasonCode: "AUCTION_STATE_CHANGED",
+                previousHighestBidWei: onchainBefore.highestBidWei.toString(),
+                currentHighestBidWei: onchainBeforeSend.highestBidWei.toString(),
+                previousHighestBidder: onchainBefore.highestBidder,
+                currentHighestBidder: onchainBeforeSend.highestBidder,
+                auctionId,
+            });
+        }
+    }
+    const commitArgs = [
+        BigInt(auctionId),
+        amountWei,
+        onchainBefore.highestBidWei,
+        onchainBefore.contractAddress,
+        onchainBefore.tokenId,
+        quantity,
+        "0x",
+    ];
+    if (dryRun && approvalNeeded) {
+        return {
+            profile: bidContext.profileName,
+            chainId: bidContext.chain.chainId,
+            command: "auction bid",
+            environment: bidContext.environment,
+            auction: {
+                id: auctionId,
+                gbmDiamond: bidContext.gbmDiamond,
+                tokenContract: onchainBefore.contractAddress,
+                tokenId: onchainBefore.tokenId.toString(),
+                quantity: quantity.toString(),
+                startBidPriceWei: startBidPriceWei.toString(),
+                highestBidWei: onchainBefore.highestBidWei.toString(),
+                highestBidder: onchainBefore.highestBidder,
+                minBidWei: minimumBidWei.toString(),
+            },
+            preflight: {
+                checks,
+                signer: bidContext.signerAddress,
+                ghstToken: bidContext.ghstToken,
+                balanceWei: ghstBalanceWei.toString(),
+                allowanceWei: allowanceWei.toString(),
+                amountWei: amountWei.toString(),
+            },
+            ...(approval ? { approval } : {}),
+            result: {
+                status: "simulated",
+                dryRun: true,
+                skippedBidSimulation: true,
+                reasonCode: "INSUFFICIENT_ALLOWANCE",
+                reason: "Approval was simulated, so bid simulation is skipped in dry-run mode.",
+                commitBidArgs: commitArgs,
+            },
+        };
+    }
+    const bidData = (0, viem_1.encodeFunctionData)({
+        abi: GBM_BID_WRITE_ABI,
+        functionName: "commitBid",
+        args: commitArgs,
+    });
+    const bidIntent = {
+        idempotencyKey,
+        profileName: bidContext.profileName,
+        chainId: bidContext.chain.chainId,
+        rpcUrl: bidContext.rpcUrl,
+        signer: bidContext.signer,
+        policy: bidContext.policy,
+        to: bidContext.gbmDiamond,
+        data: bidData,
+        noncePolicy,
+        nonce,
+        waitForReceipt,
+        dryRun,
+        timeoutMs,
+        command: "auction bid",
+    };
+    let bidResult;
+    try {
+        bidResult = await (0, tx_engine_1.executeTxIntent)(bidIntent, bidContext.chain);
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError) {
+            throw mapSimulationError(error);
+        }
+        throw error;
+    }
+    return {
+        profile: bidContext.profileName,
+        chainId: bidContext.chain.chainId,
+        command: "auction bid",
+        environment: bidContext.environment,
+        auction: {
+            id: auctionId,
+            gbmDiamond: bidContext.gbmDiamond,
+            tokenContract: onchainBefore.contractAddress,
+            tokenId: onchainBefore.tokenId.toString(),
+            quantity: quantity.toString(),
+            startBidPriceWei: startBidPriceWei.toString(),
+            highestBidWei: onchainBefore.highestBidWei.toString(),
+            highestBidder: onchainBefore.highestBidder,
+            minBidWei: minimumBidWei.toString(),
+        },
+        preflight: {
+            checks,
+            signer: bidContext.signerAddress,
+            ghstToken: bidContext.ghstToken,
+            balanceWei: ghstBalanceWei.toString(),
+            allowanceWei: allowanceWei.toString(),
+            amountWei: amountWei.toString(),
+        },
+        ...(approval ? { approval } : {}),
+        result: bidResult,
+    };
+}
+async function runAuctionBidCommand(ctx) {
+    return runSingleBid(ctx);
+}
+async function runAuctionBidUnbidCommand(ctx) {
+    const amountWei = parseAmountWeiFromFlags(ctx.args.flags, {
+        weiKey: "amount-wei",
+        ghstKey: "amount-ghst",
+        label: "Bid amount",
+    });
+    const maxTotalWei = parseAmountWeiFromFlags(ctx.args.flags, {
+        weiKey: "max-total-wei",
+        ghstKey: "max-total-ghst",
+        label: "Max total bid amount",
+    });
+    if (maxTotalWei < amountWei) {
+        throw new errors_1.CliError("INVALID_ARGUMENT", "max total amount must be greater than or equal to amount per auction.", 2, {
+            amountWei: amountWei.toString(),
+            maxTotalWei: maxTotalWei.toString(),
+        });
+    }
+    const first = parseBoundedIntFlag((0, args_1.getFlagString)(ctx.args.flags, "first"), "--first", BATCH_DEFAULT_FIRST, 1, BATCH_MAX_FIRST);
+    const skip = parseBoundedIntFlag((0, args_1.getFlagString)(ctx.args.flags, "skip"), "--skip", 0, 0, 100000);
+    const now = Math.floor(Date.now() / 1000).toString();
+    const response = await (0, client_1.executeSubgraphQuery)({
+        source: "gbm-base",
+        queryName: "auction.bid-unbid.active",
+        query: queries_1.GBM_ACTIVE_AUCTIONS_QUERY,
+        variables: {
+            now,
+            first,
+            skip,
+        },
+    });
+    if (!Array.isArray(response.data.auctions)) {
+        throw new errors_1.CliError("SUBGRAPH_INVALID_RESPONSE", "Expected auctions to be an array.", 2, {
+            source: response.source,
+            endpoint: response.endpoint,
+            queryName: response.queryName,
+        });
+    }
+    const activeAuctions = (0, normalize_1.normalizeGbmAuctions)(response.data.auctions);
+    const skipped = [];
+    const selected = [];
+    let plannedTotalWei = 0n;
+    for (const auction of activeAuctions) {
+        const auctionId = auction.id;
+        const highestBidWei = parseNonNegativeBigint(auction.highestBid, "highestBid");
+        const startBidWei = parseNonNegativeBigint(auction.startBidPrice || "0", "startBidPrice");
+        const highestBidder = auction.highestBidder || ZERO_ADDRESS;
+        const unbid = highestBidWei === 0n && highestBidder === ZERO_ADDRESS;
+        if (!unbid) {
+            skipped.push({
+                auctionId,
+                reasonCode: "NOT_UNBID",
+                reason: "Auction already has a highest bid.",
+                highestBidWei: highestBidWei.toString(),
+                highestBidder,
+            });
+            continue;
+        }
+        if (startBidWei > amountWei) {
+            skipped.push({
+                auctionId,
+                reasonCode: "START_BID_ABOVE_AMOUNT",
+                reason: "Auction start bid is above the configured amount.",
+                startBidWei: startBidWei.toString(),
+                amountWei: amountWei.toString(),
+            });
+            continue;
+        }
+        if (plannedTotalWei + amountWei > maxTotalWei) {
+            skipped.push({
+                auctionId,
+                reasonCode: "MAX_TOTAL_REACHED",
+                reason: "Adding this auction would exceed max total amount.",
+                plannedTotalWei: plannedTotalWei.toString(),
+                maxTotalWei: maxTotalWei.toString(),
+            });
+            continue;
+        }
+        selected.push(auctionId);
+        plannedTotalWei += amountWei;
+    }
+    const baseIdempotencyKey = (0, args_1.getFlagString)(ctx.args.flags, "idempotency-key");
+    const results = [];
+    for (const auctionId of selected) {
+        const stepFlags = { ...ctx.args.flags };
+        delete stepFlags["amount-ghst"];
+        delete stepFlags["max-total-ghst"];
+        delete stepFlags["max-total-wei"];
+        delete stepFlags.first;
+        delete stepFlags.skip;
+        stepFlags["auction-id"] = auctionId;
+        stepFlags["amount-wei"] = amountWei.toString();
+        stepFlags["require-unbid"] = true;
+        stepFlags["expected-highest-bid-wei"] = "0";
+        stepFlags["idempotency-key"] = parseBatchIdempotencyKey(baseIdempotencyKey, auctionId, amountWei);
+        const stepCtx = {
+            commandPath: ["auction", "bid"],
+            args: {
+                positionals: ["auction", "bid"],
+                flags: stepFlags,
+            },
+            globals: ctx.globals,
+        };
+        try {
+            const result = await runSingleBid(stepCtx, {
+                forceAuctionId: auctionId,
+                forceAmountWei: amountWei,
+                forceExpectedHighestBidWei: 0n,
+                forceRequireUnbid: true,
+                forceIdempotencyKey: parseBatchIdempotencyKey(baseIdempotencyKey, auctionId, amountWei),
+            });
+            results.push({
+                auctionId,
+                status: "ok",
+                result,
+            });
+        }
+        catch (error) {
+            if (error instanceof errors_1.CliError) {
+                results.push({
+                    auctionId,
+                    status: "error",
+                    code: error.code,
+                    message: error.message,
+                    details: error.details || null,
+                });
+                continue;
+            }
+            throw error;
+        }
+    }
+    const okCount = results.filter((result) => result.status === "ok").length;
+    const errorCount = results.length - okCount;
+    return {
+        command: "auction bid-unbid",
+        amountWei: amountWei.toString(),
+        maxTotalWei: maxTotalWei.toString(),
+        atTime: now,
+        scanned: activeAuctions.length,
+        selected: selected.length,
+        plannedTotalWei: plannedTotalWei.toString(),
+        summary: {
+            success: okCount,
+            error: errorCount,
+            skipped: skipped.length,
+        },
+        skipped,
+        results,
+    };
+}