@wowok/agent-mcp 2.7.2 → 2.7.4

package/dist/schemas/onchain_operations_guard.schema.json

@@ -2,139 +2,48 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "https://wowok.net/schemas/onchain_operations_guard.json",
   "title": "Guard Operation",
-  "description": "On-chain guard operation schema",
+  "description": "🛡️ Guard Object: Create immutable programmable validation rules that return boolean results. Set 'namedNew' to name the new Guard (you may also use 'object' as an alias — both work). Use root.type='node' for direct node tree or root.type='file' to load from file. Use 'wowok_buildin_info' tool with query='guard instructions' for all available operations. NOTE for EntityLinker/EntityRegistrar queries: Add system addresses to the Guard table - ENTITY_LINKER_ADDRESS (0xaaa) for EntityLinker, ENTITY_REGISTRAR_ADDRESS (0xaab) for EntityRegistrar.",
   "type": "object",
   "properties": {
     "operation_type": {
+      "type": "string",
       "const": "guard"
     },
     "data": {
       "type": "object",
-      "description": "On-chain Guard creation. IMPORTANT: All defined data (include all submitted data) must be defined in the 'table' field. USAGE: Set 'namedNew' field with {name, tags?, onChain?} to name the new Guard (you may also use 'object' as an alias for 'namedNew' — the MCP preprocess will convert it automatically). The Guard is immutable once created. Define the validation logic in 'root' field. When root.type='file', the file can contain all Guard fields, and any fields defined in the schema will OVERRIDE the file content.",
       "properties": {
         "namedNew": {
-          "$ref": "#/definitions/guard_namedNew",
-          "$schema": "http://json-schema.org/draft-07/schema#"
-        },
-        "description": {
-          "$ref": "#/definitions/guard_description",
-          "$schema": "http://json-schema.org/draft-07/schema#"
-        },
-        "table": {
-          "$ref": "#/definitions/guard_table",
-          "$schema": "http://json-schema.org/draft-07/schema#"
-        },
-        "root": {
-          "description": "Root definition: either a direct GuardNode computation tree (no type wrapper) or a file reference (type='file'). When type='file', the file can define all Guard fields (namedNew, description, table, root, rely), and schema fields override file content. For the node structure, see guard-node-schema.json for complete GuardNode definitions. IMPORTANT: The root node MUST be a logical operation returning Bool (e.g., logic_and, logic_or, logic_equal, query_reward_record_exists, etc.)",
-          "oneOf": [
-            {
-              "$ref": "guard-node-schema.json",
-              "description": "Direct GuardNode computation tree - the node MUST be a logical operation returning Bool (e.g., logic_and, logic_or, logic_equal, query_reward_record_exists, etc.). No 'type: node' wrapper needed."
-            },
-            {
-              "type": "object",
-              "description": "File reference",
-              "properties": {
-                "type": {
-                  "const": "file"
-                },
-                "file_path": {
-                  "type": "string",
-                  "description": "Path to JSON or Markdown file containing Guard definition"
-                },
-                "format": {
-                  "type": "string",
-                  "enum": [
-                    "json",
-                    "markdown"
-                  ],
-                  "default": "json",
-                  "description": "File format: 'json' or 'markdown'"
-                }
-              },
-              "required": [
-                "type",
-                "file_path"
-              ]
-            }
-          ]
-        },
-        "rely": {
-          "$ref": "#/definitions/guard_rely",
-          "$schema": "http://json-schema.org/draft-07/schema#"
-        },
-        "binding_hint": {
-          "$ref": "#/definitions/guard_binding_hint",
-          "$schema": "http://json-schema.org/draft-07/schema#"
-        }
-      },
-      "required": [
-        "root"
-      ],
-      "additionalProperties": false
-    },
-    "env": {
-      "$ref": "#/definitions/env",
-      "$schema": "http://json-schema.org/draft-07/schema#"
-    }
-  },
-  "required": [
-    "operation_type",
-    "data"
-  ],
-  "definitions": {
-    "guard_namedNew": {
-      "anyOf": [
-        {
-          "not": {}
-        },
-        {
+          "description": "Name and optional tags for the new Guard object. Set 'onChain: true' to create a public on-chain identity. When using root.type='file', this field OVERRIDES namedNew in the file. CIRCULAR DEPENDENCY (DOC-01): When a Guard queries a Service that hasn't been created yet, use a LocalMark NAME (not address) in the query table — the name is resolved to an address at transaction build time. Workflow: (1) Create Service (Phase 1, no publish) → (2) Create Guard referencing Service by name → (3) Update Service.buy_guard = Guard address → (4) Publish Service.",
           "type": "object",
           "properties": {
             "name": {
-              "type": "string",
-              "description": "The name of the object"
+              "description": "The name of the object",
+              "type": "string"
             },
             "tags": {
+              "description": "The tags of the object",
               "type": "array",
               "items": {
                 "type": "string"
-              },
-              "description": "The tags of the object"
+              }
             },
             "onChain": {
-              "type": "boolean",
-              "description": "CRITICAL: Whether to sync the name to the blockchain. DEFAULT (undefined/false): The name is stored LOCALLY ONLY on your device (PRIVATE). If set to true: The name is published ON-CHAIN and becomes PUBLICLY VISIBLE to everyone. Only set to true for displaying the relationships you are willing to make public on the chain."
+              "description": "CRITICAL: Whether to sync the name to the blockchain. DEFAULT (undefined/false): The name is stored LOCALLY ONLY on your device (PRIVATE). If set to true: The name is published ON-CHAIN and becomes PUBLICLY VISIBLE to everyone. Only set to true for displaying the relationships you are willing to make public on the chain.",
+              "type": "boolean"
             },
             "replaceExistName": {
-              "type": "boolean",
-              "description": "FORCE CLAIM: Set to true ONLY when the user explicitly expresses a STRONG INTENTION to forcefully take over an existing name (e.g., 'I must use this name', 'force rename', 'replace the existing one'). WARNING: This will UNBIND the name from its original object and rebind it to the new one, potentially breaking existing references. If not specified or false: the operation will FAIL with an error when the name is already in use (safe default behavior)."
+              "description": "FORCE CLAIM: Set to true ONLY when the user explicitly expresses a STRONG INTENTION to forcefully take over an existing name (e.g., 'I must use this name', 'force rename', 'replace the existing one'). WARNING: This will UNBIND the name from its original object and rebind it to the new one, potentially breaking existing references. If not specified or false: the operation will FAIL with an error when the name is already in use (safe default behavior).",
+              "type": "boolean"
             }
           },
-          "additionalProperties": false,
-          "description": "Assign a name and optional tags to a new object. By default, names are stored LOCALLY (private) on your device. Set 'onChain: true' to create a PUBLIC on-chain identity visible to everyone. IMPORTANT: If the requested name is already taken, the operation will FAIL by default. Only set 'replaceExistName: true' when the user EXPLICITLY demands to forcefully claim the name."
-        }
-      ],
-      "description": "Name and optional tags for the new Guard object. Set 'onChain: true' to create a public on-chain identity. When using root.type='file', this field OVERRIDES namedNew in the file. CIRCULAR DEPENDENCY (DOC-01): When a Guard queries a Service that hasn't been created yet, use a LocalMark NAME (not address) in the query table — the name is resolved to an address at transaction build time. Workflow: (1) Create Service (Phase 1, no publish) → (2) Create Guard referencing Service by name → (3) Update Service.buy_guard = Guard address → (4) Publish Service."
-    },
-    "guard_description": {
-      "anyOf": [
-        {
-          "not": {}
+          "additionalProperties": false
         },
-        {
-          "type": "string",
-          "description": "Description string (max 4000 bcs characters)"
-        }
-      ],
-      "description": "Guard description. When using root.type='file', this field OVERRIDES description in the file."
-    },
-    "guard_table": {
-      "anyOf": [
-        {
-          "not": {}
+        "description": {
+          "description": "Guard description. When using root.type='file', this field OVERRIDES description in the file.",
+          "type": "string"
         },
-        {
+        "table": {
+          "description": "Data table of the Guard object. When using root.type='file', this field OVERRIDES table in the file.",
           "type": "array",
           "items": {
             "type": "object",
@@ -440,6 +349,7 @@
                 "description": "Type of the value stored in `value`. One of: Bool(0), Address(1), String(2), U8(3), U16(4), U32(5), U64(6), U128(7), U256(8), VecBool(9), VecAddress(10), VecString(11), VecU8(12), VecU16(13), VecU32(14), VecU64(15), VecU128(16), VecU256(17), VecVecU8(18). When value_type=Address (1), the `value` field accepts a hex address string, a LocalMark name, or an AccountOrMark_Address object — see `value` field description for details."
               },
               "value": {
+                "description": "The actual value data. Format depends on `value_type`:\n• Bool: true/false (boolean)\n• Address (CRITICAL — string 'Address' is NOT a placeholder): a hex address (e.g. '0x1234...'), a LocalMark name (e.g. 'my-service' — resolved to address at evaluation time), an AccountOrMark_Address object (e.g. {name_or_address:'my-service'}), or system shorthand ('0xaaa' = EntityLinker, '0xaab' = EntityRegistrar). The literal string 'Address' itself is INVALID — it would be treated as a non-existent LocalMark name and fail. Example: value='0x2::wow::WOW<address>' or value='my-permission'.\n• String: any string\n• U8/U16/U32/U64/U128/U256: number or numeric string (e.g. 42 or '42')\n• Vec* types: arrays of the corresponding element type\nREQUIRED when b_submission=false. OPTIONAL when b_submission=true (value is supplied at evaluation time by user submission).",
                 "anyOf": [
                   {
                     "type": "boolean"
@@ -454,8 +364,8 @@
                             "description": "Account/Object name or ID. If specifying an account, use empty string '' for the default account. If it starts with '0x', it will be treated as an ID. Otherwise, it will be treated as a name (max 64 bcs characters)."
                           },
                           "local_mark_first": {
-                            "type": "boolean",
-                            "description": "Whether to prioritize local marks, if true, prioritize local marks, otherwise prioritize global marks"
+                            "description": "Whether to prioritize local marks, if true, prioritize local marks, otherwise prioritize global marks",
+                            "type": "boolean"
                           }
                         },
                         "additionalProperties": false,
@@ -486,12 +396,24 @@
                           "entities": {
                             "type": "array",
                             "items": {
-                              "$ref": "#/definitions/guard_table/anyOf/1/items/properties/value/anyOf/1/anyOf/0"
+                              "type": "object",
+                              "properties": {
+                                "name_or_address": {
+                                  "type": "string",
+                                  "description": "Account/Object name or ID. If specifying an account, use empty string '' for the default account. If it starts with '0x', it will be treated as an ID. Otherwise, it will be treated as a name (max 64 bcs characters)."
+                                },
+                                "local_mark_first": {
+                                  "description": "Whether to prioritize local marks, if true, prioritize local marks, otherwise prioritize global marks",
+                                  "type": "boolean"
+                                }
+                              },
+                              "additionalProperties": false,
+                              "description": "Account or address lookup object. Use this to specify which account to use for an operation. EXAMPLE: { name_or_address: 'testor2' } - looks up account by name; EXAMPLE: { name_or_address: '0x1234...' } - uses address directly; If name_or_address is empty string '', uses the default local account."
                             }
                           },
                           "check_all_founded": {
-                            "type": "boolean",
-                            "description": "Whether to check all entities are found, if true, all entities must be found (abort and throw exception if any ID not found); if false, only return found IDs"
+                            "description": "Whether to check all entities are found, if true, all entities must be found (abort and throw exception if any ID not found); if false, only return found IDs",
+                            "type": "boolean"
                           }
                         },
                         "required": [
@@ -529,200 +451,3749 @@
                       }
                     }
                   }
-                ],
-                "description": "The actual value data. Format depends on `value_type`:\n• Bool: true/false (boolean)\n• Address (CRITICAL — string 'Address' is NOT a placeholder): a hex address (e.g. '0x1234...'), a LocalMark name (e.g. 'my-service' — resolved to address at evaluation time), an AccountOrMark_Address object (e.g. {name_or_address:'my-service'}), or system shorthand ('0xaaa' = EntityLinker, '0xaab' = EntityRegistrar). The literal string 'Address' itself is INVALID — it would be treated as a non-existent LocalMark name and fail. Example: value='0x2::wow::WOW<address>' or value='my-permission'.\n• String: any string\n• U8/U16/U32/U64/U128/U256: number or numeric string (e.g. 42 or '42')\n• Vec* types: arrays of the corresponding element type\nREQUIRED when b_submission=false. OPTIONAL when b_submission=true (value is supplied at evaluation time by user submission)."
+                ]
               },
               "name": {
-                "type": "string",
                 "default": "",
-                "description": "Data name identifier. MAX 64 BCS characters (Chinese chars count as 3-4 BCS bytes each). Use short identifiers like 'order_id', 'delivery_node'. Put longer descriptions in the Guard's 'description' field, NOT here."
+                "description": "Data name identifier. MAX 64 BCS characters (Chinese chars count as 3-4 BCS bytes each). Use short identifiers like 'order_id', 'delivery_node'. Put longer descriptions in the Guard's 'description' field, NOT here.",
+                "type": "string"
               }
             },
             "required": [
               "identifier",
               "b_submission",
-              "value_type"
+              "value_type",
+              "name"
             ],
             "additionalProperties": false,
             "description": "Guard table item (INPUT/CREATION form). DO NOT include `object_type` field — it is query-output only and will be rejected here."
           }
