pandora-cli-skills 1.1.46 → 1.1.48

package/README.md

@@ -122,6 +122,7 @@ pandora --output json lifecycle resolve --id <lifecycle-id> --confirm
 - `pandora odds record|history`
 - `pandora autopilot run|once`
 - `pandora mirror browse|plan|deploy|verify|lp-explain|hedge-calc|simulate|go|sync|status|close`
+  - `mirror browse` supports `--polymarket-tag-id|--polymarket-tag-ids` (aliases `--sport-tag-id|--sport-tag-ids`) for sports-tagged Gamma event discovery.
 - `pandora polymarket check|approve|preflight|trade`
 - `pandora resolve`
 - `pandora lp add|remove|positions`

package/README_FOR_SHARING.md

@@ -200,6 +200,7 @@ Mirror advanced flags (for operator tuning):
 - `--sync-interval-ms <ms>` on `mirror go` to control auto-sync tick cadence.
 - `--oracle <address>` / `--factory <address>` on `mirror deploy` and `mirror go` for explicit contract overrides.
 - `--polymarket-gamma-mock-url <url>` on `mirror browse|plan|verify|go|sync|status` for deterministic mock-source testing.
+- `--polymarket-tag-id <id>` / `--polymarket-tag-ids <csv>` on `mirror browse` (aliases: `--sport-tag-id`, `--sport-tag-ids`) to query sports-tagged Gamma events.
 - `--no-stream` on `mirror sync` to disable per-tick stdout line streaming in run mode.
 - `--pid-file <path>` on `mirror sync stop|status` for explicit daemon process selection.
 
@@ -219,7 +220,7 @@ Mirror advanced flags (for operator tuning):
 - `pandora export --wallet <0x...> --format csv --out ./trades.csv`
 - `pandora arbitrage --venues pandora,polymarket --min-spread-pct 2 --cross-venue-only --with-rules --include-similarity`
 - `pandora autopilot once --market-address <0x...> --side no --amount-usdc 10 --trigger-yes-below 15 --paper`
-- `pandora mirror browse --min-yes-pct 20 --max-yes-pct 80 --min-volume-24h 100000 --limit 10`
+- `pandora mirror browse --polymarket-tag-id 82 --min-yes-pct 20 --max-yes-pct 80 --min-volume-24h 100000 --limit 10`
 - `pandora mirror plan --source polymarket --polymarket-market-id <id> --with-rules --include-similarity`
 - `pandora mirror go --polymarket-slug <slug> --liquidity-usdc 10 --paper`
 - `pandora mirror verify --pandora-market-address <0x...> --polymarket-market-id <id> --include-similarity`
@@ -262,7 +263,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.46
+version: 1.1.48
 ---
 
 # Pandora CLI & Skills
@@ -317,7 +317,7 @@ pandora --output json history --wallet <0x...> --limit 50
 pandora --output json export --wallet <0x...> --format csv --out ./trades.csv
 pandora --output json arbitrage --venues pandora,polymarket --min-spread-pct 3 --cross-venue-only --with-rules --include-similarity
 pandora --output json autopilot once --market-address <0x...> --side no --amount-usdc 10 --trigger-yes-below 15 --paper
-pandora --output json mirror browse --min-yes-pct 20 --max-yes-pct 80 --min-volume-24h 100000 --limit 10
+pandora --output json mirror browse --polymarket-tag-id 82 --min-yes-pct 20 --max-yes-pct 80 --min-volume-24h 100000 --limit 10
 pandora --output json mirror plan --source polymarket --polymarket-market-id <id> --with-rules --include-similarity
 pandora --output json mirror lp-explain --liquidity-usdc 10000 --source-yes-pct 58
 pandora --output json mirror hedge-calc --reserve-yes-usdc 8 --reserve-no-usdc 12 --excess-no-usdc 2 --polymarket-yes-pct 60
@@ -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.
@@ -560,7 +562,8 @@ Error envelope:
   - `{ ok: true, command: "autopilot", data: { schemaVersion, generatedAt, strategyHash, mode, executeLive, stateFile, killSwitchFile, iterationsRequested, iterationsCompleted, stoppedReason?, parameters: { marketAddress, side, amountUsdc, triggerYesBelow?, triggerYesAbove?, intervalMs, cooldownMs, maxAmountUsdc?, maxOpenExposureUsdc, dailySpendCapUsdc, maxTradesPerDay }, state, actionCount, actions[], snapshots[], webhookReports[] } }`
 - `mirror browse`:
   - `{ ok: true, command: "mirror.browse", data: { schemaVersion, generatedAt, source, gammaApiError, filters, count, items[], diagnostics[] } }`
