@wowok/agent-mcp 2.4.3 → 2.5.1

package/dist/knowledge/arbitration-context.js

@@ -0,0 +1,505 @@
+import { MAX_VOTING_GUARD_COUNT, } from "@wowok/wowok";
+import { ARBITRATION_SCENES, DUAL_GUARD_MATRIX, ARB_STATUS_CODE, ARB_TERMINAL_STATUSES, findSceneByPermissionIndex, inferSceneFromIntent, getScenesByCategory, getDualGuardMatrixEntry, isValidArbStatusTransition, isTerminalArbStatus, getActiveArbitrationPermissions, getAllArbitrationPermissions, } from "./arbitration-ledger.js";
+import { getTemplatesByScene, } from "./arbitration-templates.js";
+import { ARBITRATION_CONSTRAINT_RULES, matchSemanticPattern, } from "./arbitration-translation.js";
+import { getAllRiskRules, assessArbitrationRisks, } from "./arbitration-risk.js";
+import { initPuzzleFromIntent, checkPuzzleCompleteness, } from "./arbitration-puzzle.js";
+import { ARBITRATION_OPERATION_CHECKLIST, ARBITRATION_CONFIRMATION_QUESTIONS, } from "./arbitration-confirm.js";
+export const ARBITRATION_CONTEXT_VERSION = "1.0.0";
+export function buildArbitrationContext(input) {
+    const max_length = input.max_length ?? 4500;
+    let matched_scene;
+    if (input.intent) {
+        matched_scene = inferSceneFromIntent(input.intent);
+    }
+    else if (input.target_permission_index !== undefined) {
+        matched_scene = findSceneByPermissionIndex(input.target_permission_index);
+    }
+    else if (input.target_operation_category) {
+        const scenes = getScenesByCategory(input.target_operation_category);
+        if (scenes.length > 0)
+            matched_scene = scenes[0];
+    }
+    let matched_template;
+    if (matched_scene) {
+        const templates = getTemplatesByScene(matched_scene.id);
+        if (templates.length > 0)
+            matched_template = templates[0];
+    }
+    let matched_pattern;
+    if (input.intent) {
+        const patterns = matchSemanticPattern(input.intent);
+        if (patterns.length > 0)
+            matched_pattern = patterns[0];
+    }
+    let puzzle_state;
+    let puzzle_completeness;
+    if (input.mode === "initial_design" && input.intent) {
+        puzzle_state = initPuzzleFromIntent({ rule_sentence: input.intent });
+        puzzle_completeness = checkPuzzleCompleteness(puzzle_state);
+    }
+    const relevant_risks = filterRiskRules(input.mode, input.stakeholder, matched_scene);
+    let risk_assessment;
+    if (input.mode === "pre_publish" && input.arbitration_json) {
+        const ctx = {
+            object: input.arbitration_json.object,
+            description: input.arbitration_json.description,
+            location: input.arbitration_json.location,
+            fee: input.arbitration_json.fee,
+            pause: input.arbitration_json.pause,
+            dispute: input.arbitration_json.dispute,
+            confirm: input.arbitration_json.confirm,
+            voting_deadline_change: input.arbitration_json.voting_deadline_change,
+            vote: input.arbitration_json.vote,
+            feedback: input.arbitration_json.feedback,
+            arbitration: input.arbitration_json.arbitration,
+            reset: input.arbitration_json.reset,
+            arb_withdraw: input.arbitration_json.arb_withdraw,
+            fees_transfer: input.arbitration_json.fees_transfer,
+            usage_guard: input.arbitration_json.usage_guard,
+            voting_guard: input.arbitration_json.voting_guard,
+            um: input.arbitration_json.um,
+            builder: input.arbitration_json.builder,
+            current_arb_status: input.current_arb_status,
+            expected_arb_status: input.arbitration_json.arbitration ? "Arbitrated" : input.current_arb_status,
+        };
+        risk_assessment = assessArbitrationRisks(ctx);
+    }
+    const relevant_checklist = filterChecklist(input.mode);
+    const relevant_questions = filterQuestions(input.mode);
+    const relevant_constraints = filterConstraints(input.mode, matched_scene);
+    const relevant_permissions = input.stakeholder === "system"
+        ? getAllArbitrationPermissions()
+        : getActiveArbitrationPermissions();
+    let dual_guard_matrix_entry;
+    if (input.voting_guard_empty !== undefined && input.usage_guard_none !== undefined) {
+        dual_guard_matrix_entry = getDualGuardMatrixEntry(input.voting_guard_empty, input.usage_guard_none);
+    }
+    else if (matched_scene) {
+        const vEmpty = matched_scene.requires_voting_guard === "empty";
+        const uNone = matched_scene.requires_usage_guard === "none";
+        dual_guard_matrix_entry = getDualGuardMatrixEntry(vEmpty, uNone);
+    }
+    const arb_lifecycle_context = buildArbLifecycleContext(input.current_arb_status, matched_scene);
+    const cross_object_refs = buildCrossObjectRefs(matched_scene);
+    const onchain_constraints = buildOnchainConstraints();
+    const rendering_hints = buildRenderingHints(input.mode, max_length, !!input.arbitration_json?.arbitration, !!input.arbitration_json?.builder);
+    return {
+        version: ARBITRATION_CONTEXT_VERSION,
+        mode: input.mode,
+        stakeholder_perspective: input.stakeholder,
+        matched_scene,
+        matched_template,
+        matched_pattern,
+        puzzle_state,
+        puzzle_completeness,
+        relevant_risks,
+        risk_assessment,
+        relevant_checklist,
+        relevant_questions,
+        relevant_permissions,
+        relevant_constraints,
+        dual_guard_matrix_entry,
+        arb_lifecycle_context,
+        cross_object_refs,
+        onchain_constraints,
+        rendering_hints,
+    };
+}
+function filterRiskRules(mode, stakeholder, scene) {
+    const rules = getAllRiskRules();
+    if (mode === "initial_design") {
+        return rules.filter(r => r.category === "structural" || r.category === "authority");
+    }
+    if (mode === "pre_publish") {
+        return rules;
+    }
+    if (mode === "stakeholder_review" && stakeholder) {
+        if (stakeholder === "owner") {
+            return rules.filter(r => r.category === "authority" || r.category === "lifecycle" || r.category === "cross_object");
+        }
+        if (stakeholder === "arbiter") {
+            return rules.filter(r => r.category === "authority" || r.category === "lifecycle");
+        }
+        if (stakeholder === "voter") {
+            return rules.filter(r => r.category === "structural" || r.category === "lifecycle");
+        }
+        if (stakeholder === "disputant") {
+            return rules.filter(r => r.category === "semantic" || r.category === "lifecycle");
+        }
+        if (stakeholder === "system") {
+            return rules.filter(r => r.category === "structural" || r.category === "cross_object");
+        }
+    }
+    if (mode === "post_publish_modify") {
+        return rules.filter(r => r.category === "lifecycle" || r.category === "cross_object");
+    }
+    return rules;
+}
+function filterChecklist(mode) {
+    if (mode === "initial_design") {
+        return ARBITRATION_OPERATION_CHECKLIST.filter(i => ["C-AB-01", "C-AB-02", "C-AB-03", "C-AB-04"].includes(i.id));
+    }
+    return [...ARBITRATION_OPERATION_CHECKLIST];
+}
+function filterQuestions(mode) {
+    if (mode === "pre_publish") {
+        return [...ARBITRATION_CONFIRMATION_QUESTIONS];
+    }
+    if (mode === "post_publish_modify") {
+        return ARBITRATION_CONFIRMATION_QUESTIONS.filter(q => q.id !== "QAB5");
+    }
+    return [];
+}
+function filterConstraints(mode, scene) {
+    if (mode === "initial_design") {
+        return ARBITRATION_CONSTRAINT_RULES.filter(c => c.category === "structural");
+    }
+    if (mode === "pre_publish") {
+        return [...ARBITRATION_CONSTRAINT_RULES];
+    }
+    if (scene) {
+        const categoryMap = {
+            lifecycle: ["structural", "authority"],
+            dispute: ["semantic", "lifecycle"],
+            voting: ["semantic", "lifecycle"],
+            ruling: ["authority", "lifecycle"],
+            fund: ["cross_object"],
+            guard: ["structural", "semantic"],
+            governance: ["authority"],
+        };
+        const cats = categoryMap[scene.operation_category] ?? [];
+        return ARBITRATION_CONSTRAINT_RULES.filter(c => cats.includes(c.category));
+    }
+    return [...ARBITRATION_CONSTRAINT_RULES];
+}
+function buildArbLifecycleContext(current_status, scene) {
+    if (!current_status && !scene)
+        return undefined;
+    const is_terminal = current_status ? isTerminalArbStatus(current_status) : false;
+    const valid_next_statuses = [];
+    if (current_status) {
+        const allStatuses = [
+            "Principal_confirming",
+            "Arbitrator_confirming",
+            "Voting",
+            "Arbitrated",
+            "Objectionable",
+            "Finished",
+            "Withdrawn",
+        ];
+        for (const target of allStatuses) {
+            if (target !== current_status && isValidArbStatusTransition(current_status, target)) {
+                valid_next_statuses.push(target);
+            }
+        }
+    }
+    const valid_operations_from_here = [];
+    for (const s of ARBITRATION_SCENES) {
+        if (current_status && s.required_arb_status && s.required_arb_status.includes(current_status)) {
+            valid_operations_from_here.push(s.id);
+        }
+    }
+    return {
+        current_status,
+        current_status_code: current_status ? ARB_STATUS_CODE[current_status] : undefined,
+        is_terminal,
+        valid_next_statuses,
+        valid_operations_from_here,
+    };
+}
+function buildCrossObjectRefs(scene) {
+    const refs = [];
+    const outboundRefs = [
+        {
+            object: "Order",
+            field: "dispute.order",
+            scene_id: "arbitration_dispute",
+            description: "dispute() takes Order address — Order is the source of disputes",
+            direction: "references",
+        },
+        {
+            object: "Arb",
+            field: "dispute (spawns Arb)",
+            scene_id: "arbitration_dispute",
+            description: "Each dispute() creates a new Arb case object with 7-state lifecycle",
+            direction: "references",
+        },
+        {
+            object: "Guard",
+            field: "voting_guard / usage_guard",
+            scene_id: "arbitration_voting_guard_config / arbitration_usage_guard_config",
+            description: "voting_guard controls vote weight (max 50); usage_guard filters who can file disputes",
+            direction: "references",
+        },
+        {
+            object: "Allocation",
+            field: "fees_transfer.to.allocation",
+            scene_id: "arbitration_fees_transfer",
+            description: "Withdrawn fees can be routed to Allocation for arbiter compensation distribution",
+            direction: "references",
+        },
+        {
+            object: "Treasury",
+            field: "fees_transfer.to.treasury",
+            scene_id: "arbitration_fees_transfer",
+            description: "Withdrawn fees can be routed to Treasury as alternative destination",
+            direction: "references",
+        },
+        {
+            object: "Contact",
+            field: "um",
+            scene_id: "arbitration_um_set",
+            description: "um (Contact object) for arbitrator ↔ disputant communication channel",
+            direction: "references",
+        },
+        {
+            object: "Payment",
+            field: "fees_transfer.payment_remark / payment_index",
+            scene_id: "arbitration_fees_transfer",
+            description: "fees_transfer creates Payment object with remark + index for audit trail",
+            direction: "references",
+        },
+    ];
+    const inboundRefs = [
+        {
+            object: "Service",
+            field: "arbitrations (MAX_ARBITRATION_COUNT=20)",
+            scene_id: "service_arbitration_config",
+            description: "Service embeds up to 20 Arbitration references for dispute resolution per service",
+            direction: "referenced_by",
+        },
+    ];
+    if (scene) {
+        const sceneId = scene.id;
+        return [...outboundRefs, ...inboundRefs].filter(r => r.scene_id === sceneId || r.scene_id.includes(sceneId.split("_")[1] ?? ""));
+    }
+    return [...outboundRefs, ...inboundRefs];
+}
+function buildOnchainConstraints() {
+    return [
+        {
+            name: "MAX_VOTING_GUARD_COUNT",
+            value: MAX_VOTING_GUARD_COUNT,
+            description: "Maximum voting_guard entries per Arbitration (Move source: arbitration.move:25)",
+        },
+        {
+            name: "ARBITRATION_PERMISSION_INDEX_RANGE",
+            value: "350-368 (352 reserved)",
+            description: "19 built-in permission indexes for Arbitration — most among all 22 objects",
+        },
+        {
+            name: "ARB_STATE_COUNT",
+            value: 7,
+            description: "Arb has 7-state lifecycle: Principal_confirming → Arbitrator_confirming → Voting → Arbitrated → Objectionable → Finished/Withdrawn",
+        },
+        {
+            name: "ARB_TERMINAL_STATUSES",
+            value: ARB_TERMINAL_STATUSES.length,
+            description: `Terminal statuses: ${ARB_TERMINAL_STATUSES.join(", ")} (no further transitions)`,
+        },
+        {
+            name: "DUAL_GUARD_COMBINATIONS",
+            value: DUAL_GUARD_MATRIX.length,
+            description: "4 dual-Guard combos: (voting_guard empty/non-empty) × (usage_guard none/some)",
+        },
+    ];
+}
+function buildRenderingHints(mode, max_length, hasIndemnity, hasOwnershipTransfer) {
+    return {
+        include_puzzle_template: mode === "initial_design",
+        include_risk_details: mode === "pre_publish" || mode === "stakeholder_review",
+        include_questions: mode === "pre_publish",
+        include_dual_guard_matrix: mode === "initial_design" || mode === "pre_publish",
+        include_arb_lifecycle: mode === "pre_publish" || mode === "post_publish_modify" || mode === "stakeholder_review",
+        include_immutability_warning: mode === "post_publish_modify",
+        include_indemnity_warning: hasIndemnity,
+        include_ownership_transfer_warning: hasOwnershipTransfer,
+        max_length,
+    };
+}
+export function buildPromptFromArbitrationContext(bundle) {
+    const lines = [];
+    const h = bundle.rendering_hints;
+    lines.push(`═══ Arbitration Context (mode: ${bundle.mode}) ═══`);
+    lines.push("");
+    if (bundle.stakeholder_perspective) {
+        lines.push(`Stakeholder perspective: ${bundle.stakeholder_perspective}`);
+        lines.push("");
+    }
+    if (bundle.matched_scene) {
+        lines.push(`Scene: ${bundle.matched_scene.name}`);
+        lines.push(`Category: ${bundle.matched_scene.operation_category}`);
+        lines.push(`Permission index: ${bundle.matched_scene.permission_index} (${bundle.matched_scene.permission_name})`);
+        if (bundle.matched_scene.required_arb_status && bundle.matched_scene.required_arb_status.length > 0) {
+            lines.push(`Required Arb status: ${bundle.matched_scene.required_arb_status.join(" | ")}`);
+        }
+        if (bundle.matched_scene.resulting_arb_status) {
+            lines.push(`Resulting Arb status: ${bundle.matched_scene.resulting_arb_status}`);
+        }
+        lines.push(`Has _with_passport variant: ${bundle.matched_scene.has_passport_variant ? "YES" : "NO"}`);
+        lines.push("");
+    }
+    if (bundle.matched_template) {
+        lines.push(`Suggested template: ${bundle.matched_template.id} — ${bundle.matched_template.name}`);
+        lines.push(`Description: ${bundle.matched_template.description}`);
+        lines.push("");
+    }
+    if (bundle.matched_pattern) {
+        lines.push(`Matched pattern: ${bundle.matched_pattern.id} — ${bundle.matched_pattern.pattern_name}`);
+        lines.push(`Intent: ${bundle.matched_pattern.semantic_intent}`);
+        lines.push("");
+    }
+    if (h.include_puzzle_template && bundle.puzzle_completeness) {
+        const c = bundle.puzzle_completeness;
+        lines.push("─ Puzzle Completeness ──────────────");
+        lines.push(`Complete: ${c.complete ? "YES" : "NO"}`);
+        if (c.missing.length > 0) {
+            lines.push(`Missing dimensions: ${c.missing.join(", ")}`);
+        }
+        lines.push(`Next step: ${c.next_step}`);
+        lines.push("");
+    }
+    if (h.include_dual_guard_matrix && bundle.dual_guard_matrix_entry) {
+        const m = bundle.dual_guard_matrix_entry;
+        lines.push("─ Dual-Guard Matrix Entry ──────────────");
+        lines.push(`Voting guard: ${m.voting_guard_empty ? "EMPTY (open vote)" : "NON-EMPTY (weighted)"}`);
+        lines.push(`Usage guard: ${m.usage_guard_none ? "NONE (open dispute)" : "SOME (filtered dispute)"}`);
+        lines.push(`Vote method: ${m.vote_method}`);
+        lines.push(`Dispute method: ${m.dispute_method}`);
+        lines.push(`Scenario: ${m.scenario}`);
+        lines.push("");
+    }
+    if (h.include_arb_lifecycle && bundle.arb_lifecycle_context) {
+        const lc = bundle.arb_lifecycle_context;
+        lines.push("─ Arb 7-State Lifecycle Context ──────────────");
+        if (lc.current_status) {
+            lines.push(`Current Arb status: ${lc.current_status} (code ${lc.current_status_code})`);
+            lines.push(`Terminal: ${lc.is_terminal ? "YES — no further transitions" : "NO"}`);
+            if (lc.valid_next_statuses.length > 0) {
+                lines.push(`Valid next statuses: ${lc.valid_next_statuses.join(", ")}`);
+            }
+            if (lc.valid_operations_from_here.length > 0) {
+                lines.push(`Valid operations from here (${lc.valid_operations_from_here.length}):`);
+                for (const op of lc.valid_operations_from_here.slice(0, 6)) {
+                    lines.push(`  - ${op}`);
+                }
+                if (lc.valid_operations_from_here.length > 6) {
+                    lines.push(`  ... and ${lc.valid_operations_from_here.length - 6} more`);
+                }
+            }
+        }
+        else {
+            lines.push("No current Arb status provided — lifecycle context inactive");
+        }
+        lines.push("");
+    }
+    if (h.include_risk_details && bundle.relevant_risks.length > 0) {
+        lines.push(`─ Relevant Risk Rules (${bundle.relevant_risks.length}) ──────────────`);
+        for (const r of bundle.relevant_risks.slice(0, 6)) {
+            lines.push(`  ${r.id} — ${r.trigger}`);
+        }
+        if (bundle.relevant_risks.length > 6) {
+            lines.push(`  ... and ${bundle.relevant_risks.length - 6} more`);
+        }
+        lines.push("");
+    }
+    if (bundle.risk_assessment) {
+        lines.push("─ Risk Assessment ──────────────");
+        lines.push(`Overall risk: ${bundle.risk_assessment.overall_risk}`);
+        lines.push(`Detected: ${bundle.risk_assessment.risks.length} risk(s)`);
+        if (bundle.risk_assessment.risks.length > 0) {
+            for (const r of bundle.risk_assessment.risks.slice(0, 3)) {
+                lines.push(`  [${r.level}] ${r.id}: ${r.title}`);
+            }
+            if (bundle.risk_assessment.risks.length > 3) {
+                lines.push(`  ... and ${bundle.risk_assessment.risks.length - 3} more`);
+            }
+        }
+        lines.push("");
+    }
+    if (bundle.relevant_permissions.length > 0) {
+        lines.push(`─ Relevant Permissions (${bundle.relevant_permissions.length}) ──────────────`);
+        for (const p of bundle.relevant_permissions.slice(0, 10)) {
+            const reserved = p.is_reserved ? " [RESERVED]" : "";
+            lines.push(`  [${p.index}] ${p.name}${reserved}: ${p.description}`);
+        }
+        if (bundle.relevant_permissions.length > 10) {
+            lines.push(`  ... and ${bundle.relevant_permissions.length - 10} more`);
+        }
+        lines.push("");
+    }
+    if (bundle.relevant_constraints.length > 0) {
+        lines.push(`─ Relevant Constraint Rules (${bundle.relevant_constraints.length}) ──────────────`);
+        for (const c of bundle.relevant_constraints.slice(0, 5)) {
+            lines.push(`  ${c.id} [${c.category}]: ${c.rule}`);
+        }
+        if (bundle.relevant_constraints.length > 5) {
+            lines.push(`  ... and ${bundle.relevant_constraints.length - 5} more`);
+        }
+        lines.push("");
+    }
+    if (h.include_indemnity_warning) {
+        lines.push("⚠️ INDEMNITY OPERATION DETECTED — arbitration.indemnity transfers WOW from arbiter to disputant");
+        lines.push("   This is IRREVERSIBLE once the ruling is finalized. Verify indemnity amount carefully.");
+        lines.push("");
+    }
+    if (h.include_ownership_transfer_warning) {
+        lines.push("⚠️ OWNERSHIP TRANSFER DETECTED — builder field transfers Arbitration ownership");
+        lines.push("   This is IRREVERSIBLE. Original owner will lose all administrative rights.");
+        lines.push("");
+    }
+    if (h.include_immutability_warning) {
+        lines.push("ℹ️ POST-PUBLISH MODIFICATION — Arbitration is already on-chain");
+        lines.push("   Some fields can be modified (description, location, fee, voting_guard, usage_guard)");
+        lines.push("   but core properties (coin_type, permission object) are immutable.");
+        lines.push("");
+    }
+    if (bundle.cross_object_refs.length > 0) {
+        lines.push(`─ Cross-Object References (${bundle.cross_object_refs.length}) ──────────────`);
+        for (const r of bundle.cross_object_refs.slice(0, 6)) {
+            const arrow = r.direction === "references" ? "→" : "←";
+            lines.push(`  ${arrow} ${r.object}.${r.field} (${r.direction}) — ${r.description}`);
+        }
+        if (bundle.cross_object_refs.length > 6) {
+            lines.push(`  ... and ${bundle.cross_object_refs.length - 6} more`);
+        }
+        lines.push("");
+    }
+    if (bundle.onchain_constraints.length > 0) {
+        lines.push("─ On-chain Constraints ──────────────");
+        for (const c of bundle.onchain_constraints) {
+            lines.push(`  ${c.name} = ${c.value} — ${c.description}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export function getArbitrationContextSummary(bundle) {
+    const parts = [
+        `mode=${bundle.mode}`,
+        `scene=${bundle.matched_scene?.id ?? "none"}`,
+        `risks=${bundle.relevant_risks.length}`,
+        `permissions=${bundle.relevant_permissions.length}`,
+        `constraints=${bundle.relevant_constraints.length}`,
+    ];
+    if (bundle.stakeholder_perspective)
+        parts.push(`stakeholder=${bundle.stakeholder_perspective}`);
+    if (bundle.risk_assessment)
+        parts.push(`overall_risk=${bundle.risk_assessment.overall_risk}`);
+    if (bundle.dual_guard_matrix_entry) {
+        parts.push(`dual_guard=${bundle.dual_guard_matrix_entry.vote_method}+${bundle.dual_guard_matrix_entry.dispute_method}`);
+    }
+    if (bundle.arb_lifecycle_context?.current_status) {
+        parts.push(`arb_status=${bundle.arb_lifecycle_context.current_status}`);
+    }
+    if (bundle.cross_object_refs.length > 0)
+        parts.push(`xrefs=${bundle.cross_object_refs.length}`);
+    return parts.join(", ");
+}
+export { ARBITRATION_LEDGER_VERSION, ARBITRATION_SCENES, ARBITRATION_PERMISSIONS, DUAL_GUARD_MATRIX, ARB_STATUS_CODE, ARB_TERMINAL_STATUSES, findSceneById, findSceneByPermissionIndex, inferSceneFromIntent, getScenesByCategory, getDualGuardMatrixEntry, isValidArbStatusTransition, isTerminalArbStatus, getActiveArbitrationPermissions, getAllArbitrationPermissions, } from "./arbitration-ledger.js";
+export { ARBITRATION_TEMPLATES_VERSION, ARBITRATION_TEMPLATES, suggestTemplateForScene, getTemplatesByScene, getTemplateById, } from "./arbitration-templates.js";
+export { ARBITRATION_TRANSLATION_VERSION, SEMANTIC_TO_SCHEMA_RULES, ARBITRATION_CONSTRAINT_RULES, matchSemanticPattern, explainArbitrationCallData, explainPermissionIndex, explainArbStatus, } from "./arbitration-translation.js";
+export { ARBITRATION_RISK_VERSION, getAllRiskRules, assessArbitrationRisks, } from "./arbitration-risk.js";
+export { ARBITRATION_CONFIRM_VERSION, ARBITRATION_OPERATION_CHECKLIST, ARBITRATION_CONFIRMATION_QUESTIONS, runArbitrationConfirmGate, } from "./arbitration-confirm.js";
+export { initPuzzleFromIntent, checkPuzzleCompleteness, validateConstraints, } from "./arbitration-puzzle.js";

package/dist/knowledge/arbitration-ledger.d.ts

@@ -0,0 +1,62 @@
+export interface ArbitrationScene {
+    id: string;
+    name: string;
+    operation_category: "lifecycle" | "dispute" | "voting" | "ruling" | "fund" | "guard" | "governance";
+    permission_index: number;
+    permission_name: string;
+    required_arb_status?: ArbStatus[];
+    resulting_arb_status?: ArbStatus;
+    requires_voting_guard?: "empty" | "non_empty" | "any" | "not_applicable";
+    requires_usage_guard?: "none" | "some" | "any" | "not_applicable";
+    has_passport_variant: boolean;
+    governed_operations: string[];
+    common_patterns: string[];
+    recommended_templates: string[];
+}
+export type ArbStatus = "Principal_confirming" | "Arbitrator_confirming" | "Voting" | "Arbitrated" | "Objectionable" | "Finished" | "Withdrawn";
+export declare const ARB_STATUS_CODE: Record<ArbStatus, number>;
+export declare const ARB_TERMINAL_STATUSES: ArbStatus[];
+export declare const ARB_STATUS_ALIASES: Record<string, ArbStatus>;
+export interface ArbitrationPermissionEntry {
+    index: number;
+    name: string;
+    description: string;
+    governed_operations: string[];
+    is_reserved?: boolean;
+}
+export declare const ARBITRATION_PERMISSIONS: ArbitrationPermissionEntry[];
+export interface VotingGuardEntry {
+    guard: string;
+    vote_weight: {
+        GuardIdentifier: number;
+    } | {
+        FixedValue: number;
+    };
+}
+export interface DualGuardMatrix {
+    voting_guard_empty: boolean;
+    usage_guard_none: boolean;
+    dispute_method: "dispute" | "dispute_with_passport";
+    vote_method: "vote" | "vote_with_voting_guard";
+    scenario: string;
+}
+export declare const DUAL_GUARD_MATRIX: DualGuardMatrix[];
+export declare const ARBITRATION_SCENES: ArbitrationScene[];
+export declare const ARBITRATION_LEDGER_VERSION = "1.0.0";
+export declare function getScenesByCategory(category: ArbitrationScene["operation_category"]): ArbitrationScene[];
+export declare function findSceneById(id: string): ArbitrationScene | undefined;
+export declare function findSceneByPermissionIndex(index: number): ArbitrationScene | undefined;
+export declare function getPermissionByIndex(index: number): ArbitrationPermissionEntry | undefined;
+export declare function getPermissionByName(name: string): ArbitrationPermissionEntry | undefined;
+export declare function isReservedIndex(index: number): boolean;
+export declare function isUsedPermissionIndex(index: number): boolean;
+export declare function getActivePermissionCount(): number;
+export declare function inferSceneFromIntent(intent: string): ArbitrationScene | undefined;
+export declare function getDualGuardMatrixEntry(votingGuardEmpty: boolean, usageGuardNone: boolean): DualGuardMatrix;
+export declare function isValidArbStatusTransition(from: ArbStatus, to: ArbStatus): boolean;
+export declare function isTerminalArbStatus(status: ArbStatus): boolean;
+export declare function getScenesProducingStatus(status: ArbStatus): ArbitrationScene[];
+export declare function getScenesRequiringStatus(status: ArbStatus): ArbitrationScene[];
+export declare function getArbitrationScenesCount(): number;
+export declare function getAllArbitrationPermissions(): ArbitrationPermissionEntry[];
+export declare function getActiveArbitrationPermissions(): ArbitrationPermissionEntry[];