@ouronet/ouronet-core 4.3.6

package/dist/interactions/dexSwapPairCalcFunctions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * dexSwapPairCalcFunctions.ts
+ * Swap pair calculation reads (URC_0006-0011 swap math, decimals, total fee).
+ */
+import type { SwapCalculationResult, InverseSwapResult, CappedInverseResult, UserAccountSupplies } from "./dexTypes.js";
+/**
+ * Calculate direct swap output amounts
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function calculateDirectSwap(account: string, swpair: string, inputIds: string[], inputAmounts: string[] | number[], outputId: string): Promise<SwapCalculationResult | null>;
+/**
+ * Calculate reverse swap input amounts (user specifies desired output)
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function calculateInverseSwap(account: string, swpair: string, outputId: string, outputAmount: number, inputId: string): Promise<InverseSwapResult | null>;
+/**
+ * URC_0006b — Direct swap calculation, returns numeric output amount directly
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function calculateDirectSwapB(account: string, swpair: string, inputIds: string[], inputAmounts: string[] | number[], outputId: string): Promise<{
+    decimal: string;
+} | number | null>;
+/**
+ * URC_0007b — Inverse swap calculation, returns numeric input amount directly
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function calculateInverseSwapB(account: string, swpair: string, outputId: string, outputAmount: number, inputId: string): Promise<{
+    decimal: string;
+} | number | null>;
+/**
+ * Get maximum output amount for reverse swap (75% of token supply in pool)
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getCappedInverseAmount(swpair: string, outputId: string): Promise<CappedInverseResult | null>;
+/**
+ * Get user's token balances for all tokens in a specific swap pair
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getUserAccountSupplies(account: string, swpair: string): Promise<UserAccountSupplies | null>;
+/**
+ * Fetch decimal precision for a DPTF token via DPTF.UR_Decimals
+ * Returns the number of decimal places (e.g. 12 for high-precision tokens)
+ */
+export declare function getTokenDecimals(tokenId: string): Promise<number | null>;
+/**
+ * Fetch total fee for a swap pair pool via SWP.URC_PoolTotalFee
+ * Returns fee as a decimal fraction (e.g. 0.003 = 0.3%)
+ */
+export declare function getPoolTotalFee(swpair: string): Promise<number | null>;

package/dist/interactions/dexSwapPairCalcFunctions.js