-  - each candidate row can include `existingMirror: { marketAddress, similarity } | null`.
+  - `filters` can include `polymarketTagIds[]` when using `--polymarket-tag-id|--polymarket-tag-ids` (or `--sport-tag-id|--sport-tag-ids` aliases).
+  - each candidate row can include `eventId`, `eventSlug`, `eventTitle`, and `existingMirror: { marketAddress, similarity } | null`.
 - `mirror go`:
   - `{ ok: true, command: "mirror.go", data: { schemaVersion, generatedAt, mode, plan, deploy, verify, sync, polymarketPreflight, suggestedSyncCommand, trustManifest, diagnostics[] } }`
   - `plan` is the same payload shape as `mirror.plan`; `deploy` is the same payload shape as `mirror.deploy`; `sync` is null unless `--auto-sync` is used.

package/cli/lib/mirror_command_service.cjs

@@ -91,7 +91,7 @@ function createRunMirrorCommand(deps) {
         console.log('');
         console.log('Subcommands:');
         console.log(
-          '  browse --min-yes-pct <n> --max-yes-pct <n> --min-volume-24h <n> [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--chain-id <id>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
+          '  browse --min-yes-pct <n> --max-yes-pct <n> --min-volume-24h <n> [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--chain-id <id>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
         );
         console.log(
           '  plan   --source polymarket --polymarket-market-id <id>|--polymarket-slug <slug> [--chain-id <id>] [--target-slippage-bps <n>] [--turnover-target <n>] [--depth-slippage-bps <n>] [--safety-multiplier <n>] [--min-liquidity-usdc <n>] [--max-liquidity-usdc <n>] [--with-rules] [--include-similarity] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',

package/cli/lib/mirror_handlers/browse.cjs

@@ -22,12 +22,12 @@ module.exports = async function handleMirrorBrowse({ shared, context, deps }) {
         context.outputMode,
         'mirror.browse.help',
         commandHelpPayload(
-          'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>]',
+          'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>]',
         ),
       );
     } else {
       console.log(
-        'Usage: pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>]',
+        'Usage: pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>]',
       );
     }
     return;

package/cli/lib/mirror_service.cjs

@@ -395,6 +395,7 @@ async function browseMirrorMarkets(options = {}) {
     gammaUrl: options.polymarketGammaUrl,
     gammaMockUrl: options.polymarketGammaMockUrl,
     mockUrl: options.polymarketMockUrl,
+    polymarketTagIds: Array.isArray(options.polymarketTagIds) ? options.polymarketTagIds : [],
     timeoutMs: options.timeoutMs,
     minYesPct: options.minYesPct,
     maxYesPct: options.maxYesPct,

package/cli/lib/parsers/mirror_remaining_flags.cjs

@@ -39,8 +39,13 @@ function createParseMirrorBrowseFlags(deps) {
       polymarketGammaUrl: null,
       polymarketGammaMockUrl: null,
       polymarketMockUrl: null,
+      polymarketTagIds: [],
     };
 
+    function pushTagId(rawValue, flagName) {
+      options.polymarketTagIds.push(parsePositiveInteger(rawValue, flagName));
+    }
+
     for (let i = 0; i < args.length; i += 1) {
       const token = args[i];
       if (token === '--min-yes-pct') {
@@ -98,6 +103,26 @@ function createParseMirrorBrowseFlags(deps) {
         i += 1;
         continue;
       }
+      if (token === '--polymarket-tag-id' || token === '--sport-tag-id') {
+        pushTagId(requireFlagValue(args, i, token), token);
+        i += 1;
+        continue;
+      }
+      if (token === '--polymarket-tag-ids' || token === '--sport-tag-ids') {
+        const raw = requireFlagValue(args, i, token);
+        const values = String(raw)
+          .split(',')
+          .map((value) => value.trim())
+          .filter(Boolean);
+        if (!values.length) {
+          throw new CliError('INVALID_FLAG_VALUE', `${token} must include at least one positive integer tag id.`);
+        }
+        for (const value of values) {
+          pushTagId(value, token);
+        }
+        i += 1;
+        continue;
+      }
       throw new CliError('UNKNOWN_FLAG', `Unknown flag for mirror browse: ${token}`);
     }
 
@@ -105,6 +130,10 @@ function createParseMirrorBrowseFlags(deps) {
       throw new CliError('INVALID_ARGS', '--min-yes-pct cannot be greater than --max-yes-pct.');
     }
 
+    if (options.polymarketTagIds.length) {
+      options.polymarketTagIds = Array.from(new Set(options.polymarketTagIds));
+    }
+
     return options;
   };
 }

package/cli/lib/polymarket_trade_adapter.cjs

@@ -405,6 +405,9 @@ function normalizeMarketRow(row) {
     ).trim() || null,
     slug: String((row && (row.market_slug || row.marketSlug || row.slug)) || '').trim() || null,
     question: extractQuestionText(row),
+    eventId: toStringOrNull(row && (row.event_id || row.eventId)),
+    eventSlug: toStringOrNull(row && (row.event_slug || row.eventSlug)),
+    eventTitle: toStringOrNull(row && (row.event_title || row.eventTitle)),
     description: rulesSections.length ? rulesSections.join('\n\n') : null,
     closeTimestamp: toTimestampSeconds(
       row &&
@@ -479,6 +482,14 @@ function parseMarketsPayload(payload) {
   return [];
 }
 
+function parseEventsPayload(payload) {
+  if (Array.isArray(payload)) return payload;
+  if (payload && Array.isArray(payload.events)) return payload.events;
+  if (payload && payload.data && Array.isArray(payload.data.events)) return payload.data.events;
+  if (payload && Array.isArray(payload.data)) return payload.data;
+  return [];
+}
+
 async function fetchJson(url, timeoutMs) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -530,6 +541,15 @@ function buildGammaUrl(baseUrl, params) {
   return url.toString();
 }
 
+function buildGammaEventsUrl(baseUrl, params) {
+  const url = new URL(`${baseUrl}/events`);
+  for (const [key, value] of Object.entries(params || {})) {
+    if (value === null || value === undefined || value === '') continue;
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+
 async function fetchGammaRows(params, options = {}, diagnostics = []) {
   const timeoutMs = Number.isInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 12_000;
   const gammaUrl = normalizeGammaBaseUrl(options.gammaUrl);
@@ -543,6 +563,120 @@ async function fetchGammaRows(params, options = {}, diagnostics = []) {
   }
 }
 
+function makeMarketDedupeKey(row) {
+  return (
+    normalizeText(
+      row &&
+        (row.condition_id ||
+          row.conditionId ||
+          row.question_id ||
+          row.questionId ||
+          row.market_id ||
+          row.marketId ||
+          row.id ||
+          row.slug),
+    ) || null
+  );
+}
+
+function flattenEventMarkets(events) {
+  const output = [];
+  const seen = new Set();
+
+  for (const event of Array.isArray(events) ? events : []) {
+    const markets = Array.isArray(event && event.markets) ? event.markets : [];
+    for (const market of markets) {
+      if (!market || typeof market !== 'object') continue;
+      const dedupeKey = makeMarketDedupeKey(market);
+      if (dedupeKey && seen.has(dedupeKey)) continue;
+      if (dedupeKey) seen.add(dedupeKey);
+      output.push({
+        ...market,
+        event_id: event && event.id !== undefined ? event.id : null,
+        event_slug: event && event.slug ? event.slug : null,
+        event_title: event && event.title ? event.title : null,
+        event_tags: Array.isArray(event && event.tags) ? event.tags : [],
+      });
+    }
+  }
+
+  return output;
+}
+
+function normalizeTagIdList(input) {
+  const values = Array.isArray(input) ? input : [];
+  const normalized = [];
+  for (const value of values) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) continue;
+    const asInt = Math.trunc(numeric);
+    if (asInt <= 0) continue;
+    normalized.push(asInt);
+  }
+  return Array.from(new Set(normalized));
+}
+
+async function fetchGammaRowsByTagIds(params, options = {}, diagnostics = []) {
+  const timeoutMs = Number.isInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 12_000;
+  const gammaUrl = normalizeGammaBaseUrl(options.gammaUrl);
+  const tagIds = normalizeTagIdList(params && params.tagIds);
+  if (!tagIds.length) return [];
+
+  if (options.gammaMockUrl) {
+    try {
+      const payload = await fetchJson(options.gammaMockUrl, timeoutMs);
+      const events = parseEventsPayload(payload);
+      return flattenEventMarkets(events);
+    } catch (err) {
+      diagnostics.push(`Gamma sports-events request failed (${options.gammaMockUrl}): ${formatNetworkError(err)}`);
+      return [];
+    }
+  }
+
+  const allRows = [];
+  const perTagResults = await Promise.all(
+    tagIds.map(async (tagId) => {
+      const queryParams = {
+        ...(params || {}),
+        tag_id: tagId,
+      };
+      delete queryParams.tagIds;
+      const targetUrl = buildGammaEventsUrl(gammaUrl, queryParams);
+      try {
+        const payload = await fetchJson(targetUrl, timeoutMs);
+        const events = parseEventsPayload(payload);
+        return {
+          rows: flattenEventMarkets(events),
+          error: null,
+        };
+      } catch (err) {
+        return {
+          rows: [],
+          error: `Gamma sports-events request failed (${targetUrl}): ${formatNetworkError(err)}`,
+        };
+      }
+    }),
+  );
+
+  for (const result of perTagResults) {
+    if (result.error) {
+      diagnostics.push(result.error);
+      continue;
+    }
+    allRows.push(...result.rows);
+  }
+
+  const deduped = [];
+  const seen = new Set();
+  for (const row of allRows) {
+    const dedupeKey = makeMarketDedupeKey(row);
+    if (dedupeKey && seen.has(dedupeKey)) continue;
+    if (dedupeKey) seen.add(dedupeKey);
+    deduped.push(row);
+  }
+  return deduped;
+}
+
 function extractConditionId(row) {
   const value = toStringOrNull(
     row &&
@@ -998,21 +1132,38 @@ async function browsePolymarketMarkets(options = {}) {
   const timeoutMs = Number.isInteger(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 12_000;
   const requestedLimit = Number.isInteger(Number(options.limit)) && Number(options.limit) > 0 ? Number(options.limit) : 10;
   const scanLimit = Math.max(requestedLimit * 5, 100);
+  const polymarketTagIds = normalizeTagIdList(options.polymarketTagIds);
+  const useSportsEventsEndpoint = polymarketTagIds.length > 0;
 
   let rows = [];
+  let sourceType = options.mockUrl ? 'polymarket:mock' : 'polymarket:gamma';
   if (options.mockUrl) {
     const payload = await fetchMockPayload(options.mockUrl, timeoutMs);
     rows = parseMarketsPayload(payload);
   } else {
-    rows = await fetchGammaRows(
-      {
-        active: true,
-        closed: false,
-        limit: Math.min(scanLimit, 500),
-      },
-      options,
-      diagnostics,
-    );
+    if (useSportsEventsEndpoint) {
+      rows = await fetchGammaRowsByTagIds(
+        {
+          tagIds: polymarketTagIds,
+          active: true,
+          closed: false,
+          limit: Math.min(scanLimit, 500),
+        },
+        options,
+        diagnostics,
+      );
+      sourceType = 'polymarket:gamma-events';
+    } else {
+      rows = await fetchGammaRows(
+        {
+          active: true,
+          closed: false,
+          limit: Math.min(scanLimit, 500),
+        },
+        options,
+        diagnostics,
+      );
+    }
   }
 
   const minYesPct = toOptionalNumber(options.minYesPct);
@@ -1039,6 +1190,9 @@ async function browsePolymarketMarkets(options = {}) {
   const items = filtered.slice(0, requestedLimit).map((item) => ({
     marketId: item.marketId,
     slug: item.slug,
+    eventId: item.eventId,
+    eventSlug: item.eventSlug,
+    eventTitle: item.eventTitle,
     question: item.question,
     closeTimestamp: item.closeTimestamp,
     yesPct: item.yesPct,
@@ -1048,16 +1202,16 @@ async function browsePolymarketMarkets(options = {}) {
     active: item.active,
     resolved: item.resolved,
     url: item.url,
-    sourceType: item.source || (options.mockUrl ? 'polymarket:mock' : 'polymarket:gamma'),
+    sourceType: item.source || sourceType,
   }));
 
   const gammaApiError =
-    diagnostics.find((line) => /^Gamma request failed/i.test(String(line || ''))) || null;
+    diagnostics.find((line) => /^Gamma( sports-events)? request failed/i.test(String(line || ''))) || null;
 
   return {
     schemaVersion: '1.0.0',
     generatedAt: new Date().toISOString(),
-    source: options.mockUrl ? 'polymarket:mock' : 'polymarket:gamma',
+    source: sourceType,
     filters: {
       minYesPct,
       maxYesPct,
@@ -1066,6 +1220,7 @@ async function browsePolymarketMarkets(options = {}) {
       closesBefore,
       questionContains: options.questionContains || null,
       limit: requestedLimit,
+      polymarketTagIds,
     },
     count: items.length,
     items,

package/cli/lib/schema_command_service.cjs

@@ -264,6 +264,13 @@ function buildCommandDescriptors() {
       emits: ['sports.resolve.plan', 'sports.help'],
       dataSchema: '#/definitions/SportsResolvePlanPayload',
     }),
+    'mirror.browse': commandDescriptor({
+      summary: 'Browse Polymarket mirror candidates with optional sports tag filters.',
+      usage:
+        'pandora [--output table|json] mirror browse [--min-yes-pct <n>] [--max-yes-pct <n>] [--min-volume-24h <n>] [--closes-after <date>] [--closes-before <date>] [--question-contains <text>] [--limit <n>] [--chain-id <id>] [--polymarket-tag-id <id>] [--polymarket-tag-ids <csv>] [--sport-tag-id <id>] [--sport-tag-ids <csv>] [--polymarket-gamma-url <url>] [--polymarket-gamma-mock-url <url>] [--polymarket-mock-url <url>]',
+      emits: ['mirror.browse', 'mirror.browse.help'],
+      dataSchema: '#/definitions/MirrorBrowsePayload',
+    }),
     'mirror.plan': commandDescriptor({
       summary: 'Generate mirror sizing/distribution plan from Polymarket source.',
       usage:
@@ -568,6 +575,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' },
@@ -809,6 +819,19 @@ function buildSchemaPayload() {
           generatedAt: { type: 'string', format: 'date-time' },
         },
       },
+      MirrorBrowsePayload: {
+        type: 'object',
+        properties: {
+          source: { type: 'string' },
+          gammaApiError: { type: ['string', 'null'] },
+          filters: { type: 'object' },
+          count: { type: 'integer' },
+          items: { type: 'array', items: { type: 'object' } },
+          diagnostics: { type: 'array', items: { type: 'string' } },
+          schemaVersion: { type: 'string' },
+          generatedAt: { type: 'string', format: 'date-time' },
+        },
+      },
       MirrorPlanPayload: {
         type: 'object',
         properties: {

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.46",
+  "version": "1.1.48",
   "description": "Pandora CLI & Skills",
   "main": "cli/pandora.cjs",
   "bin": {

package/tests/cli/cli.integration.test.cjs

@@ -1090,6 +1090,9 @@ test('schema command returns envelope schema plus command descriptors', () => {
   assert.ok(payload.data.commandDescriptors.quote.emits.includes('quote'));
   assert.ok(payload.data.commandDescriptors.trade);
   assert.equal(payload.data.commandDescriptors.trade.dataSchema, '#/definitions/TradePayload');
+  assert.ok(payload.data.commandDescriptors['mirror.browse']);
+  assert.equal(payload.data.commandDescriptors['mirror.browse'].dataSchema, '#/definitions/MirrorBrowsePayload');
+  assert.match(payload.data.commandDescriptors['mirror.browse'].usage, /--polymarket-tag-id/);
   assert.ok(payload.data.commandDescriptors['mirror.plan']);
   assert.equal(payload.data.commandDescriptors['mirror.plan'].dataSchema, '#/definitions/MirrorPlanPayload');
   assert.ok(payload.data.commandDescriptors['risk.show']);
@@ -1150,6 +1153,7 @@ test('schema command returns envelope schema plus command descriptors', () => {
   assert.ok(payload.data.definitions.ModelCorrelationPayload);
   assert.ok(payload.data.definitions.ModelDiagnosePayload);
   assert.ok(payload.data.definitions.ErrorRecoveryPayload);
+  assert.ok(payload.data.definitions.MirrorBrowsePayload);
 });
 
 test('schema command rejects unknown trailing flags', () => {
@@ -4825,6 +4829,24 @@ test('mirror browse rejects invalid calendar rollover dates', () => {
   assert.match(payload.error.message, /real calendar date/);
 });
 
+test('mirror browse rejects invalid tag id values', () => {
+  const result = runCli(['--output', 'json', 'mirror', 'browse', '--polymarket-tag-id', '0']);
+  assert.equal(result.status, 1);
+  const payload = parseJsonOutput(result);
+  assert.equal(payload.ok, false);
+  assert.equal(payload.error.code, 'INVALID_FLAG_VALUE');
+  assert.match(payload.error.message, /--polymarket-tag-id must be a positive integer/i);
+});
+
+test('mirror browse rejects empty tag-id csv values', () => {
+  const result = runCli(['--output', 'json', 'mirror', 'browse', '--polymarket-tag-ids', ', ,']);
+  assert.equal(result.status, 1);
+  const payload = parseJsonOutput(result);
+  assert.equal(payload.ok, false);
+  assert.equal(payload.error.code, 'INVALID_FLAG_VALUE');
+  assert.match(payload.error.message, /must include at least one positive integer tag id/i);
+});
+
 test('boolean flags with --key=false do not silently flip behavior', () => {
   const result = runCli(['--output', 'json', 'scan', '--active=false']);
   assert.equal(result.status, 1);
@@ -4924,6 +4946,83 @@ test('mirror browse returns candidate markets with existing mirror hint', async
   }
 });
 
+test('mirror browse supports sports tag filters via gamma events endpoint', async () => {
+  const gamma = await startJsonHttpServer((request) => {
+    const parsed = new URL(request.url || '/', 'http://127.0.0.1');
+    if (parsed.pathname !== '/events') {
+      return { status: 404, body: { error: 'not found' } };
+    }
+
+    const tagId = parsed.searchParams.get('tag_id');
+    if (tagId !== '82') {
+      return { body: { events: [] } };
+    }
+
+    return {
+      body: {
+        events: [
+          {
+            id: 'evt-epl-1',
+            slug: 'everton-v-burnley',
+            title: 'Everton vs Burnley',
+            markets: [
+              {
+                condition_id: 'poly-epl-c1',
+                market_slug: 'everton-v-burnley-home',
+                question: 'Will Everton beat Burnley?',
+                end_date_iso: FIXED_MIRROR_CLOSE_ISO,
+                active: true,
+                closed: false,
+                volume24hr: 550000,
+                tokens: [
+                  { outcome: 'Yes', price: '0.605', token_id: 'poly-epl-yes-1' },
+                  { outcome: 'No', price: '0.395', token_id: 'poly-epl-no-1' },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+  });
+
+  try {
+    const result = await runCliAsync([
+      '--output',
+      'json',
+      'mirror',
+      'browse',
+      '--skip-dotenv',
+      '--polymarket-gamma-url',
+      gamma.url,
+      '--polymarket-tag-id',
+      '82',
+      '--limit',
+      '5',
+    ]);
+
+    assert.equal(result.status, 0);
+    const payload = parseJsonOutput(result);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.command, 'mirror.browse');
+    assert.equal(payload.data.source, 'polymarket:gamma-events');
+    assert.deepEqual(payload.data.filters.polymarketTagIds, [82]);
+    assert.equal(payload.data.count, 1);
+    assert.equal(payload.data.items[0].eventSlug, 'everton-v-burnley');
+    assert.equal(payload.data.items[0].eventTitle, 'Everton vs Burnley');
+    assert.equal(payload.data.items[0].eventId, 'evt-epl-1');
+
+    const eventRequest = gamma.requests.find((entry) => String(entry.url || '').startsWith('/events?'));
+    assert.ok(eventRequest);
+    const parsed = new URL(eventRequest.url, 'http://127.0.0.1');
+    assert.equal(parsed.searchParams.get('tag_id'), '82');
+    assert.equal(parsed.searchParams.get('active'), 'true');
+    assert.equal(parsed.searchParams.get('closed'), 'false');
+  } finally {
+    await gamma.close();
+  }
+});
+
 test('mirror sync accepts --market-address with --dry-run mode alias', async () => {
   const tempDir = createTempDir('pandora-mirror-sync-aliases-');
   const stateFile = path.join(tempDir, 'mirror-state.json');

package/tests/unit/new-features.test.cjs

@@ -1027,6 +1027,124 @@ test('browsePolymarketMarkets filters mock payload deterministically', async ()
   }
 });
 
+test('browsePolymarketMarkets uses gamma events endpoint for tag-id sports discovery', async () => {
+  const requests = [];
+  const server = http.createServer((req, res) => {
+    requests.push(req.url || '/');
+    const parsed = new URL(req.url || '/', 'http://127.0.0.1');
+    const tagId = parsed.searchParams.get('tag_id');
+
+    res.statusCode = 200;
+    res.setHeader('content-type', 'application/json');
+
+    if (parsed.pathname !== '/events') {
+      res.end(JSON.stringify({ events: [] }));
+      return;
+    }
+
+    if (tagId === '82') {
+      res.end(
+        JSON.stringify({
+          events: [
+            {
+              id: 'evt-82',
+              slug: 'everton-v-burnley',
+              title: 'Everton vs Burnley',
+              markets: [
+                {
+                  condition_id: 'sports-c1',
+                  market_slug: 'everton-v-burnley-home',
+                  question: 'Will Everton beat Burnley?',
+                  end_date_iso: '2030-03-09T16:00:00Z',
+                  active: true,
+                  closed: false,
+                  volume24hr: 500000,
+                  tokens: [
+                    { outcome: 'Yes', price: '0.605', token_id: 'yes-sports-1' },
+                    { outcome: 'No', price: '0.395', token_id: 'no-sports-1' },
+                  ],
+                },
+              ],
+            },
+          ],
+        }),
+      );
+      return;
+    }
+
+    if (tagId === '100350') {
+      res.end(
+        JSON.stringify({
+          events: [
+            {
+              id: 'evt-100350',
+              slug: 'leeds-v-sunderland',
+              title: 'Leeds vs Sunderland',
+              markets: [
+                {
+                  // Duplicate condition id should be deduped across tag-id scans.
+                  condition_id: 'sports-c1',
+                  market_slug: 'duplicate-market-ignored',
+                  question: 'Duplicate row should be ignored',
+                  end_date_iso: '2030-03-09T16:00:00Z',
+                  active: true,
+                  closed: false,
+                  volume24hr: 1,
+                  tokens: [
+                    { outcome: 'Yes', price: '0.5', token_id: 'dup-yes' },
+                    { outcome: 'No', price: '0.5', token_id: 'dup-no' },
+                  ],
+                },
+                {
+                  condition_id: 'sports-c2',
+                  market_slug: 'leeds-v-sunderland-home',
+                  question: 'Will Leeds beat Sunderland?',
+                  end_date_iso: '2030-03-09T16:00:00Z',
+                  active: true,
+                  closed: false,
+                  volume24hr: 400000,
+                  tokens: [
+                    { outcome: 'Yes', price: '0.495', token_id: 'yes-sports-2' },
+                    { outcome: 'No', price: '0.505', token_id: 'no-sports-2' },
+                  ],
+                },
+              ],
+            },
+          ],
+        }),
+      );
+      return;
+    }
+
+    res.end(JSON.stringify({ events: [] }));
+  });
+
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+  const { port } = server.address();
+  const gammaUrl = `http://127.0.0.1:${port}`;
+
+  try {
+    const payload = await browsePolymarketMarkets({
+      gammaUrl,
+      polymarketTagIds: [82, 100350],
+      limit: 10,
+    });
+
+    assert.equal(payload.source, 'polymarket:gamma-events');
+    assert.deepEqual(payload.filters.polymarketTagIds, [82, 100350]);
+    assert.equal(payload.count, 2);
+    assert.equal(payload.items[0].eventSlug, 'everton-v-burnley');
+    assert.equal(payload.items[1].eventSlug, 'leeds-v-sunderland');
+    assert.equal(payload.items[0].eventTitle, 'Everton vs Burnley');
+    assert.equal(payload.items[0].eventId, 'evt-82');
+
+    const eventRequests = requests.filter((entry) => String(entry).startsWith('/events?'));
+    assert.equal(eventRequests.length, 2);
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
 test('computeApprovalDiff deterministically marks missing allowance/operator checks', () => {
   const payload = computeApprovalDiff({
     ownerAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',

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]);
+});