@ouronet/ouronet-core 4.3.6

package/dist/interactions/coilFunctions.js

@@ -0,0 +1,213 @@
+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 { pactRead } from "@stoachain/stoa-core/reads";
+import { formatDecimalForPact, safeCreationTime } from "@stoachain/stoa-core/pact";
+import { universalSignTransaction, fromKeypair } from "@stoachain/stoa-core/signing";
+import { getLogger } from "@stoachain/stoa-core/observability";
+const coilPatternCache = new Map();
+function getCoilPatterns(targetTokenName) {
+    const cached = coilPatternCache.get(targetTokenName);
+    if (cached)
+        return cached;
+    const eliteHyphen = targetTokenName.replace("ELITE", "ELITE-");
+    const eliteSpace = targetTokenName.replace("ELITE", "Elite ");
+    const tail = targetTokenName.slice(-4);
+    const built = {
+        generates: [
+            new RegExp(`generates\\s+([\\d.]+)\\s+${targetTokenName}`, "i"),
+            new RegExp(`generates\\s+([\\d.]+)\\s+${eliteHyphen}`, "i"),
+            new RegExp(`generates\\s+([\\d.]+)\\s+${eliteSpace}`, "i"),
+            new RegExp(`generates\\s+([\\d.]+)\\s+\\w*${tail}\\w*`, "i"),
+        ],
+        generating: [
+            new RegExp(`generating\\s+([\\d.]+)\\s+${targetTokenName}`, "i"),
+            new RegExp(`generating\\s+([\\d.]+)\\s+${eliteHyphen}`, "i"),
+            new RegExp(`generating\\s+([\\d.]+)\\s+${eliteSpace}`, "i"),
+            new RegExp(`generating\\s+([\\d.]+)\\s+\\w*${tail}\\w*`, "i"),
+        ],
+    };
+    coilPatternCache.set(targetTokenName, built);
+    return built;
+}
+// Coiling configurations for each token pair
+export const COIL_CONFIGS = {
+    ouroToAuryn: {
+        atsPair: "Auryndex-O136CBn22ncY",
+        sourceToken: "OURO-8Nh-JO8JO4F5",
+        targetToken: "AURYN-8Nh-JO8JO4F5",
+        previewCommand: "Auryndex-O136CBn22ncY"
+    },
+    aurynToElite: {
+        atsPair: "EliteAuryndex-O136CBn22ncY",
+        sourceToken: "AURYN-8Nh-JO8JO4F5",
+        targetToken: "ELITEAURYN-8Nh-JO8JO4F5",
+        previewCommand: "EliteAuryndex-O136CBn22ncY"
+    },
+    wkdaToLkda: {
+        atsPair: "SilverStoaPillar-O136CBn22ncY",
+        sourceToken: "WSTOA-8Nh-JO8JO4F5",
+        targetToken: "SSTOA-8Nh-JO8JO4F5",
+        previewCommand: "SilverStoaPillar-O136CBn22ncY"
+    }
+};
+// Generic coil preview function
+export async function getCoilPreviewGeneric(amount, config) {
+    try {
+        const decimalAmount = formatDecimalForPact(amount);
+        const executionString = `(${KADENA_NAMESPACE}.INFO-ONE.ATS|INFO_Coil "preview" "preview" "${config.atsPair}" "${config.sourceToken}" ${decimalAmount})`;
+        const response = await pactRead(executionString, { tier: "T2" });
+        if (!response?.result?.status || response.result.status !== "success") {
+            throw new Error("Failed to get coil preview");
+        }
+        const data = response.result.data;
+        // Extract target token amount from text arrays (like original getCoilPreview)
+        let targetAmount = 0;
+        const targetTokenName = config.targetToken.replace('-8Nh-JO8JO4F5', ''); // ELITEAURYN, SSTOA, etc
+        // v3.3.6 (F-PERF-003): pull the 8 RegExp instances from the
+        // per-targetTokenName memoization cache instead of compiling them
+        // 8x per call. Behaviorally identical — same patterns, same order.
+        const patterns = getCoilPatterns(targetTokenName);
+        // Check pre-text array for target token amount
+        if (data && data['pre-text']) {
+            for (const text of data['pre-text']) {
+                for (const pattern of patterns.generates) {
+                    const tokenMatch = text.match(pattern);
+                    if (tokenMatch) {
+                        targetAmount = parseFloat(tokenMatch[1]);
+                        break;
+                    }
+                }
+                if (targetAmount > 0)
+                    break;
+            }
+        }
+        // Fallback: check post-text array
+        if (!targetAmount && data && data['post-text']) {
+            for (const text of data['post-text']) {
+                for (const pattern of patterns.generating) {
+                    const tokenMatch = text.match(pattern);
+                    if (tokenMatch) {
+                        targetAmount = parseFloat(tokenMatch[1]);
+                        break;
+                    }
+                }
+                if (targetAmount > 0)
+                    break;
+            }
+        }
+        // Final fallback: try parsing data[0] if no text match found
+        if (!targetAmount && data && Array.isArray(data) && data.length > 0) {
+            const fallbackAmount = parseFloat(data[0]);
+            if (!isNaN(fallbackAmount) && fallbackAmount > 0) {
+                targetAmount = fallbackAmount;
+            }
+        }
+        const result = {
+            targetAmount,
+            fee: 0, // Like original, always 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,
+            }
+        };
+        return result;
+    }
+    catch (error) {
+        getLogger().error("Error getting coil preview:", error);
+        throw error;
+    }
+}
+// Generic coil transaction function
+export async function coilTokensGeneric(ouroAccount, kadenaAccount, guard, targetAccount, amount, config) {
+    const keysetName = `ks`;
+    // Ensure amount is formatted as decimal
+    const decimalAmount = formatDecimalForPact(amount);
+    let gasLimit = 70000; // Default gas limit
+    // Coiling operation initiated
+    const buildTransaction = (gasLimitOverride) => {
+        return Pact.builder
+            .execution(`(${KADENA_NAMESPACE}.TS01-C2.ATS|C_Coil "${ouroAccount.address}" "${targetAccount}" "${config.atsPair}" "${config.sourceToken}" ${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);
+    // Simulation completed successfully
+    // 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 = Math.ceil(requiredGas * 1.2);
+        // Gas limit adjusted based on simulation
+        transaction = buildTransaction(gasLimit);
+    }
+    // Sign and submit the transaction
+    const signedTransaction = await universalSignTransaction(transaction, [
+        fromKeypair(kadenaAccount),
+        fromKeypair(guard),
+    ]);
+    // Submit the signed transaction
+    const result = await submit(signedTransaction);
+    return result;
+}
+// Specific functions for each coiling operation
+// OURO → AURYN (backward compatibility)
+export async function getCoilPreview(ouroAmount) {
+    const result = await getCoilPreviewGeneric(ouroAmount, COIL_CONFIGS.ouroToAuryn);
+    return {
+        auryn: result.targetAmount,
+        fee: result.fee,
+        kadenaInfo: result.kadenaInfo
+    };
+}
+export async function coilOuroToAuryn(ouroAccount, kadenaAccount, guard, targetAccount, ouroAmount) {
+    return coilTokensGeneric(ouroAccount, kadenaAccount, guard, targetAccount, ouroAmount, COIL_CONFIGS.ouroToAuryn);
+}
+// AURYN → Elite-AURYN
+export async function getAurynCoilPreview(aurynAmount) {
+    const result = await getCoilPreviewGeneric(aurynAmount, COIL_CONFIGS.aurynToElite);
+    return {
+        eliteAuryn: result.targetAmount,
+        fee: result.fee,
+        kadenaInfo: result.kadenaInfo
+    };
+}
+export async function coilAurynToElite(ouroAccount, kadenaAccount, guard, targetAccount, aurynAmount) {
+    return coilTokensGeneric(ouroAccount, kadenaAccount, guard, targetAccount, aurynAmount, COIL_CONFIGS.aurynToElite);
+}
+// WSTOA → SSTOA
+export async function getWkdaCoilPreview(wkdaAmount) {
+    const result = await getCoilPreviewGeneric(wkdaAmount, COIL_CONFIGS.wkdaToLkda);
+    return {
+        lkda: result.targetAmount,
+        fee: result.fee,
+        kadenaInfo: result.kadenaInfo
+    };
+}
+export async function coilWkdaToLkda(ouroAccount, kadenaAccount, guard, targetAccount, wkdaAmount) {
+    return coilTokensGeneric(ouroAccount, kadenaAccount, guard, targetAccount, wkdaAmount, COIL_CONFIGS.wkdaToLkda);
+}

package/dist/interactions/crossChainFunctions.d.ts

@@ -0,0 +1,211 @@
+import { ITransactionDescriptor } from "@stoachain/kadena-stoic-legacy/client";
+/**
+ * Get KDA balance for an account on a specific chain.
+ * exists=false means the account row does not exist on that chain (not just zero balance).
+ */
+export declare function getBalanceOnChain(account: string, chainId: string, tier?: "T1" | "T2" | "T3"): Promise<{
+    balance: string;
+    exists: boolean;
+    error?: string;
+}>;
+export interface CrossChainTransferParams {
+    sender: string;
+    receiver: string;
+    receiverGuard: {
+        keys: string[];
+        pred: "keys-all" | "keys-any" | "keys-2";
+    };
+    amount: string;
+    sourceChain: string;
+    targetChain: string;
+    senderPublicKey: string;
+}
+export interface TransferStatus {
+    status: "pending" | "success" | "failure" | "not-found";
+    continuation?: {
+        pactId: string;
+        step: number;
+        stepHasRollback: boolean;
+    };
+    result?: any;
+    error?: string;
+}
+/**
+ * Build a cross-chain transfer transaction (step 1)
+ * This creates a transaction that needs to be signed and submitted
+ */
+export declare function buildCrossChainTransfer(params: CrossChainTransferParams): any;
+export interface CTransferAcrossParams {
+    sender: string;
+    receiver: string;
+    receiverGuard: {
+        keys: string[];
+        pred: string;
+    };
+    amount: string;
+    sourceChain: string;
+    targetChain: string;
+    senderPublicKey: string;
+    /** Required for chain 0 — Ouronet Gas Station pub key */
+    gasStationPublicKey?: string;
+}
+/**
+ * Build a coin.C_TransferAcross transaction (step 0 of cross-chain transfer).
+ *
+ * Chain 0: Gas paid by Ouronet Gas Station (DALOS.GAS_PAYER).
+ * Other chains: Gas paid by kadena-xchain-gas (unsigned).
+ */
+export declare function buildCTransferAcross(params: CTransferAcrossParams): any;
+/**
+ * Submit a cross-chain transfer and get the request key.
+ *
+ * Resolves to the chainweb `ITransactionDescriptor` (request key + chain id +
+ * network id) for the submitted transaction. Caller is responsible for
+ * persisting the descriptor — it's the only handle for `pollTransactionStatus`,
+ * `fetchSpvProof`, and `submitContinuation` later in the cross-chain flow.
+ *
+ * **Error contract** (closes audit finding F-ERR-001 — v3.2.3):
+ *
+ * Unlike its sibling `pollTransactionStatus` (which catches errors and
+ * returns `{ status: "pending", error: ... }` — the codebase's discriminated-
+ * union convention), this function deliberately propagates errors rather
+ * than swallowing them. A failed submit is not a transient state to poll
+ * past — it means the transaction did NOT land on chain, and the caller's
+ * UI must surface that as a hard failure (refund the user's escrowed gas
+ * estimate, present a retry button, etc.). Wrapping the throw in an
+ * envelope would mask the failure.
+ *
+ * @throws {SigningError} with `code: "TIMEOUT"` if the underlying
+ *   `submit()` exceeds the per-tier deadline (default 60s for submit).
+ *   See `runWithTimeout` in `src/network/failoverClient.ts`.
+ * @throws {Error} On network failure that survives both the primary and
+ *   fallback node attempts. Both errors propagate verbatim from
+ *   `getFailoverClient`'s submit method — the caller's catch block
+ *   should distinguish via `error instanceof SigningError && error.code === "TIMEOUT"`.
+ */
+export declare function submitCrossChainTransfer(signedTransaction: any, sourceChain: string): Promise<ITransactionDescriptor>;
+/**
+ * Poll for transaction status on source chain
+ */
+export declare function pollTransactionStatus(requestKey: string, chainId: string): Promise<TransferStatus>;
+/**
+ * Fetch SPV proof for a cross-chain transfer.
+ *
+ * Requires waiting for block finality (~100-120 seconds). The on-chain
+ * proof becomes available a few blocks after the source-chain submit
+ * commits; before that, the chainweb node returns `400 not available`.
+ *
+ * v3.2.3 (closes audit finding F-BUG-004): wrapped in `withFailover` and
+ * `AbortSignal.timeout(SPV_PROOF_TIMEOUT_MS)`. Pre-v3.2.3, this was the
+ * only chain-RPC function in the entire codebase that called raw `fetch()`
+ * without either guard:
+ *
+ *   - No `AbortController`: a wedged primary node (slow, not erroring)
+ *     would hang the `await fetch(...)` indefinitely. The outer
+ *     `pollSpvProof` retry loop never advanced because each attempt
+ *     awaited the hung fetch.
+ *
+ *   - No `withFailover`: even if the primary node returned an error or
+ *     timed out, traffic stayed pinned to the primary; the consumer's
+ *     subsequent attempts hit the same wedged node forever.
+ *
+ *   - Combined consequence: the user's KDA was committed to
+ *     `kadena-xchain-gas` escrow on the source chain (step 1 succeeded),
+ *     but step 2's SPV proof retrieval hung silently with the UI showing
+ *     a perpetual "Waiting for SPV proof..." spinner and no recovery
+ *     path. This is the highest-impact bug surfaced by the 2026-05-05
+ *     audit.
+ *
+ * Post-v3.2.3 behaviour: each attempt has a hard 30s deadline; on timeout
+ * (or any network-class error on the primary node), `withFailover`
+ * switches to the fallback node and retries once. The outer
+ * `pollSpvProof` loop then re-invokes this function after the configured
+ * `delayMs` (default 5s), so a stuck primary surfaces as ~30s of
+ * waiting, then automatic fallback, then continued polling — never an
+ * infinite hang.
+ */
+export declare function fetchSpvProof(requestKey: string, sourceChain: string, targetChain: string): Promise<{
+    proof: string | null;
+    error?: string;
+}>;
+/**
+ * Poll for SPV proof with retry logic
+ * Will retry until proof is available or max attempts reached
+ */
+export declare function pollSpvProof(requestKey: string, sourceChain: string, targetChain: string, maxAttempts?: number, delayMs?: number, onProgress?: (attempt: number, maxAttempts: number) => void): Promise<{
+    proof: string | null;
+    error?: string;
+}>;
+/**
+ * Build a continuation transaction for step 2 of cross-chain transfer
+ * This can be executed by anyone - no signature required from original sender
+ */
+export declare function buildContinuationTransaction(pactId: string, proof: string, targetChain: string, gasPayerAccount?: string): any;
+/**
+ * Submit a continuation transaction.
+ *
+ * Note: for the public gas station path (chain 0 + DALOS.GAS_PAYER), no
+ * signature is needed — the caller passes the unsigned `transaction`
+ * directly. For user-paid-gas paths the transaction MUST be signed before
+ * this function is called; the function itself does not sign.
+ *
+ * **Error contract** (closes audit finding F-ERR-001 — v3.2.3): same
+ * propagating-throw pattern as `submitCrossChainTransfer`. A failed
+ * continuation submit is a hard failure, not a transient state — surface
+ * to the user, don't swallow.
+ *
+ * @throws {SigningError} with `code: "TIMEOUT"` if `submit()` exceeds
+ *   the per-tier deadline.
+ * @throws {Error} On network failure surviving both primary and fallback
+ *   node attempts.
+ */
+export declare function submitContinuation(transaction: any, targetChain: string): Promise<ITransactionDescriptor>;
+/**
+ * Listen for transaction completion (long-poll for chainweb inclusion).
+ *
+ * Resolves to the chainweb command-result envelope when the transaction
+ * is included in a block (~30-180s on mainnet depending on block density).
+ *
+ * **Error contract** (closes audit finding F-ERR-001 — v3.2.3): a thrown
+ * error from this function is **NOT** a definitive failure. The chainweb
+ * `listen` endpoint times out after a per-tier deadline (default 180s,
+ * approximately 6 Kadena blocks); if the deadline fires, the transaction
+ * may still complete on chain — it just hasn't been included yet by the
+ * time this function gives up. Callers should treat a `SigningError(code:
+ * "TIMEOUT")` from this function as `status: "pending"` (poll again
+ * later via `pollTransactionStatus`), NOT as `status: "failed"` (do not
+ * retry the submit; it would double-pay gas for a transaction that may
+ * already be confirmed). This is the exact pattern that audit finding
+ * F-ERR-014 surfaced for the multi-step add-liquidity flow before that
+ * surface was deleted in v3.2.2.
+ *
+ * @throws {SigningError} with `code: "TIMEOUT"` if `listen()` exceeds
+ *   the 180s deadline. **Treat as pending, not failed.**
+ * @throws {Error} On network failure surviving both primary and fallback
+ *   node attempts.
+ */
+export declare function listenForCompletion(requestKey: string, chainId: string): Promise<any>;
+/**
+ * Simulate a Pact code execution to check if it will succeed.
+ *
+ * Public-API break (v1.8): the first parameter is now the raw Pact code string
+ * rather than a built transaction. Consumers that previously held the built
+ * transaction now hold the pact-code string they fed into `.execution(...)`.
+ */
+export declare function simulateTransaction(pactCode: string, chainId: string): Promise<{
+    success: boolean;
+    result?: any;
+    error?: string;
+    gas?: number;
+}>;
+/**
+ * Get pending cross-chain transfers for an account
+ * Checks for continuation status
+ */
+export declare function getContinuationStatus(requestKey: string, sourceChain: string): Promise<{
+    exists: boolean;
+    completed: boolean;
+    pactId?: string;
+    step?: number;
+    error?: string;
+}>;