@ouronet/ouronet-core 4.3.6

package/dist/interactions/ouroSubCompressFunctions.js

@@ -0,0 +1,191 @@
+/**
+ * ouroSubCompressFunctions.ts
+ * Sublimate (OURO -> IGNIS) and compress (IGNIS -> OURO) execution + preview/info reads.
+ */
+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 { createSigningError, createSimulationError, logDetailedError } from "@stoachain/stoa-core/errors";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+// Ouro to Ignis
+// (namespace.T201-C2.ORBR|C_Sublimate client target ouro-amount)
+export async function sublimateOuroToIgnis(ouroAccount, kadenaAccount, guard, targetAccount, 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.ORBR|C_Sublimate "${ouroAccount.address}" "${targetAccount}" ${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 error = createSimulationError("OURO to IGNIS sublimation", simulation.result, `Amount: ${decimalAmount} OURO → Target: ${targetAccount}`);
+        logDetailedError(error);
+        throw error;
+    }
+    // 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
+    try {
+        const signedTransaction = await universalSignTransaction(transaction, [
+            fromKeypair(kadenaAccount),
+            fromKeypair(guard),
+        ]);
+        // Submit the signed transaction
+        const result = await submit(signedTransaction);
+        return result;
+    }
+    catch (originalError) {
+        const error = createSigningError("OURO to IGNIS sublimation", originalError, `Signers: ${kadenaAccount.publicKey.slice(0, 8)}... (payer), ${guard.publicKey.slice(0, 8)}... (guard)`);
+        logDetailedError(error);
+        throw error;
+    }
+}
+// Ignis to Ouro is mainly the same as sublimateOuroToIgnis but has no target
+// ORBR|C_Compress:decimal (client:string ignis-amount:decimal)
+export async function compressIgnisToOuro(ouroAccount, kadenaAccount, guard, ignisAmount) {
+    const keysetName = `ks`;
+    // Ensure amount is formatted as decimal
+    const decimalAmount = formatDecimalForPact(ignisAmount);
+    let gasLimit = 2000000; // Default gas limit
+    const buildTransaction = (gasLimitOverride) => {
+        return Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.TS01-C2.ORBR|C_Compress "${ouroAccount.address}" ${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;
+}
+// Get IGNIS generation preview for sublimation
+// (namespace.OUROBOROS.URC_Sublimate ouro-amount)
+export async function getSublimatPreview(ouroAmount) {
+    try {
+        const decimalAmount = formatDecimalForPact(ouroAmount);
+        const response = await pactRead(`(${KADENA_NAMESPACE}.OUROBOROS.URC_Sublimate (at 0 (${KADENA_NAMESPACE}.U|ATS.UC_PromilleSplit 10.0 ${decimalAmount} 24)))`, { tier: "T2" });
+        if (!response || !response.result || response.result.status === "failure") {
+            return null;
+        }
+        const data = response.result.data;
+        return {
+            ignis: data,
+            fee: 0,
+        };
+    }
+    catch (error) {
+        getLogger().error("Error getting sublimate preview:", error);
+        return null;
+    }
+}
+// getCompressPreview
+// (at 0 (ouronet-ns.OUROBOROS.URC_Compress ignis-amount))
+export async function getCompressPreview(ignisAmount) {
+    try {
+        const decimalAmount = formatDecimalForPact(ignisAmount);
+        const response = await pactRead(`(at 0 (${KADENA_NAMESPACE}.OUROBOROS.URC_Compress ${decimalAmount}))`, { tier: "T2" });
+        if (!response || !response.result || response.result.status === "failure") {
+            return null;
+        }
+        const data = response.result.data;
+        if (!data?.decimal) {
+            return null;
+        }
+        return {
+            ouro: parseFloat(data.decimal),
+            fee: 0,
+        };
+    }
+    catch (error) {
+        getLogger().error("Error getting compress preview:", error);
+        return null;
+    }
+}
+/**
+ * @deprecated Use `getSublimateInfo` from `@ouronet/ouronet-core/interactions/infoOneFunctions` instead.
+ * This compat shim accepts the legacy (patron, resident, amount-as-string) signature and forwards to the canonical
+ * (client, target, amount-as-number) form. Will be removed in v4.2.0.
+ */
+export async function getSublimateInfo(a, b, c) {
+    const { getSublimateInfo: canonical } = await import("./infoOneFunctions");
+    return canonical(a, b, typeof c === "string" ? Number(c) : c);
+}
+export async function getCompressInfo(client, amount) {
+    try {
+        const decimalAmount = formatDecimalForPact(amount);
+        const pactCode = `(${KADENA_NAMESPACE}.INFO-ONE.ORBR|INFO_Compress "${client}" ${decimalAmount})`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (response?.result?.status === "success")
+            return response.result.data;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getCompressInfo:", error);
+        return null;
+    }
+}

package/dist/interactions/ouroTransferFunctions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ouroTransferFunctions.ts
+ * Single-token DPTF transfer execution via TS01-C1.DPTF|C_Transfer.
+ */
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+import type { IOuroAccountKeypair } from "./ouroTypes.js";
+export declare function transferToken(patronAccount: IOuroAccountKeypair, // The patron account (owner)
+tokenId: string, // Token ID
+senderAccount: string, // Sender Ouro address (usually same as patron)
+receiverAccount: string, // Receiver Ouro address
+transferAmount: string, // Amount to transfer
+method: boolean, // false for standard accounts, true for smart accounts
+kadenaAccount: IKadenaKeypair, // The kadena account (payer)
+guardAccount: IKadenaKeypair): Promise<import("@stoachain/kadena-stoic-legacy/client").ITransactionDescriptor>;

package/dist/interactions/ouroTransferFunctions.js

@@ -0,0 +1,87 @@
+/**
+ * ouroTransferFunctions.ts
+ * Single-token DPTF transfer execution via TS01-C1.DPTF|C_Transfer.
+ */
+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";
+// Single Token Transfer
+// (namespace.TS01-C1.DPTF|C_Transfer patron id sender receiver transfer-amount method)
+export async function transferToken(patronAccount, // The patron account (owner)
+tokenId, // Token ID
+senderAccount, // Sender Ouro address (usually same as patron)
+receiverAccount, // Receiver Ouro address
+transferAmount, // Amount to transfer
+method, // false for standard accounts, true for smart accounts
+kadenaAccount, // The kadena account (payer)
+guardAccount // The guard account from the Ouro account
+) {
+    // Ensure amount is formatted as decimal
+    const decimalAmount = formatDecimalForPact(transferAmount);
+    let gasLimit = 2000000; // Default gas limit for transfer operation
+    const buildTransaction = (gasLimitOverride) => {
+        return Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.TS01-C1.DPTF|C_Transfer "${patronAccount.address}" "${tokenId}" "${senderAccount}" "${receiverAccount}" ${decimalAmount} ${method})`)
+            .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(guardAccount.publicKey)
+            .createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    // First do a simulation to check gas
+    let transaction = buildTransaction();
+    let simulation = await dirtyRead(transaction);
+    // Check if simulation failed due to gas limit exceeded
+    if (simulation.result.status === "failure") {
+        const errorMessage = simulation.result.error?.message || "";
+        // Check if it's a gas limit exceeded error
+        if (errorMessage.includes("Gas limit") && errorMessage.includes("exceeded")) {
+            // Extract the required gas from error message or use a higher limit
+            const gasMatch = errorMessage.match(/exceeded:\s*(\d+)/);
+            if (gasMatch) {
+                const requiredGas = parseInt(gasMatch[1]);
+                gasLimit = calculateAutoGasLimit(requiredGas); // 20% buffer
+                // Rebuild and retry simulation with higher gas limit
+                transaction = buildTransaction(gasLimit);
+                simulation = await dirtyRead(transaction);
+            }
+            else {
+                // If we can't extract exact gas, increase by 50%
+                gasLimit = Math.ceil(gasLimit * 1.5);
+                transaction = buildTransaction(gasLimit);
+                simulation = await dirtyRead(transaction);
+            }
+        }
+        // If still failing after retry, throw error
+        if (simulation.result.status === "failure") {
+            const finalErrorMessage = simulation.result.error?.message || "Transaction simulation failed";
+            throw new Error(`Simulation failed: ${finalErrorMessage}`);
+        }
+    }
+    // Check if we need to adjust gas limit further (normal case)
+    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/ouroTypes.d.ts

@@ -0,0 +1,113 @@
+/**
+ * ouroTypes.ts
+ * Cross-cutting interface and type-alias definitions for the ouro entity files.
+ * Sole non-local re-export: IKadenaKeypair from @stoachain/stoa-core/signing.
+ */
+export type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+export interface AccountSelectorData {
+    readonly "iz-activated": boolean;
+    readonly "ouronet-account": string;
+    readonly "ouronet-account-guard": any;
+    readonly "iz-smart": boolean | number;
+    readonly "ouro-balance": number;
+    readonly "ignis-balance": number;
+    readonly "payment-key-existance": boolean;
+    readonly "payment-key": string;
+    readonly "payment-key-balance": number;
+    readonly "payment-key-guard": any;
+    readonly "ignis-discount": any;
+    readonly "stoa-discount": any;
+    /**
+     * On-chain public key for the account — the long base-49 string in the
+     * DALOS `{prefixLenBase49}.{xyBase49}` format. Populated for both
+     * Standard (Ѻ.) and Smart (Σ.) accounts. **This is the on-chain source
+     * of truth** and is expected to match the codex-stored `publicKey` for
+     * any account created through the standard flow. A mismatch would
+     * indicate either (a) an admin-level key rotation performed on chain
+     * (designed as a last-resort correction tool), or (b) a corrupted
+     * codex entry. Added in ouronet-core v1.4.0 alongside the
+     * `URC_0027_AccountSelectorMapper` Pact-side extension.
+     */
+    readonly "public-key": string;
+    /**
+     * Sovereign — only populated for Smart accounts (iz-smart = true). The
+     * Ѻ. Standard Ouronet Account that has sovereignty over this Smart
+     * account; proving ownership of the sovereign proves ownership of the
+     * Smart account's `sovereign` authorization path. Pact returns `false`
+     * for Standard accounts and unactivated accounts. Added in v1.4.0.
+     */
+    readonly "sovereign": string | false;
+    /**
+     * Governor — only populated for Smart accounts. A Pact guard used for
+     * complex custom authorization logic (capability guards, module guards,
+     * user guards, or additional keyset arrangements). For Smart accounts
+     * where no custom governor has been set, this equals the account's own
+     * `ouronet-account-guard`. Pact returns `false` for Standard accounts
+     * and unactivated accounts. Added in v1.4.0.
+     */
+    readonly "governor": any | false;
+    /**
+     * Stoic Tag — the human-readable alias attached to this Ouronet account.
+     *   `stoic-tag-has`            true when the account has an active tag.
+     *   `stoic-tag`                the tag name, or the literal sentinel
+     *                              "No StoicTag yet" when none. Consumers MUST
+     *                              gate on `stoic-tag-has`, never the string.
+     *   `stoic-tag-registered-at`  block time at registration; `false` if none.
+     */
+    readonly "stoic-tag-has": boolean;
+    readonly "stoic-tag": string;
+    readonly "stoic-tag-registered-at": unknown;
+}
+/**
+ * Inverse StoicTag read — one row per queried tag name, from
+ * `URC_0027c_StoicTagSelectorSingle` (and the batch `URC_0027b_…Mapper`).
+ * Powers Address Book StoicTag entries, which watch a tag independently of
+ * any codex account.
+ */
+export interface StoicTagSelectorData {
+    readonly "stoic-tag": string;
+    readonly "iz-row-exists": boolean;
+    readonly "iz-active": boolean;
+    readonly "iz-released": boolean;
+    readonly "iz-never-registered": boolean;
+    readonly "ouronet-account": string;
+    readonly "registered-at": unknown;
+}
+export interface StoaAccountSelectorData {
+    readonly "iz-activated": boolean;
+    readonly "account": string;
+    readonly "balance": number;
+    readonly "guard": any;
+}
+export interface AccountOverviewData {
+    readonly "global-administrative-pause": boolean;
+    readonly "iz-selected-activated": boolean;
+    readonly "stoa-costs": number;
+}
+export interface IOuroAccountKeypair {
+    readonly address: string;
+    readonly publicKey: string;
+    readonly privateKey?: string;
+}
+export interface UnwrapStoaParams {
+    readonly patronAddress: string;
+    readonly unwrapperAddress: string;
+    readonly amount: string;
+    readonly numAmount: number;
+    readonly targetAddress: string;
+    readonly targetExists: boolean;
+    readonly gasStationKey: IKadenaKeypair;
+    readonly patronGuardKeys: IKadenaKeypair[];
+    readonly accountGuardKeys: IKadenaKeypair[];
+}
+export interface UnwrapUrStoaParams {
+    readonly patronAddress: string;
+    readonly unwrapperAddress: string;
+    readonly amount: string;
+    readonly targetAddress: string;
+    readonly targetExists: boolean;
+    readonly gasStationKey: IKadenaKeypair;
+    readonly patronGuardKeys: IKadenaKeypair[];
+    readonly accountGuardKeys: IKadenaKeypair[];
+}

package/dist/interactions/ouroTypes.js

@@ -0,0 +1,6 @@
+/**
+ * ouroTypes.ts
+ * Cross-cutting interface and type-alias definitions for the ouro entity files.
+ * Sole non-local re-export: IKadenaKeypair from @stoachain/stoa-core/signing.
+ */
+export {};

package/dist/interactions/ouroUrStoaFunctions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ouroUrStoaFunctions.ts
+ * UrStoa account-existence probe, unwrap-info read, and unwrap execution (parallel to UnwrapStoa).
+ */
+import type { UnwrapUrStoaParams } from "./ouroTypes.js";
+/**
+ * Check if an account exists in the UrStoa table.
+ * (if (= (typeof (try false (coin.UR_UR|Balance "<address>"))) "bool") false true)
+ */
+export declare function checkUrStoaAccountExists(address: string): Promise<boolean | null>;
+/**
+ * Get INFO for UnwrapUrStoa function.
+ * (ouronet-ns.INFO-ONE.LIQUID|INFO_UnwrapUrStoa <patron> <wrapper> <amount:decimal>)
+ */
+export declare function getUnwrapUrStoaInfo(patron: string, wrapper: string, amount: string): Promise<any | null>;
+export declare function executeUnwrapUrStoa(params: UnwrapUrStoaParams): Promise<any>;

package/dist/interactions/ouroUrStoaFunctions.js

@@ -0,0 +1,121 @@
+/**
+ * ouroUrStoaFunctions.ts
+ * UrStoa account-existence probe, unwrap-info read, and unwrap execution (parallel to UnwrapStoa).
+ */
+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 { createSimulationError, logDetailedError } from "@stoachain/stoa-core/errors";
+import { pactRead } from "@stoachain/stoa-core/reads";
+import { getLogger } from "@stoachain/stoa-core/observability";
+// ─── Unwrap UrStoa ────────────────────────────────────────────────────────────
+/**
+ * Check if an account exists in the UrStoa table.
+ * (if (= (typeof (try false (coin.UR_UR|Balance "<address>"))) "bool") false true)
+ */
+export async function checkUrStoaAccountExists(address) {
+    try {
+        const pactCode = `(if (= (typeof (try false (coin.UR_UR|Balance "${address}"))) "bool") false true)`;
+        const response = await pactRead(pactCode, { tier: "T3" });
+        const data = response?.result?.data;
+        if (data === true)
+            return true;
+        if (data === false)
+            return false;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error checking UrStoa account:", error);
+        return null;
+    }
+}
+/**
+ * Get INFO for UnwrapUrStoa function.
+ * (ouronet-ns.INFO-ONE.LIQUID|INFO_UnwrapUrStoa <patron> <wrapper> <amount:decimal>)
+ */
+export async function getUnwrapUrStoaInfo(patron, wrapper, amount) {
+    try {
+        const decimalAmount = formatDecimalForPact(amount);
+        const pactCode = `(${KADENA_NAMESPACE}.INFO-ONE.LIQUID|INFO_UnwrapUrStoa "${patron}" "${wrapper}" ${decimalAmount})`;
+        const response = await pactRead(pactCode, { tier: "T2" });
+        if (response?.result?.status === "success") {
+            return response.result.data;
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error getting UnwrapUrStoa info:", error);
+        return null;
+    }
+}
+// ─── executeUnwrapUrStoa ──────────────────────────────────────────────────────
+// Handles both cases:
+//   target exists → simple unwrap via C_UnwrapUrStoa
+//   target new k: → create UrStoa account + unwrap
+export async function executeUnwrapUrStoa(params) {
+    const { patronAddress, unwrapperAddress, amount, targetAddress, targetExists, gasStationKey, patronGuardKeys, accountGuardKeys, } = params;
+    const allSigners = [gasStationKey];
+    const addedPubs = new Set([gasStationKey.publicKey]);
+    for (const k of [...patronGuardKeys, ...accountGuardKeys]) {
+        if (!addedPubs.has(k.publicKey)) {
+            allSigners.push(k);
+            addedPubs.add(k.publicKey);
+        }
+    }
+    let gasLimit = 2000000;
+    const buildTransaction = (gasLimitOverride) => {
+        const effectiveGasLimit = gasLimitOverride ?? gasLimit;
+        let builder = targetExists
+            ? Pact.builder.execution(`(${KADENA_NAMESPACE}.TS01-C2.LQD|C_UnwrapUrStoa "${patronAddress}" "${unwrapperAddress}" ${amount})`)
+            : Pact.builder
+                .execution(`(namespace "${KADENA_NAMESPACE}")\n` +
+                `(IGNIS.C_Collect "${patronAddress}" (IGNIS.UDC_CustomCodeCumulator))\n` +
+                `(let\n` +
+                `  (\n` +
+                `    (wp:string "${unwrapperAddress}")\n` +
+                `    (target:string (DALOS.UR_AccountKadena wp))\n` +
+                `  )\n` +
+                `  [\n` +
+                `    (coin.C_UR|CreateAccount target (read-keyset "ks"))\n` +
+                `    (TS01-C2.LQD|C_UnwrapUrStoa "${patronAddress}" "${unwrapperAddress}" ${amount})\n` +
+                `  ]\n` +
+                `)`)
+                .addData("ks", {
+                keys: [targetAddress.slice(2)],
+                pred: "keys-all",
+            });
+        builder = builder
+            .setMeta({ senderAccount: STOA_AUTONOMIC_OURONETGASSTATION, chainId: KADENA_CHAIN_ID, creationTime: safeCreationTime(),
+            gasLimit: effectiveGasLimit })
+            .setNetworkId(KADENA_NETWORK)
+            .addSigner(gasStationKey.publicKey, (w) => [
+            w(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+        ]);
+        const addedSignerPubs = new Set([gasStationKey.publicKey]);
+        for (const k of [...patronGuardKeys, ...accountGuardKeys]) {
+            if (!addedSignerPubs.has(k.publicKey)) {
+                builder = builder.addSigner(k.publicKey);
+                addedSignerPubs.add(k.publicKey);
+            }
+        }
+        return builder.createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    let transaction = buildTransaction();
+    const simulation = await dirtyRead(transaction);
+    if (simulation.result.status === "failure") {
+        const error = createSimulationError("Unwrap UrStoa", simulation.result, `Patron: ${patronAddress} | Unwrapper: ${unwrapperAddress} | Target: ${targetAddress} | Amount: ${amount}`);
+        logDetailedError(error);
+        throw error;
+    }
+    const requiredGas = simulation.gas;
+    if (requiredGas) {
+        gasLimit = calculateAutoGasLimit(requiredGas);
+        transaction = buildTransaction(gasLimit);
+    }
+    const signed = await universalSignTransaction(transaction, allSigners.map((s) => fromKeypair(s)));
+    return await submit(signed);
+}

package/dist/interactions/ouroWrapFunctions.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ouroWrapFunctions.ts
+ * KDA wrap/unwrap and unwrap-stoa execution + supporting reads.
+ */
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+import type { IOuroAccountKeypair, UnwrapStoaParams } from "./ouroTypes.js";
+export declare function wrapKadena(patronAccount: IOuroAccountKeypair, wrapperAccount: string, // Ouro address that will receive the wrapped KDA
+kadenaAccount: IKadenaKeypair, // The kadena account that will transfer KDA
+guardAccount: IKadenaKeypair, // The guard account from the Ouro account
+amount: string): Promise<import("@stoachain/kadena-stoic-legacy/client").ITransactionDescriptor>;
+export declare function unwrapKadena(patronAccount: IOuroAccountKeypair, // Ouro account that owns the WSTOA
+unwrapperAccount: string, // Ouro address that will receive the unwrapped KDA
+kadenaAccount: IKadenaKeypair, // The kadena account (payer)
+guardAccount: IKadenaKeypair, // The guard account from the Ouro account
+amount: string): Promise<import("@stoachain/kadena-stoic-legacy/client").ITransactionDescriptor>;
+/**
+ * Resolve the target Kadena address for an Ouronet unwrapper account.
+ * (ouronet-ns.DALOS.UR_AccountKadena <unwrapper>)
+ */
+export declare function getUnwrapStoaTarget(unwrapper: string): Promise<string | null>;
+export declare function getUnwrapStoaInfo(patron: string, unwrapper: string, amount: string): Promise<any | null>;
+export declare function executeUnwrapStoa(params: UnwrapStoaParams): Promise<any>;