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

package/dist/index.js

@@ -2,12 +2,25 @@ import {
   DEV_ACCOUNTS_PASSWORD,
   KaspaWasmPrivateKeySigner,
   assertSigningNetworkAllowed,
+  assertValueConservation,
+  createBalancedTransaction,
   createDevSigner,
+  createScriptTransaction,
   ensureDevAccounts,
   getOrCreateDevAccount,
-  listDevAccountsSync
-} from "./chunk-YZ6W5EBW.js";
-import "./chunk-R5P3WIWR.js";
+  listDevAccountsSync,
+  planOutputsWithChange,
+  toWasmScriptPublicKey
+} from "./chunk-CELVD4YG.js";
+import {
+  parseWasmTxToRpc
+} from "./chunk-GM2BY4VS.js";
+import {
+  detectCapabilities,
+  getKaspaSigningBackendStatus,
+  loadKaspaWasm,
+  loadKaspaWasmSync
+} from "./chunk-BNF566PS.js";
 import {
   assertAccountCompatible,
   createEmptyRealAccountStore,
@@ -28,12 +41,7 @@ import {
   validateAccountName,
   validateAddressNetwork,
   validateAddressPrefix
-} from "./chunk-YBNHOFVX.js";
-import {
-  detectCapabilities,
-  getKaspaSigningBackendStatus,
-  loadKaspaWasm
-} from "./chunk-6DPO5V3N.js";
+} from "./chunk-7KKJXU73.js";
 import {
   KeystoreManager
 } from "./chunk-YLG2NIAU.js";