@@ -0,0 +1,218 @@
+/**
+ * dexSwapPairCalcFunctions.ts
+ * Swap pair calculation reads (URC_0006-0011 swap math, decimals, total fee).
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+/**
+ * Calculate direct swap output amounts
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function calculateDirectSwap(account, swpair, inputIds, inputAmounts, outputId) {
+    try {
+        // Format arrays for Pact with proper decimal formatting - keep as strings to preserve precision
+        const pactInputIds = `[${inputIds.map(id => `"${id}"`).join(' ')}]`;
+        const pactInputAmounts = `[${inputAmounts.map(amount => {
+            const amountStr = typeof amount === 'string' ? amount : amount.toString();
+            return amountStr.includes('.') ? amountStr : `${amountStr}.0`;
+        }).join(' ')}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0006_Swap "${account}" "${swpair}" ${pactInputIds} ${pactInputAmounts} "${outputId}")`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve direct swap calculation from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Direct swap calculation failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in calculateDirectSwap:", error);
+        return null;
+    }
+}
+/**
+ * Calculate reverse swap input amounts (user specifies desired output)
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function calculateInverseSwap(account, swpair, outputId, outputAmount, inputId) {
+    try {
+        // Format outputAmount as decimal for Pact (e.g., 1 → "1.0")
+        const outputAmountDecimal = outputAmount.toString().includes('.') ? outputAmount.toString() : `${outputAmount}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0007_InverseSwap "${account}" "${swpair}" "${outputId}" ${outputAmountDecimal} "${inputId}")`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve inverse swap calculation from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Inverse swap calculation failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in calculateInverseSwap:", error);
+        return null;
+    }
+}
+/**
+ * URC_0006b — Direct swap calculation, returns numeric output amount directly
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function calculateDirectSwapB(account, swpair, inputIds, inputAmounts, outputId) {
+    try {
+        const pactInputIds = `[${inputIds.map(id => `"${id}"`).join(' ')}]`;
+        const pactInputAmounts = `[${inputAmounts.map(a => {
+            const s = typeof a === 'string' ? a : a.toString();
+            return s.includes('.') ? s : `${s}.0`;
+        }).join(' ')}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0006b_DirectSwap "${account}" "${swpair}" ${pactInputIds} ${pactInputAmounts} "${outputId}")`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response?.result)
+            throw new Error("No response");
+        if (response.result.status === "failure")
+            throw new Error(response.result.error?.message ?? "Failed");
+        return response.result.data;
+    }
+    catch (error) {
+        getLogger().error("Error in calculateDirectSwapB:", error);
+        return null;
+    }
+}
+/**
+ * URC_0007b — Inverse swap calculation, returns numeric input amount directly
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function calculateInverseSwapB(account, swpair, outputId, outputAmount, inputId) {
+    try {
+        const outDecimal = outputAmount.toString().includes('.') ? outputAmount.toString() : `${outputAmount}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0007b_InverseSwap "${account}" "${swpair}" "${outputId}" ${outDecimal} "${inputId}")`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response?.result)
+            throw new Error("No response");
+        if (response.result.status === "failure")
+            throw new Error(response.result.error?.message ?? "Failed");
+        return response.result.data;
+    }
+    catch (error) {
+        getLogger().error("Error in calculateInverseSwapB:", error);
+        return null;
+    }
+}
+/**
+ * Get maximum output amount for reverse swap (75% of token supply in pool)
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getCappedInverseAmount(swpair, outputId) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0008_CappedInverse "${swpair}" "${outputId}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve capped inverse amount from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Capped inverse query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in getCappedInverseAmount:", error);
+        return null;
+    }
+}
+/**
+ * Get user's token balances for all tokens in a specific swap pair
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getUserAccountSupplies(account, swpair) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0011_AccountSuppliesForSwpair "${account}" "${swpair}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve user account supplies from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`User account supplies query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in getUserAccountSupplies:", error);
+        return null;
+    }
+}
+/**
+ * Fetch decimal precision for a DPTF token via DPTF.UR_Decimals
+ * Returns the number of decimal places (e.g. 12 for high-precision tokens)
+ */
+export async function getTokenDecimals(tokenId) {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.DPTF.UR_Decimals "${tokenId}")`, { tier: "T7" });
+        if (!response || !response.result || response.result.status === "failure") {
+            return null;
+        }
+        const data = response.result.data;
+        if (typeof data === "number") {
+            return Number.isFinite(data) ? data : null;
+        }
+        if (data && typeof data === "object") {
+            if ("int" in data) {
+                const n = parseInt(data.int, 10);
+                return Number.isFinite(n) ? n : null;
+            }
+            if ("decimal" in data) {
+                const n = parseInt(data.decimal, 10);
+                return Number.isFinite(n) ? n : null;
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getTokenDecimals:", error);
+        return null;
+    }
+}
+/**
+ * Local helper to resolve Pact decimal/int/number values to JS number
+ */
+function resolvePactDecimalLocal(val) {
+    if (val === null || val === undefined)
+        return 0;
+    if (typeof val === "number")
+        return val;
+    if (typeof val === "object") {
+        if ("decimal" in val)
+            return parseFloat(val.decimal);
+        if ("int" in val)
+            return parseInt(val.int, 10);
+    }
+    return parseFloat(String(val));
+}
+/**
+ * Fetch total fee for a swap pair pool via SWP.URC_PoolTotalFee
+ * Returns fee as a decimal fraction (e.g. 0.003 = 0.3%)
+ */
+export async function getPoolTotalFee(swpair) {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.SWP.URC_PoolTotalFee "${swpair}")`, { tier: "T5" });
+        if (response?.result?.status === "success") {
+            const value = resolvePactDecimalLocal(response.result.data);
+            return Number.isFinite(value) ? value : null;
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getPoolTotalFee:", error);
+        return null;
+    }
+}

package/dist/interactions/dexSwapPairDashboardFunctions.d.ts

