@ouronet/ouronet-core 4.3.6

package/dist/interactions/dexCollectablesFunctions.js

@@ -0,0 +1,227 @@
+/**
+ * dexCollectablesFunctions.ts
+ * Collectables (Semi + Non Fungibles) entity reads — header, entries, nonce data, sets, filters, button state.
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+import { parseNonceData } from "./dexParseFunctions.js";
+export async function getCollectablesHeader(account) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0021_CollectablesHeader "${account}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0021_CollectablesHeader failed:", err);
+        return null;
+    }
+}
+export async function getSemifungibleEntries(account, dpdcIds) {
+    try {
+        const idList = `[${dpdcIds.map(id => `"${id}"`).join(" ")}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0022a_SemifungibleEntryMapper "${account}" ${idList})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return dpdcIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return dpdcIds.map(() => null);
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0022a_SemifungibleEntryMapper failed:", err);
+        return dpdcIds.map(() => null);
+    }
+}
+export async function getNonfungibleEntries(account, dpdcIds) {
+    try {
+        const idList = `[${dpdcIds.map(id => `"${id}"`).join(" ")}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0022a_NonfungibleEntryMapper "${account}" ${idList})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return dpdcIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return dpdcIds.map(() => null);
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0022a_NonfungibleEntryMapper failed:", err);
+        return dpdcIds.map(() => null);
+    }
+}
+export async function getCollectableNonceData(dpdcId, isSFT, nonces) {
+    if (nonces.length === 0)
+        return [];
+    const nonceList = nonces.join(" ");
+    const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0023_CollectablesNonceData "${dpdcId}" ${isSFT} [${nonceList}])`;
+    try {
+        const response = await pactRead(pactCode, { tier: "T5" });
+        const data = response?.result?.data;
+        if (Array.isArray(data))
+            return data.map(parseNonceData);
+        return [];
+    }
+    catch (e) {
+        getLogger().error("URC_0023 fetch error:", e);
+        return [];
+    }
+}
+export async function getCollectableNonceSupply(dpdcId, isSFT, nonce) {
+    const pactCode = `(${KADENA_NAMESPACE}.DPDC.UR_NonceSupply "${dpdcId}" ${isSFT} ${nonce})`;
+    try {
+        const response = await pactRead(pactCode, { tier: "T5" });
+        const data = response?.result?.data;
+        if (typeof data === "number")
+            return data;
+        if (typeof data === "object" && data !== null) {
+            if ("decimal" in data)
+                return parseFloat(data.decimal) || 0;
+            if ("int" in data)
+                return parseFloat(data.int) || 0;
+        }
+        return 0;
+    }
+    catch (e) {
+        getLogger().error("UR_NonceSupply fetch error:", e);
+        return 0;
+    }
+}
+/**
+ * Batched per-account per-nonce supplies (DPDC.UR_AccountNoncesSupplies).
+ * Replaces the per-nonce UR_NonceSupply loop with a single read for N nonces.
+ */
+export async function getAccountNoncesSupplies(account, dpdcId, isSFT, nonces) {
+    if (nonces.length === 0)
+        return [];
+    try {
+        const nonceList = nonces.join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPDC.UR_AccountNoncesSupplies "${account}" "${dpdcId}" ${isSFT} [${nonceList}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return nonces.map(() => 0);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return nonces.map(() => 0);
+        return data.map((n) => {
+            if (typeof n === "number")
+                return n;
+            if (typeof n === "object" && n !== null) {
+                if ("decimal" in n)
+                    return parseFloat(n.decimal) || 0;
+                if ("int" in n)
+                    return parseFloat(n.int) || 0;
+            }
+            return parseFloat(String(n)) || 0;
+        });
+    }
+    catch (err) {
+        getLogger().error("DPDC.UR_AccountNoncesSupplies failed:", err);
+        return nonces.map(() => 0);
+    }
+}
+export async function getCollectableSets(dpdcId, isSFT) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0024_SetReader "${dpdcId}" ${isSFT})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return [];
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return [];
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0024_SetReader failed:", err);
+        return [];
+    }
+}
+/**
+ * Filter wallet nonces by nonce class for composite set positions.
+ * Returns only the nonces that match the given class.
+ */
+export async function filterNoncesByClass(dpdcId, isSFT, nonces, nonceClass) {
+    if (nonces.length === 0)
+        return [];
+    try {
+        const nonceList = `[${nonces.join(" ")}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0025_FilterNoncesByClass "${dpdcId}" ${isSFT} ${nonceList} ${nonceClass})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return [];
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return [];
+        return data.map((n) => {
+            if (typeof n === "number")
+                return n;
+            if (typeof n === "object" && n !== null && "int" in n)
+                return n.int;
+            return parseInt(String(n), 10) || 0;
+        }).filter((n) => n > 0);
+    }
+    catch (err) {
+        getLogger().error("URC_0025_FilterNoncesByClass failed:", err);
+        return [];
+    }
+}
+/**
+ * Batched filter-nonces-by-classes (URC_0025a_FilterNoncesByClasses).
+ * One network call returns one filtered nonce list per class, in order.
+ * Replaces N per-position calls to filterNoncesByClass.
+ */
+export async function filterNoncesByClasses(dpdcId, isSFT, nonces, nonceClasses) {
+    if (nonceClasses.length === 0)
+        return [];
+    if (nonces.length === 0)
+        return nonceClasses.map(() => []);
+    try {
+        const nonceList = `[${nonces.join(" ")}]`;
+        const classList = `[${nonceClasses.join(" ")}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0025a_FilterNoncesByClasses "${dpdcId}" ${isSFT} ${nonceList} ${classList})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return nonceClasses.map(() => []);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return nonceClasses.map(() => []);
+        return data.map((row) => {
+            if (!Array.isArray(row))
+                return [];
+            return row.map((n) => {
+                if (typeof n === "number")
+                    return n;
+                if (typeof n === "object" && n !== null && "int" in n)
+                    return n.int;
+                return parseInt(String(n), 10) || 0;
+            }).filter((n) => n > 0);
+        });
+    }
+    catch (err) {
+        getLogger().error("URC_0025a_FilterNoncesByClasses failed:", err);
+        return nonceClasses.map(() => []);
+    }
+}
+export async function getCollectablesButtonState(account, dpdcId, isSFT, selectedNonces) {
+    try {
+        const nonceList = `[${selectedNonces.join(" ")}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0026_CollectablesButtons "${account}" "${dpdcId}" ${isSFT} ${nonceList})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0026_CollectablesButtons failed:", err);
+        return null;
+    }
+}

package/dist/interactions/dexFunctions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * dexFunctions.ts
+ *
+ * Thin re-export shim for backward compat (Phase 1 of v4.2.0).
+ *
+ * The original 2663-line god file was split along Ouronet's locked seven-entity
+ * taxonomy. Real logic now lives in entity-oriented files: dexSwapPair*Functions
+ * (calc, execute, smart-swap, dashboard, admin), dexTrueFungibleFunctions,
+ * dexOrtoFungibleFunctions, dexCollectablesFunctions, dexAcquisitionPoolFunctions,
+ * dexParseFunctions, dexTypes. Every original symbol is reachable via this shim.
+ */
+export * from "./dexTypes.js";
+export * from "./dexParseFunctions.js";
+export * from "./dexSwapPairCalcFunctions.js";
+export * from "./dexSwapPairExecuteFunctions.js";
+export * from "./dexSwapPairSmartSwapFunctions.js";
+export * from "./dexSwapPairDashboardFunctions.js";
+export * from "./dexSwapPairAdminFunctions.js";
+export * from "./dexTrueFungibleFunctions.js";
+export * from "./dexOrtoFungibleFunctions.js";
+export * from "./dexCollectablesFunctions.js";
+export * from "./dexAcquisitionPoolFunctions.js";
+export * from "./addLiquidityFunctions.js";

package/dist/interactions/dexFunctions.js

@@ -0,0 +1,23 @@
+/**
+ * dexFunctions.ts
+ *
+ * Thin re-export shim for backward compat (Phase 1 of v4.2.0).
+ *
+ * The original 2663-line god file was split along Ouronet's locked seven-entity
+ * taxonomy. Real logic now lives in entity-oriented files: dexSwapPair*Functions
+ * (calc, execute, smart-swap, dashboard, admin), dexTrueFungibleFunctions,
+ * dexOrtoFungibleFunctions, dexCollectablesFunctions, dexAcquisitionPoolFunctions,
+ * dexParseFunctions, dexTypes. Every original symbol is reachable via this shim.
+ */
+export * from "./dexTypes.js";
+export * from "./dexParseFunctions.js";
+export * from "./dexSwapPairCalcFunctions.js";
+export * from "./dexSwapPairExecuteFunctions.js";
+export * from "./dexSwapPairSmartSwapFunctions.js";
+export * from "./dexSwapPairDashboardFunctions.js";
+export * from "./dexSwapPairAdminFunctions.js";
+export * from "./dexTrueFungibleFunctions.js";
+export * from "./dexOrtoFungibleFunctions.js";
+export * from "./dexCollectablesFunctions.js";
+export * from "./dexAcquisitionPoolFunctions.js";
+export * from "./addLiquidityFunctions.js";

package/dist/interactions/dexOrtoFungibleFunctions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * dexOrtoFungibleFunctions.ts
+ * Orto Fungible (OF) entity reads — header, entries, sleeping-LP, nonces supplies/metadata, button state, hibernating.
+ */
+import type { OrtoFungibleHeaderData, OrtoFungibleEntryData, OrtofungibleButtonState, HibernatingNonceData } from "./dexTypes.js";
+/**
+ * Fetch Orto Fungible header data for an account.
+ * Returns global OF count + nonces, held OF list/count, managed OF list/count.
+ */
+export declare function getOrtoFungibleHeader(account: string): Promise<OrtoFungibleHeaderData | null>;
+/**
+ * Batch-fetch OrtoFungibleEntry data for Native/Vesting/Sleeping/Hibernating tokens.
+ * Uses URC_0009a_OrtoFungibleEntryMapper(account, dpofs:[string])
+ */
+export declare function getOrtoFungibleEntries(account: string, tokenIds: string[]): Promise<(OrtoFungibleEntryData | null)[]>;
+/**
+ * Batch-fetch Sleeping LP Orto Fungible data.
+ * Uses URC_0009b_OrtoFungibleSleepingLPMapper(account, lp-ids:[string])
+ */
+export declare function getOrtoFungibleSleepingLPEntries(account: string, lpIds: string[]): Promise<(OrtoFungibleEntryData | null)[]>;
+/**
+ * Fetch supplies for specific nonces of an Orto Fungible.
+ * Returns a list of decimal strings (one per nonce, in order).
+ */
+export declare function getOrtoFungibleNoncesSupplies(dpofId: string, nonces: number[]): Promise<string[]>;
+/**
+ * Fetch metadata for specific nonces of an Orto Fungible.
+ * Returns array of metadata objects (one per nonce).
+ * Each nonce's metadata is itself an array of objects [object].
+ */
+export declare function getOrtoFungibleNoncesMetaDatas(dpofId: string, nonces: number[]): Promise<(any[] | null)[]>;
+export declare function getOrtofungibleButtonState(account: string, dpofId: string, selectedNonces: number[]): Promise<OrtofungibleButtonState | null>;
+export declare function getHibernatingNonceData(dpofId: string, nonce: number): Promise<HibernatingNonceData | null>;

package/dist/interactions/dexOrtoFungibleFunctions.js

@@ -0,0 +1,171 @@
+/**
+ * dexOrtoFungibleFunctions.ts
+ * Orto Fungible (OF) entity reads — header, entries, sleeping-LP, nonces supplies/metadata, button state, hibernating.
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+/**
+ * Fetch Orto Fungible header data for an account.
+ * Returns global OF count + nonces, held OF list/count, managed OF list/count.
+ */
+export async function getOrtoFungibleHeader(account) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0018_OrtofungibleHeader "${account}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0018_OrtofungibleHeader failed:", err);
+        return null;
+    }
+}
+/**
+ * Batch-fetch OrtoFungibleEntry data for Native/Vesting/Sleeping/Hibernating tokens.
+ * Uses URC_0009a_OrtoFungibleEntryMapper(account, dpofs:[string])
+ */
+export async function getOrtoFungibleEntries(account, tokenIds) {
+    if (tokenIds.length === 0)
+        return [];
+    try {
+        const listItems = tokenIds.map(id => `"${id}"`).join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0009a_OrtoFungibleEntryMapper "${account}" [${listItems}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return tokenIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return tokenIds.map(() => null);
+        return data.map((item) => {
+            if (!item || typeof item !== "object" || item === false)
+                return null;
+            return item;
+        });
+    }
+    catch (err) {
+        getLogger().error("URC_0009a_OrtoFungibleEntryMapper failed:", err);
+        return tokenIds.map(() => null);
+    }
+}
+/**
+ * Batch-fetch Sleeping LP Orto Fungible data.
+ * Uses URC_0009b_OrtoFungibleSleepingLPMapper(account, lp-ids:[string])
+ */
+export async function getOrtoFungibleSleepingLPEntries(account, lpIds) {
+    if (lpIds.length === 0)
+        return [];
+    try {
+        const listItems = lpIds.map(id => `"${id}"`).join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0009b_OrtoFungibleSleepingLPMapper "${account}" [${listItems}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return lpIds.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return lpIds.map(() => null);
+        return data.map((item) => {
+            if (!item || typeof item !== "object" || item === false)
+                return null;
+            return item;
+        });
+    }
+    catch (err) {
+        getLogger().error("URC_0009b_OrtoFungibleSleepingLPMapper failed:", err);
+        return lpIds.map(() => null);
+    }
+}
+/**
+ * Fetch supplies for specific nonces of an Orto Fungible.
+ * Returns a list of decimal strings (one per nonce, in order).
+ */
+export async function getOrtoFungibleNoncesSupplies(dpofId, nonces) {
+    if (nonces.length === 0)
+        return [];
+    try {
+        const nonceList = nonces.join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPOF.UR_NoncesSupplies "${dpofId}" [${nonceList}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return nonces.map(() => "0");
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return nonces.map(() => "0");
+        return data.map((item) => {
+            if (item === null || item === undefined)
+                return "0";
+            if (typeof item === "object" && "decimal" in item)
+                return String(item.decimal);
+            return String(item);
+        });
+    }
+    catch (err) {
+        getLogger().error("DPOF.UR_NoncesSupplies failed:", err);
+        return nonces.map(() => "0");
+    }
+}
+/**
+ * Fetch metadata for specific nonces of an Orto Fungible.
+ * Returns array of metadata objects (one per nonce).
+ * Each nonce's metadata is itself an array of objects [object].
+ */
+export async function getOrtoFungibleNoncesMetaDatas(dpofId, nonces) {
+    if (nonces.length === 0)
+        return [];
+    try {
+        const nonceList = nonces.join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.DPOF.UR_NoncesMetaDatas "${dpofId}" [${nonceList}])`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return nonces.map(() => null);
+        const data = response.result.data;
+        if (!Array.isArray(data))
+            return nonces.map(() => null);
+        return data.map((item) => {
+            if (!item || !Array.isArray(item))
+                return item ? [item] : null;
+            return item;
+        });
+    }
+    catch (err) {
+        getLogger().error("DPOF.UR_NoncesMetaDatas failed:", err);
+        return nonces.map(() => null);
+    }
+}
+export async function getOrtofungibleButtonState(account, dpofId, selectedNonces) {
+    try {
+        const nonceList = `[${selectedNonces.join(" ")}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0019_OrtofungibleButton "${account}" "${dpofId}" ${nonceList})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0019_OrtofungibleButton failed:", err);
+        return null;
+    }
+}
+export async function getHibernatingNonceData(dpofId, nonce) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0020_HibernatingNonceData "${dpofId}" ${nonce})`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response?.result || response.result.status === "failure")
+            return null;
+        const data = response.result.data;
+        if (!data || typeof data !== "object")
+            return null;
+        return data;
+    }
+    catch (err) {
+        getLogger().error("URC_0020_HibernatingNonceData failed:", err);
+        return null;
+    }
+}

