pandora-cli-skills 1.1.53 → 1.1.54

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: pandora-cli-skills
 summary: Canonical skill and operator guide for Pandora CLI including mirror, polymarket, resolve, and LP flows.
-version: 1.1.53
+version: 1.1.54
 ---
 
 # Pandora CLI & Skills

package/cli/lib/market_admin_service.cjs

@@ -153,6 +153,32 @@ const POLL_STATUS_READ_CANDIDATES = [
 ];
 
 const POLL_FINALIZED_READ_CANDIDATES = [
+  {
+    fn: 'getFinalizedStatus',
+    kind: 'status-answer-epoch',
+    abi: [
+      {
+        type: 'function',
+        name: 'getFinalizedStatus',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'uint8' }, { type: 'uint8' }, { type: 'uint32' }],
+      },
+    ],
+  },
+  {
+    fn: 'getFinalizedStatus',
+    kind: 'bool-answer-epoch',
+    abi: [
+      {
+        type: 'function',
+        name: 'getFinalizedStatus',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ type: 'bool' }, { type: 'uint8' }, { type: 'uint32' }],
+      },
+    ],
+  },
   { fn: 'getFinalizedStatus', abi: [{ type: 'function', name: 'getFinalizedStatus', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] }] },
   { fn: 'isFinalized', abi: [{ type: 'function', name: 'isFinalized', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] }] },
   { fn: 'finalized', abi: [{ type: 'function', name: 'finalized', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] }] },
@@ -179,6 +205,28 @@ const POLL_FINALIZATION_EPOCH_READ_CANDIDATES = [
   },
 ];
 
+const POLL_CURRENT_EPOCH_READ_CANDIDATES = [
+  {
+    fn: 'getCurrentEpoch',
+    abi: [{ type: 'function', name: 'getCurrentEpoch', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] }],
+  },
+  {
+    fn: 'currentEpoch',
+    abi: [{ type: 'function', name: 'currentEpoch', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] }],
+  },
+];
+
+const POLL_EPOCH_LENGTH_READ_CANDIDATES = [
+  {
+    fn: 'getEpochLength',
+    abi: [{ type: 'function', name: 'getEpochLength', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] }],
+  },
+  {
+    fn: 'epochLength',
+    abi: [{ type: 'function', name: 'epochLength', stateMutability: 'view', inputs: [], outputs: [{ type: 'uint256' }] }],
+  },
+];
+
 const POLL_OPERATOR_READ_CANDIDATES = [
   { fn: 'arbiter', abi: [{ type: 'function', name: 'arbiter', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] }] },
   { fn: 'operator', abi: [{ type: 'function', name: 'operator', stateMutability: 'view', inputs: [], outputs: [{ type: 'address' }] }] },
@@ -380,12 +428,12 @@ async function tryReadContractAny(publicClient, address, candidates = []) {
         functionName: candidate.fn,
         args: [],
       });
-      return { ok: true, fn: candidate.fn, value };
+      return { ok: true, fn: candidate.fn, value, candidate };
     } catch {
       // continue
     }
   }
