@needmoretruth/nmts-cli 0.17.2 → 0.34.1

package/dist/shared/lib/storage-control/reuse.js

@@ -0,0 +1,95 @@
+// Registering a new blob into a storage resource the wallet ALREADY holds — the place where
+// "put it in that space" is expressed as a transaction. ⚠ PUBLISHED — copied byte-for-byte into
+// the `nmts` command-line package; keep comments self-contained English.
+//
+// ⛔ WHY THE SDK IS NOT USED HERE. `client.registerBlob` hard-codes `storage: this.createStorage(…)`
+//    — it always BUYS. There is no slot for a resource one already owns. The Move function takes
+//    that slot as an argument (`register_blob(self, storage, blobId, rootHash, size, encodingType,
+//    deletable, writePayment)`), and the SDK offers no path to it.
+//
+// ⛔ THE GENERATED MOVE BINDINGS CANNOT BE USED EITHER. `@mysten/walrus/dist/contracts/walrus/
+//    system.mjs` is a path the package does not export; importing it is refused with
+//    `ERR_PACKAGE_PATH_NOT_EXPORTED` (measured 2026-08-28). So the `moveCall` is written by hand,
+//    which is the right thing anyway: leaning on somebody's internal path breaks silently on their
+//    next version.
+//
+// ⛔ THE WRITE-PAYMENT COIN GOES IN BY REFERENCE. Move takes what it needs out of it and THE EMPTY
+//    SHELL IS THE CALLER'S TO DESTROY. Left alone, the transaction never reaches the chain: it is
+//    refused at assembly with `UnusedValueWithoutDrop` — which happened once, for real.
+//
+// ⭐ THIS FILE BUILDS TRANSACTIONS AND NOTHING ELSE. "May this resource be used" is answered by the
+//    pure judgement below, and the final verdict is a DRY RUN (if the chain refuses, no value
+//    leaves).
+import { coinWithBalance, Transaction } from "@mysten/sui/transactions";
+import { bcs } from "@mysten/sui/bcs";
+/**
+ * Only "it certainly fits" is true.
+ *
+ * ⛔ THE ENCODED LENGTH IS NOT COMPUTED HERE. That arithmetic is the protocol's and lives inside
+ *    the SDK (unexported); a copy kept here would be wrong the day they change it, and only we
+ *    would not know. ▶ Instead MONOTONICITY alone is used: the encoded length never shrinks as the
+ *    raw length grows, so a new file no larger than the one the resource held certainly fits.
+ * ⚠ This is therefore a SUFFICIENT condition. When it is false the real answer comes from a dry
+ *   run — resources carry a 63 MiB floor, so a slightly larger file fitting a small file's slot
+ *   is common in practice.
+ */
+export function surelyFits(input) {
+    if (input.resourceEndEpoch <= input.currentEpoch)
+        return false;
+    if (input.heldRawBytes === undefined)
+        return false;
+    return input.newRawBytes <= input.heldRawBytes;
+}
+/** A registration that uses ONE held storage resource as it is. */
+export function registerIntoStorage(input, transaction) {
+    const tx = transaction ?? new Transaction();
+    tx.setSenderIfNotSet(input.owner);
+    const writeCoin = tx.add(coinWithBalance({ balance: input.writeCost, type: input.walType }));
+    const blob = tx.moveCall({
+        package: input.walrusPackageId,
+        module: "system",
+        function: "register_blob",
+        arguments: [
+            tx.object(input.systemObjectId),
+            tx.object(input.storageObjectId),
+            tx.pure.u256(input.blobIdAsInt),
+            tx.pure.u256(BigInt(bcs.u256().parse(input.rootHash))),
+            tx.pure.u64(input.rawBytes),
+            // 1 = RS2. ⚠ Must equal what the SDK registers with — otherwise the storage nodes wait for
+            // a different encoding.
+            tx.pure.u8(1),
+            tx.pure.bool(input.deletable),
+            writeCoin,
+        ],
+    });
+    // ⛔ The place the header comment is about. Not destroyed = refused at assembly.
+    tx.moveCall({ target: "0x2::coin::destroy_zero", typeArguments: [input.walType], arguments: [writeCoin] });
+    tx.transferObjects([blob], input.owner);
+    return tx;
+}
+/**
+ * "Cut to fit": shrink a held resource to exactly what the file needs, so the rest stays a free
+ * resource instead of being bound inside the blob. The owner's rule: the person chooses between
+ * cutting and binding whole, and is shown the leftover in bytes — no default is chosen for them.
+ *
+ * ⛔ WHICH HALF IS WHICH IS THE CONTRACT'S CHOICE, read from `storage_resource.move`: `split_by_size`
+ *    MODIFIES the given resource down to `split_size` and RETURNS a new object holding the rest.
+ *    So the object id the caller already holds is the one that registers the blob afterwards, and
+ *    the returned object is the leftover — which must be transferred, or the transaction is
+ *    refused at assembly for an unused value.
+ *
+ * ⚠ `keepBytes` must be the ENCODED size (the chain's `encoded_blob_length`), never the raw one:
+ *   registration checks `encoded_size <= storage_size` and a resource cut to the raw size fails it.
+ */
+export function splitStorageToFit(input, transaction) {
+    const tx = transaction ?? new Transaction();
+    tx.setSenderIfNotSet(input.owner);
+    const rest = tx.moveCall({
+        package: input.walrusPackageId,
+        module: "storage_resource",
+        function: "split_by_size",
+        arguments: [tx.object(input.storageObjectId), tx.pure.u64(input.keepBytes)],
+    });
+    tx.transferObjects([rest], input.owner);
+    return tx;
+}

