@ouronet/ouronet-core 4.3.6

package/dist/interactions/dexParseFunctions.js

@@ -0,0 +1,316 @@
+/**
+ * dexParseFunctions.ts
+ * Pact response parsers and formatters for dex entities (cross-cutting helpers).
+ */
+// Utility functions to parse swap calculation results
+export function parseSwapAmount(amountString) {
+    // Extract number from strings like "WSTOA-8Nh-JO8JO4F5 Output: 28.633136871920000000000000"
+    const match = amountString.match(/:\s*([0-9.]+)/);
+    return match ? parseFloat(match[1]) : 0;
+}
+/**
+ * Parse swap amount as string to preserve full decimal precision
+ * @param amountString - String like "WSTOA-8Nh-JO8JO4F5 Output: 28.633136871920000000000000"
+ * @returns The numeric value as a string with full precision
+ */
+export function parseSwapAmountPrecise(amountString) {
+    const match = amountString.match(/:\s*([0-9.]+)/);
+    return match ? match[1] : "0";
+}
+export function parseSwapLiquidityProviders(providers) {
+    // Sum all liquidity provider fees from array like:
+    // ["SSTOA-8Nh-JO8JO4F5 from Input to Liquidity Providers: 0.0000829749299355716637", "OURO-8Nh-JO8JO4F5 from Input to Liquidity Providers: 0.26312828657714566275"]
+    return providers.reduce((total, providerString) => {
+        const amount = parseSwapAmount(providerString);
+        return total + amount;
+    }, 0);
+}
+export function parseSwapLiquidityProvidersDetailed(providers) {
+    // Parse individual liquidity provider fees from array like:
+    return providers.map((providerString) => {
+        const amount = parseSwapAmount(providerString);
+        // Extract token name from the beginning of the string (e.g., "SSTOA" from "SSTOA-8Nh-JO8JO4F5")
+        const tokenMatch = providerString.match(/^([A-Z]+)/);
+        const token = tokenMatch ? tokenMatch[1] : 'Unknown';
+        return {
+            token,
+            amount
+        };
+    });
+}
+/**
+ * Parse liquidity provider fees with full precision
+ * @param providers - Array of provider strings from API
+ * @returns Array of {token, amount} with amount as string for full precision
+ */
+export function parseSwapLiquidityProvidersDetailedPrecise(providers) {
+    return providers.map((providerString) => {
+        const amount = parseSwapAmountPrecise(providerString);
+        const tokenMatch = providerString.match(/^([A-Z]+)/);
+        const token = tokenMatch ? tokenMatch[1] : 'Unknown';
+        return {
+            token,
+            amount
+        };
+    });
+}
+/**
+ * Parse decimal string to number for display
+ */
+export function parseDecimalValue(decimalValue) {
+    return parseFloat(decimalValue.decimal);
+}
+/**
+ * Parse decimal value as string to preserve full precision
+ * @param decimalValue - DecimalValue object with decimal string
+ * @returns The decimal value as a string with full precision
+ */
+export function parseDecimalValuePrecise(decimalValue) {
+    return decimalValue.decimal;
+}
+/**
+ * Format pool type for display
+ */
+export function formatPoolType(poolType, poolTypeWord) {
+    return `${poolType} (${poolTypeWord})`;
+}
+/**
+ * Get total pool value in USD from a pool
+ */
+export function getPoolValueUSD(pool) {
+    return pool["tvl-in-$"];
+}
+/**
+ * Get pool tokens summary
+ */
+export function getPoolTokensSummary(pool) {
+    return {
+        tokens: pool["pool-tokens"],
+        supplies: pool["pool-token-supplies"].map(parseDecimalValue),
+        totalTokens: pool["pool-tokens"].length,
+    };
+}
+/**
+ * Calculate total fees for pool
+ */
+export function getPoolFeeStructure(pool) {
+    return {
+        liquidFee: pool["liquid-fee"],
+        lpFee: pool["lp-fee"],
+        specialFee: pool["special-fee"],
+        totalFee: pool["total-fee"],
+    };
+}
+/**
+ * Get special fee targets with proportions
+ */
+export function getSpecialFeeTargets(pool) {
+    return {
+        targets: pool["special-fee-targets"],
+        shortTargets: pool["special-fee-targets-short"],
+        proportions: pool["special-fee-targets-proportions"],
+    };
+}
+/**
+ * Get formatted pool values from enhanced preview data
+ */
+export function getFormattedPoolValues(pool) {
+    return {
+        formattedPoolValue: pool["ft-pool-value-in-dwk"],
+        formattedLpSupply: pool["ft-lp-supply"],
+        formattedLpValue: pool["ft-lp-value-in-dwk"],
+        formattedTokenSupplies: pool["ft-pool-token-supplies"],
+    };
+}
+/**
+ * Get pool weights and calculate percentages
+ */
+export function getPoolWeights(pool) {
+    const weights = pool["weigths"]; // Note: API has typo "weigths"
+    const percentages = weights.map(w => `${(w * 100).toFixed(1)}%`);
+    const isBalanced = weights.every(w => Math.abs(w - weights[0]) < 0.01);
+    return {
+        weights,
+        weightPercentages: percentages,
+        isBalanced,
+    };
+}
+/**
+ * Calculate pool composition data for charts/visualizations
+ */
+export function getPoolComposition(pool) {
+    const tokens = pool["pool-tokens"];
+    const supplies = pool["pool-token-supplies"].map(parseDecimalValue);
+    const weights = pool["weigths"];
+    const formattedSupplies = pool["ft-pool-token-supplies"];
+    const compositions = tokens.map((token, index) => ({
+        token: token.split('-')[0], // Clean token name
+        supply: supplies[index],
+        weight: weights[index],
+        percentage: `${(weights[index] * 100).toFixed(1)}%`,
+        formattedSupply: formattedSupplies[index],
+    }));
+    return {
+        tokens,
+        supplies,
+        weights,
+        compositions,
+    };
+}
+/**
+ * Local helper to resolve Pact decimal/int values to a numeric string.
+ */
+function parseLPDec(v) {
+    if (v == null)
+        return "0";
+    if (typeof v === "number")
+        return String(v);
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "object" && v !== null && "decimal" in v)
+        return v.decimal;
+    if (typeof v === "object" && v !== null && "int" in v)
+        return String(v.int);
+    return String(v);
+}
+/**
+ * Local helper to resolve Pact int/number values to JS number.
+ */
+function parseIntVal(v) {
+    if (v === null || v === undefined)
+        return 0;
+    if (typeof v === "number")
+        return v;
+    if (typeof v === "object" && "int" in v)
+        return v.int;
+    return parseInt(String(v), 10) || 0;
+}
+export function formatLPEntry(entry) {
+    const walletSupply = parseLPDec(entry["wallet-supply"]);
+    const totalSupply = parseLPDec(entry["dptf-supply"]);
+    const walletStoa = parseLPDec(entry["wallet-worth-in-stoa"]);
+    const walletUsd = typeof entry["wallet-worth-in-dollarz"] === "string"
+        ? entry["wallet-worth-in-dollarz"]
+        : parseLPDec(entry["wallet-worth-in-dollarz"]);
+    const tokenStoa = parseLPDec(entry["token-worth-in-stoa"]);
+    const tokenUsd = typeof entry["token-worth-in-dollarz"] === "string"
+        ? entry["token-worth-in-dollarz"]
+        : parseLPDec(entry["token-worth-in-dollarz"]);
+    return { name: entry.t1, tokenId: entry.t2, walletSupply, totalSupply, walletStoa, walletUsd, tokenStoa, tokenUsd };
+}
+/**
+ * Format a TrueFungibleEntry response into display-ready values.
+ */
+export function formatTFEntry(entry) {
+    const walletSupply = parseLPDec(entry["wallet-supply"]);
+    const totalSupply = parseLPDec(entry["dptf-supply"]);
+    const walletStoa = parseLPDec(entry["wallet-worth-in-stoa"]);
+    const walletUsd = typeof entry["wallet-worth-in-dollarz"] === "string"
+        ? entry["wallet-worth-in-dollarz"]
+        : parseLPDec(entry["wallet-worth-in-dollarz"]);
+    const tokenStoa = parseLPDec(entry["token-worth-in-stoa"]);
+    const tokenUsd = typeof entry["token-worth-in-dollarz"] === "string"
+        ? entry["token-worth-in-dollarz"]
+        : parseLPDec(entry["token-worth-in-dollarz"]);
+    return { name: entry.t1, tokenId: entry.t2, walletSupply, totalSupply, walletStoa, walletUsd, tokenStoa, tokenUsd };
+}
+/**
+ * Format an OrtoFungibleEntryData into display-ready values.
+ * Same as formatTFEntry but includes wallet-nonces.
+ */
+export function formatOFEntry(entry) {
+    const walletSupply = parseLPDec(entry["wallet-supply"]);
+    const totalSupply = parseLPDec(entry["dpof-supply"]);
+    const walletStoa = parseLPDec(entry["wallet-worth-in-stoa"]);
+    const walletUsd = typeof entry["wallet-worth-in-dollarz"] === "string"
+        ? entry["wallet-worth-in-dollarz"]
+        : parseLPDec(entry["wallet-worth-in-dollarz"]);
+    const tokenStoa = parseLPDec(entry["token-worth-in-stoa"]);
+    const tokenUsd = typeof entry["token-worth-in-dollarz"] === "string"
+        ? entry["token-worth-in-dollarz"]
+        : parseLPDec(entry["token-worth-in-dollarz"]);
+    // wallet-nonces can be [0, 1, 2] or [{int: 0}, {int: 1}, {int: 2}] from chain
+    const rawNonces = entry["wallet-nonces"] ?? [];
+    const walletNonces = rawNonces.map((n) => parseIntVal(n));
+    const walletNoncesNo = parseIntVal(entry["wallet-nonces-no"]);
+    return { name: entry.t1, tokenId: entry.t2, walletSupply, totalSupply, walletStoa, walletUsd, tokenStoa, tokenUsd, walletNonces, walletNoncesNo };
+}
+/**
+ * Classify a token ID into its category based on prefix.
+ * Returns: "lp" | "frozen-lp" | "frozen" | "reserved" | "native"
+ */
+export function classifyTokenId(tokenId) {
+    // Frozen LP: F|S|, F|W|, F|P|
+    if (/^F\|[SWP]\|/.test(tokenId))
+        return "frozen-lp";
+    // LP: S|, W|, P|
+    if (/^[SWP]\|/.test(tokenId))
+        return "lp";
+    // Frozen: F|
+    if (tokenId.startsWith("F|"))
+        return "frozen";
+    // Reserved: R|
+    if (tokenId.startsWith("R|"))
+        return "reserved";
+    return "native";
+}
+/**
+ * Classify an Orto Fungible token ID into one of 5 categories.
+ *
+ * Sleeping LP: Z|S|, Z|W|, Z|P|
+ * Vesting:     V|
+ * Sleeping:    Z| (but NOT Z|S|, Z|W|, Z|P|)
+ * Hibernating: H|
+ * Native:      everything else
+ */
+export function classifyOrtoFungibleId(tokenId) {
+    // Sleeping LP: Z|S|, Z|W|, Z|P| — must be checked BEFORE sleeping
+    if (/^Z\|[SWP]\|/.test(tokenId))
+        return "sleeping-lp";
+    // Vesting: V|
+    if (tokenId.startsWith("V|"))
+        return "vesting";
+    // Sleeping: Z|
+    if (tokenId.startsWith("Z|"))
+        return "sleeping";
+    // Hibernating: H|
+    if (tokenId.startsWith("H|"))
+        return "hibernating";
+    return "native";
+}
+export function parseNonceData(raw) {
+    const parseURIType = (t) => ({
+        image: !!t?.image, audio: !!t?.audio, video: !!t?.video,
+        document: !!t?.document, archive: !!t?.archive, model: !!t?.model, exotic: !!t?.exotic,
+    });
+    const parseURIData = (d) => ({
+        image: d?.image ?? "", audio: d?.audio ?? "", video: d?.video ?? "",
+        document: d?.document ?? "", archive: d?.archive ?? "", model: d?.model ?? "", exotic: d?.exotic ?? "",
+    });
+    const parseDecNonce = (v) => {
+        if (typeof v === "number")
+            return v;
+        if (typeof v === "object" && v !== null) {
+            if ("decimal" in v)
+                return parseFloat(v.decimal) || 0;
+            if ("int" in v)
+                return parseFloat(v.int) || 0;
+        }
+        return parseFloat(String(v)) || 0;
+    };
+    return {
+        royalty: parseDecNonce(raw?.royalty),
+        ignis: parseDecNonce(raw?.ignis),
+        name: raw?.name ?? "",
+        description: raw?.description ?? "",
+        "meta-data": {
+            score: parseDecNonce(raw?.["meta-data"]?.score),
+            composition: Array.isArray(raw?.["meta-data"]?.composition) ? raw["meta-data"].composition : [],
+            "meta-data": raw?.["meta-data"]?.["meta-data"] ?? {},
+        },
+        "asset-type": parseURIType(raw?.["asset-type"]),
+        "uri-primary": parseURIData(raw?.["uri-primary"]),
+        "uri-secondary": parseURIData(raw?.["uri-secondary"]),
+        "uri-tertiary": parseURIData(raw?.["uri-tertiary"]),
+    };
+}

