@kynesyslabs/demosdk 2.12.1 → 3.1.0

package/build/websdk/demosclass.js

@@ -15,6 +15,9 @@ import { web2Calls } from "./Web2Calls.js";
 import { hexToUint8Array, uint8ArrayToHex, UnifiedCrypto, } from "../encryption/unifiedCrypto.js";
 import { GCRGeneration } from "./GCRGeneration.js";
 import { Hashing } from "../encryption/Hashing.js";
+import { OS_PER_DEM, demToOs, parseOsString, } from "../denomination/index.js";
+import { serializeTransactionContent } from "../denomination/serializerGate.js";
+import { SubDemPrecisionError, } from "../denomination/networkInfo.js";
 import * as bip39 from "@scure/bip39";
 import { wordList } from "../encryption/PQC/falconts/index.js";
 async function sleep(ms) {
@@ -55,6 +58,24 @@ export class Demos {
         this.rpc_url = null;
         /** Cached TLSNotary instance */
         this._tlsnotaryInstance = null;
+        this._cachedNetworkParameters = null;
+        this._cachedNetworkParametersAt = 0;
+        this._cachedNetworkParametersRpcUrl = null;
+        // P4 commit 3: per-instance cached fork status. `null` after a failed
+        // detection attempt (`_cachedNetworkInfoFailed = true`) means we have
+        // already assumed pre-fork; we keep this state until the rpc_url
+        // changes or the failed-cache TTL elapses, to avoid hammering an
+        // unreachable node, and warn exactly once.
+        //
+        // PR-86 myc#18 — keyed by rpc_url, mirroring `_cachedNetworkParametersRpcUrl`.
+        // Without this, a single Demos instance reused across two RPCs (one
+        // pre-fork, one post-fork) would lock onto the first answer and sign
+        // transactions with the wrong wire shape against the second.
+        this._cachedNetworkInfo = null;
+        this._cachedNetworkInfoRpcUrl = null;
+        this._cachedNetworkInfoFailed = false;
+        this._cachedNetworkInfoFailedAt = 0;
+        this._cachedNetworkInfoWarned = false;
         /** Connection status of the RPC URL */
         this.connected = false;
         this.dual_sign = false;
@@ -120,9 +141,12 @@ export class Demos {
             /**
              * Get a cost quote for an IPFS operation without submitting a transaction.
              *
-             * Use this to estimate costs and populate custom_charges before signing.
-             * The returned cost should be used as max_cost_dem in the transaction's
-             * custom_charges field.
+             * Use this to estimate costs and populate `custom_charges` before signing.
+             * Pipe the response through `IPFSOperations.quoteToCustomCharges`
+             * (or `createCustomCharges`) to obtain a `max_cost_os` decimal-string
+             * suitable for the transaction's `custom_charges.ipfs.max_cost_os`
+             * field. The helpers handle both pre-fork (`cost_dem`) and
+             * post-fork (`cost_os`) node response shapes.
              *
              * @param fileSizeBytes - Size of file in bytes
              * @param operation - IPFS operation type ('IPFS_ADD', 'IPFS_PIN', or 'IPFS_UNPIN')
@@ -133,7 +157,6 @@ export class Demos {
              * ```typescript
              * // Get quote for add operation
              * const quote = await demos.ipfs.quote(content.length, 'IPFS_ADD')
-             * console.log(`Cost: ${quote.cost_dem} DEM`)
              *
              * // Use quote to build transaction with cost control
              * const payload = IPFSOperations.createAddPayload(content, {
@@ -205,6 +228,17 @@ export class Demos {
     async connect(rpc_url) {
         const response = await axios.get(rpc_url);
         if (response.status == 200) {
+            // PR-86 myc#18: a fresh connect (or reconnect to a different
+            // RPC) must drop the per-rpc cached fork status so the next
+            // sign() re-detects against the new node. Don't reset the
+            // warn-once flag — operators have already seen the warning
+            // for this instance's lifetime.
+            if (this.rpc_url !== rpc_url) {
+                this._cachedNetworkInfo = null;
+                this._cachedNetworkInfoRpcUrl = null;
+                this._cachedNetworkInfoFailed = false;
+                this._cachedNetworkInfoFailedAt = 0;
+            }
             this.rpc_url = rpc_url;
         }
         this.connected = true;
@@ -285,41 +319,69 @@ export class Demos {
     }
     // !SECTION Connection and listeners
     /**
-     * Generates a random MUID.
-     *
-     * @returns The MUID
+     * Generates a random MUID using a CSPRNG. Math.random is unsafe in any
+     * security-sensitive path (a predictable PRNG lets an attacker
+     * pre-compute MUIDs). 26 bytes → 52 hex chars, same length range as the
+     * legacy MUID format.
      */
     generateMuid() {
-        const number_1 = Math.random().toString(36).substring(2, 15) +
-            Math.random().toString(36).substring(2, 15);
-        const number_2 = Math.random().toString(36).substring(2, 15) +
-            Math.random().toString(36).substring(2, 15);
-        const muid = number_1 + number_2;
-        return muid;
+        const buf = new Uint8Array(26);
+        crypto.getRandomValues(buf);
+        return Array.from(buf, b => b.toString(16).padStart(2, "0")).join("");
     }
     /**
      * Create a signed DEMOS transaction to send native tokens to a given address.
      *
-     * @param to - The reciever
-     * @param amount - The amount in DEM
+     * P4 dual-input:
+     *  - `bigint` (preferred, post-v3): amount in OS (smallest unit;
+     *    1 DEM = 10^9 OS). Use `denomination.demToOs(...)` to convert
+     *    a human-readable DEM input.
+     *  - `number` (deprecated, v2 callers): amount in DEM. Auto-converted
+     *    to OS internally via `OS_PER_DEM`. Will be removed in v4.
+     *
+     * Sub-DEM precision is rejected with `SubDemPrecisionError` when
+     * the connected node is pre-fork — its legacy DEM-`number` wire
+     * cannot carry < 1 DEM and silent truncation is unacceptable. The
+     * caller can either round to a whole DEM or upgrade the target
+     * node.
+     *
+     * @example
+     * ```ts
+     * import { denomination } from "@kynesyslabs/demosdk"
+     * await demos.pay("0x...", denomination.demToOs(100))   // 100 DEM
+     * await demos.pay("0x...", 100_000_000_000n)             // raw OS
+     * await demos.pay("0x...", 100)                          // legacy DEM number (deprecated)
+     * ```
      *
+     * @param to - The receiver address (0x-prefixed hex).
+     * @param amount - DEM `number` (legacy) or OS `bigint` (preferred).
      * @returns The signed transaction.
      */
-    pay(to, amount) {
+    async pay(to, amount) {
         required(this.keypair, "Wallet not connected");
-        return DemosTransactions.pay(to, amount, this);
+        const amountOs = typeof amount === "bigint" ? amount : demToOs(amount);
+        await this._assertAmountAcceptableOnTargetNode(amountOs);
+        return DemosTransactions.pay(to, amountOs, this);
     }
     /**
      * Create a signed DEMOS transaction to send native tokens to a given address.
      *
-     * @param to - The reciever
-     * @param amount - The amount in DEM
+     * Alias of {@link pay}. Same dual-input semantics — `bigint` is the
+     * preferred OS shape; `number` is the deprecated legacy DEM shape.
      *
+     * @example
+     * ```ts
+     * import { denomination } from "@kynesyslabs/demosdk"
+     * await demos.transfer("0x...", denomination.demToOs("1.5"))  // 1.5 DEM
+     * await demos.transfer("0x...", 1_500_000_000n)                // raw OS
+     * ```
+     *
+     * @param to - The receiver address (0x-prefixed hex).
+     * @param amount - DEM `number` (legacy) or OS `bigint` (preferred).
      * @returns The signed transaction.
      */
-    transfer(to, amount) {
-        required(this.keypair, "Wallet not connected");
-        return DemosTransactions.pay(to, amount, this);
+    async transfer(to, amount) {
+        return this.pay(to, amount);
     }
     /**
      * Create a signed DEMOS transaction to store binary data on the blockchain.
@@ -432,17 +494,49 @@ export class Demos {
             raw_tx.content.from = "0x" + raw_tx.content.from;
         }
         raw_tx.content.gcr_edits = await GCRGeneration.generate(raw_tx);
-        // We derive the network fee from GCR edits (sum of sender balance removals minus `amount`).
-        // This is a pragmatic interim approach; ideally the node should authoritatively return fees
-        // to avoid drift between SDK and node logic.
+        // Node is source of truth for governance-driven fees; edits-derived
+        // calc kicks in only if RPC is unreachable or endpoint is missing.
+        let appliedFromNode = false;
         try {
-            raw_tx = this._calculateAndApplyGasFee(raw_tx);
+            const params = await this._getNetworkParametersCached();
+            if (params && typeof params.networkFee === "number") {
+                raw_tx.content.transaction_fee = {
+                    network_fee: params.networkFee,
+                    rpc_fee: typeof params.rpcFee === "number" ? params.rpcFee : 0,
+                    additional_fee: 0,
+                };
+                appliedFromNode = true;
+            }
         }
-        catch (e) {
-            // Non-fatal: if fee derivation fails, continue without modifying fees
-            console.warn("[demos] fee derivation skipped:", e);
+        catch {
+            /* fall through */
         }
-        raw_tx.hash = Hashing.sha256(JSON.stringify(raw_tx.content));
+        if (!appliedFromNode) {
+            try {
+                raw_tx = this._calculateAndApplyGasFee(raw_tx);
+            }
+            catch (e) {
+                console.warn("[demos] fee derivation skipped:", e);
+            }
+        }
+        // P4 commit 3: route hashing through the dual-format serializerGate
+        // with the cached fork status. The first `sign()` call after
+        // `connect()` triggers `getNetworkInfo`; subsequent signs reuse
+        // the cached result. On RPC failure the cache stays in
+        // "assume pre-fork" mode for the instance's lifetime.
+        const isPostFork = await this._isPostForkCached();
+        const serialized = serializeTransactionContent(raw_tx.content, isPostFork);
+        raw_tx.hash = Hashing.sha256(serialized);
+        // Normalise content to the wire shape the hash committed to.
+        // Without this, internal `bigint` carriers in `tx.content.amount`,
+        // `tx.content.transaction_fee.*`, and `gcr_edits[].amount` would
+        // leak into downstream `JSON.stringify` (axios body serialisation
+        // in confirm/broadcast), throwing TypeError on bigint or sending
+        // a different byte-shape than the one we just signed (which the
+        // node rejects as InvalidSignature). `JSON.parse(serialized)`
+        // round-trips through the canonical post-fork-or-pre-fork shape
+        // and matches the bytes hashed.
+        raw_tx.content = JSON.parse(serialized);
         const signature = await this.crypto.sign(this.algorithm, new TextEncoder().encode(raw_tx.hash));
         // INFO: We only dual-sign when signing with PQC keypairs
         let dual_sign = this.dual_sign && this.algorithm !== "ed25519";
@@ -511,12 +605,24 @@ export class Demos {
     /**
      * @private
      * Calculates and applies the gas fee for a transaction (SDK-level fallback).
-     * NOTE: We infer the fee by analyzing the generated GCR (Gas Consumption Record) edits:
-     * - Sum all "balance" edits with operation "remove" for the sender
-     * - Subtract the declared transaction `amount`
-     * The remainder is treated as the network fee. If a fee already exists on the tx, we only raise
-     * `network_fee` if the newly inferred fee is higher (prevents double-charging on re-sign).
-     * This is an interim approach; the preferred design is for the node to return fees explicitly.
+     *
+     * NOTE: We infer the fee by analyzing the generated GCR (Gas Consumption
+     * Record) edits:
+     * - Sum all "balance" edits with operation "remove" for the sender.
+     * - Subtract the declared transaction `amount`.
+     * The remainder is treated as the network fee. If a fee already exists on
+     * the tx, we only raise `network_fee` if the newly inferred fee is higher
+     * (prevents double-charging on re-sign). This is an interim approach; the
+     * preferred design is for the node to return fees explicitly.
+     *
+     * P4: arithmetic uses `bigint` internally so OS-magnitude amounts
+     * (~10^19 OS for whole-network supply) don't overflow JS `number`'s
+     * 2^53 safe-integer ceiling. The function tolerates legacy `number`
+     * (DEM) and post-fork `string` (OS) inputs in any field, normalises
+     * to OS-bigint via `_coerceWireAmountToOs`, then writes the
+     * derived fee back in DEM-`number` (legacy wire) — the
+     * serializerGate (P4 commit 2) re-encodes to OS at hash time when
+     * the connected node is post-fork.
      *
      * @param raw_tx - The transaction for which to calculate the fee.
      * @returns The updated transaction with the fee applied.
@@ -530,23 +636,28 @@ export class Demos {
         // INFO: The gas fee is calculated by summing up all "remove" balance edits for the sender's account
         // and then subtracting the actual transaction amount. This gives the value of the fee.
         const sender = (raw_tx.content.from_ed25519_address ?? "").toLowerCase();
-        const totalRemoved = edits.reduce((sum, edit) => {
+        let totalRemovedOs = 0n;
+        for (const edit of edits) {
             try {
                 if (edit.type === "balance" &&
                     edit.operation === "remove" &&
                     typeof edit.account === "string" &&
                     edit.account.toLowerCase() === sender) {
-                    const amt = Number(edit.amount);
-                    return sum + (Number.isFinite(amt) ? amt : 0);
+                    totalRemovedOs += Demos._coerceWireAmountToOs(edit.amount);
                 }
             }
             catch {
                 // skip malformed entries
             }
-            return sum;
-        }, 0);
-        const txAmt = Number(raw_tx.content.amount ?? 0);
-        const calculatedFee = Math.max(totalRemoved - (Number.isFinite(txAmt) ? txAmt : 0), 0);
+        }
+        let txAmtOs = 0n;
+        try {
+            txAmtOs = Demos._coerceWireAmountToOs(raw_tx.content.amount ?? 0);
+        }
+        catch {
+            txAmtOs = 0n;
+        }
+        const calculatedFeeOs = totalRemovedOs > txAmtOs ? totalRemovedOs - txAmtOs : 0n;
         // INFO: This logic handles both initial fee creation and accumulation for re-signed transactions.
         // To avoid fee accumulation, a new transaction object should be created for each signing.
         const existing = raw_tx.content.transaction_fee ?? {
@@ -554,19 +665,50 @@ export class Demos {
             rpc_fee: 0,
             additional_fee: 0,
         };
-        const totalExisting = (Number(existing.network_fee) || 0) +
-            (Number(existing.rpc_fee) || 0) +
-            (Number(existing.additional_fee) || 0);
-        // Only set the fee if no fees are already applied
-        if (totalExisting === 0) {
+        const totalExistingOs = Demos._coerceWireAmountToOs(existing.network_fee ?? 0) +
+            Demos._coerceWireAmountToOs(existing.rpc_fee ?? 0) +
+            Demos._coerceWireAmountToOs(existing.additional_fee ?? 0);
+        // Only set the fee if no fees are already applied. We emit the
+        // legacy DEM-number wire shape; the serializerGate normalises to
+        // OS-string post-fork. Convert OS bigint back to DEM number,
+        // assuming the inferred fee is a whole multiple of OS_PER_DEM
+        // (true for current 1-DEM gas + 1-DEM-per-KB storage formulas).
+        if (totalExistingOs === 0n) {
+            const feeDem = Number(calculatedFeeOs / OS_PER_DEM);
             raw_tx.content.transaction_fee = {
-                network_fee: calculatedFee,
+                network_fee: feeDem,
                 rpc_fee: 0,
                 additional_fee: 0,
             };
         }
         return raw_tx;
     }
+    /**
+     * Coerce a wire-format amount/fee value (legacy DEM `number`,
+     * post-fork OS decimal `string`, or in-flight `bigint`) to an OS
+     * `bigint`. Used by `_calculateAndApplyGasFee` and other internal
+     * arithmetic paths to stay in OS-bigint regardless of which wire
+     * shape the caller produced. Mirrors the node's `toOsBigint` helper
+     * in `forks/serializerGate.ts`.
+     *
+     * @internal
+     */
+    static _coerceWireAmountToOs(value) {
+        if (typeof value === "bigint") {
+            return value;
+        }
+        if (typeof value === "string") {
+            // Already on the wire as OS decimal string.
+            return parseOsString(value);
+        }
+        if (typeof value === "number") {
+            if (!Number.isFinite(value))
+                return 0n;
+            // Pre-fork DEM number → OS bigint.
+            return demToOs(value);
+        }
+        return 0n;
+    }
     // L2PS calls are defined here
     /**
      * Single transport wrapper for axios.post against the Demos RPC node.
@@ -871,6 +1013,18 @@ export class Demos {
     /**
      * Get information about an address.
      *
+     * P4: `balance` is `bigint` in **OS** (smallest unit, 1 DEM = 10^9 OS).
+     * Use `denomination.osToDem(info.balance)` for display.
+     *
+     * @example
+     * ```ts
+     * import { denomination } from "@kynesyslabs/demosdk"
+     * const info = await demos.getAddressInfo("0x...")
+     * if (info) {
+     *     console.log("balance:", denomination.osToDem(info.balance), "DEM")
+     * }
+     * ```
+     *
      * @param address - The address
      */
     async getAddressInfo(address) {
@@ -878,13 +1032,13 @@ export class Demos {
             address,
         });
         if (info) {
-            // REVIEW Fix for when the balance is 0 (see FIXME below)
-            if (!info.balance) {
-                info.balance = 0;
-            }
+            // Balance can come back as `null`/`undefined`/`0`/`"0"`/
+            // bigint-string. `BigInt(null)` throws, so coalesce to 0
+            // before parsing.
+            const rawBalance = info.balance ?? 0;
             return {
                 ...info,
-                balance: BigInt(info.balance), // FIXME This fails when the balance is 0
+                balance: BigInt(rawBalance),
             };
         }
         return null;
@@ -910,6 +1064,225 @@ export class Demos {
         }
         return 0;
     }
+    /**
+     * Get a validator's current record (stake, status, unstake timestamps).
+     * Returns null if the address is not (and never was) a validator.
+     */
+    async getValidatorInfo(address) {
+        return (await this.nodeCall("getValidatorInfo", {
+            address,
+        }));
+    }
+    /**
+     * List validators at a given block (defaults to the current head). Only
+     * returns validators whose `valid_at` block is <= the queried block and
+     * whose status is still active.
+     */
+    async getValidators(blockNumber) {
+        return ((await this.nodeCall("getValidators", {
+            blockNumber,
+        })) ?? []);
+    }
+    /**
+     * Convenience: return a single validator's current staked amount as a
+     * bigint-encoded string. Returns `"0"` for non-validators.
+     */
+    async getStakedAmount(address) {
+        const v = await this.nodeCall("getStakedAmount", { address });
+        return typeof v === "string" ? v : "0";
+    }
+    // SECTION Governance (stackable-genesis, Phase 1)
+    /**
+     * Returns the currently-active NetworkParameters — the result of folding
+     * every `active` NetworkUpgrade over the genesis defaults.
+     */
+    async getNetworkParameters() {
+        return (await this.nodeCall("getNetworkParameters"));
+    }
+    /**
+     * Returns network parameters with a short-lived TTL cache to reduce RPC
+     * calls during signing. Cache is scoped to the active `rpc_url` — a
+     * network change within TTL invalidates the entry.
+     *
+     * @param ttlMs - Cache TTL in milliseconds (default: 30_000).
+     * @returns The cached `NetworkParameters`, or `null` if not connected /
+     *   the response shape is invalid.
+     */
+    async _getNetworkParametersCached(ttlMs = 30000) {
+        if (!this.rpc_url)
+            return null;
+        const now = Date.now();
+        // Reuse the cached entry only if the underlying node hasn't changed.
+        // Without the rpc-url guard, switching networks within TTL applies
+        // the previous chain's fees to the new one's signed transactions.
+        if (this._cachedNetworkParameters &&
+            this._cachedNetworkParametersRpcUrl === this.rpc_url &&
+            now - this._cachedNetworkParametersAt < ttlMs) {
+            return this._cachedNetworkParameters;
+        }
+        const fresh = await this.getNetworkParameters();
+        // Validate shape before caching: nodeCall() can return a truthy
+        // RPC error envelope on transient failures; caching that would
+        // freeze the SDK on locally-derived fees for the full TTL.
+        if (fresh &&
+            typeof fresh === "object" &&
+            typeof fresh.networkFee === "number" &&
+            typeof fresh.rpcFee === "number") {
+            this._cachedNetworkParameters = fresh;
+            this._cachedNetworkParametersAt = now;
+            this._cachedNetworkParametersRpcUrl = this.rpc_url;
+            return fresh;
+        }
+        return null;
+    }
+    // SECTION Fork detection (P4 commit 3)
+    /**
+     * Fetches the connected node's per-fork activation status.
+     *
+     * Mirrors the node's `getNetworkInfo` `nodeCall`
+     * (`libs/network/handlers/forkHandlers.ts`). The response carries
+     * activation height, current chain head, and the `activated` boolean
+     * for every known fork.
+     *
+     * Caches the result on this `Demos` instance for the instance's
+     * lifetime (no TTL). To re-fetch after a node upgrade, construct a
+     * fresh `Demos` instance.
+     *
+     * On RPC failure (404, malformed response, network error), this
+     * method returns `null` and the SDK assumes pre-fork wire format.
+     * A `console.warn` is emitted exactly once per `Demos` instance
+     * recommending the operator upgrade the target node.
+     *
+     * @returns The fork-status payload, or `null` if the RPC failed.
+     */
+    async getNetworkInfo() {
+        // PR-86 myc#18: cache is keyed by rpc_url. A stale entry from a
+        // previously-connected RPC must not satisfy a lookup against
+        // the current one. Switch detection happens here (rather than
+        // only in connect()) so callers that mutate rpc_url via other
+        // paths still see correct behaviour.
+        if (this._cachedNetworkInfo &&
+            this._cachedNetworkInfoRpcUrl === this.rpc_url) {
+            return this._cachedNetworkInfo;
+        }
+        if (this._cachedNetworkInfo &&
+            this._cachedNetworkInfoRpcUrl !== this.rpc_url) {
+            // RPC has changed since we cached — invalidate before re-fetching.
+            this._cachedNetworkInfo = null;
+            this._cachedNetworkInfoRpcUrl = null;
+            this._cachedNetworkInfoFailed = false;
+            this._cachedNetworkInfoFailedAt = 0;
+        }
+        // Honour the failed-cache TTL so a transient outage doesn't lock
+        // the instance into pre-fork mode forever. After the TTL we'll
+        // retry; the warn-once flag is sticky regardless.
+        if (this._cachedNetworkInfoFailed &&
+            this._cachedNetworkInfoRpcUrl === this.rpc_url &&
+            Date.now() - this._cachedNetworkInfoFailedAt <
+                Demos._NETWORK_INFO_FAILURE_TTL_MS) {
+            return null;
+        }
+        let fresh = null;
+        try {
+            fresh = await this.nodeCall("getNetworkInfo");
+        }
+        catch {
+            // call() already swallows transport errors, but be defensive
+            // in case future nodeCall() rewrites surface them.
+            fresh = null;
+        }
+        if (fresh &&
+            typeof fresh === "object" &&
+            fresh.forks &&
+            fresh.forks.osDenomination &&
+            typeof fresh.forks.osDenomination.activated ===
+                "boolean") {
+            this._cachedNetworkInfo = fresh;
+            this._cachedNetworkInfoRpcUrl = this.rpc_url;
+            // A successful detection clears any stale failure memo for
+            // the current rpc_url.
+            this._cachedNetworkInfoFailed = false;
+            this._cachedNetworkInfoFailedAt = 0;
+            return this._cachedNetworkInfo;
+        }
+        // Cache the failure (with TTL) so we don't hammer an unreachable /
+        // pre-P3c node on every sign(). Warn once per instance.
+        this._cachedNetworkInfoFailed = true;
+        this._cachedNetworkInfoFailedAt = Date.now();
+        this._cachedNetworkInfoRpcUrl = this.rpc_url;
+        if (!this._cachedNetworkInfoWarned) {
+            this._cachedNetworkInfoWarned = true;
+            console.warn("getNetworkInfo unavailable on target node — assuming pre-fork wire format. Upgrade the node to a post-fork-aware version (>= the version that ships with forkHandlers). This fallback path is deprecated and will be removed in v4.");
+        }
+        return null;
+    }
+    /**
+     * @internal
+     * Cached fork-status accessor. Returns `osDenomination` activation
+     * status as a boolean. `false` is the safe default (legacy wire
+     * format) when the node is unreachable or pre-P3c.
+     */
+    async _isPostForkCached() {
+        const info = await this.getNetworkInfo();
+        return Boolean(info?.forks?.osDenomination?.activated);
+    }
+    /**
+     * @internal
+     * Reset the cached fork status. Intended for tests; production code
+     * should construct a fresh `Demos` instance instead.
+     */
+    _resetForkStatusCacheForTesting() {
+        this._cachedNetworkInfo = null;
+        this._cachedNetworkInfoRpcUrl = null;
+        this._cachedNetworkInfoFailed = false;
+        this._cachedNetworkInfoFailedAt = 0;
+        this._cachedNetworkInfoWarned = false;
+    }
+    /**
+     * @internal
+     * Sub-DEM precision guard. Run by every public-API entry point that
+     * takes a user-supplied OS amount before tx construction. Throws
+     * `SubDemPrecisionError` when the connected node is pre-fork and
+     * the amount carries sub-DEM precision (would silently truncate on
+     * the legacy DEM-`number` wire).
+     *
+     * @param amountOs - The OS amount the caller is sending.
+     */
+    async _assertAmountAcceptableOnTargetNode(amountOs) {
+        const isPostFork = await this._isPostForkCached();
+        if (isPostFork)
+            return;
+        const remainder = amountOs % OS_PER_DEM;
+        if (remainder !== 0n) {
+            throw new SubDemPrecisionError(amountOs, remainder);
+        }
+    }
+    /**
+     * Lists currently-open proposals (pending tally or activating after
+     * approval). Rejected/active historical proposals are not included.
+     */
+    async getActiveProposals() {
+        return ((await this.nodeCall("getActiveProposals")) ??
+            []);
+    }
+    /**
+     * Returns the live vote tally for a specific proposal — total snapshot
+     * weight, approve/reject breakdowns, per-validator votes, threshold, and
+     * a `passed` flag.
+     */
+    async getProposalVotes(proposalId) {
+        return (await this.nodeCall("getProposalVotes", {
+            proposalId,
+        }));
+    }
+    /**
+     * Returns the ordered history of proposals whose status has reached
+     * `active`. Ordered by `effectiveAtBlock` ASC, then `proposalId` ASC.
+     */
+    async getUpgradeHistory() {
+        return ((await this.nodeCall("getUpgradeHistory")) ??
+            []);
+    }
     /**
      * Disconnects from the RPC URL and the wallet.
      */
@@ -996,4 +1369,11 @@ export class Demos {
     }
 }
 Demos._instance = null;
+/**
+ * TTL for the failed-detection memo. After this elapses we re-attempt
+ * `getNetworkInfo` so a transient outage doesn't poison the instance
+ * forever. The warn-once flag is sticky across retries — operators
+ * still see the warning exactly once per instance lifetime.
+ */
+Demos._NETWORK_INFO_FAILURE_TTL_MS = 30000;
 //# sourceMappingURL=demosclass.js.map