@ouronet/ouronet-core 4.3.6

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/interactions/activateFunctions.d.ts

@@ -0,0 +1,67 @@
+/**
+ * activateFunctions.ts
+ * Info + execute functions for C_DeployStandardAccount (Activate Standard Ouronet Account).
+ */
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+export type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+export interface DeployStandardAccountInfo {
+    ignis: {
+        "ignis-need": number;
+        "ignis-full"?: number;
+        "ignis-discount"?: number;
+        "ignis-text"?: string;
+    };
+    kadena: {
+        "kadena-need"?: number;
+        "kadena-full": number;
+        "kadena-targets": string[];
+        "kadena-split": number[];
+        "kadena-text"?: string;
+    };
+    "pre-text"?: string | string[];
+    "post-text"?: string | string[];
+}
+export interface DeployStandardAccountFullInfo {
+    info: DeployStandardAccountInfo;
+    receivers: string[];
+}
+/**
+ * Fetches info for C_DeployStandardAccount.
+ * Also resolves the 4 receiver addresses from kadena-targets via DALOS.UR_AccountKadena.
+ * Single network call combining both.
+ */
+/**
+ * Fetches ONLY the INFO response (no receiver resolution).
+ * Used by FunctionInfoZone — simpler, won't fail if kadena-targets resolution has issues.
+ */
+export declare function getDeployStandardAccountInfoOnly(account: string): Promise<any | null>;
+export declare function getDeployStandardAccountInfo(account: string): Promise<DeployStandardAccountFullInfo | null>;
+export type DeploySmartAccountInfo = DeployStandardAccountInfo;
+export type DeploySmartAccountFullInfo = DeployStandardAccountFullInfo;
+/** Fetches ONLY the INFO response for C_DeploySmartAccount (no receiver
+ *  resolution). Mirror of {@link getDeployStandardAccountInfoOnly}. */
+export declare function getDeploySmartAccountInfoOnly(account: string): Promise<any | null>;
+/** Fetches INFO + resolves the receiver addresses for C_DeploySmartAccount.
+ *  Mirror of {@link getDeployStandardAccountInfo}. */
+export declare function getDeploySmartAccountInfo(account: string): Promise<DeploySmartAccountFullInfo | null>;
+export interface DeployStandardAccountParams {
+    /** INPUT I  — Ouronet account address to activate */
+    account: string;
+    /** INPUT II — guard keyset keys (pub keys, 64 hex chars each) */
+    guardKeys: string[];
+    /** INPUT II — guard predicate */
+    guardPred: string;
+    /** INPUT III — k: Stoa account that sends the 4 coin.TRANSFER payments */
+    kadenaAddress: string;
+    /** INPUT IV — Ouronet account public key */
+    publicKey: string;
+    /** 4 receiver addresses (from info kadena-targets → UR_AccountKadena) */
+    receivers: string[];
+    /** 4 transfer amounts (from info kadena-split) */
+    amounts: number[];
+    /** CodexPrime Key #0 — signs GAS_PAYER + 4× coin.TRANSFER */
+    gasPayerKey: IKadenaKeypair;
+    /** Guard keyset signer keys (pure signers, de-duped with gasPayerKey) */
+    guardSignerKeys: IKadenaKeypair[];
+}
+export declare function executeDeployStandardAccount(params: DeployStandardAccountParams): Promise<any>;

package/dist/interactions/activateFunctions.js

