@wowok/agent-mcp 2.4.1 → 2.4.3

package/dist/knowledge/guard-ledger.js

@@ -13,6 +13,7 @@ export const GUARD_SCENES = [
             "The name of b_submission=true entries must be a natural-language description (the contract the customer sees)",
             "If the Guard references the Service itself, use the circular reference pattern (CREATE Service → CREATE Guard → MODIFY Service)",
             "buy_guard can still be modified after Service is published (via MODIFY Service)",
+            "Reentrancy: LOW — Each purchase creates a fresh Order; no existing Order state is modified. Default: no reentrancy risk. IF business intent is 'limit one purchase per user' (limited-edition goods, whitelist single-buy), an anti-reentrancy check is REQUIRED but no direct GUARDQUERY primitive exists for per-user purchase history — use a Repository to record prior purchases and add `repository.data has` (query 1166) + `logic_not` to root, or revoke EntityRegistrar membership after first buy",
         ],
         common_patterns: [
             "Identity check: context(Signer) + logic_equal (single address) / vec_contains_address (whitelist)",
@@ -39,12 +40,18 @@ export const GUARD_SCENES = [
             "Guard usually queries Order/Progress state to determine allocation conditions",
             "Common queries: order.amount, progress.current_node, order.completed, etc.",
             "GuardIdentifier can be used for dynamic amounts (extract u64 value from table as allocation ratio)",
+            "Guard+sharing coupling: Guard determines IF allocation happens; sharing.who determines WHERE funds go. If sharing.who=Signer, the caller receives funds — the Guard MUST bind Signer (context(Signer)==authorized) to prevent theft. PREFERRED: use sharing.who=Entity (Treasury or fixed address) so funds always go to the legitimate recipient regardless of caller.",
+            "allocators require unique guard addresses: no two allocators may reference the same Guard object (create separate Guard objects with identical root/table but different descriptions if needed).",
+            "First-match-wins: only the first allocator whose Guard passes executes; subsequent allocators are skipped. Multiple allocators represent alternative strategies, not a simultaneous split.",
+            "If sharing.who=Entity references a Treasury object, verify the Treasury's permission is consistent with the Service's permission (different permissions = different permission organizations = minor risk).",
+            "Reentrancy: LOW — Protocol-level protection: order::on_allocation (order.move L116-119) asserts `allocation` field is None (E_ALLOCATION_ALREADY_SPECIFIED), enforcing ONE Allocation object per Order, ever. After alloc() executes, typical Rate-mode allocators (sum=10000, validated at allocation.move L162-163) and any Surplus-mode allocator drain balance to 0 via balance::withdraw_all (L254), making a second alloc() fail at `assert!(balance >= threshold)` (L193). EDGE CASE: Amount-mode-only allocators (no Surplus, total < full balance) leave remainder; a second alloc() could extract more — mitigated by preferring Rate/Surplus modes. External deposit via receive() (L291) is possible but irrational (attacker funds the Allocation they attack). Optional anti-reentrancy primitive: `order.allocation some` (query 1568) + logic_not",
         ],
         common_patterns: [
             "Node state check: query(Progress.current_node) + logic_equal('Completed')",
             "Amount threshold: query(Order.amount) + logic_as_u256_greater_or_equal(threshold)",
             "Multi-condition combination: logic_and (node state + amount + time)",
             "GuardIdentifier dynamic ratio: table[u64] extracts allocation ratio",
+            "Treasury+personal 2-allocator pattern: 2 Guard objects (identical root/table, different descriptions) + 2 allocators (sharing.who=Entity Treasury / Entity personal) — 2 alternative merchant collection approaches; first-match-wins means only the first executes.",
         ],
         mutable_after_publish: false,
         r_rounds_focus: ["R1", "R2", "R3", "R5", "R6", "R7"],
@@ -64,6 +71,7 @@ export const GUARD_SCENES = [
             "retained_submission indices must correspond to the Guard table",
             "Common queries: progress.current_node, progress.session_forward, order.service, etc.",
             "Time lock: context(Clock) + calc_number_add(progress.entry_time, duration) tested with 1000ms",
+            "Reentrancy: ALLOWED — By design, Forward moves progress.current_node to next_node (progress.move L443), naturally invalidating the Guard at the old node. Re-submission at the SAME node (before forward completes) is intentional: users may fix prior submission data or accumulate session weight toward threshold. No anti-reentrancy primitive needed. Optional observability queries: `progress.session_forward` (1262), `progress.history` (1273), `query_progress_history_find` (1274)",
         ],
         common_patterns: [
             "Identity check: context(Signer) + logic_equal (only specific parties can advance)",
@@ -88,6 +96,7 @@ export const GUARD_SCENES = [
             "Works in concert with Forward.guard: Forward.guard validates eligibility, submission guard validates data",
             "retained_submission stores submission data in Progress session for audit",
             "Common queries: progress.session_forward, progress.session_weight, etc.",
+            "Reentrancy: ALLOWED — Multiple submissions accumulate session weight toward threshold by design (progress.move session_accomplish_imp). Re-submission is the intended mechanism for reaching threshold; no anti-reentrancy primitive needed",
         ],
         common_patterns: [
             "Signature validation: identifier(signature_submission) + logic_equal(expected)",
@@ -110,6 +119,7 @@ export const GUARD_SCENES = [
             "Common query_reward_record_count prevents duplicate claims (one-time claim)",
             "Guard usually queries history records + time conditions + identity validation",
             "If the Reward references a Service, use the circular reference pattern",
+            "Reentrancy: CRITICAL — Guard pass distributes reward funds to the Claimant AND creates a reward_record, but the Guard conditions (identity, time, node state) do NOT naturally invalidate after a claim. Without an explicit anti-reentrancy primitive, the same Claimant can repeatedly pass the Guard and DRAIN THE ENTIRE POOL. This is the most severe reentrancy scene. REQUIRED anti-reentrancy primitive (any one): `reward.record has` (query 1613, Bool) + `logic_not`; OR `reward.record count` (query 1612, U64) + `logic_equal(0)`; OR `reward.record.find_first` (query 1626, U64) + `logic_not`/`logic_equal(0)`. Reference template: MyShop_Advanced Guard 7 condition 4 — `logic_not(query_reward_record_exists(where.storeFromId=order_id))`",
         ],
         common_patterns: [
             "One-time claim: query_reward_record_count(recipient) + logic_equal(0)",
@@ -134,6 +144,7 @@ export const GUARD_SCENES = [
             "The table entry referenced by data_from_submission must match the Repository's value_type",
             "Type mismatch leads to write failure or data corruption",
             "Commonly used for oracle data writes, third-party credential attestation, etc.",
+            "Reentrancy: LOW — Default writes are idempotent (same ID overwrites, different ID appends); no fund flow. IF business intent is 'one write per ID' (e.g. voting, immutable credential, single-attestation), an anti-reentrancy check is needed. Optional primitive: `repository.data has` (query 1166, Bool) + `logic_not`",
         ],
         common_patterns: [
             "Authorized writer: context(Signer) + vec_contains_address(authorized_writers)",
@@ -157,6 +168,7 @@ export const GUARD_SCENES = [
             "The customer must first generate a Passport (gen_passport passes usage_guard)",
             "Common queries: order.completed, order.service, entity.has, etc.",
             "Guard validates customer identity + order status + dispute eligibility",
+            "Reentrancy: HIGH — Guard pass creates a new Arb case. Without anti-reentrancy, a customer can create multiple Arb cases for the SAME Order (up to MAX_DISPUTE_COUNT=10 per order.move L96), harassing the counterparty and inflating arbitration system load. Not direct fund loss, but severe system abuse. Note: order::dispute (order.move L93-99) deduplicates by Arb address but does NOT prevent multiple distinct Arbs for the same Order. REQUIRED anti-reentrancy primitive (any one): `order.dispute has` (query 1565, Bool, per-Arb check) + `logic_not`; OR `order.dispute count` (query 1564, U64) + `logic_equal(0)` (strict: block any prior dispute) or `logic_as_u256_less_or_equal(N)` (lenient: allow up to N disputes)",
         ],
         common_patterns: [
             "Order status validation: query(Order.status) + logic_equal('completed')",
@@ -182,6 +194,7 @@ export const GUARD_SCENES = [
             "b_submission must be true (weight is submitted at runtime by the voter)",
             "Multiple voting_guards can be configured, each corresponding to a different voter group",
             "When Arbitration bPaused=true, voting is blocked",
+            "Reentrancy: CRITICAL — Guard pass counts the vote with the extracted weight. Without anti-reentrancy, the same voter can vote MULTIPLE times, multiplying their weight and skewing the arbitration result (which directly determines fund ownership via compensation). The voter's eligibility (identity, reputation) does NOT naturally invalidate after voting. REQUIRED anti-reentrancy primitive (any one): `arb.voted has` (query 1404, Bool, per-voter) + `logic_not`; OR `arb.voted.agree has` (query 1406, Bool, per-voter-per-proposition) + `logic_not`; OR `arb.voted.agree count` (query 1405, U64, per-voter) + `logic_equal(0)`. Note: `arb.voted_count` (1403) is total voter count (NOT per-voter) and does NOT serve as an anti-reentrancy primitive for individual voters",
         ],
         common_patterns: [
             "Reputation score weight: query(EntityRegistrar.records[reputation]) + GuardIdentifier(u64)",
@@ -208,6 +221,7 @@ export const GUARD_SCENES = [
             "Guard can be created standalone (not bound to a specific Host Object)",
             "Guard can be depended on by other Guards via rely (requires rep=true)",
             "The Passport generated by gen_passport can be used as submission data for subsequent operations",
+            "Reentrancy: LOW — Each gen_passport call generates an independent Passport (one Passport per operation). Multiple Passports for the same user are usually valid (each serves a different subsequent operation). IF business intent is 'one active Passport per user', an anti-reentrancy check is needed but no direct GUARDQUERY primitive exists — use off-chain tracking or a Repository to record issued Passport IDs",
         ],
         common_patterns: [
             "Identity validation: context(Signer) + logic_equal (single address/whitelist)",

package/dist/knowledge/guard-lint.d.ts

@@ -34,6 +34,7 @@ export interface GuardJsonInput {
         host_object?: string;
         binding_field?: string;
         action?: string;
+        sharing_recipients?: ("Signer" | "Entity" | "GuardIdentifier")[];
     };
 }
 export interface AutoFixAction {

package/dist/knowledge/guard-lint.js

@@ -81,10 +81,15 @@ async function checkSdkSyntax(json) {
 function checkSemanticErrors(json) {
     const diagnostics = [];
     const { table, root, binding_hint } = json;
+    const scene = binding_hint ? findScene(binding_hint.host_object ?? "", binding_hint.binding_field ?? "") : undefined;
     const submissionEntries = getSubmissionEntries(table);
     if (submissionEntries.length > 0 && root && !hasSignerContext(root)) {
         const hasAddressSubmission = submissionEntries.some((e) => e.value_type === "Address");
-        if (hasAddressSubmission) {
+        const isAllocatorsEntitySharing = scene?.id === "service_order_allocators_guard" &&
+            binding_hint?.sharing_recipients !== undefined &&
+            binding_hint.sharing_recipients.length > 0 &&
+            !binding_hint.sharing_recipients.includes("Signer");
+        if (hasAddressSubmission && !isAllocatorsEntitySharing) {
             const indices = submissionEntries
                 .filter((e) => e.value_type === "Address")
                 .map((e) => table.indexOf(e));
@@ -101,7 +106,6 @@ function checkSemanticErrors(json) {
             });
         }
     }
-    const scene = binding_hint ? findScene(binding_hint.host_object ?? "", binding_hint.binding_field ?? "") : undefined;
     if (scene?.id === "arbitration_voting_guard") {
         const hasWeightSubmission = submissionEntries.some((e) => ["U8", "U16", "U32", "U64", "U128", "U256"].includes(e.value_type ?? ""));
         if (hasWeightSubmission) {
@@ -238,6 +242,22 @@ function checkSyntaxHints(json) {
             });
         }
     }
+    for (let i = 0; i < table.length; i++) {
+        const entry = table[i];
+        if (entry.b_submission === true && entry.value !== undefined && entry.value !== null) {
+            diagnostics.push({
+                code: "SH-11",
+                message: `table[${i}] has a redundant value field on b_submission=true entry (the verifier supplies the value at runtime; this value is ignored by BCS encoding and wastes gas)`,
+                severity: "warning",
+                source: "lint",
+                location: { path: `/table/${i}/value` },
+                fix: {
+                    description: "Remove the value field — it is ignored for b_submission=true entries",
+                    auto_fixable: true,
+                },
+            });
+        }
+    }
     return diagnostics;
 }
 function checkSuggestions(json) {
@@ -324,6 +344,46 @@ function checkSuggestions(json) {
             });
         }
     }
+    if (root) {
+        const rootStr = rootToString(root);
+        const hasProofSigner = rootStr.includes("proof.signer");
+        const hasProofTime = rootStr.includes("proof.time");
+        const hasStringLength = rootStr.includes("calc_string_length");
+        const hasStringSubmission = submissionEntries.some((e) => e.value_type === "String");
+        if (hasProofSigner && hasProofTime) {
+            diagnostics.push({
+                code: "SG-04",
+                message: "Strict-mode privacy-delivery guard detected (proof.signer + proof.time). " +
+                    "Recommended three conditions: Signer==proof.signer (submitter accountability), " +
+                    "proof.time>order.time (freshness), order.service==service (project binding). " +
+                    "No content verification — only submission responsibility ('whoever benefits bears the burden of proof').",
+                severity: "info",
+                source: "lint",
+                location: { path: "/root" },
+                fix: {
+                    description: "Ensure all three conditions are present (logic_and). Refer to template tpl_forward_privacy_delivery_proof. " +
+                        "Query IDs: proof.signer=1958, proof.time=1960, order.time=1574, order.service=1563.",
+                    auto_fixable: false,
+                },
+            });
+        }
+        else if (hasStringLength && hasStringSubmission) {
+            diagnostics.push({
+                code: "SG-04",
+                message: "Broad-mode privacy-delivery guard detected (String submission + length check, e.g. Merkle Root length == 66). " +
+                    "This trusts the submitter's honesty; the counterparty can dispute by checking their own Messenger conversation. " +
+                    "Suitable as an arbitration basis, not a fund-flow gate.",
+                severity: "info",
+                source: "lint",
+                location: { path: "/root" },
+                fix: {
+                    description: "For stronger assurance, consider strict mode: submit a Proof object address (from messenger.submitChainProof) + " +
+                        "Order address, then verify proof.signer/proof.time/order.service. See template tpl_forward_privacy_delivery_proof.",
+                    auto_fixable: false,
+                },
+            });
+        }
+    }
     return diagnostics;
 }
 export function autoFixGuard(json) {
@@ -433,6 +493,20 @@ export function autoFixGuard(json) {
             fixed.rely.guards = unique;
         }
     }
+    for (let i = 0; i < fixed.table.length; i++) {
+        const entry = fixed.table[i];
+        if (entry.b_submission === true && entry.value !== undefined && entry.value !== null) {
+            const before = JSON.stringify(entry.value);
+            delete entry.value;
+            actions.push({
+                diagnostic_code: "SH-11",
+                description: `table[${i}] remove redundant value on b_submission=true entry`,
+                before,
+                after: "(removed)",
+                path: `/table/${i}/value`,
+            });
+        }
+    }
     return { fixed, actions };
 }
 export async function lintGuard(json, options) {
@@ -467,7 +541,13 @@ export async function lintGuard(json, options) {
             name: e.name,
             object_type: e.object_type,
         }));
-        risk_assessment = assessGuardRisks({ table: mappedTable, root, rely, scene });
+        risk_assessment = assessGuardRisks({
+            table: mappedTable,
+            root,
+            rely,
+            scene,
+            sharing_recipients: binding_hint?.sharing_recipients,
+        });
         for (const r of risk_assessment.risks) {
             const severity = r.level === "critical" || r.level === "high" ? "error" :
                 r.level === "medium" ? "warning" :

package/dist/knowledge/guard-migration.d.ts

@@ -0,0 +1,48 @@
+export type GuardNodeType = 'logic_or' | 'logic_and' | 'logic_not' | 'logic_equal' | 'logic_string_nocase_equal' | 'logic_as_u256_equal' | 'logic_string_contains' | 'logic_string_nocase_contains' | 'logic_as_u256_greater' | 'logic_as_u256_lesser' | 'logic_as_u256_greater_or_equal' | 'logic_as_u256_lesser_or_equal' | 'vec_contains_string' | 'vec_contains_string_nocase' | 'vec_contains_address' | 'vec_contains_number' | 'vec_contains_bool' | 'identifier' | 'query' | 'context' | 'calc_number_add' | 'calc_number_subtract' | 'calc_number_multiply' | 'calc_number_divide' | 'calc_number_mod' | string;
+export interface GuardNode {
+    type: GuardNodeType;
+    nodes?: GuardNode[];
+    node?: GuardNode;
+    identifier?: number;
+    query?: string | number;
+    context?: string;
+    object?: {
+        identifier?: number;
+        convert_witness?: string | number;
+    };
+    parameters?: unknown[];
+}
+export interface GuardTableEntry {
+    identifier: number;
+    b_submission?: boolean;
+    value_type?: string | number;
+    value?: unknown;
+    name?: string;
+}
+export type VecContainsTarget = 'vec_contains_string' | 'vec_contains_string_nocase' | 'vec_contains_address' | 'vec_contains_number' | 'vec_contains_bool';
+export type VecValueType = 'VecString' | 'VecAddress' | 'VecU64' | 'VecU128' | 'VecU256' | 'VecU8' | 'VecU16' | 'VecU32' | 'VecBool';
+export interface ConversionResult {
+    convertible: boolean;
+    targetOperator?: VecContainsTarget;
+    vectorValueType?: VecValueType;
+    sharedNode?: GuardNode;
+    constants?: Array<{
+        identifier: number;
+        value: unknown;
+        value_type: string;
+    }>;
+    reasons?: string[];
+}
+export declare function analyzeLogicOrConversion(orNode: GuardNode, table: GuardTableEntry[]): ConversionResult;
+export interface ShorthandResult {
+    newRoot: GuardNode;
+    removeIdentifiers: number[];
+    addEntry: {
+        identifier: number;
+        b_submission: false;
+        value_type: VecValueType;
+        value: unknown[];
+        name: string;
+    };
+}
+export declare function buildShorthand(orNode: GuardNode, result: ConversionResult, newIdentifier: number): ShorthandResult | null;

package/dist/knowledge/guard-migration.js

@@ -0,0 +1,228 @@
+const EQUAL_OPERATORS = new Set([
+    'logic_equal',
+    'logic_string_nocase_equal',
+    'logic_as_u256_equal',
+]);
+function mapOperatorToTarget(operator, valueType) {
+    if (valueType === 'String' || valueType === 2) {
+        if (operator === 'logic_string_nocase_equal') {
+            return { target: 'vec_contains_string_nocase', vecType: 'VecString' };
+        }
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_string', vecType: 'VecString' };
+        }
+        return null;
+    }
+    if (valueType === 'Address' || valueType === 1) {
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_address', vecType: 'VecAddress' };
+        }
+        return null;
+    }
+    if (valueType === 'Bool' || valueType === 0) {
+        if (operator === 'logic_equal') {
+            return { target: 'vec_contains_bool', vecType: 'VecBool' };
+        }
+        return null;
+    }
+    const numericTypes = new Set([
+        'U8', 'U16', 'U32', 'U64', 'U128', 'U256',
+        3, 4, 5, 6, 7, 8,
+    ]);
+    if (numericTypes.has(valueType)) {
+        if (operator === 'logic_equal' || operator === 'logic_as_u256_equal') {
+            return { target: 'vec_contains_number', vecType: 'VecU256' };
+        }
+        return null;
+    }
+    return null;
+}
+export function analyzeLogicOrConversion(orNode, table) {
+    const reasons = [];
+    if (orNode.type !== 'logic_or') {
+        return {
+            convertible: false,
+            reasons: [`Node type is '${orNode.type}', not 'logic_or'. Only logic_or nodes are candidates.`],
+        };
+    }
+    const children = orNode.nodes ?? [];
+    if (children.length < 2) {
+        return {
+            convertible: false,
+            reasons: [`logic_or has ${children.length} children; need at least 2 to convert.`],
+        };
+    }
+    if (children.length > 7) {
+        return {
+            convertible: false,
+            reasons: [
+                `logic_or has ${children.length} children; vec_contains_* supports at most 7 needles (1 haystack + 7 needles = 8 node limit). Keep the logic_or.`,
+            ],
+        };
+    }
+    const childOperators = new Set();
+    for (const child of children) {
+        if (!EQUAL_OPERATORS.has(child.type)) {
+            if (child.type === 'logic_string_contains' || child.type === 'logic_string_nocase_contains') {
+                reasons.push(`Child uses '${child.type}' (substring match). vec_contains_* is whole-element membership, NOT substring. Cannot convert.`);
+            }
+            else if (child.type?.startsWith('logic_as_u256_greater') || child.type?.startsWith('logic_as_u256_lesser')) {
+                reasons.push(`Child uses '${child.type}' (ordering comparison). vec_contains_* is membership, not ordering. Cannot convert.`);
+            }
+            else if (child.type === 'logic_and' || child.type === 'logic_or' || child.type === 'logic_not') {
+                reasons.push(`Child is a nested logic node ('${child.type}'). Only leaf equal-style comparisons are convertible.`);
+            }
+            else {
+                reasons.push(`Child uses '${child.type}' which is not an equal-style operator (logic_equal / logic_string_nocase_equal / logic_as_u256_equal).`);
+            }
+            return { convertible: false, reasons };
+        }
+        childOperators.add(child.type);
+    }
+    if (childOperators.size > 1) {
+        const opList = Array.from(childOperators).join(', ');
+        return {
+            convertible: false,
+            reasons: [
+                `Children use mixed operators: [${opList}]. Mixing case-sensitive (logic_equal) and case-insensitive (logic_string_nocase_equal) comparisons would change semantics. Keep the logic_or.`,
+            ],
+        };
+    }
+    const sharedOperator = children[0].type;
+    for (let i = 0; i < children.length; i++) {
+        const childNodes = children[i].nodes ?? [];
+        if (childNodes.length !== 2) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} ('${sharedOperator}') has ${childNodes.length} sub-nodes; expected exactly 2 (one constant side + one shared query side).`,
+                ],
+            };
+        }
+    }
+    const constants = [];
+    let sharedNode = null;
+    let sharedNodeSerial = null;
+    for (let i = 0; i < children.length; i++) {
+        const childNodes = children[i].nodes;
+        const left = childNodes[0];
+        const right = childNodes[1];
+        const leftIsConstId = left.type === 'identifier' && typeof left.identifier === 'number';
+        const rightIsConstId = right.type === 'identifier' && typeof right.identifier === 'number';
+        if (!leftIsConstId && !rightIsConstId) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} has no constant identifier side (both sub-nodes are non-identifier). Conversion requires one side to be a constant table entry.`,
+                ],
+            };
+        }
+        if (leftIsConstId && rightIsConstId) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} has two identifier sides. Conversion requires one side to be a non-constant (query/context/calc) node shared across all children.`,
+                ],
+            };
+        }
+        const constIdNode = leftIsConstId ? left : right;
+        const nonConstNode = leftIsConstId ? right : left;
+        const tableEntry = table.find((e) => e.identifier === constIdNode.identifier);
+        if (!tableEntry) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] which is not in the table.`,
+                ],
+            };
+        }
+        if (tableEntry.b_submission !== false) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] with b_submission=${tableEntry.b_submission}. Conversion requires compile-time constants (b_submission=false).`,
+                ],
+            };
+        }
+        if (tableEntry.value === undefined || tableEntry.value === null) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i} references identifier[${constIdNode.identifier}] which has no 'value' field. Conversion requires explicit constant values.`,
+                ],
+            };
+        }
+        const nonConstSerial = JSON.stringify(nonConstNode);
+        if (sharedNodeSerial === null) {
+            sharedNodeSerial = nonConstSerial;
+            sharedNode = nonConstNode;
+        }
+        else if (sharedNodeSerial !== nonConstSerial) {
+            return {
+                convertible: false,
+                reasons: [
+                    `Child ${i}'s non-constant side differs from child 0's. All children must share the SAME non-constant node (same query, same convert_witness, same parameters). Keep the logic_or.`,
+                ],
+            };
+        }
+        constants.push({
+            identifier: constIdNode.identifier,
+            value: tableEntry.value,
+            value_type: String(tableEntry.value_type ?? ''),
+        });
+    }
+    const valueTypes = new Set(constants.map((c) => c.value_type));
+    if (valueTypes.size > 1) {
+        return {
+            convertible: false,
+            reasons: [
+                `Constants have mixed value_types: [${Array.from(valueTypes).join(', ')}]. All constants must share the same type to form a single VecXxx.`,
+            ],
+        };
+    }
+    const sharedValueType = constants[0].value_type;
+    const mapping = mapOperatorToTarget(sharedOperator, sharedValueType);
+    if (!mapping) {
+        return {
+            convertible: false,
+            reasons: [
+                `No vec_contains_* variant maps to operator='${sharedOperator}' with value_type='${sharedValueType}'. ` +
+                    `Mappable combinations: (logic_string_nocase_equal, String)→vec_contains_string_nocase; ` +
+                    `(logic_equal, String)→vec_contains_string; (logic_equal, Address)→vec_contains_address; ` +
+                    `(logic_equal, Bool)→vec_contains_bool; (logic_equal|logic_as_u256_equal, numeric)→vec_contains_number.`,
+            ],
+        };
+    }
+    return {
+        convertible: true,
+        targetOperator: mapping.target,
+        vectorValueType: mapping.vecType,
+        sharedNode: sharedNode ?? undefined,
+        constants,
+    };
+}
+export function buildShorthand(orNode, result, newIdentifier) {
+    if (!result.convertible || !result.targetOperator || !result.vectorValueType || !result.sharedNode || !result.constants) {
+        return null;
+    }
+    const values = result.constants.map((c) => c.value);
+    const removeIdentifiers = result.constants.map((c) => c.identifier);
+    const newRoot = {
+        type: result.targetOperator,
+        nodes: [
+            { type: 'identifier', identifier: newIdentifier },
+            result.sharedNode,
+        ],
+    };
+    return {
+        newRoot,
+        removeIdentifiers,
+        addEntry: {
+            identifier: newIdentifier,
+            b_submission: false,
+            value_type: result.vectorValueType,
+            value: values,
+            name: 'converted_constants',
+        },
+    };
+}

package/dist/knowledge/guard-risk.d.ts

@@ -46,6 +46,7 @@ export interface RiskCheckContext {
     };
     scene?: GuardScene;
     operation_type?: string;
+    sharing_recipients?: ("Signer" | "Entity" | "GuardIdentifier")[];
 }
 export declare function assessGuardRisks(params: {
     table: RiskCheckContext["table"];
@@ -53,6 +54,7 @@ export declare function assessGuardRisks(params: {
     rely?: RiskCheckContext["rely"];
     scene?: GuardScene;
     operation_type?: string;
+    sharing_recipients?: RiskCheckContext["sharing_recipients"];
 }): GuardRiskAssessment;
 export declare function assessGuardRisksForOperation(operation_type: string, data: any): GuardRiskAssessment | null;
 export declare function getRiskSummary(assessment: GuardRiskAssessment): {