@ouronet/ouronet-core 4.3.6

package/dist/interactions/ouroCoilFunctions.js

@@ -0,0 +1,190 @@
+/**
+ * ouroCoilFunctions.ts
+ * OURO-specific coil/curl execution + verbatim tail-block re-exports of the broader
+ * coil/pension/info-one preview surface (locked here because the original tail-block
+ * comment "Export new coiling functions for AURYN and WSTOA" places them in the coil domain).
+ */
+import { calculateAutoGasLimit } from "@stoachain/stoa-core/gas";
+import { KADENA_CHAIN_ID, KADENA_NAMESPACE, STOA_AUTONOMIC_OURONETGASSTATION, KADENA_NETWORK, } from "../constants/index.js";
+import { safeCreationTime, formatDecimalForPact } from "@stoachain/stoa-core/pact";
+import { Pact } from "@stoachain/kadena-stoic-legacy/client";
+import { getFailoverClient } from "@stoachain/stoa-core/network";
+import { universalSignTransaction, fromKeypair } from "@stoachain/stoa-core/signing";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+// Get AURYN generation preview for coiling OURO
+export async function getCoilPreview(ouroAmount) {
+    try {
+        const decimalAmount = formatDecimalForPact(ouroAmount);
+        const response = await pactRead(`(${KADENA_NAMESPACE}.INFO-ONE.ATS|INFO_Coil "preview" "preview" "Auryndex-O136CBn22ncY" "OURO-8Nh-JO8JO4F5" ${decimalAmount})`, { tier: "T2" });
+        if (!response || !response.result || response.result.status === "failure") {
+            // v3.3.0 (closes part of F-LOGGER-SEAM-001): routed through getLogger().warn
+            // — failure context is operationally useful, kept at warn-level so
+            // structured-logger consumers (HUB pino, OuronetUI Sentry) capture it.
+            getLogger().warn("Coil preview failed:", response?.result);
+            return null;
+        }
+        const data = response.result.data;
+        // v3.3.0: removed `console.log("Coil preview response data:", data)`
+        // — pure debug-only data dump on the success path, no operational
+        // value beyond developer trace. Matches the F-LOGGER-SEAM-001
+        // validator's "should be removed" classification for debug-leak sites.
+        // Extract AURYN amount from text arrays
+        let aurynAmount = 0;
+        // Check pre-text array for AURYN amount
+        if (data && data['pre-text']) {
+            for (const text of data['pre-text']) {
+                const aurynMatch = text.match(/generates\s+([\d.]+)\s+AURYN/);
+                if (aurynMatch) {
+                    aurynAmount = parseFloat(aurynMatch[1]);
+                    break;
+                }
+            }
+        }
+        // Fallback: check post-text array
+        if (!aurynAmount && data && data['post-text']) {
+            for (const text of data['post-text']) {
+                const aurynMatch = text.match(/generating\s+([\d.]+)\s+AURYN/);
+                if (aurynMatch) {
+                    aurynAmount = parseFloat(aurynMatch[1]);
+                    break;
+                }
+            }
+        }
+        // Return rich data structure
+        return {
+            auryn: aurynAmount,
+            fee: 0,
+            kadenaInfo: {
+                text: data?.kadena?.[`kadena-text`] || "Kadena fee information not available",
+                discount: data?.kadena?.[`kadena-discount`] || 1,
+                full: data?.kadena?.[`kadena-full`] || 0,
+                need: data?.kadena?.[`kadena-need`] || 0,
+            },
+            ignisInfo: {
+                text: data?.ignis?.[`ignis-text`] || "IGNIS fee information not available",
+                discount: data?.ignis?.[`ignis-discount`] || 1,
+                full: data?.ignis?.[`ignis-full`] || 0,
+                need: data?.ignis?.[`ignis-need`] || 0,
+            },
+            preText: data?.[`pre-text`] || [],
+            postText: data?.[`post-text`] || [],
+        };
+    }
+    catch (error) {
+        getLogger().error("Error getting coil preview:", error);
+        return null;
+    }
+}
+// Curl OURO to Elite AURYN
+// (namespace.TS01-C2.ATS|C_Curl patron:string curler:string "Auryndex-O136CBn22ncY" "EliteAuryndex-O136CBn22ncY" "OURO-8Nh-JO8JO4F5" amount:decimal)
+export async function curlOuroToEliteAuryn(ouroAccount, kadenaAccount, guard, targetAccount, // The account that will receive the Elite AURYN (same as patron per client explanation)
+ouroAmount) {
+    const keysetName = `ks`;
+    // Ensure amount is formatted as decimal
+    const decimalAmount = formatDecimalForPact(ouroAmount);
+    let gasLimit = 2000000; // Default gas limit
+    const buildTransaction = (gasLimitOverride) => {
+        return Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.TS01-C2.ATS|C_Curl "${ouroAccount.address}" "${targetAccount}" "Auryndex-O136CBn22ncY" "EliteAuryndex-O136CBn22ncY" "OURO-8Nh-JO8JO4F5" ${decimalAmount})`)
+            .addData(keysetName, {
+            keys: [guard.publicKey],
+            pred: "keys-all",
+        })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimitOverride || gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(kadenaAccount.publicKey, (withCapability) => [
+            withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+        ])
+            .addSigner(guard.publicKey)
+            .createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    // First do a simulation to check gas
+    let transaction = buildTransaction();
+    const simulation = await dirtyRead(transaction);
+    // Check if simulation failed
+    if (simulation.result.status === "failure") {
+        const errorMessage = simulation.result.error?.message || "Transaction simulation failed";
+        throw new Error(`Simulation failed: ${errorMessage}`);
+    }
+    // Check if we need to adjust gas limit
+    const requiredGas = simulation.gas;
+    if (requiredGas && requiredGas > gasLimit) {
+        // Rebuild transaction with adjusted gas limit (20% buffer)
+        gasLimit = calculateAutoGasLimit(requiredGas);
+        transaction = buildTransaction(gasLimit);
+    }
+    // Sign the transaction with both keypairs
+    const signedTransaction = await universalSignTransaction(transaction, [
+        fromKeypair(kadenaAccount),
+        fromKeypair(guard),
+    ]);
+    // Submit the signed transaction
+    const result = await submit(signedTransaction);
+    return result;
+}
+// Export new coiling functions for AURYN and WSTOA
+export { getAurynCoilPreview, coilAurynToElite, getWkdaCoilPreview, coilWkdaToLkda, COIL_CONFIGS } from "./coilFunctions.js";
+// Export pension functions for WSTOA and SSTOA
+export { brumateWkdaToPkda, constrictLkdaToPkda } from "./pensionFunctions.js";
+// Export INFO-ONE preview functions
+export { getTransferPreview, getCoilPreviewInfo, getCurlPreviewInfo, getBrumatePreviewInfo, getConstrictPreviewInfo, parseTransferPreview } from "./infoOneFunctions.js";
+// Coil OURO to AURYN
+// (namespace.TS01-C2.ATS|C_Coil patron:string coiler:string "Auryndex-O136CBn22ncY" "OURO-8Nh-JO8JO4F5" amount:decimal)
+export async function coilOuroToAuryn(ouroAccount, kadenaAccount, guard, targetAccount, // The account that will receive the AURYN
+ouroAmount) {
+    const keysetName = `ks`;
+    // Ensure amount is formatted as decimal
+    const decimalAmount = formatDecimalForPact(ouroAmount);
+    let gasLimit = 2000000; // Default gas limit
+    const buildTransaction = (gasLimitOverride) => {
+        return Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.TS01-C2.ATS|C_Coil "${ouroAccount.address}" "${targetAccount}" "Auryndex-O136CBn22ncY" "OURO-8Nh-JO8JO4F5" ${decimalAmount})`)
+            .addData(keysetName, {
+            keys: [guard.publicKey],
+            pred: "keys-all",
+        })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimitOverride || gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(kadenaAccount.publicKey, (withCapability) => [
+            withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+        ])
+            .addSigner(guard.publicKey)
+            .createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    // First do a simulation to check gas
+    let transaction = buildTransaction();
+    const simulation = await dirtyRead(transaction);
+    // Check if simulation failed
+    if (simulation.result.status === "failure") {
+        const errorMessage = simulation.result.error?.message || "Transaction simulation failed";
+        throw new Error(`Simulation failed: ${errorMessage}`);
+    }
+    // Check if we need to adjust gas limit
+    const requiredGas = simulation.gas;
+    if (requiredGas && requiredGas > gasLimit) {
+        // Rebuild transaction with adjusted gas limit (20% buffer)
+        gasLimit = calculateAutoGasLimit(requiredGas);
+        transaction = buildTransaction(gasLimit);
+    }
+    // Sign the transaction with both keypairs
+    const signedTransaction = await universalSignTransaction(transaction, [
+        fromKeypair(kadenaAccount),
+        fromKeypair(guard),
+    ]);
+    // Submit the signed transaction
+    const result = await submit(signedTransaction);
+    return result;
+}

