@wowok/agent-mcp 2.6.3 → 2.6.6

package/dist/knowledge/fund-layer.js

@@ -72,12 +72,16 @@ export async function resolveTokenByType(tokenType, network) {
             verified: true,
         };
     }
+    const memKey = `${cacheNet(network)}::${tokenType}`;
+    const memHit = RESOLUTION_CACHE.get(memKey);
+    if (memHit)
+        return memHit;
     try {
         const { TokenInfo } = await import("@wowok/wowok");
         const tokenInfo = TokenInfo.Instance();
         const fetched = await tokenInfo.fetch(tokenType, undefined, network);
         if (fetched) {
-            return {
+            const resolution = {
                 type: fetched.type,
                 symbol: fetched.symbol ?? "",
                 decimals: fetched.decimals ?? 0,
@@ -85,6 +89,8 @@ export async function resolveTokenByType(tokenType, network) {
                 source: "cache",
                 verified: false,
             };
+            RESOLUTION_CACHE.set(memKey, resolution);
+            return resolution;
         }
     }
     catch {
@@ -150,13 +156,22 @@ export function isAmountWithSymbol(value) {
 export async function parseAmount(amount, tokenType, network) {
     const originalInput = amount;
     const resolution = await resolveTokenByType(tokenType, network);
+    const precisionKnown = resolution !== undefined;
     const decimals = resolution?.decimals ?? 9;
     const symbol = resolution?.symbol ?? "";
-    const source = resolution?.source ?? "registry";
+    const source = resolution?.source ?? "onchain";
     const verified = resolution?.verified ?? false;
     if (typeof amount === "string") {
         const match = amount.match(AMOUNT_WITH_SYMBOL);
         if (match) {
+            if (!precisionKnown) {
+                throw new Error(`TOKEN PRECISION UNKNOWN for ${tokenType} — REFUSING to convert "${amount}". ` +
+                    `The token's decimals could not be resolved from the official registry, local cache, ` +
+                    `or on-chain metadata, and guessing decimals would forge a wrong on-chain value. ` +
+                    `Retry (the on-chain lookup may have been transient), or pass a pure numeric value ` +
+                    `in smallest units only if you are certain of the raw u64 amount. ` +
+                    knownTokenSuggestions(network));
+            }
             const numericPart = parseFloat(match[1]);
             const symbolPart = match[2];
             if (symbol && symbolPart.toLowerCase() !== symbol.toLowerCase()) {
@@ -175,6 +190,7 @@ export async function parseAmount(amount, tokenType, network) {
                 converted: true,
                 source,
                 verified,
+                precision_known: true,
             };
         }
     }
@@ -186,10 +202,12 @@ export async function parseAmount(amount, tokenType, network) {
         throw new Error(`Invalid amount: "${amount}". Expected a number, a numeric string (smallest unit), ` +
             `or a display-format string like "2.5WOW" (matching the token's symbol).`);
     }
-    const displayValue = smallestToDisplay(smallestUnit, decimals);
+    const displayValue = precisionKnown
+        ? smallestToDisplay(smallestUnit, decimals)
+        : `${smallestUnit.toString()} raw smallest units (token precision unknown)`;
     return {
         smallestUnit,
-        displayAmount: symbol ? `${displayValue} ${symbol}` : displayValue,
+        displayAmount: precisionKnown && symbol ? `${displayValue} ${symbol}` : displayValue,
         originalInput,
         tokenType,
         tokenSymbol: symbol,
@@ -197,6 +215,7 @@ export async function parseAmount(amount, tokenType, network) {
         converted: false,
         source,
         verified,
+        precision_known: precisionKnown,
     };
 }
 function displayToSmallestUnit(display, decimals) {
@@ -207,13 +226,27 @@ function displayToSmallestUnit(display, decimals) {
     return BigInt(combined || "0");
 }
 export function smallestToDisplay(value, decimals) {
+    const sign = value < 0n ? "-" : "";
+    const abs = value < 0n ? -value : value;
     const divisor = BigInt(10) ** BigInt(decimals);
-    const whole = value / divisor;
-    const frac = value % divisor;
+    const whole = abs / divisor;
+    const frac = abs % divisor;
     if (frac === 0n)
-        return whole.toString();
+        return `${sign}${whole.toString()}`;
     const fracStr = frac.toString().padStart(decimals, "0").replace(/0+$/, "");
-    return `${whole.toString()}.${fracStr}`;
+    return `${sign}${whole.toString()}.${fracStr}`;
+}
+export function displayStringToSmallest(display, decimals) {
+    const trimmed = display.trim();
+    if (!/^\d+(\.\d+)?$/.test(trimmed)) {
+        throw new Error(`Invalid display amount: "${display}". Expected a non-negative decimal number like "2.5".`);
+    }
+    const [whole, frac = ""] = trimmed.split(".");
+    if (frac.length > decimals) {
+        throw new Error(`Too many decimal places: "${display}" has ${frac.length}, but this token supports at most ${decimals} (decimals: ${decimals}).`);
+    }
+    const paddedFrac = frac.padEnd(decimals, "0");
+    return BigInt(whole + paddedFrac);
 }
 export function generateFundConfirmation(fields, ambiguities = []) {
     const hasAmbiguity = ambiguities.length > 0;
@@ -251,13 +284,16 @@ export function generateFundConfirmation(fields, ambiguities = []) {
         message: parts.join("\n"),
     };
 }
-function extractTokenType(data, operationType) {
+function extractTokenType(data, operationType, objectTokenType) {
     if (data?.object && typeof data.object === "object" && data.object.type_parameter) {
         return data.object.type_parameter;
     }
     if (operationType === "payment" && data?.type_parameter) {
         return data.type_parameter;
     }
+    if (objectTokenType) {
+        return objectTokenType;
+    }
     return GasTokenType;
 }
 const MONETARY_FIELDS = {
@@ -281,6 +317,9 @@ const MONETARY_FIELDS = {
     payment: [
         { path: "revenue", context: "Payment amount", isArray: true, amountField: "amount.balance" },
     ],
+    allocation: [
+        { path: "coin.balance", context: "Allocation funding amount" },
+    ],
 };
 function getNestedValue(obj, path) {
     const parts = path.split(".");
@@ -292,17 +331,18 @@ function getNestedValue(obj, path) {
     }
     return current;
 }
-export async function processFundOperation(data, operationType, network) {
+export async function processFundOperation(data, operationType, network, options) {
     const result = {
         convertedData: data,
         warnings: [],
+        errors: [],
         confirmation: null,
     };
     const fields = MONETARY_FIELDS[operationType];
     if (!fields) {
         return result;
     }
-    const tokenType = extractTokenType(data, operationType);
+    const tokenType = extractTokenType(data, operationType, options?.objectTokenType);
     const confirmationFields = [];
     const ambiguities = [];
     const seenSymbols = new Map();
@@ -364,6 +404,13 @@ async function processSingleField(parentObj, fieldKey, fieldPath, context, token
         return;
     try {
         const parsed = await parseAmount(value, tokenType, network);
+        if (!parsed.precision_known) {
+            result.errors.push(`FUND INPUT BLOCKED at ${fieldPath}: token precision unavailable for ${tokenType}. ` +
+                `The raw value ${JSON.stringify(value)} was NOT converted or confirmed. ` +
+                `Retry after the token info resolves (registry → cache → on-chain), ` +
+                `or use a known token. ${knownTokenSuggestions(network)}`);
+            return;
+        }
         if (parsed.converted) {
             parentObj[fieldKey] = parsed.smallestUnit.toString();
         }
@@ -399,7 +446,7 @@ async function processSingleField(parentObj, fieldKey, fieldPath, context, token
         }
     }
     catch (err) {
-        result.warnings.push(`FUND LAYER ERROR at ${fieldPath}: ${err.message}`);
+        result.errors.push(`FUND INPUT BLOCKED at ${fieldPath}: ${err.message}`);
     }
 }
 export function generateSkillsHint(confirmation) {
@@ -418,3 +465,505 @@ export function generateSkillsHint(confirmation) {
         "dialogue scripts. Otherwise, present the confirmation message to the user " +
         "and proceed only after explicit consent (env.confirmed=true).");
 }
+export async function formatChainValue(raw, tokenType, network) {
+    let rawStr;
+    try {
+        rawStr = BigInt(raw).toString();
+    }
+    catch {
+        rawStr = String(raw);
+    }
+    const resolution = await resolveTokenByType(tokenType, network);
+    if (resolution && typeof resolution.decimals === "number") {
+        let display = rawStr;
+        try {
+            display = smallestToDisplay(BigInt(rawStr), resolution.decimals);
+        }
+        catch {
+        }
+        const symbol = resolution.symbol || "";
+        const text = symbol
+            ? `${display} ${symbol} (decimals: ${resolution.decimals}; 1 ${symbol} = 10^${resolution.decimals} raw units; raw: ${rawStr})`
+            : `${display} (decimals: ${resolution.decimals}; 1 unit = 10^${resolution.decimals} raw units; raw: ${rawStr})`;
+        return {
+            raw: rawStr,
+            display,
+            symbol: symbol || undefined,
+            decimals: resolution.decimals,
+            token_type: tokenType,
+            precision_known: true,
+            text,
+        };
+    }
+    return {
+        raw: rawStr,
+        display: rawStr,
+        token_type: tokenType,
+        precision_known: false,
+        text: `${rawStr} raw smallest units (token precision unavailable for ${tokenType} — ` +
+            `cannot convert to unit value. Conversion rule once decimals N is known: ` +
+            `unit = raw / 10^N. Re-run the query to retry the on-chain precision lookup.)`,
+    };
+}
+export function registryDisplayHint(tokenType, network) {
+    if (!tokenType)
+        return undefined;
+    const entry = findInRegistryByType(tokenType, network);
+    if (!entry)
+        return undefined;
+    return { decimals: entry.decimals, symbol: entry.symbol };
+}
+const RESOLUTION_CACHE = new Map();
+const OBJECT_TYPE_CACHE = new Map();
+function cacheNet(network) {
+    return network ?? "default";
+}
+function isCacheableObjectRef(ref) {
+    return /^0x[0-9a-fA-F]{20,}$/.test(ref);
+}
+export function clearFundResolutionCaches() {
+    RESOLUTION_CACHE.clear();
+    OBJECT_TYPE_CACHE.clear();
+}
+export function knownTokenSuggestions(network) {
+    const tokens = getRegistryForNetwork(network)
+        .map(t => `${t.symbol} (${t.type}, ${t.decimals} decimals)`);
+    return tokens.length > 0
+        ? `Known tokens: ${tokens.join("; ")}.`
+        : "No officially-known tokens on this network.";
+}
+export function formatAmountText(raw, decimals, symbol) {
+    let rawStr;
+    try {
+        rawStr = BigInt(raw).toString();
+    }
+    catch {
+        rawStr = String(raw);
+    }
+    if (decimals === undefined) {
+        return `${rawStr} smallest units (token precision unknown)`;
+    }
+    let display = rawStr;
+    try {
+        display = smallestToDisplay(BigInt(rawStr), decimals);
+    }
+    catch {
+    }
+    return symbol
+        ? `${display} ${symbol} (decimals: ${decimals}; raw: ${rawStr})`
+        : `${display} (decimals: ${decimals}; raw: ${rawStr})`;
+}
+export async function convertTokenValue(tokenType, value, network) {
+    const resolution = await resolveTokenByType(tokenType, network);
+    const decimals = resolution?.decimals;
+    const symbol = resolution?.symbol || undefined;
+    const base = { token_type: tokenType, symbol, decimals };
+    if (value.raw !== undefined) {
+        let rawStr;
+        try {
+            rawStr = BigInt(value.raw).toString();
+        }
+        catch {
+            return {
+                ...base,
+                precision_known: decimals !== undefined,
+                direction: "raw_to_unit",
+                input: String(value.raw),
+                output: "",
+                error: `Invalid raw value: "${String(value.raw)}" — expected a non-negative integer (u64 smallest units).`,
+                text: `Cannot convert: invalid raw value "${String(value.raw)}".`,
+            };
+        }
+        if (decimals === undefined) {
+            return {
+                ...base,
+                precision_known: false,
+                direction: "raw_to_unit",
+                input: rawStr,
+                output: rawStr,
+                text: `${rawStr} raw smallest units (token precision unavailable for ${tokenType} — ` +
+                    `cannot convert to unit value. Rule once decimals N is known: unit = raw / 10^N.)`,
+            };
+        }
+        let unit = rawStr;
+        try {
+            unit = smallestToDisplay(BigInt(rawStr), decimals);
+        }
+        catch { }
+        return {
+            ...base,
+            precision_known: true,
+            direction: "raw_to_unit",
+            input: rawStr,
+            output: unit,
+            text: symbol
+                ? `${rawStr} raw = ${unit} ${symbol} (decimals: ${decimals}; 1 ${symbol} = 10^${decimals} raw units)`
+                : `${rawStr} raw = ${unit} (decimals: ${decimals}; 1 unit = 10^${decimals} raw units)`,
+        };
+    }
+    const unitStr = String(value.unit ?? "").trim();
+    if (decimals === undefined) {
+        return {
+            ...base,
+            precision_known: false,
+            direction: "unit_to_raw",
+            input: unitStr,
+            output: "",
+            error: `Token precision unavailable for ${tokenType} — REFUSING to convert "${unitStr}" to raw units. ` +
+                `Guessing decimals would forge a wrong on-chain value. Retry after the precision lookup succeeds, ` +
+                `or check the token's coin metadata.`,
+            text: `Cannot convert "${unitStr}" to raw units: token precision unknown for ${tokenType}.`,
+        };
+    }
+    try {
+        const raw = displayStringToSmallest(unitStr, decimals);
+        return {
+            ...base,
+            precision_known: true,
+            direction: "unit_to_raw",
+            input: unitStr,
+            output: raw.toString(),
+            text: symbol
+                ? `${unitStr} ${symbol} = ${raw.toString()} raw smallest units (decimals: ${decimals}; 1 ${symbol} = 10^${decimals} raw units)`
+                : `${unitStr} = ${raw.toString()} raw smallest units (decimals: ${decimals}; 1 unit = 10^${decimals} raw units)`,
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            ...base,
+            precision_known: true,
+            direction: "unit_to_raw",
+            input: unitStr,
+            output: "",
+            error: msg,
+            text: `Cannot convert "${unitStr}" to raw units: ${msg}`,
+        };
+    }
+}
+export const TOKEN_GENERIC_OBJECT_TYPES = [
+    "Treasury",
+    "Allocation",
+    "Arbitration",
+    "Arb",
+    "Payment",
+    "Reward",
+    "Service",
+];
+export function extractGenericTokenType(typeRaw) {
+    if (!typeRaw || typeof typeRaw !== "string")
+        return undefined;
+    const lt = typeRaw.indexOf("<");
+    if (lt < 0)
+        return undefined;
+    let depth = 0;
+    for (let i = lt; i < typeRaw.length; i++) {
+        const ch = typeRaw[i];
+        if (ch === "<")
+            depth++;
+        else if (ch === ">") {
+            depth--;
+            if (depth === 0) {
+                return typeRaw.slice(lt + 1, i).trim() || undefined;
+            }
+        }
+    }
+    return undefined;
+}
+export async function resolveObjectTokenType(objectRef, network) {
+    if (!objectRef || typeof objectRef !== "string")
+        return undefined;
+    const cacheable = isCacheableObjectRef(objectRef);
+    const memKey = `${cacheNet(network)}::${objectRef}`;
+    if (cacheable) {
+        const memHit = OBJECT_TYPE_CACHE.get(memKey);
+        if (memHit)
+            return memHit;
+    }
+    try {
+        const { query_objects } = await import("@wowok/wowok");
+        const res = await query_objects({ objects: [objectRef], network });
+        const obj = res?.objects?.[0];
+        if (!obj)
+            return undefined;
+        const typeRaw = obj.type_raw ?? obj.content_raw?.type ?? undefined;
+        const resolution = {
+            tokenType: extractGenericTokenType(typeRaw),
+            objectType: obj.type,
+            typeRaw,
+        };
+        if (cacheable)
+            OBJECT_TYPE_CACHE.set(memKey, resolution);
+        return resolution;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function resolveOperationObjectTokenType(data, operationType, network) {
+    if (!data)
+        return undefined;
+    if (data.object && typeof data.object === "object" && typeof data.object.type_parameter === "string") {
+        return data.object.type_parameter;
+    }
+    if (operationType === "payment" && typeof data.type_parameter === "string") {
+        return data.type_parameter;
+    }
+    if (typeof data.object === "string" && data.object.length > 0) {
+        const resolved = await resolveObjectTokenType(data.object, network);
+        return resolved?.tokenType;
+    }
+    return undefined;
+}
+const RECEIVE_TOKEN_FIELDS = {
+    treasury: ["receive"],
+    allocation: ["received_coins"],
+    reward: ["receive"],
+    service: ["compensation_fund_receive"],
+    arbitration: ["receive"],
+};
+const COIN_PARAM_FIELDS = {
+    treasury: ["deposit.coin"],
+    allocation: ["coin"],
+    reward: ["coin_add"],
+    arbitration: ["dispute.fee"],
+    service: ["compensation_fund_add", "order_new.buy.total_pay"],
+};
+export async function validateOperationTokenMatch(data, operationType, objectTokenType, network) {
+    const result = { errors: [], warnings: [], objectTokenType };
+    if (!data || !objectTokenType)
+        return result;
+    const objectLabel = typeof data.object === "string" ? data.object : "the target object";
+    const mismatchMsg = (provided, context) => `TOKEN TYPE MISMATCH (${context}): ${objectLabel} only accepts ${objectTokenType} ` +
+        `(its generic token type is fixed and immutable), but ${provided} was provided. ` +
+        `Use ${objectTokenType} for this operation, or target a different object.`;
+    for (const field of RECEIVE_TOKEN_FIELDS[operationType] ?? []) {
+        const v = data[field];
+        if (v && typeof v === "object" && typeof v.token_type === "string" && v.token_type !== objectTokenType) {
+            result.errors.push(mismatchMsg(v.token_type, `field '${field}.token_type'`));
+        }
+    }
+    for (const path of COIN_PARAM_FIELDS[operationType] ?? []) {
+        const coinParam = getNestedValue(data, path);
+        if (coinParam && typeof coinParam === "object" && typeof coinParam.coin === "string") {
+            const coinRef = coinParam.coin;
+            const resolved = await resolveObjectTokenType(coinRef, network);
+            if (resolved?.tokenType) {
+                if (resolved.tokenType !== objectTokenType) {
+                    result.errors.push(mismatchMsg(resolved.tokenType, `coin '${coinRef}' at '${path}'`));
+                }
+            }
+            else if (resolved === undefined) {
+                result.warnings.push(`Could not resolve coin object '${coinRef}' (${path}) to verify its token type ` +
+                    `matches ${objectTokenType}. The on-chain type check will reject a mismatch at execution.`);
+            }
+        }
+    }
+    return result;
+}
+const OBJECT_MONEY_FIELDS = {
+    Treasury: ["balance", "inflow", "outflow"],
+    Allocation: ["balance"],
+    Arbitration: ["fee", "balance"],
+    Reward: ["balance"],
+    Service: ["compensation_fund"],
+    Payment: ["amount"],
+    Arb: ["fee"],
+};
+export async function annotateObjectMonetaryFields(obj, network) {
+    if (!obj || typeof obj !== "object" || typeof obj.type !== "string")
+        return;
+    let tokenType = extractGenericTokenType(obj.type_raw);
+    const displays = {};
+    const annotate = async (path, raw, tt) => {
+        if (raw === null || raw === undefined)
+            return;
+        if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
+            return;
+        displays[path] = tt
+            ? await formatChainValue(raw, tt, network)
+            : {
+                raw: String(raw),
+                display: String(raw),
+                token_type: "",
+                precision_known: false,
+                text: `${String(raw)} raw smallest units (token type could not be determined for this field — ` +
+                    `no conversion applied. Showing the true raw value; re-run the query to retry resolution.)`,
+            };
+    };
+    if (!tokenType && (obj.type === "Order" || obj.type === "Discount") && typeof obj.service === "string") {
+        try {
+            const svc = await resolveObjectTokenType(obj.service, network);
+            tokenType = svc?.tokenType;
+        }
+        catch {
+        }
+    }
+    for (const field of OBJECT_MONEY_FIELDS[obj.type] ?? []) {
+        await annotate(field, obj[field], tokenType);
+    }
+    switch (obj.type) {
+        case "Service":
+            if (Array.isArray(obj.sales)) {
+                for (let i = 0; i < obj.sales.length; i++) {
+                    await annotate(`sales[${i}].price`, obj.sales[i]?.price, tokenType);
+                }
+            }
+            break;
+        case "Order":
+            await annotate("amount", obj.amount, tokenType);
+            if (Array.isArray(obj.items)) {
+                for (let i = 0; i < obj.items.length; i++) {
+                    await annotate(`items[${i}].price`, obj.items[i]?.price, tokenType);
+                }
+            }
+            break;
+        case "Payment":
+            if (Array.isArray(obj.record)) {
+                for (let i = 0; i < obj.record.length; i++) {
+                    await annotate(`record[${i}].amount`, obj.record[i]?.amount, tokenType);
+                }
+            }
+            break;
+        case "Reward":
+            if (Array.isArray(obj.guards)) {
+                for (let i = 0; i < obj.guards.length; i++) {
+                    const amount = obj.guards[i]?.amount;
+                    if (amount && typeof amount === "object" && amount.type === 1) {
+                        await annotate(`guards[${i}].amount.value`, amount.value, tokenType);
+                    }
+                }
+            }
+            break;
+        case "Arb":
+            await annotate("indemnity.amount", obj.indemnity?.amount, tokenType);
+            break;
+        case "Discount":
+            await annotate("benchmark", obj.benchmark, tokenType);
+            if (obj.discount_type === 1) {
+                await annotate("off", obj.off, tokenType);
+            }
+            break;
+    }
+    if (Object.keys(displays).length > 0) {
+        obj._money_display = displays;
+    }
+}
+const TABLE_ITEM_MONEY_FIELDS = {
+    TableItem_TreasuryHistory: ["amount"],
+    TableItem_RewardRecord: ["total"],
+};
+export async function resolveParentObjectTokenType(parentRef, network) {
+    const res = await resolveObjectTokenType(parentRef, network);
+    if (!res)
+        return undefined;
+    if (res.objectType && TOKEN_GENERIC_OBJECT_TYPES.includes(res.objectType)) {
+        return res.tokenType;
+    }
+    return undefined;
+}
+export async function annotateTableItemMonetaryFields(item, parentTokenType, network) {
+    if (!item || typeof item !== "object" || typeof item.type !== "string")
+        return;
+    const displays = {};
+    const annotate = async (path, raw) => {
+        if (raw === null || raw === undefined)
+            return;
+        if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
+            return;
+        displays[path] = parentTokenType
+            ? await formatChainValue(raw, parentTokenType, network)
+            : {
+                raw: String(raw),
+                display: String(raw),
+                token_type: "",
+                precision_known: false,
+                text: `${String(raw)} raw smallest units (parent object token type could not ` +
+                    `be resolved — no conversion applied)`,
+            };
+    };
+    for (const field of TABLE_ITEM_MONEY_FIELDS[item.type] ?? []) {
+        await annotate(field, item[field]);
+    }
+    if (item.type === "TableItem_RewardRecord" && Array.isArray(item.record)) {
+        for (let i = 0; i < item.record.length; i++) {
+            await annotate(`record[${i}].amount`, item.record[i]?.amount);
+        }
+    }
+    if (Object.keys(displays).length > 0) {
+        item._money_display = displays;
+    }
+}
+export async function annotateEventMonetaryFields(event, network) {
+    if (!event || typeof event !== "object")
+        return;
+    if (event.type !== "NewOrderEvent")
+        return;
+    const raw = event.amount;
+    if (raw === null || raw === undefined)
+        return;
+    if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
+        return;
+    let tokenType;
+    if (typeof event.service === "string" && event.service) {
+        try {
+            tokenType = (await resolveObjectTokenType(event.service, network))?.tokenType;
+        }
+        catch {
+        }
+    }
+    event._money_display = {
+        amount: tokenType
+            ? await formatChainValue(raw, tokenType, network)
+            : {
+                raw: String(raw),
+                display: String(raw),
+                token_type: "",
+                precision_known: false,
+                text: `${String(raw)} raw smallest units (order's Service token type could not be ` +
+                    `resolved — showing the true raw value; re-run the query to retry.)`,
+            },
+    };
+}
+export async function annotateEventsMonetaryFields(events, network) {
+    if (!Array.isArray(events))
+        return;
+    for (const ev of events) {
+        try {
+            await annotateEventMonetaryFields(ev, network);
+        }
+        catch {
+        }
+    }
+}
+export async function annotateBalanceChanges(changes, network) {
+    if (!Array.isArray(changes))
+        return;
+    for (const change of changes) {
+        try {
+            const coinType = change?.coin_type;
+            const raw = change?.amount;
+            if (typeof coinType !== "string" || !coinType)
+                continue;
+            if (typeof raw !== "string" && typeof raw !== "number" && typeof raw !== "bigint")
+                continue;
+            change._money_display = {
+                amount: await formatChainValue(raw, coinType, network),
+            };
+        }
+        catch {
+        }
+    }
+}
+export async function prepareFundOperation(data, operationType, network) {
+    const objectTokenType = await resolveOperationObjectTokenType(data, operationType, network);
+    const match = await validateOperationTokenMatch(data, operationType, objectTokenType, network);
+    const processed = await processFundOperation(data, operationType, network, { objectTokenType });
+    return {
+        ...processed,
+        warnings: [...match.warnings, ...processed.warnings],
+        matchErrors: match.errors,
+        blockingErrors: [...match.errors, ...processed.errors],
+        objectTokenType,
+    };
+}

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

@@ -34,5 +34,15 @@ export declare function validateTemplateParams(templateId: string, params: Recor
     valid: boolean;
     missing: string[];
 };
+export type FillGuardTemplateResult = {
+    ok: true;
+    table: unknown;
+    root: unknown;
+} | {
+    ok: false;
+    error: string;
+    missing?: string[];
+};
+export declare function fillGuardTemplate(templateId: string, params: Record<string, unknown>): FillGuardTemplateResult;
 export declare const GUARD_TEMPLATES_VERSION = "1.0.0";
 export declare const GUARD_TEMPLATES_COUNT: number;