package/dist/interactions/dexSwapPairAdminFunctions.d.ts

@@ -0,0 +1,75 @@
+/**
+ * dexSwapPairAdminFunctions.ts
+ * Swap pair admin reads — module/principals/limits/management/branding (URC_0014-0015, BRD/DALOS reads).
+ */
+export declare function describeModule(moduleName: string): Promise<string | null>;
+/** Fetch SWP principal tokens list */
+export declare function getSWPPrincipals(): Promise<string[]>;
+/**
+ * Fetch the current owner account of a SWP pair (Ouronet account string).
+ *
+ *   (ouronet-ns.SWP.UR_OwnerKonto <swpair>)
+ *
+ * Lightweight unprotected read — returns just the owner-konto string. Used
+ * by the OuronetUI ChangeOwnership flow to decide which ghost address to
+ * pre-fill in the new-owner field (must differ from the current owner so
+ * the ghost-as-default execution path stays valid).
+ */
+export declare function getSwpairOwnerKonto(swpair: string): Promise<string | null>;
+/**
+ * Fetch the current `can-swap` (UI label "Swapping") flag for a SWP pair.
+ *
+ *   (ouronet-ns.SWP.UR_CanSwap <swpair>)
+ *
+ * Used by the OuronetUI ToggleSwapCapability flow to compute the
+ * autonomous `toggle` argument (chain rejects same-value writes; only
+ * allowed value is the inverse of current).
+ */
+export declare function getSwpairCanSwap(swpair: string): Promise<boolean | null>;
+/**
+ * Fetch the current `can-add` (UI label "Provisioning") flag for a SWP pair.
+ *
+ *   (ouronet-ns.SWP.UR_CanAdd <swpair>)
+ *
+ * Used by the OuronetUI ToggleAddLiquidity flow to compute the autonomous
+ * `toggle` argument (same chain-rejects-same-value-writes constraint as
+ * the other Toggle flows).
+ */
+export declare function getSwpairCanAdd(swpair: string): Promise<boolean | null>;
+/**
+ * Fetch the current `can-change-owner` flag for a SWP pair (boolean).
+ *
+ *   (ouronet-ns.SWP.UR_CanChangeOwner <swpair>)
+ *
+ * Lightweight unprotected read. Used by the OuronetUI ModifyCanChangeOwner
+ * flow to compute the only-allowed `new-boolean` argument (the chain
+ * rejects same-value writes, so `new-boolean` is always the inverse of the
+ * current value — autonomous, never user-typed).
+ */
+export declare function getSwpairCanChangeOwner(swpair: string): Promise<boolean | null>;
+/** Fetch SWP spawn limit (WSTOA minimum to create a pool) */
+export declare function getSWPSpawnLimit(): Promise<string | null>;
+/** Fetch SWP inactive limit (WSTOA below which swap auto-deactivates) */
+export declare function getSWPInactiveLimit(): Promise<string | null>;
+/**
+ * Fetch management pool settings for a specific swap pair
+ * URC_0014_SwpairManagementPoolSettings
+ */
+export declare function getSwpairManagementPoolSettings(swpair: string): Promise<any>;
+/**
+ * URC_0015_SwpairManagementFeeSettings
+ * Returns fee configuration for a SWP pair: lock state, fee breakdown,
+ * special fee targets (up to 7), and max available target slots.
+ */
+export declare function getSwpairManagementFeeSettings(swpair: string): Promise<any>;
+/**
+ * DALOS.UR_UsagePrice — Get the price for a usage type (e.g. "blue" for blue flag branding)
+ * Returns the price in STOA
+ */
+export declare function getUsagePrice(usageType: string): Promise<number | null>;
+/**
+ * BRD.UR_Branding — Fetch branding properties for an entity
+ * @param entityId - SWP pair ID or LP token ID
+ * @param pending - true for pending branding, false for live branding
+ */
+export declare function getBranding(entityId: string, pending: boolean): Promise<any>;