package/dist/interactions/ouroFunctions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ouroFunctions.ts
+ *
+ * Thin re-export shim for backward compat (Phase 2 of v4.2.0).
+ *
+ * Real logic moved to entity-oriented files: ouroAccountFunctions,
+ * ouroPrimordialsFunctions, ouroSubCompressFunctions, ouroWrapFunctions,
+ * ouroTransferFunctions, ouroMovieBoosterFunctions, ouroCoilFunctions,
+ * ouroBalanceFunctions, ouroRotateFunctions, ouroPriceFunctions,
+ * ouroUrStoaFunctions, ouroTypes.
+ */
+export * from "./ouroTypes.js";
+export * from "./ouroAccountFunctions.js";
+export * from "./ouroPrimordialsFunctions.js";
+export * from "./ouroSubCompressFunctions.js";
+export * from "./ouroWrapFunctions.js";
+export * from "./ouroTransferFunctions.js";
+export * from "./ouroMovieBoosterFunctions.js";
+export * from "./ouroCoilFunctions.js";
+export * from "./ouroBalanceFunctions.js";
+export * from "./ouroRotateFunctions.js";
+export * from "./ouroPriceFunctions.js";
+export * from "./ouroUrStoaFunctions.js";

package/dist/interactions/ouroFunctions.js