@@ -41,8 +49,7 @@ import {
   LazyAccountAuthorizer,
   PrivateKeyAuthorizer,
   StaticSignatureScriptAuthorizer
-} from "./chunk-5266LO4K.js";
-import "./chunk-MCKGQKYU.js";
+} from "./chunk-E73SSWAX.js";
 
 // src/simulated.ts
 var SimulatedSigner = class {
@@ -238,6 +245,526 @@ async function signTxPlanArtifact(input) {
   throw new Error(`Unsupported account kind for signing: ${accountRecord ? accountRecord.kind : "unknown"}`);
 }
 
+// src/silver-spend.ts
+import {
+  encodeSilverEntryArgs,
+  getSilContract,
+  loadManagedKaspaWasmSync,
+  silContractBytecodeHex,
+  silverP2shLock,
+  silverSigFromInputSignature,
+  silverUnlockScript
+} from "@hardkas/core";
+import { calculateUpstreamStorageMass, measureBuiltTransactionMass } from "@hardkas/tx-builder";
+function spendError(code, message) {
+  const err = new Error(`${code}: ${message}`);
+  err.code = code;
+  return err;
+}
+var PLACEHOLDER_SIG = { kind: "bytes", value: new Uint8Array(65) };
+function buildSilverSweep(request) {
+  const k = loadManagedKaspaWasmSync();
+  const { name: contractName, contract } = getSilContract(request.artifact, request.contractName);
+  const bytecode = silContractBytecodeHex(contract);
+  const lock = silverP2shLock(bytecode);
+  const utxoSpk = request.utxo.scriptPublicKey;
+  if (Number(utxoSpk.version) !== lock.version || String(utxoSpk.script).toLowerCase() !== lock.script) {
+    throw spendError(
+      "SILVER_SPEND_LOCK_MISMATCH",
+      `output ${request.utxo.outpoint.transactionId}:${request.utxo.outpoint.index} is not locked to contract '${contractName}'`
+    );
+  }
+  if (!k.Address.validate(request.to)) throw spendError("SILVER_SPEND_INVALID_RECIPIENT", `'${request.to}' is not a Kaspa address`);
+  const sequence = request.sequence ?? 0n;
+  const sigOpCount = request.sigOpCount ?? 1;
+  const amountIn = request.utxo.amountSompi;
+  const { transactionId, index } = request.utxo.outpoint;
+  const makeTx = (amountOut2, signatureScript) => {
+    const tx = new k.Transaction({
+      version: 0,
+      inputs: [
+        {
+          previousOutpoint: { transactionId, index },
+          signatureScript,
+          sequence,
+          sigOpCount,
+          utxo: {
+            outpoint: { transactionId, index },
+            amount: amountIn,
+            scriptPublicKey: new k.ScriptPublicKey(lock.version, lock.script),
+            blockDaaScore: request.utxo.blockDaaScore,
+            isCoinbase: request.utxo.isCoinbase
+          }
+        }
+      ],
+      outputs: [{ value: amountOut2, scriptPublicKey: k.payToAddressScript(new k.Address(request.to)) }],
+      lockTime: 0n,
+      subnetworkId: "0000000000000000000000000000000000000000",
+      gas: 0n,
+      payload: ""
+    });
+    tx.storageMass = calculateUpstreamStorageMass([amountIn], [amountOut2], request.networkId);
+    return tx;
+  };
+  const entryArgs = (resolveSig) => encodeSilverEntryArgs({
+    artifact: request.artifact,
+    contractName,
+    entry: request.entry,
+    args: request.args.map((a) => a.kind === "signature" ? resolveSig(a) : a)
+  });
+  const placeholderUnlock = silverUnlockScript(bytecode, entryArgs(() => PLACEHOLDER_SIG));
+  let fee = 0n;
+  let priced;
+  let converged = false;
+  for (let round = 0; round < 8 && !converged; round++) {
+    const amountOut2 = amountIn - fee;
+    if (amountOut2 <= 0n) throw spendError("SILVER_SPEND_INSUFFICIENT_VALUE", `output of ${amountIn} sompi cannot pay a fee of ${fee}`);
+    priced = measureBuiltTransactionMass(makeTx(amountOut2, placeholderUnlock), request.networkId);
+    if (!priced.standard) {
+      throw spendError("TX_MASS_ABOVE_STANDARD_LIMIT", `mass ${priced.mass} exceeds the maximum standard mass ${priced.maximumStandardMass}`);
+    }
+    const byRate = request.feeRateSompiPerGram !== void 0 ? priced.mass * request.feeRateSompiPerGram : 0n;
+    const required = priced.minimumFeeSompi > byRate ? priced.minimumFeeSompi : byRate;
+    if (required <= fee) converged = true;
+    else fee = required;
+  }
+  if (!priced || !converged) throw spendError("SILVER_SPEND_FEE_UNRESOLVED", "the fee did not converge");
+  const amountOut = amountIn - fee;
+  const unsigned = makeTx(amountOut, "");
+  const unlock = silverUnlockScript(
+    bytecode,
+    entryArgs((a) => ({
+      kind: "bytes",
+      value: silverSigFromInputSignature(String(k.createInputSignature(unsigned, 0, new k.PrivateKey(a.privateKey), k.SighashType.All)))
+    }))
+  );
+  if (unlock.length !== placeholderUnlock.length) {
+    throw spendError("SILVER_SPEND_UNLOCK_SIZE_CHANGED", "the signed unlock is not the size the fee was computed for");
+  }
+  const signed = makeTx(amountOut, unlock);
+  return {
+    transaction: signed,
+    rpcTransaction: parseWasmTxToRpc(signed.serializeToObject()),
+    txId: String(signed.id),
+    contractName,
+    entry: request.entry,
+    outputSompi: amountOut,
+    feeSompi: fee,
+    mass: priced.mass,
+    storageMass: BigInt(signed.storageMass),
+    signatureScriptHex: unlock,
+    assumptions: [...priced.assumptions, `sigOpCount ${sigOpCount}`]
+  };
+}
+var SILVER_SPEND_DRAFT_SCHEMA = "hardkas.silver.spendDraft.v1";
+function draftTx(k, draft, signatureScript, networkId) {
+  const i = draft.input;
+  const tx = new k.Transaction({
+    version: 0,
+    inputs: [{
+      previousOutpoint: i.outpoint,
+      signatureScript,
+      sequence: BigInt(i.sequence),
+      sigOpCount: i.sigOpCount,
+      utxo: {
+        outpoint: i.outpoint,
+        amount: BigInt(i.amountSompi),
+        scriptPublicKey: new k.ScriptPublicKey(i.scriptPublicKey.version, i.scriptPublicKey.script),
+        blockDaaScore: BigInt(i.blockDaaScore),
+        isCoinbase: i.isCoinbase
+      }
+    }],
+    outputs: draft.outputs.map((o) => ({ value: BigInt(o.valueSompi), scriptPublicKey: new k.ScriptPublicKey(o.scriptPublicKey.version, o.scriptPublicKey.script) })),
+    lockTime: 0n,
+    subnetworkId: "0000000000000000000000000000000000000000",
+    gas: 0n,
+    payload: ""
+  });
+  tx.storageMass = calculateUpstreamStorageMass([BigInt(i.amountSompi)], draft.outputs.map((o) => BigInt(o.valueSompi)), networkId);
+  return tx;
+}
+function draftUnlock(artifact, contractName, entry, args, fill) {
+  const { contract } = getSilContract(artifact, contractName);
+  return silverUnlockScript(
+    silContractBytecodeHex(contract),
+    encodeSilverEntryArgs({ artifact, contractName, entry, args: args.map((a) => a.kind === "signer" ? fill(a) : a) })
+  );
+}
+function prepareSilverSpend(request) {
+  const k = loadManagedKaspaWasmSync();
+  const { name: contractName, contract } = getSilContract(request.artifact, request.contractName);
+  const lock = silverP2shLock(silContractBytecodeHex(contract));
+  const u = request.utxo;
+  if (Number(u.scriptPublicKey.version) !== lock.version || String(u.scriptPublicKey.script).toLowerCase() !== lock.script) {
+    throw spendError("SILVER_SPEND_LOCK_MISMATCH", `output ${u.outpoint.transactionId}:${u.outpoint.index} is not locked to contract '${contractName}'`);
+  }
+  const signers = request.args.filter((a) => a.kind === "signer").map((a) => a.signer);
+  const outputs = request.outputs.map((o, i) => {
+    let spk = o.scriptPublicKey;
+    if (!spk && o.address) {
+      if (!k.Address.validate(o.address)) throw spendError("SILVER_SPEND_INVALID_RECIPIENT", `output ${i}: '${o.address}' is not a Kaspa address`);
+      const s = k.payToAddressScript(new k.Address(o.address));
+      spk = { version: Number(s.version), script: String(s.script) };
+    }
+    if (!spk || !/^(?:[0-9a-f]{2})+$/i.test(spk.script)) throw spendError("SILVER_SPEND_INVALID_RECIPIENT", `output ${i} has no script`);
+    if (o.amountSompi <= 0n) throw spendError("SILVER_SPEND_INVALID_OUTPUT", `output ${i} has no value`);
+    return { valueSompi: o.amountSompi.toString(), scriptPublicKey: { version: Number(spk.version), script: String(spk.script).toLowerCase() } };
+  });
+  const totalOut = outputs.reduce((s, o) => s + BigInt(o.valueSompi), 0n);
+  if (totalOut > u.amountSompi) throw spendError("SILVER_SPEND_INSUFFICIENT_VALUE", `outputs ${totalOut} exceed the contract output ${u.amountSompi}`);
+  const base = {
+    networkId: request.networkId,
+    contractName,
+    entry: request.entry,
+    input: {
+      outpoint: { transactionId: u.outpoint.transactionId, index: u.outpoint.index },
+      amountSompi: u.amountSompi.toString(),
+      scriptPublicKey: { version: lock.version, script: lock.script },
+      blockDaaScore: u.blockDaaScore.toString(),
+      isCoinbase: u.isCoinbase,
+      sequence: (request.sequence ?? 0n).toString(),
+      sigOpCount: request.sigOpCount ?? Math.max(1, signers.length)
+    },
+    outputs
+  };
+  const placeholder = draftUnlock(request.artifact, contractName, request.entry, request.args, () => PLACEHOLDER_SIG);
+  const priced = measureBuiltTransactionMass(draftTx(k, base, placeholder, request.networkId), request.networkId);
+  if (!priced.standard) throw spendError("TX_MASS_ABOVE_STANDARD_LIMIT", `mass ${priced.mass} exceeds the maximum standard mass ${priced.maximumStandardMass}`);
+  const fee = u.amountSompi - totalOut;
+  if (fee < priced.minimumFeeSompi) {
+    throw spendError("FEE_BELOW_NETWORK_MINIMUM", `the outputs leave ${fee} sompi of fee; the SDK minimum for this spend is ${priced.minimumFeeSompi}`);
+  }
+  const unsigned = draftTx(k, base, "", request.networkId);
+  return {
+    schema: SILVER_SPEND_DRAFT_SCHEMA,
+    ...base,
+    signers,
+    feeSompi: fee.toString(),
+    mass: priced.mass.toString(),
+    storageMass: String(unsigned.storageMass),
+    unlockHexLength: placeholder.length,
+    unsignedTxId: String(unsigned.id)
+  };
+}
+function signSilverSpend(draft, privateKey) {
+  if (draft?.schema !== SILVER_SPEND_DRAFT_SCHEMA) throw spendError("SILVER_SPEND_DRAFT_INVALID", "not a SilverScript spend draft");
+  const k = loadManagedKaspaWasmSync();
+  const unsigned = draftTx(k, draft, "", draft.networkId);
+  if (String(unsigned.id) !== draft.unsignedTxId) throw spendError("SILVER_SPEND_DRAFT_INVALID", "the draft does not rebuild to the transaction it describes");
+  const inputSignature = String(k.createInputSignature(unsigned, 0, new k.PrivateKey(privateKey), k.SighashType.All));
+  return Buffer.from(silverSigFromInputSignature(inputSignature)).toString("hex");
+}
+function finalizeSilverSpend(draft, artifact, args, signatures) {
+  if (draft?.schema !== SILVER_SPEND_DRAFT_SCHEMA) throw spendError("SILVER_SPEND_DRAFT_INVALID", "not a SilverScript spend draft");
+  const k = loadManagedKaspaWasmSync();
+  const lock = silverP2shLock(silContractBytecodeHex(getSilContract(artifact, draft.contractName).contract));
+  if (lock.script !== draft.input.scriptPublicKey.script) throw spendError("SILVER_SPEND_LOCK_MISMATCH", "the artifact is not the contract the draft spends");
+  const unlock = draftUnlock(artifact, draft.contractName, draft.entry, args, (slot) => {
+    const sig = signatures[slot.signer];
+    if (!sig) throw spendError("SILVER_SPEND_SIGNATURE_MISSING", `no signature from '${slot.signer}'`);
+    return { kind: "bytes", value: Buffer.from(sig, "hex") };
+  });
+  if (unlock.length !== draft.unlockHexLength) {
+    throw spendError("SILVER_SPEND_UNLOCK_SIZE_CHANGED", "the signed unlock is not the size the fee was checked for");
+  }
+  const tx = draftTx(k, draft, unlock, draft.networkId);
+  if (String(tx.id) !== draft.unsignedTxId) throw spendError("SILVER_SPEND_DRAFT_INVALID", "the finalized transaction differs from the draft");
+  return { rpcTransaction: parseWasmTxToRpc(tx.serializeToObject()), txId: String(tx.id), signatureScriptHex: unlock };
+}
+
+// src/silver-covenant.ts
+import {
+  encodeSilverEntryArgs as encodeSilverEntryArgs2,
+  getSilContract as getSilContract2,
+  loadManagedKaspaWasmSync as loadManagedKaspaWasmSync2,
+  silContractBytecodeHex as silContractBytecodeHex2,
+  silverP2shLock as silverP2shLock2,
+  silverUnlockScript as silverUnlockScript2
+} from "@hardkas/core";
+import { calculateUpstreamStorageMass as calculateUpstreamStorageMass2, measureBuiltTransactionMass as measureBuiltTransactionMass2 } from "@hardkas/tx-builder";
+function covenantError(code, message) {
+  const err = new Error(`${code}: ${message}`);
+  err.code = code;
+  return err;
+}
+var ZERO_SUBNET = "0000000000000000000000000000000000000000";
+function checkBudget(budget, where) {
+  if (!Number.isInteger(budget) || budget < 0 || budget > 65535) {
+    throw covenantError("COVENANT_COMPUTE_BUDGET_INVALID", `${where}: compute budget ${budget} is not a u16`);
+  }
+  return budget;
+}
+function requireExplicitFeeForBudgets(budgets, feeSompi) {
+  if (budgets.some((b) => b > 0) && feeSompi === void 0) {
+    throw covenantError(
+      "COVENANT_V1_FEE_UNPRICED",
+      "the SDK mass calculator does not count v1 compute budgets (upstream TODO); pass feeSompi explicitly for inputs with computeBudget > 0"
+    );
+  }
+}
+function settleFee(build, networkId, feeRate, explicitFee) {
+  if (explicitFee !== void 0) {
+    const measured = measureBuiltTransactionMass2(build(explicitFee), networkId);
+    if (!measured.standard) {
+      throw covenantError("TX_MASS_ABOVE_STANDARD_LIMIT", `mass ${measured.mass} exceeds the maximum standard mass ${measured.maximumStandardMass}`);
+    }
+    if (explicitFee < measured.minimumFeeSompi) {
+      throw covenantError("FEE_BELOW_NETWORK_MINIMUM", `fee ${explicitFee} is below the SDK minimum ${measured.minimumFeeSompi}`);
+    }
+    return { fee: explicitFee, measured };
+  }
+  let fee = 0n;
+  for (let round = 0; round < 8; round++) {
+    const measured = measureBuiltTransactionMass2(build(fee), networkId);
+    if (!measured.standard) {
+      throw covenantError("TX_MASS_ABOVE_STANDARD_LIMIT", `mass ${measured.mass} exceeds the maximum standard mass ${measured.maximumStandardMass}`);
+    }
+    const byRate = feeRate !== void 0 ? measured.mass * feeRate : 0n;
+    const required = measured.minimumFeeSompi > byRate ? measured.minimumFeeSompi : byRate;
+    if (required <= fee) return { fee, measured };
+    fee = required;
+  }
+  throw covenantError("COVENANT_FEE_UNRESOLVED", "the fee did not converge");
+}
+function buildCovenantGenesis(request) {
+  const k = loadManagedKaspaWasmSync2();
+  const { contract } = getSilContract2(request.artifact, request.contractName);
+  const lock = silverP2shLock2(silContractBytecodeHex2(contract));
+  if (request.funding.length === 0) throw covenantError("COVENANT_GENESIS_UNFUNDED", "a genesis needs at least one funding input");
+  if (!k.Address.validate(request.changeAddress)) throw covenantError("COVENANT_INVALID_ADDRESS", `'${request.changeAddress}' is not a Kaspa address`);
+  const inputs = request.funding.map((f, i) => {
+    const key = new k.PrivateKey(f.privateKey);
+    const expected = k.payToAddressScript(key.toKeypair().toAddress(request.networkId));
+    if (Number(f.scriptPublicKey.version) !== Number(expected.version) || String(f.scriptPublicKey.script).toLowerCase() !== String(expected.script)) {
+      throw covenantError("COVENANT_FUNDING_KEY_MISMATCH", `funding input ${i} is not a P2PK output of its key`);
+    }
+    return { ...f, computeBudget: checkBudget(f.computeBudget, `funding input ${i}`), key };
+  });
+  const totalIn = inputs.reduce((s, f) => s + f.amountSompi, 0n);
+  const make = (fee2, signatureScripts) => {
+    const change = totalIn - request.valueSompi - fee2;
+    if (change < 0n) throw covenantError("COVENANT_GENESIS_INSUFFICIENT_FUNDS", `inputs ${totalIn} cannot cover ${request.valueSompi} + fee ${fee2}`);
+    const outputs = [{ value: request.valueSompi, scriptPublicKey: new k.ScriptPublicKey(lock.version, lock.script) }];
+    if (change > 0n) outputs.push({ value: change, scriptPublicKey: k.payToAddressScript(new k.Address(request.changeAddress)) });
+    const tx = new k.Transaction({
+      version: 1,
+      inputs: inputs.map((f, i) => ({
+        previousOutpoint: f.outpoint,
+        signatureScript: signatureScripts?.[i] ?? "",
+        sequence: 0n,
+        sigOpCount: 0,
+        computeBudget: f.computeBudget,
+        utxo: {
+          outpoint: f.outpoint,
+          amount: f.amountSompi,
+          scriptPublicKey: new k.ScriptPublicKey(Number(f.scriptPublicKey.version), String(f.scriptPublicKey.script)),
+          blockDaaScore: f.blockDaaScore,
+          isCoinbase: f.isCoinbase
+        }
+      })),
+      outputs,
+      lockTime: 0n,
+      subnetworkId: ZERO_SUBNET,
+      gas: 0n,
+      payload: ""
+    });
+    tx.populateGenesisCovenants([{ authorizingInput: 0, outputs: [0] }]);
+    tx.storageMass = calculateUpstreamStorageMass2(
+      inputs.map((f) => f.amountSompi),
+      change > 0n ? [request.valueSompi, change] : [request.valueSompi],
+      request.networkId
+    );
+    return tx;
+  };
+  requireExplicitFeeForBudgets(inputs.map((f) => f.computeBudget), request.feeSompi);
+  const { fee, measured } = settleFee((f) => make(f), request.networkId, request.feeRateSompiPerGram, request.feeSompi);
+  const unsigned = make(fee);
+  const signatures = inputs.map((f, i) => String(k.createInputSignature(unsigned, i, f.key, k.SighashType.All)));
+  const signed = make(fee, signatures);
+  const binding = signed.outputs[0].covenant;
+  if (!binding) throw covenantError("COVENANT_GENESIS_UNBOUND", "the SDK did not bind the covenant output");
+  return {
+    transaction: signed,
+    rpcTransaction: parseWasmTxToRpc(signed.serializeToObject()),
+    txId: String(signed.id),
+    covenantId: String(binding.covenantId),
+    lockingScript: lock,
+    feeSompi: fee,
+    mass: measured.mass,
+    storageMass: BigInt(signed.storageMass),
+    changeSompi: totalIn - request.valueSompi - fee,
+    computeBudgets: inputs.map((f) => f.computeBudget),
+    assumptions: [
+      ...measured.assumptions,
+      "compute budgets supplied by the caller; validated only by the node",
+      ...request.feeSompi !== void 0 ? ["fee supplied by the caller: the SDK does not price v1 compute budgets"] : []
+    ]
+  };
+}
+function buildCovenantTransition(request) {
+  const k = loadManagedKaspaWasmSync2();
+  const { name, contract } = getSilContract2(request.current, request.contractName);
+  const next = getSilContract2(request.successor, name).contract;
+  if (contract.delegate_entry_abi !== void 0) {
+    throw covenantError("COVENANT_BINDING_NOT_IMPLEMENTED", `contract '${name}' is a cov-bound leader contract; only auth-bound singletons are supported`);
+  }
+  const entry = contract.cov_decl_to_abi?.[request.policy];
+  if (!entry) {
+    throw covenantError(
+      "COVENANT_POLICY_NOT_FOUND",
+      `contract '${name}' declares no covenant policy '${request.policy}' (has: ${Object.keys(contract.cov_decl_to_abi ?? {}).join(", ") || "none"})`
+    );
+  }
+  if (!Buffer.from(contract.compiled.template_hash).equals(Buffer.from(next.compiled.template_hash))) {
+    throw covenantError("SILVER_SUCCESSOR_TEMPLATE_CHANGED", "the successor artifact is not the same template");
+  }
+  const bytecode = silContractBytecodeHex2(contract);
+  const lock = silverP2shLock2(bytecode);
+  const successorLock = silverP2shLock2(silContractBytecodeHex2(next));
+  const u = request.utxo;
+  if (Number(u.scriptPublicKey.version) !== lock.version || String(u.scriptPublicKey.script).toLowerCase() !== lock.script) {
+    throw covenantError("SILVER_SPEND_LOCK_MISMATCH", `output ${u.outpoint.transactionId}:${u.outpoint.index} is not locked to the current state of '${name}'`);
+  }
+  if (!/^[0-9a-f]{64}$/i.test(u.covenantId ?? "")) throw covenantError("COVENANT_ID_MISSING", "the covenant UTXO carries no covenant id");
+  const budget = checkBudget(request.computeBudget, "covenant input");
+  const unlock = silverUnlockScript2(bytecode, encodeSilverEntryArgs2({ artifact: request.current, contractName: name, entry, args: request.args }));
+  const make = (fee2) => {
+    const value = u.amountSompi - fee2;
+    if (value <= 0n) throw covenantError("COVENANT_INSUFFICIENT_VALUE", `covenant output of ${u.amountSompi} cannot pay a fee of ${fee2}`);
+    const tx2 = new k.Transaction({
+      version: 1,
+      inputs: [{
+        previousOutpoint: u.outpoint,
+        signatureScript: unlock,
+        sequence: 0n,
+        sigOpCount: 0,
+        computeBudget: budget,
+        utxo: {
+          outpoint: u.outpoint,
+          amount: u.amountSompi,
+          scriptPublicKey: new k.ScriptPublicKey(lock.version, lock.script),
+          blockDaaScore: u.blockDaaScore,
+          isCoinbase: u.isCoinbase,
+          covenantId: u.covenantId
+        }
+      }],
+      outputs: [{
+        value,
+        scriptPublicKey: new k.ScriptPublicKey(successorLock.version, successorLock.script),
+        covenant: { authorizingInput: 0, covenantId: u.covenantId }
+      }],
+      lockTime: 0n,
+      subnetworkId: ZERO_SUBNET,
+      gas: 0n,
+      payload: ""
+    });
+    tx2.storageMass = calculateUpstreamStorageMass2([u.amountSompi], [value], request.networkId);
+    return tx2;
+  };
+  requireExplicitFeeForBudgets([budget], request.feeSompi);
+  const { fee, measured } = settleFee(make, request.networkId, request.feeRateSompiPerGram, request.feeSompi);
+  const tx = make(fee);
+  return {
+    transaction: tx,
+    rpcTransaction: parseWasmTxToRpc(tx.serializeToObject()),
+    txId: String(tx.id),
+    covenantId: u.covenantId,
+    lockingScript: successorLock,
+    feeSompi: fee,
+    mass: measured.mass,
+    storageMass: BigInt(tx.storageMass),
+    successorSompi: u.amountSompi - fee,
+    computeBudgets: [budget],
+    assumptions: [
+      ...measured.assumptions,
+      "compute budget supplied by the caller; validated only by the node",
+      ...request.feeSompi !== void 0 ? ["fee supplied by the caller: the SDK does not price v1 compute budgets"] : []
+    ]
+  };
+}
+
+// src/silver-funding.ts
+import { loadManagedKaspaWasmSync as loadManagedKaspaWasmSync3 } from "@hardkas/core";
+import { calculateUpstreamStorageMass as calculateUpstreamStorageMass3, measureBuiltTransactionMass as measureBuiltTransactionMass3 } from "@hardkas/tx-builder";
+function fundingError(code, message) {
+  const err = new Error(`${code}: ${message}`);
+  err.code = code;
+  return err;
+}
+function buildScriptFunding(request) {
+  const k = loadManagedKaspaWasmSync3();
+  const key = new k.PrivateKey(request.privateKey);
+  const address = key.toKeypair().toAddress(request.networkId);
+  const p2pk = k.payToAddressScript(address);
+  const own = { version: Number(p2pk.version), script: String(p2pk.script) };
+  const lock = request.lockingScript;
+  const make = (inputs, fee, signatureScripts) => {
+    const total = inputs.reduce((s, u) => s + u.amountSompi, 0n);
+    const change = total - request.valueSompi - fee;
+    const outputs = [{ value: request.valueSompi, scriptPublicKey: new k.ScriptPublicKey(lock.version, lock.script) }];
+    if (change > 0n) outputs.push({ value: change, scriptPublicKey: new k.ScriptPublicKey(own.version, own.script) });
+    const tx = new k.Transaction({
+      version: 0,
+      inputs: inputs.map((u, i) => ({
+        previousOutpoint: u.outpoint,
+        signatureScript: signatureScripts?.[i] ?? "",
+        sequence: 0n,
+        sigOpCount: 1,
+        utxo: {
+          outpoint: u.outpoint,
+          amount: u.amountSompi,
+          scriptPublicKey: new k.ScriptPublicKey(own.version, own.script),
+          blockDaaScore: u.blockDaaScore,
+          isCoinbase: u.isCoinbase
+        }
+      })),
+      outputs,
+      lockTime: 0n,
+      subnetworkId: "0000000000000000000000000000000000000000",
+      gas: 0n,
+      payload: ""
+    });
+    tx.storageMass = calculateUpstreamStorageMass3(
+      inputs.map((u) => u.amountSompi),
+      change > 0n ? [request.valueSompi, change] : [request.valueSompi],
+      request.networkId
+    );
+    return { tx, change };
+  };
+  for (const u of request.utxos) {
+    if (Number(u.scriptPublicKey.version) !== own.version || String(u.scriptPublicKey.script).toLowerCase() !== own.script) {
+      throw fundingError("FUNDING_KEY_MISMATCH", `${u.outpoint.transactionId}:${u.outpoint.index} is not a P2PK output of the funding key`);
+    }
+  }
+  const selected = [];
+  for (const u of request.utxos) {
+    selected.push(u);
+    const total = selected.reduce((s, x) => s + x.amountSompi, 0n);
+    if (total <= request.valueSompi) continue;
+    let fee = 0n;
+    for (let round = 0; round < 8; round++) {
+      if (total < request.valueSompi + fee) break;
+      const measured = measureBuiltTransactionMass3(make(selected, fee).tx, request.networkId);
+      if (!measured.standard) throw fundingError("TX_MASS_ABOVE_STANDARD_LIMIT", `mass ${measured.mass} exceeds the maximum standard mass`);
+      if (measured.minimumFeeSompi <= fee) {
+        const unsigned = make(selected, fee).tx;
+        const signatures = selected.map((_, i) => String(k.createInputSignature(unsigned, i, key, k.SighashType.All)));
+        const { tx, change } = make(selected, fee, signatures);
+        return {
+          rpcTransaction: parseWasmTxToRpc(tx.serializeToObject()),
+          txId: String(tx.id),
+          outputIndex: 0,
+          feeSompi: fee,
+          changeSompi: change,
+          spent: selected.map((s) => s.outpoint)
+        };
+      }
+      fee = measured.minimumFeeSompi;
+    }
+  }
+  throw fundingError("FUNDING_INSUFFICIENT", `the given outputs cannot cover ${request.valueSompi} sompi plus the fee`);
+}
+
 // src/kaspa-sdk-keygen.ts
 import { getNetworkPrefix } from "@hardkas/core";
 var KaspaSdkKeyGenerator = class {
@@ -246,7 +773,8 @@ var KaspaSdkKeyGenerator = class {
   constructor(options) {
     this.networkId = options?.networkId || "simnet";
     const rawLoader = options?.sdkLoader || (async () => {
-      return await import("kaspa-wasm");
+      const { loadKaspaWasm: loadKaspaWasm2 } = await import("./signer-backend-LHWY7ULI.js");
+      return await loadKaspaWasm2();
     });
     this.sdkLoader = async () => {
       try {
@@ -324,6 +852,7 @@ var KaspaSdkRealTxSigner = class {
     try {
       sdk = await this.sdkLoader();
     } catch (e) {
+      if (typeof e?.code === "string" && e.code.startsWith("WASM_TOOLCHAIN_")) throw e;
       throw new Error(
         "Kaspa SDK real transaction signer dependency is not installed. Install/configure the supported Kaspa WASM SDK adapter."
       );
@@ -344,12 +873,6 @@ var KaspaSdkRealTxSigner = class {
             `UTXO ${u.outpoint.transactionId}:${u.outpoint.index} is missing scriptPublicKey required for signing.`
           );
         }
-        let spkHex = String(u.scriptPublicKey);
-        let spkVersion = 0;
-        if (spkHex.length >= 68) {
-          spkVersion = parseInt(spkHex.slice(0, 4), 16) || 0;
-          spkHex = spkHex.slice(4);
-        }
         return {
           address: account.address,
           outpoint: {
@@ -358,25 +881,19 @@ var KaspaSdkRealTxSigner = class {
           },
           utxoEntry: {
             amount: BigInt(u.amountSompi),
-            scriptPublicKey: new sdk.ScriptPublicKey(spkVersion, spkHex),
+            scriptPublicKey: toWasmScriptPublicKey(sdk, u.scriptPublicKey),
             blockDaaScore: BigInt(u.blockDaaScore ?? 0),
             isCoinbase: u.isCoinbase ?? false
           }
         };
       });
-      const outputs = plan.outputs.map(
-        (o) => new sdk.PaymentOutput(new sdk.Address(o.address), BigInt(o.amountSompi))
-      );
-      const changeAddress = plan.change ? plan.change.address : account.address;
-      const priorityFee = BigInt(plan.estimatedFeeSompi);
-      const unsignedTx = sdk.createTransaction(
+      const unsignedTx = createBalancedTransaction(sdk, {
         utxos,
-        outputs,
-        changeAddress,
-        priorityFee
-      );
+        outputs: planOutputsWithChange(plan),
+        feeSompi: BigInt(plan.estimatedFeeSompi)
+      });
       const signedTx = sdk.signTransaction(unsignedTx, [privateKey], true);
-      const innerTx = signedTx.tx || signedTx;
+      const innerTx = signedTx;
       const txId = innerTx?.id;
       const payload = JSON.stringify(
         innerTx.toJSON(),
@@ -483,9 +1000,7 @@ async function appendToKeystoreJson(workspaceRoot, alias, accountData) {
 
 // src/address-manager.ts
 import { createHash } from "crypto";
-import { createRequire } from "module";
 import { getNetworkPrefix as getNetworkPrefix2 } from "@hardkas/core";
-var require2 = createRequire(import.meta.url);
 function resolveChain(chain) {
   if (chain === "receive" || chain === 0) return 0;
   if (chain === "change" || chain === 1) return 1;
@@ -517,12 +1032,16 @@ var AddressManager = {
     const hash = createHash("sha256").update(payload).digest("hex");
     let address;
     try {
-      const kaspa = require2("kaspa-wasm");
+      const kaspa = loadKaspaWasmSync();
       const priv = new kaspa.PrivateKey(hash);
       address = priv.toKeypair().toAddress(getNetworkPrefix2(network)).toString();
     } catch (e) {
-      const prefix = network.includes("sim") ? "kaspasim" : "kaspatest";
-      address = `${prefix}:q${hash.slice(0, 42)}`;
+      if (typeof e?.code === "string" && e.code.startsWith("WASM_TOOLCHAIN_")) throw e;
+      const err = new Error(
+        `ADDRESS_DERIVATION_UNAVAILABLE: the Kaspa WASM SDK could not derive an address: ${e instanceof Error ? e.message : String(e)}`
+      );
+      err.code = "ADDRESS_DERIVATION_UNAVAILABLE";
+      throw err;
     }
     return {
       address,
@@ -712,6 +1231,7 @@ export {
   KeystoreManager,
   LazyAccountAuthorizer,
   PrivateKeyAuthorizer,
+  SILVER_SPEND_DRAFT_SCHEMA,
   SimulatedSigner,
   StaticSignatureScriptAuthorizer,
   UnsupportedKaspaKeyGenerator,
@@ -723,12 +1243,20 @@ export {
   appendToKeystoreJson,
   assertAccountCompatible,
   assertSigningNetworkAllowed,
+  assertValueConservation,
+  buildCovenantGenesis,
+  buildCovenantTransition,
+  buildScriptFunding,
+  buildSilverSweep,
+  createBalancedTransaction,
   createDevSigner,
   createEmptyRealAccountStore,
   createLocalKaspaWallet,
+  createScriptTransaction,
   describeAccount,
   detectCapabilities,
   ensureDevAccounts,
+  finalizeSilverSpend,
   getDefaultRealAccountsPath,
   getKaspaSigningBackendStatus,
   getOrCreateDevAccount,
@@ -739,16 +1267,22 @@ export {
   listHardkasAccounts,
   listRealDevAccounts,
   loadKaspaWasm,
+  loadKaspaWasmSync,
   loadOrCreateRealAccountStore,
   loadRealAccountStore,
   loadRealAccountStoreSync,
+  parseWasmTxToRpc,
+  planOutputsWithChange,
   prepareEvmAccountExport,
+  prepareSilverSpend,
   removeRealDevAccount,
   resolveHardkasAccount,
   resolveHardkasAccountAddress,
   resolveRealAccountOrAddress,
   saveRealAccountStore,
+  signSilverSpend,
   signTxPlanArtifact,
+  toWasmScriptPublicKey,
   validateAccountName,
   validateAddressNetwork,
   validateAddressPrefix,