@hardkas/simulator 0.8.20-alpha → 0.9.1-alpha

package/dist/index.d.ts

@@ -374,4 +374,164 @@ declare function profileAndCompare(opts: {
     comparison?: MassComparison;
 };
 
-export { ApproxGhostdagEngine, type BlockHash, type BlueWorkType, type CandidateColor, type CompactGhostdagData, DEFAULT_K, type DagMetrics, GENESIS_HASH, type GhostdagData, GhostdagStore, type MassBreakdown, type MassComparison, type MassSnapshot, type MassSnapshotStore, type ScenarioConfig, type ScenarioResult, type SimBlock, type SimBlockHeader, type SimulationResult, type SortableBlock, type TxLifecyclePhase, TxSimulator, type TxTraceEvent, blockBlueScore, blockBlueWork, blockHash, blockParents, compactFromFull, compareMassProfiles, compareSortableBlocks, computeDagMetrics, createTraceId, findSelectedParent, formatMassComparison, formatMassProfile, formatScenarioReport, genesisGhostdagData, headerWork, isDagAncestorOf, loadMassSnapshot, orderedMergesetWithoutSelectedParent, pastSet, profileAndCompare, profileMass, runAllScenarios, runDiamondDag, runForkResolution, runLinearChain, runWideDag, saveMassSnapshot, sortBlocks, unorderedMergesetWithoutSelectedParent };
+declare const SILVER_SIMULATOR_FEE_SOMPI = 2000n;
+declare const SILVER_SIMULATOR_CREATED_AT = "1970-01-01T00:00:00.000Z";
+declare const SILVER_SIMULATOR_VERSION = "1.0.0-alpha";
+type SilverSimulationStatus = "SIMULATED_ACCEPTED";
+type SilverSimulationErrorCode = "SILVERSCRIPT_REDEEM_HASH_MISMATCH" | "SILVERSCRIPT_LOCKING_SCRIPT_MISMATCH" | "SILVERSCRIPT_SIGNATURE_SCRIPT_NOT_PUSH_ONLY" | "SILVERSCRIPT_ARGS_HASH_MISMATCH" | "SILVERSCRIPT_UTXO_ALREADY_SPENT" | "SILVERSCRIPT_NETWORK_UNSUPPORTED" | "SILVERSCRIPT_AMOUNT_TOO_SMALL" | "SILVERSCRIPT_DEPLOY_RECEIPT_NOT_FOUND" | "SILVERSCRIPT_SCHEMA_INVALID" | "SILVERSCRIPT_INVALID_HEX" | "SILVERSCRIPT_EXPECTED_OUTPUTS_REQUIRED" | "SILVERSCRIPT_SIGNATURE_SCRIPT_MISMATCH";
+declare class SilverSimulationError extends Error {
+    readonly code: SilverSimulationErrorCode;
+    constructor(code: SilverSimulationErrorCode, message: string);
+}
+interface SilverDeployPlanArtifactLike {
+    schema: "hardkas.silver.deployPlan";
+    hardkasVersion?: string;
+    version?: string;
+    hashVersion?: number | string;
+    networkId: string;
+    mode?: string;
+    createdAt?: string;
+    contentHash?: string;
+    compileArtifactHash: string;
+    compiledScriptHash: string;
+    redeemScriptHex: string;
+    redeemScriptHash: string;
+    lockingScriptHex: string;
+    scriptPublicKeyVersion: number;
+    amountSompi: string;
+    deployerAddress: string;
+}
+interface SilverArgArtifactLike {
+    type: "hex";
+    value: string;
+}
+interface SilverSpendPlanArtifactLike {
+    schema: "hardkas.silver.spendPlan";
+    hardkasVersion?: string;
+    version?: string;
+    hashVersion?: number | string;
+    networkId: string;
+    mode?: string;
+    createdAt?: string;
+    contentHash?: string;
+    deployArtifactHash: string;
+    compileArtifactHash: string;
+    redeemScriptHash: string;
+    lockingScriptHex: string;
+    contractUtxoRef: {
+        transactionId: string;
+        index: number;
+    };
+    args: SilverArgArtifactLike[];
+    argsHash: string;
+    signatureScriptHex: string;
+    expectedOutputs: SilverExpectedOutput[];
+}
+interface SilverExpectedOutput {
+    address: string;
+    amountSompi: string;
+    scriptHash?: string;
+}
+interface SilverSyntheticOutpoint {
+    transactionId: string;
+    index: number;
+}
+interface SilverDeploySimulationReceipt {
+    schema: "hardkas.silver.deploySimulation";
+    hardkasVersion: string;
+    version: "1.0.0-alpha";
+    hashVersion: number;
+    networkId: "simnet";
+    mode: "simulated";
+    createdAt: string;
+    deployPlanHash: string;
+    compileArtifactHash: string;
+    compiledScriptHash: string;
+    redeemScriptHex: string;
+    redeemScriptHash: string;
+    lockingScriptHex: string;
+    scriptPublicKeyVersion: 0;
+    simulatedDeployTxId: string;
+    syntheticOutpoint: SilverSyntheticOutpoint;
+    amountSompi: string;
+    feeSompi: string;
+    status: SilverSimulationStatus;
+    lineage: {
+        artifactId: string;
+        lineageId: string;
+        parentArtifactId: string;
+        rootArtifactId: string;
+        sequence: number;
+    };
+    contentHash: string;
+    artifactId: string;
+}
+interface SilverSpendSimulationReceipt {
+    schema: "hardkas.silver.spendSimulation";
+    hardkasVersion: string;
+    version: "1.0.0-alpha";
+    hashVersion: number;
+    networkId: "simnet";
+    mode: "simulated";
+    createdAt: string;
+    deploySimulationHash: string;
+    spendPlanHash: string;
+    redeemScriptHash: string;
+    lockingScriptHex: string;
+    signatureScriptHex: string;
+    simulatedSpendTxId: string;
+    spentOutpoint: SilverSyntheticOutpoint;
+    expectedOutputs: SilverExpectedOutput[];
+    feeSompi: string;
+    status: SilverSimulationStatus;
+    lineage: {
+        artifactId: string;
+        lineageId: string;
+        parentArtifactId: string;
+        rootArtifactId: string;
+        sequence: number;
+    };
+    contentHash: string;
+    artifactId: string;
+}
+interface SilverSimulatedUtxo {
+    outpoint: SilverSyntheticOutpoint;
+    deploySimulationHash: string;
+    deployPlanHash: string;
+    redeemScriptHex: string;
+    redeemScriptHash: string;
+    lockingScriptHex: string;
+    amountSompi: string;
+    networkId: "simnet";
+    spent: boolean;
+    spentByTxId?: string;
+}
+interface SilverSimulationState {
+    schema: "hardkas.silver.simulationState.v1";
+    version: "1.0.0-alpha";
+    networkId: "simnet";
+    mode: "simulated";
+    deployReceipts: Record<string, SilverDeploySimulationReceipt>;
+    utxos: Record<string, SilverSimulatedUtxo>;
+    spentOutpoints: string[];
+}
+interface SilverDeploySimulationResult {
+    receipt: SilverDeploySimulationReceipt;
+    state: SilverSimulationState;
+}
+interface SilverSpendSimulationResult {
+    receipt: SilverSpendSimulationReceipt;
+    state: SilverSimulationState;
+}
+interface SilverSimulationOptions {
+    hardkasVersion?: string;
+    createdAt?: string;
+}
+declare function createSilverSimulationState(): SilverSimulationState;
+declare function simulateSilverDeploy(deployPlanArtifact: SilverDeployPlanArtifactLike, options?: SilverSimulationOptions): SilverDeploySimulationResult;
+declare function simulateSilverSpend(spendPlanArtifact: SilverSpendPlanArtifactLike, simulatedState: SilverSimulationState, options?: SilverSimulationOptions): SilverSpendSimulationResult;
+declare function calculateSilverArgsHash(args: readonly SilverArgArtifactLike[]): string;
+declare function outpointKey(outpoint: SilverSyntheticOutpoint): string;
+declare function parsePushOnlyScript(signatureScriptHex: string): string[];
+
+export { ApproxGhostdagEngine, type BlockHash, type BlueWorkType, type CandidateColor, type CompactGhostdagData, DEFAULT_K, type DagMetrics, GENESIS_HASH, type GhostdagData, GhostdagStore, type MassBreakdown, type MassComparison, type MassSnapshot, type MassSnapshotStore, SILVER_SIMULATOR_CREATED_AT, SILVER_SIMULATOR_FEE_SOMPI, SILVER_SIMULATOR_VERSION, type ScenarioConfig, type ScenarioResult, type SilverArgArtifactLike, type SilverDeployPlanArtifactLike, type SilverDeploySimulationReceipt, type SilverDeploySimulationResult, type SilverExpectedOutput, type SilverSimulatedUtxo, SilverSimulationError, type SilverSimulationErrorCode, type SilverSimulationOptions, type SilverSimulationState, type SilverSimulationStatus, type SilverSpendPlanArtifactLike, type SilverSpendSimulationReceipt, type SilverSpendSimulationResult, type SimBlock, type SimBlockHeader, type SimulationResult, type SortableBlock, type TxLifecyclePhase, TxSimulator, type TxTraceEvent, blockBlueScore, blockBlueWork, blockHash, blockParents, calculateSilverArgsHash, compactFromFull, compareMassProfiles, compareSortableBlocks, computeDagMetrics, createSilverSimulationState, createTraceId, findSelectedParent, formatMassComparison, formatMassProfile, formatScenarioReport, genesisGhostdagData, headerWork, isDagAncestorOf, loadMassSnapshot, orderedMergesetWithoutSelectedParent, outpointKey, parsePushOnlyScript, pastSet, profileAndCompare, profileMass, runAllScenarios, runDiamondDag, runForkResolution, runLinearChain, runWideDag, saveMassSnapshot, simulateSilverDeploy, simulateSilverSpend, sortBlocks, unorderedMergesetWithoutSelectedParent };

package/dist/index.js

@@ -624,6 +624,7 @@ function formatScenarioReport(results) {
 
 // src/mass-profile.ts
 import { estimateTransactionMass, estimateFeeFromMass } from "@hardkas/tx-builder";
+import { formatSompiToKas } from "@hardkas/core";
 function formatBigInt(n) {
   return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 }
@@ -678,7 +679,7 @@ function compareMassProfiles(current, previous) {
   };
 }
 function formatMassProfile(breakdown) {
-  const kasAmount = Number(breakdown.estimatedFeeSompi) / 1e8;
+  const kasAmount = formatSompiToKas(breakdown.estimatedFeeSompi);
   return [
     "\u2550\u2550\u2550 Mass Profile \u2550\u2550\u2550",
     `  Inputs     : ${breakdown.inputCount} inputs \u2192 ${formatBigInt(breakdown.inputMass)} mass`,
@@ -686,7 +687,7 @@ function formatMassProfile(breakdown) {
     `  Payload    : ${breakdown.payloadBytes} bytes \u2192 ${formatBigInt(breakdown.payloadMass)} mass`,
     `  Total mass : ${formatBigInt(breakdown.totalMass)}`,
     `  Fee rate   : ${formatBigInt(breakdown.feeRate)} sompi/mass`,
-    `  Est. fee   : ${formatBigInt(breakdown.estimatedFeeSompi)} sompi (${kasAmount.toFixed(8)} KAS)`
+    `  Est. fee   : ${formatBigInt(breakdown.estimatedFeeSompi)} sompi (${kasAmount} KAS)`
   ].join("\n");
 }
 function formatMassComparison(comparison) {
@@ -757,20 +758,445 @@ function reviveSnapshot(snapshot) {
   };
   return snapshot;
 }
+
+// src/silver-simulator.ts
+import { createHash as createHash2 } from "crypto";
+import { createKaspaP2shBlake2bLock } from "@hardkas/core";
+var SILVER_SIMULATOR_FEE_SOMPI = 2000n;
+var SILVER_SIMULATOR_CREATED_AT = "1970-01-01T00:00:00.000Z";
+var SILVER_SIMULATOR_VERSION = "1.0.0-alpha";
+var CURRENT_HASH_VERSION = 4;
+var SilverSimulationError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SilverSimulationError";
+    this.code = code;
+  }
+};
+function createSilverSimulationState() {
+  return {
+    schema: "hardkas.silver.simulationState.v1",
+    version: SILVER_SIMULATOR_VERSION,
+    networkId: "simnet",
+    mode: "simulated",
+    deployReceipts: {},
+    utxos: {},
+    spentOutpoints: []
+  };
+}
+function simulateSilverDeploy(deployPlanArtifact, options = {}) {
+  if (deployPlanArtifact.schema !== "hardkas.silver.deployPlan") {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SCHEMA_INVALID",
+      "Expected hardkas.silver.deployPlan."
+    );
+  }
+  assertSimnet(deployPlanArtifact.networkId);
+  assertHex(deployPlanArtifact.redeemScriptHex, "redeemScriptHex");
+  const amountSompi = parseSompi(deployPlanArtifact.amountSompi);
+  if (amountSompi <= SILVER_SIMULATOR_FEE_SOMPI) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_AMOUNT_TOO_SMALL",
+      "Deploy amount must be greater than the simulator fee."
+    );
+  }
+  const lock = createKaspaP2shBlake2bLock(deployPlanArtifact.redeemScriptHex);
+  if (lock.redeemScriptHash !== deployPlanArtifact.redeemScriptHash) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_REDEEM_HASH_MISMATCH",
+      "redeemScriptHash must equal blake2b32(raw redeem script bytes)."
+    );
+  }
+  if (lock.lockingScriptHex !== deployPlanArtifact.lockingScriptHex) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_LOCKING_SCRIPT_MISMATCH",
+      "lockingScriptHex must equal aa20 + redeemScriptHash + 87."
+    );
+  }
+  if (deployPlanArtifact.scriptPublicKeyVersion !== 0) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_LOCKING_SCRIPT_MISMATCH",
+      "scriptPublicKeyVersion must be 0 for this local simulator."
+    );
+  }
+  const deployPlanHash = artifactHash(deployPlanArtifact);
+  const simulatedDeployTxId = deterministicHex({
+    kind: "hardkas.silver.simulatedDeployTx",
+    deployPlanHash,
+    redeemScriptHash: deployPlanArtifact.redeemScriptHash,
+    amountSompi: deployPlanArtifact.amountSompi
+  });
+  const syntheticOutpoint = {
+    transactionId: simulatedDeployTxId,
+    index: 0
+  };
+  const draft = {
+    schema: "hardkas.silver.deploySimulation",
+    hardkasVersion: options.hardkasVersion ?? deployPlanArtifact.hardkasVersion ?? "0.9.1-alpha",
+    version: SILVER_SIMULATOR_VERSION,
+    hashVersion: CURRENT_HASH_VERSION,
+    networkId: "simnet",
+    mode: "simulated",
+    createdAt: options.createdAt ?? SILVER_SIMULATOR_CREATED_AT,
+    deployPlanHash,
+    compileArtifactHash: deployPlanArtifact.compileArtifactHash,
+    compiledScriptHash: deployPlanArtifact.compiledScriptHash,
+    redeemScriptHex: deployPlanArtifact.redeemScriptHex,
+    redeemScriptHash: deployPlanArtifact.redeemScriptHash,
+    lockingScriptHex: deployPlanArtifact.lockingScriptHex,
+    scriptPublicKeyVersion: 0,
+    simulatedDeployTxId,
+    syntheticOutpoint,
+    amountSompi: amountSompi.toString(),
+    feeSompi: SILVER_SIMULATOR_FEE_SOMPI.toString(),
+    status: "SIMULATED_ACCEPTED",
+    lineage: {
+      artifactId: `deploy-sim-${deployPlanHash.slice(0, 16)}`,
+      lineageId: `silver-lineage-${deployPlanHash.slice(0, 16)}`,
+      parentArtifactId: deployPlanHash,
+      rootArtifactId: deployPlanHash,
+      sequence: 1
+    }
+  };
+  const receipt = finalizeArtifact(draft, "silverdeploysim");
+  const state = createSilverSimulationState();
+  state.deployReceipts[receipt.contentHash] = receipt;
+  state.utxos[outpointKey(syntheticOutpoint)] = {
+    outpoint: syntheticOutpoint,
+    deploySimulationHash: receipt.contentHash,
+    deployPlanHash,
+    redeemScriptHex: deployPlanArtifact.redeemScriptHex,
+    redeemScriptHash: deployPlanArtifact.redeemScriptHash,
+    lockingScriptHex: deployPlanArtifact.lockingScriptHex,
+    amountSompi: amountSompi.toString(),
+    networkId: "simnet",
+    spent: false
+  };
+  return {
+    receipt,
+    state: normalizeState(state)
+  };
+}
+function simulateSilverSpend(spendPlanArtifact, simulatedState, options = {}) {
+  if (spendPlanArtifact.schema !== "hardkas.silver.spendPlan") {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SCHEMA_INVALID",
+      "Expected hardkas.silver.spendPlan."
+    );
+  }
+  assertSimnet(spendPlanArtifact.networkId);
+  if (simulatedState.networkId !== "simnet") {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_NETWORK_UNSUPPORTED",
+      "Silver/Toccata simulation state must be simnet."
+    );
+  }
+  if (!Array.isArray(spendPlanArtifact.expectedOutputs) || spendPlanArtifact.expectedOutputs.length === 0) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_EXPECTED_OUTPUTS_REQUIRED",
+      "Spend simulation requires explicit expectedOutputs."
+    );
+  }
+  const key = outpointKey(spendPlanArtifact.contractUtxoRef);
+  const utxo = simulatedState.utxos[key];
+  const deployReceipt = simulatedState.deployReceipts[spendPlanArtifact.deployArtifactHash] ?? Object.values(simulatedState.deployReceipts).find((receipt2) => {
+    return outpointKey(receipt2.syntheticOutpoint) === key;
+  });
+  if (!utxo || !deployReceipt) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_DEPLOY_RECEIPT_NOT_FOUND",
+      `No deploy simulation receipt exists for ${key}.`
+    );
+  }
+  if (deployReceipt.networkId !== spendPlanArtifact.networkId || utxo.networkId !== spendPlanArtifact.networkId) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_NETWORK_UNSUPPORTED",
+      "Spend plan network must match the deployed synthetic UTXO network."
+    );
+  }
+  if (utxo.spent || simulatedState.spentOutpoints.includes(key)) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_UTXO_ALREADY_SPENT",
+      `Synthetic UTXO ${key} has already been spent.`
+    );
+  }
+  const pushes = parsePushOnlyScript(spendPlanArtifact.signatureScriptHex);
+  const redeemScriptHex = pushes.at(-1);
+  if (!redeemScriptHex) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SIGNATURE_SCRIPT_NOT_PUSH_ONLY",
+      "signatureScriptHex must end with a pushed redeem script."
+    );
+  }
+  if (redeemScriptHex !== utxo.redeemScriptHex.toLowerCase()) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SIGNATURE_SCRIPT_MISMATCH",
+      "Redeem script must be the last push and match the deployed script."
+    );
+  }
+  const lock = createKaspaP2shBlake2bLock(redeemScriptHex);
+  if (lock.redeemScriptHash !== spendPlanArtifact.redeemScriptHash) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_REDEEM_HASH_MISMATCH",
+      "Spend redeemScriptHash does not match pushed redeem script."
+    );
+  }
+  if (lock.lockingScriptHex !== spendPlanArtifact.lockingScriptHex) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_LOCKING_SCRIPT_MISMATCH",
+      "Spend lockingScriptHex does not match pushed redeem script."
+    );
+  }
+  if (calculateSilverArgsHash(spendPlanArtifact.args) !== spendPlanArtifact.argsHash) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_ARGS_HASH_MISMATCH",
+      "Spend argsHash does not match args."
+    );
+  }
+  const argValues = spendPlanArtifact.args.map((arg) => {
+    if (arg.type !== "hex" || !isHex(arg.value)) {
+      throw new SilverSimulationError(
+        "SILVERSCRIPT_INVALID_HEX",
+        "Spend args must be hex push values."
+      );
+    }
+    return arg.value.toLowerCase();
+  });
+  const pushedArgs = pushes.slice(0, -1);
+  if (JSON.stringify(pushedArgs) !== JSON.stringify(argValues)) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SIGNATURE_SCRIPT_MISMATCH",
+      "signatureScriptHex args do not match spend plan args."
+    );
+  }
+  const inputAmount = BigInt(utxo.amountSompi);
+  const outputTotal = spendPlanArtifact.expectedOutputs.reduce((sum, output) => {
+    return sum + parseSompi(output.amountSompi);
+  }, 0n);
+  if (outputTotal <= 0n || outputTotal + SILVER_SIMULATOR_FEE_SOMPI > inputAmount) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_AMOUNT_TOO_SMALL",
+      "Synthetic UTXO amount must cover expectedOutputs plus simulator fee."
+    );
+  }
+  const spendPlanHash = artifactHash(spendPlanArtifact);
+  const simulatedSpendTxId = deterministicHex({
+    kind: "hardkas.silver.simulatedSpendTx",
+    spendPlanHash,
+    deploySimulationHash: deployReceipt.contentHash,
+    spentOutpoint: key,
+    expectedOutputs: spendPlanArtifact.expectedOutputs
+  });
+  const draft = {
+    schema: "hardkas.silver.spendSimulation",
+    hardkasVersion: options.hardkasVersion ?? spendPlanArtifact.hardkasVersion ?? "0.9.1-alpha",
+    version: SILVER_SIMULATOR_VERSION,
+    hashVersion: CURRENT_HASH_VERSION,
+    networkId: "simnet",
+    mode: "simulated",
+    createdAt: options.createdAt ?? SILVER_SIMULATOR_CREATED_AT,
+    deploySimulationHash: deployReceipt.contentHash,
+    spendPlanHash,
+    redeemScriptHash: spendPlanArtifact.redeemScriptHash,
+    lockingScriptHex: spendPlanArtifact.lockingScriptHex,
+    signatureScriptHex: spendPlanArtifact.signatureScriptHex,
+    simulatedSpendTxId,
+    spentOutpoint: spendPlanArtifact.contractUtxoRef,
+    expectedOutputs: spendPlanArtifact.expectedOutputs,
+    feeSompi: SILVER_SIMULATOR_FEE_SOMPI.toString(),
+    status: "SIMULATED_ACCEPTED",
+    lineage: {
+      artifactId: `spend-sim-${spendPlanHash.slice(0, 16)}`,
+      lineageId: deployReceipt.lineage.lineageId,
+      parentArtifactId: spendPlanHash,
+      rootArtifactId: deployReceipt.lineage.rootArtifactId,
+      sequence: 2
+    }
+  };
+  const receipt = finalizeArtifact(draft, "silverspendsim");
+  const nextState = cloneState(simulatedState);
+  nextState.utxos[key] = {
+    ...utxo,
+    spent: true,
+    spentByTxId: simulatedSpendTxId
+  };
+  nextState.spentOutpoints = Array.from(
+    /* @__PURE__ */ new Set([...nextState.spentOutpoints, key])
+  ).sort();
+  return {
+    receipt,
+    state: normalizeState(nextState)
+  };
+}
+function calculateSilverArgsHash(args) {
+  return createHash2("sha256").update(JSON.stringify(args)).digest("hex");
+}
+function outpointKey(outpoint) {
+  return `${outpoint.transactionId}:${outpoint.index}`;
+}
+function parsePushOnlyScript(signatureScriptHex) {
+  assertHex(signatureScriptHex, "signatureScriptHex");
+  const pushes = [];
+  let offset = 0;
+  while (offset < signatureScriptHex.length) {
+    const opcode = readByte(signatureScriptHex, offset);
+    offset += 2;
+    let byteCount;
+    if (opcode === 0) {
+      byteCount = 0;
+    } else if (opcode >= 1 && opcode <= 75) {
+      byteCount = opcode;
+    } else if (opcode === 76) {
+      byteCount = readByte(signatureScriptHex, offset);
+      offset += 2;
+    } else if (opcode === 77) {
+      byteCount = readLittleEndian(signatureScriptHex, offset, 2);
+      offset += 4;
+    } else if (opcode === 78) {
+      byteCount = readLittleEndian(signatureScriptHex, offset, 4);
+      offset += 8;
+    } else {
+      throw new SilverSimulationError(
+        "SILVERSCRIPT_SIGNATURE_SCRIPT_NOT_PUSH_ONLY",
+        `Non-push opcode 0x${opcode.toString(16)} encountered.`
+      );
+    }
+    const hexCount = byteCount * 2;
+    const end = offset + hexCount;
+    if (end > signatureScriptHex.length) {
+      throw new SilverSimulationError(
+        "SILVERSCRIPT_SIGNATURE_SCRIPT_NOT_PUSH_ONLY",
+        "Truncated pushdata in signatureScriptHex."
+      );
+    }
+    pushes.push(signatureScriptHex.slice(offset, end).toLowerCase());
+    offset = end;
+  }
+  return pushes;
+}
+function assertSimnet(networkId) {
+  if (networkId !== "simnet") {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_NETWORK_UNSUPPORTED",
+      "Silver/Toccata simulator only supports local simnet."
+    );
+  }
+}
+function assertHex(value, field) {
+  if (!isHex(value)) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_INVALID_HEX",
+      `${field} must be even-length hex.`
+    );
+  }
+}
+function isHex(value) {
+  return typeof value === "string" && value.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(value);
+}
+function calculateContentHash(value, _version = CURRENT_HASH_VERSION) {
+  return createHash2("sha256").update(canonicalStringify(value)).digest("hex");
+}
+function canonicalStringify(value) {
+  if (typeof value === "bigint") {
+    return JSON.stringify(`n:${value.toString()}`);
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => canonicalStringify(item)).join(",")}]`;
+  }
+  const exclusions = /* @__PURE__ */ new Set([
+    "contentHash",
+    "artifactId",
+    "hashVersion",
+    "createdAt",
+    "hardkasVersion",
+    "status"
+  ]);
+  const record = value;
+  return `{${Object.keys(record).filter((key) => !exclusions.has(key) && record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalStringify(record[key])}`).join(",")}}`;
+}
+function parseSompi(value) {
+  if (!/^[0-9]+$/.test(value)) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_AMOUNT_TOO_SMALL",
+      "Sompi values must be unsigned integer strings."
+    );
+  }
+  return BigInt(value);
+}
+function artifactHash(value) {
+  return value.contentHash ?? calculateContentHash(value, CURRENT_HASH_VERSION);
+}
+function deterministicHex(value) {
+  return calculateContentHash(value, CURRENT_HASH_VERSION);
+}
+function finalizeArtifact(artifact, prefix) {
+  const contentHash = calculateContentHash(artifact, CURRENT_HASH_VERSION);
+  return {
+    ...artifact,
+    contentHash,
+    artifactId: `${prefix}-${contentHash.slice(0, 16)}`
+  };
+}
+function cloneState(state) {
+  return JSON.parse(JSON.stringify(state));
+}
+function normalizeState(state) {
+  return {
+    ...state,
+    deployReceipts: Object.fromEntries(
+      Object.entries(state.deployReceipts).sort(([a], [b]) => a.localeCompare(b))
+    ),
+    utxos: Object.fromEntries(
+      Object.entries(state.utxos).sort(([a], [b]) => a.localeCompare(b))
+    ),
+    spentOutpoints: [...state.spentOutpoints].sort()
+  };
+}
+function readByte(hex, offset) {
+  const raw = hex.slice(offset, offset + 2);
+  if (raw.length !== 2) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SIGNATURE_SCRIPT_NOT_PUSH_ONLY",
+      "Truncated opcode in signatureScriptHex."
+    );
+  }
+  return parseInt(raw, 16);
+}
+function readLittleEndian(hex, offset, byteCount) {
+  const raw = hex.slice(offset, offset + byteCount * 2);
+  if (raw.length !== byteCount * 2) {
+    throw new SilverSimulationError(
+      "SILVERSCRIPT_SIGNATURE_SCRIPT_NOT_PUSH_ONLY",
+      "Truncated pushdata length in signatureScriptHex."
+    );
+  }
+  const bytes = raw.match(/../g) ?? [];
+  return parseInt(bytes.reverse().join(""), 16);
+}
 export {
   ApproxGhostdagEngine,
   DEFAULT_K,
   GENESIS_HASH,
   GhostdagStore,
+  SILVER_SIMULATOR_CREATED_AT,
+  SILVER_SIMULATOR_FEE_SOMPI,
+  SILVER_SIMULATOR_VERSION,
+  SilverSimulationError,
   TxSimulator,
   blockBlueScore,
   blockBlueWork,
   blockHash,
   blockParents,
+  calculateSilverArgsHash,
   compactFromFull,
   compareMassProfiles,
   compareSortableBlocks,
   computeDagMetrics,
+  createSilverSimulationState,
   createTraceId,
   findSelectedParent,
   formatMassComparison,
@@ -781,6 +1207,8 @@ export {
   isDagAncestorOf,
   loadMassSnapshot,
   orderedMergesetWithoutSelectedParent,
+  outpointKey,
+  parsePushOnlyScript,
   pastSet,
   profileAndCompare,
   profileMass,
@@ -790,6 +1218,8 @@ export {
   runLinearChain,
   runWideDag,
   saveMassSnapshot,
+  simulateSilverDeploy,
+  simulateSilverSpend,
   sortBlocks,
   unorderedMergesetWithoutSelectedParent
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/simulator",
-  "version": "0.8.20-alpha",
+  "version": "0.9.1-alpha",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,8 +12,8 @@
     }
   },
   "dependencies": {
-    "@hardkas/core": "0.8.20-alpha",
-    "@hardkas/tx-builder": "0.8.20-alpha"
+    "@hardkas/core": "0.9.1-alpha",
+    "@hardkas/tx-builder": "0.9.1-alpha"
   },
   "devDependencies": {
     "tsup": "^8.3.5",