@hardkas/accounts 0.11.2-alpha → 0.11.6-alpha

package/dist/authorizers-TYSAH7ZC.js

@@ -0,0 +1,10 @@
+import {
+  LazyAccountAuthorizer,
+  PrivateKeyAuthorizer,
+  StaticSignatureScriptAuthorizer
+} from "./chunk-3XXJ6UUU.js";
+export {
+  LazyAccountAuthorizer,
+  PrivateKeyAuthorizer,
+  StaticSignatureScriptAuthorizer
+};

package/dist/chunk-3XXJ6UUU.js

@@ -0,0 +1,99 @@
+// src/authorizers.ts
+var StaticSignatureScriptAuthorizer = class {
+  constructor(signatureScript) {
+    this.signatureScript = signatureScript;
+  }
+  signatureScript;
+  authorize() {
+    return {
+      kind: "signature-script",
+      signatureScript: this.signatureScript
+    };
+  }
+};
+var PrivateKeyAuthorizer = class {
+  constructor(accountName, privateKeyHex) {
+    this.accountName = accountName;
+    this.privateKeyHex = privateKeyHex;
+  }
+  accountName;
+  privateKeyHex;
+  authorize(context) {
+    const planInput = context.plan.inputs[context.inputIndex];
+    if (!planInput) {
+      throw new Error(`INVALID_AUTHORIZER_INPUT_INDEX: Input index ${context.inputIndex} does not exist in plan.`);
+    }
+    return {
+      kind: "wasm-signer",
+      signer: {
+        signInput: async (ctx) => {
+          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();
+          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}'.`
+            );
+          }
+          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}'.`);
+            }
+            const sigScriptHex = typeof sigScript === "string" ? sigScript : Buffer.from(sigScript).toString("hex");
+            return sigScriptHex;
+          } catch (e) {
+            throw new Error(`UNAUTHORIZED_TRANSACTION_INPUT: Failed to sign input ${inputIndex} with PrivateKeyAuthorizer: ${e.message}`);
+          }
+        }
+      }
+    };
+  }
+};
+var LazyAccountAuthorizer = class {
+  constructor(accountName, workspaceRoot) {
+    this.accountName = accountName;
+    this.workspaceRoot = workspaceRoot;
+  }
+  accountName;
+  workspaceRoot;
+  async authorize(context) {
+    const { resolveHardkasAccount } = await import("./resolve-EXYT2GAC.js");
+    const account = await resolveHardkasAccount({
+      nameOrAddress: this.accountName,
+      config: { cwd: this.workspaceRoot }
+    });
+    let pkValue = account.privateKeyEnv ? process.env[account.privateKeyEnv] : void 0;
+    if (!pkValue && account.privateKey) {
+      pkValue = account.privateKey;
+    }
+    if (!pkValue && account.keystorePath) {
+      try {
+        const { KeystoreManager } = await import("./keystore-CMWEKGBF.js");
+        const { DEV_ACCOUNTS_PASSWORD } = await import("./dev-accounts-UULCTDJB.js");
+        const keystore = await KeystoreManager.loadEncryptedKeystore(account.keystorePath);
+        const unlock = await KeystoreManager.decryptEncryptedKeystore(keystore, DEV_ACCOUNTS_PASSWORD);
+        if (unlock.success && unlock.payload) {
+          pkValue = unlock.payload.privateKey;
+        }
+      } catch (e) {
+      }
+    }
+    if (!pkValue) {
+      throw new Error(`DEV_ACCOUNT_KEY_UNAVAILABLE: Missing required private key for account '${this.accountName}'.`);
+    }
+    const internalAuthorizer = new PrivateKeyAuthorizer(this.accountName, pkValue);
+    return internalAuthorizer.authorize(context);
+  }
+};
+
+export {
+  StaticSignatureScriptAuthorizer,
+  PrivateKeyAuthorizer,
+  LazyAccountAuthorizer
+};

package/dist/chunk-6DPO5V3N.js

