@stratabook/mcp 0.2.3 → 0.2.5

package/README.md

@@ -45,6 +45,8 @@ The tools currently available are:
 - `strata_portfolio_history`
 - `strata_market_making_status`
 - `strata_market_making_reputation`
+- `strata_market_making_prepare` — start or stop a Strand/Current from a market label, decimal base size, spread, and duration; no arrays or atom conversion
+- `strata_market_making_submit_and_wait` — submit the externally signed preparation idempotently and wait for matching chain-derived state
 - `strata_market_making_strand_prepare`, `strata_market_making_strand_submit`
 - `strata_market_making_current_prepare`, `strata_market_making_current_submit`
 - `strata_vault_status`
@@ -82,6 +84,27 @@ so a disabled capability stops immediately even if a client cached an older
 tool list. Tool discovery from the connected server remains authoritative for
 self-hosted deployments or any future policy change.
 
+For normal maker operation, use two calls:
+
+1. Call `strata_market_making_prepare` with `action: "start"`, a label such as
+   `SOL/USDC`, `product: "current"` or `"strand"`, `spreadBps`, a decimal size
+   such as `0.01 SOL`, and the maker wallet. Duration defaults to ten minutes
+   and levels default to three.
+2. Verify and sign only `prepared.transaction_base64` in the external wallet,
+   then pass it and `prepared.maker_control_id` to
+   `strata_market_making_submit_and_wait`.
+
+The second call returns only after Strata's chain-derived maker status matches
+the exact product settings. Use `action: "stop"` through the same pair. The
+older product-specific tools remain available for strategies that deliberately
+manage every low-level array and safety field.
+
+For maker funding, initialize the market Vault if needed, activate the Strand
+or Current, then deposit with `strata_vault_deposit`. The market keeps that
+available collateral while a control is live and returns it after the final
+control is disabled, exhausted, expired, or cancelled. Current follows Strata's
+live mark and needs no separate publisher transaction.
+
 ## Hosted Streamable HTTP
 
 The managed public endpoint is:

package/dist/src/server.js

@@ -21,6 +21,8 @@ const LEGACY_TOOL_CAPABILITIES = {
     strata_market_making_strand_submit: { ids: ["mm.strand.manage"] },
     strata_market_making_current_prepare: { ids: ["mm.current.manage"] },
     strata_market_making_current_submit: { ids: ["mm.current.manage"] },
+    strata_market_making_prepare: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
+    strata_market_making_submit_and_wait: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
     strata_execute_quote: { ids: ["trade.submit"] },
     strata_order_execute: { ids: ["orders.prepare", "orders.submit"] },
 };
@@ -61,6 +63,8 @@ const PLATFORM_TOOL_CAPABILITIES = {
     strata_market_making_strand_submit: { ids: ["mm.strand.manage"] },
     strata_market_making_current_prepare: { ids: ["mm.current.manage"] },
     strata_market_making_current_submit: { ids: ["mm.current.manage"] },
+    strata_market_making_prepare: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
+    strata_market_making_submit_and_wait: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
     strata_rewards: { ids: ["rewards.read"] },
     strata_referrals: { ids: ["referrals.read"] },
     strata_referral_link: { ids: ["referrals.link"] },
@@ -256,6 +260,7 @@ export async function createStrataMcpServer(options = {}) {
         instructions: STRATA_AGENT_HARNESS_INSTRUCTIONS,
     });
     const { registerTool, handles: registeredTools } = trackedToolRegistrar(server);
+    const makerQuickstartPreparations = new Map();
     server.registerResource("strata_agent_harness", STRATA_AGENT_HARNESS_URI, {
         title: "Strata Agent Harness",
         description: "Canonical capability-gated first-run workflow for Strata agents.",
@@ -1509,6 +1514,109 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.orders.status(marketId, { orderControlId, idempotencyKey });
         return toolResult(response, `Order control ${response.order_control_id} is ${response.status}.`);
     }));
