@hardkas/accounts 0.11.2-alpha → 0.11.4-alpha

package/dist/chunk-TY5CXPHB.js

@@ -0,0 +1,452 @@
+import {
+  parseWasmTxToRpc
+} from "./chunk-WRRHW2WO.js";
+import {
+  resolveHardkasAccount
+} from "./chunk-ILASLDZU.js";
+import {
+  loadKaspaWasm
+} from "./chunk-6DPO5V3N.js";
+import {
+  KeystoreManager
+} from "./chunk-YLG2NIAU.js";
+
+// src/dev-accounts.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { deterministicCompare } from "@hardkas/core";
+
+// src/kaspa-wasm-signer.ts
+import { calculateContentHash } from "@hardkas/artifacts";
+var KaspaWasmPrivateKeySigner = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  kind = "kaspa-private-key";
+  async signTxPlan(input) {
+    const plan = input.planArtifact;
+    const sdk = await loadKaspaWasm(this.options.wasmConfig);
+    const { detectCapabilities } = await import("./signer-backend-W3LNCQA3.js");
+    const capabilities = detectCapabilities(sdk);
+    if (plan.computeBudget !== void 0 || plan.outputs.some((o) => o.covenant)) {
+      if (!capabilities.transactionV1Signing) {
+        throw new Error("Transaction V1 signing is not supported by the installed kaspa-wasm version");
+      }
+    }
+    assertSigningNetworkAllowed({
+      network: plan.networkId,
+      mode: plan.mode,
+      allowMainnet: this.options.allowMainnet
+    });
+    let authorizers = input.authorizers ? { ...input.authorizers } : {};
+    const numInputs = plan.inputs?.length || plan.selectedUtxos?.length || 0;
+    if (this.options.account) {
+      const account = this.options.account;
+      let pkValue = account.privateKeyEnv ? process.env[account.privateKeyEnv] : void 0;
+      if (!pkValue && account.privateKey) {
+        if (plan.networkId === "mainnet") {
+          throw new Error(
+            `Mainnet guard: Unsafe plaintext privateKey fallback is forbidden on mainnet for account '${account.name}'. Use privateKeyEnv instead.`
+          );
+        }
+        pkValue = account.privateKey;
+      }
+      if (!pkValue && account.keystorePath) {
+        try {
+          const KeystoreManager2 = (await import("./keystore-CMWEKGBF.js")).KeystoreManager;
+          const DEV_ACCOUNTS_PASSWORD2 = (await import("./dev-accounts-FU4XTSGF.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) {
+            pkValue = unlock.payload.privateKey;
+          }
+        } catch (e) {
+        }
+      }
+      if (!pkValue) {
+        const err = new Error(`DEV_ACCOUNT_KEY_UNAVAILABLE: Missing required private key for account '${account.name}'.`);
+        err.code = "DEV_ACCOUNT_KEY_UNAVAILABLE";
+        throw err;
+      }
+      if (typeof pkValue !== "string" || pkValue.trim() === "" || !/^[0-9a-fA-F]{64}$/.test(pkValue)) {
+        const err = new Error("INVALID_PRIVATE_KEY_MATERIAL: Private key must be a valid 64-character hex string.");
+        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-N2RUAVJV.js");
+      const sourceInputs = plan.inputs || plan.selectedUtxos || [];
+      for (let i = 0; i < numInputs; i++) {
+        if (!authorizers[i]) {
+          const inputAddress = sourceInputs[i]?.address;
+          if (inputAddress === expectedAddress) {
+            authorizers[i] = new PrivateKeyAuthorizer(account.name, pkValue);
+          }
+        }
+      }
+    }
+    for (let i = 0; i < numInputs; i++) {
+      if (!authorizers[i]) {
+        throw new Error(`MISSING_INPUT_AUTHORIZER: No authorizer was provided for input index ${i}.`);
+      }
+    }
+    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) {
+          throw new Error(`UTXO is missing transactionId or index. Re-run tx plan.`);
+        }
+        const spk = u.scriptPublicKey;
+        if (!spk) {
+          throw new Error(
+            "UTXO is missing scriptPublicKey. Real signing flows must never fabricate cryptographic state."
+          );
+        }
+        return {
+          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)),
+            blockDaaScore: BigInt(u.blockDaaScore || "0"),
+            isCoinbase: !!u.isCoinbase
+          }
+        };
+      });
+      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));
+          });
+          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 genesisGroups = /* @__PURE__ */ new Map();
+          allOutputs.forEach((o, idx) => {
+            if (o.covenant && !o.covenant.covenantId) {
+              const authIn = o.covenant.authorizingInput;
+              if (!genesisGroups.has(authIn)) genesisGroups.set(authIn, []);
+              genesisGroups.get(authIn).push(idx);
+            }
+          });
+          if (genesisGroups.size > 0) {
+            const groupsArray = Array.from(genesisGroups.entries()).map(([authIn, outIndices]) => {
+              return new sdk.GenesisCovenantGroup(authIn, outIndices);
+            });
+            unsignedTx.populateGenesisCovenants(groupsArray);
+          }
+          unsignedTx.version = 1;
+          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 });
+          unsignedTx = sdk.createTransaction(
+            utxos,
+            wasmOutputs,
+            priorityFee
+          );
+        }
+        const inputs = unsignedTx.inputs;
+        for (let i = 0; i < inputs.length; i++) {
+          if (plan.computeBudget !== void 0) {
+            const val = Number(plan.computeBudget);
+            inputs[i].computeBudget = val;
+          }
+          if (unsignedTx.version === 1) {
+            inputs[i].sigOpCount = 0;
+          }
+        }
+        unsignedTx.inputs = inputs;
+        console.log("DEBUG createFreshTx RETURNING:", unsignedTx?.constructor?.name);
+        return unsignedTx;
+      };
+      const inputOverrides = {};
+      if (!authorizers || Object.keys(authorizers).length === 0) {
+        throw new Error("MISSING_INPUT_AUTHORIZER: No authorizers were provided for the transaction.");
+      }
+      const dummyTx = createFreshTx();
+      const numInputsWasm = dummyTx.inputs.length;
+      for (let i = 0; i < numInputsWasm; i++) {
+        const authorizer = authorizers[i];
+        if (!authorizer) {
+          throw new Error(`MISSING_INPUT_AUTHORIZER: No authorizer was provided for input index ${i}.`);
+        }
+        const txForAuth = createFreshTx();
+        const authorization = await authorizer.authorize({
+          inputIndex: i,
+          plan,
+          wasmTransaction: txForAuth,
+          wasm: sdk
+        });
+        let sigScript;
+        if (authorization.kind === "signature-script") {
+          sigScript = authorization.signatureScript;
+        } else if (authorization.kind === "wasm-signer") {
+          sigScript = await authorization.signer.signInput({
+            inputIndex: i,
+            plan,
+            wasmTransaction: txForAuth,
+            wasm: sdk
+          });
+        }
+        if (!sigScript || sigScript.trim() === "") {
+          throw new Error(`INVALID_SIGNATURE_SCRIPT: Authorizer for input ${i} failed to return a signatureScript.`);
+        }
+        if (!/^[0-9a-fA-F]+$/.test(sigScript)) {
+          throw new Error(`INVALID_SIGNATURE_SCRIPT: Authorizer for input ${i} returned a non-hex signatureScript.`);
+        }
+        inputOverrides[i] = { signatureScript: sigScript };
+      }
+      const finalTx = createFreshTx();
+      const signedTx = finalTx;
+      const wasmTxStr = typeof signedTx.serializeToJSON === "function" ? signedTx.serializeToJSON() : signedTx.toString();
+      const rpcTx = parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan);
+      const rawTx = JSON.stringify(rpcTx);
+      return {
+        signatureKind: "kaspa-private-key",
+        signerAddress: input.accountName || plan.from.address || "authorized",
+        signedTransaction: {
+          format: "hex",
+          payload: rawTx
+        },
+        txId: signedTx.id,
+        signature: {
+          // We use the txid as the signature identifier in the artifact
+          value: signedTx.id || calculateContentHash(plan)
+        }
+      };
+    } catch (error) {
+      console.error("DEBUG SIGNING ERROR:", error);
+      throw new Error(
+        `Kaspa WASM signing failed: ${error instanceof Error ? error.stack || error.message : JSON.stringify(error, Object.getOwnPropertyNames(error))}`
+      );
+    }
+  }
+};
+function assertSigningNetworkAllowed(input) {
+  const isMainnet = input.network === "mainnet";
+  if (isMainnet && !input.allowMainnet) {
+    throw new Error(
+      "Mainnet signing is disabled by default. Use --allow-mainnet-signing only if you understand the risks."
+    );
+  }
+}
+
+// src/dev-accounts.ts
+var DEV_ACCOUNTS_PASSWORD = "hardkas-local-dev";
+var SIMNET_DETERMINISTIC_SEED = "hardkas-deterministic-simnet-seed-v1";
+async function ensureDevAccounts(workspaceDir) {
+  const devAccountsDir = path.join(workspaceDir, ".hardkas", "dev-accounts");
+  if (!fs.existsSync(devAccountsDir)) {
+    await fs.promises.mkdir(devAccountsDir, { recursive: true });
+  }
+  await getOrCreateDevAccount(workspaceDir, 0, "alice");
+  await getOrCreateDevAccount(workspaceDir, 1, "bob");
+}
+async function getOrCreateDevAccount(workspaceDir, index, alias) {
+  const devAccountsDir = path.join(workspaceDir, ".hardkas", "dev-accounts");
+  const filePath = path.join(devAccountsDir, `${alias}.json`);
+  if (fs.existsSync(filePath)) {
+    const keystore2 = await KeystoreManager.loadEncryptedKeystore(filePath);
+    const unlock = await KeystoreManager.decryptEncryptedKeystore(
+      keystore2,
+      DEV_ACCOUNTS_PASSWORD
+    );
+    if (!unlock.success || !unlock.payload) {
+      throw new Error(
+        `Failed to decrypt dev account ${alias}. Expected password: ${DEV_ACCOUNTS_PASSWORD}`
+      );
+    }
+    return {
+      address: unlock.payload.address,
+      privateKey: unlock.payload.privateKey,
+      publicKey: unlock.payload.publicKey
+    };
+  }
+  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 accountData = {
+    address,
+    privateKey,
+    publicKey
+  };
+  if (!fs.existsSync(devAccountsDir)) {
+    await fs.promises.mkdir(devAccountsDir, { recursive: true });
+  }
+  const payload = {
+    address: accountData.address,
+    privateKey: accountData.privateKey,
+    network: "simnet"
+  };
+  if (accountData.publicKey) {
+    payload.publicKey = accountData.publicKey;
+  }
+  const keystore = await KeystoreManager.createEncryptedKeystore(
+    payload,
+    DEV_ACCOUNTS_PASSWORD,
+    {
+      label: alias,
+      network: "simnet"
+    }
+  );
+  await KeystoreManager.saveEncryptedKeystore(filePath, keystore);
+  return accountData;
+}
+function listDevAccountsSync(workspaceDir) {
+  const devAccountsDir = path.join(workspaceDir, ".hardkas", "dev-accounts");
+  if (!fs.existsSync(devAccountsDir)) {
+    return [];
+  }
+  const accounts = [];
+  const files = fs.readdirSync(devAccountsDir);
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      const name = path.basename(file, ".json");
+      try {
+        const data = fs.readFileSync(path.join(devAccountsDir, file), "utf-8");
+        const keystore = JSON.parse(data);
+        if (keystore.type === "hardkas.encryptedKeystore.v2") {
+          accounts.push({
+            name,
+            address: keystore.metadata?.address || ""
+          });
+        }
+      } catch (e) {
+      }
+    }
+  }
+  accounts.sort((a, b) => deterministicCompare(a.name, b.name));
+  return accounts;
+}
+async function createDevSigner(workspaceDir, accountNameOrAddress) {
+  const account = resolveHardkasAccount({
+    nameOrAddress: accountNameOrAddress,
+    config: { cwd: workspaceDir }
+  });
+  if (account.kind !== "kaspa-private-key") {
+    throw new Error(`Account '${accountNameOrAddress}' is not a private key account, cannot create local dev signer.`);
+  }
+  return new KaspaWasmPrivateKeySigner({
+    account,
+    allowMainnet: false
+  });
+}
+
+export {
+  DEV_ACCOUNTS_PASSWORD,
+  ensureDevAccounts,
+  getOrCreateDevAccount,
+  listDevAccountsSync,
+  createDevSigner,
+  KaspaWasmPrivateKeySigner,
+  assertSigningNetworkAllowed
+};