@@ -0,0 +1,23 @@
+/**
+ * ouroFunctions.ts
+ *
+ * Thin re-export shim for backward compat (Phase 2 of v4.2.0).
+ *
+ * Real logic moved to entity-oriented files: ouroAccountFunctions,
+ * ouroPrimordialsFunctions, ouroSubCompressFunctions, ouroWrapFunctions,
+ * ouroTransferFunctions, ouroMovieBoosterFunctions, ouroCoilFunctions,
+ * ouroBalanceFunctions, ouroRotateFunctions, ouroPriceFunctions,
+ * ouroUrStoaFunctions, ouroTypes.
+ */
+export * from "./ouroTypes.js";
+export * from "./ouroAccountFunctions.js";
+export * from "./ouroPrimordialsFunctions.js";
+export * from "./ouroSubCompressFunctions.js";
+export * from "./ouroWrapFunctions.js";
+export * from "./ouroTransferFunctions.js";
+export * from "./ouroMovieBoosterFunctions.js";
+export * from "./ouroCoilFunctions.js";
+export * from "./ouroBalanceFunctions.js";
+export * from "./ouroRotateFunctions.js";
+export * from "./ouroPriceFunctions.js";
+export * from "./ouroUrStoaFunctions.js";

package/dist/interactions/ouroMovieBoosterFunctions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ouroMovieBoosterFunctions.ts
+ * Sparks balance / movie-booster purchase / firestarter execution + max-buy probe.
+ */
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+import type { IOuroAccountKeypair } from "./ouroTypes.js";
+export declare function getTotalMBCost(sparks: number): Promise<string | null>;
+export declare function movieBoosterBuy(patronAccount: IOuroAccountKeypair, // The patron account (owner)
+buyerAccount: string, // Buyer Ouro address (usually same as patron)
+mbAmount: number, // Amount of SPARK tokens to buy (integer)
+isNative: boolean, // true for KDA, false for WSTOA
+kadenaAccount: IKadenaKeypair, // The kadena account (payer)
+guardAccount: IKadenaKeypair): Promise<import("@stoachain/kadena-stoic-legacy/client").ITransactionDescriptor>;
+export declare function getMaxBuyMovieBooster(account: string, native: boolean): Promise<number | null>;
+export declare function getSparksBalance(account: string): Promise<any | null>;
+export declare function firestarter(ouroAccount: IOuroAccountKeypair, // Ouro account that will receive the IGNIS
+kadenaAccount: IKadenaKeypair, // The kadena account that will transfer KDA
+guardAccount: IKadenaKeypair): Promise<import("@stoachain/kadena-stoic-legacy/client").ITransactionDescriptor>;

