@sage-protocol/cli 0.8.2 → 0.8.4

package/dist/cli/commands/boost.js

@@ -9,6 +9,45 @@ function register(program) {
     .description('USDC governance boosts (direct or policy-based)')
     .addHelpText('after', `\nAgent/Automation Support:\n  Use -y/--yes flag or SAGE_YES=1 environment variable to skip all interactive prompts.\n\nExamples:\n  $ sage boost create --proposal-id 1 --governor 0x... --per-voter 1000000 --max-voters 100 --yes\n  $ sage boost fund --proposal-id 1 --amount 10000000 -y\n`);
 
+  const resolveSubgraphUrl = () => (cliConfig.resolveSubgraphUrl ? cliConfig.resolveSubgraphUrl() : (
+    process.env.SUBGRAPH_URL || process.env.SAGE_SUBGRAPH_URL || process.env.NEXT_PUBLIC_GRAPH_ENDPOINT || process.env.NEXT_PUBLIC_SUBGRAPH_URL || null
+  ));
+
+  const parseProofInput = (value) => {
+    const fs = require('fs');
+    if (!value) return null;
+    let raw = String(value).trim();
+    if (!raw.startsWith('[')) {
+      raw = fs.readFileSync(raw, 'utf8');
+    }
+    return JSON.parse(raw);
+  };
+
+  const detectManagerType = async (provider, address) => {
+    const directIface = new ethers.Interface([
+      'function getBoost(uint256) view returns (tuple(address creator, address governor, uint256 proposalId, uint256 snapshot, uint256 perVoter, uint256 maxVoters, uint256 votersPaid, uint96 minVotes, uint8 payoutMode, uint8 support, uint256 startAt, uint256 expiresAt, uint256 totalPool, uint256 totalPaid, uint8 kind, address policy, bool active, bool paused) boost)'
+    ]);
+    const merkleIface = new ethers.Interface([
+      'function getBoost(uint256) view returns (uint256,uint256,bytes32,bool,bool,address)'
+    ]);
+    try {
+      const callData = directIface.encodeFunctionData('getBoost', [0n]);
+      const ret = await provider.call({ to: address, data: callData });
+      directIface.decodeFunctionResult('getBoost', ret);
+      return 'direct';
+    } catch (_) {
+      try {
+        const callDataM = merkleIface.encodeFunctionData('getBoost', [0n]);
+        const retM = await provider.call({ to: address, data: callDataM });
+        merkleIface.decodeFunctionResult('getBoost', retM);
+        return 'merkle';
+      } catch (_) {
+        return 'unknown';
+      }
+    }
+  };
+
+
   boost
     .command('create')
     .description('Create a boost (direct/Merkle/custom) with payout mode and time window')
@@ -49,31 +88,7 @@ function register(program) {
         if (!usdcAddr) throw new Error('Missing USDC token (env USDC_ADDRESS/MOCK_USDC_ADDRESS) and manager.usdc() not readable');
 
         // ===== Manager-type preflight (DIRECT vs MERKLE) =====
-        const detectManagerType = async (address) => {
-          const directIface = new ethers.Interface([
-            'function getBoost(uint256) view returns (tuple(address creator, address governor, uint256 proposalId, uint256 snapshot, uint256 perVoter, uint256 maxVoters, uint256 votersPaid, uint96 minVotes, uint8 payoutMode, uint8 support, uint256 startAt, uint256 expiresAt, uint256 totalPool, uint256 totalPaid, uint8 kind, address policy, bool active, bool paused) boost)'
-          ]);
-          const merkleIface = new ethers.Interface([
-            'function getBoost(uint256) view returns (uint256,uint256,bytes32,bool,bool,address)'
-          ]);
-          try {
-            const callData = directIface.encodeFunctionData('getBoost', [0n]);
-            const ret = await provider.call({ to: address, data: callData });
-            directIface.decodeFunctionResult('getBoost', ret); // will throw if not direct
-            return 'direct';
-          } catch (_) {
-            try {
-              const callDataM = merkleIface.encodeFunctionData('getBoost', [0n]);
-              const retM = await provider.call({ to: address, data: callDataM });
-              merkleIface.decodeFunctionResult('getBoost', retM);
-              return 'merkle';
-            } catch (_) {
-              return 'unknown';
-            }
-          }
-        };
-
-        const mgrType = await detectManagerType(mgrAddr);
+        const mgrType = await detectManagerType(provider, mgrAddr);
         if (mgrType === 'merkle') {
           ui.error(`Detected Merkle boost manager at ${mgrAddr}`);
           ui.output('   This command uses the DIRECT manager ABI (createBoost(address,uint256,...)).');
@@ -288,18 +303,266 @@ function register(program) {
       } catch (e) { handleCLIError(e, 'set-root'); }
     });
 
+  boost
+    .command('list')
+    .description('List boosts (direct/merkle) using subgraph or on-chain logs')
+    .option('--type <type>', 'direct|merkle|auto (default: auto)', 'auto')
+    .option('--manager <address>', 'Boost manager address (overrides default for the selected type)')
+    .option('--governor <address>', 'Filter by governor (direct only)')
+    .option('--proposal-id <id>', 'Filter by proposal ID')
+    .option('--active', 'Only show active boosts', false)
+    .option('--from-block <n>', 'Start block for on-chain log scan (fallback)')
+    .option('--limit <n>', 'Maximum number of results (default: 25)', '25')
+    .option('--json', 'Output JSON', false)
+    .action(async (opts) => {
+      try {
+        const { enterJsonMode, withJsonVersion } = require('../utils/json-output');
+        enterJsonMode(opts);
+        ui.configure({ json: opts.json });
+        const WM = require('../wallet-manager');
+        const wm = new WM(); await wm.connect();
+        const provider = wm.getProvider();
+
+        const limit = Math.max(1, Number(opts.limit || 25));
+        let type = String(opts.type || 'auto').toLowerCase();
+        const proposalId = opts.proposalId ? BigInt(opts.proposalId) : null;
+        const governor = opts.governor ? String(opts.governor).toLowerCase() : null;
+
+        let directManager = cliConfig.resolveAddress('BOOST_MANAGER_DIRECT_ADDRESS', process.env.BOOST_MANAGER_DIRECT_ADDRESS) || cliConfig.resolveAddress('BOOST_MANAGER_ADDRESS');
+        let merkleManager = cliConfig.resolveAddress('BOOST_MANAGER_ADDRESS');
+        const loggerGlue = cliConfig.resolveAddress('BOOST_LOGGER_GLUE_ADDRESS', process.env.BOOST_LOGGER_GLUE_ADDRESS);
+
+        const results = [];
+        const sources = [];
+
+        if (opts.manager) {
+          if (type === 'direct') {
+            directManager = opts.manager;
+          } else if (type === 'merkle') {
+            merkleManager = opts.manager;
+          } else {
+            const detected = await detectManagerType(provider, opts.manager);
+            if (detected === 'direct') {
+              directManager = opts.manager;
+              type = 'direct';
+            } else if (detected === 'merkle') {
+              merkleManager = opts.manager;
+              type = 'merkle';
+            } else {
+              throw new Error(`Unknown boost manager type at ${opts.manager}. Pass --type direct|merkle.`);
+            }
+          }
+        }
+
+        const fetchDirectFromSubgraph = async () => {
+          const subgraphUrl = resolveSubgraphUrl();
+          if (!subgraphUrl) return null;
+          const { querySubgraph } = require('../utils/subgraph-client');
+          const where = {};
+          if (proposalId != null) where.proposalId = proposalId.toString();
+          if (governor) where.governor = governor;
+          const query = `
+            query BoostEvents($first: Int!, $skip: Int!, $orderBy: String!, $orderDirection: String!, $where: BoostEvent_filter) {
+              boostEvents(first: $first, skip: $skip, orderBy: $orderBy, orderDirection: $orderDirection, where: $where) {
+                id
+                proposalId
+                governor
+                perVoter
+                maxVoters
+                snapshot
+                kind
+                policy
+                minVotes
+                blockTimestamp
+                transactionHash
+              }
+            }
+          `;
+          const data = await querySubgraph(query, {
+            first: limit,
+            skip: 0,
+            orderBy: 'blockTimestamp',
+            orderDirection: 'desc',
+            where
+          }, { subgraphUrl });
+          return data?.boostEvents || [];
+        };
+
+        const fetchDirectFromLogs = async () => {
+          if (!loggerGlue) throw new Error('Missing BOOST_LOGGER_GLUE_ADDRESS for log scan fallback');
+          const iface = new ethers.Interface([
+            'event BoostCreated(uint256 indexed proposalId, address indexed governor, uint256 perVoter, uint256 maxVoters, uint256 snapshot, uint8 kind, address policy, uint96 minVotes)'
+          ]);
+          const latest = await provider.getBlockNumber();
+          const fromBlock = opts.fromBlock ? Number(opts.fromBlock) : Math.max(0, latest - 200000);
+          const topics = [iface.getEvent('BoostCreated').topicHash, null, null];
+          if (proposalId != null) topics[1] = ethers.zeroPadValue(ethers.toBeHex(proposalId), 32);
+          if (governor) topics[2] = ethers.zeroPadValue(governor, 32);
+          const logs = await provider.getLogs({ address: loggerGlue, fromBlock, toBlock: latest, topics });
+          return logs.map((log) => {
+            const parsed = iface.parseLog(log);
+            return {
+              id: `${log.transactionHash}-${log.logIndex}`,
+              proposalId: parsed.args.proposalId.toString(),
+              governor: parsed.args.governor,
+              perVoter: parsed.args.perVoter.toString(),
+              maxVoters: parsed.args.maxVoters.toString(),
+              snapshot: parsed.args.snapshot.toString(),
+              kind: Number(parsed.args.kind),
+              policy: parsed.args.policy,
+              minVotes: parsed.args.minVotes.toString(),
+              blockTimestamp: String(log.blockNumber || ''),
+              transactionHash: log.transactionHash
+            };
+          }).slice(0, limit);
+        };
+
+        const fetchMerkleFromLogs = async () => {
+          if (!merkleManager) throw new Error('Missing BOOST_MANAGER_ADDRESS for merkle listing');
+          const iface = new ethers.Interface([
+            'event BoostCreated(uint256 indexed proposalId, address indexed creator, uint256 totalPool)'
+          ]);
+          const latest = await provider.getBlockNumber();
+          const fromBlock = opts.fromBlock ? Number(opts.fromBlock) : Math.max(0, latest - 200000);
+          const topics = [iface.getEvent('BoostCreated').topicHash];
+          if (proposalId != null) topics.push(ethers.zeroPadValue(ethers.toBeHex(proposalId), 32));
+          const logs = await provider.getLogs({ address: merkleManager, fromBlock, toBlock: latest, topics });
+          return logs.map((log) => {
+            const parsed = iface.parseLog(log);
+            return {
+              id: `${log.transactionHash}-${log.logIndex}`,
+              proposalId: parsed.args.proposalId.toString(),
+              creator: parsed.args.creator,
+              totalPool: parsed.args.totalPool.toString(),
+              transactionHash: log.transactionHash
+            };
+          }).slice(0, limit);
+        };
+
+        const enrichDirect = async (items) => {
+          if (!directManager) return items;
+          const ifDirect = new ethers.Interface([
+            'function getBoost(uint256) view returns (tuple(address creator, address governor, uint256 proposalId, uint256 snapshot, uint256 perVoter, uint256 maxVoters, uint256 votersPaid, uint96 minVotes, uint8 payoutMode, uint8 support, uint256 startAt, uint256 expiresAt, uint256 totalPool, uint256 totalPaid, uint8 kind, address policy, bool active, bool paused) boost)'
+          ]);
+          const enriched = await Promise.all(items.map(async (row) => {
+            try {
+              const ret = await provider.call({ to: directManager, data: ifDirect.encodeFunctionData('getBoost', [BigInt(row.proposalId)]) });
+              const [b] = ifDirect.decodeFunctionResult('getBoost', ret);
+              return {
+                ...row,
+                managerType: 'direct',
+                manager: directManager,
+                active: b.active,
+                paused: b.paused,
+                totalPool: b.totalPool.toString(),
+                totalPaid: b.totalPaid.toString(),
+                votersPaid: b.votersPaid.toString()
+              };
+            } catch (_) {
+              return { ...row, managerType: 'direct', manager: directManager };
+            }
+          }));
+          return enriched;
+        };
+
+        const enrichMerkle = async (items) => {
+          if (!merkleManager) return items;
+          const ifMerkle = new ethers.Interface([
+            'function getBoost(uint256) view returns (uint256,uint256,bytes32,bool,bool,address)'
+          ]);
+          const enriched = await Promise.all(items.map(async (row) => {
+            try {
+              const ret = await provider.call({ to: merkleManager, data: ifMerkle.encodeFunctionData('getBoost', [BigInt(row.proposalId)]) });
+              const [totalPool, totalClaimed, merkleRoot, active, finalized, creator] = ifMerkle.decodeFunctionResult('getBoost', ret);
+              return {
+                ...row,
+                managerType: 'merkle',
+                manager: merkleManager,
+                totalPool: totalPool.toString(),
+                totalClaimed: totalClaimed.toString(),
+                merkleRoot,
+                active,
+                finalized,
+                creator
+              };
+            } catch (_) {
+              return { ...row, managerType: 'merkle', manager: merkleManager };
+            }
+          }));
+          return enriched;
+        };
+
+        if (type === 'direct' || type === 'auto') {
+          let directItems = null;
+          try {
+            directItems = await fetchDirectFromSubgraph();
+            if (directItems?.length) sources.push('subgraph');
+          } catch (e) {
+            ui.warn(`Subgraph query failed: ${e.message}. Falling back to logs.`);
+          }
+          if (!directItems || !directItems.length) {
+            directItems = await fetchDirectFromLogs();
+            sources.push('logs');
+          }
+          const enriched = await enrichDirect(directItems || []);
+          results.push(...enriched);
+        }
+
+        if (type === 'merkle' || type === 'auto') {
+          if (governor && type !== 'direct') {
+            ui.warn('Governor filter is only supported for direct boosts; ignoring for merkle listing.');
+          }
+          const merkleItems = await fetchMerkleFromLogs();
+          sources.push('logs');
+          const enriched = await enrichMerkle(merkleItems || []);
+          results.push(...enriched);
+        }
+
+        const filtered = opts.active ? results.filter(r => r.active) : results;
+        if (opts.json) {
+          ui.json(withJsonVersion({ count: filtered.length, source: sources, boosts: filtered }));
+          return;
+        }
+
+        if (!filtered.length) {
+          ui.info('No boosts found matching the criteria.');
+          return;
+        }
+        ui.output(`Found ${filtered.length} boosts (${sources.join(', ')}):\n`);
+        for (const b of filtered) {
+          if (b.managerType === 'merkle') {
+            ui.output(`[${b.proposalId}] merkle boost`);
+            ui.output(`  Manager: ${b.manager || 'unknown'}`);
+            if (b.totalPool) ui.output(`  Pool: ${b.totalPool} | Claimed: ${b.totalClaimed ?? '0'}`);
+            if (b.active != null) ui.output(`  Active: ${b.active} | Finalized: ${b.finalized ?? false}`);
+          } else {
+            ui.output(`[${b.proposalId}] direct boost`);
+            ui.output(`  Governor: ${b.governor || 'n/a'} | Manager: ${b.manager || 'unknown'}`);
+            ui.output(`  Per Voter: ${b.perVoter} | Max Voters: ${b.maxVoters}`);
+            if (b.totalPool) ui.output(`  Pool: ${b.totalPool} | Paid: ${b.totalPaid ?? '0'} | Voters Paid: ${b.votersPaid ?? '0'}`);
+            if (b.active != null) ui.output(`  Active: ${b.active} | Paused: ${b.paused ?? false}`);
+          }
+          ui.output('');
+        }
+      } catch (e) { handleCLIError(e, 'list'); }
+    });
+
   boost
     .command('status')
     .description('Show boost status for a proposal')
-    .requiredOption('--proposal-id <id>', 'Proposal ID')
+    .option('--proposal-id <id>', 'Proposal ID')
+    .option('--boost-id <id>', 'Alias for proposal ID')
     .option('--manager <address>', 'Boost manager')
     .action(async (opts) => {
       try {
+        if (!opts.proposalId && !opts.boostId) {
+          throw new Error('Missing --proposal-id (or --boost-id)');
+        }
         const WM = require('../wallet-manager');
         const wm = new WM(); await wm.connect();
         const provider = wm.getProvider();
         const mgrAddr = opts.manager || cliConfig.resolveAddress('BOOST_MANAGER_ADDRESS');
-        const id = BigInt(opts.proposalId);
+        const id = BigInt(opts.proposalId || opts.boostId);
         const ifMerkle = new ethers.Interface(['function getBoost(uint256) view returns (uint256,uint256,bytes32,bool,bool,address)']);
         const ifDirect = new ethers.Interface(['function getBoost(uint256) view returns (tuple(address creator, address governor, uint256 proposalId, uint256 snapshot, uint256 perVoter, uint256 maxVoters, uint256 votersPaid, uint96 minVotes, uint8 payoutMode, uint8 support, uint256 startAt, uint256 expiresAt, uint256 totalPool, uint256 totalPaid, uint8 kind, address policy, bool active, bool paused) boost)']);
         // Try DIRECT first
@@ -307,7 +570,7 @@ function register(program) {
           const retD = await provider.call({ to: mgrAddr, data: ifDirect.encodeFunctionData('getBoost', [id]) });
           const [b] = ifDirect.decodeFunctionResult('getBoost', retD);
           const boostData = {
-            managerType: 'direct', proposalId: opts.proposalId,
+            managerType: 'direct', proposalId: String(opts.proposalId || opts.boostId),
             creator: b.creator, governor: b.governor, snapshot: b.snapshot.toString(), perVoter: b.perVoter.toString(),
             maxVoters: b.maxVoters.toString(), votersPaid: b.votersPaid.toString(), minVotes: Number(b.minVotes),
             kind: Number(b.kind), policy: b.policy, active: b.active, paused: b.paused,
@@ -321,7 +584,7 @@ function register(program) {
           const retM = await provider.call({ to: mgrAddr, data: ifMerkle.encodeFunctionData('getBoost', [id]) });
           const [totalPool, totalClaimed, merkleRoot, active, finalized, creator] = ifMerkle.decodeFunctionResult('getBoost', retM);
           const boostData = {
-            managerType: 'merkle', proposalId: opts.proposalId,
+            managerType: 'merkle', proposalId: String(opts.proposalId || opts.boostId),
             totalPool: totalPool.toString(), totalClaimed: totalClaimed.toString(), merkleRoot, active, finalized, creator
           };
           ui.json(boostData);
@@ -347,27 +610,7 @@ function register(program) {
         const mgrAddr = opts.manager || cliConfig.resolveAddress('BOOST_MANAGER_ADDRESS');
 
         // Manager-type preflight + helpful hint if mismatched
-        const detectManagerType = async (address) => {
-          const directIface = new ethers.Interface([
-            'function getBoost(uint256) view returns (tuple(address creator, address governor, uint256 proposalId, uint256 snapshot, uint256 perVoter, uint256 maxVoters, uint256 votersPaid, uint96 minVotes, uint8 payoutMode, uint8 support, uint256 startAt, uint256 expiresAt, uint256 totalPool, uint256 totalPaid, uint8 kind, address policy, bool active, bool paused) boost)'
-          ]);
-          const merkleIface = new ethers.Interface([
-            'function getBoost(uint256) view returns (uint256,uint256,bytes32,bool,bool,address)'
-          ]);
-          try {
-            const retD = await provider.call({ to: address, data: directIface.encodeFunctionData('getBoost', [0n]) });
-            directIface.decodeFunctionResult('getBoost', retD);
-            return 'direct';
-          } catch (_) {
-            try {
-              const retM = await provider.call({ to: address, data: merkleIface.encodeFunctionData('getBoost', [0n]) });
-              merkleIface.decodeFunctionResult('getBoost', retM);
-              return 'merkle';
-            } catch (_) { return 'unknown'; }
-          }
-        };
-
-        const mgrType = await detectManagerType(mgrAddr);
+        const mgrType = await detectManagerType(provider, mgrAddr);
         const id = BigInt(opts.proposalId);
         let looksEmpty = false;
         if (mgrType === 'direct') {
@@ -404,10 +647,12 @@ function register(program) {
 
   boost
     .command('claim')
-    .description('Claim a boost rebate with Merkle proof')
+    .description('Claim a boost rebate (direct or merkle)')
     .requiredOption('--proposal-id <id>', 'Proposal ID')
-    .requiredOption('--amount <usdc>', 'USDC amount (6 decimals)')
-    .requiredOption('--proof <json>', 'JSON array of hex nodes or path to json file')
+    .option('--type <type>', 'direct|merkle|auto (default: auto)', 'auto')
+    .option('--amount <usdc>', 'USDC amount (required for merkle or variable payouts)')
+    .option('--proof <json>', 'JSON array of hex nodes or path to json file')
+    .option('--data <hex>', 'ABI-encoded bytes (overrides proof/amount for direct custom eligibility)')
     .option('--manager <address>', 'Boost manager')
     .option('--json', 'Output JSON', false)
     .action(async (opts) => {
@@ -416,19 +661,51 @@ function register(program) {
         enterJsonMode(opts);
         ui.configure({ json: opts.json });
         const WM = require('../wallet-manager');
-        const fs = require('fs');
         const wm = new WM(); await wm.connect();
         const signer = wm.getSigner();
-        const mgrAddr = opts.manager || cliConfig.resolveAddress('BOOST_MANAGER_ADDRESS');
-        let proofStr = opts.proof;
-        if (!proofStr.startsWith('[')) {
-          proofStr = fs.readFileSync(proofStr, 'utf8');
+        const provider = wm.getProvider();
+        const mgrAddr = opts.manager || cliConfig.resolveAddress('BOOST_MANAGER_ADDRESS') || cliConfig.resolveAddress('BOOST_MANAGER_DIRECT_ADDRESS');
+
+        const type = String(opts.type || 'auto').toLowerCase();
+        const managerType = type === 'auto' ? await detectManagerType(provider, mgrAddr) : type;
+
+        if (managerType === 'merkle') {
+          if (!opts.amount) throw new Error('--amount is required for merkle claims');
+          if (!opts.proof) throw new Error('--proof is required for merkle claims');
+          const proof = parseProofInput(opts.proof);
+          const iface = new ethers.Interface(['function claim(uint256,address,uint256,bytes32[])']);
+          const tx = await signer.sendTransaction({ to: mgrAddr, data: iface.encodeFunctionData('claim', [BigInt(opts.proposalId), await signer.getAddress(), BigInt(String(opts.amount).replace(/_/g, '')), proof]) });
+          if (opts.json) {
+            printOk({ proposalId: String(opts.proposalId), boostId: String(opts.proposalId), manager: mgrAddr, amount: String(opts.amount), txHash: tx.hash });
+            return;
+          }
+          ui.success(`Transaction sent: ${tx.hash}`);
+          return;
+        }
+
+        if (managerType !== 'direct') {
+          throw new Error(`Unknown boost manager type at ${mgrAddr}. Pass --type direct|merkle.`);
+        }
+
+        let data = opts.data;
+        if (!data) {
+          if (opts.proof) {
+            const proof = parseProofInput(opts.proof);
+            const coder = ethers.AbiCoder.defaultAbiCoder();
+            if (opts.amount) {
+              data = coder.encode(['bytes32[]', 'uint256'], [proof, BigInt(String(opts.amount).replace(/_/g, ''))]);
+            } else {
+              data = coder.encode(['bytes32[]'], [proof]);
+            }
+          } else {
+            data = '0x';
+          }
         }
-        const proof = JSON.parse(proofStr);
-        const iface = new ethers.Interface(['function claim(uint256,address,uint256,bytes32[])']);
-        const tx = await signer.sendTransaction({ to: mgrAddr, data: iface.encodeFunctionData('claim', [BigInt(opts.proposalId), await signer.getAddress(), BigInt(opts.amount), proof]) });
+
+        const iface = new ethers.Interface(['function claim(uint256,bytes)']);
+        const tx = await signer.sendTransaction({ to: mgrAddr, data: iface.encodeFunctionData('claim', [BigInt(opts.proposalId), data]) });
         if (opts.json) {
-          printOk({ proposalId: String(opts.proposalId), boostId: String(opts.proposalId), manager: mgrAddr, amount: String(opts.amount), txHash: tx.hash });
+          printOk({ proposalId: String(opts.proposalId), boostId: String(opts.proposalId), manager: mgrAddr, txHash: tx.hash, managerType: 'direct' });
           return;
         }
         ui.success(`Transaction sent: ${tx.hash}`);

package/dist/cli/commands/bounty.js

@@ -1709,6 +1709,7 @@ function register(program) {
     .option('--limit <number>', 'Maximum number of bounties to show', '10')
     .option('--dao <address>', 'Filter by DAO/SubDAO/Governor address')
     .option('--subdao <address>', 'Alias for --dao')
+    .option('--json', 'Output JSON', false)
     .action(async (opts) => {
       try {
         const bountySystem = cliConfig.resolveAddress('SIMPLE_BOUNTY_SYSTEM_ADDRESS');
@@ -1718,7 +1719,7 @@ function register(program) {
           return;
         }
 
-        const rpcUrl = cliConfig.resolveRpcUrl();
+        const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
 
         // Resolve dao filter to governor address if provided
         let governorFilter = null;
@@ -1745,14 +1746,17 @@ function register(program) {
         const nextIdBigInt = await contracts.getNextBountyId(bountySystem, rpcUrl);
         const totalBounties = Number(nextIdBigInt);
 
-        ui.info(`Found ${totalBounties} total bounties`);
-        ui.header('Bounty List');
+        if (!opts.json) {
+          ui.info(`Found ${totalBounties} total bounties`);
+          ui.header('Bounty List');
+        }
 
         const limit = Math.min(parseInt(opts.limit), totalBounties);
         const statusFilter = opts.status?.toUpperCase();
         const statusMap = { 'ACTIVE': 0, 'CLAIMED': 1, 'COMPLETED': 2, 'CANCELLED': 3, 'EXPIRED': 4, 'UNDER_REVIEW': 5 };
 
         let displayed = 0;
+        const results = [];
         for (let i = 0; i < totalBounties && displayed < limit; i++) {
           try {
             const bounty = await contracts.getBounty(bountySystem, i, rpcUrl);
@@ -1773,7 +1777,22 @@ function register(program) {
             const statusNames = ['ACTIVE', 'CLAIMED', 'COMPLETED', 'CANCELLED', 'EXPIRED', 'UNDER_REVIEW'];
             const rewardEther = ethers.formatEther(reward);
 
-            ui.output(`ID: ${i} | Status: ${statusNames[status]} | Reward: ${rewardEther} SXXX`);
+            results.push({
+              id: i,
+              status: statusNames[status] || String(status),
+              rewardWei: reward?.toString?.() || String(reward),
+              rewardSxxx: rewardEther,
+              creator: bounty.creator || null,
+              deadline: bounty.deadline?.toString?.() || null,
+              minContributorLevel: bounty.minContributorLevel?.toString?.() || null,
+              minTokenBalance: bounty.minTokenBalance?.toString?.() || null,
+              requiredBadgeId: bounty.requiredBadgeId?.toString?.() || null,
+              libraryAction: bounty.libraryAction?.toString?.() || null
+            });
+
+            if (!opts.json) {
+              ui.output(`ID: ${i} | Status: ${statusNames[status]} | Reward: ${rewardEther} SXXX`);
+            }
             displayed++;
 
           } catch (e) {
@@ -1782,6 +1801,11 @@ function register(program) {
           }
         }
 
+        if (opts.json) {
+          ui.json({ ok: true, total: totalBounties, count: results.length, bounties: results });
+          return;
+        }
+
         if (displayed === 0) {
           ui.info('No bounties found matching the criteria');
         }

package/dist/cli/commands/config.js

@@ -762,7 +762,16 @@ function register(program) {
     .addCommand(
       new Command('show')
         .description('Show current configuration')
-        .action(() => {
+        .option('--json', 'Output JSON', false)
+        .action((opts) => {
+          if (opts.json) {
+            ui.json({
+              ok: true,
+              projectDir: config.getProjectDir(),
+              envPath: path.join(config.getProjectDir(), '.env')
+            });
+            return;
+          }
           ui.keyValue({
             'Current project directory': config.getProjectDir(),
             '.env file location': path.join(config.getProjectDir(), '.env')

package/dist/cli/commands/contributor.js

@@ -16,10 +16,19 @@ function register(program) {
           try {
             const chalk = { green: (s)=>s, yellow: (s)=>s, red: (s)=>s, cyan: (s)=>s, gray: (s)=>s };
             const { ethers } = require('ethers');
-            const sxxxTokenAddress = cliConfig.resolveAddress('SXXX_TOKEN_ADDRESS');
             const system = cliConfig.resolveAddress('SIMPLE_CONTRIBUTOR_SYSTEM_ADDRESS');
             if (!system) throw new Error('SimpleContributorSystem address not configured');
+            const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
+            const provider = new ethers.JsonRpcProvider(rpcUrl);
+            const sysAbi = resolveArtifact('contracts/SimpleContributorSystem.sol/SimpleContributorSystem.json').abi;
+            const sysRead = new ethers.Contract(system, sysAbi, provider);
+            const systemToken = await sysRead.sxxxToken().catch(() => null);
+            const cfgToken = cliConfig.resolveAddress('SXXX_TOKEN_ADDRESS');
+            const sxxxTokenAddress = systemToken || cfgToken;
             if (!sxxxTokenAddress) throw new Error('SXXX token address not configured');
+            if (systemToken && cfgToken && systemToken.toLowerCase() !== cfgToken.toLowerCase()) {
+              ui.warn(`SXXX token mismatch: contributor system uses ${systemToken}, config has ${cfgToken}. Using system token.`);
+            }
             const WM = require('../wallet-manager');
             const wm = new WM();
             await wm.connect();
@@ -36,13 +45,12 @@ function register(program) {
             const ERC20 = [ 'function approve(address,uint256) returns (bool)' ];
             const tok = new ethers.Contract(sxxxTokenAddress, ERC20, signer);
             const txa = await tok.approve(system, amountWei);
-            { const { waitForReceipt } = require('../utils/tx-wait'); const pr = new (require('ethers')).JsonRpcProvider(process.env.RPC_URL || process.env.BASE_SEPOLIA_RPC || process.env.BASE_RPC_URL || 'https://base-sepolia.publicnode.com'); await waitForReceipt(pr, txa, Number(process.env.SAGE_TX_WAIT_MS || 60000)); }
+            { const { waitForReceipt } = require('../utils/tx-wait'); await waitForReceipt(provider, txa, Number(process.env.SAGE_TX_WAIT_MS || 60000)); }
             ui.success('SXXX approval confirmed');
             ui.info('Staking tokens...');
-            const sysAbi = resolveArtifact('contracts/SimpleContributorSystem.sol/SimpleContributorSystem.json').abi;
             const c = new ethers.Contract(system, sysAbi, signer);
             const txs = await c.stake(amountWei);
-            { const { waitForReceipt } = require('../utils/tx-wait'); const pr = new (require('ethers')).JsonRpcProvider(process.env.RPC_URL || process.env.BASE_SEPOLIA_RPC || process.env.BASE_RPC_URL || 'https://base-sepolia.publicnode.com'); await waitForReceipt(pr, txs, Number(process.env.SAGE_TX_WAIT_MS || 60000)); }
+            { const { waitForReceipt } = require('../utils/tx-wait'); await waitForReceipt(provider, txs, Number(process.env.SAGE_TX_WAIT_MS || 60000)); }
             if (options.json) ui.json({ success: true, amount: amountWei.toString() });
             else ui.success(`Successfully staked ${ethers.formatEther(amountWei)} SXXX`);
           } catch (error) {
@@ -61,6 +69,8 @@ function register(program) {
             const { ethers } = require('ethers');
             const system = cliConfig.resolveAddress('SIMPLE_CONTRIBUTOR_SYSTEM_ADDRESS');
             if (!system) throw new Error('SimpleContributorSystem address not configured');
+            const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
+            const provider = new ethers.JsonRpcProvider(rpcUrl);
             const WM = require('../wallet-manager');
             const wm = new WM();
             await wm.connect();
@@ -72,7 +82,7 @@ function register(program) {
             const sysAbi = resolveArtifact('contracts/SimpleContributorSystem.sol/SimpleContributorSystem.json').abi;
             const c = new ethers.Contract(system, sysAbi, signer);
             const tx = await c.withdrawStake(amountWei);
-            { const { waitForReceipt } = require('../utils/tx-wait'); const pr = new (require('ethers')).JsonRpcProvider(process.env.RPC_URL || process.env.BASE_SEPOLIA_RPC || process.env.BASE_RPC_URL || 'https://base-sepolia.publicnode.com'); await waitForReceipt(pr, tx, Number(process.env.SAGE_TX_WAIT_MS || 60000)); }
+            { const { waitForReceipt } = require('../utils/tx-wait'); await waitForReceipt(provider, tx, Number(process.env.SAGE_TX_WAIT_MS || 60000)); }
             if (options.json) ui.json({ success: true, amount: amountWei.toString() });
             else ui.success(`Successfully unstaked ${ethers.formatEther(amountWei)} SXXX`);
           } catch (error) {
@@ -91,7 +101,7 @@ function register(program) {
             const { ethers } = require('ethers');
             const system = cliConfig.resolveAddress('SIMPLE_CONTRIBUTOR_SYSTEM_ADDRESS');
             if (!system) throw new Error('SimpleContributorSystem address not configured');
-            const rpcUrl = process.env.RPC_URL || 'https://base-sepolia.publicnode.com';
+            const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
             const provider = new ethers.JsonRpcProvider(rpcUrl);
             const sysAbi = resolveArtifact('contracts/SimpleContributorSystem.sol/SimpleContributorSystem.json').abi;
             const c = new ethers.Contract(system, sysAbi, provider);

package/dist/cli/commands/discover.js

@@ -41,7 +41,7 @@ function register(program) {
         if (options.tags) params.set('tags', options.tags);
         if (options.vector === false) params.set('useVector', 'false');
 
-        const { body } = await client._fetchJson(`/discover/search?${params}`);
+        const { body } = await client._fetchJson(`/prompts/search?${params}`);
 
         if (options.json) {
           ui.json(body);
@@ -167,7 +167,7 @@ function register(program) {
           method: options.method,
         });
 
-        const { body } = await client._fetchJson(`/discover/similar/${cid}?${params}`);
+        const { body } = await client._fetchJson(`/prompts/similar/${cid}?${params}`);
 
         if (options.json) {
           ui.json(body);
@@ -246,7 +246,7 @@ function register(program) {
           payload.diversify = true;
         }
 
-        const { body } = await client._fetchJson('/discover/match', {
+        const { body } = await client._fetchJson('/prompts/match', {
           method: 'POST',
           headers: client.headers(),
           body: JSON.stringify(payload),