pandora-cli-skills 1.1.45 → 1.1.47

package/README_FOR_SHARING.md

@@ -262,7 +262,9 @@ Mirror advanced flags (for operator tuning):
   - envelope is `ok=true`, `command="trade"`, with tx metadata (`approveTxHash` optional, `buyTxHash` required on success) plus `selectedProbabilityPct` and `riskGuards`.
 
 ## Phase 2 limitations
-- `trade` currently targets PariMutuel-compatible `buy(bool,uint256,uint256)` markets.
+- `trade` auto-detects market type and uses the correct buy signature:
+  - PariMutuel: `buy(bool,uint256,uint256)`
+  - AMM: `buy(bool,uint256,uint256,uint256)` (deadline-aware)
 - `minSharesOut` protection defaults to raw `0` unless explicitly set with `--min-shares-out-raw`.
 - If indexer odds are unavailable, `quote` still returns a structured payload with `quoteAvailable=false`.
 - `trade --execute` blocks unquoted execution by default unless `--min-shares-out-raw` or `--allow-unquoted-execute` is provided.

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.44
+version: 1.1.46
 ---
 
 # Pandora CLI & Skills
@@ -359,7 +359,9 @@ pandora --output json schema
   - envelope is `ok=true`, `command="trade"`, with tx metadata (`approveTxHash` optional, `buyTxHash` required on success) plus `selectedProbabilityPct` and `riskGuards`.
 
 ## Phase 2 limitations
-- `trade` currently targets PariMutuel-compatible `buy(bool,uint256,uint256)` markets.
+- `trade` auto-detects market type and uses the correct buy signature:
+  - PariMutuel: `buy(bool,uint256,uint256)`
+  - AMM: `buy(bool,uint256,uint256,uint256)` (deadline-aware)
 - `--min-shares-out-raw` is the explicit slippage guard input for on-chain execution.
 - If indexer odds are unavailable, `quote` still returns structured output with `quoteAvailable=false`.
 - `trade --execute` blocks unquoted execution by default unless `--min-shares-out-raw` or `--allow-unquoted-execute` is provided.
@@ -489,8 +491,8 @@ Common structured error codes for automation:
 - `ODDS_*`: odds record/history storage and connector failures.
 - `ARB_*`: arb scan parsing/execution output-mode failures.
 - `CONFIG_*`: config read/parse failures (for example `CONFIG_FILE_NOT_FOUND`).
-- `SIMULATE_*`: simulate namespace failures (`SIMULATE_MC_INVALID_INPUT`, `SIMULATE_PARTICLE_FILTER_FAILED`, `SIMULATE_AGENTS_FAILED`).
-- `MODEL_*`: model namespace failures (`MODEL_CALIBRATE_INVALID_INPUT`, `MODEL_CORRELATION_FAILED`, `MODEL_DIAGNOSE_INVALID_INPUT`, `MODEL_SCORE_BRIER_FAILED`).
+- `SIMULATE_*`: simulate namespace failures (`SIMULATE_MC_FAILED`, `SIMULATE_MC_INVALID_INPUT`, `SIMULATE_PARTICLE_FILTER_FAILED`, `SIMULATE_PARTICLE_FILTER_INVALID_INPUT`, `SIMULATE_AGENTS_FAILED`, `SIMULATE_AGENTS_INVALID_INPUT`).
+- `MODEL_*`: model namespace failures (`MODEL_CALIBRATE_FAILED`, `MODEL_CALIBRATE_INVALID_INPUT`, `MODEL_CORRELATION_FAILED`, `MODEL_CORRELATION_INVALID_INPUT`, `MODEL_DIAGNOSE_FAILED`, `MODEL_DIAGNOSE_INVALID_INPUT`, `MODEL_SCORE_BRIER_FAILED`, `MODEL_SCORE_BRIER_INVALID_INPUT`).
 - `FORECAST_*`: forecast ledger read/write/normalization failures (`FORECAST_WRITE_FAILED`, `FORECAST_INVALID_RECORD`, `FORECAST_READ_FAILED`).
 - `BRIER_*`: brier scoring input/grouping failures (`BRIER_INVALID_INPUT`, `BRIER_INVALID_GROUP_BY`, `BRIER_FAILED`).
 - `MCP_FILE_ACCESS_BLOCKED`: MCP-mode file path denied outside workspace root.