package/dist/shared/lib/storage-network.d.ts

@@ -0,0 +1,25 @@
+/** Network codes, as stored. Fixed forever once a row carries one. */
+export declare const NETWORK_WALRUS = 0;
+/** Filecoin — product tier 「NMTS Heavy」. Reserved; no upload path exists yet. */
+export declare const NETWORK_FILECOIN = 1;
+/** Arweave — reserved and deliberately last: it cannot be deleted, ever (BACKLOG §2.2). */
+export declare const NETWORK_ARWEAVE = 2;
+/** The wire NAME of each network, as the recovery map spells it. */
+export type StorageNetworkName = "walrus" | "filecoin" | "arweave";
+/**
+ * Code → the name a recovery map stores. `null` for a code this build has never heard of.
+ *
+ * A newer client could store a network this one predates. Returning null makes that visible to
+ * the caller instead of mislabelling someone's bytes.
+ */
+export declare function networkName(code: number): StorageNetworkName | null;
+/** Name → code. `null` for anything not in the registry. */
+export declare function networkCode(name: string): number | null;
+/**
+ * What an ABSENT network field means: Walrus.
+ *
+ * This is a fact, not a fallback. No other network has ever had an upload path, so every part,
+ * entry and map written before the field existed is on Walrus by construction. Stated as a named
+ * constant so the reasoning sits next to every use of it rather than being re-derived.
+ */
+export declare const NETWORK_WHEN_UNRECORDED = 0;

package/dist/shared/lib/upload/part-plan.d.ts

@@ -0,0 +1,24 @@
+export interface PartRange {
+    /**
+     * Zero-based position of this part in the file.
+     *
+     * It orders the download AND is sealed into the part's own header, so a storage service cannot
+     * reorder parts or serve one in another's place without the decryption failing.
+     */
+    partIndex: number;
+    /** Where this part starts in the plaintext, inclusive. */
+    offset: number;
+    /** How many plaintext bytes this part carries. Becomes the declared length in its header. */
+    length: number;
+}
+/**
+ * Split a plaintext length into ordered, contiguous, non-overlapping ranges of at most
+ * `partSizeBytes` each; the last one carries the remainder.
+ *
+ * The ranges tile `[0, plaintextLen)` exactly — the lengths sum to `plaintextLen` — and a file that
+ * fits in one part is simply the one-range case, so a caller never needs a separate path for it.
+ *
+ * Throws on a non-positive length or part size rather than coercing: both are caller mistakes, and
+ * a silently corrected one would produce a plan that does not describe the file.
+ */
+export declare function planParts(plaintextLen: number, partSizeBytes: number): PartRange[];

