@hardkas/accounts 0.12.0-rc.2 → 0.12.0-rc.21

package/dist/{authorizers-OVWWAL5J.js → authorizers-CP222OTW.js}

@@ -2,7 +2,7 @@ import {
   LazyAccountAuthorizer,
   PrivateKeyAuthorizer,
   StaticSignatureScriptAuthorizer
-} from "./chunk-YJL7P33W.js";
+} from "./chunk-E73SSWAX.js";
 export {
   LazyAccountAuthorizer,
   PrivateKeyAuthorizer,

package/dist/{chunk-TRVIQTIO.js → chunk-7KKJXU73.js}

@@ -219,7 +219,7 @@ function resolveHardkasAccount(options) {
   let alias = nameOrAddress;
   if (alias === "0") alias = "alice";
   if (alias === "1") alias = "bob";
-  const accounts = listHardkasAccounts(config);
+  const accounts = listHardkasAccounts(config, options.executionTarget);
   const found = accounts.find((a) => a.name === alias);
   if (found) {
     return found;
@@ -229,17 +229,63 @@ function resolveHardkasAccount(options) {
     `Unknown HardKAS account '${nameOrAddress}'. Available accounts: ${available}`
   );
 }
-function listHardkasAccounts(config) {
+function assertAccountCompatible(account, target) {
+  if (account.kind === "synthetic" && target.mode !== "simulator") {
+    throw new AccountNetworkMismatchError({
+      expected: `Execution mode 'simulator'`,
+      actual: `Execution mode '${target.mode}'`,
+      detail: `Account '${account.name}' is a synthetic simulator account and cannot be used with mode '${target.mode}'.`
+    });
+  }
+  if ("network" in account && account.network && target.network && account.network !== target.network) {
+    throw new AccountNetworkMismatchError({
+      expected: target.network,
+      actual: account.network,
+      detail: `Account '${account.name}' is bound to network '${account.network}' but execution target is '${target.network}'.`
+    });
+  }
+}
+function listHardkasAccounts(config, executionTarget) {
   const accounts = /* @__PURE__ */ new Map();
+  let targetMode = "localnet";
+  if (executionTarget) {
+    targetMode = executionTarget.mode;
+  } else {
+    const execConfig = config?.execution;
+    if (execConfig) {
+      if (execConfig.mode) {
+        targetMode = execConfig.mode;
+      } else if (execConfig.default) {
+        const targetName = execConfig.default;
+        const target = execConfig.targets?.[targetName];
+        if (target?.mode) {
+          targetMode = target.mode;
+        } else if (targetName === "simulator") {
+          targetMode = "simulator";
+        }
+      }
+    } else if (config?.defaultNetwork === "simulated") {
+      targetMode = "simulator";
+    }
+  }
   const detAccounts = createDeterministicAccounts();
   for (const det of detAccounts) {
-    accounts.set(det.name, {
-      name: det.name,
-      kind: "synthetic",
-      executionMode: "simulator",
-      address: det.address,
-      evmAddress: det.evmAddress
-    });
+    if (targetMode === "simulator") {
+      accounts.set(det.name, {
+        name: det.name,
+        kind: "synthetic",
+        executionMode: "simulator",
+        address: `kaspa:sim_${det.name}`,
+        evmAddress: det.evmAddress
+      });
+    } else {
+      accounts.set(det.name, {
+        name: det.name,
+        kind: "kaspa",
+        network: "simnet",
+        address: det.address
+      });
+    }
   }
   const workspaceRoot = config?.cwd || process.cwd();
   const devAccountsDir = path2.join(workspaceRoot, ".hardkas", "dev-accounts");
@@ -255,13 +301,23 @@ function listHardkasAccounts(config) {
             if (!keystore.metadata?.network) {
               throw new AccountNetworkMismatchError({ expected: "known network", actual: "undefined", detail: `at ${path2.join(devAccountsDir, file)}` });
             }
-            accounts.set(name, {
-              name,
-              kind: "kaspa",
-              network: keystore.metadata.network,
-              address: keystore.payload?.address || keystore.metadata?.address,
-              keystorePath: path2.join(devAccountsDir, file)
-            });
+            if (targetMode === "simulator") {
+              accounts.set(name, {
+                name,
+                kind: "synthetic",
+                executionMode: "simulator",
+                address: `kaspa:sim_${name}`,
+                keystorePath: path2.join(devAccountsDir, file)
+              });
+            } else {
+              accounts.set(name, {
+                name,
+                kind: "kaspa",
+                network: keystore.metadata.network,
+                address: keystore.payload?.address || keystore.metadata?.address,
+                keystorePath: path2.join(devAccountsDir, file)
+              });
+            }
           }
         } catch (e) {
           if (e instanceof AccountNetworkMismatchError) throw e;
@@ -275,19 +331,15 @@ function listHardkasAccounts(config) {
       const data = fs2.readFileSync(keystoreJsonPath, "utf-8");
       const ks = JSON.parse(data);
       for (const [name, acc] of Object.entries(ks)) {
-        const existing = accounts.get(name);
-        const configKind = acc.type === "simulated" ? "synthetic" : "kaspa";
-        if (existing && existing.kind !== configKind) {
-          console.error(`COLLISION DETECTED for ${name}. existing:`, existing, `configKind:`, configKind, `workspaceRoot:`, workspaceRoot, `keystoreJsonPath:`, keystoreJsonPath);
-          throw new CrossWorldAccountCollisionError({ accountId: name, worlds: [existing.kind, configKind] });
-        }
         if (acc.type === "simulated") {
-          accounts.set(name, {
-            name,
-            kind: "synthetic",
-            executionMode: "simulator",
-            address: acc.address
-          });
+          if (targetMode === "simulator") {
+            accounts.set(name, {
+              name,
+              kind: "synthetic",
+              executionMode: "simulator",
+              address: acc.address
+            });
+          }
         } else {
           if (!acc.network) {
             throw new AccountNetworkMismatchError({ expected: "known network", actual: "undefined", detail: "in keystore.json" });
@@ -373,7 +425,8 @@ async function resolveHardkasAccountAddress(accountOrAddress, config, context =
     }
     if (!accountOrAddress.startsWith("kaspa:sim_")) {
       try {
-        const kaspa = await import("kaspa-wasm");
+        const { loadKaspaWasm } = await import("./signer-backend-LHWY7ULI.js");
+        const kaspa = await loadKaspaWasm();
         try {
           if (typeof kaspa.Address === "function" || kaspa.Address) {
             new kaspa.Address(accountOrAddress);
@@ -387,6 +440,7 @@ async function resolveHardkasAccountAddress(accountOrAddress, config, context =
         }
       } catch (e) {
         if (e instanceof Error && e.code === "HARDKAS_INVALID_ADDRESS") throw e;
+        if (e instanceof Error && e.code === "WASM_TOOLCHAIN_INTEGRITY_FAILED") throw e;
         if (e instanceof Error && (e.code === "ERR_MODULE_NOT_FOUND" || (e instanceof Error ? e instanceof Error ? e.message : String(e) : String(e)).includes("Cannot find module") || (e instanceof Error ? e instanceof Error ? e.message : String(e) : String(e)).includes("kaspa-wasm"))) {
           const err = new Error(
             "ADDRESS_VALIDATOR_UNAVAILABLE: The Kaspa address validator backend is not available."
@@ -450,6 +504,7 @@ export {
   listRealDevAccounts,
   resolveRealAccountOrAddress,
   resolveHardkasAccount,
+  assertAccountCompatible,
   listHardkasAccounts,
   resolveHardkasAccountAddress,
   describeAccount

package/dist/{chunk-6DPO5V3N.js → chunk-BNF566PS.js}

@@ -2,18 +2,14 @@
 import path from "path";
 import fs from "fs";
 import { pathToFileURL } from "url";
+import { loadManagedKaspaWasmSync } from "@hardkas/core";
+function loadKaspaWasmSync() {
+  return loadManagedKaspaWasmSync();
+}
 async function loadKaspaWasm(config) {
-  const provider = config?.provider || "npm";
-  if (provider === "npm") {
-    try {
-      return await import("kaspa-wasm");
-    } catch (error) {
-      const err = new Error(
-        "SIGNER_BACKEND_UNAVAILABLE: Official Kaspa WASM backend is required to sign transactions.\nInstall it via: npm install kaspa-wasm"
-      );
-      err.code = "SIGNER_BACKEND_UNAVAILABLE";
-      throw err;
-    }
+  const provider = config?.provider || "managed";
+  if (provider === "managed") {
+    return loadKaspaWasmSync();
   }
   if (provider === "local" || provider === "release-asset") {
     if (!config?.path) {
@@ -52,13 +48,7 @@ async function loadKaspaWasm(config) {
   }
 }
 function detectCapabilities(sdk) {
-  let v1 = false;
-  if (sdk.createTransaction && sdk.createTransaction.length >= 8) {
-    v1 = true;
-  }
-  if (sdk.createV1Transaction || sdk.Transaction && sdk.Transaction.prototype && !!Object.getOwnPropertyDescriptor(sdk.Transaction.prototype, "storageMass")) {
-    v1 = true;
-  }
+  const v1 = !!(sdk?.Transaction?.prototype && Object.getOwnPropertyDescriptor(sdk.Transaction.prototype, "storageMass"));
   return { transactionV1Signing: v1 };
 }
 async function getKaspaSigningBackendStatus(config) {
@@ -67,11 +57,11 @@ async function getKaspaSigningBackendStatus(config) {
     return {
       available: true,
       name: "Kaspa WASM SDK",
-      version: sdk.version || "unknown",
+      version: typeof sdk.version === "function" ? String(sdk.version()) : "unknown",
       capabilities: detectCapabilities(sdk)
     };
   } catch (error) {
-    if (error.code === "WASM_RELEASE_ASSET_NOT_FOUND") {
+    if (error.code === "WASM_RELEASE_ASSET_NOT_FOUND" || error.code === "WASM_TOOLCHAIN_INTEGRITY_FAILED") {
       throw error;
     }
     return {
@@ -84,6 +74,7 @@ async function getKaspaSigningBackendStatus(config) {
 }
 
 export {
+  loadKaspaWasmSync,
   loadKaspaWasm,
   detectCapabilities,
   getKaspaSigningBackendStatus

package/dist/{chunk-6Q4K4A24.js → chunk-CELVD4YG.js}

@@ -1,12 +1,12 @@
 import {
   parseWasmTxToRpc
-} from "./chunk-R5P3WIWR.js";
-import {
-  resolveHardkasAccount
-} from "./chunk-TRVIQTIO.js";
+} from "./chunk-GM2BY4VS.js";
 import {
   loadKaspaWasm
-} from "./chunk-6DPO5V3N.js";
+} from "./chunk-BNF566PS.js";
+import {
+  resolveHardkasAccount
+} from "./chunk-7KKJXU73.js";
 import {
   KeystoreManager
 } from "./chunk-YLG2NIAU.js";
@@ -15,10 +15,87 @@ import {
 import fs from "fs";
 import path from "path";
 import crypto from "crypto";
-import { deterministicCompare } from "@hardkas/core";
+import { deterministicCompare, getNetworkPrefix as getNetworkPrefix2 } from "@hardkas/core";
 
 // src/kaspa-wasm-signer.ts
 import { calculateContentHash } from "@hardkas/artifacts";
+import { getNetworkPrefix } from "@hardkas/core";
+
+// src/wasm-transaction.ts
+function assertValueConservation(input) {
+  const inputs = input.inputAmounts.reduce((a, b) => a + b, 0n);
+  const outputs = input.outputAmounts.reduce((a, b) => a + b, 0n);
+  if (input.feeSompi < 0n || inputs - outputs !== input.feeSompi) {
+    const err = new Error(
+      `TX_VALUE_NOT_CONSERVED: inputs ${inputs} - outputs ${outputs} = ${inputs - outputs} sompi, but the plan's fee is ${input.feeSompi}. Refusing to build a transaction whose difference would be paid as fee.`
+    );
+    err.code = "TX_VALUE_NOT_CONSERVED";
+    throw err;
+  }
+}
+function createBalancedTransaction(sdk, input) {
+  assertValueConservation({
+    inputAmounts: input.utxos.map((u) => u.utxoEntry.amount),
+    outputAmounts: input.outputs.map((o) => o.amountSompi),
+    feeSompi: input.feeSompi
+  });
+  return sdk.createTransaction(
+    [...input.utxos],
+    input.outputs.map((o) => o.output),
+    input.feeSompi
+  );
+}
+function createScriptTransaction(sdk, input) {
+  assertValueConservation({
+    inputAmounts: input.utxos.map((u) => u.utxoEntry.amount),
+    outputAmounts: input.outputs.map((o) => o.value),
+    feeSompi: input.feeSompi
+  });
+  return new sdk.Transaction({
+    version: 0,
+    inputs: input.utxos.map((u) => ({
+      previousOutpoint: { transactionId: u.outpoint.transactionId, index: u.outpoint.index },
+      signatureScript: "",
+      sequence: 0n,
+      sigOpCount: 1,
+      utxo: {
+        address: u.address,
+        outpoint: { transactionId: u.outpoint.transactionId, index: u.outpoint.index },
+        amount: u.utxoEntry.amount,
+        scriptPublicKey: u.utxoEntry.scriptPublicKey,
+        blockDaaScore: u.utxoEntry.blockDaaScore,
+        isCoinbase: u.utxoEntry.isCoinbase
+      }
+    })),
+    outputs: [...input.outputs],
+    lockTime: 0n,
+    subnetworkId: "0000000000000000000000000000000000000000",
+    gas: 0n,
+    payload: ""
+  });
+}
+function toWasmScriptPublicKey(sdk, spk) {
+  if (spk && typeof spk === "object") {
+    const o = spk;
+    return new sdk.ScriptPublicKey(Number(o.version ?? 0), String(o.scriptPublicKey || o.script || ""));
+  }
+  const hex = String(spk ?? "");
+  if (/^[0-9a-fA-F]{72}$/.test(hex) && hex.startsWith("0000")) {
+    return new sdk.ScriptPublicKey(0, hex.slice(4));
+  }
+  return new sdk.ScriptPublicKey(0, hex);
+}
+function planOutputsWithChange(plan) {
+  const all = [...plan.outputs];
+  if (plan.change && BigInt(plan.change.amountSompi) > 0n) all.push(plan.change);
+  return all.map((o) => {
+    if (!o.address) throw new Error("Output is missing address.");
+    const amount = BigInt(o.amountSompi);
+    return { amountSompi: amount, output: { address: o.address, amount } };
+  });
+}
+
+// src/kaspa-wasm-signer.ts
 var KaspaWasmPrivateKeySigner = class {
   constructor(options) {
     this.options = options;
@@ -28,7 +105,7 @@ var KaspaWasmPrivateKeySigner = class {
   async signTxPlan(input) {
     const plan = input.planArtifact;
     const sdk = await loadKaspaWasm(this.options.wasmConfig);
-    const { detectCapabilities } = await import("./signer-backend-W3LNCQA3.js");
+    const { detectCapabilities } = await import("./signer-backend-LHWY7ULI.js");
     const capabilities = detectCapabilities(sdk);
     if (plan.computeBudget !== void 0 || plan.outputs.some((o) => o.covenant)) {
       if (!capabilities.transactionV1Signing) {
@@ -56,7 +133,7 @@ var KaspaWasmPrivateKeySigner = class {
       if (!pkValue && account.keystorePath) {
         try {
           const KeystoreManager2 = (await import("./keystore-CMWEKGBF.js")).KeystoreManager;
-          const DEV_ACCOUNTS_PASSWORD2 = (await import("./dev-accounts-B6ZVTPCW.js")).DEV_ACCOUNTS_PASSWORD;
+          const DEV_ACCOUNTS_PASSWORD2 = (await import("./dev-accounts-BSWPKAAE.js")).DEV_ACCOUNTS_PASSWORD;
           const keystore = await KeystoreManager2.loadEncryptedKeystore(account.keystorePath);
           const unlock = await KeystoreManager2.decryptEncryptedKeystore(keystore, DEV_ACCOUNTS_PASSWORD2);
           if (unlock.success && unlock.payload) {
@@ -75,8 +152,8 @@ var KaspaWasmPrivateKeySigner = class {
         err.code = "INVALID_PRIVATE_KEY_MATERIAL";
         throw err;
       }
-      const expectedAddress = new sdk.PrivateKey(pkValue).toKeypair().toAddress(plan.networkId || "simnet").toString();
-      const { PrivateKeyAuthorizer } = await import("./authorizers-OVWWAL5J.js");
+      const expectedAddress = new sdk.PrivateKey(pkValue).toKeypair().toAddress(getNetworkPrefix(plan.networkId || "simnet")).toString();
+      const { PrivateKeyAuthorizer } = await import("./authorizers-CP222OTW.js");
       const sourceInputs = plan.inputs || plan.selectedUtxos || [];
       for (let i = 0; i < numInputs; i++) {
         if (!authorizers[i]) {
@@ -93,7 +170,6 @@ var KaspaWasmPrivateKeySigner = class {
       }
     }
     try {
-      console.log("DEBUG PLAN INPUTS:", JSON.stringify(plan.inputs || plan.selectedUtxos, null, 2));
       const sourceInputs = plan.inputs || plan.selectedUtxos || [];
       const utxos = sourceInputs.map((u) => {
         if (!u.outpoint.transactionId || u.outpoint.index === void 0) {
@@ -105,15 +181,27 @@ var KaspaWasmPrivateKeySigner = class {
             "UTXO is missing scriptPublicKey. Real signing flows must never fabricate cryptographic state."
           );
         }
+        let spkHex = "";
+        let spkVersion = 0;
+        if (typeof spk === "object" && spk !== null) {
+          spkVersion = Number(spk.version ?? 0);
+          spkHex = String(spk.scriptPublicKey || spk.script || "");
+        } else {
+          spkHex = String(spk);
+          if (/^[0-9a-fA-F]{72}$/.test(spkHex) && spkHex.startsWith("0000")) {
+            spkVersion = parseInt(spkHex.slice(0, 4), 16) || 0;
+            spkHex = spkHex.slice(4);
+          }
+        }
         return {
-          address: plan.from.address,
+          address: u.address || plan.from.address,
           outpoint: {
             transactionId: u.outpoint.transactionId,
             index: u.outpoint.index
           },
           utxoEntry: {
             amount: BigInt(u.amountSompi),
-            scriptPublicKey: new sdk.ScriptPublicKey(parseInt(spk.substring(0, 4), 16) || 0, spk.substring(4)),
+            scriptPublicKey: new sdk.ScriptPublicKey(spkVersion, spkHex),
             blockDaaScore: BigInt(u.blockDaaScore || "0"),
             isCoinbase: !!u.isCoinbase
           }
@@ -121,35 +209,28 @@ var KaspaWasmPrivateKeySigner = class {
       });
       const priorityFee = BigInt(plan.estimatedFeeSompi);
       const createFreshTx = () => {
-        let unsignedTx;
-        if (plan.txVersion === 1) {
-          if (!capabilities.transactionV1Signing) {
-            throw new Error("Transaction V1 signing is not supported by the installed kaspa-wasm version");
-          }
-          const allOutputs = [...plan.outputs];
-          if (plan.change) {
-            allOutputs.push({
-              address: plan.change.address,
-              amountSompi: plan.change.amountSompi
-            });
-          }
-          const wasmOutputs = allOutputs.map((o, idx) => {
-            if (!o.address) throw new Error("Output is missing address.");
-            if (o.covenant && o.covenant.covenantId) {
-              const hash = new sdk.Hash(o.covenant.covenantId);
-              const binding = new sdk.CovenantBinding(o.covenant.authorizingInput, hash);
-              return sdk.PaymentOutput.withCovenant(new sdk.Address(o.address), BigInt(o.amountSompi), binding);
-            }
-            return new sdk.PaymentOutput(new sdk.Address(o.address), BigInt(o.amountSompi));
+        const isV1 = plan.txVersion === 1;
+        if (isV1 && !capabilities.transactionV1Signing) {
+          throw new Error("Transaction V1 signing is not supported by the installed kaspa-wasm version");
+        }
+        const allOutputs = [...plan.outputs];
+        if (plan.change && BigInt(plan.change.amountSompi) > 0n) {
+          allOutputs.push({
+            address: plan.change.address,
+            amountSompi: plan.change.amountSompi
           });
-          console.log("DEBUG: Calling V1 createTransaction with:", { utxos: utxos.length, wasmOutputs: wasmOutputs.length, priorityFee });
-          console.log("DEBUG KASPA-WASM PATH:", import.meta.resolve("kaspa-wasm"));
-          console.log("DEBUG CREATE TRANSACTION FN:", sdk.createTransaction.toString());
-          unsignedTx = sdk.createTransaction(
-            utxos,
-            wasmOutputs,
-            priorityFee
-          );
+        }
+        const outputs = allOutputs.map((o) => {
+          if (!o.address) throw new Error("Output is missing address.");
+          const amount = BigInt(o.amountSompi);
+          if (isV1 && o.covenant && o.covenant.covenantId) {
+            const binding = new sdk.CovenantBinding(o.covenant.authorizingInput, new sdk.Hash(o.covenant.covenantId));
+            return { amountSompi: amount, output: sdk.PaymentOutput.withCovenant(new sdk.Address(o.address), amount, binding) };
+          }
+          return { amountSompi: amount, output: new sdk.PaymentOutput(new sdk.Address(o.address), amount) };
+        });
+        const unsignedTx = createBalancedTransaction(sdk, { utxos, outputs, feeSompi: priorityFee });
+        if (isV1) {
           const genesisGroups = /* @__PURE__ */ new Map();
           allOutputs.forEach((o, idx) => {
             if (o.covenant && !o.covenant.covenantId) {
@@ -168,29 +249,6 @@ var KaspaWasmPrivateKeySigner = class {
           if (plan.storageMass !== void 0) {
             unsignedTx.storageMass = BigInt(plan.storageMass);
           }
-        } else {
-          const allOutputs = [...plan.outputs];
-          if (plan.change) {
-            allOutputs.push({
-              address: plan.change.address,
-              amountSompi: plan.change.amountSompi
-            });
-          }
-          const wasmOutputs = allOutputs.map((o) => {
-            if (!o.address) throw new Error("Output is missing address.");
-            return {
-              address: o.address,
-              amount: BigInt(o.amountSompi)
-            };
-          });
-          console.log("DEBUG: Calling V0 createTransaction with:", { utxos: utxos.length, wasmOutputs: wasmOutputs.length, priorityFee });
-          const dummyChange = plan.change?.address || plan.from.address;
-          unsignedTx = sdk.createTransaction(
-            utxos,
-            wasmOutputs,
-            dummyChange,
-            priorityFee
-          );
         }
         const inputs = unsignedTx.inputs;
         for (let i = 0; i < inputs.length; i++) {
@@ -202,7 +260,6 @@ var KaspaWasmPrivateKeySigner = class {
             inputs[i].sigOpCount = 0;
           }
         }
-        console.log("DEBUG createFreshTx RETURNING:", unsignedTx?.constructor?.name);
         return unsignedTx;
       };
       const inputOverrides = {};
@@ -244,10 +301,7 @@ var KaspaWasmPrivateKeySigner = class {
       }
       const finalTx = createFreshTx();
       const signedTx = finalTx;
-      const wasmTxStr = typeof signedTx.serializeToJSON === "function" ? signedTx.serializeToJSON() : signedTx.toString();
-      console.log("DEBUG wasmTxStr:", wasmTxStr);
-      console.log("DEBUG: about to parseWasmTxToRpc");
-      const rpcTx = parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan);
+      const rpcTx = parseWasmTxToRpc(signedTx.serializeToObject(), signedTx, inputOverrides, plan);
       const rawTx = JSON.stringify(rpcTx);
       return {
         signatureKind: "kaspa",
@@ -263,8 +317,6 @@ var KaspaWasmPrivateKeySigner = class {
         }
       };
     } catch (error) {
-      console.error("DEBUG SIGNING ERROR:", error);
-      console.error("DEBUG STACK:", error?.stack || "NO STACK (raw panic)");
       throw new Error(
         `Kaspa WASM signing failed: ${error instanceof Error ? error.stack || error.message : JSON.stringify(error, Object.getOwnPropertyNames(error))}`
       );
@@ -290,6 +342,8 @@ async function ensureDevAccounts(workspaceDir) {
   }
   await getOrCreateDevAccount(workspaceDir, 0, "alice");
   await getOrCreateDevAccount(workspaceDir, 1, "bob");
+  await getOrCreateDevAccount(workspaceDir, 2, "carol");
+  await getOrCreateDevAccount(workspaceDir, 3, "dave");
 }
 async function getOrCreateDevAccount(workspaceDir, index, alias) {
   const devAccountsDir = path.join(workspaceDir, ".hardkas", "dev-accounts");
@@ -314,70 +368,12 @@ async function getOrCreateDevAccount(workspaceDir, index, alias) {
   const seedString = `${SIMNET_DETERMINISTIC_SEED}-${index}`;
   const privateKeyHex = crypto.createHash("sha256").update(seedString).digest("hex");
   const network = "simnet";
-  const isSimnet = ["simnet", "kaspasim", "local"].includes(network);
-  let address = "";
-  let privateKey = "";
-  let publicKey = "";
-  try {
-    if (isSimnet) {
-      let kaspaWasm;
-      try {
-        kaspaWasm = await import(
-          /* @vite-ignore */
-          "kaspa-wasm"
-        );
-      } catch (e) {
-        console.warn(`
-[Warning] kaspa-wasm is not installed. Required for simnet.`);
-        return { address: "", privateKey: "", publicKey: "" };
-      }
-      const privKey = new kaspaWasm.PrivateKey(privateKeyHex);
-      const kp = privKey.toKeypair();
-      address = kp.toAddress(network).toString();
-      publicKey = kp.publicKey;
-      privateKey = privateKeyHex;
-    } else {
-      let sdkModule;
-      try {
-        sdkModule = await import(
-          /* @vite-ignore */
-          "@kaspa/core-lib"
-        );
-      } catch (e) {
-        console.warn(`
-[Warning] @kaspa/core-lib is not installed.`);
-        return { address: "", privateKey: "", publicKey: "" };
-      }
-      const sdk = sdkModule.default || sdkModule;
-      if (typeof sdk.initRuntime === "function") {
-        await sdk.initRuntime();
-      }
-      const privKey = new sdk.PrivateKey(privateKeyHex);
-      const pubKey = privKey.toPublicKey();
-      try {
-        address = pubKey.toAddress(network).toString();
-      } catch (e) {
-        const msg = e instanceof Error ? e instanceof Error ? e instanceof Error ? e.message : String(e) : String(e) : String(e);
-        if (msg.includes("Second argument must be") || msg.includes("Unsupported")) {
-          const err = new Error("DEV_ACCOUNT_BACKEND_UNSUPPORTED_NETWORK");
-          err.code = "DEV_ACCOUNT_BACKEND_UNSUPPORTED_NETWORK";
-          throw err;
-        }
-        throw e;
-      }
-      publicKey = pubKey.toString();
-      privateKey = privKey.toString();
-    }
-  } catch (e) {
-    const msg = e instanceof Error ? e instanceof Error ? e instanceof Error ? e.message : String(e) : String(e) : String(e);
-    if (msg === "DEV_ACCOUNT_BACKEND_UNSUPPORTED_NETWORK") {
-      throw e;
-    }
-    console.warn(`
-[Warning] Could not generate dev account '${alias}'.
-${msg}`);
-    return { address: "", privateKey: "", publicKey: "" };
-  }
+  const { loadKaspaWasm: loadKaspaWasm2 } = await import("./signer-backend-LHWY7ULI.js");
+  const kaspaWasm = await loadKaspaWasm2();
+  const kp = new kaspaWasm.PrivateKey(privateKeyHex).toKeypair();
+  const address = kp.toAddress(getNetworkPrefix2(network)).toString();
+  const publicKey = kp.publicKey;
+  const privateKey = privateKeyHex;
   const accountData = {
     address,
     privateKey,
@@ -446,6 +442,11 @@ async function createDevSigner(workspaceDir, accountNameOrAddress) {
 }
 
 export {
+  assertValueConservation,
+  createBalancedTransaction,
+  createScriptTransaction,
+  toWasmScriptPublicKey,
+  planOutputsWithChange,
   DEV_ACCOUNTS_PASSWORD,
   ensureDevAccounts,
   getOrCreateDevAccount,

package/dist/{chunk-YJL7P33W.js → chunk-E73SSWAX.js}

@@ -1,4 +1,5 @@
 // src/authorizers.ts
+import { getNetworkPrefix } from "@hardkas/core";
 var StaticSignatureScriptAuthorizer = class {
   constructor(signatureScript) {
     this.signatureScript = signatureScript;
@@ -30,7 +31,7 @@ var PrivateKeyAuthorizer = class {
           const { wasm, wasmTransaction, inputIndex } = ctx;
           const privateKey = new wasm.PrivateKey(this.privateKeyHex);
           const networkId = context.plan.networkId || "simnet";
-          const expectedAddress = privateKey.toKeypair().toAddress(networkId).toString();
+          const expectedAddress = privateKey.toKeypair().toAddress(getNetworkPrefix(networkId)).toString();
           if (planInput.address && expectedAddress !== planInput.address) {
             throw new Error(
               `PRIVATE_KEY_DOES_NOT_CONTROL_INPUT: The provided private key for account '${this.accountName}' derives to address '${expectedAddress}', but input ${context.inputIndex} is controlled by '${planInput.address}'.`
@@ -38,9 +39,7 @@ var PrivateKeyAuthorizer = class {
           }
           const tx = wasmTransaction;
           try {
-            console.log("DEBUG: Calling signTransaction");
             const signedTx = wasm.signTransaction(tx, [privateKey], false);
-            console.log("DEBUG: signTransaction OK");
             const sigScript = signedTx.inputs[inputIndex].signatureScript;
             if (!sigScript || sigScript.length === 0) {
               throw new Error(`UNAUTHORIZED_TRANSACTION_INPUT: Kaspa WASM failed to generate a signature script for input ${inputIndex} using account '${this.accountName}'.`);
@@ -63,7 +62,7 @@ var LazyAccountAuthorizer = class {
   accountName;
   workspaceRoot;
   async authorize(context) {
-    const { resolveHardkasAccount } = await import("./resolve-GHZEED5L.js");
+    const { resolveHardkasAccount } = await import("./resolve-KMMTZWC3.js");
     const account = await resolveHardkasAccount({
       nameOrAddress: this.accountName,
       config: { cwd: this.workspaceRoot }
@@ -75,7 +74,7 @@ var LazyAccountAuthorizer = class {
     if (!pkValue && account.keystorePath) {
       try {
         const { KeystoreManager } = await import("./keystore-CMWEKGBF.js");
-        const { DEV_ACCOUNTS_PASSWORD } = await import("./dev-accounts-B6ZVTPCW.js");
+        const { DEV_ACCOUNTS_PASSWORD } = await import("./dev-accounts-BSWPKAAE.js");
         const keystore = await KeystoreManager.loadEncryptedKeystore(account.keystorePath);
         const unlock = await KeystoreManager.decryptEncryptedKeystore(keystore, DEV_ACCOUNTS_PASSWORD);
         if (unlock.success && unlock.payload) {