@hardkas/accounts 0.11.6-alpha → 0.12.0-rc.10

package/dist/{authorizers-TYSAH7ZC.js → authorizers-NEWT33BI.js}

@@ -2,7 +2,8 @@ import {
   LazyAccountAuthorizer,
   PrivateKeyAuthorizer,
   StaticSignatureScriptAuthorizer
-} from "./chunk-3XXJ6UUU.js";
+} from "./chunk-5WYALW6N.js";
+import "./chunk-MCKGQKYU.js";
 export {
   LazyAccountAuthorizer,
   PrivateKeyAuthorizer,

package/dist/{chunk-ILASLDZU.js → chunk-23LEGEIY.js}

@@ -2,6 +2,7 @@
 import fs2 from "fs";
 import path2 from "path";
 import { createDeterministicAccounts } from "@hardkas/localnet";
+import { CrossWorldAccountCollisionError, AccountNetworkMismatchError } from "@hardkas/core";
 
 // src/real-accounts.ts
 import fs from "fs";
@@ -193,97 +194,76 @@ function resolveRealAccountOrAddress(store, nameOrAddress) {
 // src/resolve.ts
 function resolveHardkasAccount(options) {
   const { nameOrAddress, config } = options;
+  if (nameOrAddress.startsWith("kaspa:sim_")) {
+    return {
+      name: nameOrAddress,
+      kind: "synthetic",
+      executionMode: "simulator",
+      address: nameOrAddress
+    };
+  }
   if (nameOrAddress.startsWith("kaspa:") || nameOrAddress.startsWith("kaspatest:") || nameOrAddress.startsWith("kaspasim:")) {
+    let network = "mainnet";
+    if (nameOrAddress.startsWith("kaspasim:")) network = "simnet";
+    else if (nameOrAddress.startsWith("kaspatest:")) {
+      const match = nameOrAddress.match(/^kaspatest:(\d+)_/);
+      network = match ? `testnet-${match[1]}` : void 0;
+    }
     return {
       name: nameOrAddress,
       kind: "external-wallet",
+      ...network ? { network } : {},
       address: nameOrAddress
     };
   }
   let alias = nameOrAddress;
   if (alias === "0") alias = "alice";
   if (alias === "1") alias = "bob";
-  const workspaceRoot = config?.cwd || process.cwd();
-  const devAccountPath = path2.join(
-    workspaceRoot,
-    ".hardkas",
-    "dev-accounts",
-    `${alias}.json`
-  );
-  if (fs2.existsSync(devAccountPath)) {
-    try {
-      const data = fs2.readFileSync(devAccountPath, "utf-8");
-      const keystore = JSON.parse(data);
-      if (keystore.type === "hardkas.encryptedKeystore.v2") {
-        return {
-          name: alias,
-          kind: "kaspa-private-key",
-          address: keystore.metadata?.address,
-          keystorePath: devAccountPath
-        };
-      }
-    } catch (e) {
-    }
-  }
-  const keystoreJsonPath = path2.join(workspaceRoot, ".hardkas", "keystore.json");
-  if (fs2.existsSync(keystoreJsonPath)) {
-    try {
-      const data = fs2.readFileSync(keystoreJsonPath, "utf-8");
-      const ks = JSON.parse(data);
-      if (ks[alias]) {
-        return {
-          name: alias,
-          kind: ks[alias].type === "simulated" ? "simulated" : "kaspa-private-key",
-          address: ks[alias].address
-        };
-      }
-    } catch (e) {
-    }
+  const accounts = listHardkasAccounts(config);
+  const found = accounts.find((a) => a.name === alias);
+  if (found) {
+    return found;
   }
-  if (config?.accounts && config.accounts[alias]) {
-    const accConfig = config.accounts[alias];
-    return {
-      name: alias,
-      ...accConfig
-    };
-  }
-  const realStore = loadRealAccountStoreSync({ cwd: workspaceRoot });
-  const realAcc = realStore ? getRealDevAccount(realStore, alias) : null;
-  if (realAcc) {
-    return {
-      name: realAcc.name,
-      kind: "kaspa-private-key",
-      // Assuming Kaspa for now, could be extensible
-      address: realAcc.address,
-      ...realAcc.privateKeyEnv ? { privateKeyEnv: realAcc.privateKeyEnv } : {},
-      ...realAcc.privateKey ? { privateKey: realAcc.privateKey } : {}
-    };
-  }
-  const detAccounts = createDeterministicAccounts();
-  const det = detAccounts.find((a) => a.name === alias);
-  if (det) {
-    return {
-      name: det.name,
-      kind: "simulated",
-      address: det.address,
-      evmAddress: det.evmAddress
-    };
-  }
-  const available = listHardkasAccounts(config).map((a) => a.name).join(", ");
+  const available = accounts.map((a) => a.name).join(", ");
   throw new Error(
     `Unknown HardKAS account '${nameOrAddress}'. Available accounts: ${available}`
   );
 }
 function listHardkasAccounts(config) {
   const accounts = /* @__PURE__ */ new Map();
+  let targetMode = "localnet";
+  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";
+      }
+    }
+  }
   const detAccounts = createDeterministicAccounts();
   for (const det of detAccounts) {
-    accounts.set(det.name, {
-      name: det.name,
-      kind: "simulated",
-      address: det.address,
-      evmAddress: det.evmAddress
-    });
+    if (targetMode === "simulator") {
+      accounts.set(det.name, {
+        name: det.name,
+        kind: "synthetic",
+        executionMode: "simulator",
+        address: det.address,
+        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");
@@ -296,14 +276,19 @@ function listHardkasAccounts(config) {
           const data = fs2.readFileSync(path2.join(devAccountsDir, file), "utf-8");
           const keystore = JSON.parse(data);
           if (keystore.type === "hardkas.encryptedKeystore.v2") {
+            if (!keystore.metadata?.network) {
+              throw new AccountNetworkMismatchError({ expected: "known network", actual: "undefined", detail: `at ${path2.join(devAccountsDir, file)}` });
+            }
             accounts.set(name, {
               name,
-              kind: "kaspa-private-key",
+              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;
         }
       }
     }
@@ -314,21 +299,33 @@ 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: "simulated",
+            kind: "synthetic",
+            executionMode: "simulator",
             address: acc.address
           });
         } else {
+          if (!acc.network) {
+            throw new AccountNetworkMismatchError({ expected: "known network", actual: "undefined", detail: "in keystore.json" });
+          }
           accounts.set(name, {
             name,
-            kind: "kaspa-private-key",
+            kind: "kaspa",
+            network: acc.network,
             address: acc.address
           });
         }
       }
     } catch (e) {
+      if (e instanceof CrossWorldAccountCollisionError || e instanceof AccountNetworkMismatchError) throw e;
     }
   }
   const realStore = loadRealAccountStoreSync({ cwd: workspaceRoot });