+    const makerPrepare = registerTool("strata_market_making_prepare", {
+        title: "Prepare simple Strata market making",
+        description: "Prepare a pro-level Strand or Current from a market label, decimal base size, spread, and duration. Strata resolves IDs, decimals, live mark, tick grid, expiry, safety bounds, and fixed on-chain arrays. Sign only the returned transaction externally, then call submit_and_wait.",
+        inputSchema: {
+            action: z.enum(["start", "stop"]),
+            market: z.string().min(1).max(128),
+            product: z.enum(["strand", "current"]),
+            makerWallet: z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/),
+            spreadBps: z.number().int().min(1).max(5_000).optional(),
+            size: z.string().min(1).max(64).optional(),
+            duration: z.union([
+                z.number().int().min(1).max(604_800),
+                z.string().regex(/^[1-9][0-9]*(?:s|m|h|d)$/i),
+            ]).optional(),
+            levels: z.number().int().min(1).max(16).optional(),
+            levelStepBps: z.number().int().min(1).max(5_000).optional(),
+            side: z.enum(["both", "buy", "sell"]).optional(),
+            asyncOnly: z.boolean().optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => guardedTool(client, `mm.${args.product}.manage`, async () => {
+        const prepared = args.action === "stop"
+            ? await platformClient.marketMaking.prepareStop({
+                market: args.market,
+                product: args.product,
+                makerWallet: args.makerWallet,
+            })
+            : (() => {
+                if (args.spreadBps === undefined || args.size === undefined) {
+                    return undefined;
+                }
+                return platformClient.marketMaking.prepareStart({
+                    market: args.market,
+                    product: args.product,
+                    makerWallet: args.makerWallet,
+                    spreadBps: args.spreadBps,
+                    size: args.size,
+                    ...(args.duration === undefined ? {} : { duration: args.duration }),
+                    ...(args.levels === undefined ? {} : { levels: args.levels }),
+                    ...(args.levelStepBps === undefined ? {} : { levelStepBps: args.levelStepBps }),
+                    ...(args.side === undefined ? {} : { side: args.side }),
+                    ...(args.asyncOnly === undefined ? {} : { asyncOnly: args.asyncOnly }),
+                });
+            })();
+        if (prepared === undefined) {
+            return toolError("invalid_request", "Starting market making requires spreadBps and size.", false);
+        }
+        const resolved = await prepared;
+        makerQuickstartPreparations.set(resolved.prepared.maker_control_id, resolved);
+        while (makerQuickstartPreparations.size > 128) {
+            const oldest = makerQuickstartPreparations.keys().next().value;
+            if (oldest === undefined)
+                break;
+            makerQuickstartPreparations.delete(oldest);
+        }
+        const response = {
+            action: args.action,
+            market: resolved.market,
+            product: resolved.product,
+            ...("base_asset" in resolved ? { base_asset: resolved.base_asset } : {}),
+            operation: resolved.operation,
+            prepared: resolved.prepared,
+        };
+        return toolResult(response, `Prepared ${args.action} for ${resolved.market.label} as ${resolved.prepared.maker_control_id}. Verify and sign only prepared.transaction_base64, then submit it within 30 seconds.`);
+    }));
+    const makerSubmitAndWait = registerTool("strata_market_making_submit_and_wait", {
+        title: "Submit and confirm Strata market making",
+        description: "Submit the exact externally signed quickstart transaction and wait until Strata's chain-derived maker state confirms the product started or stopped. The control ID is its default idempotency key.",
+        inputSchema: {
+            makerControlId: z.string().regex(/^mc_[0-9a-f]{32}$/),
+            signedTransactionBase64: z.string().min(4).max(4_096).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+            idempotencyKey: z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/).optional(),
+            confirmationTimeoutMs: z.number().int().min(1_000).max(120_000).optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const prepared = makerQuickstartPreparations.get(args.makerControlId);
+        if (!prepared) {
+            return toolError("session_expired", "This quickstart preparation is not in the current MCP session. Prepare it again; maker transactions expire after 30 seconds.", false);
+        }
+        return guardedTool(client, `mm.${prepared.product}.manage`, async () => {
+            const response = await platformClient.marketMaking.submitPrepared({
+                prepared,
+                signedTransactionBase64: args.signedTransactionBase64,
+                ...(args.idempotencyKey === undefined ? {} : { idempotencyKey: args.idempotencyKey }),
+                ...(args.confirmationTimeoutMs === undefined
+                    ? {}
+                    : { confirmationTimeoutMs: args.confirmationTimeoutMs }),
+            });
+            makerQuickstartPreparations.delete(args.makerControlId);
+            return toolResult(response, `${response.product} is confirmed ${response.operation.action === "cancel" ? "stopped" : "live"} on ${response.market.label}.`);
+        });
+    });
     const makerStrandPrepare = registerTool("strata_market_making_strand_prepare", {
         title: "Prepare Strata Strand control",
         description: "Build one exact unsigned maker-owned Strand transaction. Every exposure and level size is expressed in base-asset atoms, never lots or whole tokens. Verify and sign it externally with the maker wallet, then submit it with the Strand submit tool.",
@@ -1700,6 +1808,8 @@ export async function createStrataMcpServer(options = {}) {
         orderPrepare,
         orderSubmit,
         orderStatus,
+        makerPrepare,
+        makerSubmitAndWait,
         makerStrandPrepare,
         makerStrandSubmit,
         makerCurrentPrepare,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stratabook/mcp",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Connect AI agents to Strata markets and Sonar quotes with MCP.",
   "type": "module",
   "license": "MIT OR Apache-2.0",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@stratabook/sdk": "0.2.3",
+    "@stratabook/sdk": "0.2.5",
     "zod": "^3.25.76"
   },
   "devDependencies": {