-  return { ok: false, fn: null, value: null };
+  return { ok: false, fn: null, value: null, candidate: null };
 }
 
 function normalizeOptionalBigInt(value) {
@@ -415,6 +463,14 @@ function normalizePollAnswer(value) {
   return String(asBig);
 }
 
+function deriveCurrentEpochFromTimestamp(timestamp, epochLengthSeconds = 300n) {
+  const ts = normalizeOptionalBigInt(timestamp);
+  if (ts === null) return null;
+  const epochLength = normalizeOptionalBigInt(epochLengthSeconds);
+  if (epochLength === null || epochLength <= 0n) return null;
+  return ts / epochLength;
+}
+
 async function readPollResolutionState(publicClient, pollAddress) {
   const statusRead = await tryReadContractAny(publicClient, pollAddress, POLL_STATUS_READ_CANDIDATES);
   const finalizedRead = await tryReadContractAny(publicClient, pollAddress, POLL_FINALIZED_READ_CANDIDATES);
@@ -425,14 +481,50 @@ async function readPollResolutionState(publicClient, pollAddress) {
     POLL_FINALIZATION_EPOCH_READ_CANDIDATES,
   );
   const operatorRead = await tryReadContractAny(publicClient, pollAddress, POLL_OPERATOR_READ_CANDIDATES);
-  const currentEpoch = await publicClient.getBlockNumber();
+  const currentEpochRead = await tryReadContractAny(publicClient, pollAddress, POLL_CURRENT_EPOCH_READ_CANDIDATES);
+  const epochLengthRead = await tryReadContractAny(publicClient, pollAddress, POLL_EPOCH_LENGTH_READ_CANDIDATES);
+
+  let currentEpoch = currentEpochRead.ok ? normalizeOptionalBigInt(currentEpochRead.value) : null;
+  if (currentEpoch === null) {
+    try {
+      const block = await publicClient.getBlock({ blockTag: 'latest' });
+      const epochLength = epochLengthRead.ok ? normalizeOptionalBigInt(epochLengthRead.value) : 300n;
+      currentEpoch = deriveCurrentEpochFromTimestamp(block && block.timestamp, epochLength === null ? 300n : epochLength);
+    } catch {
+      currentEpoch = null;
+    }
+  }
 
   const statusNumeric = statusRead.ok ? Number(statusRead.value) : null;
-  const finalizedBool = finalizedRead.ok ? Boolean(finalizedRead.value) : null;
-  const answer = answerRead.ok ? normalizePollAnswer(answerRead.value) : null;
-  const finalizationEpoch = finalizationEpochRead.ok ? normalizeOptionalBigInt(finalizationEpochRead.value) : null;
+  let finalizedBool = null;
+  let finalizedAnswer = null;
+  let finalizedEpoch = null;
+  if (finalizedRead.ok) {
+    const kind = finalizedRead.candidate && finalizedRead.candidate.kind ? finalizedRead.candidate.kind : null;
+    if (kind === 'status-answer-epoch' || kind === 'bool-answer-epoch') {
+      const tuple = Array.isArray(finalizedRead.value) ? finalizedRead.value : null;
+      if (tuple && tuple.length >= 3) {
+        if (kind === 'status-answer-epoch') {
+          const statusRaw = normalizeOptionalBigInt(tuple[0]);
+          finalizedBool = statusRaw === null ? null : statusRaw >= 2n;
+        } else {
+          finalizedBool = Boolean(tuple[0]);
+        }
+        finalizedAnswer = normalizePollAnswer(tuple[1]);
+        finalizedEpoch = normalizeOptionalBigInt(tuple[2]);
+      }
+    } else {
+      finalizedBool = Boolean(finalizedRead.value);
+    }
+  }
+  const answer = answerRead.ok ? normalizePollAnswer(answerRead.value) : finalizedAnswer;
+  const finalizationEpoch = finalizationEpochRead.ok ? normalizeOptionalBigInt(finalizationEpochRead.value) : finalizedEpoch;
   const epochsUntilFinalization =
-    finalizationEpoch === null ? null : finalizationEpoch > currentEpoch ? Number(finalizationEpoch - currentEpoch) : 0;
+    (finalizationEpoch === null || currentEpoch === null)
+      ? null
+      : finalizationEpoch > currentEpoch
+        ? Number(finalizationEpoch - currentEpoch)
+        : 0;
   const claimable =
     answer !== null &&
     ((finalizedBool === true) || (epochsUntilFinalization !== null && epochsUntilFinalization <= 0));
@@ -443,7 +535,7 @@ async function readPollResolutionState(publicClient, pollAddress) {
     pollFinalized: finalizedBool,
     pollAnswer: answer,
     finalizationEpoch: finalizationEpoch === null ? null : finalizationEpoch.toString(),
-    currentEpoch: currentEpoch.toString(),
+    currentEpoch: currentEpoch === null ? null : currentEpoch.toString(),
     epochsUntilFinalization,
     claimable,
     operator: operatorRead.ok ? normalizeOptionalAddress(operatorRead.value) : null,
@@ -452,6 +544,8 @@ async function readPollResolutionState(publicClient, pollAddress) {
       finalized: finalizedRead.fn,
       answer: answerRead.fn,
       finalizationEpoch: finalizationEpochRead.fn,
+      currentEpoch: currentEpochRead.fn,
+      epochLength: epochLengthRead.fn,
       operator: operatorRead.fn,
     },
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pandora-cli-skills",
-  "version": "1.1.53",
+  "version": "1.1.54",
   "description": "Pandora CLI & Skills",
   "main": "cli/pandora.cjs",
   "bin": {

package/tests/unit/market_admin_resolution_state.test.cjs

@@ -0,0 +1,71 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { readPollResolutionState } = require('../../cli/lib/market_admin_service.cjs');
+
+const POLL_ADDRESS = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+const OPERATOR = '0x0D7B957C47Da86c2968dc52111D633D42cb7a5F7';
+
+test('readPollResolutionState extracts answer/finalization epoch from getFinalizedStatus tuple', async () => {
+  const publicClient = {
+    async readContract({ functionName }) {
+      if (functionName === 'getStatus') return 2n;
+      if (functionName === 'getFinalizedStatus') return [2n, 1n, 5908608n];
+      if (functionName === 'arbiter') return OPERATOR;
+      if (functionName === 'getCurrentEpoch' || functionName === 'getFinalizationEpoch' || functionName === 'answer') {
+        throw new Error(`missing function: ${functionName}`);
+      }
+      if (functionName === 'getEpochLength') return 300n;
+      throw new Error(`unexpected function read: ${functionName}`);
+    },
+    async getBlock() {
+      return { timestamp: 1772550000n }; // 5908500 * 300
+    },
+  };
+
+  const state = await readPollResolutionState(publicClient, POLL_ADDRESS);
+
+  assert.equal(state.pollAddress, POLL_ADDRESS);
+  assert.equal(state.marketState, 2);
+  assert.equal(state.pollFinalized, true);
+  assert.equal(state.pollAnswer, 'yes');
+  assert.equal(state.finalizationEpoch, '5908608');
+  assert.equal(state.currentEpoch, '5908500');
+  assert.equal(state.epochsUntilFinalization, 108);
+  assert.equal(state.claimable, true);
+  assert.equal(state.operator, OPERATOR.toLowerCase());
+  assert.equal(state.readSources.finalized, 'getFinalizedStatus');
+  assert.equal(state.readSources.answer, null);
+});
+
+test('readPollResolutionState uses dedicated answer/currentEpoch readers when available', async () => {
+  const publicClient = {
+    async readContract({ functionName }) {
+      if (functionName === 'getStatus') return 1n;
+      if (functionName === 'getFinalizedStatus') throw new Error('tuple reader not supported');
+      if (functionName === 'isFinalized') return false;
+      if (functionName === 'answer') return 0n;
+      if (functionName === 'getFinalizationEpoch') return 5908610n;
+      if (functionName === 'getCurrentEpoch') return 5908600n;
+      if (functionName === 'arbiter') return OPERATOR;
+      if (functionName === 'getEpochLength') throw new Error('epoch length not needed');
+      throw new Error(`unexpected function read: ${functionName}`);
+    },
+    async getBlock() {
+      throw new Error('getBlock should not be called when getCurrentEpoch is available');
+    },
+  };
+
+  const state = await readPollResolutionState(publicClient, POLL_ADDRESS);
+
+  assert.equal(state.pollFinalized, false);
+  assert.equal(state.pollAnswer, 'no');
+  assert.equal(state.finalizationEpoch, '5908610');
+  assert.equal(state.currentEpoch, '5908600');
+  assert.equal(state.epochsUntilFinalization, 10);
+  assert.equal(state.claimable, false);
+  assert.equal(state.readSources.finalized, 'isFinalized');
+  assert.equal(state.readSources.answer, 'answer');
+  assert.equal(state.readSources.currentEpoch, 'getCurrentEpoch');
+});
+