package/cli/lib/schema_command_service.cjs

@@ -568,6 +568,9 @@ function buildSchemaPayload() {
           mode: { enum: ['dry-run', 'execute'] },
           status: { type: 'string' },
           marketAddress: { type: 'string' },
+          marketType: { type: ['string', 'null'] },
+          buySignature: { type: ['string', 'null'] },
+          ammDeadlineEpoch: { type: ['string', 'null'] },
           side: { enum: ['yes', 'no'] },
           amountUsdc: { type: 'number' },
           quote: { type: 'object' },

package/cli/lib/trade_command_service.cjs

@@ -117,6 +117,9 @@ function createRunTradeCommand(deps) {
       },
       chainId: execution.chainId,
       marketAddress: options.marketAddress,
+      marketType: execution.marketType || null,
+      buySignature: execution.buySignature || null,
+      ammDeadlineEpoch: execution.ammDeadlineEpoch || null,
       side: options.side,
       amountUsdc: options.amountUsdc,
       amountRaw: execution.amountRaw,

package/cli/lib/trade_market_type_service.cjs

@@ -0,0 +1,203 @@
+const PARI_MUTUEL_BUY_ABI = [
+  {
+    name: 'buy',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'isYes', type: 'bool' },
+      { name: 'collateralAmount', type: 'uint256' },
+      { name: 'minSharesOut', type: 'uint256' },
+    ],
+    outputs: [{ name: 'sharesOut', type: 'uint256' }],
+  },
+];
+
+const PREDICTION_AMM_BUY_ABI = [
+  {
+    name: 'buy',
+    type: 'function',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'isYes', type: 'bool' },
+      { name: 'collateralAmount', type: 'uint256' },
+      { name: 'minSharesOut', type: 'uint256' },
+      { name: 'deadline', type: 'uint256' },
+    ],
+    outputs: [{ name: 'sharesOut', type: 'uint256' }],
+  },
+];
+
+const PARI_MUTUEL_MARKER_ABI = [
+  {
+    type: 'function',
+    name: 'curveFlattener',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ type: 'uint8' }],
+  },
+];
+
+const PREDICTION_AMM_MARKER_ABI = [
+  {
+    type: 'function',
+    name: 'tradingFee',
+    stateMutability: 'view',
+    inputs: [],
+    outputs: [{ type: 'uint24' }],
+  },
+];
+
+const DEFAULT_AMM_TRADE_DEADLINE_OFFSET_SEC = 15 * 60;
+
+function createTradeTypeError(code, message, details = undefined) {
+  const err = new Error(message);
+  err.code = code;
+  if (details !== undefined) {
+    err.details = details;
+  }
+  return err;
+}
+
+/**
+ * Detects supported Pandora market type by probing stable view-method markers.
+ * @param {{readContract: Function}} publicClient
+ * @param {`0x${string}`} marketAddress
+ * @returns {Promise<{marketType:'parimutuel'|'amm', detectedBy:string}>}
+ */
+async function detectTradeMarketType(publicClient, marketAddress) {
+  let pariError = null;
+  try {
+    await publicClient.readContract({
+      address: marketAddress,
+      abi: PARI_MUTUEL_MARKER_ABI,
+      functionName: 'curveFlattener',
+    });
+    return {
+      marketType: 'parimutuel',
+      detectedBy: 'curveFlattener',
+    };
+  } catch (err) {
+    pariError = err;
+  }
+
+  let ammError = null;
+  try {
+    await publicClient.readContract({
+      address: marketAddress,
+      abi: PREDICTION_AMM_MARKER_ABI,
+      functionName: 'tradingFee',
+    });
+    return {
+      marketType: 'amm',
+      detectedBy: 'tradingFee',
+    };
+  } catch (err) {
+    ammError = err;
+  }
+
+  throw createTradeTypeError(
+    'UNSUPPORTED_MARKET_TRADE_INTERFACE',
+    'Market does not expose a supported Pandora trade interface.',
+    {
+      marketAddress,
+      attemptedMarkers: ['curveFlattener', 'tradingFee'],
+      markerErrors: {
+        parimutuel: pariError && pariError.message ? pariError.message : String(pariError),
+        amm: ammError && ammError.message ? ammError.message : String(ammError),
+      },
+    },
+  );
+}
+
+function toEpochSeconds(value, fallback) {
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) {
+    const truncated = Math.trunc(numeric);
+    if (truncated >= 0) return truncated;
+  }
+  return fallback;
+}
+
+/**
+ * Builds the market-specific buy call shape.
+ * @param {{
+ *   marketType: 'parimutuel'|'amm',
+ *   side: 'yes'|'no',
+ *   amountRaw: bigint,
+ *   minSharesOutRaw: bigint,
+ *   nowEpochSec?: number,
+ *   ammDeadlineOffsetSec?: number,
+ * }} input
+ * @returns {{marketType:'parimutuel'|'amm', abi: object[], functionName: 'buy', args: (boolean|bigint)[], signature: string, ammDeadlineEpoch?: string}}
+ */
+function buildTradeBuyCall(input) {
+  const marketType = String(input.marketType || '').toLowerCase();
+  const isYes = String(input.side || '').toLowerCase() === 'yes';
+  const amountRaw = input.amountRaw;
+  const minSharesOutRaw = input.minSharesOutRaw;
+
+  if (marketType === 'parimutuel') {
+    return {
+      marketType: 'parimutuel',
+      abi: PARI_MUTUEL_BUY_ABI,
+      functionName: 'buy',
+      args: [isYes, amountRaw, minSharesOutRaw],
+      signature: 'buy(bool,uint256,uint256)',
+      ammDeadlineEpoch: null,
+    };
+  }
+
+  if (marketType === 'amm') {
+    const nowEpochSec = toEpochSeconds(input.nowEpochSec, Math.trunc(Date.now() / 1000));
+    const offsetSec = toEpochSeconds(input.ammDeadlineOffsetSec, DEFAULT_AMM_TRADE_DEADLINE_OFFSET_SEC);
+    const deadlineEpoch = BigInt(nowEpochSec + Math.max(1, offsetSec));
+    return {
+      marketType: 'amm',
+      abi: PREDICTION_AMM_BUY_ABI,
+      functionName: 'buy',
+      args: [isYes, amountRaw, minSharesOutRaw, deadlineEpoch],
+      signature: 'buy(bool,uint256,uint256,uint256)',
+      ammDeadlineEpoch: deadlineEpoch.toString(),
+    };
+  }
+
+  throw createTradeTypeError('UNSUPPORTED_MARKET_TYPE', `Unsupported market type for trade execution: ${marketType}`);
+}
+
+/**
+ * Resolves market type then constructs the correct buy call descriptor.
+ * @param {{
+ *   publicClient: { readContract: Function },
+ *   marketAddress: `0x${string}`,
+ *   side: 'yes'|'no',
+ *   amountRaw: bigint,
+ *   minSharesOutRaw: bigint,
+ *   nowEpochSec?: number,
+ *   ammDeadlineOffsetSec?: number,
+ * }} input
+ * @returns {Promise<{marketType:'parimutuel'|'amm', detectedBy:string, abi: object[], functionName: 'buy', args: (boolean|bigint)[], signature: string, ammDeadlineEpoch?: string}>}
+ */
+async function resolveTradeBuyCall(input) {
+  const detected = await detectTradeMarketType(input.publicClient, input.marketAddress);
+  const call = buildTradeBuyCall({
+    marketType: detected.marketType,
+    side: input.side,
+    amountRaw: input.amountRaw,
+    minSharesOutRaw: input.minSharesOutRaw,
+    nowEpochSec: input.nowEpochSec,
+    ammDeadlineOffsetSec: input.ammDeadlineOffsetSec,
+  });
+  return {
+    ...call,
+    detectedBy: detected.detectedBy,
+  };
+}
+
+module.exports = {
+  PARI_MUTUEL_BUY_ABI,
+  PREDICTION_AMM_BUY_ABI,
+  DEFAULT_AMM_TRADE_DEADLINE_OFFSET_SEC,
+  detectTradeMarketType,
+  buildTradeBuyCall,
+  resolveTradeBuyCall,
+};