-        }
-      ],
-      "description": "Data table of the Guard object. When using root.type='file', this field OVERRIDES table in the file."
-    },
-    "guard_rely": {
-      "anyOf": [
-        {
-          "not": {}
-        },
-        {
-          "type": "object",
-          "properties": {
-            "guards": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "description": "Account/Object name or ID. If specifying an account, use empty string '' for the default account. If it starts with '0x', it will be treated as an ID. Otherwise, it will be treated as a name (max 64 bcs characters)."
-              },
-              "description": "List of dependent Guard object IDs or names."
-            },
-            "logic_or": {
-              "type": "boolean",
-              "description": "Whether to use logical OR operator."
-            }
-          },
-          "required": [
-            "guards"
-          ],
-          "additionalProperties": false
-        }
-      ],
-      "description": "All Guard objects that the new Guard object depends on. If logic_or is true, the execution result of the new Guard object is the logical OR of the execution results of all dependent Guard objects; otherwise, it is logical AND. When using root.type='file', this field OVERRIDES rely in the file."
-    },
-    "guard_binding_hint": {
-      "anyOf": [
-        {
-          "not": {}
-        },
-        {
-          "type": "object",
-          "properties": {
-            "action": {
-              "type": "string",
-              "enum": [
-                "buy",
-                "forward",
-                "allocate",
-                "claim_reward",
-                "vote",
-                "dispute",
-                "write_repository",
-                "submit_progress",
-                "gen_passport",
-                "custom"
-              ],
-              "description": "Protected action type. Example: 'buy' for Service buy_guard, 'forward' for Machine Forward.guard."
-            },
-            "host_object": {
-              "type": "string",
-              "enum": [
-                "Service",
-                "Machine",
-                "Arbitration",
-                "Reward",
-                "Repository",
-                "Progress",
-                "Demand",
-                "Standalone"
-              ],
-              "description": "Host object type. Example: 'Service', 'Machine'."
-            },
-            "binding_field": {
-              "type": "string",
-              "enum": [
-                "buy_guard",
-                "order_allocators",
-                "Forward.guard",
-                "submission",
-                "guard",
-                "write_guard",
-                "usage_guard",
-                "voting_guard",
-                "ServiceGuard",
-                "none"
-              ],
-              "description": "Binding field. Example: 'buy_guard', 'Forward.guard'."
-            },
-            "rule_sentence": {
-              "type": "string",
-              "description": "One-sentence description of the validation rule (human-readable). Example: 'Only the author can purchase this service'."
-            },
-            "failure_conditions": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              },
-              "description": "List of conditions under which the Guard should FAIL. Example: ['Signer is not in allowlist','Order is already completed']."
-            },
-            "circular_reference": {
-              "type": "boolean",
-              "description": "Whether the Guard references the Host Object itself (circular reference pattern). true=Guard queries the Host Object it binds to."
-            }
-          },
-          "required": [
-            "action",
-            "host_object",
-            "binding_field"
-          ],
-          "additionalProperties": false,
-          "description": "Optional semantic hint for Guard capability system. Provides intent + binding context so the MCP server can derive GuardPuzzle, run risk assessment, and generate confirmation text. Strongly recommended: fill this field to enable puzzle_status, matched_scene, suggested_patterns, confirmation_text, and pending_questions in the response guard_advice."
-        }
-      ],
-      "description": "Phase 5 Guard capability hint. Provides semantic context (action + host_object + binding_field + optional rule/failure_conditions) for puzzle derivation. When provided, the response will include complete guard_advice (puzzle_status, matched_scene, suggested_patterns, confirmation_text, pending_questions). When absent, puzzle_status intent/binding dimensions are marked incomplete."
-    },
-    "env": {
-      "type": "object",
-      "properties": {
-        "account": {
-          "type": "string",
-          "description": "Account/Object name or ID. If specifying an account, use empty string '' for the default account. If it starts with '0x', it will be treated as an ID. Otherwise, it will be treated as a name (max 64 bcs characters).",
-          "default": ""
-        },
-        "permission_guard": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "List of permission guard IDs. Used to extend additional operation permissions (requires verification and configuration in the Permission object)."
-        },
-        "no_cache": {
-          "type": "boolean",
-          "description": "Whether to disable caching."
-        },
-        "network": {
-          "type": "string",
-          "enum": [
-            "localnet",
-            "testnet",
-            "mainnet"
-          ],
-          "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
-        },
-        "referrer": {
-          "$ref": "#/definitions/env/properties/account",
-          "description": "Referrer ID. If the user is using the network for the first time, the referrer ID will be recorded."
-        },
-        "confirmed": {
-          "type": "boolean",
-          "description": "Phase 2 ConfirmGate: set to true to proceed after a 'pending_confirmation' result. The operation is NOT executed until you re-call with confirmed=true after user consent."
-        },
-        "user_intent_phrases": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Phase 2 ConfirmGate: explicit user intent phrases collected from conversation context (e.g. 'use default account', 'force publish'). Used to bypass confirmation rules whose bypass_on_explicit_intent matches."
-        },
-        "project": {
-          "type": "string",
-          "description": "Project prefix to assign this object to (e.g. 'myshop'). When set: 1) the object is tagged with 'project:<prefix>' on-chain automatically via ProjectService, 2) the newly created object is auto-associated to the SQLite project for local management, evaluation, and graph tracking. The project MUST exist (create via project_operation action='create_project' first). Use project_operation to manage projects."
-        },
-        "client_schema_version": {
-          "type": "string",
-          "description": "Client-side schema version (semver, e.g. '1.0.0'). When provided, the server checks compatibility and attaches warnings if mismatched."
-        },
-        "schema_strict_mode": {
-          "type": "boolean",
-          "default": false,
-          "description": "When true, schema incompatibility returns an error instead of a warning. Default: false (warn mode)."
         },