package/dist/interactions/dexSwapPairAdminFunctions.js

@@ -0,0 +1,255 @@
+/**
+ * dexSwapPairAdminFunctions.ts
+ * Swap pair admin reads — module/principals/limits/management/branding (URC_0014-0015, BRD/DALOS reads).
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+export async function describeModule(moduleName) {
+    try {
+        const fqn = moduleName.includes(".") ? moduleName : `${KADENA_NAMESPACE}.${moduleName}`;
+        const response = await pactRead(`(describe-module "${fqn}")`, { tier: "T7" });
+        if (response.result.status === "success") {
+            const data = response.result.data;
+            return data?.code || JSON.stringify(data);
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in describeModule:", error);
+        return null;
+    }
+}
+/** Fetch SWP principal tokens list */
+export async function getSWPPrincipals() {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_Principals)`, { tier: "T7" });
+        if (res.result.status === "failure")
+            return [];
+        return (Array.isArray(res.result.data) ? res.result.data : []);
+    }
+    catch (error) {
+        getLogger().error("Error in getSWPPrincipals:", error);
+        return [];
+    }
+}
+/**
+ * Fetch the current owner account of a SWP pair (Ouronet account string).
+ *
+ *   (ouronet-ns.SWP.UR_OwnerKonto <swpair>)
+ *
+ * Lightweight unprotected read — returns just the owner-konto string. Used
+ * by the OuronetUI ChangeOwnership flow to decide which ghost address to
+ * pre-fill in the new-owner field (must differ from the current owner so
+ * the ghost-as-default execution path stays valid).
+ */
+export async function getSwpairOwnerKonto(swpair) {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_OwnerKonto "${swpair}")`, { tier: "T5" });
+        if (res.result.status === "failure")
+            return null;
+        const d = res.result.data;
+        return d == null ? null : String(d);
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairOwnerKonto:", error);
+        return null;
+    }
+}
+/**
+ * Fetch the current `can-swap` (UI label "Swapping") flag for a SWP pair.
+ *
+ *   (ouronet-ns.SWP.UR_CanSwap <swpair>)
+ *
+ * Used by the OuronetUI ToggleSwapCapability flow to compute the
+ * autonomous `toggle` argument (chain rejects same-value writes; only
+ * allowed value is the inverse of current).
+ */
+export async function getSwpairCanSwap(swpair) {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_CanSwap "${swpair}")`, { tier: "T5" });
+        if (res.result.status === "failure")
+            return null;
+        const d = res.result.data;
+        if (typeof d === "boolean")
+            return d;
+        if (d === "true")
+            return true;
+        if (d === "false")
+            return false;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairCanSwap:", error);
+        return null;
+    }
+}
+/**
+ * Fetch the current `can-add` (UI label "Provisioning") flag for a SWP pair.
+ *
+ *   (ouronet-ns.SWP.UR_CanAdd <swpair>)
+ *
+ * Used by the OuronetUI ToggleAddLiquidity flow to compute the autonomous
+ * `toggle` argument (same chain-rejects-same-value-writes constraint as
+ * the other Toggle flows).
+ */
+export async function getSwpairCanAdd(swpair) {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_CanAdd "${swpair}")`, { tier: "T5" });
+        if (res.result.status === "failure")
+            return null;
+        const d = res.result.data;
+        if (typeof d === "boolean")
+            return d;
+        if (d === "true")
+            return true;
+        if (d === "false")
+            return false;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairCanAdd:", error);
+        return null;
+    }
+}
+/**
+ * Fetch the current `can-change-owner` flag for a SWP pair (boolean).
+ *
+ *   (ouronet-ns.SWP.UR_CanChangeOwner <swpair>)
+ *
+ * Lightweight unprotected read. Used by the OuronetUI ModifyCanChangeOwner
+ * flow to compute the only-allowed `new-boolean` argument (the chain
+ * rejects same-value writes, so `new-boolean` is always the inverse of the
+ * current value — autonomous, never user-typed).
+ */
+export async function getSwpairCanChangeOwner(swpair) {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_CanChangeOwner "${swpair}")`, { tier: "T5" });
+        if (res.result.status === "failure")
+            return null;
+        const d = res.result.data;
+        if (typeof d === "boolean")
+            return d;
+        if (d === "true")
+            return true;
+        if (d === "false")
+            return false;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairCanChangeOwner:", error);
+        return null;
+    }
+}
+/** Fetch SWP spawn limit (WSTOA minimum to create a pool) */
+export async function getSWPSpawnLimit() {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_SpawnLimit)`, { tier: "T7" });
+        if (res.result.status === "failure")
+            return null;
+        const d = res.result.data;
+        return d && typeof d === "object" && d.decimal ? d.decimal : (d != null ? String(d) : null);
+    }
+    catch (error) {
+        getLogger().error("Error in getSWPSpawnLimit:", error);
+        return null;
+    }
+}
+/** Fetch SWP inactive limit (WSTOA below which swap auto-deactivates) */
+export async function getSWPInactiveLimit() {
+    try {
+        const res = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_InactiveLimit)`, { tier: "T7" });
+        if (res.result.status === "failure")
+            return null;
+        const d = res.result.data;
+        return d && typeof d === "object" && d.decimal ? d.decimal : (d != null ? String(d) : null);
+    }
+    catch (error) {
+        getLogger().error("Error in getSWPInactiveLimit:", error);
+        return null;
+    }
+}
+/**
+ * Fetch management pool settings for a specific swap pair
+ * URC_0014_SwpairManagementPoolSettings
+ */
+export async function getSwpairManagementPoolSettings(swpair) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0014_SwpairManagementPoolSettings "${swpair}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve pool settings from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Pool settings query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (err) {
+        getLogger().error("URC_0014 failed:", err);
+        return null;
+    }
+}
+/**
+ * URC_0015_SwpairManagementFeeSettings
+ * Returns fee configuration for a SWP pair: lock state, fee breakdown,
+ * special fee targets (up to 7), and max available target slots.
+ */
+export async function getSwpairManagementFeeSettings(swpair) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0015_SwpairManagementFeeSettings "${swpair}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve fee settings from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Fee settings query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (err) {
+        getLogger().error("URC_0015 failed:", err);
+        return null;
+    }
+}
+/**
+ * DALOS.UR_UsagePrice — Get the price for a usage type (e.g. "blue" for blue flag branding)
+ * Returns the price in STOA
+ */
+export async function getUsagePrice(usageType) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DALOS.UR_UsagePrice "${usageType}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (response?.result?.status === "success") {
+            const d = response.result.data;
+            return typeof d === "number" ? d : (typeof d === "object" && d?.decimal ? parseFloat(d.decimal) : null);
+        }
+        return null;
+    }
+    catch (err) {
+        getLogger().error(`UR_UsagePrice(${usageType}) failed:`, err);
+        return null;
+    }
+}
+/**
+ * BRD.UR_Branding — Fetch branding properties for an entity
+ * @param entityId - SWP pair ID or LP token ID
+ * @param pending - true for pending branding, false for live branding
+ */
+export async function getBranding(entityId, pending) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.BRD.UR_Branding "${entityId}" ${pending})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve branding from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Branding query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (err) {
+        getLogger().error(`BRD.UR_Branding(${entityId}, ${pending}) failed:`, err);
+        return null;
+    }
+}