@senpi/runtime 3.0.9-dev.20260710204324 → 3.0.9-dev.feat-strategy-compos.20260716233548

package/dist/composer/registry/generate.py

@@ -0,0 +1,425 @@
+"""generate — deterministic artifact generation from the registry (D4, D6).
+
+Everything the agent and the tooling read is generated here from ``NODES`` alone, so it
+cannot drift from the models the validator/compiler use. Three artifacts, written to
+``composer/generated/`` (see that directory's README):
+
+    graph.schema.json  — JSON Schema for the graph document format (D6). YAML is authored;
+                          this JSON Schema is canonical. Per-node param constraints are
+                          derived via if/then on the node name. YAML anchors/merge keys are
+                          banned at the document level (noted here; enforced in slice 2).
+    catalog.md         — the ~1-2k-token index: node names + one-liners + param summaries.
+    describe.md        — full ports/params/example/cost per node (`composer describe`).
+
+Determinism is a hard requirement (the golden-file oracle): stable ordering
+(``sorted_nodes``), sorted JSON keys, no timestamps, trailing newline. Run twice → byte
+identical. Entry point:
+
+    python -m composer.registry.generate            # write artifacts
+    python -m composer.registry.generate --check     # exit 1 if regeneration differs
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from .models import NodeDef, Param, PortType, SCHEMA_VERSION
+from .nodes import KIND_ORDER, sorted_nodes
+
+GENERATED_DIR = Path(__file__).resolve().parent.parent / "generated"
+SCHEMA_PATH = GENERATED_DIR / "graph.schema.json"
+CATALOG_PATH = GENERATED_DIR / "catalog.md"
+DESCRIBE_PATH = GENERATED_DIR / "describe.md"
+
+_JSON_TYPE = {
+    "int": "integer",
+    "float": "number",
+    "str": "string",
+    "bool": "boolean",
+}
+
+
+# --------------------------------------------------------------------------- JSON Schema
+
+def _param_schema(param: Param) -> dict:
+    """JSON Schema fragment for a single param (with bounds, choices, default)."""
+    if param.type == "list[str]":
+        node: dict = {"type": "array", "items": {"type": "string"}}
+    elif param.type == "map_str_float":
+        node = {"type": "object", "additionalProperties": {"type": "number"}}
+    elif param.type == "map_str_json":
+        # str-keyed JSON object passed verbatim to an MCP tool (mcp_read escape hatch); values
+        # are arbitrary JSON, so no additionalProperties constraint beyond "it is an object".
+        node = {"type": "object"}
+    else:
+        node = {"type": _JSON_TYPE[param.type]}
+        if param.minimum is not None:
+            node["minimum"] = param.minimum
+        if param.maximum is not None:
+            node["maximum"] = param.maximum
+        if param.choices is not None:
+            node["enum"] = list(param.choices)
+    if param.default is not None:
+        node["default"] = list(param.default) if isinstance(param.default, tuple) else param.default
+    node["description"] = param.doc
+    return node
+
+
+def _params_object_schema(node: NodeDef) -> dict:
+    props = {p.name: _param_schema(p) for p in node.params}
+    required = [p.name for p in node.params if p.default is None]
+    obj: dict = {"type": "object", "additionalProperties": False, "properties": props}
+    if required:
+        obj["required"] = sorted(required)
+    return obj
+
+
+def _pure_fn_port_schema() -> dict:
+    """A pure_fn declared port: name + a type from the closed PortType vocabulary."""
+    return {
+        "type": "object",
+        "additionalProperties": False,
+        "required": ["name", "type"],
+        "properties": {
+            "name": {"type": "string"},
+            "type": {"enum": [t.value for t in PortType]},
+            "doc": {"type": "string"},
+        },
+    }
+
+
+def _pure_fn_param_schema() -> dict:
+    """A pure_fn literal param (config, not an edge): name + type + optional default."""
+    return {
+        "type": "object",
+        "additionalProperties": False,
+        "required": ["name", "type"],
+        "properties": {
+            "name": {"type": "string"},
+            "type": {"enum": ["int", "float", "str", "bool", "list[str]", "map_str_float"]},
+            "default": {},
+            "doc": {"type": "string"},
+        },
+    }
+
+
+def _pure_fn_test_schema() -> dict:
+    """An inline fixture case: named input values -> expected outputs (run at validate time)."""
+    return {
+        "type": "object",
+        "additionalProperties": False,
+        "required": ["name", "inputs", "expect"],
+        "properties": {
+            "name": {"type": "string"},
+            "inputs": {"type": "object"},
+            "expect": {"type": "object"},
+        },
+    }
+
+
+def build_schema() -> dict:
+    nodes = sorted_nodes()
+    names = sorted(n.name for n in nodes)
+
+    defs = {f"params_{n.name}": _params_object_schema(n) for n in nodes}
+    all_of = [
+        {
+            "if": {"properties": {"node": {"const": n.name}}},
+            "then": {"properties": {"with": {"$ref": f"#/$defs/params_{n.name}"}}},
+        }
+        for n in sorted(nodes, key=lambda n: n.name)
+    ]
+
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "$id": "https://senpi.ai/strategy-composer/graph.schema.json",
+        "title": "Strategy Composer Graph",
+        "description": (
+            "Typed dataflow DAG for a trading strategy (D1). YAML is authored; this JSON "
+            "Schema is canonical (D6). YAML anchors and merge keys are banned at the "
+            "document level (enforced in the validator, slice 2). Generated from the node "
+            "registry — do not edit by hand."
+        ),
+        "type": "object",
+        "additionalProperties": False,
+        "required": ["nodes"],
+        "properties": {
+            "version": {"const": SCHEMA_VERSION, "description": "Registry/schema version."},
+            "metadata": {
+                "type": "object",
+                "description": "Interview answers and authoring notes (D7); free-form.",
+            },
+            "nodes": {
+                "type": "array",
+                "minItems": 1,
+                "description": (
+                    "The DAG nodes. Each is EITHER a primitive node binding a registry "
+                    "`node:` to params, OR a per-graph `kind: pure_fn` node (D2 kind 2) "
+                    "carrying declared typed inputs/outputs and an inline `fn:` body. The "
+                    "per-node `node`-keyed branches below apply only to primitive nodes; a "
+                    "pure_fn node (no `node:`) satisfies them vacuously and is checked by the "
+                    "validator's purity + inline-test stage."
+                ),
+                "items": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "required": ["id"],
+                    "properties": {
+                        "id": {"type": "string", "description": "Unique node id within the graph."},
+                        "node": {
+                            "type": "string",
+                            "enum": names,
+                            "description": "Registry node name (primitive nodes only).",
+                        },
+                        "with": {"type": "object", "description": "Node parameters."},
+                        "kind": {
+                            "enum": ["pure_fn"],
+                            "description": "Marks a per-graph pure-function node (D2 kind 2).",
+                        },
+                        "inputs": {
+                            "type": "array",
+                            "items": _pure_fn_port_schema(),
+                            "description": "pure_fn declared typed input ports.",
+                        },
+                        "outputs": {
+                            "type": "array",
+                            "items": _pure_fn_port_schema(),
+                            "description": "pure_fn declared typed output ports.",
+                        },
+                        "params": {
+                            "type": "array",
+                            "items": _pure_fn_param_schema(),
+                            "description": "pure_fn literal params (config, not edges).",
+                        },
+                        "fn": {
+                            "type": "string",
+                            "description": "pure_fn body: exactly one top-level `def` (purity-checked).",
+                        },
+                        "tests": {
+                            "type": "array",
+                            "items": _pure_fn_test_schema(),
+                            "description": "pure_fn inline fixture tests, run at validate time.",
+                        },
+                    },
+                    "allOf": all_of,
+                },
+            },
+            "edges": {
+                "type": "array",
+                "description": "Wiring: from 'nodeId.outPort' to 'nodeId.inPort' (D1).",
+                "items": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "required": ["from", "to"],
+                    "properties": {
+                        "from": {"type": "string", "pattern": "^[^.]+\\.[^.]+$"},
+                        "to": {"type": "string", "pattern": "^[^.]+\\.[^.]+$"},
+                    },
+                },
+            },
+            "pipeline": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": (
+                    "RESERVED shorthand marker for the common linear case (D1/D6). "
+                    "Desugaring into nodes+edges is slice 2 and is NOT built here."
+                ),
+            },
+        },
+        "$defs": defs,
+    }
+
+
+def render_schema() -> str:
+    return json.dumps(build_schema(), indent=2, sort_keys=True) + "\n"
+
+
+# ------------------------------------------------------------------------------- catalog
+
+def _param_summary(param: Param) -> str:
+    if param.default is None:
+        val = "required"
+    elif param.type == "list[str]":
+        val = "[" + ", ".join(param.default) + "]"
+    elif param.type in ("map_str_float", "map_str_json"):
+        val = "{...}" if param.default else "{}"
+    else:
+        val = repr(param.default) if param.type == "str" else str(param.default)
+    body = f"{param.name} ({param.type}={val}"
+    if param.minimum is not None or param.maximum is not None:
+        body += f", {_bound(param, param.minimum)}..{_bound(param, param.maximum)}"
+    return body + ")"
+
+
+def _bound(param: Param, value) -> str:
+    if value is None:
+        return ""
+    return str(int(value)) if param.type == "int" else str(value)
+
+
+def render_catalog() -> str:
+    lines = [
+        "# Strategy Composer — Node Catalog",
+        "",
+        f"Schema version: {SCHEMA_VERSION}. Generated from composer/registry/nodes.py — "
+        "do not edit by hand.",
+        "",
+        "Progressive-disclosure index (D4): node names, one-liners, param summaries. "
+        "`composer describe <node>` gives full ports/params/examples.",
+        "",
+        "## scoring",
+        "",
+        "Bespoke scoring/classification is a `kind: pure_fn` node (typed ports, one `def`, "
+        "math/statistics only, inline tests), never a primitive; `hard_gates_all` covers "
+        "simple gate-and-weigh. Repeated shapes promote post-MVP.",
+    ]
+    nodes = sorted_nodes()
+    for kind in KIND_ORDER:
+        kind_nodes = [n for n in nodes if n.kind.value == kind]
+        if not kind_nodes:
+            continue
+        lines.append("")
+        lines.append(f"## {kind}")
+        lines.append("")
+        for node in kind_nodes:
+            lines.append(f"- **{node.name}** — {node.summary}")
+            if node.params:
+                params = "; ".join(_param_summary(p) for p in node.params)
+                lines.append(f"  - params: {params}")
+    return "\n".join(lines) + "\n"
+
+
+# ------------------------------------------------------------------------------ describe
+
+def _port_line(port) -> str:
+    line = f"- `{port.name}`: {port.type.value} — {port.doc}"
+    annotations = []
+    if not port.required:
+        annotations.append("optional")
+    if port.merge:
+        annotations.append("merge")
+    if annotations:
+        line += f" [{', '.join(annotations)}]"
+    return line
+
+
+def _param_detail(param: Param) -> str:
+    if param.default is None:
+        default = "required"
+    elif param.type == "list[str]":
+        default = "[" + ", ".join(param.default) + "]"
+    elif param.type in ("map_str_float", "map_str_json"):
+        default = json.dumps(param.default, sort_keys=True)
+    else:
+        default = repr(param.default) if param.type == "str" else str(param.default)
+    line = f"- `{param.name}`: {param.type} (default: {default})"
+    if param.minimum is not None or param.maximum is not None:
+        line += f" [{_bound(param, param.minimum)}..{_bound(param, param.maximum)}]"
+    if param.choices is not None:
+        line += f" choices: {list(param.choices)}"
+    return line + f" — {param.doc}"
+
+
+def _describe_node(node) -> list[str]:
+    """The reference block for ONE node (shared by the full describe.md and the per-node
+    `composer describe <node>` verb, so the two never drift)."""
+    lines = [
+        f"## {node.name}  ({node.kind.value})",
+        "",
+        node.doc,
+        "",
+        "Inputs:",
+    ]
+    lines.extend([_port_line(p) for p in node.inputs] or ["- (none)"])
+    lines.append("")
+    lines.append("Outputs:")
+    lines.extend([_port_line(p) for p in node.outputs] or ["- (none)"])
+    lines.append("")
+    lines.append("Params:")
+    lines.extend([_param_detail(p) for p in node.params] or ["- (none)"])
+    lines.append("")
+    lines.append(f"Cost: {node.cost}")
+    lines.append("")
+    lines.append("Example:")
+    lines.append("```yaml")
+    lines.append(node.example.rstrip("\n"))
+    lines.append("```")
+    return lines
+
+
+def render_describe() -> str:
+    lines = [
+        "# Strategy Composer — Node Reference",
+        "",
+        f"Schema version: {SCHEMA_VERSION}. Generated from composer/registry/nodes.py — "
+        "do not edit by hand.",
+    ]
+    for node in sorted_nodes():
+        lines.append("")
+        lines.extend(_describe_node(node))
+    return "\n".join(lines) + "\n"
+
+
+def render_describe_node(name: str) -> str:
+    """Render the reference block for a single node by name (the `composer describe` verb).
+
+    Raises KeyError with the nearest-alternatives hint when the name is unknown, mirroring
+    the validator's unknown-node teaching error so the surface stays consistent.
+    """
+    from . import NODES_BY_NAME
+
+    node = NODES_BY_NAME.get(name)
+    if node is None:
+        known = sorted(NODES_BY_NAME)
+        near = [n for n in known if name in n or n in name or n[:3] == name[:3]]
+        hint = f" Did you mean: {', '.join(near[:4])}?" if near else ""
+        raise KeyError(
+            f"unknown node {name!r}.{hint} Run `composer catalog` for the full index."
+        )
+    return "\n".join(_describe_node(node)) + "\n"
+
+
+# -------------------------------------------------------------------------------- driver
+
+ARTIFACTS = {
+    "graph.schema.json": (SCHEMA_PATH, render_schema),
+    "catalog.md": (CATALOG_PATH, render_catalog),
+    "describe.md": (DESCRIBE_PATH, render_describe),
+}
+
+
+def write_all() -> None:
+    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
+    for _name, (path, render) in ARTIFACTS.items():
+        path.write_text(render(), encoding="utf-8")
+
+
+def check_all() -> list[str]:
+    """Return the list of artifact names whose committed content differs from a fresh render."""
+    stale = []
+    for name, (path, render) in ARTIFACTS.items():
+        current = path.read_text(encoding="utf-8") if path.exists() else None
+        if current != render():
+            stale.append(name)
+    return stale
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else argv
+    if "--check" in argv:
+        stale = check_all()
+        if stale:
+            print("stale generated artifacts (run `python -m composer.registry.generate`): "
+                  + ", ".join(stale), file=sys.stderr)
+            return 1
+        print("generated artifacts are up to date")
+        return 0
+    write_all()
+    print(f"wrote {len(ARTIFACTS)} artifacts to {GENERATED_DIR}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/composer/registry/mcp-tools-snapshot.json

@@ -0,0 +1,193 @@
+{
+  "_comment": "Trimmed snapshot of the live prod MCP tools/list (names + input-schema hash only) for the registry closure check. Regenerate via MCP_SNAPSHOT_REFRESH=1 pytest python-tests/composer/test_mcp_closure.py (fetches https://mcp.prod.senpi.ai/mcp, unauthenticated initialize + tools/list). Do not hand-edit.",
+  "source": "https://mcp.prod.senpi.ai/mcp",
+  "tool_count": 62,
+  "tools": {
+    "account_get_historical_info": {
+      "schema_sha256": "343e4681e9c8d500ccd29de71e8cf39a7ee013f438f3e4e219ce25f40c89f6f9"
+    },
+    "account_get_portfolio": {
+      "schema_sha256": "f9192e9e827d7d1c112bb7f25721e6a2e01955ecc150e238a6bd6a7beecadced"
+    },
+    "arena_leaderboard": {
+      "schema_sha256": "ce4c834ff0444dddf743e5d9f3a366d6e30ab5ee96dcc512e94ad106deb6fad2"
+    },
+    "arena_pool": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "arena_prizes": {
+      "schema_sha256": "421d6192dfab0707b947e318d96d78a94fc80d8d63d99f275093a04e88b05917"
+    },
+    "arena_roe_chart": {
+      "schema_sha256": "ea0f18eda7b70ce3b3d2ddf84f44f7ec8029549c403c55dcf5ee35032c62d535"
+    },
+    "cancel_order": {
+      "schema_sha256": "27093457765e49342e60be640f5160cf839e832942f6f9532fab1246961654c3"
+    },
+    "close_position": {
+      "schema_sha256": "a9992eecf1e84e639be4356e36f79c79319382ac354f2b254f73f8b3b12de829"
+    },
+    "create_position": {
+      "schema_sha256": "01d65e0cb9cf1aec73f37d8246a7f2b75a7826f83f6dfc5c3ee07cf9b0c4b80d"
+    },
+    "discovery_get_open_position_realized_pnl": {
+      "schema_sha256": "c40eeebdd3242b3a97821a9f45c99cdc1bfe476482bb660b9ccdf65055632358"
+    },
+    "discovery_get_top_strategies": {
+      "schema_sha256": "bf9c4d412268be3c8f2aae23c8af4b5a69fb12f15ccdfd487b6fc970ea5f674f"
+    },
+    "discovery_get_top_traders": {
+      "schema_sha256": "38d62d42db6811ff6e2b707036bc92110318d32ee2a405896b0d598057db441e"
+    },
+    "discovery_get_trader_history": {
+      "schema_sha256": "fef06f73272f9a637f937d898be4fddd23b47150062f0bd36eebe3ca0633cc60"
+    },
+    "discovery_get_trader_state": {
+      "schema_sha256": "9a07274df7f2d5721478100cf5e4b9b5b1ef41ccee25b7e94ff01324a94c20f4"
+    },
+    "edit_position": {
+      "schema_sha256": "a5b8e3a7f2ac89b0e262354f74a18aa56239379d37b65897e8d7465865f17b00"
+    },
+    "estimate_custom_strategy_positions_opening": {
+      "schema_sha256": "341b278c6bc5bc7905facf44a39d55d2aa60cda02df0cd231629f030a94b2ba0"
+    },
+    "execution_estimate_position_opening": {
+      "schema_sha256": "ff038e8aeb0baf8dcee1f1c8e6ddb7d2b20ee5ef904a521fa15b548eb4eaad22"
+    },
+    "execution_get_closed_position_details": {
+      "schema_sha256": "3e4eb5ae16ae78866979ee466e52a15716b090dee82669515f584cecf7e8592f"
+    },
+    "execution_get_open_position_details": {
+      "schema_sha256": "406eb43e19077ce59e967b4b73100e72e0bfdec4205ceb9ef82fbc412d9a3d24"
+    },
+    "execution_get_order_status": {
+      "schema_sha256": "22e5705787eb675c913a28f4fa324f80b127a147141a50d1ac5ed1e7ccfb7d2b"
+    },
+    "get_loyalty_tiers": {
+      "schema_sha256": "c8a1ac469a826ea3547ac220c7bbfdcd6b58080d4ec596ff2a0149c5ccb9b699"
+    },
+    "leaderboard_get_markets": {
+      "schema_sha256": "a317a038e3a1303d3f57f75a48829a6eacdb4de0389b0b2c37f2a0b089079dd7"
+    },
+    "leaderboard_get_momentum_events": {
+      "schema_sha256": "0820afef65df3db8c953d3730ec788582dedc829d4f69ee4cde68911d574fcf5"
+    },
+    "leaderboard_get_status": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "leaderboard_get_top": {
+      "schema_sha256": "454650ea0b6ef0d3c649572d64181d76c721501c7bfe493807cd217ebb0b959d"
+    },
+    "leaderboard_get_trader": {
+      "schema_sha256": "0a2734aef6353d2453bf6baf1d98adeb1f2a160fbce63100028ecf14653a598b"
+    },
+    "leaderboard_get_trader_positions": {
+      "schema_sha256": "0a2734aef6353d2453bf6baf1d98adeb1f2a160fbce63100028ecf14653a598b"
+    },
+    "list_senpi_guides": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "market_get_asset_data": {
+      "schema_sha256": "00c3d06ea47ed8d5c15db12cfa1d7cb3c0e13489ed352fb9a0bcab757a654ddb"
+    },
+    "market_get_cross_asset_flows": {
+      "schema_sha256": "64c0acc7ee5112d28137cf5da5b7391e7d46e3059aa9e549dcf8f043524211ba"
+    },
+    "market_get_funding_history": {
+      "schema_sha256": "7ab047ba0d7d08fffe96b677137117584e198c1500e83bd53075a68970638d16"
+    },
+    "market_get_funding_regime": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "market_get_prices": {
+      "schema_sha256": "31d8841aef56629c14676092d10b023aed8d1ebfc83c35b57709980f1c4d5584"
+    },
+    "market_list_instruments": {
+      "schema_sha256": "6c94db6f450c8cbd6e3977beaddddd9861b2534239d96d1e48949fa749f0a0cd"
+    },
+    "ratchet_stop_add": {
+      "schema_sha256": "40be0af285960b6bccd8ee6be9c59672a9b0f3497b7cdcfaffdcdeea4a8dfea8"
+    },
+    "ratchet_stop_delete": {
+      "schema_sha256": "6691ba26604fa3c87424289cf222af89b4cc8e19faf0c23c51f3dea4d12b3274"
+    },
+    "ratchet_stop_edit": {
+      "schema_sha256": "0f3d557613ce310b9e8029f7a36e3fab8936b41acf2a58963fa6d330105b6204"
+    },
+    "ratchet_stop_events": {
+      "schema_sha256": "2571476a51a089c95f8c3466eb8c6dd7144c1a1735801dbdfdd2dd40b76cf485"
+    },
+    "ratchet_stop_get": {
+      "schema_sha256": "567f87bcc34142ab4408542ed895c6662a7dd1b8d294261a58ef00c05622f2d0"
+    },
+    "ratchet_stop_list": {
+      "schema_sha256": "478226aafa7f1497a6fa29610208cd7a7075cbc75d102801f029ab5064bb456b"
+    },
+    "read_senpi_guide": {
+      "schema_sha256": "7e3d0dda419529f5f4f192a2a87e7897d9b13dda157803276df802240a2961ad"
+    },
+    "strategy_bridge_funds_from_hyperliquid_to_evm": {
+      "schema_sha256": "625d5c98d21eb3d3244f68e75af1496e8dbd58a7bbee5a3c7e4431aef025a645"
+    },
+    "strategy_close": {
+      "schema_sha256": "4dd7cae4b3282cc957341124d010f1f66774d4da56c4bb0ee19697b94f8f6ab1"
+    },
+    "strategy_close_positions": {
+      "schema_sha256": "1f301a7d902a96238e905192b135231e1afbb7236329bbdc3c1d4fc6a33ef58f"
+    },
+    "strategy_create": {
+      "schema_sha256": "8d164f7bc0a350ebfc73cb9708cca0065b4e144e2afec5087dce7bde8e46a099"
+    },
+    "strategy_create_custom_strategy": {
+      "schema_sha256": "10647877b62d274a6196fdd4c5586083706cf077fd398e3e5fc2e4e214952664"
+    },
+    "strategy_get": {
+      "schema_sha256": "85a57eda310b79cb1c6be47a3ae1b9f42d1274abbd6afcde1c2ef55734d2fea6"
+    },
+    "strategy_get_asset_trading_limits": {
+      "schema_sha256": "a7e88d43bcc19f61c9364d8008d14f471f6baf7a0b82a095de982959e70fe53d"
+    },
+    "strategy_get_clearinghouse_state": {
+      "schema_sha256": "06a33161f5e39fb38fbc79db0728b2404c18f0351169f28bf48274f5ea27d44e"
+    },
+    "strategy_get_open_orders": {
+      "schema_sha256": "23e715d14e321fe64647512e67a6e0553179268fb6e4dc17aaff4da8b1efed17"
+    },
+    "strategy_get_pnl_and_account_value_history": {
+      "schema_sha256": "0198d02c8c07affda424afe6f761d2c4525a2f66d1b441c5bdeeb56a2b992877"
+    },
+    "strategy_list": {
+      "schema_sha256": "78b1037a28cf446ad73cee48cb55d39a917c47fb0cc363c0836110039cf72a9f"
+    },
+    "strategy_pause": {
+      "schema_sha256": "4dd7cae4b3282cc957341124d010f1f66774d4da56c4bb0ee19697b94f8f6ab1"
+    },
+    "strategy_top_up": {
+      "schema_sha256": "5b90a94f30311ccf4ab6fd207929fef356073783acce189765cf94e5245f6a83"
+    },
+    "strategy_update": {
+      "schema_sha256": "7011937857282acf33e08f1d51c4d4425d325a48d5f7fc52bc580ebce1c52093"
+    },
+    "strategy_withdraw_funds": {
+      "schema_sha256": "297b1e9fb90acc7d62d2e1d95e6cb60a716f1cf6299e9ea6bf4ba3dd47387631"
+    },
+    "transfer_spot_to_perps": {
+      "schema_sha256": "89a78a64ef01c8ceaa381e54158c3111fa1671c98daea6a72e115a2a028568bf"
+    },
+    "user_claim_referral_rewards": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "user_get_me": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "user_get_referral_rewards": {
+      "schema_sha256": "efddc7bd8bbcef73a14eb1ace1ffdaec81e518ef1e13c1e9271d0b8acb694a49"
+    },
+    "user_get_senpi_points": {
+      "schema_sha256": "09aae7dac73afe34d62721e3c59c14cc2e78cdba77f8bee971161a7841379925"
+    },
+    "user_get_senpi_points_leaderboard": {
+      "schema_sha256": "e7289cdc922d69fd9028e0ddf3b9f848424a0bab059d79865a7382cb46dde444"
+    }
+  }
+}