@@ -0,0 +1,154 @@
+/**
+ * activateFunctions.ts
+ * Info + execute functions for C_DeployStandardAccount (Activate Standard Ouronet Account).
+ */
+import { KADENA_NAMESPACE, KADENA_CHAIN_ID, KADENA_NETWORK, STOA_AUTONOMIC_OURONETGASSTATION, } 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 { universalSignTransaction, fromKeypair } from "@stoachain/stoa-core/signing";
+import { calculateAutoGasLimit } from "@stoachain/stoa-core/gas";
+import { createSimulationError, logDetailedError } from "@stoachain/stoa-core/errors";
+import { getLogger } from "@stoachain/stoa-core/observability";
+import { safeCreationTime } from "@stoachain/stoa-core/pact";
+// ─── Info ─────────────────────────────────────────────────────────────────────
+/**
+ * Fetches info for C_DeployStandardAccount.
+ * Also resolves the 4 receiver addresses from kadena-targets via DALOS.UR_AccountKadena.
+ * Single network call combining both.
+ */
+/**
+ * Fetches ONLY the INFO response (no receiver resolution).
+ * Used by FunctionInfoZone — simpler, won't fail if kadena-targets resolution has issues.
+ */
+export async function getDeployStandardAccountInfoOnly(account) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.INFO-ZERO.DALOS-INFO|URC_DeployStandardAccount "${account}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (response?.result?.status === "success")
+            return response.result.data;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getDeployStandardAccountInfoOnly:", error);
+        return null;
+    }
+}
+export async function getDeployStandardAccountInfo(account) {
+    try {
+        const pactCode = `(let*` +
+            `  ((info (${KADENA_NAMESPACE}.INFO-ZERO.DALOS-INFO|URC_DeployStandardAccount "${account}"))` +
+            `   (receivers (map (${KADENA_NAMESPACE}.DALOS.UR_AccountKadena) (at "kadena-targets" (at "kadena" info))))` +
+            `)` +
+            `{ "info": info, "receivers": receivers })`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (response?.result?.status === "success") {
+            const data = response.result.data;
+            return { info: data.info, receivers: data.receivers };
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error fetching DeployStandardAccount info:", error);
+        return null;
+    }
+}
+/** Fetches ONLY the INFO response for C_DeploySmartAccount (no receiver
+ *  resolution). Mirror of {@link getDeployStandardAccountInfoOnly}. */
+export async function getDeploySmartAccountInfoOnly(account) {
+    try {
+        const pactCode = `(${KADENA_NAMESPACE}.INFO-ZERO.DALOS-INFO|URC_DeploySmartAccount "${account}")`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (response?.result?.status === "success")
+            return response.result.data;
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error in getDeploySmartAccountInfoOnly:", error);
+        return null;
+    }
+}
+/** Fetches INFO + resolves the receiver addresses for C_DeploySmartAccount.
+ *  Mirror of {@link getDeployStandardAccountInfo}. */
+export async function getDeploySmartAccountInfo(account) {
+    try {
+        const pactCode = `(let*` +
+            `  ((info (${KADENA_NAMESPACE}.INFO-ZERO.DALOS-INFO|URC_DeploySmartAccount "${account}"))` +
+            `   (receivers (map (${KADENA_NAMESPACE}.DALOS.UR_AccountKadena) (at "kadena-targets" (at "kadena" info))))` +
+            `)` +
+            `{ "info": info, "receivers": receivers })`;
+        const response = await pactRead(pactCode, { tier: "T5" });
+        if (response?.result?.status === "success") {
+            const data = response.result.data;
+            return { info: data.info, receivers: data.receivers };
+        }
+        return null;
+    }
+    catch (error) {
+        getLogger().error("Error fetching DeploySmartAccount info:", error);
+        return null;
+    }
+}
+export async function executeDeployStandardAccount(params) {
+    const { account, guardKeys, guardPred, kadenaAddress, publicKey, receivers, amounts, gasPayerKey, guardSignerKeys, } = params;
+    const pactCode = `(${KADENA_NAMESPACE}.TS01-C1.DALOS|C_DeployStandardAccount` +
+        ` "${account}"` +
+        ` (read-keyset "ks")` +
+        ` "${kadenaAddress}"` +
+        ` "${publicKey}"` +
+        `)`;
+    let gasLimit = 2000000;
+    const buildTransaction = (gasLimitOverride) => {
+        const effectiveGasLimit = gasLimitOverride ?? gasLimit;
+        let builder = Pact.builder
+            .execution(pactCode)
+            .addData("ks", { keys: guardKeys, pred: guardPred })
+            .setMeta({
+            senderAccount: STOA_AUTONOMIC_OURONETGASSTATION,
+            creationTime: safeCreationTime(),
+            chainId: KADENA_CHAIN_ID,
+            gasLimit: effectiveGasLimit,
+        })
+            .setNetworkId(KADENA_NETWORK)
+            // CodexPrime Key #0: GAS_PAYER + 4× coin.TRANSFER
+            .addSigner(gasPayerKey.publicKey, (w) => [
+            w(`${KADENA_NAMESPACE}.DALOS.GAS_PAYER`, "", { int: 0 }, { decimal: "0.0" }),
+            ...receivers.map((receiver, i) => w("coin.TRANSFER", kadenaAddress, receiver, { decimal: String(amounts[i]) })),
+        ]);
+        // Guard keys — pure signers (skip if already added as gasPayerKey)
+        const addedPubs = new Set([gasPayerKey.publicKey]);
+        for (const k of guardSignerKeys) {
+            if (!addedPubs.has(k.publicKey)) {
+                builder = builder.addSigner(k.publicKey);
+                addedPubs.add(k.publicKey);
+            }
+        }
+        return builder.createTransaction();
+    };
+    const { dirtyRead, submit } = getFailoverClient(KADENA_CHAIN_ID);
+    // 1. Simulate with 2M (network max)
+    let transaction = buildTransaction();
+    const simulation = await dirtyRead(transaction);
+    if (simulation.result.status === "failure") {
+        const error = createSimulationError("Activate Standard Account", simulation.result, `Account: ${account} | Kadena: ${kadenaAddress}`);
+        logDetailedError(error);
+        throw error;
+    }
+    // 2. Adaptive gas: rebuild with calibrated limit
+    const requiredGas = simulation.gas;
+    if (requiredGas) {
+        gasLimit = calculateAutoGasLimit(requiredGas);
+        transaction = buildTransaction(gasLimit);
+    }
+    // 3. Sign & submit
+    const allSigners = [gasPayerKey];
+    const seenPubs = new Set([gasPayerKey.publicKey]);
+    for (const k of guardSignerKeys) {
+        if (!seenPubs.has(k.publicKey)) {
+            allSigners.push(k);
+            seenPubs.add(k.publicKey);
+        }
+    }
+    const signed = await universalSignTransaction(transaction, allSigners.map((s) => fromKeypair(s)));
+    return await submit(signed);
+}

package/dist/interactions/addLiquidityFunctions.d.ts

@@ -0,0 +1,140 @@
+import type { IOuroAccountKeypair } from "./dexTypes.js";
+import type { IKadenaKeypair } from "@stoachain/stoa-core/signing";
+export interface LiquidityData {
+    readonly [key: string]: any;
+}
+export interface DeviationResult {
+    readonly deviation: number;
+    readonly maxDeviation: number;
+    readonly isValid: boolean;
+}
+export interface AddLiquidityParams {
+    readonly patronKeypair: IOuroAccountKeypair;
+    readonly kadenaKeypair: IKadenaKeypair;
+    readonly guardKeypair: IKadenaKeypair;
+    readonly account: string;
+    readonly swpair: string;
+    readonly inputAmounts: string[];
+}
+export interface LPTypeInfo {
+    readonly hasFrozenLP: boolean | null;
+    readonly hasSleepingLP: boolean | null;
+}
+export interface SpecialLPParams {
+    readonly type: "iced" | "glacial" | "frozen" | "sleeping";
+    readonly frozenDptf?: string;
+    readonly sleepingDpmf?: string;
+    readonly nonce?: number;
+}
+/**
+ * Generate LiquidityData object for deviation validation
+ */
+export declare function generateLiquidityData(swpair: string, input: string, amounts: number[]): Promise<LiquidityData | null>;
+/**
+ * Validate liquidity deviation
+ */
+export declare function validateLiquidityDeviation(swpair: string, liquidityData: LiquidityData): Promise<DeviationResult | null>;
+/**
+ * Calculate balanced liquidity amounts based on one input token
+ */
+export declare function calculateBalancedLiquidity(swpair: string, inputTokenId: string, inputAmount: string, withValidation?: boolean): Promise<string[]>;
+/**
+ * Check if pool supports special LP types
+ */
+export declare function getLPTypeInfo(swpair: string): Promise<LPTypeInfo>;
+/**
+ * Execute single-step add liquidity (TS01-C3 module)
+ */
+export declare function executeAddLiquiditySingle(params: AddLiquidityParams): Promise<any>;
+/**
+ * Main add liquidity function — single-step with gas simulation.
+ *
+ * REMOVED IN v3.2.2: the four multi-step execute functions
+ * (`executeAddLiquidityMultiStep1`, `executeAddLiquidityMultiStep2`,
+ * `executeAddLiquidityMultiStep3`, `executeAddLiquidityMultiStepComplete`)
+ * and the `MultiStepAddLiquidityResult` type they returned. The
+ * multi-step pipeline existed because the historical Kadena chainweb
+ * gas limit (150k per block) couldn't fit a single-block add-liquidity
+ * transaction; the consumer had to split into a defpact with two
+ * continuation steps. StoaChain's chainweb runs at 2M gas per block
+ * (13×), which fits the entire add-liquidity flow in one transaction —
+ * so the multi-step path has been dead code in OuronetUI since the
+ * gas-limit increase. Removing it closes audit findings F-ERR-005
+ * (`error.message.includes` on possibly-undefined retry-loop crashes),
+ * F-ERR-014 (listen timeout vs submit failure double-pay risk),
+ * F-PERF-014 (4× hardcoded 3-second sleeps), F-PERF-015 (retry-with-
+ * fixed-sleep against string-matched error messages), and F-API-026
+ * (the `_strategy` parameter on `executeAddLiquidity` was always
+ * `"auto"` → single-step path; dead public surface).
+ *
+ * The Pact-side multi-step contract still exists on chain
+ * (`TS01-CP.SWP|C_AddStandardLiquidity` defpact with continuation
+ * steps) — preserved for historical interoperability. This package
+ * just stops exposing the TypeScript wrappers around it because no
+ * consumer needs them any more.
+ */
+export declare function executeAddLiquidity(params: AddLiquidityParams): Promise<any>;
+/**
+ * Execute special LP type add liquidity (Iced, Glacial, Frozen, Sleeping)
+ */
+export declare function executeSpecialAddLiquidity(params: AddLiquidityParams, specialParams: SpecialLPParams): Promise<any>;
+/**
+ * URC_BalancedLiquidity — compute balanced amounts for all tokens given one input.
+ * Returns decimal[] with balanced values for each pool token.
+ */
+export declare function getBalancedLiquidity(swpair: string, inputId: string, inputAmount: string, withValidation?: boolean): Promise<string[] | null>;
+/**
+ * URC_SortLiquidity — split input amounts into balanced + asymmetric portions.
+ * Returns { balanced: string[], asymmetric: string[] }
+ */
+export declare function getSortLiquidity(swpair: string, inputAmounts: string[]): Promise<{
+    balanced: string[];
+    asymmetric: string[];
+} | null>;
+/**
+ * URC_LD — build LiquidityData object from input amounts.
+ */
+export declare function getLiquidityData(swpair: string, inputAmounts: string[]): Promise<any | null>;
+/**
+ * UEV_Liquidity — validate asymmetric liquidity doesn't exceed max deviation.
+ * Returns true if valid, false if deviation too high.
+ */
+/**
+ * Validate asymmetric liquidity deviation.
+ * Returns { valid: true, computed: string, max: string } on success,
+ * { valid: false } when deviation exceeds limit (chain rejection / validation failure),
+ * or { valid: false, error: string } when the read itself throws (RPC failure).
+ * Consumers distinguish RPC failure from validation rejection by checking the optional `error` field.
+ */
+export declare function validateLiquidity(swpair: string, inputAmounts: string[]): Promise<{
+    valid: boolean;
+    computed?: string;
+    max?: string;
+    error?: string;
+}>;
+/**
+ * Execute Fuel — transfer tokens into pool without receiving LP.
+ * (ouronet-ns.TS01-C3.SWP|C_Fuel patron account swpair input-amounts)
+ */
+export declare function executeFuel(params: AddLiquidityParams): Promise<any>;
+/**
+ * Execute Remove Liquidity (Unfold) — burn LP tokens to recover underlying pool tokens.
+ * (ouronet-ns.TS01-C3.SWP|C_RemoveLiquidity patron account swpair lp-amount)
+ */
+export declare function executeRemoveLiquidity(params: {
+    patronKeypair: {
+        address: string;
+        publicKey: string;
+    };
+    kadenaKeypair: {
+        publicKey: string;
+        secretKey: string;
+    };
+    guardKeypair: {
+        publicKey: string;
+        secretKey: string;
+    };
+    account: string;
+    swpair: string;
+    lpAmount: string;
+}): Promise<any>;