@ninsei-labs/sdk 0.43.1 → 0.44.0

package/src/sweep.mjs

@@ -7,6 +7,9 @@
 import { SdkError } from "./errors.mjs";
 import { primitives } from "./primitives.mjs";
 import * as engine from "./engine.mjs";
+import { restoreWallet } from "./sweep-restore.mjs";
+import { moneroWalletAdapter } from "./adapters/monero-wallet.mjs";
+import { checkDestination } from "./destination.mjs";
 
 // The same boundary as when the file was issued: a passphrase shorter than twelve characters will not open the file.
 const MIN_PASSPHRASE = 12;
@@ -30,6 +33,23 @@ const walletStep = async (surface, step) => {
   }
 };
 
+// THE FEE A WALLET REPORTS FOR A SIGNED TRANSACTION. Optional on purpose: the adapter contract does not require
+// it, and an adapter without it is not broken - the answer is simply unknown. The library's own shape is tried
+// (`getFee()` on the transaction or on the signed wrapper), because that is what monero-ts returns; a value that is
+// not a non-negative integer string is refused as unknown rather than trusted.
+const feeOf = async (wallet, signed) => {
+  if (!wallet || typeof wallet.fee !== "function") return null;
+  let value;
+  try {
+    value = await wallet.fee(signed);
+  } catch {
+    return null;
+  }
+  if (value === null || value === undefined) return null;
+  const text = String(value);
+  return /^\d+$/.test(text) ? text : null;
+};
+
 export function createSweep({ http, config }) {
   // THE NAME IS NEEDED BY THE OBJECT ITSELF: `run` calls `api.plan(...)` - the step order is held by the plan and
   // the withdrawal living in one object, not in two copies. During a manual merge of branches the object was left
@@ -40,7 +60,52 @@ export function createSweep({ http, config }) {
   const sessions = new Map();
   let sessionSeq = 0;
 
+  // THE NETWORK NAME MONERO-TS TAKES. The adapter speaks a string ("stagenet") because that is what a node says and
+  // what a human reads; the library wants its own enum. That translation used to be a callback on the sweep page -
+  // the last thing a caller had to know about the library to open a wallet.
+  const NETWORK_ENUM = { mainnet: "MAINNET", stagenet: "STAGENET", testnet: "TESTNET" };
+
   const api = {
+    // BUILD THE WITHDRAWAL WALLET from the library namespace the caller has. The page used to pass a `createWallet`
+    // callback that mapped the enum itself; that mapping is here now, so a caller passes `moneroTs` and the keys.
+    wallet(request = {}) {
+      const moneroTs = request.moneroTs;
+      if (!moneroTs || typeof moneroTs !== "object") throw new SdkError("bad-input", { field: "moneroTs" });
+      if (typeof moneroTs.createWalletFull !== "function") throw new SdkError("bad-input", { field: "moneroTs.createWalletFull" });
+      const network = String(request.network || "").trim().toLowerCase();
+      const enumName = NETWORK_ENUM[network] || null;
+      const enumValue = enumName && moneroTs.MoneroNetworkType ? moneroTs.MoneroNetworkType[enumName] : undefined;
+      if (enumValue === undefined || enumValue === null) {
+        throw new SdkError("bad-input", { field: "network", known: Object.keys(NETWORK_ENUM), got: request.network });
+      }
+      if (typeof request.serverUri !== "string" || !request.serverUri) throw new SdkError("bad-input", { field: "serverUri" });
+      return moneroWalletAdapter({
+        createWallet: (config) => moneroTs.createWalletFull({ ...config, networkType: enumValue }),
+        network,
+        serverUri: request.serverUri,
+        password: request.password,
+        keys: request.keys || {},
+        restoreHeight: request.restoreHeight,
+        expectedAddress: request.expectedAddress || null,
+      });
+    },
+
+    // WHERE THE WITHDRAWAL GOES. The file names the recipient the swap was made for; this compares the address the
+    // person typed with that promise and with the file's network. `matches` is null when the file named nobody -
+    // that is not a failure, it is an absence the caller can phrase.
+    async destination(request = {}) {
+      const contents = contentsOf(request.file);
+      if (!contents) throw new SdkError("bad-input", { field: "file" });
+      if (!request.passphrase) throw new SdkError("bad-input", { field: "passphrase" });
+      if (typeof request.dest !== "string" || !request.dest.trim()) throw new SdkError("bad-input", { field: "dest" });
+      let payload = null;
+      try { payload = await engine.recoveryFile.decryptFile(JSON.parse(contents), request.passphrase); }
+      catch { throw new SdkError("recovery-failed", { step: "decrypt" }); }
+      try { engine.recoveryFile.validatePayload(payload); }
+      catch { throw new SdkError("recovery-failed", { step: "validate" }); }
+      return checkDestination(payload, request.dest);
+    },
+
     async plan(request) {
       if (!request || typeof request !== "object") throw new SdkError("bad-input", { field: "request" });
       const contents = contentsOf(request.file);
@@ -145,6 +210,13 @@ export function createSweep({ http, config }) {
       }
     },
 
+    // THE PASS BEFORE SIGNING: set the height, rescan, sync, read the balance, and - when coins exist but none is
+    // spendable - re-check the spent status once. The wallet is the same withdrawal adapter `sign` takes; the page
+    // no longer decides when a second pass is needed.
+    async restore(request) {
+      return await restoreWallet(request || {});
+    },
+
     // THE WITHDRAWAL ITSELF. The wallet arrives as an adapter (the WASM and the worker live with whoever builds the
     // page), while the core holds the order: open -> sync -> look at the free remainder -> SIGN (relay: false) ->
     // send -> close.
@@ -202,9 +274,26 @@ export function createSweep({ http, config }) {
         // zero, and the refusal would look like success.
         if (unlocked <= 0n) throw new SdkError("insufficient-funds", { unlocked: unlocked.toString() });
         const signed = await walletStep("sweepUnlocked", () => wallet.sweepUnlocked({ address: request.to, relay: false }));
+        // WHAT THE TRANSFER COSTS, WHEN THE WALLET CAN SAY. A withdrawal moves the whole free remainder, so the fee
+        // is not extra money on top - it is taken out of it, and the recipient receives the remainder MINUS the fee.
+        // An adapter that cannot report a fee answers null; publishing 0 there would be a claim the package cannot
+        // support, and the interface would show a free transfer.
+        const fee = await feeOf(wallet, signed);
+        const feeValue = fee === null ? null : BigInt(fee);
         const token = "sweep-" + (++sessionSeq);
         sessions.set(token, { wallet, plan, signed });
-        return { token, amount: unlocked.toString(), to: request.to, swept: plan.address };
+        return {
+          token,
+          amount: unlocked.toString(),
+          // The fee in atomic units, or null when the wallet could not report it.
+          fee,
+          // What the recipient receives: the remainder minus the fee. Null whenever the fee is unknown, and null
+          // rather than a negative number when a fee claims more than the remainder (that is a broken report, not
+          // a transfer).
+          receive: feeValue === null || feeValue >= unlocked ? null : (unlocked - feeValue).toString(),
+          to: request.to,
+          swept: plan.address,
+        };
       } catch (error) {
         // There is no signature - we do not leave an open wallet. Closing must not hide the refusal's reason.
         try { await wallet.close(); } catch { /* the reason matters more than closing */ }

package/src/version.mjs

@@ -6,4 +6,4 @@
 // tools/sync-version.mjs. Do not edit it by hand - set the version in package.json and run `npm run sync:version`.
 // The `version` check in tools/check.mjs refuses a mismatch, and refuses a runtime read of package.json here.
 
-export const SDK_VERSION = "0.43.1";
+export const SDK_VERSION = "0.44.0";