package/dist/interactions/ouroMovieBoosterFunctions.js

@@ -0,0 +1,203 @@
+/**
+ * ouroMovieBoosterFunctions.ts
+ * Sparks balance / movie-booster purchase / firestarter execution + max-buy probe.
+ */
+import { calculateAutoGasLimit } from "@stoachain/stoa-core/gas";
+import { KADENA_CHAIN_ID, KADENA_NAMESPACE, STOA_AUTONOMIC_OURONETGASSTATION, KADENA_NETWORK, } from "../constants/index.js";
+import { safeCreationTime } from "@stoachain/stoa-core/pact";
+import { Pact } from "@stoachain/kadena-stoic-legacy/client";
+import { getFailoverClient } from "@stoachain/stoa-core/network";
+import { universalSignTransaction, fromKeypair } from "@stoachain/stoa-core/signing";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+// (ouronet-ns.MB.URC_TotalMBCost sparks)
+export async function getTotalMBCost(sparks) {
+    try {
+        const integerSparks = Math.floor(sparks);
+        const response = await pactRead(`(${KADENA_NAMESPACE}.MB.URC_TotalMBCost ${integerSparks})`, { tier: "T5" });
+        if (!response || !response.result || response.result.status === "failure") {
+            return null;
+        }
+        return response.result.data;
+    }
+    catch (error) {
+        getLogger().error("Error getting total MB cost:", error);
+        return null;
+    }
+}
+// (ouronet-ns.MB.C_MovieBoosterBuyer patron:string buyer:string mb-amount:integer iz-native:bool)
+export async function movieBoosterBuy(patronAccount, // The patron account (owner)
+buyerAccount, // Buyer Ouro address (usually same as patron)
+mbAmount, // Amount of SPARK tokens to buy (integer)
+isNative, // true for KDA, false for WSTOA
+kadenaAccount, // The kadena account (payer)
+guardAccount // The guard account from the Ouro account
+) {
+    const keysetName = `ks`;
+    // Ensure amount is integer
+    const integerAmount = Math.floor(mbAmount);
+    const kadenaCost = await getTotalMBCost(integerAmount);
+    let gasLimit = 2000000; // Default gas limit for movie booster buy
+    const buildTransaction = (gasLimitOverride) => {
+        const txBuilder = Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.MB.C_MovieBoosterBuyer "${patronAccount.address}" "${buyerAccount}" ${integerAmount} ${isNative})`)
+            .addData(keysetName, {
+            keys: [guardAccount.publicKey],
+            pred: "keys-all",
+        })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimitOverride || gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(kadenaAccount.publicKey, (withCapability) => {
+            const capabilities = [
+                withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            ];
+            // If paying with native KDA, add coin.TRANSFER capability
+            if (isNative) {
+                // We'll need to calculate the KDA amount based on SPARK price
+                // For now, we'll use a placeholder that will be replaced after simulation
+                capabilities.push(withCapability("coin.TRANSFER", `k:${kadenaAccount.publicKey}`, STOA_AUTONOMIC_OURONETGASSTATION, { decimal: `${kadenaCost}` } // This will be updated after simulation
+                ));
+            }
+            return capabilities;
+        })
+            .addSigner(guardAccount.publicKey);
+        return txBuilder.createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    // First do a simulation to check gas and get the actual KDA amount if native
+    let transaction = buildTransaction();
+    const simulation = await dirtyRead(transaction);
+    // Check if simulation failed
+    if (simulation.result.status === "failure") {
+        const errorMessage = simulation.result.error?.message || "Transaction simulation failed";
+        throw new Error(`Simulation failed: ${errorMessage}`);
+    }
+    if (isNative && simulation.result.data) {
+        if (kadenaCost && parseFloat(kadenaCost) <= 0) {
+            throw new Error("Invalid KDA amount required for purchase");
+        }
+        // Rebuild transaction with correct KDA amount
+        transaction = Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.MB.C_MovieBoosterBuyer "${patronAccount.address}" "${buyerAccount}" ${integerAmount} ${isNative})`)
+            .addData(keysetName, {
+            keys: [guardAccount.publicKey],
+            pred: "keys-all",
+        })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(kadenaAccount.publicKey, (withCapability) => [
+            withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            withCapability("coin.TRANSFER", `k:${kadenaAccount.publicKey}`, STOA_AUTONOMIC_OURONETGASSTATION, { decimal: `${kadenaCost}` }),
+        ])
+            .addSigner(guardAccount.publicKey)
+            .createTransaction();
+    }
+    // Check if we need to adjust gas limit
+    const requiredGas = simulation.gas;
+    if (requiredGas && requiredGas > gasLimit) {
+        // Rebuild transaction with adjusted gas limit (20% buffer)
+        gasLimit = calculateAutoGasLimit(requiredGas);
+        transaction = buildTransaction(gasLimit);
+    }
+    // Sign the transaction with both keypairs
+    const signedTransaction = await universalSignTransaction(transaction, [
+        fromKeypair(kadenaAccount),
+        fromKeypair(guardAccount),
+    ]);
+    // Submit the signed transaction
+    const result = await submit(signedTransaction);
+    return result;
+}
+export async function getMaxBuyMovieBooster(account, native) {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.MB.URC_GetMaxBuy "${account}" ${native})`, { tier: "T5" });
+        if (!response || !response.result || response.result.status === "failure") {
+            return null;
+        }
+        const data = response.result.data;
+        const value = Number(data?.int);
+        return Number.isFinite(value) ? value : null;
+    }
+    catch (error) {
+        getLogger().error("Error getting max buy for movie booster:", error);
+        return null;
+    }
+}
+export async function getSparksBalance(account) {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.MB.UR_Sparks "${account}")`, { tier: "T5" });
+        if (!response || !response.result || response.result.status === "failure") {
+            return null;
+        }
+        return response.result.data;
+    }
+    catch (error) {
+        getLogger().error("Error getting sparks balance:", error);
+        return null;
+    }
+}
+// (ouronet-ns.TS01-C2.SWP|C_Firestarter ouro-account:string)
+export async function firestarter(ouroAccount, // Ouro account that will receive the IGNIS
+kadenaAccount, // The kadena account that will transfer KDA
+guardAccount // The guard account from the Ouro account
+) {
+    const keysetName = `ks`;
+    // Fixed amount of 10 KDA
+    const kdaAmount = "10.0";
+    let gasLimit = 2000000; // Default gas limit for firestarter operation
+    const buildTransaction = (gasLimitOverride) => {
+        return Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.TS01-C3.SWP|C_Firestarter "${ouroAccount.address}")`)
+            .addData(keysetName, {
+            keys: [guardAccount.publicKey],
+            pred: "keys-all",
+        })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimitOverride || gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(kadenaAccount.publicKey, (withCapability) => [
+            withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            withCapability("coin.TRANSFER", `k:${kadenaAccount.publicKey}`, STOA_AUTONOMIC_OURONETGASSTATION, { decimal: kdaAmount }),
+        ])
+            .addSigner(guardAccount.publicKey)
+            .createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    // First do a simulation to check gas
+    let transaction = buildTransaction();
+    const simulation = await dirtyRead(transaction);
+    // Check if simulation failed
+    if (simulation.result.status === "failure") {
+        const errorMessage = simulation.result.error?.message || "Transaction simulation failed";
+        throw new Error(`Simulation failed: ${errorMessage}`);
+    }
+    // Check if we need to adjust gas limit
+    const requiredGas = simulation.gas;
+    if (requiredGas && requiredGas > gasLimit) {
+        // Rebuild transaction with adjusted gas limit (20% buffer)
+        gasLimit = calculateAutoGasLimit(requiredGas);
+        transaction = buildTransaction(gasLimit);
+    }
+    // Sign the transaction with both keypairs
+    const signedTransaction = await universalSignTransaction(transaction, [
+        fromKeypair(kadenaAccount),
+        fromKeypair(guardAccount),
+    ]);
+    // Submit the signed transaction
+    const result = await submit(signedTransaction);
+    return result;
+}

package/dist/interactions/ouroPriceFunctions.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ouroPriceFunctions.ts
+ * Price oracle (STOA/USD), coin-account existence probe, DPTF issue/min-move reads.
+ * All four functions follow the v3.0.0 nullable contract — return null on RPC failure or non-finite value.
+ */
+/**
+ * Read the live STOA/USD price from the on-chain KDA-PID oracle.
+ *
+ * Returns `null` when the oracle is unreachable, the chain call returns a
+ * non-success status, or the decoded value is not a finite number. Callers
+ * are expected to handle the nullable contract explicitly — no fabricated
+ * fallback price is ever returned.
+ */
+export declare function getStoaPriceUSD(options?: {
+    skipTempWatcher?: boolean;
+}): Promise<number | null>;
+/**
+ * Check if a coin account exists.
+ * (try false (coin.get-balance <address>))
+ * Returns: true = exists, false = doesn't exist, null = error
+ */
+export declare function checkCoinAccountExists(address: string): Promise<boolean | null>;
+/**
+ * Get INFO for UnwrapStoa function.
+ * (ouronet-ns.INFO-ONE.LIQUID|INFO_UnwrapStoa <patron> <unwrapper> <amount:decimal>)
+ */
+export declare function getDPTFIssueInfo(patron: string, resident: string, tokens: string[]): Promise<any | null>;
+/**
+ * Fetch the minimum transfer amount for a DPTF token.
+ * (ouronet-ns.DPTF.UR_MinMove <token-id>) → decimal
+ *
+ * Returns null when the chain read returns a non-success status, when the
+ * outer call throws, or when the decoded value is not a finite number.
+ * Callers must handle the nullable contract explicitly — no fabricated
+ * sentinel (previously `0`) is ever returned, since `0` is also a valid
+ * legitimate min-move and would mask read failures.
+ */
+export declare function getDPTFMinMove(tokenId: string): Promise<number | null>;

package/dist/interactions/ouroPriceFunctions.js

@@ -0,0 +1,96 @@
+/**
+ * ouroPriceFunctions.ts
+ * Price oracle (STOA/USD), coin-account existence probe, DPTF issue/min-move reads.
+ * All four functions follow the v3.0.0 nullable contract — return null on RPC failure or non-finite value.
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { mayComeWithDeimal } from "@stoachain/stoa-core/pact";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+/**
+ * Read the live STOA/USD price from the on-chain KDA-PID oracle.
+ *
+ * Returns `null` when the oracle is unreachable, the chain call returns a
+ * non-success status, or the decoded value is not a finite number. Callers
+ * are expected to handle the nullable contract explicitly — no fabricated
+ * fallback price is ever returned.
+ */
+export async function getStoaPriceUSD(options) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.U|CT.UR|KDA-PID)`;
+        const response = await pactRead(pactCode, { tier: "T6", skipTempWatcher: options?.skipTempWatcher });
+        if (response?.result?.status === "success") {
+            const value = Number(mayComeWithDeimal(response.result.data));
+            return Number.isFinite(value) ? value : null;
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getStoaPriceUSD:", error);
+        return null;
+    }
+}
+/**
+ * Check if a coin account exists.
+ * (try false (coin.get-balance <address>))
+ * Returns: true = exists, false = doesn't exist, null = error
+ */
+export async function checkCoinAccountExists(address) {
+    try {
+        const pactCode = `(try false (coin.get-balance "${address}"))`;
+        const response = await pactRead(pactCode, { tier: "T3" });
+        const data = response?.result?.data;
+        if (data === false || data === "false")
+            return false;
+        if (typeof data === "number" || (data && typeof data === "object" && "decimal" in data))
+            return true;
+        return false;
+    }
+    catch (error) {
+        getLogger().error("Error checking coin account:", error);
+        return null;
+    }
+}
+/**
+ * Get INFO for UnwrapStoa function.
+ * (ouronet-ns.INFO-ONE.LIQUID|INFO_UnwrapStoa <patron> <unwrapper> <amount:decimal>)
+ */
+export async function getDPTFIssueInfo(patron, resident, tokens) {
+    try {
+        const tokenList = tokens.map(t => `"${t}"`).join(" ");
+        const pactCode = `(${KADENA_NAMESPACE}.INFO-ONE.DPTF|INFO_Issue "${patron}" "${resident}" [${tokenList}])`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (response?.result?.status === "success")
+            return response.result.data;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getDPTFIssueInfo:", error);
+        return null;
+    }
+}
+/**
+ * Fetch the minimum transfer amount for a DPTF token.
+ * (ouronet-ns.DPTF.UR_MinMove <token-id>) → decimal
+ *
+ * Returns null when the chain read returns a non-success status, when the
+ * outer call throws, or when the decoded value is not a finite number.
+ * Callers must handle the nullable contract explicitly — no fabricated
+ * sentinel (previously `0`) is ever returned, since `0` is also a valid
+ * legitimate min-move and would mask read failures.
+ */
+export async function getDPTFMinMove(tokenId) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPTF.UR_MinMove "${tokenId}")`;
+        const response = await pactRead(pactCode, { tier: "T7" });
+        if (response?.result?.status === "success") {
+            const value = parseFloat(String(mayComeWithDeimal(response.result.data)));
+            return Number.isFinite(value) ? value : null;
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getDPTFMinMove:", error);
+        return null;
+    }
+}

package/dist/interactions/ouroPrimordialsFunctions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ouroPrimordialsFunctions.ts
+ * Chain call to ouronet-ns.DPL-UR.URC_0002_Primordials plus the placeholder factory.
+ * The internal `parseResponse` and `fmt` helpers retain the v4.x token-decoration
+ * logic verbatim for backward compat (v5.0.0 will physically extract it).
+ */
+export declare function getPrimordials(currentAccount?: string, codexAccounts?: string[], options?: {
+    skipTempWatcher?: boolean;
+}): Promise<any>;
+export declare function buildPlaceholderPrimordials(): any;