@@ -336,7 +333,9 @@ function listHardkasAccounts(config) {
     for (const realAcc of listRealDevAccounts(realStore)) {
       accounts.set(realAcc.name, {
         name: realAcc.name,
-        kind: "kaspa-private-key",
+        kind: "kaspa",
+        network: "simnet",
+        // Wait, listRealDevAccounts returns accounts, does it have network? The legacy real store assumed simnet. We'll leave it as simnet for now, or maybe the store should provide it.
         address: realAcc.address,
         ...realAcc.privateKeyEnv ? { privateKeyEnv: realAcc.privateKeyEnv } : {},
         ...realAcc.privateKey ? { privateKey: realAcc.privateKey } : {}
@@ -353,15 +352,20 @@ function listHardkasAccounts(config) {
           const data = fs2.readFileSync(path2.join(keystoreDir, file), "utf-8");
           const keystore = JSON.parse(data);
           if (keystore.type === "hardkas.encryptedKeystore.v2") {
+            if (!keystore.metadata?.network) {
+              throw new AccountNetworkMismatchError({ expected: "known network", actual: "undefined", detail: `at ${path2.join(keystoreDir, file)}` });
+            }
             accounts.set(name, {
               name,
-              kind: "kaspa-private-key",
+              kind: "kaspa",
+              network: keystore.metadata.network,
               address: keystore.payload?.address || keystore.metadata?.address,
               // Payloads are encrypted, but address might be in metadata
               keystorePath: path2.join(keystoreDir, file)
             });
           }
         } catch (e) {
+          if (e instanceof AccountNetworkMismatchError) throw e;
         }
       }
     }
@@ -369,12 +373,16 @@ function listHardkasAccounts(config) {
   if (config?.accounts) {
     for (const [name, accConfig] of Object.entries(config.accounts)) {
       const existing = accounts.get(name);
-      if (existing && existing.kind === "kaspa-private-key" && accConfig.kind === "simulated") {
-        continue;
+      const configKind = accConfig.kind === "simulated" ? "synthetic" : accConfig.kind;
+      if (existing && existing.kind !== configKind) {
+        console.error(`COLLISION DETECTED for ${name}. existing:`, existing, `configKind:`, configKind);
+        throw new CrossWorldAccountCollisionError({ accountId: name, worlds: [existing.kind, configKind] });
       }
       accounts.set(name, {
         name,
-        ...accConfig
+        ...accConfig,
+        kind: configKind,
+        ...configKind === "synthetic" ? { executionMode: "simulator" } : {}
       });
     }
   }
@@ -441,7 +449,7 @@ function describeAccount(account) {
   if (account.address) {
     desc.address = account.address;
   }
-  if (account.kind === "kaspa-private-key" || account.kind === "evm-private-key") {
+  if (account.kind === "kaspa" || account.kind === "evm-private-key") {
     desc.privateKeyEnv = account.privateKeyEnv;
   }
   if (account.kind === "external-wallet" && account.walletId) {

package/dist/{chunk-3XXJ6UUU.js → chunk-5WYALW6N.js}

@@ -63,7 +63,7 @@ var LazyAccountAuthorizer = class {
   accountName;
   workspaceRoot;
   async authorize(context) {
-    const { resolveHardkasAccount } = await import("./resolve-EXYT2GAC.js");
+    const { resolveHardkasAccount } = await import("./resolve-LNOAVBLS.js");
     const account = await resolveHardkasAccount({
       nameOrAddress: this.accountName,
       config: { cwd: this.workspaceRoot }
@@ -74,8 +74,8 @@ var LazyAccountAuthorizer = class {
     }
     if (!pkValue && account.keystorePath) {
       try {
-        const { KeystoreManager } = await import("./keystore-CMWEKGBF.js");
-        const { DEV_ACCOUNTS_PASSWORD } = await import("./dev-accounts-UULCTDJB.js");
+        const { KeystoreManager } = await import("./keystore-2KRHVGCM.js");
+        const { DEV_ACCOUNTS_PASSWORD } = await import("./dev-accounts-IIHQSSO2.js");
         const keystore = await KeystoreManager.loadEncryptedKeystore(account.keystorePath);
         const unlock = await KeystoreManager.decryptEncryptedKeystore(keystore, DEV_ACCOUNTS_PASSWORD);
         if (unlock.success && unlock.payload) {

package/dist/chunk-MCKGQKYU.js

@@ -0,0 +1,15 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};

package/dist/{chunk-WXMOC6WN.js → chunk-P7GKSUK7.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-R5P3WIWR.js";
 import {
   resolveHardkasAccount
-} from "./chunk-ILASLDZU.js";
+} from "./chunk-23LEGEIY.js";
 import {
   loadKaspaWasm
 } from "./chunk-6DPO5V3N.js";
@@ -24,11 +24,11 @@ var KaspaWasmPrivateKeySigner = class {
     this.options = options;
   }
   options;
-  kind = "kaspa-private-key";
+  kind = "kaspa";
   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-X3FD3XMB.js");
     const capabilities = detectCapabilities(sdk);
     if (plan.computeBudget !== void 0 || plan.outputs.some((o) => o.covenant)) {
       if (!capabilities.transactionV1Signing) {
@@ -55,8 +55,8 @@ var KaspaWasmPrivateKeySigner = class {
       }
       if (!pkValue && account.keystorePath) {
         try {
-          const KeystoreManager2 = (await import("./keystore-CMWEKGBF.js")).KeystoreManager;
-          const DEV_ACCOUNTS_PASSWORD2 = (await import("./dev-accounts-UULCTDJB.js")).DEV_ACCOUNTS_PASSWORD;
+          const KeystoreManager2 = (await import("./keystore-2KRHVGCM.js")).KeystoreManager;
+          const DEV_ACCOUNTS_PASSWORD2 = (await import("./dev-accounts-IIHQSSO2.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) {
@@ -76,7 +76,7 @@ var KaspaWasmPrivateKeySigner = class {
         throw err;
       }
       const expectedAddress = new sdk.PrivateKey(pkValue).toKeypair().toAddress(plan.networkId || "simnet").toString();
-      const { PrivateKeyAuthorizer } = await import("./authorizers-TYSAH7ZC.js");
+      const { PrivateKeyAuthorizer } = await import("./authorizers-NEWT33BI.js");
       const sourceInputs = plan.inputs || plan.selectedUtxos || [];
       for (let i = 0; i < numInputs; i++) {
         if (!authorizers[i]) {
@@ -250,7 +250,7 @@ var KaspaWasmPrivateKeySigner = class {
       const rpcTx = parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan);
       const rawTx = JSON.stringify(rpcTx);
       return {
-        signatureKind: "kaspa-private-key",
+        signatureKind: "kaspa",
         signerAddress: input.accountName || plan.from.address || "authorized",
         signedTransaction: {
           format: "hex",
@@ -341,7 +341,7 @@ async function getOrCreateDevAccount(workspaceDir, index, alias) {
       try {
         sdkModule = await import(
           /* @vite-ignore */
-          "@kaspa/core-lib"
+          "./core-lib-2VZIZ7XT.js"
         );
       } catch (e) {
         console.warn(`
@@ -436,7 +436,7 @@ async function createDevSigner(workspaceDir, accountNameOrAddress) {
     nameOrAddress: accountNameOrAddress,
     config: { cwd: workspaceDir }
   });
-  if (account.kind !== "kaspa-private-key") {
+  if (account.kind !== "kaspa") {
     throw new Error(`Account '${accountNameOrAddress}' is not a private key account, cannot create local dev signer.`);
   }
   return new KaspaWasmPrivateKeySigner({