-        "dry_run": {
-          "type": "boolean",
-          "description": "Phase 1 dry_run: when true, SIMULATE the transaction without signing or submitting. Returns effects + events showing what WOULD happen — no on-chain state is modified, no gas is charged. Use this to verify an operation will succeed before committing. Essential for the 5-step loop's Plan step. The returned digest will be 'dry_run:<timestamp>' and objectChanges will be empty (simulation only)."
-        }
-      },
-      "additionalProperties": false,
-      "description": "IMPORTANT: Execution environment includes: account for signing operations, network selection ([object Object]), additional Guard permissions, and more. Used to specify context information during the call. If account is not specified, the default account (\"\") will be used."
+        "root": {
+          "anyOf": [
+            {
+              "description": "Guard computational tree root node. MUST be an operation that returns a Bool value (pass/fail). For 'query' type, the specific query must return Bool. For 'identifier' type, the referenced table item must have value_type=Bool.",
+              "oneOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "identifier"
+                    },
+                    "identifier": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 255,
+                      "description": "Identifier (0-255) for data lookup in Guard table."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "identifier"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns the constant value stored at the specified identifier in the Guard table."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query"
+                    },
+                    "query": {
+                      "anyOf": [
+                        {
+                          "type": "integer",
+                          "minimum": -9007199254740991,
+                          "maximum": 9007199254740991
+                        },
+                        {
+                          "type": "string"
+                        }
+                      ],
+                      "description": "ID or name of the wowok object data query instruction. Can be a numeric ID (e.g., 1001) or a name string (e.g., 'permission.description'). Name matching is case-insensitive."
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        },
+                        "convert_witness": {
+                          "anyOf": [
+                            {
+                              "type": "integer",
+                              "minimum": -9007199254740991,
+                              "maximum": 9007199254740991
+                            },
+                            {
+                              "type": "string"
+                            }
+                          ],
+                          "description": "When specified, the query retrieves data from the associated (witness) object instead of the queried object itself. This enables cross-object queries within Guard validation logic. Can be a numeric ID (100-108) or a string name (case-insensitive, with or without the 'Type' prefix). String format is recommended for readability.\n\nAvailable WitnessTypes:\n- OrderProgress / TypeOrderProgress (100): Query an Order's associated Progress object. Use case: Check if order has reached a specific workflow node (e.g., 'complete') before allowing reward claims.\n- OrderMachine / TypeOrderMachine (101): Query an Order's associated Machine (workflow definition). Use case: Verify the workflow structure or check node configurations.\n- OrderService / TypeOrderService (102): Query an Order's parent Service object. Use case: Validate the service offering details or check service-level configurations.\n- ProgressMachine / TypeProgressMachine (103): Query a Progress's associated Machine. Use case: Access workflow definition from a Progress context.\n- ArbOrder / TypeArbOrder (104): Query an Arb's associated Order. Use case: In arbitration voting guards, verify order details like payment amount or service ID.\n- ArbArbitration / TypeArbArbitration (105): Query an Arb's parent Arbitration service. Use case: Access arbitration configuration or fee settings from within an Arb case.\n- ArbProgress / TypeArbProgress (106): Query an Arb's associated Progress. Use case: Check order workflow state during arbitration validation.\n- ArbMachine / TypeArbMachine (107): Query an Arb's associated Machine. Use case: Access workflow definition for dispute context analysis.\n- ArbService / TypeArbService (108): Query an Arb's associated Service. Use case: Verify service terms or compensation fund status during arbitration.\n\nExample: To validate that an order has reached the 'complete' node, query the Order with convert_witness='OrderProgress' and check the Progress's current_node field."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "The object to query from the Guard table."
+                    },
+                    "parameters": {
+                      "description": "Parameters required by the query. Optional — defaults to empty array []. Many queries (e.g. progress.current, order.service) take no parameters; for those, this field can be omitted.",
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "query",
+                    "object"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns the result of executing a data query instruction on the specified object. The return type depends on the query being executed. SPECIAL NOTE for EntityLinker/EntityRegistrar queries: Use system addresses in the Guard table -0x0000000000000000000000000000000000000000000000000000000000000aaa for EntityLinker queries, 0x0000000000000000000000000000000000000000000000000000000000000aab for EntityRegistrar queries."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_as_u256_greater_or_equal"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first >= all others, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_as_u256_lesser_or_equal"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first <= all others, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_as_u256_greater"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first > all others, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_as_u256_lesser"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first < all others, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_as_u256_equal"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first equals all others, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_equal"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 nodes of any type. Computed by comparing the first node with all subsequent nodes in both type and value. Returns true if type and value match for all, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_not"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Computed by inverting the boolean value of the child node (true -> false, false -> true)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_and"
+                    },
+                    "nodes": {
+                      "minItems": 2,
+                      "maxItems": 8,
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 boolean nodes. Computed by performing logical AND on all child node values. Returns true if ALL are true, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_or"
+                    },
+                    "nodes": {
+                      "minItems": 2,
+                      "maxItems": 8,
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 boolean nodes. Computed by performing logical OR on all child node values. Returns true if ANY is true, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_string_contains"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-sensitive."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_string_nocase_contains"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-insensitive."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "logic_string_nocase_equal"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 string nodes. Computed by comparing the first node with all subsequent nodes as strings, ignoring case. Returns true if all are equal, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_number_add"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by adding the first node value with all subsequent node values in sequence (first + second + third + ...)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_number_multiply"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by multiplying the first node value with all subsequent node values in sequence (first * second * third * ...)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_number_subtract"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by subtracting the second node value from the first node value in sequence, then continuing with each subsequent node (first - second - third - ...)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_number_divide"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by dividing the first node value by the second node value in sequence, then continuing with each subsequent node ((first / second) / third / ...). Throws exception if any divisor is zero."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_number_mod"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by taking the remainder of dividing the first node value by the second node value in sequence, then continuing with each subsequent node ((first % second) % third % ...). Throws exception if any divisor is zero."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_string_length"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by getting the length (number of UTF-8 bytes) of the child node value."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_string_nocase_contains"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-insensitive."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_string_nocase_equal"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 string nodes. Computed by comparing the first node with all subsequent nodes as strings, ignoring case. Returns true if all are equal, otherwise false."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_string_contains"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      }
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-sensitive."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_string_indexof"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from start to end, 'backward' searches from end to start."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node (needle) in the first node (haystack). Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "calc_string_nocase_indexof"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from start to end, 'backward' searches from end to start."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node (needle) in the first node (haystack), ignoring case. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_number_address"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Address. Computed by converting the child node value from number type to Address type."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_address_number"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Computed by converting the child node value from Address type to number type."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_number_string"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns String. Computed by converting the child node value from number type to string type."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_string_number"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Computed by parsing the child node value as a number. Throws exception if the string is not a valid number."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_safe_u8"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U8. Computed by converting the child node value to U8. Throws exception if value is out of U8 range (0-255)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_safe_u16"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U16. Computed by converting the child node value to U16. Throws exception if value is out of U16 range (0-65535)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_safe_u32"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U32. Computed by converting the child node value to U32. Throws exception if value is out of U32 range."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_safe_u64"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by converting the child node value to U64. Throws exception if value is out of U64 range."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_safe_u128"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U128. Computed by converting the child node value to U128. Throws exception if value is out of U128 range."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "convert_safe_u256"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U256. Computed by converting the child node value to U256."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "value_type"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U8. Computed by getting the type identifier (ValueType) of the child node value. Value type: can be specified as a string name (e.g., 'U64', 'Address', 'String') or a number (0-18). Supported types: Bool=0/'Bool', Address=1/'Address', String=2/'String', U8=3/'U8', U16=4/'U16', U32=5/'U32', U64=6/'U64', U128=7/'U128', U256=8/'U256', VecBool=9/'VecBool', VecAddress=10/'VecAddress', VecString=11/'VecString', VecU8=12/'VecU8', VecU16=13/'VecU16', VecU32=14/'VecU32', VecU64=15/'VecU64', VecU128=16/'VecU128', VecU256=17/'VecU256', VecVecU8=18/'VecVecU8'. Note: Value=19 is an INTERNAL type for wowok system use only and should NOT be used directly by users. String format is recommended for better readability."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_length"
+                    },
+                    "node": {
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "node"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by getting the length of the vector in the child node value. Child node must be one of Vec types: VecBool=9, VecAddress=10, VecString=11, VecU8=12, VecU16=13, VecU32=14, VecU64=15, VecU128=16, VecU256=17, VecVecU8=18, Value=19."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_contains_bool"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      },
+                      "description": "2 to 8 nodes required. First node must be VecBool (ValueType=9) or Value (ValueType=19), remaining nodes must be Bool (ValueType=0) or Value (ValueType=19)."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL boolean values (subsequent nodes)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_contains_address"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      },
+                      "description": "2 to 8 nodes required. First node must be VecAddress (ValueType=10) or Value (ValueType=19), remaining nodes must be Address (ValueType=1) or Value (ValueType=19)."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL address values (subsequent nodes)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_contains_string"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      },
+                      "description": "2 to 8 nodes required. First node must be VecString (ValueType=11) or Value (ValueType=19), remaining nodes must be String (ValueType=2) or Value (ValueType=19)."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL string values (subsequent nodes)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_contains_string_nocase"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      },
+                      "description": "2 to 8 nodes required. First node must be VecString (ValueType=11) or Value (ValueType=19), remaining nodes must be String (ValueType=2) or Value (ValueType=19)."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL string values (subsequent nodes), using case-insensitive comparison."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_contains_number"
+                    },
+                    "nodes": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/__schema0"
+                      },
+                      "description": "2 to 8 nodes required. First node must be VecU8 (12), VecU16 (13), VecU32 (14), VecU64 (15), VecU128 (16), VecU256 (17) or Value (ValueType=19), remaining nodes must be U8 (3), U16 (4), U32 (5), U64 (6), U128 (7), U256 (8) or Value (ValueType=19)."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodes"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL number values (subsequent nodes)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_indexof_bool"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from index 0, 'backward' searches from last index."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecBool (ValueType=9) or Value (ValueType=19) type, nodeRight must be Bool (ValueType=0) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_indexof_address"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from index 0, 'backward' searches from last index."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecAddress (ValueType=10) or Value (ValueType=19) type, nodeRight must be Address (ValueType=1) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_indexof_string"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from index 0, 'backward' searches from last index."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecString (ValueType=11) or Value (ValueType=19) type, nodeRight must be String (ValueType=2) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_indexof_string_nocase"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from index 0, 'backward' searches from last index."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node value in the vector (first node), using case-insensitive comparison. nodeLeft must be VecString (ValueType=11) or Value (ValueType=19) type, nodeRight must be String (ValueType=2) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "vec_indexof_number"
+                    },
+                    "nodeLeft": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "nodeRight": {
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "order": {
+                      "type": "string",
+                      "enum": [
+                        "forward",
+                        "backward"
+                      ],
+                      "description": "'forward' searches from index 0, 'backward' searches from last index."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "nodeLeft",
+                    "nodeRight",
+                    "order"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecU8 (12), VecU16 (13), VecU32 (14), VecU64 (15), VecU128 (16), VecU256 (17) or Value (ValueType=19) type, nodeRight must be U8 (3), U16 (4), U32 (5), U64 (6), U128 (7), U256 (8) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "context"
+                    },
+                    "context": {
+                      "type": "string",
+                      "enum": [
+                        "Signer",
+                        "Clock",
+                        "Guard"
+                      ],
+                      "description": "System context type: Signer returns transaction sender address (Address), Clock returns current on-chain timestamp (U64), Guard returns current Guard object ID (Address)."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "context"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Signer returns transaction sender address (Address), Clock returns current on-chain timestamp (U64), Guard returns current Guard object ID (Address)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_reward_record_find"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Reward object in the Guard table (must be Address type)."
+                    },
+                    "find": {
+                      "type": "string",
+                      "enum": [
+                        "first",
+                        "last"
+                      ],
+                      "description": "'first' finds the earliest matching record, 'last' finds the most recent matching record."
+                    },
+                    "recipient": {
+                      "description": "Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address.",
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false
+                    },
+                    "where": {
+                      "type": "object",
+                      "properties": {
+                        "guard": {
+                          "description": "Optional filter: Guard object address constant to match.",
+                          "type": "string"
+                        },
+                        "timeMin": {
+                          "description": "Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "timeMax": {
+                          "description": "Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "amountMin": {
+                          "description": "Optional filter: minimum reward amount (inclusive). Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "amountMax": {
+                          "description": "Optional filter: maximum reward amount (inclusive). Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "storeFromId": {
+                          "description": "Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants.",
+                          "type": "object",
+                          "properties": {
+                            "identifier": {
+                              "type": "integer",
+                              "minimum": 0,
+                              "maximum": 255,
+                              "description": "Identifier (0-255) for data lookup in Guard table."
+                            }
+                          },
+                          "required": [
+                            "identifier"
+                          ],
+                          "additionalProperties": false
+                        }
+                      },
+                      "additionalProperties": false,
+                      "description": "Filter conditions for the reward record query."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "find",
+                    "where"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Finds the index of the first or last reward record matching the specified recipient and filter conditions. Returns the record index (U64) if found. Throws error if no matching record is found (Guard validation fails). If recipient is not specified, uses the transaction signer address."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_reward_record_count"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Reward object in the Guard table (must be Address type)."
+                    },
+                    "recipient": {
+                      "description": "Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address.",
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false
+                    },
+                    "where": {
+                      "type": "object",
+                      "properties": {
+                        "guard": {
+                          "description": "Optional filter: Guard object address constant to match.",
+                          "type": "string"
+                        },
+                        "timeMin": {
+                          "description": "Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "timeMax": {
+                          "description": "Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "amountMin": {
+                          "description": "Optional filter: minimum reward amount (inclusive). Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "amountMax": {
+                          "description": "Optional filter: maximum reward amount (inclusive). Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "storeFromId": {
+                          "description": "Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants.",
+                          "type": "object",
+                          "properties": {
+                            "identifier": {
+                              "type": "integer",
+                              "minimum": 0,
+                              "maximum": 255,
+                              "description": "Identifier (0-255) for data lookup in Guard table."
+                            }
+                          },
+                          "required": [
+                            "identifier"
+                          ],
+                          "additionalProperties": false
+                        }
+                      },
+                      "additionalProperties": false,
+                      "description": "Filter conditions for the reward record count query."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "where"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Counts the number of reward records matching the specified recipient and filter conditions. If recipient is not specified, uses the transaction signer address."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_reward_record_exists"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Reward object in the Guard table (must be Address type)."
+                    },
+                    "recipient": {
+                      "description": "Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address.",
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false
+                    },
+                    "where": {
+                      "type": "object",
+                      "properties": {
+                        "guard": {
+                          "description": "Optional filter: Guard object address constant to match.",
+                          "type": "string"
+                        },
+                        "timeMin": {
+                          "description": "Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "timeMax": {
+                          "description": "Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "amountMin": {
+                          "description": "Optional filter: minimum reward amount (inclusive). Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "amountMax": {
+                          "description": "Optional filter: maximum reward amount (inclusive). Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "storeFromId": {
+                          "description": "Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants.",
+                          "type": "object",
+                          "properties": {
+                            "identifier": {
+                              "type": "integer",
+                              "minimum": 0,
+                              "maximum": 255,
+                              "description": "Identifier (0-255) for data lookup in Guard table."
+                            }
+                          },
+                          "required": [
+                            "identifier"
+                          ],
+                          "additionalProperties": false
+                        }
+                      },
+                      "additionalProperties": false,
+                      "description": "Filter conditions for the reward record existence query."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "where"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns Bool. Returns true if at least one reward record exists matching the specified recipient and filter conditions, otherwise false. If recipient is not specified, uses the transaction signer address."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_progress_history_find"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Progress object in the Guard table (must be Address type)."
+                    },
+                    "where": {
+                      "type": "object",
+                      "properties": {
+                        "node": {
+                          "description": "Optional filter: node name string to match.",
+                          "type": "string"
+                        },
+                        "nextNode": {
+                          "description": "Optional filter: next node name string to match.",
+                          "type": "string"
+                        },
+                        "timeMin": {
+                          "description": "Optional filter: minimum timestamp (inclusive) for history entry time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "timeMax": {
+                          "description": "Optional filter: maximum timestamp (inclusive) for history entry time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "indexMin": {
+                          "description": "Optional filter: minimum history index (inclusive) to search within. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "indexMax": {
+                          "description": "Optional filter: maximum history index (inclusive) to search within. Use string to represent U64 value.",
+                          "type": "string"
+                        }
+                      },
+                      "additionalProperties": false,
+                      "description": "Filter conditions for the progress history query."
+                    },
+                    "find": {
+                      "type": "string",
+                      "enum": [
+                        "first",
+                        "last"
+                      ],
+                      "description": "'first' finds the earliest matching history entry, 'last' finds the most recent matching history entry."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "where",
+                    "find"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Finds the index of the first or last history entry matching the filter conditions. Returns the history index (U64) if found. Throws error if no matching entry is found (Guard validation fails)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_progress_history_session_find"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Progress object in the Guard table (must be Address type)."
+                    },
+                    "historyIdx": {
+                      "description": "GuardNode that returns the history index (U64 type) to search within. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "where": {
+                      "type": "object",
+                      "properties": {
+                        "nextNode": {
+                          "description": "Optional filter: next node name string to match.",
+                          "type": "string"
+                        }
+                      },
+                      "additionalProperties": false,
+                      "description": "Filter conditions for the progress history session query."
+                    },
+                    "find": {
+                      "type": "string",
+                      "enum": [
+                        "first",
+                        "last"
+                      ],
+                      "description": "'first' finds the earliest matching session, 'last' finds the most recent matching session."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "historyIdx",
+                    "where",
+                    "find"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Finds the index of the first or last session within the specified history entry matching the filter conditions. Returns the session index (U64) if found. Throws error if no matching session is found (Guard validation fails)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_progress_history_session_forward_find"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Progress object in the Guard table (must be Address type)."
+                    },
+                    "historyIdx": {
+                      "description": "GuardNode that returns the history index (U64 type). Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "sessionIdx": {
+                      "description": "GuardNode that returns the session index (U64 type) within the history entry. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "where": {
+                      "type": "object",
+                      "properties": {
+                        "who": {
+                          "description": "Optional filter: operator address string to match.",
+                          "type": "string"
+                        },
+                        "operation": {
+                          "description": "Optional filter: operation name string to match.",
+                          "type": "string"
+                        },
+                        "accomplished": {
+                          "description": "Optional filter: whether the forward operation was accomplished.",
+                          "type": "boolean"
+                        },
+                        "timeMin": {
+                          "description": "Optional filter: minimum timestamp (inclusive) for forward operation time. Use string to represent U64 value.",
+                          "type": "string"
+                        },
+                        "timeMax": {
+                          "description": "Optional filter: maximum timestamp (inclusive) for forward operation time. Use string to represent U64 value.",
+                          "type": "string"
+                        }
+                      },
+                      "additionalProperties": false,
+                      "description": "Filter conditions for the progress history session forward query."
+                    },
+                    "find": {
+                      "type": "string",
+                      "enum": [
+                        "first",
+                        "last"
+                      ],
+                      "description": "'first' finds the earliest matching forward operation, 'last' finds the most recent matching forward operation."
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "historyIdx",
+                    "sessionIdx",
+                    "where",
+                    "find"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Finds the index of the first or last forward operation within the specified history session matching the filter conditions. Returns the forward index (U64) if found. Throws error if no matching forward operation is found (Guard validation fails)."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_progress_history_session_count"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Progress object in the Guard table (must be Address type)."
+                    },
+                    "historyIdx": {
+                      "description": "GuardNode that returns the history index (U64 type) to count sessions for. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "historyIdx"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Counts the number of sessions within the specified history entry."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_progress_history_session_forward_count"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Progress object in the Guard table (must be Address type)."
+                    },
+                    "historyIdx": {
+                      "description": "GuardNode that returns the history index (U64 type). Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "sessionIdx": {
+                      "description": "GuardNode that returns the session index (U64 type) within the history entry. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "historyIdx",
+                    "sessionIdx"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Counts the number of forward operations within the specified history session."
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "const": "query_progress_history_session_forward_retained_submission_count"
+                    },
+                    "object": {
+                      "type": "object",
+                      "properties": {
+                        "identifier": {
+                          "type": "integer",
+                          "minimum": 0,
+                          "maximum": 255,
+                          "description": "Identifier (0-255) for data lookup in Guard table."
+                        }
+                      },
+                      "required": [
+                        "identifier"
+                      ],
+                      "additionalProperties": false,
+                      "description": "Reference to the Progress object in the Guard table (must be Address type)."
+                    },
+                    "historyIdx": {
+                      "description": "GuardNode that returns the history index (U64 type). Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "sessionIdx": {
+                      "description": "GuardNode that returns the session index (U64 type) within the history entry. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    },
+                    "forwardIdx": {
+                      "description": "GuardNode that returns the forward operation index (U64 type) within the session. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+                      "allOf": [
+                        {
+                          "$ref": "#/definitions/__schema1"
+                        }
+                      ],
+                      "$ref": "#/definitions/__schema0"
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "object",
+                    "historyIdx",
+                    "sessionIdx",
+                    "forwardIdx"
+                  ],
+                  "additionalProperties": false,
+                  "description": "Returns U64. Counts the number of retained submissions within the specified forward operation."
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            {
+              "type": "object",
+              "properties": {
+                "type": {
+                  "type": "string",
+                  "const": "file"
+                },
+                "file_path": {
+                  "type": "string",
+                  "description": "Path to JSON or Markdown file containing Guard definition. File can define: namedNew, description, table, root, rely."
+                },
+                "format": {
+                  "default": "json",
+                  "description": "File format: 'json' or 'markdown'. Default is 'json'.",
+                  "type": "string",
+                  "enum": [
+                    "json",
+                    "markdown"
+                  ]
+                }
+              },
+              "required": [
+                "type",
+                "file_path",
+                "format"
+              ],
+              "additionalProperties": false
+            }
+          ],
+          "description": "Root definition: either a direct GuardNode (must be a logical operation returning Bool) or a file reference (type='file'). When type='file', the file can define all Guard fields (namedNew, description, table, root, rely), and schema fields override file content."
+        },
+        "rely": {
+          "description": "All Guard objects that the new Guard object depends on. If logic_or is true, the execution result of the new Guard object is the logical OR of the execution results of all dependent Guard objects; otherwise, it is logical AND. When using root.type='file', this field OVERRIDES rely in the file.",
+          "type": "object",
+          "properties": {
+            "guards": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "description": "Account/Object name or ID. If specifying an account, use empty string '' for the default account. If it starts with '0x', it will be treated as an ID. Otherwise, it will be treated as a name (max 64 bcs characters)."
+              },
+              "description": "List of dependent Guard object IDs or names."
+            },
+            "logic_or": {
+              "description": "Whether to use logical OR operator.",
+              "type": "boolean"
+            }
+          },
+          "required": [
+            "guards"
+          ],
+          "additionalProperties": false
+        },
+        "binding_hint": {
+          "description": "Phase 5 Guard capability hint. Provides semantic context (action + host_object + binding_field + optional rule/failure_conditions) for puzzle derivation. When provided, the response will include complete guard_advice (puzzle_status, matched_scene, suggested_patterns, confirmation_text, pending_questions). When absent, puzzle_status intent/binding dimensions are marked incomplete.",
+          "type": "object",
+          "properties": {
+            "action": {
+              "type": "string",
+              "enum": [
+                "buy",
+                "forward",
+                "allocate",
+                "claim_reward",
+                "vote",
+                "dispute",
+                "write_repository",
+                "submit_progress",
+                "gen_passport",
+                "custom"
+              ],
+              "description": "Protected action type. Example: 'buy' for Service buy_guard, 'forward' for Machine Forward.guard."
+            },
+            "host_object": {
+              "type": "string",
+              "enum": [
+                "Service",
+                "Machine",
+                "Arbitration",
+                "Reward",
+                "Repository",
+                "Progress",
+                "Demand",
+                "Standalone"
+              ],
+              "description": "Host object type. Example: 'Service', 'Machine'."
+            },
+            "binding_field": {
+              "type": "string",
+              "enum": [
+                "buy_guard",
+                "order_allocators",
+                "Forward.guard",
+                "submission",
+                "guard",
+                "write_guard",
+                "usage_guard",
+                "voting_guard",
+                "ServiceGuard",
+                "none"
+              ],
+              "description": "Binding field. Example: 'buy_guard', 'Forward.guard'."
+            },
+            "rule_sentence": {
+              "description": "One-sentence description of the validation rule (human-readable). Example: 'Only the author can purchase this service'.",
+              "type": "string"
+            },
+            "failure_conditions": {
+              "description": "List of conditions under which the Guard should FAIL. Example: ['Signer is not in allowlist','Order is already completed'].",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "circular_reference": {
+              "description": "Whether the Guard references the Host Object itself (circular reference pattern). true=Guard queries the Host Object it binds to.",
+              "type": "boolean"
+            }
+          },
+          "required": [
+            "action",
+            "host_object",
+            "binding_field"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "required": [
+        "root"
+      ],
+      "additionalProperties": false,
+      "description": "On-chain Guard creation. IMPORTANT: All defined data (include all submitted data) must be defined in the 'table' field. USAGE: Set 'namedNew' field with {name, tags?, onChain?} to name the new Guard (you may also use 'object' as an alias for 'namedNew' — the MCP preprocess will convert it automatically). The Guard is immutable once created. Define the validation logic in 'root' field. When root.type='file', the file can contain all Guard fields, and any fields defined in the schema will OVERRIDE the file content."
+    },
+    "env": {
+      "type": "object",
+      "properties": {
+        "account": {
+          "default": "",
+          "type": "string",
+          "description": "Account/Object name or ID. If specifying an account, use empty string '' for the default account. If it starts with '0x', it will be treated as an ID. Otherwise, it will be treated as a name (max 64 bcs characters)."
+        },
+        "permission_guard": {
+          "description": "List of permission guard IDs. Used to extend additional operation permissions (requires verification and configuration in the Permission object).",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "no_cache": {
+          "description": "Whether to disable caching.",
+          "type": "boolean"
+        },
+        "network": {
+          "type": "string",
+          "enum": [
+            "localnet",
+            "testnet",
+            "mainnet"
+          ],
+          "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
+        },
+        "referrer": {
+          "description": "Referrer ID. If the user is using the network for the first time, the referrer ID will be recorded.",
+          "type": "string"
+        },
+        "confirmed": {
+          "description": "Phase 2 ConfirmGate: set to true to proceed after a 'pending_confirmation' result. The operation is NOT executed until you re-call with confirmed=true after user consent.",
+          "type": "boolean"
+        },
+        "user_intent_phrases": {
+          "description": "Phase 2 ConfirmGate: explicit user intent phrases collected from conversation context (e.g. 'use default account', 'force publish'). Used to bypass confirmation rules whose bypass_on_explicit_intent matches.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "project": {
+          "description": "Project prefix to assign this object to (e.g. 'myshop'). When set: 1) the object is tagged with 'project:<prefix>' on-chain automatically via ProjectService, 2) the newly created object is auto-associated to the SQLite project for local management, evaluation, and graph tracking. The project MUST exist (create via project_operation action='create_project' first). Use project_operation to manage projects.",
+          "type": "string"
+        },
+        "client_schema_version": {
+          "description": "Client-side schema version (semver, e.g. '1.0.0'). When provided, the server checks compatibility and attaches warnings if mismatched.",
+          "type": "string"
+        },
+        "schema_strict_mode": {
+          "default": false,
+          "description": "When true, schema incompatibility returns an error instead of a warning. Default: false (warn mode).",
+          "type": "boolean"
+        },
+        "dry_run": {
+          "description": "Phase 1 dry_run: when true, SIMULATE the transaction without signing or submitting. Returns effects + events showing what WOULD happen — no on-chain state is modified, no gas is charged. Use this to verify an operation will succeed before committing. Essential for the 5-step loop's Plan step. The returned digest will be 'dry_run:<timestamp>' and objectChanges will be empty (simulation only).",
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "account",
+        "schema_strict_mode"
+      ],
+      "additionalProperties": false,
+      "description": "IMPORTANT: Execution environment includes: account for signing operations, network selection ([object Object]), additional Guard permissions, and more. Used to specify context information during the call. If account is not specified, the default account (\"\") will be used."
+    }
+  },
+  "required": [
+    "operation_type",
+    "data"
+  ],
+  "additionalProperties": false,
+  "definitions": {
+    "__schema0": {
+      "description": "Guard node: represents an operation instruction in Guard. Each node returns a value of a specific type, computed from its child nodes or context.",
+      "allOf": [
+        {
+          "$ref": "#/definitions/__schema1"
+        }
+      ]
+    },
+    "__schema1": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "identifier"
+            },
+            "identifier": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 255,
+              "description": "Identifier (0-255) for data lookup in Guard table."
+            }
+          },
+          "required": [
+            "type",
+            "identifier"
+          ],
+          "additionalProperties": false,
+          "description": "Returns the constant value stored at the specified identifier in the Guard table."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query"
+            },
+            "query": {
+              "anyOf": [
+                {
+                  "type": "integer",
+                  "minimum": -9007199254740991,
+                  "maximum": 9007199254740991
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "description": "ID or name of the wowok object data query instruction. Can be a numeric ID (e.g., 1001) or a name string (e.g., 'permission.description'). Name matching is case-insensitive."
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                },
+                "convert_witness": {
+                  "anyOf": [
+                    {
+                      "type": "integer",
+                      "minimum": -9007199254740991,
+                      "maximum": 9007199254740991
+                    },
+                    {
+                      "type": "string"
+                    }
+                  ],
+                  "description": "When specified, the query retrieves data from the associated (witness) object instead of the queried object itself. This enables cross-object queries within Guard validation logic. Can be a numeric ID (100-108) or a string name (case-insensitive, with or without the 'Type' prefix). String format is recommended for readability.\n\nAvailable WitnessTypes:\n- OrderProgress / TypeOrderProgress (100): Query an Order's associated Progress object. Use case: Check if order has reached a specific workflow node (e.g., 'complete') before allowing reward claims.\n- OrderMachine / TypeOrderMachine (101): Query an Order's associated Machine (workflow definition). Use case: Verify the workflow structure or check node configurations.\n- OrderService / TypeOrderService (102): Query an Order's parent Service object. Use case: Validate the service offering details or check service-level configurations.\n- ProgressMachine / TypeProgressMachine (103): Query a Progress's associated Machine. Use case: Access workflow definition from a Progress context.\n- ArbOrder / TypeArbOrder (104): Query an Arb's associated Order. Use case: In arbitration voting guards, verify order details like payment amount or service ID.\n- ArbArbitration / TypeArbArbitration (105): Query an Arb's parent Arbitration service. Use case: Access arbitration configuration or fee settings from within an Arb case.\n- ArbProgress / TypeArbProgress (106): Query an Arb's associated Progress. Use case: Check order workflow state during arbitration validation.\n- ArbMachine / TypeArbMachine (107): Query an Arb's associated Machine. Use case: Access workflow definition for dispute context analysis.\n- ArbService / TypeArbService (108): Query an Arb's associated Service. Use case: Verify service terms or compensation fund status during arbitration.\n\nExample: To validate that an order has reached the 'complete' node, query the Order with convert_witness='OrderProgress' and check the Progress's current_node field."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "The object to query from the Guard table."
+            },
+            "parameters": {
+              "description": "Parameters required by the query. Optional — defaults to empty array []. Many queries (e.g. progress.current, order.service) take no parameters; for those, this field can be omitted.",
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "query",
+            "object"
+          ],
+          "additionalProperties": false,
+          "description": "Returns the result of executing a data query instruction on the specified object. The return type depends on the query being executed. SPECIAL NOTE for EntityLinker/EntityRegistrar queries: Use system addresses in the Guard table -0x0000000000000000000000000000000000000000000000000000000000000aaa for EntityLinker queries, 0x0000000000000000000000000000000000000000000000000000000000000aab for EntityRegistrar queries."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_as_u256_greater_or_equal"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first >= all others, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_as_u256_lesser_or_equal"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first <= all others, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_as_u256_greater"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first > all others, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_as_u256_lesser"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first < all others, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_as_u256_equal"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by comparing the first node value with all subsequent node values. Returns true if first equals all others, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_equal"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 nodes of any type. Computed by comparing the first node with all subsequent nodes in both type and value. Returns true if type and value match for all, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_not"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Computed by inverting the boolean value of the child node (true -> false, false -> true)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_and"
+            },
+            "nodes": {
+              "minItems": 2,
+              "maxItems": 8,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 boolean nodes. Computed by performing logical AND on all child node values. Returns true if ALL are true, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_or"
+            },
+            "nodes": {
+              "minItems": 2,
+              "maxItems": 8,
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 boolean nodes. Computed by performing logical OR on all child node values. Returns true if ANY is true, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_string_contains"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-sensitive."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_string_nocase_contains"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-insensitive."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "logic_string_nocase_equal"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 string nodes. Computed by comparing the first node with all subsequent nodes as strings, ignoring case. Returns true if all are equal, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_number_add"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by adding the first node value with all subsequent node values in sequence (first + second + third + ...)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_number_multiply"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by multiplying the first node value with all subsequent node values in sequence (first * second * third * ...)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_number_subtract"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by subtracting the second node value from the first node value in sequence, then continuing with each subsequent node (first - second - third - ...)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_number_divide"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by dividing the first node value by the second node value in sequence, then continuing with each subsequent node ((first / second) / third / ...). Throws exception if any divisor is zero."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_number_mod"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Requires 2-8 numeric nodes (U8, U16, U32, U64, U128, U256). Computed by taking the remainder of dividing the first node value by the second node value in sequence, then continuing with each subsequent node ((first % second) % third % ...). Throws exception if any divisor is zero."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_string_length"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by getting the length (number of UTF-8 bytes) of the child node value."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_string_nocase_contains"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-insensitive."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_string_nocase_equal"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 string nodes. Computed by comparing the first node with all subsequent nodes as strings, ignoring case. Returns true if all are equal, otherwise false."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_string_contains"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              }
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Requires 2-8 string nodes. The first node is the haystack, all subsequent nodes are needles. Returns true if all needles are substrings of the haystack, otherwise false. Case-sensitive."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_string_indexof"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from start to end, 'backward' searches from end to start."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node (needle) in the first node (haystack). Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "calc_string_nocase_indexof"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from start to end, 'backward' searches from end to start."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node (needle) in the first node (haystack), ignoring case. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_number_address"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Address. Computed by converting the child node value from number type to Address type."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_address_number"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Computed by converting the child node value from Address type to number type."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_number_string"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns String. Computed by converting the child node value from number type to string type."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_string_number"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Computed by parsing the child node value as a number. Throws exception if the string is not a valid number."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_safe_u8"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U8. Computed by converting the child node value to U8. Throws exception if value is out of U8 range (0-255)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_safe_u16"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U16. Computed by converting the child node value to U16. Throws exception if value is out of U16 range (0-65535)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_safe_u32"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U32. Computed by converting the child node value to U32. Throws exception if value is out of U32 range."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_safe_u64"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by converting the child node value to U64. Throws exception if value is out of U64 range."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_safe_u128"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U128. Computed by converting the child node value to U128. Throws exception if value is out of U128 range."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "convert_safe_u256"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U256. Computed by converting the child node value to U256."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "value_type"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U8. Computed by getting the type identifier (ValueType) of the child node value. Value type: can be specified as a string name (e.g., 'U64', 'Address', 'String') or a number (0-18). Supported types: Bool=0/'Bool', Address=1/'Address', String=2/'String', U8=3/'U8', U16=4/'U16', U32=5/'U32', U64=6/'U64', U128=7/'U128', U256=8/'U256', VecBool=9/'VecBool', VecAddress=10/'VecAddress', VecString=11/'VecString', VecU8=12/'VecU8', VecU16=13/'VecU16', VecU32=14/'VecU32', VecU64=15/'VecU64', VecU128=16/'VecU128', VecU256=17/'VecU256', VecVecU8=18/'VecVecU8'. Note: Value=19 is an INTERNAL type for wowok system use only and should NOT be used directly by users. String format is recommended for better readability."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_length"
+            },
+            "node": {
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "node"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by getting the length of the vector in the child node value. Child node must be one of Vec types: VecBool=9, VecAddress=10, VecString=11, VecU8=12, VecU16=13, VecU32=14, VecU64=15, VecU128=16, VecU256=17, VecVecU8=18, Value=19."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_contains_bool"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              },
+              "description": "2 to 8 nodes required. First node must be VecBool (ValueType=9) or Value (ValueType=19), remaining nodes must be Bool (ValueType=0) or Value (ValueType=19)."
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL boolean values (subsequent nodes)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_contains_address"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              },
+              "description": "2 to 8 nodes required. First node must be VecAddress (ValueType=10) or Value (ValueType=19), remaining nodes must be Address (ValueType=1) or Value (ValueType=19)."
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL address values (subsequent nodes)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_contains_string"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              },
+              "description": "2 to 8 nodes required. First node must be VecString (ValueType=11) or Value (ValueType=19), remaining nodes must be String (ValueType=2) or Value (ValueType=19)."
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL string values (subsequent nodes)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_contains_string_nocase"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              },
+              "description": "2 to 8 nodes required. First node must be VecString (ValueType=11) or Value (ValueType=19), remaining nodes must be String (ValueType=2) or Value (ValueType=19)."
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL string values (subsequent nodes), using case-insensitive comparison."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_contains_number"
+            },
+            "nodes": {
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/__schema0"
+              },
+              "description": "2 to 8 nodes required. First node must be VecU8 (12), VecU16 (13), VecU32 (14), VecU64 (15), VecU128 (16), VecU256 (17) or Value (ValueType=19), remaining nodes must be U8 (3), U16 (4), U32 (5), U64 (6), U128 (7), U256 (8) or Value (ValueType=19)."
+            }
+          },
+          "required": [
+            "type",
+            "nodes"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Computed by checking if the vector (first node) contains ALL number values (subsequent nodes)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_indexof_bool"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from index 0, 'backward' searches from last index."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecBool (ValueType=9) or Value (ValueType=19) type, nodeRight must be Bool (ValueType=0) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_indexof_address"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from index 0, 'backward' searches from last index."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecAddress (ValueType=10) or Value (ValueType=19) type, nodeRight must be Address (ValueType=1) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_indexof_string"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from index 0, 'backward' searches from last index."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecString (ValueType=11) or Value (ValueType=19) type, nodeRight must be String (ValueType=2) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_indexof_string_nocase"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from index 0, 'backward' searches from last index."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node value in the vector (first node), using case-insensitive comparison. nodeLeft must be VecString (ValueType=11) or Value (ValueType=19) type, nodeRight must be String (ValueType=2) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "vec_indexof_number"
+            },
+            "nodeLeft": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "nodeRight": {
+              "$ref": "#/definitions/__schema0"
+            },
+            "order": {
+              "type": "string",
+              "enum": [
+                "forward",
+                "backward"
+              ],
+              "description": "'forward' searches from index 0, 'backward' searches from last index."
+            }
+          },
+          "required": [
+            "type",
+            "nodeLeft",
+            "nodeRight",
+            "order"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Computed by searching for the second node value in the vector (first node). nodeLeft must be VecU8 (12), VecU16 (13), VecU32 (14), VecU64 (15), VecU128 (16), VecU256 (17) or Value (ValueType=19) type, nodeRight must be U8 (3), U16 (4), U32 (5), U64 (6), U128 (7), U256 (8) or Value (ValueType=19) type. Returns index of first occurrence in the specified direction. If not found, returns u64::MAX (18446744073709551615)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "context"
+            },
+            "context": {
+              "type": "string",
+              "enum": [
+                "Signer",
+                "Clock",
+                "Guard"
+              ],
+              "description": "System context type: Signer returns transaction sender address (Address), Clock returns current on-chain timestamp (U64), Guard returns current Guard object ID (Address)."
+            }
+          },
+          "required": [
+            "type",
+            "context"
+          ],
+          "additionalProperties": false,
+          "description": "Signer returns transaction sender address (Address), Clock returns current on-chain timestamp (U64), Guard returns current Guard object ID (Address)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_reward_record_find"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Reward object in the Guard table (must be Address type)."
+            },
+            "find": {
+              "type": "string",
+              "enum": [
+                "first",
+                "last"
+              ],
+              "description": "'first' finds the earliest matching record, 'last' finds the most recent matching record."
+            },
+            "recipient": {
+              "description": "Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address.",
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false
+            },
+            "where": {
+              "type": "object",
+              "properties": {
+                "guard": {
+                  "description": "Optional filter: Guard object address constant to match.",
+                  "type": "string"
+                },
+                "timeMin": {
+                  "description": "Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "timeMax": {
+                  "description": "Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "amountMin": {
+                  "description": "Optional filter: minimum reward amount (inclusive). Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "amountMax": {
+                  "description": "Optional filter: maximum reward amount (inclusive). Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "storeFromId": {
+                  "description": "Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants.",
+                  "type": "object",
+                  "properties": {
+                    "identifier": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 255,
+                      "description": "Identifier (0-255) for data lookup in Guard table."
+                    }
+                  },
+                  "required": [
+                    "identifier"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "additionalProperties": false,
+              "description": "Filter conditions for the reward record query."
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "find",
+            "where"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Finds the index of the first or last reward record matching the specified recipient and filter conditions. Returns the record index (U64) if found. Throws error if no matching record is found (Guard validation fails). If recipient is not specified, uses the transaction signer address."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_reward_record_count"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Reward object in the Guard table (must be Address type)."
+            },
+            "recipient": {
+              "description": "Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address.",
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false
+            },
+            "where": {
+              "type": "object",
+              "properties": {
+                "guard": {
+                  "description": "Optional filter: Guard object address constant to match.",
+                  "type": "string"
+                },
+                "timeMin": {
+                  "description": "Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "timeMax": {
+                  "description": "Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "amountMin": {
+                  "description": "Optional filter: minimum reward amount (inclusive). Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "amountMax": {
+                  "description": "Optional filter: maximum reward amount (inclusive). Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "storeFromId": {
+                  "description": "Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants.",
+                  "type": "object",
+                  "properties": {
+                    "identifier": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 255,
+                      "description": "Identifier (0-255) for data lookup in Guard table."
+                    }
+                  },
+                  "required": [
+                    "identifier"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "additionalProperties": false,
+              "description": "Filter conditions for the reward record count query."
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "where"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Counts the number of reward records matching the specified recipient and filter conditions. If recipient is not specified, uses the transaction signer address."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_reward_record_exists"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Reward object in the Guard table (must be Address type)."
+            },
+            "recipient": {
+              "description": "Optional: Identifier reference to the recipient address in the Guard table (must be Address type). If not specified, uses the transaction signer address.",
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false
+            },
+            "where": {
+              "type": "object",
+              "properties": {
+                "guard": {
+                  "description": "Optional filter: Guard object address constant to match.",
+                  "type": "string"
+                },
+                "timeMin": {
+                  "description": "Optional filter: minimum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "timeMax": {
+                  "description": "Optional filter: maximum timestamp (inclusive) for record creation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "amountMin": {
+                  "description": "Optional filter: minimum reward amount (inclusive). Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "amountMax": {
+                  "description": "Optional filter: maximum reward amount (inclusive). Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "storeFromId": {
+                  "description": "Optional filter: identifier reference to the store_from_id address in the Guard table (must be Address type). If not specified, the store_from_id field is ignored during matching. The server resolves this identifier to the actual address from the Guard table constants.",
+                  "type": "object",
+                  "properties": {
+                    "identifier": {
+                      "type": "integer",
+                      "minimum": 0,
+                      "maximum": 255,
+                      "description": "Identifier (0-255) for data lookup in Guard table."
+                    }
+                  },
+                  "required": [
+                    "identifier"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "additionalProperties": false,
+              "description": "Filter conditions for the reward record existence query."
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "where"
+          ],
+          "additionalProperties": false,
+          "description": "Returns Bool. Returns true if at least one reward record exists matching the specified recipient and filter conditions, otherwise false. If recipient is not specified, uses the transaction signer address."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_progress_history_find"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Progress object in the Guard table (must be Address type)."
+            },
+            "where": {
+              "type": "object",
+              "properties": {
+                "node": {
+                  "description": "Optional filter: node name string to match.",
+                  "type": "string"
+                },
+                "nextNode": {
+                  "description": "Optional filter: next node name string to match.",
+                  "type": "string"
+                },
+                "timeMin": {
+                  "description": "Optional filter: minimum timestamp (inclusive) for history entry time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "timeMax": {
+                  "description": "Optional filter: maximum timestamp (inclusive) for history entry time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "indexMin": {
+                  "description": "Optional filter: minimum history index (inclusive) to search within. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "indexMax": {
+                  "description": "Optional filter: maximum history index (inclusive) to search within. Use string to represent U64 value.",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "description": "Filter conditions for the progress history query."
+            },
+            "find": {
+              "type": "string",
+              "enum": [
+                "first",
+                "last"
+              ],
+              "description": "'first' finds the earliest matching history entry, 'last' finds the most recent matching history entry."
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "where",
+            "find"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Finds the index of the first or last history entry matching the filter conditions. Returns the history index (U64) if found. Throws error if no matching entry is found (Guard validation fails)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_progress_history_session_find"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Progress object in the Guard table (must be Address type)."
+            },
+            "historyIdx": {
+              "description": "GuardNode that returns the history index (U64 type) to search within. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            "where": {
+              "type": "object",
+              "properties": {
+                "nextNode": {
+                  "description": "Optional filter: next node name string to match.",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "description": "Filter conditions for the progress history session query."
+            },
+            "find": {
+              "type": "string",
+              "enum": [
+                "first",
+                "last"
+              ],
+              "description": "'first' finds the earliest matching session, 'last' finds the most recent matching session."
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "historyIdx",
+            "where",
+            "find"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Finds the index of the first or last session within the specified history entry matching the filter conditions. Returns the session index (U64) if found. Throws error if no matching session is found (Guard validation fails)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_progress_history_session_forward_find"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Progress object in the Guard table (must be Address type)."
+            },
+            "historyIdx": {
+              "description": "GuardNode that returns the history index (U64 type). Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            "sessionIdx": {
+              "description": "GuardNode that returns the session index (U64 type) within the history entry. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            "where": {
+              "type": "object",
+              "properties": {
+                "who": {
+                  "description": "Optional filter: operator address string to match.",
+                  "type": "string"
+                },
+                "operation": {
+                  "description": "Optional filter: operation name string to match.",
+                  "type": "string"
+                },
+                "accomplished": {
+                  "description": "Optional filter: whether the forward operation was accomplished.",
+                  "type": "boolean"
+                },
+                "timeMin": {
+                  "description": "Optional filter: minimum timestamp (inclusive) for forward operation time. Use string to represent U64 value.",
+                  "type": "string"
+                },
+                "timeMax": {
+                  "description": "Optional filter: maximum timestamp (inclusive) for forward operation time. Use string to represent U64 value.",
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false,
+              "description": "Filter conditions for the progress history session forward query."
+            },
+            "find": {
+              "type": "string",
+              "enum": [
+                "first",
+                "last"
+              ],
+              "description": "'first' finds the earliest matching forward operation, 'last' finds the most recent matching forward operation."
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "historyIdx",
+            "sessionIdx",
+            "where",
+            "find"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Finds the index of the first or last forward operation within the specified history session matching the filter conditions. Returns the forward index (U64) if found. Throws error if no matching forward operation is found (Guard validation fails)."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_progress_history_session_count"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Progress object in the Guard table (must be Address type)."
+            },
+            "historyIdx": {
+              "description": "GuardNode that returns the history index (U64 type) to count sessions for. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "historyIdx"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Counts the number of sessions within the specified history entry."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_progress_history_session_forward_count"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Progress object in the Guard table (must be Address type)."
+            },
+            "historyIdx": {
+              "description": "GuardNode that returns the history index (U64 type). Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            "sessionIdx": {
+              "description": "GuardNode that returns the session index (U64 type) within the history entry. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "historyIdx",
+            "sessionIdx"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Counts the number of forward operations within the specified history session."
+        },
+        {
+          "type": "object",
+          "properties": {
+            "type": {
+              "type": "string",
+              "const": "query_progress_history_session_forward_retained_submission_count"
+            },
+            "object": {
+              "type": "object",
+              "properties": {
+                "identifier": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 255,
+                  "description": "Identifier (0-255) for data lookup in Guard table."
+                }
+              },
+              "required": [
+                "identifier"
+              ],
+              "additionalProperties": false,
+              "description": "Reference to the Progress object in the Guard table (must be Address type)."
+            },
+            "historyIdx": {
+              "description": "GuardNode that returns the history index (U64 type). Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            "sessionIdx": {
+              "description": "GuardNode that returns the session index (U64 type) within the history entry. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            },
+            "forwardIdx": {
+              "description": "GuardNode that returns the forward operation index (U64 type) within the session. Typically an 'identifier' node referencing a U64 value from the Guard table.",
+              "allOf": [
+                {
+                  "$ref": "#/definitions/__schema1"
+                }
+              ],
+              "$ref": "#/definitions/__schema0"
+            }
+          },
+          "required": [
+            "type",
+            "object",
+            "historyIdx",
+            "sessionIdx",
+            "forwardIdx"
+          ],
+          "additionalProperties": false,
+          "description": "Returns U64. Counts the number of retained submissions within the specified forward operation."
+        }
+      ]
     }
   }
 }