package/dist/shared/lib/wallet/activity.d.ts

@@ -0,0 +1,138 @@
+/** The names we can prove. `other` means "could not name it", not "nothing happened". */
+export type ActivityKind = "seal" | "extend" | "erase" | "exchange" | "donate" | "send" | "receive" | "other";
+/** Who paid the network fee. `pool` means the free-trial pool did. */
+export type GasPayer = "self" | "pool" | "other";
+export interface ActivityChange {
+    /** The coin's name when it is one we know, else `null` (the type string is kept regardless). */
+    coin: "SUI" | "WAL" | null;
+    coinType: string;
+    /** How much THIS address's balance moved. Negative means it left. */
+    amount: bigint;
+}
+export interface ActivityRow {
+    digest: string;
+    /** The chain's own timestamp (epoch ms). `null` when the RPC did not give one — never invented. */
+    atMs: number | null;
+    failed: boolean;
+    gasPayer: GasPayer;
+    kind: ActivityKind;
+    /** THIS address's balance changes only. Other people's changes are not in this list. */
+    changes: ActivityChange[];
+    explorerUrl: string;
+}
+/** Everything the judgement compares against — all passed in; this file touches no screen and no network. */
+export interface ActivityContext {
+    /** The wallet whose list this is. */
+    address: string;
+    /** Where gifts go (developer, pool). Empty ⇒ nothing is ever named a donation. */
+    donationAddresses: readonly string[];
+    /** The free-trial pool's address. Empty ⇒ no `pool` judgement. */
+    poolAddress: string;
+    /** The network's WAL coin type — the one balance change we name "WAL". */
+    walCoinType: string;
+    /** The Walrus system object id — the input that proves a storage-network transaction. */
+    walrusSystemObjectId: string;
+    /** The DeepBook package on this network, or `null` when there is none. */
+    deepbookPackageId: string | null;
+    /** The Bluefin package on this network, or `null` when there is none (testnet). */
+    bluefinPackageId: string | null;
+    /** The official testnet WAL exchange object, or `null` on a network that has none (mainnet). */
+    exchangeObjectId: string | null;
+    /** The network name the explorer link is built for: `"mainnet"` or `"testnet"`. */
+    network: string;
+}
+export interface RpcMoveCall {
+    package?: string;
+    module?: string;
+    function?: string;
+}
+/**
+ * One command of a programmable transaction.
+ *
+ * ⚠ THE INDEX SIGNATURE IS REQUIRED. The SDK's command type is a union of `{MoveCall}`,
+ *   `{TransferObjects}`, `{SplitCoins}` … and with only `MoveCall?` here TypeScript refuses it
+ *   ("no properties in common" — weak-type detection). The index signature says "any other field
+ *   is fine".
+ */
+export interface RpcCommand {
+    MoveCall?: RpcMoveCall;
+    [other: string]: unknown;
+}
+/**
+ * What can sit in a command slot — usually the shape above, but sometimes A BARE STRING (the
+ * command list of an end-of-epoch transaction carries name-only entries). Our wallet transactions
+ * never contain one, but the receiving type includes that branch, so it is accepted — and skipped.
+ */
+export type RpcCommandEntry = RpcCommand | string;
+/** One transaction input. The index signature is needed for the same reason (pure-value inputs have no `objectId`). */
+export interface RpcInput {
+    objectId?: string;
+    [other: string]: unknown;
+}
+export interface RpcBalanceChange {
+    owner?: unknown;
+    coinType?: string;
+    amount?: string;
+}
+export interface RpcTransaction {
+    digest?: string;
+    timestampMs?: string | number | null;
+    balanceChanges?: readonly RpcBalanceChange[] | null;
+    effects?: {
+        status?: {
+            status?: string;
+        };
+    } | null;
+    transaction?: {
+        data?: {
+            sender?: string;
+            gasData?: {
+                owner?: string;
+            };
+            transaction?: {
+                /** `ProgrammableTransaction` and the like. Not read, but it MUST be declared — for the same
+                 *  reason as the index signatures: without it other kinds (`ChangeEpoch`) fail the type check. */
+                kind?: string;
+                inputs?: readonly RpcInput[];
+                transactions?: readonly RpcCommandEntry[];
+            };
+        };
+    } | null;
+}
+/**
+ * Put an address into one shape before comparing.
+ *
+ * ⚠ A Sui address can be written zero-padded or not (`0x2` and `0x000…02` are the same one). The
+ *   RPC's form and the one in our configuration can differ, and then THE SAME ADDRESS COMPARES AS
+ *   DIFFERENT — a gift would fall through to "send". So both are padded to 32 bytes first.
+ */
+export declare function normalizeAddress(raw: string): string;
+/**
+ * One transaction → one row for a screen or a terminal.
+ *
+ * ⛔ THE ORDER OF THE JUDGEMENT IS THE ANSWER — a transaction matching several branches gets the
+ *    first: ① storage network (system object + a known `system` function) ② exchange ③ donation
+ *    ④ send / receive ⑤ other. Storage comes first because it is the commonest reason a balance
+ *    here goes down; donation comes before send because a more specific truth beats a less
+ *    specific one.
+ */
+export declare function toActivityRow(tx: RpcTransaction, ctx: ActivityContext): ActivityRow;
+/**
+ * Where a person can look the transaction up themselves.
+ *
+ * ⚠ A plain navigation link (not a fetch, so no `connect-src` concern). The same explorer's object
+ *   links are already used elsewhere in the product, in the same shape.
+ * ⭐ The URL shape was CHECKED IN A REAL BROWSER (2026-08-17): opening it shows that digest.
+ *   ⛔ It cannot be checked with `curl` — the site renders in the browser, the fetched HTML is
+ *   empty, and EVERY path answers 200.
+ */
+export declare function explorerTxUrl(digest: string, network: string): string;
+/**
+ * The two lists (sent, received) folded into one.
+ *
+ * ⛔ THE RPC FILTER HAS NO OR — `FromAddress` and `ToAddress` cannot be asked for together, so
+ *    they are asked for twice and merged here. A transaction can appear on both sides, so
+ *    DUPLICATES ARE REMOVED BY DIGEST.
+ * ⚠ Rows with no time go LAST — treating a missing time as 0 would float "1970" to the top.
+ */
+export declare function mergeActivity(groups: readonly (readonly ActivityRow[])[], limit: number): ActivityRow[];