package/cli/pandora.cjs

@@ -60,6 +60,7 @@ const { createRunOddsCommand } = require('./lib/odds_command_service.cjs');
 const { createRunSportsCommand } = require('./lib/sports_command_service.cjs');
 const { createRunRiskCommand } = require('./lib/risk_command_service.cjs');
 const { createRunModelCommand } = require('./lib/model_command_service.cjs');
+const { resolveTradeBuyCall } = require('./lib/trade_market_type_service.cjs');
 const {
   DEFAULT_INDEXER_URL: SHARED_DEFAULT_INDEXER_URL,
   DEFAULT_RPC_BY_CHAIN_ID,
@@ -598,20 +599,6 @@ const ERC20_ABI = [
     outputs: [{ type: 'uint256' }],
   },
 ];
-const PARI_MUTUEL_ABI = [
-  {
-    name: 'buy',
-    type: 'function',
-    stateMutability: 'nonpayable',
-    inputs: [
-      { name: 'isYes', type: 'bool' },
-      { name: 'collateralAmount', type: 'uint256' },
-      { name: 'minSharesOut', type: 'uint256' },
-    ],
-    outputs: [{ name: 'sharesOut', type: 'uint256' }],
-  },
-];
-
 const MARKET_DIRECT_ODDS_FIELDS = [
   { yesField: 'yesPct', noField: 'noPct', source: 'direct:yesPct/noPct' },
   { yesField: 'yesOdds', noField: 'noOdds', source: 'direct:yesOdds/noOdds' },
@@ -897,10 +884,10 @@ Usage:
 
 Notes:
   - --dry-run prints the execution plan and quote without sending transactions.
-  - --execute performs allowance check, optional USDC approve, then calls buy(bool,uint256,uint256).
+  - --execute performs allowance check, optional USDC approve, then calls market buy() using the detected market ABI.
   - --max-amount-usdc and probability guard flags fail fast before execution.
   - --execute requires a quote by default unless --min-shares-out-raw or --allow-unquoted-execute is set.
-  - Current execute path targets PariMutuel-compatible markets.
+  - Supports both PariMutuel and AMM market buy signatures.
 `);
 }
 
@@ -3604,6 +3591,28 @@ async function executeTradeOnchain(options) {
     });
   };
 
+  let buyCall;
+  try {
+    buyCall = await resolveTradeBuyCall({
+      publicClient,
+      marketAddress: options.marketAddress,
+      side: options.side,
+      amountRaw,
+      minSharesOutRaw,
+    });
+  } catch (error) {
+    if (error && error.code) {
+      throw new CliError(
+        error.code,
+        error.message || 'Unsupported market trade interface.',
+        error.details,
+      );
+    }
+    await decodeTradeError(error, 'TRADE_MARKET_TYPE_RESOLUTION_FAILED', 'Unable to resolve market trade interface.', {
+      stage: 'market-type-resolve',
+    });
+  }
+
   let allowance;
   try {
     allowance = await publicClient.readContract({
@@ -3660,9 +3669,9 @@ async function executeTradeOnchain(options) {
     const buySimulation = await publicClient.simulateContract({
       account,
       address: options.marketAddress,
-      abi: PARI_MUTUEL_ABI,
-      functionName: 'buy',
-      args: [options.side === 'yes', amountRaw, minSharesOutRaw],
+      abi: buyCall.abi,
+      functionName: buyCall.functionName,
+      args: buyCall.args,
     });
     buyGasEstimate =
       buySimulation && buySimulation.request && buySimulation.request.gas
@@ -3675,6 +3684,9 @@ async function executeTradeOnchain(options) {
     await decodeTradeError(error, 'TRADE_EXECUTION_FAILED', 'Buy transaction failed.', {
       stage: 'buy',
       buyTxHash,
+      marketType: buyCall ? buyCall.marketType : null,
+      buySignature: buyCall ? buyCall.signature : null,
+      ammDeadlineEpoch: buyCall && buyCall.ammDeadlineEpoch ? buyCall.ammDeadlineEpoch : null,
     });
   }
 
@@ -3684,6 +3696,9 @@ async function executeTradeOnchain(options) {
     rpcUrl: runtime.rpcUrl,
     account: account.address,
     usdc: runtime.usdcAddress,
+    marketType: buyCall.marketType,
+    buySignature: buyCall.signature,
+    ammDeadlineEpoch: buyCall.ammDeadlineEpoch,
     amountRaw: amountRaw.toString(),
     minSharesOutRaw: minSharesOutRaw.toString(),
     approveTxHash,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pandora-cli-skills",
-  "version": "1.1.45",
+  "version": "1.1.47",
   "description": "Pandora CLI & Skills",
   "main": "cli/pandora.cjs",
   "bin": {
@@ -19,6 +19,7 @@
     "tests/cli/**",
     "tests/helpers/**",
     "tests/smoke/**",
+    "tsconfig.json",
     "SKILL.md",
     "README.md",
     "README_FOR_SHARING.md"

package/tests/unit/trade_market_type_service.test.cjs

@@ -0,0 +1,109 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  DEFAULT_AMM_TRADE_DEADLINE_OFFSET_SEC,
+  detectTradeMarketType,
+  buildTradeBuyCall,
+  resolveTradeBuyCall,
+} = require('../../cli/lib/trade_market_type_service.cjs');
+
+const MARKET = '0x1111111111111111111111111111111111111111';
+
+test('detectTradeMarketType resolves parimutuel marker first', async () => {
+  const publicClient = {
+    async readContract(request) {
+      if (request.functionName === 'curveFlattener') return 7n;
+      throw new Error('unexpected');
+    },
+  };
+
+  const detected = await detectTradeMarketType(publicClient, MARKET);
+  assert.equal(detected.marketType, 'parimutuel');
+  assert.equal(detected.detectedBy, 'curveFlattener');
+});
+
+test('detectTradeMarketType falls back to amm marker', async () => {
+  const publicClient = {
+    async readContract(request) {
+      if (request.functionName === 'curveFlattener') throw new Error('function selector was not recognized');
+      if (request.functionName === 'tradingFee') return 3000n;
+      throw new Error('unexpected');
+    },
+  };
+
+  const detected = await detectTradeMarketType(publicClient, MARKET);
+  assert.equal(detected.marketType, 'amm');
+  assert.equal(detected.detectedBy, 'tradingFee');
+});
+
+test('detectTradeMarketType throws unsupported interface when neither marker exists', async () => {
+  const publicClient = {
+    async readContract() {
+      throw new Error('reverted');
+    },
+  };
+
+  await assert.rejects(
+    () => detectTradeMarketType(publicClient, MARKET),
+    (error) => {
+      assert.equal(error.code, 'UNSUPPORTED_MARKET_TRADE_INTERFACE');
+      assert.equal(error.details.marketAddress, MARKET);
+      return true;
+    },
+  );
+});
+
+test('buildTradeBuyCall uses 3-arg buy for parimutuel', () => {
+  const call = buildTradeBuyCall({
+    marketType: 'parimutuel',
+    side: 'yes',
+    amountRaw: 1_000_000n,
+    minSharesOutRaw: 0n,
+  });
+
+  assert.equal(call.signature, 'buy(bool,uint256,uint256)');
+  assert.deepEqual(call.args, [true, 1_000_000n, 0n]);
+  assert.equal(call.ammDeadlineEpoch, null);
+});
+
+test('buildTradeBuyCall uses 4-arg deadline buy for amm', () => {
+  const nowEpochSec = 1_700_000_000;
+  const call = buildTradeBuyCall({
+    marketType: 'amm',
+    side: 'no',
+    amountRaw: 2_500_000n,
+    minSharesOutRaw: 12n,
+    nowEpochSec,
+  });
+
+  assert.equal(call.signature, 'buy(bool,uint256,uint256,uint256)');
+  assert.equal(call.args.length, 4);
+  assert.deepEqual(call.args.slice(0, 3), [false, 2_500_000n, 12n]);
+  assert.equal(call.ammDeadlineEpoch, String(nowEpochSec + DEFAULT_AMM_TRADE_DEADLINE_OFFSET_SEC));
+});
+
+test('resolveTradeBuyCall composes detection and call creation', async () => {
+  const publicClient = {
+    async readContract(request) {
+      if (request.functionName === 'curveFlattener') throw new Error('not pari');
+      if (request.functionName === 'tradingFee') return 500n;
+      throw new Error('unexpected');
+    },
+  };
+
+  const call = await resolveTradeBuyCall({
+    publicClient,
+    marketAddress: MARKET,
+    side: 'yes',
+    amountRaw: 9n,
+    minSharesOutRaw: 1n,
+    nowEpochSec: 1000,
+    ammDeadlineOffsetSec: 5,
+  });
+
+  assert.equal(call.marketType, 'amm');
+  assert.equal(call.detectedBy, 'tradingFee');
+  assert.equal(call.signature, 'buy(bool,uint256,uint256,uint256)');
+  assert.deepEqual(call.args, [true, 9n, 1n, 1005n]);
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["scripts/**/*.ts"]
+}