@@ -0,0 +1,90 @@
+// src/signer-backend.ts
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+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;
+    }
+  }
+  if (provider === "local" || provider === "release-asset") {
+    if (!config?.path) {
+      throw new Error(`WASM_PROVIDER_ERROR: 'path' must be provided when using provider '${provider}'`);
+    }
+    const absolutePath = path.isAbsolute(config.path) ? config.path : path.resolve(process.cwd(), config.path);
+    if (!fs.existsSync(absolutePath)) {
+      if (provider === "release-asset") {
+        const err = new Error(`WASM_RELEASE_ASSET_NOT_FOUND: Could not find WASM release asset at ${absolutePath}`);
+        err.code = "WASM_RELEASE_ASSET_NOT_FOUND";
+        throw err;
+      }
+      throw new Error(`WASM_PROVIDER_ERROR: Local WASM path does not exist at ${absolutePath}`);
+    }
+    try {
+      let entryPath = absolutePath;
+      if (fs.statSync(absolutePath).isDirectory()) {
+        const pkgPath = path.join(absolutePath, "package.json");
+        if (fs.existsSync(pkgPath)) {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+          if (pkg.main) {
+            entryPath = path.join(absolutePath, pkg.main);
+          } else {
+            entryPath = path.join(absolutePath, "index.js");
+          }
+        } else {
+          entryPath = path.join(absolutePath, "index.js");
+        }
+      }
+      return await import(pathToFileURL(entryPath).href);
+    } catch (error) {
+      const err = new Error(`WASM_LOAD_FAILED: Failed to load local WASM backend from ${absolutePath}. Details: ${error.message}`);
+      err.code = "WASM_LOAD_FAILED";
+      throw err;
+    }
+  }
+}
+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;
+  }
+  return { transactionV1Signing: v1 };
+}
+async function getKaspaSigningBackendStatus(config) {
+  try {
+    const sdk = await loadKaspaWasm(config);
+    return {
+      available: true,
+      name: "Kaspa WASM SDK",
+      version: sdk.version || "unknown",
+      capabilities: detectCapabilities(sdk)
+    };
+  } catch (error) {
+    if (error.code === "WASM_RELEASE_ASSET_NOT_FOUND") {
+      throw error;
+    }
+    return {
+      available: false,
+      name: "None",
+      error: error instanceof Error ? error.message : String(error),
+      capabilities: { transactionV1Signing: false }
+    };
+  }
+}
+
+export {
+  loadKaspaWasm,
+  detectCapabilities,
+  getKaspaSigningBackendStatus
+};

package/dist/chunk-ILASLDZU.js