@@ -0,0 +1,47 @@
+/**
+ * dexSwapPairDashboardFunctions.ts
+ * Swap pair dashboard reads and pool previews (URC_0003-0005, URC_0010 dashboard surface).
+ */
+import type { SwapPoolData, PoolPreviewData, SwpairInternalDashboard } from "./dexTypes.js";
+/**
+ * Fetch all swap pair IDs from the SWP contract
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getPoolIds(): Promise<string[] | null>;
+/**
+ * Fetch the primordial pool ID
+ */
+export declare function getPrimordialPool(): Promise<string | null>;
+/**
+ * Fetch general information for all swap pairs
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getSWPairGeneralInfo(): Promise<any>;
+/**
+ * Fetch detailed dashboard information for a specific swap pair
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getSWPairDashboardInfo(swpair: string): Promise<SwapPoolData | null>;
+/**
+ * Fetch enhanced pool preview/dashboard data for a specific pool
+ * Returns richer data structure with formatted values and weights
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getPoolPreviewData(poolId: string): Promise<PoolPreviewData | null>;
+/**
+ * Fetch detailed dashboard information for multiple swap pairs
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getSWPairMultiDashboardInfo(swpairs: string[]): Promise<SwapPoolData[] | null>;
+/**
+ * Fetch comprehensive internal dashboard data for a specific swap pair
+ * Contains all pool stats including detailed analytics
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export declare function getSwpairInternalDashboard(swpair: string): Promise<SwpairInternalDashboard | null>;

package/dist/interactions/dexSwapPairDashboardFunctions.js

@@ -0,0 +1,179 @@
+/**
+ * dexSwapPairDashboardFunctions.ts
+ * Swap pair dashboard reads and pool previews (URC_0003-0005, URC_0010 dashboard surface).
+ */
+import { KADENA_NAMESPACE } from "../constants/index.js";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+/**
+ * Fetch all swap pair IDs from the SWP contract
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getPoolIds() {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.SWP.URC_Swpairs)`, { tier: "T7" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve pool IDs from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Pool IDs query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return Array.isArray(data) ? data : null;
+    }
+    catch (error) {
+        getLogger().error("Error in getPoolIds:", error);
+        return null;
+    }
+}
+/**
+ * Fetch the primordial pool ID
+ */
+export async function getPrimordialPool() {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.SWP.UR_PrimordialPool)`, { tier: "T7" });
+        if (response?.result?.status === "success") {
+            return String(response.result.data);
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getPrimordialPool:", error);
+        return null;
+    }
+}
+/**
+ * Fetch general information for all swap pairs
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getSWPairGeneralInfo() {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.DPL-UR.URC_0003_SWPairGeneralInfo)`, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve general swap pair info from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`General info query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (error) {
+        getLogger().error("Error in getSWPairGeneralInfo:", error);
+        return null;
+    }
+}
+/**
+ * Fetch detailed dashboard information for a specific swap pair
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getSWPairDashboardInfo(swpair) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0004_SWPairDashboardInfo "${swpair}")`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve swap pair dashboard info from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Dashboard info query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        // Single pool API returns an object directly, not an array
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            return data;
+        }
+        else if (Array.isArray(data) && data.length > 0) {
+            return data[0];
+        }
+        else {
+            return null;
+        }
+    }
+    catch (error) {
+        getLogger().error("Error in getSWPairDashboardInfo:", error);
+        return null;
+    }
+}
+/**
+ * Fetch enhanced pool preview/dashboard data for a specific pool
+ * Returns richer data structure with formatted values and weights
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getPoolPreviewData(poolId) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0004_SWPairDashboardInfo "${poolId}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve pool preview data from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Pool preview query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        // Enhanced pool API returns an object directly with additional formatted fields
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            return data;
+        }
+        else if (Array.isArray(data) && data.length > 0) {
+            return data[0];
+        }
+        else {
+            return null;
+        }
+    }
+    catch (error) {
+        getLogger().error("Error in getPoolPreviewData:", error);
+        return null;
+    }
+}
+/**
+ * Fetch detailed dashboard information for multiple swap pairs
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getSWPairMultiDashboardInfo(swpairs) {
+    try {
+        // Format array for Pact: ["id1" "id2" "id3"]
+        const pactArray = `[${swpairs.map(swpair => `"${swpair}"`).join(' ')}]`;
+        const response = await pactRead(`(${KADENA_NAMESPACE}.DPL-UR.URC_0005_SWPairMultiDashboardInfo ${pactArray})`, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve multi swap pair dashboard info from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Multi dashboard info query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return Array.isArray(data) ? data : null;
+    }
+    catch (error) {
+        getLogger().error("Error in getSWPairMultiDashboardInfo:", error);
+        return null;
+    }
+}
+/**
+ * Fetch comprehensive internal dashboard data for a specific swap pair
+ * Contains all pool stats including detailed analytics
+ *
+ * Returns null on RPC failure (catch-and-return-null contract, v4.2.0).
+ */
+export async function getSwpairInternalDashboard(swpair) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.DPL-UR.URC_0010_SwpairInternalDashboard "${swpair}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve internal dashboard data from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Internal dashboard query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return data;
+    }
+    catch (error) {
+        getLogger().error("Error in getSwpairInternalDashboard:", error);
+        return null;
+    }
+}

package/dist/interactions/dexSwapPairExecuteFunctions.d.ts

@@ -0,0 +1,40 @@
+/**
+ * dexSwapPairExecuteFunctions.ts
+ * Swap pair execution (single/multi pool, with/without slippage protection — TS01-C3 module).
+ */
+import type { SwapExecutionParams, SlippageBounds } from "./dexTypes.js";
+/**
+ * Fetch slippage bounds object for a swap via dirtyRead.
+ * Must be called before executing a swap with slippage protection.
+ */
+export declare function getSlippageBounds(swpair: string, inputIds: string[], inputAmounts: (string | number)[], outputId: string, slippage: number): Promise<SlippageBounds>;
+/**
+ * Execute single swap with slippage protection
+ */
+export declare function executeSingleSwapWithSlippage(params: SwapExecutionParams & {
+    inputId: string;
+    inputAmount: string | number;
+    slippage: number;
+}): Promise<any>;
+/**
+ * Execute single swap without slippage protection
+ */
+export declare function executeSingleSwapNoSlippage(params: SwapExecutionParams & {
+    inputId: string;
+    inputAmount: string | number;
+}): Promise<any>;
+/**
+ * Execute multi-token swap with slippage protection
+ */
+export declare function executeMultiSwapWithSlippage(params: SwapExecutionParams & {
+    inputIds: string[];
+    inputAmounts: (string | number)[];
+    slippage: number;
+}): Promise<any>;
+/**
+ * Execute multi-token swap without slippage protection
+ */
+export declare function executeMultiSwapNoSlippage(params: SwapExecutionParams & {
+    inputIds: string[];
+    inputAmounts: (string | number)[];
+}): Promise<any>;