package/dist/shared/lib/wallet/activity.js

@@ -0,0 +1,208 @@
+// The wallet's activity list — one pure judgement per transaction. ⚠ PUBLISHED — copied
+// byte-for-byte into the `nmts` command-line package; keep comments self-contained English.
+//
+// ⛔ THE ONE RULE THIS FILE KEEPS: NO NAME OF OURS ON A TRANSACTION WE ARE NOT SURE OF. The chain
+//    gives a digest, a time and balance changes — not our words "upload" or "exchange". Writing
+//    "upload" on a "probably an upload" is a lie to the person, and the worst kind: they came here
+//    to find out why the balance went down.
+//    ▶ So a name is put only where a constant we already hold PROVES it, and the rest is "other"
+//      — still shown with its time, its balance changes and its chain link. Not knowing is written
+//      as not knowing, never drawn as nothing having happened.
+//
+// ⭐ What proves each name (every one a measured constant, none a guess):
+//   · storage network — the transaction's inputs carry the Walrus SYSTEM object (an id the SDK
+//     publishes per network) and a Move call's module is `system`. The function then decides:
+//     `register_blob` / `certify_blob` → seal · `extend_blob` → extend · `delete_blob` → erase.
+//     (Function names read verbatim from `@mysten/walrus`'s generated contract bindings, 2026-08-17.)
+//   · exchange — a Move call's package is DeepBook or Bluefin, or the inputs carry the testnet
+//     exchange object.
+//   · donate — a transaction in which one of our donation addresses GAINED balance.
+//   · send / receive — a pure transfer with no Move call; our balance down = send, up = receive.
+//   · anything else → no name.
+//
+// ⚠ What this judgement cannot do:
+//   · a transaction that does several things gets the FIRST name that matches (the order below is
+//     the answer);
+//   · a Walrus package upgrade keeps the system object id, so this survives one; the day the
+//     system object itself changes, storage transactions quietly become "other" — a missing name,
+//     never a wrong one;
+//   · the list is what the CHAIN knows. Whether a storage node still holds the bytes is not
+//     proved here.
+//
+// ⛔ NO CONSTANT IS IMPORTED. Everything the judgement compares against arrives in
+//    `ActivityContext`, so the same file serves the browser (which reads its build's network) and
+//    the command-line tool (which resolves the network at run time) without a fork.
+// ── Small readers ─────────────────────────────────────────────────────────────────────────────
+/** The address out of `{ AddressOwner: "0x…" }`. Other owner shapes (shared, immutable) have none → `null`. */
+function ownerAddress(owner) {
+    if (typeof owner !== "object" || owner === null)
+        return null;
+    if (!("AddressOwner" in owner))
+        return null;
+    const value = owner.AddressOwner;
+    return typeof value === "string" ? value : null;
+}
+/** The RPC gives the time as a string. Unreadable ⇒ `null`, NEVER an invented number. */
+function readTimestamp(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    const value = typeof raw === "number" ? raw : Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+/**
+ * Put an address into one shape before comparing.
+ *
+ * ⚠ A Sui address can be written zero-padded or not (`0x2` and `0x000…02` are the same one). The
+ *   RPC's form and the one in our configuration can differ, and then THE SAME ADDRESS COMPARES AS
+ *   DIFFERENT — a gift would fall through to "send". So both are padded to 32 bytes first.
+ */
+export function normalizeAddress(raw) {
+    const body = raw.trim().toLowerCase().replace(/^0x/, "");
+    if (body === "" || !/^[0-9a-f]+$/.test(body) || body.length > 64)
+        return raw.trim().toLowerCase();
+    return `0x${body.padStart(64, "0")}`;
+}
+/** Every Move call (empty for a pure transfer). */
+function moveCalls(tx) {
+    const commands = tx.transaction?.data?.transaction?.transactions ?? [];
+    const calls = [];
+    for (const command of commands) {
+        if (typeof command === "string")
+            continue;
+        if (command.MoveCall !== undefined)
+            calls.push(command.MoveCall);
+    }
+    return calls;
+}
+/** Every object id among the inputs, zero-padded. */
+function inputObjectIds(tx) {
+    const ids = new Set();
+    for (const input of tx.transaction?.data?.transaction?.inputs ?? []) {
+        if (typeof input.objectId === "string")
+            ids.add(normalizeAddress(input.objectId));
+    }
+    return ids;
+}
+/** The functions of the Walrus `system` module whose names we know → our kind. */
+const WALRUS_FUNCTION_KIND = {
+    register_blob: "seal",
+    certify_blob: "seal",
+    extend_blob: "extend",
+    delete_blob: "erase",
+};
+/**
+ * One transaction → one row for a screen or a terminal.
+ *
+ * ⛔ THE ORDER OF THE JUDGEMENT IS THE ANSWER — a transaction matching several branches gets the
+ *    first: ① storage network (system object + a known `system` function) ② exchange ③ donation
+ *    ④ send / receive ⑤ other. Storage comes first because it is the commonest reason a balance
+ *    here goes down; donation comes before send because a more specific truth beats a less
+ *    specific one.
+ */
+export function toActivityRow(tx, ctx) {
+    const me = normalizeAddress(ctx.address);
+    const digest = typeof tx.digest === "string" ? tx.digest : "";
+    const sender = normalizeAddress(tx.transaction?.data?.sender ?? "");
+    const gasOwnerRaw = tx.transaction?.data?.gasData?.owner;
+    const gasOwner = typeof gasOwnerRaw === "string" ? normalizeAddress(gasOwnerRaw) : sender;
+    const pool = ctx.poolAddress === "" ? null : normalizeAddress(ctx.poolAddress);
+    const gasPayer = gasOwner === sender ? "self" : pool !== null && gasOwner === pool ? "pool" : "other";
+    const changes = [];
+    let donationGain = false;
+    for (const change of tx.balanceChanges ?? []) {
+        const owner = ownerAddress(change.owner);
+        if (owner === null)
+            continue;
+        const normalized = normalizeAddress(owner);
+        const amount = BigInt(change.amount ?? "0");
+        if (normalized === me) {
+            const coinType = change.coinType ?? "";
+            changes.push({
+                coin: coinType === ctx.walCoinType ? "WAL" : coinType === "0x2::sui::SUI" ? "SUI" : null,
+                coinType,
+                amount,
+            });
+            continue;
+        }
+        if (amount > 0n && ctx.donationAddresses.some((a) => a !== "" && normalizeAddress(a) === normalized)) {
+            donationGain = true;
+        }
+    }
+    const calls = moveCalls(tx);
+    const inputs = inputObjectIds(tx);
+    const walrusSystem = normalizeAddress(ctx.walrusSystemObjectId);
+    let kind = "other";
+    const walrusCall = inputs.has(walrusSystem)
+        ? calls.find((c) => c.module === "system" && (c.function ?? "") in WALRUS_FUNCTION_KIND)
+        : undefined;
+    if (walrusCall !== undefined) {
+        kind = WALRUS_FUNCTION_KIND[walrusCall.function ?? ""] ?? "other";
+    }
+    else if (calls.some((c) => typeof c.package === "string" &&
+        ((ctx.deepbookPackageId !== null &&
+            normalizeAddress(c.package) === normalizeAddress(ctx.deepbookPackageId)) ||
+            (ctx.bluefinPackageId !== null &&
+                normalizeAddress(c.package) === normalizeAddress(ctx.bluefinPackageId)))) ||
+        (ctx.exchangeObjectId !== null && inputs.has(normalizeAddress(ctx.exchangeObjectId)))) {
+        kind = "exchange";
+    }
+    else if (donationGain && sender === me) {
+        kind = "donate";
+    }
+    else if (calls.length === 0 && changes.length > 0) {
+        const net = changes.reduce((sum, c) => sum + c.amount, 0n);
+        if (sender === me && net < 0n)
+            kind = "send";
+        else if (sender !== me && net > 0n)
+            kind = "receive";
+    }
+    return {
+        digest,
+        atMs: readTimestamp(tx.timestampMs),
+        failed: (tx.effects?.status?.status ?? "success") !== "success",
+        gasPayer,
+        kind,
+        changes,
+        explorerUrl: explorerTxUrl(digest, ctx.network),
+    };
+}
+/**
+ * Where a person can look the transaction up themselves.
+ *
+ * ⚠ A plain navigation link (not a fetch, so no `connect-src` concern). The same explorer's object
+ *   links are already used elsewhere in the product, in the same shape.
+ * ⭐ The URL shape was CHECKED IN A REAL BROWSER (2026-08-17): opening it shows that digest.
+ *   ⛔ It cannot be checked with `curl` — the site renders in the browser, the fetched HTML is
+ *   empty, and EVERY path answers 200.
+ */
+export function explorerTxUrl(digest, network) {
+    return `https://suiscan.xyz/${network}/tx/${digest}`;
+}
+/**
+ * The two lists (sent, received) folded into one.
+ *
+ * ⛔ THE RPC FILTER HAS NO OR — `FromAddress` and `ToAddress` cannot be asked for together, so
+ *    they are asked for twice and merged here. A transaction can appear on both sides, so
+ *    DUPLICATES ARE REMOVED BY DIGEST.
+ * ⚠ Rows with no time go LAST — treating a missing time as 0 would float "1970" to the top.
+ */
+export function mergeActivity(groups, limit) {
+    const byDigest = new Map();
+    for (const group of groups) {
+        for (const row of group) {
+            if (row.digest !== "" && !byDigest.has(row.digest))
+                byDigest.set(row.digest, row);
+        }
+    }
+    return [...byDigest.values()]
+        .sort((a, b) => {
+        if (a.atMs === b.atMs)
+            return 0;
+        if (a.atMs === null)
+            return 1;
+        if (b.atMs === null)
+            return -1;
+        return b.atMs - a.atMs;
+    })
+        .slice(0, limit);
+}

package/dist/shared/lib/wallet/send-rules.d.ts

@@ -0,0 +1,68 @@
+/** Base-unit scale for both tokens (1 SUI = 1e9 MIST, 1 WAL = 1e9 FROST). */
+export declare const TOKEN_DECIMALS = 9;
+/**
+ * SUI kept back so a send or exchange can pay its own gas (0.05 SUI). A ceiling, not the charged
+ * amount — a real fee is a few million MIST; this is generous so a send never strands the wallet
+ * without gas.
+ */
+export declare const SUI_GAS_RESERVE_MIST = 50000000n;
+/** Which token a send moves. */
+export type SendCoin = "SUI" | "WAL";
+/** Trim and lowercase an address (hex is case-insensitive; lowercase is the shape kept). */
+export declare function normalizeSuiAddress(input: string): string;
+/** True when `input`, normalised, is a full 0x + 64-hex Sui address. */
+export declare function isValidSuiAddress(input: string): boolean;
+/**
+ * A decimal amount ("0.5", "12", ".25") as base units, EXACTLY — no floating point, so 0.1 never
+ * drifts. Null for anything malformed or finer than the chain keeps (never silently rounded). Does
+ * not judge whether the amount is affordable; that is the validator's job.
+ */
+export declare function parseTokenAmountToBaseUnits(input: string, decimals?: number): bigint | null;
+/**
+ * The most that can be sent, in base units. SUI keeps the gas reserve back; WAL is fully sendable
+ * (a WAL transfer pays its gas in SUI, which the validator checks separately). Never negative.
+ */
+export declare function maxSendableBaseUnits(params: {
+    coin: SendCoin;
+    suiBalance: bigint;
+    walBalance: bigint;
+    gasReserve?: bigint;
+}): bigint;
+/** Stable error codes for a send. Each maps to one honest sentence on whichever surface shows it. */
+export type SendValidationError = "invalidAddress" | "invalidAmount" | "insufficientBalance" | "noGasForWal";
+export type SendValidation = {
+    ok: true;
+    amountBaseUnits: bigint;
+    address: string;
+} | {
+    ok: false;
+    error: SendValidationError;
+};
+/**
+ * Validate a send. The address must be a full Sui address; the amount must be above zero and within
+ * what can be sent; a WAL send also needs the gas reserve in SUI — else `noGasForWal`.
+ */
+export declare function validateSendForm(params: {
+    coin: SendCoin;
+    amountInput: string;
+    addressInput: string;
+    suiBalance: bigint;
+    walBalance: bigint;
+    gasReserve?: bigint;
+}): SendValidation;
+/** The lowest gas budget a person may set: 0.002 SUI. Below it no transaction goes through. */
+export declare const GAS_BUDGET_MIN_MIST = 2000000n;
+/** The absolute ceiling: 1 SUI. A slipped extra zero stops here. */
+export declare const GAS_BUDGET_ABS_MAX_MIST = 1000000000n;
+/**
+ * The RECOMMENDED gas budget from a measured (dry-run) fee: twice the measurement, at least
+ * 0.005 SUI, at most 1 SUI.
+ *
+ * Why twice: the measurement is taken against this moment's object versions and reference gas
+ * price, and both move a little between signing and broadcast. A budget below the real cost makes
+ * the transaction FAIL FOR WANT OF GAS, and that gas is gone; the doubling is what buys out that
+ * failure. A budget is a ceiling, not a charge — what is not used stays in the wallet.
+ */
+export declare function recommendedGasBudgetMist(estimateMist: bigint): bigint;
+/** Keep a typed gas budget inside the usable range — clamped, not refused. */
+export declare function clampGasBudgetMist(n: bigint): bigint;