package/dist/interactions/dexParseFunctions.d.ts

@@ -0,0 +1,150 @@
+/**
+ * dexParseFunctions.ts
+ * Pact response parsers and formatters for dex entities (cross-cutting helpers).
+ */
+import type { DecimalValue, SwapPoolData, PoolPreviewData, SwapLiquidityProviderItem, SwapLiquidityProviderItemPrecise, TrueFungibleLPEntry, TrueFungibleEntryData, OrtoFungibleEntryData, OrtoFungibleCategory, NonceData } from "./dexTypes.js";
+export declare function parseSwapAmount(amountString: string): number;
+/**
+ * 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 declare function parseSwapAmountPrecise(amountString: string): string;
+export declare function parseSwapLiquidityProviders(providers: string[]): number;
+export declare function parseSwapLiquidityProvidersDetailed(providers: string[]): SwapLiquidityProviderItem[];
+/**
+ * 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 declare function parseSwapLiquidityProvidersDetailedPrecise(providers: string[]): SwapLiquidityProviderItemPrecise[];
+/**
+ * Parse decimal string to number for display
+ */
+export declare function parseDecimalValue(decimalValue: DecimalValue): number;
+/**
+ * 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 declare function parseDecimalValuePrecise(decimalValue: DecimalValue): string;
+/**
+ * Format pool type for display
+ */
+export declare function formatPoolType(poolType: string, poolTypeWord: string): string;
+/**
+ * Get total pool value in USD from a pool
+ */
+export declare function getPoolValueUSD(pool: SwapPoolData): string;
+/**
+ * Get pool tokens summary
+ */
+export declare function getPoolTokensSummary(pool: SwapPoolData): {
+    tokens: readonly string[];
+    supplies: number[];
+    totalTokens: number;
+};
+/**
+ * Calculate total fees for pool
+ */
+export declare function getPoolFeeStructure(pool: SwapPoolData): {
+    liquidFee: number;
+    lpFee: number;
+    specialFee: number;
+    totalFee: number;
+};
+/**
+ * Get special fee targets with proportions
+ */
+export declare function getSpecialFeeTargets(pool: SwapPoolData): {
+    targets: readonly string[];
+    shortTargets: readonly string[];
+    proportions: readonly number[];
+};
+/**
+ * Get formatted pool values from enhanced preview data
+ */
+export declare function getFormattedPoolValues(pool: PoolPreviewData): {
+    formattedPoolValue: string;
+    formattedLpSupply: string;
+    formattedLpValue: string;
+    formattedTokenSupplies: readonly string[];
+};
+/**
+ * Get pool weights and calculate percentages
+ */
+export declare function getPoolWeights(pool: PoolPreviewData): {
+    weights: readonly number[];
+    weightPercentages: string[];
+    isBalanced: boolean;
+};
+/**
+ * Calculate pool composition data for charts/visualizations
+ */
+export declare function getPoolComposition(pool: PoolPreviewData): {
+    tokens: readonly string[];
+    supplies: number[];
+    weights: readonly number[];
+    compositions: Array<{
+        token: string;
+        supply: number;
+        weight: number;
+        percentage: string;
+        formattedSupply: string;
+    }>;
+};
+export declare function formatLPEntry(entry: TrueFungibleLPEntry): {
+    name: string;
+    tokenId: string;
+    walletSupply: string;
+    totalSupply: string;
+    walletStoa: string;
+    walletUsd: string;
+    tokenStoa: string;
+    tokenUsd: string;
+};
+/**
+ * Format a TrueFungibleEntry response into display-ready values.
+ */
+export declare function formatTFEntry(entry: TrueFungibleEntryData): {
+    name: string;
+    tokenId: string;
+    walletSupply: string;
+    totalSupply: string;
+    walletStoa: string;
+    walletUsd: string;
+    tokenStoa: string;
+    tokenUsd: string;
+};
+/**
+ * Format an OrtoFungibleEntryData into display-ready values.
+ * Same as formatTFEntry but includes wallet-nonces.
+ */
+export declare function formatOFEntry(entry: OrtoFungibleEntryData): {
+    name: string;
+    tokenId: string;
+    walletSupply: string;
+    totalSupply: string;
+    walletStoa: string;
+    walletUsd: string;
+    tokenStoa: string;
+    tokenUsd: string;
+    walletNonces: number[];
+    walletNoncesNo: number;
+};
+/**
+ * Classify a token ID into its category based on prefix.
+ * Returns: "lp" | "frozen-lp" | "frozen" | "reserved" | "native"
+ */
+export declare function classifyTokenId(tokenId: string): "lp" | "frozen-lp" | "frozen" | "reserved" | "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 declare function classifyOrtoFungibleId(tokenId: string): OrtoFungibleCategory;
+export declare function parseNonceData(raw: any): NonceData;