package/dist/chunk-WRRHW2WO.js

@@ -0,0 +1,103 @@
+// src/internal/wasm-rpc-serialization.ts
+function parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan) {
+  let parsed;
+  try {
+    parsed = JSON.parse(wasmTxStr);
+  } catch (e) {
+    throw new Error("Failed to parse WASM transaction JSON: " + String(e));
+  }
+  while (typeof parsed === "string") {
+    parsed = JSON.parse(parsed);
+  }
+  const txInner = parsed.outputs ? parsed : parsed.tx ? parsed.tx.inner : parsed.inner;
+  if (!txInner) throw new Error("Could not find inner tx data");
+  const version = txInner.version || 0;
+  const numInputs = txInner.inputs ? txInner.inputs.length : 0;
+  if (inputOverrides) {
+    for (const idxStr of Object.keys(inputOverrides)) {
+      const idx = parseInt(idxStr, 10);
+      if (isNaN(idx) || idx < 0 || idx >= numInputs) {
+        throw new Error(`INVALID_UNLOCKER_INPUT_INDEX: Unlocker provided for non-existent input index ${idxStr}`);
+      }
+    }
+  }
+  function toHex(arr) {
+    if (!arr) return "";
+    return Buffer.from(arr).toString("hex");
+  }
+  return {
+    version,
+    inputs: (txInner.inputs || []).map((i, idx) => {
+      const isFlattened = !!txInner.outputs || !!i.previousOutpoint || !!i.transactionId;
+      const prevOut = isFlattened ? i.previousOutpoint || i : i.inner.previousOutpoint.inner;
+      const originalSigScript = isFlattened ? i.signatureScript || "" : toHex(i.inner.signatureScript);
+      const originalSigOpCount = isFlattened ? i.sigOpCount : i.inner.sigOpCount;
+      const computeBudget = isFlattened ? i.computeBudget : i.inner.computeBudget;
+      const override = inputOverrides ? inputOverrides[idx] : void 0;
+      const finalSigScript = override ? override.signatureScript : originalSigScript;
+      if (!finalSigScript || finalSigScript.length === 0 || !/^[0-9a-fA-F]+$/.test(finalSigScript)) {
+        throw new Error(`INVALID_SIGNATURE_SCRIPT: Missing or invalid hex signature script at input ${idx}`);
+      }
+      const sigOpCount = version === 1 ? 0 : originalSigOpCount !== void 0 ? originalSigOpCount : 1;
+      if (version === 1 && sigOpCount !== 0) {
+        throw new Error("INVALID_V1_SIG_OP_COUNT: V1 transactions must have sigOpCount = 0.");
+      }
+      const overrideBudget = plan?.computeBudget;
+      const finalComputeBudget = overrideBudget !== void 0 ? Number(overrideBudget) : computeBudget !== void 0 && computeBudget !== 0 ? computeBudget : 0;
+      return {
+        previousOutpoint: {
+          transactionId: prevOut.transactionId || prevOut.transactionId,
+          index: prevOut.index || prevOut.index
+        },
+        signatureScript: finalSigScript,
+        sequence: isFlattened ? i.sequence || 0 : i.inner.sequence || 0,
+        sigOpCount,
+        computeBudget: finalComputeBudget
+      };
+    }),
+    outputs: (txInner.outputs || []).map((o, idx) => {
+      const isFlattened = !!txInner.outputs || !!o.scriptPublicKey || !!o.value || !!o.amount;
+      const innerOut = isFlattened ? o : o.inner;
+      const scriptObj = innerOut.scriptPublicKey;
+      const ret = {
+        amount: (innerOut.value || innerOut.amount || 0).toString(),
+        scriptPublicKey: {
+          version: typeof scriptObj === "string" ? parseInt(scriptObj.substring(0, 4), 16) || 0 : scriptObj.version || 0,
+          scriptPublicKey: typeof scriptObj === "string" ? scriptObj.substring(4) : scriptObj.scriptPublicKey || scriptObj.script || ""
+        }
+      };
+      if (innerOut.covenant) {
+        ret.covenant = {
+          authorizingInput: innerOut.covenant.authorizingInput !== void 0 ? innerOut.covenant.authorizingInput : 0,
+          covenantId: typeof innerOut.covenant.covenantId === "string" ? innerOut.covenant.covenantId : ""
+        };
+      } else if (signedTx && typeof signedTx.outputs === "function") {
+        const outputs = signedTx.outputs();
+        if (outputs && outputs[idx] && outputs[idx].covenant) {
+          const cov = outputs[idx].covenant;
+          ret.covenant = {
+            authorizingInput: cov.authorizingInput !== void 0 ? cov.authorizingInput : 0,
+            covenantId: typeof cov.covenantId === "string" ? cov.covenantId : cov.covenantId.toString()
+          };
+        }
+      } else if (signedTx && signedTx.outputs && signedTx.outputs[idx] && signedTx.outputs[idx].covenant) {
+        const cov = signedTx.outputs[idx].covenant;
+        ret.covenant = {
+          authorizingInput: cov.authorizingInput !== void 0 ? cov.authorizingInput : 0,
+          covenantId: typeof cov.covenantId === "string" ? cov.covenantId : cov.covenantId.toString()
+        };
+      }
+      return ret;
+    }),
+    lockTime: txInner.lockTime || 0,
+    subnetworkId: txInner.subnetworkId || "0000000000000000000000000000000000000000",
+    gas: txInner.gas || 0,
+    mass: txInner.mass || 0,
+    storageMass: txInner.storageMass || 0,
+    payload: txInner.payload && txInner.payload.length > 0 ? typeof txInner.payload === "string" ? txInner.payload : toHex(txInner.payload) : ""
+  };
+}
+
+export {
+  parseWasmTxToRpc
+};