@ouronet/ouronet-core 4.3.6

package/dist/interactions/dexSwapPairExecuteFunctions.js

@@ -0,0 +1,301 @@
+/**
+ * dexSwapPairExecuteFunctions.ts
+ * Swap pair execution (single/multi pool, with/without slippage protection — TS01-C3 module).
+ */
+import { KADENA_CHAIN_ID, KADENA_NAMESPACE, STOA_AUTONOMIC_OURONETGASSTATION, KADENA_NETWORK, } from "../constants/index.js";
+import { Pact } from "@stoachain/kadena-stoic-legacy/client";
+import { getFailoverClient } from "@stoachain/stoa-core/network";
+import { universalSignTransaction, fromKeypair } from "@stoachain/stoa-core/signing";
+import { calculateAutoGasLimit } from "@stoachain/stoa-core/gas";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { safeCreationTime } from "@stoachain/stoa-core/pact";
+import { getLogger } from "@stoachain/stoa-core/observability";
+/**
+ * Fetch slippage bounds object for a swap via dirtyRead.
+ * Must be called before executing a swap with slippage protection.
+ */
+export async function getSlippageBounds(swpair, inputIds, inputAmounts, outputId, slippage) {
+    try {
+        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 slippageStr = slippage.toString();
+        const slippageDecimal = slippageStr.includes('.') ? slippageStr : `${slippageStr}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.SWPU.UDC_SpawnSlippageBounds "${swpair}" ${pactInputIds} ${pactInputAmounts} "${outputId}" ${slippageDecimal})`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve slippage bounds from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Slippage bounds query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred fetching slippage bounds");
+    }
+}
+/**
+ * Execute single swap with slippage protection
+ */
+export async function executeSingleSwapWithSlippage(params) {
+    try {
+        // Format numbers as decimals for Pact (preserve exact user input, just ensure decimal format)
+        const inputAmountStr = typeof params.inputAmount === 'string' ? params.inputAmount : params.inputAmount.toString();
+        const inputAmountDecimal = inputAmountStr.includes('.') ? inputAmountStr : `${inputAmountStr}.0`;
+        // Fetch slippage bounds object from chain before executing
+        const slippageBoundsObj = await getSlippageBounds(params.swpair, [params.inputId], [inputAmountDecimal], params.outputId, params.slippage);
+        const pactCode = `(${KADENA_NAMESPACE}.TS01-C3.SWP|C_SingleSwapWithSlippage "${params.patronKeypair.address}" "${params.account}" "${params.swpair}" "${params.inputId}" ${inputAmountDecimal} "${params.outputId}" (read-msg 'slippage-bounds))`;
+        // Create keyset name for the guard (following OURO pattern)
+        const keysetName = `ks`;
+        let gasLimit = 100000; // Default gas limit for swap execution (under block limit)
+        // Build transaction function
+        const buildTransaction = (gasLimitOverride) => {
+            return Pact.builder
+                .execution(pactCode)
+                .addData(keysetName, {
+                keys: [params.guardKeypair.publicKey],
+                pred: "keys-all",
+            })
+                .addData('slippage-bounds', slippageBoundsObj)
+                .setMeta({
+                senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+                creationTime: safeCreationTime(),
+                chainId: KADENA_CHAIN_ID,
+                gasLimit: gasLimitOverride || gasLimit,
+            })
+                .setNetworkId(KADENA_NETWORK)
+                .addSigner(params.kadenaKeypair.publicKey, (withCapability) => [
+                withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            ])
+                .addSigner(params.guardKeypair.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(`Single swap execution failed: ${errorMessage}`);
+        }
+        // Apply adaptive gas limit from simulation
+        const requiredGas = simulation.gas;
+        if (requiredGas) {
+            // Rebuild with adaptive gas limit
+            gasLimit = calculateAutoGasLimit(requiredGas);
+            transaction = buildTransaction(gasLimit);
+        }
+        // Sign the transaction with both keypairs
+        const signedTransaction = await universalSignTransaction(transaction, [
+            fromKeypair(params.kadenaKeypair),
+            fromKeypair(params.guardKeypair),
+        ]);
+        // Submit the signed transaction
+        const result = await submit(signedTransaction);
+        return result;
+    }
+    catch (error) {
+        getLogger().error("Single Swap WITH Slippage Error:", error);
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Execute single swap without slippage protection
+ */
+export async function executeSingleSwapNoSlippage(params) {
+    try {
+        // Format numbers as decimals for Pact (preserve exact user input, just ensure decimal format)
+        const inputAmountStr = typeof params.inputAmount === 'string' ? params.inputAmount : params.inputAmount.toString();
+        const inputAmountDecimal = inputAmountStr.includes('.') ? inputAmountStr : `${inputAmountStr}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.TS01-C3.SWP|C_SingleSwapNoSlippage "${params.patronKeypair.address}" "${params.account}" "${params.swpair}" "${params.inputId}" ${inputAmountDecimal} "${params.outputId}")`;
+        // Create keyset name for the guard (following OURO pattern)
+        const keysetName = `ks`;
+        let gasLimit = 140000; // Default gas limit for swap execution
+        // Build transaction function
+        const buildTransaction = (gasLimitOverride) => {
+            return Pact.builder
+                .execution(pactCode)
+                .addData(keysetName, {
+                keys: [params.guardKeypair.publicKey],
+                pred: "keys-all",
+            })
+                .setMeta({
+                senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+                creationTime: safeCreationTime(),
+                chainId: KADENA_CHAIN_ID,
+                gasLimit: gasLimitOverride || gasLimit,
+            })
+                .setNetworkId(KADENA_NETWORK)
+                .addSigner(params.kadenaKeypair.publicKey, (withCapability) => [
+                withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            ])
+                .addSigner(params.guardKeypair.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(`Single swap execution failed: ${errorMessage}`);
+        }
+        // Apply adaptive gas limit from simulation
+        const requiredGas = simulation.gas;
+        if (requiredGas) {
+            // Rebuild with adaptive gas limit
+            gasLimit = calculateAutoGasLimit(requiredGas);
+            transaction = buildTransaction(gasLimit);
+        }
+        // Sign the transaction with both keypairs
+        const signedTransaction = await universalSignTransaction(transaction, [
+            fromKeypair(params.kadenaKeypair),
+            fromKeypair(params.guardKeypair),
+        ]);
+        // Submit the signed transaction
+        const result = await submit(signedTransaction);
+        return result;
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Execute multi-token swap with slippage protection
+ */
+export async function executeMultiSwapWithSlippage(params) {
+    try {
+        // Format arrays for Pact with decimals (preserve exact user input as strings)
+        const pactInputIds = `[${params.inputIds.map(id => `"${id}"`).join(' ')}]`;
+        const formattedAmounts = params.inputAmounts.map(amount => {
+            const amountStr = typeof amount === 'string' ? amount : amount.toString();
+            return amountStr.includes('.') ? amountStr : `${amountStr}.0`;
+        });
+        const pactInputAmounts = `[${formattedAmounts.join(' ')}]`;
+        // Fetch slippage bounds object from chain before executing
+        const slippageBoundsObj = await getSlippageBounds(params.swpair, params.inputIds, formattedAmounts, params.outputId, params.slippage);
+        const pactCode = `(${KADENA_NAMESPACE}.TS01-C3.SWP|C_MultiSwapWithSlippage "${params.patronKeypair.address}" "${params.account}" "${params.swpair}" ${pactInputIds} ${pactInputAmounts} "${params.outputId}" (read-msg 'slippage-bounds))`;
+        // Create keyset name for the guard (following OURO pattern)
+        const keysetName = `ks`;
+        let gasLimit = 120000; // Default gas limit for multi-swap execution (under block limit)
+        // Build transaction function
+        const buildTransaction = (gasLimitOverride) => {
+            return Pact.builder
+                .execution(pactCode)
+                .addData(keysetName, {
+                keys: [params.guardKeypair.publicKey],
+                pred: "keys-all",
+            })
+                .addData('slippage-bounds', slippageBoundsObj)
+                .setMeta({
+                senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+                creationTime: safeCreationTime(),
+                chainId: KADENA_CHAIN_ID,
+                gasLimit: gasLimitOverride || gasLimit,
+            })
+                .setNetworkId(KADENA_NETWORK)
+                .addSigner(params.kadenaKeypair.publicKey, (withCapability) => [
+                withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            ])
+                .addSigner(params.guardKeypair.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(`Multi swap execution failed: ${errorMessage}`);
+        }
+        // Apply adaptive gas limit from simulation
+        const requiredGas = simulation.gas;
+        if (requiredGas) {
+            // Rebuild with adaptive gas limit
+            gasLimit = calculateAutoGasLimit(requiredGas);
+            transaction = buildTransaction(gasLimit);
+        }
+        // Sign the transaction with both keypairs
+        const signedTransaction = await universalSignTransaction(transaction, [
+            fromKeypair(params.kadenaKeypair),
+            fromKeypair(params.guardKeypair),
+        ]);
+        // Submit the signed transaction
+        const result = await submit(signedTransaction);
+        return result;
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Execute multi-token swap without slippage protection
+ */
+export async function executeMultiSwapNoSlippage(params) {
+    try {
+        // Format arrays for Pact with decimals (preserve exact user input as strings)
+        const pactInputIds = `[${params.inputIds.map(id => `"${id}"`).join(' ')}]`;
+        const pactInputAmounts = `[${params.inputAmounts.map(amount => {
+            const amountStr = typeof amount === 'string' ? amount : amount.toString();
+            return amountStr.includes('.') ? amountStr : `${amountStr}.0`;
+        }).join(' ')}]`;
+        const pactCode = `(${KADENA_NAMESPACE}.TS01-C3.SWP|C_MultiSwapNoSlippage "${params.patronKeypair.address}" "${params.account}" "${params.swpair}" ${pactInputIds} ${pactInputAmounts} "${params.outputId}")`;
+        // Create keyset name for the guard (following OURO pattern)
+        const keysetName = `ks`;
+        let gasLimit = 120000; // Default gas limit for multi-swap execution (under block limit)
+        // Build transaction function
+        const buildTransaction = (gasLimitOverride) => {
+            return Pact.builder
+                .execution(pactCode)
+                .addData(keysetName, {
+                keys: [params.guardKeypair.publicKey],
+                pred: "keys-all",
+            })
+                .setMeta({
+                senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+                creationTime: safeCreationTime(),
+                chainId: KADENA_CHAIN_ID,
+                gasLimit: gasLimitOverride || gasLimit,
+            })
+                .setNetworkId(KADENA_NETWORK)
+                .addSigner(params.kadenaKeypair.publicKey, (withCapability) => [
+                withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            ])
+                .addSigner(params.guardKeypair.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(`Multi swap execution failed: ${errorMessage}`);
+        }
+        // Apply adaptive gas limit from simulation
+        const requiredGas = simulation.gas;
+        if (requiredGas) {
+            // Rebuild with adaptive gas limit
+            gasLimit = calculateAutoGasLimit(requiredGas);
+            transaction = buildTransaction(gasLimit);
+        }
+        // Sign the transaction with both keypairs
+        const signedTransaction = await universalSignTransaction(transaction, [
+            fromKeypair(params.kadenaKeypair),
+            fromKeypair(params.guardKeypair),
+        ]);
+        // Submit the signed transaction
+        const result = await submit(signedTransaction);
+        return result;
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}

package/dist/interactions/dexSwapPairSmartSwapFunctions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * dexSwapPairSmartSwapFunctions.ts
+ * Smart-swap routing and multi-hop execution (URC_Hopper, SWPU.UDC_SpawnSmartSwapSlippageBounds, TS01-C3 SmartSwap).
+ */
+import type { SmartSwapHopper, SmartSwapSlippageBounds, SmartSwapExecutionParams } from "./dexTypes.js";
+/**
+ * Fetch all tokens available across all pools via SWP.URC_AllPoolTokens
+ */
+export declare function getAllPoolTokens(): Promise<string[]>;
+/**
+ * Preview a smart swap via SWPI.URC_Hopper
+ */
+export declare function getSmartSwapHopper(inputId: string, outputId: string, inputAmount: string | number): Promise<SmartSwapHopper | null>;
+/**
+ * Get slippage bounds for a smart swap via SWPU.UDC_SpawnSmartSwapSlippageBounds
+ */
+export declare function getSmartSwapSlippageBounds(inputId: string, inputAmount: string | number, outputId: string, slippage: number): Promise<SmartSwapSlippageBounds>;
+/**
+ * Execute a smart swap with slippage protection
+ */
+export declare function executeSmartSwapWithSlippage(params: SmartSwapExecutionParams): Promise<any>;
+/**
+ * Execute a smart swap without slippage protection
+ */
+export declare function executeSmartSwapNoSlippage(params: SmartSwapExecutionParams): Promise<any>;

package/dist/interactions/dexSwapPairSmartSwapFunctions.js

@@ -0,0 +1,166 @@
+/**
+ * dexSwapPairSmartSwapFunctions.ts
+ * Smart-swap routing and multi-hop execution (URC_Hopper, SWPU.UDC_SpawnSmartSwapSlippageBounds, TS01-C3 SmartSwap).
+ */
+import { KADENA_CHAIN_ID, KADENA_NAMESPACE, STOA_AUTONOMIC_OURONETGASSTATION, KADENA_NETWORK, } from "../constants/index.js";
+import { Pact } from "@stoachain/kadena-stoic-legacy/client";
+import { getFailoverClient } from "@stoachain/stoa-core/network";
+import { universalSignTransaction, fromKeypair } from "@stoachain/stoa-core/signing";
+import { calculateAutoGasLimit } from "@stoachain/stoa-core/gas";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { safeCreationTime } from "@stoachain/stoa-core/pact";
+/**
+ * Fetch all tokens available across all pools via SWP.URC_AllPoolTokens
+ */
+export async function getAllPoolTokens() {
+    try {
+        const response = await pactRead(`(${KADENA_NAMESPACE}.SWP.URC_AllPoolTokens)`, { tier: "T7" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve pool tokens from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Pool tokens query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        const data = response.result.data;
+        return Array.isArray(data) ? data : [];
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Preview a smart swap via SWPI.URC_Hopper
+ */
+export async function getSmartSwapHopper(inputId, outputId, inputAmount) {
+    try {
+        const amountStr = typeof inputAmount === "string" ? inputAmount : inputAmount.toString();
+        const amountDecimal = amountStr.includes(".") ? amountStr : `${amountStr}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.SWPI.URC_Hopper "${inputId}" "${outputId}" ${amountDecimal})`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve smart swap hopper from the transaction.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Smart swap hopper query failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Get slippage bounds for a smart swap via SWPU.UDC_SpawnSmartSwapSlippageBounds
+ */
+export async function getSmartSwapSlippageBounds(inputId, inputAmount, outputId, slippage) {
+    try {
+        const amountStr = typeof inputAmount === "string" ? inputAmount : inputAmount.toString();
+        const amountDecimal = amountStr.includes(".") ? amountStr : `${amountStr}.0`;
+        const slippageStr = slippage.toString();
+        const slippageDecimal = slippageStr.includes(".") ? slippageStr : `${slippageStr}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.SWPU.UDC_SpawnSmartSwapSlippageBounds "${inputId}" ${amountDecimal} "${outputId}" ${slippageDecimal})`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (!response || !response.result) {
+            throw new Error("Failed to retrieve smart swap slippage bounds.");
+        }
+        if (response.result.status === "failure") {
+            throw new Error(`Smart swap slippage bounds failed: ${response.result.error?.message || "Unknown error"}`);
+        }
+        return response.result.data;
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Execute a smart swap with slippage protection
+ */
+export async function executeSmartSwapWithSlippage(params) {
+    try {
+        const amountStr = typeof params.inputAmount === "string" ? params.inputAmount : params.inputAmount.toString();
+        const amountDecimal = amountStr.includes(".") ? amountStr : `${amountStr}.0`;
+        const slippage = params.slippage ?? 5;
+        // Fetch slippage bounds before executing
+        const slippageObj = await getSmartSwapSlippageBounds(params.inputId, amountDecimal, params.outputId, slippage);
+        const pactCode = `(${KADENA_NAMESPACE}.TS01-C3.SWP|C_SmartSwapWithSlippage "${params.patronKeypair.address}" "${params.account}" "${params.inputId}" ${amountDecimal} "${params.outputId}" (read-msg 'slippage-bounds))`;
+        const gasLimit = 1500000;
+        const buildTx = (gasLimitOverride) => Pact.builder
+            .execution(pactCode)
+            .addData("ks", {
+            keys: [params.guardKeypair.publicKey],
+            pred: "keys-all",
+        })
+            .addData("slippage-bounds", slippageObj)
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimitOverride ?? gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(params.kadenaKeypair.publicKey, (withCapability) => [
+            withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+        ])
+            .addSigner(params.guardKeypair.publicKey)
+            .createTransaction();
+        const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+        const simulation = await dirtyRead(buildTx());
+        if (simulation.result.status === "failure") {
+            throw new Error(`Smart swap simulation failed: ${simulation.result.error?.message || "Unknown error"}`);
+        }
+        const finalGas = simulation.gas ? calculateAutoGasLimit(simulation.gas) : gasLimit;
+        const tx = buildTx(finalGas);
+        const signedTx = await universalSignTransaction(tx, [
+            fromKeypair(params.kadenaKeypair),
+            fromKeypair(params.guardKeypair),
+        ]);
+        return await submit(signedTx);
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}
+/**
+ * Execute a smart swap without slippage protection
+ */
+export async function executeSmartSwapNoSlippage(params) {
+    try {
+        const amountStr = typeof params.inputAmount === "string" ? params.inputAmount : params.inputAmount.toString();
+        const amountDecimal = amountStr.includes(".") ? amountStr : `${amountStr}.0`;
+        const pactCode = `(${KADENA_NAMESPACE}.TS01-C3.SWP|C_SmartSwapNoSlippage "${params.patronKeypair.address}" "${params.account}" "${params.inputId}" ${amountDecimal} "${params.outputId}")`;
+        const gasLimit = 1500000;
+        const buildTx = (gasLimitOverride) => Pact.builder
+            .execution(pactCode)
+            .addData("ks", {
+            keys: [params.guardKeypair.publicKey],
+            pred: "keys-all",
+        })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: gasLimitOverride ?? gasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(params.kadenaKeypair.publicKey, (withCapability) => [
+            withCapability(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+        ])
+            .addSigner(params.guardKeypair.publicKey)
+            .createTransaction();
+        const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+        const simulation = await dirtyRead(buildTx());
+        if (simulation.result.status === "failure") {
+            throw new Error(`Smart swap simulation failed: ${simulation.result.error?.message || "Unknown error"}`);
+        }
+        const finalGas = simulation.gas ? calculateAutoGasLimit(simulation.gas) : gasLimit;
+        const tx = buildTx(finalGas);
+        const signedTx = await universalSignTransaction(tx, [
+            fromKeypair(params.kadenaKeypair),
+            fromKeypair(params.guardKeypair),
+        ]);
+        return await submit(signedTx);
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error("Unknown error occurred");
+    }
+}

package/dist/interactions/dexTrueFungibleFunctions.d.ts

@@ -0,0 +1,52 @@
+/**
+ * dexTrueFungibleFunctions.ts
+ * True Fungible (TF) entity reads — LP entries, header, entries, native/frozen LP, button state, swpair lookup.
+ */
+import type { TrueFungibleLPEntry, TrueFungibleHeaderData, TrueFungibleEntryData, TrueFungibleButtonState } from "./dexTypes.js";
+export declare function getTrueFungibleLPEntry(account: string, swpair: string, izNative: boolean): Promise<TrueFungibleLPEntry | null>;
+export declare function getLPEntries(account: string, swpair: string): Promise<{
+    native: TrueFungibleLPEntry | null;
+    frozen: TrueFungibleLPEntry | null;
+}>;
+/**
+ * Fetch swap pairs owned by a specific Ouronet resident account.
+ * Returns a list of swpair IDs that the account can manage.
+ */
+export declare function getOwnedSwapPairs(account: string): Promise<string[]>;
+/**
+ * Fetch True Fungible header data for an account.
+ * Returns global TF count, held TF list/count, managed TF list/count.
+ */
+export declare function getTrueFungibleHeader(account: string): Promise<TrueFungibleHeaderData | null>;
+/**
+ * Batch-fetch TrueFungibleEntry data for multiple token IDs using the chain mapper function.
+ * Works for Native, Frozen, and Reserved tokens (not LP).
+ * Uses URC_0008a_TrueFungibleEntryMapper(account, dptfs:[string])
+ */
+export declare function getTrueFungibleEntries(account: string, tokenIds: string[]): Promise<(TrueFungibleEntryData | null)[]>;
+/**
+ * Batch-fetch Native LP entry data using the chain mapper function.
+ * Uses URC_0008b_TrueFungibleNativeLPMapper(account, lp-ids:[string])
+ * Accepts LP token IDs directly — chain resolves swpairs internally.
+ */
+export declare function getNativeLPEntries(account: string, lpIds: string[]): Promise<(TrueFungibleLPEntry | null)[]>;
+/**
+ * Batch-fetch Frozen LP entry data using the chain mapper function.
+ * Uses URC_0008b_TrueFungibleFrozenLPMapper(account, lp-ids:[string])
+ * Accepts LP token IDs directly — chain resolves swpairs internally.
+ */
+export declare function getFrozenLPEntries(account: string, lpIds: string[]): Promise<(TrueFungibleLPEntry | null)[]>;
+/**
+ * Get the SWP-Pair ID from an LP token ID.
+ * Uses SWP.UR_GetLpSwpair on chain.
+ */
+export declare function getSwpairFromLpId(lpId: string): Promise<string | null>;
+/**
+ * Batch-fetch SWP-Pair IDs for multiple LP token IDs using a single Pact (map ...) call.
+ */
+export declare function getSwpairsFromLpIds(lpIds: string[]): Promise<(string | null)[]>;
+/**
+ * Fetch button enable/disable state for a specific token held by an account.
+ * Uses URC_0017_TruefungibleButton(account, dptf)
+ */
+export declare function getTrueFungibleButtonState(account: string, dptfId: string): Promise<TrueFungibleButtonState | null>;