@@ -0,0 +1,472 @@
+// src/resolve.ts
+import fs2 from "fs";
+import path2 from "path";
+import { createDeterministicAccounts } from "@hardkas/localnet";
+
+// src/real-accounts.ts
+import fs from "fs";
+import path from "path";
+import { writeFileAtomicSync } from "@hardkas/core";
+import {
+  HARDKAS_VERSION,
+  ARTIFACT_SCHEMAS,
+  ARTIFACT_VERSION
+} from "@hardkas/artifacts";
+function getDefaultRealAccountsPath(cwd) {
+  const root = cwd ?? process.cwd();
+  return path.join(root, ".hardkas", "accounts.real.json");
+}
+function createEmptyRealAccountStore() {
+  return {
+    schema: ARTIFACT_SCHEMAS.REAL_ACCOUNT_STORE,
+    hardkasVersion: HARDKAS_VERSION,
+    version: ARTIFACT_VERSION,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    networkId: "simnet",
+    mode: "real",
+    connectionMode: "node",
+    warning: "HardKAS: Development account store. Encrypted storage is default. Unsafe plaintext storage is legacy.",
+    accounts: []
+  };
+}
+function loadRealAccountStoreSync(options) {
+  const filePath = options?.path || getDefaultRealAccountsPath(options?.cwd);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const data = fs.readFileSync(filePath, "utf-8");
+    const store = JSON.parse(data);
+    for (const a of store.accounts) {
+      if ("privateKey" in a && a.privateKey !== void 0) {
+        if (a.privateKey === null || a.privateKey === "" || a.privateKey === "[object Object]" || typeof a.privateKey === "object" || typeof a.privateKey === "string" && a.privateKey.includes("__wbg_ptr") || typeof a.privateKey === "object" && "__wbg_ptr" in a.privateKey) {
+          const err = new Error(
+            "CORRUPTED_PRIVATE_KEY_SERIALIZATION: This account was generated by a broken alpha and must be regenerated. The private key was not recoverably stored."
+          );
+          err.code = "CORRUPTED_PRIVATE_KEY_SERIALIZATION";
+          throw err;
+        }
+      }
+    }
+    const plaintextAccounts = store.accounts.filter((a) => a.privateKey);
+    if (plaintextAccounts.length > 0) {
+      const names = plaintextAccounts.map((a) => a.name).join(", ");
+      console.warn(
+        `
+  \u26A0\uFE0F  [SECURITY WARNING] Plaintext private keys detected in legacy account store for: ${names}`
+      );
+      console.warn(`     Location: ${filePath}`);
+      console.warn(
+        `     Recommendation: Re-import these accounts using encrypted keystores.
+`
+      );
+    }
+    return store;
+  } catch (e) {
+    throw new Error(
+      `Failed to load real account store at ${filePath}: ${e instanceof Error ? e instanceof Error ? e instanceof Error ? e.message : String(e) : String(e) : String(e)}`
+    );
+  }
+}
+async function loadRealAccountStore(options) {
+  return loadRealAccountStoreSync(options);
+}
+async function loadOrCreateRealAccountStore(options) {
+  const store = await loadRealAccountStore(options);
+  if (store) return store;
+  const newStore = createEmptyRealAccountStore();
+  await saveRealAccountStore(newStore, options);
+  return newStore;
+}
+async function saveRealAccountStore(store, options) {
+  const filePath = options?.path || getDefaultRealAccountsPath(options?.cwd);
+  try {
+    writeFileAtomicSync(filePath, JSON.stringify(store, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+  } catch (e) {
+    throw new Error(
+      `Failed to save real account store at ${filePath}: ${e instanceof Error ? e instanceof Error ? e instanceof Error ? e.message : String(e) : String(e) : String(e)}`
+    );
+  }
+}
+function validateAccountName(name) {
+  if (!name) {
+    throw new Error("Account name is required.");
+  }
+  const nameRegex = /^[a-zA-Z0-9_-]+$/;
+  if (!nameRegex.test(name)) {
+    throw new Error(
+      `Invalid account name '${name}'. Only letters, numbers, dashes and underscores are allowed.`
+    );
+  }
+}
+function validateAddressPrefix(address) {
+  if (!address) {
+    throw new Error("Address is required.");
+  }
+  const validPrefixes = ["kaspa:", "kaspatest:", "kaspasim:"];
+  const hasValidPrefix = validPrefixes.some((prefix) => address.startsWith(prefix));
+  if (!hasValidPrefix) {
+    const err = new Error(
+      `HARDKAS_INVALID_ADDRESS: Invalid address '${address}'. Must start with one of: ${validPrefixes.join(", ")}`
+    );
+    err.code = "HARDKAS_INVALID_ADDRESS";
+    throw err;
+  }
+}
+function validateAddressNetwork(address, networkId, allowMainnet) {
+  if (address.startsWith("kaspa:sim_")) {
+    return;
+  }
+  validateAddressPrefix(address);
+  let expectedPrefix;
+  if (networkId === "mainnet") {
+    expectedPrefix = "kaspa:";
+  } else if (networkId === "testnet-10" || networkId === "testnet-11") {
+    expectedPrefix = "kaspatest:";
+  } else if (networkId === "simnet" || networkId === "devnet" || networkId === "simulated") {
+    expectedPrefix = "kaspasim:";
+  } else {
+    return;
+  }
+  if (expectedPrefix !== "kaspa:" && address.startsWith("kaspa:") && allowMainnet) {
+    return;
+  }
+  if (!address.startsWith(expectedPrefix)) {
+    const err = new Error(
+      `NETWORK_ADDRESS_MISMATCH: Address '${address}' does not match the expected prefix '${expectedPrefix}' for network '${networkId}'.`
+    );
+    err.code = "NETWORK_ADDRESS_MISMATCH";
+    throw err;
+  }
+}
+function importRealDevAccount(store, account) {
+  validateAccountName(account.name);
+  validateAddressPrefix(account.address);
+  if (store.accounts.some((a) => a.name.toLowerCase() === account.name.toLowerCase())) {
+    throw new Error(`Account with name '${account.name}' already exists.`);
+  }
+  const newAccount = {
+    ...account,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    ...store,
+    accounts: [...store.accounts, newAccount]
+  };
+}
+function removeRealDevAccount(store, name) {
+  const index = store.accounts.findIndex(
+    (a) => a.name.toLowerCase() === name.toLowerCase()
+  );
+  if (index === -1) {
+    throw new Error(`Account with name '${name}' not found.`);
+  }
+  const newAccounts = [...store.accounts];
+  newAccounts.splice(index, 1);
+  return {
+    ...store,
+    accounts: newAccounts
+  };
+}
+function getRealDevAccount(store, name) {
+  return store.accounts.find((a) => a.name.toLowerCase() === name.toLowerCase()) || null;
+}
+function listRealDevAccounts(store) {
+  return store.accounts;
+}
+function resolveRealAccountOrAddress(store, nameOrAddress) {
+  const account = store ? getRealDevAccount(store, nameOrAddress) : null;
+  if (account) {
+    return { address: account.address, name: account.name };
+  }
+  if (nameOrAddress.startsWith("kaspa:") || nameOrAddress.startsWith("kaspatest:") || nameOrAddress.startsWith("kaspasim:")) {
+    return { address: nameOrAddress };
+  }
+  throw new Error(
+    `'${nameOrAddress}' is not a registered real account name and is not a valid Kaspa address.`
+  );
+}
+
+// src/resolve.ts
+function resolveHardkasAccount(options) {
+  const { nameOrAddress, config } = options;
+  if (nameOrAddress.startsWith("kaspa:") || nameOrAddress.startsWith("kaspatest:") || nameOrAddress.startsWith("kaspasim:")) {
+    return {
+      name: nameOrAddress,
+      kind: "external-wallet",
+      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) {
+    }
+  }
+  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(", ");
+  throw new Error(
+    `Unknown HardKAS account '${nameOrAddress}'. Available accounts: ${available}`
+  );
+}
+function listHardkasAccounts(config) {
+  const accounts = /* @__PURE__ */ new Map();
+  const detAccounts = createDeterministicAccounts();
+  for (const det of detAccounts) {
+    accounts.set(det.name, {
+      name: det.name,
+      kind: "simulated",
+      address: det.address,
+      evmAddress: det.evmAddress
+    });
+  }
+  const workspaceRoot = config?.cwd || process.cwd();
+  const devAccountsDir = path2.join(workspaceRoot, ".hardkas", "dev-accounts");
+  if (fs2.existsSync(devAccountsDir)) {
+    const files = fs2.readdirSync(devAccountsDir);
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const name = path2.basename(file, ".json");
+          const data = fs2.readFileSync(path2.join(devAccountsDir, file), "utf-8");
+          const keystore = JSON.parse(data);
+          if (keystore.type === "hardkas.encryptedKeystore.v2") {
+            accounts.set(name, {
+              name,
+              kind: "kaspa-private-key",
+              address: keystore.payload?.address || keystore.metadata?.address,
+              keystorePath: path2.join(devAccountsDir, file)
+            });
+          }
+        } 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);
+      for (const [name, acc] of Object.entries(ks)) {
+        if (acc.type === "simulated") {
+          accounts.set(name, {
+            name,
+            kind: "simulated",
+            address: acc.address
+          });
+        } else {
+          accounts.set(name, {
+            name,
+            kind: "kaspa-private-key",
+            address: acc.address
+          });
+        }
+      }
+    } catch (e) {
+    }
+  }
+  const realStore = loadRealAccountStoreSync({ cwd: workspaceRoot });
+  if (realStore) {
+    for (const realAcc of listRealDevAccounts(realStore)) {
+      accounts.set(realAcc.name, {
+        name: realAcc.name,
+        kind: "kaspa-private-key",
+        address: realAcc.address,
+        ...realAcc.privateKeyEnv ? { privateKeyEnv: realAcc.privateKeyEnv } : {},
+        ...realAcc.privateKey ? { privateKey: realAcc.privateKey } : {}
+      });
+    }
+  }
+  const keystoreDir = path2.join(process.cwd(), ".hardkas", "keystore");
+  if (fs2.existsSync(keystoreDir)) {
+    const files = fs2.readdirSync(keystoreDir);
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const name = path2.basename(file, ".json");
+          const data = fs2.readFileSync(path2.join(keystoreDir, file), "utf-8");
+          const keystore = JSON.parse(data);
+          if (keystore.type === "hardkas.encryptedKeystore.v2") {
+            accounts.set(name, {
+              name,
+              kind: "kaspa-private-key",
+              address: keystore.payload?.address || keystore.metadata?.address,
+              // Payloads are encrypted, but address might be in metadata
+              keystorePath: path2.join(keystoreDir, file)
+            });
+          }
+        } catch (e) {
+        }
+      }
+    }
+  }
+  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;
+      }
+      accounts.set(name, {
+        name,
+        ...accConfig
+      });
+    }
+  }
+  return Array.from(accounts.values());
+}
+async function resolveHardkasAccountAddress(accountOrAddress, config, context = "L1") {
+  if (accountOrAddress.startsWith("kaspa:") || accountOrAddress.startsWith("kaspatest:") || accountOrAddress.startsWith("kaspasim:")) {
+    if (context === "L2") {
+      throw new Error(
+        `Invalid L2 address provided: ${accountOrAddress}. Expected EVM address or account alias.`
+      );
+    }
+    if (!accountOrAddress.startsWith("kaspa:sim_")) {
+      try {
+        const kaspa = await import("kaspa-wasm");
+        try {
+          if (typeof kaspa.Address === "function" || kaspa.Address) {
+            new kaspa.Address(accountOrAddress);
+          }
+        } catch (e) {
+          const err = new Error(
+            `HARDKAS_INVALID_ADDRESS: Invalid Kaspa address format or checksum.`
+          );
+          err.code = "HARDKAS_INVALID_ADDRESS";
+          throw err;
+        }
+      } catch (e) {
+        if (e instanceof Error && e.code === "HARDKAS_INVALID_ADDRESS") 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."
+          );
+          err.code = "ADDRESS_VALIDATOR_UNAVAILABLE";
+          throw err;
+        }
+        throw e;
+      }
+    }
+    return accountOrAddress;
+  }
+  if (accountOrAddress.startsWith("0x") && accountOrAddress.length === 42) {
+    return accountOrAddress;
+  }
+  const account = resolveHardkasAccount({ nameOrAddress: accountOrAddress, config });
+  if (context === "L2") {
+    const evmAddress = account.evmAddress;
+    if (!evmAddress) {
+      throw new Error(
+        `Account '${account.name}' does not have an EVM address configured for L2.`
+      );
+    }
+    return evmAddress;
+  }
+  if (!account.address) {
+    throw new Error(`Account '${account.name}' does not have a resolved address yet.`);
+  }
+  return account.address;
+}
+function describeAccount(account) {
+  const desc = {
+    name: account.name,
+    kind: account.kind
+  };
+  if (account.address) {
+    desc.address = account.address;
+  }
+  if (account.kind === "kaspa-private-key" || account.kind === "evm-private-key") {
+    desc.privateKeyEnv = account.privateKeyEnv;
+  }
+  if (account.kind === "external-wallet" && account.walletId) {
+    desc.walletId = account.walletId;
+  }
+  return desc;
+}
+
+export {
+  getDefaultRealAccountsPath,
+  createEmptyRealAccountStore,
+  loadRealAccountStoreSync,
+  loadRealAccountStore,
+  loadOrCreateRealAccountStore,
+  saveRealAccountStore,
+  validateAccountName,
+  validateAddressPrefix,
+  validateAddressNetwork,
+  importRealDevAccount,
+  removeRealDevAccount,
+  getRealDevAccount,
+  listRealDevAccounts,
+  resolveRealAccountOrAddress,
+  resolveHardkasAccount,
+  listHardkasAccounts,
+  resolveHardkasAccountAddress,
+  describeAccount
+};