@hardkas/localnet 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Rodriguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-CXDVB3K4.js

@@ -0,0 +1,60 @@
+// src/receipts.ts
+import fs from "fs/promises";
+import path from "path";
+import { existsSync } from "fs";
+function getDefaultReceiptsDir(cwd = process.cwd()) {
+  return path.join(cwd, ".hardkas", "receipts");
+}
+function getReceiptPath(txId, cwd) {
+  validateTxId(txId);
+  return path.join(getDefaultReceiptsDir(cwd), `${txId}.json`);
+}
+function validateTxId(txId) {
+  if (txId.includes("/") || txId.includes("\\") || txId.includes("..")) {
+    throw new Error(`Invalid txId: ${txId}`);
+  }
+}
+async function saveSimulatedReceipt(receipt, options) {
+  const dir = getDefaultReceiptsDir(options?.cwd);
+  if (!existsSync(dir)) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  const filePath = getReceiptPath(receipt.txId, options?.cwd);
+  await fs.writeFile(filePath, JSON.stringify(receipt, null, 2), "utf-8");
+  return filePath;
+}
+async function loadSimulatedReceipt(txId, options) {
+  const filePath = getReceiptPath(txId, options?.cwd);
+  if (!existsSync(filePath)) {
+    throw new Error(`Receipt not found: ${txId}`);
+  }
+  const data = await fs.readFile(filePath, "utf-8");
+  return JSON.parse(data);
+}
+async function listSimulatedReceipts(options) {
+  const dir = getDefaultReceiptsDir(options?.cwd);
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const files = await fs.readdir(dir);
+  const receipts = [];
+  for (const file of files) {
+    if (file.endsWith(".json")) {
+      try {
+        const txId = path.basename(file, ".json");
+        const receipt = await loadSimulatedReceipt(txId, options);
+        receipts.push(receipt);
+      } catch (e) {
+      }
+    }
+  }
+  return receipts.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+export {
+  getDefaultReceiptsDir,
+  getReceiptPath,
+  saveSimulatedReceipt,
+  loadSimulatedReceipt,
+  listSimulatedReceipts
+};

package/dist/chunk-W7ZBGUNK.js

@@ -0,0 +1,60 @@
+// src/traces.ts
+import fs from "fs/promises";
+import path from "path";
+import { existsSync } from "fs";
+function getDefaultTracesDir(cwd = process.cwd()) {
+  return path.join(cwd, ".hardkas", "traces");
+}
+function getTracePath(txId, cwd) {
+  validateTxId(txId);
+  return path.join(getDefaultTracesDir(cwd), `${txId}.trace.json`);
+}
+function validateTxId(txId) {
+  if (txId.includes("/") || txId.includes("\\") || txId.includes("..")) {
+    throw new Error(`Invalid txId: ${txId}`);
+  }
+}
+async function saveSimulatedTrace(trace, options) {
+  const dir = getDefaultTracesDir(options?.cwd);
+  if (!existsSync(dir)) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  const filePath = getTracePath(trace.txId, options?.cwd);
+  await fs.writeFile(filePath, JSON.stringify(trace, null, 2), "utf-8");
+  return filePath;
+}
+async function loadSimulatedTrace(txId, options) {
+  const filePath = getTracePath(txId, options?.cwd);
+  if (!existsSync(filePath)) {
+    throw new Error(`Trace not found: ${txId}`);
+  }
+  const data = await fs.readFile(filePath, "utf-8");
+  return JSON.parse(data);
+}
+async function listSimulatedTraces(options) {
+  const dir = getDefaultTracesDir(options?.cwd);
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const files = await fs.readdir(dir);
+  const traces = [];
+  for (const file of files) {
+    if (file.endsWith(".trace.json")) {
+      try {
+        const txId = path.basename(file, ".trace.json");
+        const trace = await loadSimulatedTrace(txId, options);
+        traces.push(trace);
+      } catch (e) {
+      }
+    }
+  }
+  return traces.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+
+export {
+  getDefaultTracesDir,
+  getTracePath,
+  saveSimulatedTrace,
+  loadSimulatedTrace,
+  listSimulatedTraces
+};

package/dist/index.d.ts

@@ -0,0 +1,334 @@
+import { HardkasArtifactBase, Snapshot as Snapshot$1, ARTIFACT_SCHEMAS, TxReceipt, TxPlan } from '@hardkas/artifacts';
+import { ExecutionMode, NetworkId } from '@hardkas/core';
+
+interface HardkasAccount {
+    readonly name: string;
+    readonly address: string;
+    readonly balanceSompi: bigint;
+}
+declare function createDeterministicAccounts(input?: {
+    readonly count?: number | undefined;
+    readonly initialBalanceSompi?: bigint | undefined;
+} | undefined): HardkasAccount[];
+declare function resolveAccountAddress(input: string): string;
+
+interface SimulatedUtxo {
+    readonly id: string;
+    readonly address: string;
+    readonly amountSompi: bigint;
+    readonly spent: boolean;
+}
+interface Snapshot {
+    readonly id: string;
+    readonly utxos: readonly SimulatedUtxo[];
+    readonly daaScore: bigint;
+}
+declare class SimulatedKaspaChain {
+    private utxos;
+    private daaScore;
+    constructor(accounts: readonly HardkasAccount[]);
+    getDaaScore(): bigint;
+    mineBlock(): bigint;
+    getBalance(address: string): bigint;
+    getUtxos(address: string): readonly SimulatedUtxo[];
+    fund(address: string, amountSompi: bigint): SimulatedUtxo;
+    snapshot(): Snapshot;
+    restore(snapshot: Snapshot): void;
+}
+
+interface HardkasDevnet {
+    readonly mode: "simulated";
+    readonly accounts: readonly HardkasAccount[];
+    readonly chain: SimulatedKaspaChain;
+    stop(): Promise<void>;
+}
+declare function startSimulatedDevnet(input?: {
+    readonly accounts?: number | undefined;
+    readonly initialBalanceSompi?: bigint | undefined;
+} | undefined): Promise<HardkasDevnet>;
+
+interface LocalnetAccount {
+    name: string;
+    address: string;
+}
+interface LocalnetUtxo {
+    id: string;
+    address: string;
+    amountSompi: string;
+    spent: boolean;
+    createdAtDaaScore: string;
+    spentAtDaaScore?: string;
+}
+interface LocalnetState extends HardkasArtifactBase {
+    schema: "hardkas.localnetState.v1";
+    mode: ExecutionMode;
+    networkId: NetworkId;
+    daaScore: string;
+    accounts: LocalnetAccount[];
+    utxos: LocalnetUtxo[];
+    snapshots?: Snapshot$1[];
+    dag?: SimulatedDag;
+}
+interface SimulatedBlock {
+    id: string;
+    parents: string[];
+    blueScore: string;
+    daaScore: string;
+    acceptedTxIds: string[];
+    isGenesis?: boolean;
+}
+interface SimulatedDag {
+    blocks: Record<string, SimulatedBlock>;
+    sink: string;
+    selectedPathToSink: string[];
+    acceptedTxIds: string[];
+    displacedTxIds: string[];
+    conflictSet: Array<{
+        outpoint: string;
+        winnerTxId: string;
+        loserTxIds: string[];
+    }>;
+}
+interface StateTransition {
+    preStateHash: string;
+    postStateHash: string;
+    daaScore: string;
+}
+interface SimulationResult {
+    ok: boolean;
+    state: LocalnetState;
+    receipt: any;
+    planArtifact?: any;
+    errors: string[];
+}
+interface ReplayInvariantResult {
+    ok: boolean;
+    mismatches: string[];
+}
+interface ReplayVerificationReport {
+    planOk: boolean;
+    receiptOk: boolean;
+    invariantsOk: boolean;
+    errors: string[];
+}
+interface SnapshotVerificationResult {
+    ok: boolean;
+    hashes: {
+        accountsMatch: boolean;
+        utxoSetMatch: boolean;
+        stateMatch: boolean;
+        contentMatch: boolean;
+    };
+    errors: string[];
+}
+interface SnapshotRestoreResult {
+    ok: boolean;
+    previousStateHash?: string;
+    newStateHash?: string;
+    error?: string;
+}
+
+interface CreateInitialStateOptions {
+    accounts?: number | undefined;
+    initialBalanceSompi?: bigint | undefined;
+}
+declare function createInitialLocalnetState(options?: CreateInitialStateOptions): LocalnetState;
+declare function resolveAccountAddressFromState(state: LocalnetState, nameOrAddress: string): string;
+
+declare function getDefaultLocalnetDir(cwd?: string): string;
+declare function getDefaultLocalnetStatePath(cwd?: string): string;
+declare function saveLocalnetState(state: LocalnetState, filePath?: string): Promise<void>;
+declare function loadLocalnetState(filePath?: string): Promise<LocalnetState | null>;
+declare function loadOrCreateLocalnetState(options?: {
+    cwd?: string;
+    accounts?: number;
+    initialBalanceSompi?: bigint;
+}): Promise<LocalnetState>;
+declare function resetLocalnetState(options?: {
+    cwd?: string;
+    accounts?: number;
+    initialBalanceSompi?: bigint;
+}): Promise<LocalnetState>;
+
+interface FundAddressInput {
+    address: string;
+    amountSompi: bigint;
+}
+declare function fundAddress(state: LocalnetState, input: FundAddressInput): LocalnetState;
+
+declare function getAddressBalanceSompi(state: LocalnetState, address: string): bigint;
+declare function getAccountBalanceSompi(state: LocalnetState, nameOrAddress: string): bigint;
+declare function getSpendableUtxos(state: LocalnetState, address: string): LocalnetUtxo[];
+
+/**
+ * Calculates hash of the UTXO set (sorted by outpoint).
+ */
+declare function calculateUtxoSetHash(utxos: LocalnetUtxo[]): string;
+/**
+ * Calculates hash of the account set (sorted by address).
+ */
+declare function calculateAccountsHash(accounts: LocalnetAccount[]): string;
+/**
+ * Calculates the state hash (daaScore + accountsHash + utxoSetHash).
+ */
+declare function calculateStateHash(state: LocalnetState): string;
+/**
+ * Creates a canonical deterministic snapshot.
+ */
+declare function createLocalnetSnapshot(state: LocalnetState, name?: string): LocalnetState;
+/**
+ * Verifies the integrity of a snapshot.
+ */
+declare function verifySnapshot(snapshot: any): SnapshotVerificationResult;
+/**
+ * Restores a snapshot with atomic safety and verification.
+ */
+declare function restoreLocalnetSnapshot(state: LocalnetState, snapshotIdOrName: string): LocalnetState;
+
+interface SimulatedPaymentInput {
+    readonly from: string;
+    readonly to: string;
+    readonly amountSompi: bigint;
+    readonly feeRateSompiPerMass?: bigint;
+}
+/**
+ * Standard Kaspa dust limit (approximate).
+ */
+declare const DUST_LIMIT_SOMPI = 600n;
+/**
+ * Applies a simulated payment to the localnet state with atomic safety and validation.
+ */
+declare function applySimulatedPayment(state: LocalnetState, input: SimulatedPaymentInput): SimulationResult;
+/**
+ * Executes a pre-built transaction plan against the simulated state.
+ */
+declare function applySimulatedPlan(state: LocalnetState, planArtifact: any, // TxPlanArtifact
+options?: {
+    txId?: string;
+}): SimulationResult;
+
+interface StoredSimulatedTxReceipt extends HardkasArtifactBase {
+    schema: typeof ARTIFACT_SCHEMAS.TX_RECEIPT;
+    version: "1.0.0-alpha";
+    txId: string;
+    status: "confirmed" | "failed";
+    mode: ExecutionMode;
+    networkId: NetworkId;
+    from: {
+        address: string;
+    };
+    to: {
+        address: string;
+    };
+    amountSompi: string;
+    feeSompi: string;
+    changeSompi?: string | undefined;
+    spentUtxoIds: string[];
+    createdUtxoIds: string[];
+    daaScore: string;
+}
+declare function getDefaultReceiptsDir(cwd?: string): string;
+declare function getReceiptPath(txId: string, cwd?: string): string;
+declare function saveSimulatedReceipt(receipt: StoredSimulatedTxReceipt, options?: {
+    cwd?: string;
+}): Promise<string>;
+declare function loadSimulatedReceipt(txId: string, options?: {
+    cwd?: string;
+}): Promise<StoredSimulatedTxReceipt>;
+declare function listSimulatedReceipts(options?: {
+    cwd?: string;
+}): Promise<StoredSimulatedTxReceipt[]>;
+
+type StoredTraceEvent = {
+    readonly type: "phase.started";
+    readonly phase: string;
+    readonly timestamp: number;
+} | {
+    readonly type: "phase.completed";
+    readonly phase: string;
+    readonly timestamp: number;
+} | {
+    readonly type: "note";
+    readonly message: string;
+    readonly timestamp: number;
+} | {
+    readonly type: "tx.failed";
+    readonly phase: string;
+    readonly reason: string;
+    readonly timestamp: number;
+};
+interface StoredSimulatedTxTrace extends HardkasArtifactBase {
+    readonly schema: typeof ARTIFACT_SCHEMAS.TX_TRACE;
+    readonly txId: string;
+    readonly mode: ExecutionMode;
+    readonly networkId: NetworkId;
+    readonly events: readonly StoredTraceEvent[];
+    readonly receiptPath?: string | undefined;
+}
+declare function getDefaultTracesDir(cwd?: string): string;
+declare function getTracePath(txId: string, cwd?: string): string;
+declare function saveSimulatedTrace(trace: StoredSimulatedTxTrace, options?: {
+    cwd?: string;
+}): Promise<string>;
+declare function loadSimulatedTrace(txId: string, options?: {
+    cwd?: string;
+}): Promise<StoredSimulatedTxTrace>;
+declare function listSimulatedTraces(options?: {
+    cwd?: string;
+}): Promise<StoredSimulatedTxTrace[]>;
+
+interface SimulatedReplaySummary {
+    receipt: TxReceipt;
+    trace: StoredSimulatedTxTrace;
+    summary: {
+        spentCount: number;
+        createdCount: number;
+        transferredSompi: bigint;
+        feeSompi: bigint;
+        changeSompi: bigint;
+        finalDaaScore: string;
+    };
+}
+/**
+ * Verifies that a transaction replay matches the original artifacts.
+ */
+declare function verifyReplay(state: LocalnetState, originalPlan: TxPlan, originalReceipt: TxReceipt): ReplayVerificationReport;
+/**
+ * Loads receipt and trace for a transaction and produces a summary.
+ */
+declare function getSimulatedReplaySummary(txId: string, options?: {
+    cwd?: string;
+}): Promise<SimulatedReplaySummary>;
+
+/**
+ * Creates a fresh simulated DAG with a genesis block.
+ */
+declare function createSimulatedDag(): SimulatedDag;
+/**
+ * Adds a block to the DAG.
+ */
+declare function addSimulatedBlock(dag: SimulatedDag, block: SimulatedBlock): SimulatedDag;
+/**
+ * Moves the sink and recomputes the accepted transaction set.
+ */
+declare function moveSink(dag: SimulatedDag, newSinkId: string, txProvider: (txId: string) => {
+    inputs: string[];
+} | undefined): SimulatedDag;
+/**
+ * Deterministic Conflict Resolution (Approximation for v0.2-alpha)
+ * Priority:
+ * 1. sink ancestry priority (is part of selectedPathToSink?)
+ * 2. deterministic block order (daaScore then block ID)
+ * 3. txId lexicographic tie-break
+ */
+declare function resolveConflictsDeterministically(txs: Array<{
+    txId: string;
+    blockId: string;
+    inputs: string[];
+}>, dag: SimulatedDag): {
+    accepted: string[];
+    displaced: string[];
+    conflicts: any[];
+};
+
+export { type CreateInitialStateOptions, DUST_LIMIT_SOMPI, type FundAddressInput, type HardkasAccount, type HardkasDevnet, type LocalnetAccount, type LocalnetState, type LocalnetUtxo, type ReplayInvariantResult, type ReplayVerificationReport, type SimulatedBlock, type SimulatedDag, SimulatedKaspaChain, type SimulatedPaymentInput, type SimulatedReplaySummary, type SimulatedUtxo, type SimulationResult, type Snapshot, type SnapshotRestoreResult, type SnapshotVerificationResult, type StateTransition, type StoredSimulatedTxReceipt, type StoredSimulatedTxTrace, type StoredTraceEvent, addSimulatedBlock, applySimulatedPayment, applySimulatedPlan, calculateAccountsHash, calculateStateHash, calculateUtxoSetHash, createDeterministicAccounts, createInitialLocalnetState, createLocalnetSnapshot, createSimulatedDag, fundAddress, getAccountBalanceSompi, getAddressBalanceSompi, getDefaultLocalnetDir, getDefaultLocalnetStatePath, getDefaultReceiptsDir, getDefaultTracesDir, getReceiptPath, getSimulatedReplaySummary, getSpendableUtxos, getTracePath, listSimulatedReceipts, listSimulatedTraces, loadLocalnetState, loadOrCreateLocalnetState, loadSimulatedReceipt, loadSimulatedTrace, moveSink, resetLocalnetState, resolveAccountAddress, resolveAccountAddressFromState, resolveConflictsDeterministically, restoreLocalnetSnapshot, saveLocalnetState, saveSimulatedReceipt, saveSimulatedTrace, startSimulatedDevnet, verifyReplay, verifySnapshot };

package/dist/index.js

@@ -0,0 +1,861 @@
+import {
+  getDefaultReceiptsDir,
+  getReceiptPath,
+  listSimulatedReceipts,
+  loadSimulatedReceipt,
+  saveSimulatedReceipt
+} from "./chunk-CXDVB3K4.js";
+import {
+  getDefaultTracesDir,
+  getTracePath,
+  listSimulatedTraces,
+  loadSimulatedTrace,
+  saveSimulatedTrace
+} from "./chunk-W7ZBGUNK.js";
+
+// src/accounts.ts
+function createDeterministicAccounts(input) {
+  const count = input?.count ?? 5;
+  const initialBalanceSompi = input?.initialBalanceSompi ?? 1000n * 100000000n;
+  const names = ["alice", "bob", "carol", "dave", "erin"];
+  return Array.from({ length: count }, (_, index) => {
+    const name = names[index] ?? `account${index}`;
+    return {
+      name,
+      address: `kaspa:sim_${name}`,
+      balanceSompi: initialBalanceSompi
+    };
+  });
+}
+function resolveAccountAddress(input) {
+  if (input.startsWith("kaspa:")) {
+    return input;
+  }
+  const aliases = {
+    alice: "kaspa:sim_alice",
+    bob: "kaspa:sim_bob",
+    carol: "kaspa:sim_carol",
+    dave: "kaspa:sim_dave",
+    erin: "kaspa:sim_erin"
+  };
+  const resolved = aliases[input.toLowerCase()];
+  if (!resolved) {
+    throw new Error(`Unknown account alias: ${input}`);
+  }
+  return resolved;
+}
+
+// src/simulated-chain.ts
+var SimulatedKaspaChain = class {
+  utxos = [];
+  daaScore = 0n;
+  constructor(accounts) {
+    for (const account of accounts) {
+      this.utxos.push({
+        id: `genesis:${account.name}:0`,
+        address: account.address,
+        amountSompi: account.balanceSompi,
+        spent: false
+      });
+    }
+  }
+  getDaaScore() {
+    return this.daaScore;
+  }
+  mineBlock() {
+    this.daaScore += 1n;
+    return this.daaScore;
+  }
+  getBalance(address) {
+    return this.utxos.filter((utxo) => utxo.address === address && !utxo.spent).reduce((sum, utxo) => sum + utxo.amountSompi, 0n);
+  }
+  getUtxos(address) {
+    return this.utxos.filter((utxo) => utxo.address === address && !utxo.spent);
+  }
+  fund(address, amountSompi) {
+    if (amountSompi <= 0n) {
+      throw new Error("Faucet amount must be positive.");
+    }
+    const utxo = {
+      id: `faucet:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`,
+      address,
+      amountSompi,
+      spent: false
+    };
+    this.utxos.push(utxo);
+    this.mineBlock();
+    return utxo;
+  }
+  snapshot() {
+    return {
+      id: `snapshot:${Date.now().toString(36)}`,
+      utxos: this.utxos.map((utxo) => ({ ...utxo })),
+      daaScore: this.daaScore
+    };
+  }
+  restore(snapshot) {
+    this.utxos = snapshot.utxos.map((utxo) => ({ ...utxo }));
+    this.daaScore = snapshot.daaScore;
+  }
+};
+
+// src/devnet.ts
+async function startSimulatedDevnet(input) {
+  const accounts = createDeterministicAccounts({
+    count: input?.accounts,
+    initialBalanceSompi: input?.initialBalanceSompi
+  });
+  const chain = new SimulatedKaspaChain(accounts);
+  return {
+    mode: "simulated",
+    accounts,
+    chain,
+    async stop() {
+    }
+  };
+}
+
+// src/state.ts
+import { SOMPI_PER_KAS } from "@hardkas/core";
+import { HARDKAS_VERSION, ARTIFACT_SCHEMAS } from "@hardkas/artifacts";
+function createInitialLocalnetState(options = {}) {
+  const accountCount = options.accounts ?? 5;
+  const initialBalanceSompi = options.initialBalanceSompi ?? 1000n * SOMPI_PER_KAS;
+  const accounts = createDeterministicAccounts({
+    count: accountCount,
+    initialBalanceSompi
+  });
+  return {
+    schema: ARTIFACT_SCHEMAS.LOCALNET_STATE,
+    hardkasVersion: HARDKAS_VERSION,
+    version: "1.0.0-alpha",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode: "simulated",
+    networkId: "simnet",
+    daaScore: "0",
+    accounts: accounts.map((a) => ({
+      name: a.name,
+      address: a.address
+    })),
+    utxos: accounts.map((a) => ({
+      id: `genesis:${a.name}:0`,
+      address: a.address,
+      amountSompi: a.balanceSompi.toString(),
+      spent: false,
+      createdAtDaaScore: "0"
+    })),
+    snapshots: []
+  };
+}
+function resolveAccountAddressFromState(state, nameOrAddress) {
+  if (nameOrAddress.startsWith("kaspa:")) {
+    return nameOrAddress;
+  }
+  const account = state.accounts.find((a) => a.name === nameOrAddress);
+  if (account) {
+    return account.address;
+  }
+  return nameOrAddress;
+}
+
+// src/store.ts
+import fs from "fs/promises";
+import path from "path";
+function getDefaultLocalnetDir(cwd = process.cwd()) {
+  return path.join(cwd, ".hardkas");
+}
+function getDefaultLocalnetStatePath(cwd = process.cwd()) {
+  return path.join(getDefaultLocalnetDir(cwd), "localnet.json");
+}
+async function saveLocalnetState(state, filePath) {
+  const targetPath = filePath ?? getDefaultLocalnetStatePath();
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(targetPath, JSON.stringify(state, null, 2), "utf-8");
+}
+async function loadLocalnetState(filePath) {
+  const targetPath = filePath ?? getDefaultLocalnetStatePath();
+  try {
+    const content = await fs.readFile(targetPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+async function loadOrCreateLocalnetState(options = {}) {
+  const path2 = getDefaultLocalnetStatePath(options.cwd);
+  let state = await loadLocalnetState(path2);
+  if (!state) {
+    state = createInitialLocalnetState({
+      accounts: options.accounts,
+      initialBalanceSompi: options.initialBalanceSompi
+    });
+    await saveLocalnetState(state, path2);
+  }
+  return state;
+}
+async function resetLocalnetState(options = {}) {
+  const path2 = getDefaultLocalnetStatePath(options.cwd);
+  const state = createInitialLocalnetState({
+    accounts: options.accounts,
+    initialBalanceSompi: options.initialBalanceSompi
+  });
+  await saveLocalnetState(state, path2);
+  return state;
+}
+
+// src/faucet.ts
+function fundAddress(state, input) {
+  if (input.amountSompi <= 0n) {
+    throw new Error("Faucet amount must be positive.");
+  }
+  const nextDaaScore = (BigInt(state.daaScore) + 1n).toString();
+  const newUtxo = {
+    id: `faucet:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`,
+    address: input.address,
+    amountSompi: input.amountSompi.toString(),
+    spent: false,
+    createdAtDaaScore: nextDaaScore
+  };
+  return {
+    ...state,
+    daaScore: nextDaaScore,
+    utxos: [...state.utxos, newUtxo]
+  };
+}
+
+// src/balance.ts
+function getAddressBalanceSompi(state, address) {
+  return state.utxos.filter((u) => u.address === address && !u.spent).reduce((sum, u) => sum + BigInt(u.amountSompi), 0n);
+}
+function getAccountBalanceSompi(state, nameOrAddress) {
+  const address = resolveAccountAddressFromState(state, nameOrAddress);
+  return getAddressBalanceSompi(state, address);
+}
+function getSpendableUtxos(state, address) {
+  return state.utxos.filter((u) => u.address === address && !u.spent);
+}
+
+// src/snapshot.ts
+import {
+  HARDKAS_VERSION as HARDKAS_VERSION2,
+  ARTIFACT_VERSION,
+  calculateContentHash,
+  sortUtxosByOutpoint
+} from "@hardkas/artifacts";
+function calculateUtxoSetHash(utxos) {
+  const sorted = sortUtxosByOutpoint(utxos);
+  return calculateContentHash(sorted);
+}
+function calculateAccountsHash(accounts) {
+  const sorted = [...accounts].sort((a, b) => a.address.localeCompare(b.address));
+  return calculateContentHash(sorted);
+}
+function calculateStateHash(state) {
+  const accountsHash = calculateAccountsHash(state.accounts);
+  const utxoSetHash = calculateUtxoSetHash(state.utxos);
+  return calculateContentHash({
+    daaScore: state.daaScore,
+    accountsHash,
+    utxoSetHash
+  });
+}
+function createLocalnetSnapshot(state, name) {
+  const accountsHash = calculateAccountsHash(state.accounts);
+  const utxoSetHash = calculateUtxoSetHash(state.utxos);
+  const stateHash = calculateStateHash(state);
+  const snapshot = {
+    schema: "hardkas.snapshot",
+    hardkasVersion: HARDKAS_VERSION2,
+    version: ARTIFACT_VERSION,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    name,
+    daaScore: state.daaScore,
+    accountsHash,
+    utxoSetHash,
+    stateHash,
+    accounts: JSON.parse(JSON.stringify(state.accounts)),
+    utxos: JSON.parse(JSON.stringify(sortUtxosByOutpoint(state.utxos)))
+  };
+  snapshot.contentHash = calculateContentHash(snapshot);
+  return {
+    ...state,
+    snapshots: [...state.snapshots || [], snapshot]
+  };
+}
+function verifySnapshot(snapshot) {
+  const errors = [];
+  const currentContentHash = calculateContentHash(snapshot);
+  const contentMatch = snapshot.contentHash === currentContentHash;
+  if (!contentMatch) errors.push(`Content hash mismatch: expected ${snapshot.contentHash}, got ${currentContentHash}`);
+  const currentAccountsHash = calculateAccountsHash(snapshot.accounts);
+  const accountsMatch = snapshot.accountsHash === currentAccountsHash;
+  if (!accountsMatch) errors.push(`Accounts hash mismatch: expected ${snapshot.accountsHash}, got ${currentAccountsHash}`);
+  const currentUtxoSetHash = calculateUtxoSetHash(snapshot.utxos);
+  const utxoSetMatch = snapshot.utxoSetHash === currentUtxoSetHash;
+  if (!utxoSetMatch) errors.push(`UTXO set hash mismatch: expected ${snapshot.utxoSetHash}, got ${currentUtxoSetHash}`);
+  const currentStateHash = calculateContentHash({
+    daaScore: snapshot.daaScore,
+    accountsHash: currentAccountsHash,
+    utxoSetHash: currentUtxoSetHash
+  });
+  const stateMatch = snapshot.stateHash === currentStateHash;
+  if (!stateMatch) errors.push(`State hash mismatch: expected ${snapshot.stateHash}, got ${currentStateHash}`);
+  return {
+    ok: errors.length === 0,
+    hashes: {
+      accountsMatch,
+      utxoSetMatch,
+      stateMatch,
+      contentMatch
+    },
+    errors
+  };
+}
+function restoreLocalnetSnapshot(state, snapshotIdOrName) {
+  const snapshot = state.snapshots?.find(
+    (s) => s.id === snapshotIdOrName || s.name === snapshotIdOrName || s.contentHash === snapshotIdOrName
+  );
+  if (!snapshot) {
+    throw new Error(`Snapshot not found: ${snapshotIdOrName}`);
+  }
+  const verification = verifySnapshot(snapshot);
+  if (!verification.ok) {
+    throw new Error(`Corrupted snapshot: ${verification.errors.join(", ")}`);
+  }
+  return {
+    ...state,
+    daaScore: snapshot.daaScore,
+    accounts: JSON.parse(JSON.stringify(snapshot.accounts)),
+    utxos: JSON.parse(JSON.stringify(snapshot.utxos))
+  };
+}
+
+// src/transactions.ts
+import { createHash } from "crypto";
+import { buildPaymentPlan } from "@hardkas/tx-builder";
+import {
+  createTxPlanArtifact,
+  createSimulatedTxReceipt,
+  calculateContentHash as calculateContentHash2
+} from "@hardkas/artifacts";
+function generateDeterministicTxId(planArtifact, preStateHash, daaScore) {
+  const planHash = planArtifact.contentHash || calculateContentHash2(planArtifact);
+  const input = `${planHash}:${preStateHash}:${daaScore}`;
+  const hash = createHash("sha256").update(input).digest("hex").slice(0, 32);
+  return `simtx_${hash}`;
+}
+var DUST_LIMIT_SOMPI = 600n;
+function applySimulatedPayment(state, input) {
+  const errors = [];
+  const preStateHash = calculateStateHash(state);
+  try {
+    const fromAddress = resolveAccountAddressFromState(state, input.from);
+    const toAddress = resolveAccountAddressFromState(state, input.to);
+    const amountSompi = input.amountSompi;
+    const feeRateSompiPerMass = input.feeRateSompiPerMass ?? 1n;
+    if (amountSompi <= 0n) {
+      throw new Error("Amount must be greater than 0");
+    }
+    if (amountSompi < DUST_LIMIT_SOMPI) {
+      errors.push(`Amount ${amountSompi} is below dust limit (${DUST_LIMIT_SOMPI})`);
+    }
+    const unspent = getSpendableUtxos(state, fromAddress);
+    if (unspent.length === 0) {
+      throw new Error(`Insufficient funds: no unspent UTXOs for ${fromAddress}`);
+    }
+    const availableUtxos = unspent.map((u) => {
+      const parts = u.id.split(":");
+      const index = Number(parts[parts.length - 1]);
+      const transactionId = parts.slice(0, -1).join(":");
+      return {
+        outpoint: { transactionId, index },
+        address: u.address,
+        amountSompi: BigInt(u.amountSompi),
+        scriptPublicKey: "mock-script"
+      };
+    });
+    const plan = buildPaymentPlan({
+      fromAddress,
+      outputs: [{ address: toAddress, amountSompi }],
+      availableUtxos,
+      feeRateSompiPerMass
+    });
+    const spentUtxoIds = plan.inputs.map((i) => `${i.outpoint.transactionId}:${i.outpoint.index}`);
+    const uniqueSpentIds = new Set(spentUtxoIds);
+    if (uniqueSpentIds.size !== spentUtxoIds.length) {
+      throw new Error("Duplicate inputs detected in transaction plan");
+    }
+    for (const id of spentUtxoIds) {
+      const utxo = state.utxos.find((u) => u.id === id);
+      if (!utxo) throw new Error(`UTXO not found: ${id}`);
+      if (utxo.spent) throw new Error(`UTXO already spent: ${id}`);
+    }
+    const planArtifact = createTxPlanArtifact({
+      networkId: state.networkId || "simnet",
+      mode: "simulated",
+      from: { input: input.from, address: fromAddress },
+      to: { input: input.to, address: toAddress },
+      amountSompi,
+      plan
+    });
+    const nextDaaScore = (BigInt(state.daaScore) + 1n).toString();
+    const txId = generateDeterministicTxId(planArtifact, preStateHash, nextDaaScore);
+    const nextUtxos = state.utxos.map((u) => {
+      if (spentUtxoIds.includes(u.id)) {
+        return {
+          ...u,
+          spent: true,
+          spentAtDaaScore: nextDaaScore
+        };
+      }
+      return u;
+    });
+    const createdUtxoIds = [];
+    const recipientUtxo = {
+      id: `${txId}:0`,
+      address: toAddress,
+      amountSompi: amountSompi.toString(),
+      spent: false,
+      createdAtDaaScore: nextDaaScore
+    };
+    nextUtxos.push(recipientUtxo);
+    createdUtxoIds.push(recipientUtxo.id);
+    if (plan.change) {
+      const changeUtxo = {
+        id: `${txId}:1`,
+        address: fromAddress,
+        amountSompi: plan.change.amountSompi.toString(),
+        spent: false,
+        createdAtDaaScore: nextDaaScore
+      };
+      nextUtxos.push(changeUtxo);
+      createdUtxoIds.push(changeUtxo.id);
+    }
+    const nextState = {
+      ...state,
+      daaScore: nextDaaScore,
+      utxos: nextUtxos
+    };
+    const postStateHash = calculateStateHash(nextState);
+    const receipt = createSimulatedTxReceipt(planArtifact, txId, {
+      spentUtxoIds,
+      createdUtxoIds,
+      daaScore: nextDaaScore
+    });
+    receipt.preStateHash = preStateHash;
+    receipt.postStateHash = postStateHash;
+    if (state.dag) {
+      receipt.dagContext = {
+        mode: "dag-light",
+        sink: state.dag.sink,
+        acceptedTxIds: state.dag.acceptedTxIds,
+        displacedTxIds: state.dag.displacedTxIds,
+        conflictSet: state.dag.conflictSet
+      };
+    } else {
+      receipt.dagContext = { mode: "linear", sink: "linear-pseudo-sink" };
+    }
+    return {
+      ok: true,
+      state: nextState,
+      receipt,
+      planArtifact,
+      errors
+    };
+  } catch (error) {
+    const txId = "failed-" + Date.now();
+    const receipt = {
+      schema: "hardkas.txReceipt",
+      status: "failed",
+      mode: "simulated",
+      txId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      errors: [error.message],
+      preStateHash,
+      postStateHash: preStateHash
+    };
+    return {
+      ok: false,
+      state,
+      // No mutation
+      receipt,
+      errors: [error.message]
+    };
+  }
+}
+function applySimulatedPlan(state, planArtifact, options) {
+  const errors = [];
+  const preStateHash = calculateStateHash(state);
+  try {
+    const spentUtxoIds = planArtifact.inputs.map((i) => `${i.outpoint.transactionId}:${i.outpoint.index}`);
+    for (const id of spentUtxoIds) {
+      const utxo = state.utxos.find((u) => u.id === id);
+      if (!utxo) throw new Error(`UTXO not found: ${id}`);
+      if (utxo.spent) throw new Error(`UTXO already spent: ${id}`);
+    }
+    const nextDaaScore = (BigInt(state.daaScore) + 1n).toString();
+    const txId = options?.txId || generateDeterministicTxId(planArtifact, preStateHash, nextDaaScore);
+    const nextUtxos = state.utxos.map((u) => {
+      if (spentUtxoIds.includes(u.id)) {
+        return { ...u, spent: true, spentAtDaaScore: nextDaaScore };
+      }
+      return u;
+    });
+    const createdUtxoIds = [];
+    planArtifact.outputs.forEach((o, idx) => {
+      const utxo = {
+        id: `${txId}:${idx}`,
+        address: o.address,
+        amountSompi: o.amountSompi.toString(),
+        spent: false,
+        createdAtDaaScore: nextDaaScore
+      };
+      nextUtxos.push(utxo);
+      createdUtxoIds.push(utxo.id);
+    });
+    if (planArtifact.change) {
+      const changeUtxo = {
+        id: `${txId}:${planArtifact.outputs.length}`,
+        address: planArtifact.change.address,
+        amountSompi: planArtifact.change.amountSompi.toString(),
+        spent: false,
+        createdAtDaaScore: nextDaaScore
+      };
+      nextUtxos.push(changeUtxo);
+      createdUtxoIds.push(changeUtxo.id);
+    }
+    const nextState = { ...state, daaScore: nextDaaScore, utxos: nextUtxos };
+    const postStateHash = calculateStateHash(nextState);
+    const receipt = createSimulatedTxReceipt(planArtifact, txId, {
+      spentUtxoIds,
+      createdUtxoIds,
+      daaScore: nextDaaScore
+    });
+    receipt.preStateHash = preStateHash;
+    receipt.postStateHash = postStateHash;
+    if (state.dag) {
+      receipt.dagContext = {
+        mode: "dag-light",
+        sink: state.dag.sink,
+        acceptedTxIds: state.dag.acceptedTxIds,
+        displacedTxIds: state.dag.displacedTxIds,
+        conflictSet: state.dag.conflictSet
+      };
+    } else {
+      receipt.dagContext = { mode: "linear", sink: "linear-pseudo-sink" };
+    }
+    return { ok: true, state: nextState, receipt, planArtifact, errors };
+  } catch (error) {
+    const receipt = {
+      schema: "hardkas.txReceipt",
+      status: "failed",
+      mode: "simulated",
+      txId: "failed-replay",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      errors: [error.message],
+      preStateHash,
+      postStateHash: preStateHash
+    };
+    return { ok: false, state, receipt, errors: [error.message] };
+  }
+}
+
+// src/replay.ts
+import {
+  calculateContentHash as calculateContentHash3
+} from "@hardkas/artifacts";
+import { coreEvents } from "@hardkas/core";
+function verifyReplay(state, originalPlan, originalReceipt) {
+  const errors = [];
+  const currentPlanHash = calculateContentHash3(originalPlan);
+  if (originalPlan.contentHash && currentPlanHash !== originalPlan.contentHash) {
+    const errorMsg = `TxPlan contentHash mismatch: expected ${originalPlan.contentHash}, got ${currentPlanHash}`;
+    errors.push(errorMsg);
+    coreEvents.normalizeAndEmit({
+      kind: "replay.divergence",
+      txId: originalReceipt.txId,
+      field: "planHash",
+      expected: originalPlan.contentHash,
+      actual: currentPlanHash
+    });
+  }
+  const result = applySimulatedPlan(state, originalPlan, { txId: originalReceipt.txId });
+  const replayReceipt = result.receipt;
+  const checks = [
+    { field: "status", expected: originalReceipt.status, actual: replayReceipt.status },
+    { field: "mass", expected: String(originalReceipt.mass), actual: String(replayReceipt.mass) },
+    { field: "feeSompi", expected: String(originalReceipt.feeSompi), actual: String(replayReceipt.feeSompi) },
+    { field: "preStateHash", expected: String(originalReceipt.preStateHash), actual: String(replayReceipt.preStateHash) },
+    { field: "postStateHash", expected: String(originalReceipt.postStateHash), actual: String(replayReceipt.postStateHash) },
+    { field: "spentUtxos", expected: String(originalReceipt.spentUtxoIds?.length), actual: String(replayReceipt.spentUtxoIds?.length) }
+  ];
+  for (const check of checks) {
+    if (check.expected !== check.actual) {
+      errors.push(`${check.field} mismatch: expected ${check.expected}, got ${check.actual}`);
+      coreEvents.normalizeAndEmit({
+        kind: "replay.divergence",
+        txId: originalReceipt.txId,
+        field: check.field,
+        expected: check.expected,
+        actual: check.actual
+      });
+    }
+  }
+  if (errors.length === 0) {
+    coreEvents.normalizeAndEmit({
+      kind: "replay.verified",
+      txId: originalReceipt.txId
+    });
+  }
+  return {
+    planOk: !errors.some((e) => e.includes("TxPlan")),
+    receiptOk: !errors.some((e) => e.includes("Status") || e.includes("Hash")),
+    invariantsOk: errors.length === 0,
+    errors
+  };
+}
+async function getSimulatedReplaySummary(txId, options = {}) {
+  const { loadSimulatedReceipt: loadSimulatedReceipt2 } = await import("./receipts-ICI3GEJW.js");
+  const { loadSimulatedTrace: loadSimulatedTrace2 } = await import("./traces-DSACQ53V.js");
+  const receipt = await loadSimulatedReceipt2(txId, options);
+  const trace = await loadSimulatedTrace2(txId, options);
+  if (!receipt || !trace) {
+    throw new Error(`Receipt or trace not found for transaction: ${txId}`);
+  }
+  return {
+    receipt,
+    trace,
+    summary: {
+      spentCount: receipt.spentUtxoIds?.length || 0,
+      createdCount: receipt.createdUtxoIds?.length || 0,
+      transferredSompi: BigInt(receipt.amountSompi),
+      feeSompi: BigInt(receipt.feeSompi || "0"),
+      changeSompi: BigInt(receipt.changeSompi || "0"),
+      finalDaaScore: receipt.daaScore || "0"
+    }
+  };
+}
+
+// src/dag.ts
+function createSimulatedDag() {
+  const genesis = {
+    id: "genesis",
+    parents: [],
+    blueScore: "0",
+    daaScore: "0",
+    acceptedTxIds: [],
+    isGenesis: true
+  };
+  return {
+    blocks: { [genesis.id]: genesis },
+    sink: genesis.id,
+    selectedPathToSink: [genesis.id],
+    acceptedTxIds: [],
+    displacedTxIds: [],
+    conflictSet: []
+  };
+}
+function addSimulatedBlock(dag, block) {
+  const newBlocks = { ...dag.blocks, [block.id]: block };
+  return {
+    ...dag,
+    blocks: newBlocks
+  };
+}
+function moveSink(dag, newSinkId, txProvider) {
+  if (!dag.blocks[newSinkId]) {
+    throw new Error(`Block ${newSinkId} not found in DAG.`);
+  }
+  const selectedPath = calculateSelectedPath(dag, newSinkId);
+  const reachableBlocks = identifyReachableBlocks(dag, newSinkId);
+  const sortedBlocks = reachableBlocks.sort((a, b) => {
+    const daaA = BigInt(a.daaScore);
+    const daaB = BigInt(b.daaScore);
+    if (daaA !== daaB) return daaA < daaB ? -1 : 1;
+    return a.id.localeCompare(b.id);
+  });
+  const acceptedTxIds = [];
+  const displacedTxIds = [];
+  const conflictSet = [];
+  const spentOutpoints = /* @__PURE__ */ new Map();
+  for (const block of sortedBlocks) {
+    for (const txId of block.acceptedTxIds) {
+      const tx = txProvider(txId);
+      if (!tx) {
+        continue;
+      }
+      let conflictFound = false;
+      for (const input of tx.inputs) {
+        if (spentOutpoints.has(input)) {
+          const winnerTxId = spentOutpoints.get(input);
+          let entry = conflictSet.find((c) => c.outpoint === input);
+          if (!entry) {
+            entry = { outpoint: input, winnerTxId, loserTxIds: [] };
+            conflictSet.push(entry);
+          }
+          entry.loserTxIds.push(txId);
+          conflictFound = true;
+          break;
+        }
+      }
+      if (conflictFound) {
+        displacedTxIds.push(txId);
+      } else {
+        acceptedTxIds.push(txId);
+        for (const input of tx.inputs) {
+          spentOutpoints.set(input, txId);
+        }
+      }
+    }
+  }
+  const newlyDisplaced = dag.acceptedTxIds.filter((id) => !acceptedTxIds.includes(id));
+  for (const id of newlyDisplaced) {
+    if (!displacedTxIds.includes(id)) {
+      displacedTxIds.push(id);
+    }
+    const tx = txProvider(id);
+    if (tx) {
+      for (const input of tx.inputs) {
+        if (spentOutpoints.has(input)) {
+          const winnerTxId = spentOutpoints.get(input);
+          let entry = conflictSet.find((c) => c.outpoint === input);
+          if (!entry) {
+            entry = { outpoint: input, winnerTxId, loserTxIds: [] };
+            conflictSet.push(entry);
+          }
+          if (!entry.loserTxIds.includes(id)) {
+            entry.loserTxIds.push(id);
+          }
+          break;
+        }
+      }
+    }
+  }
+  return {
+    ...dag,
+    sink: newSinkId,
+    selectedPathToSink: selectedPath.map((b) => b.id),
+    acceptedTxIds,
+    displacedTxIds,
+    conflictSet
+  };
+}
+function calculateSelectedPath(dag, sinkId) {
+  const path2 = [];
+  let currentId = sinkId;
+  while (currentId) {
+    const current = dag.blocks[currentId];
+    if (!current) break;
+    path2.unshift(current);
+    if (current.parents.length === 0) break;
+    currentId = current.parents[0];
+  }
+  return path2;
+}
+function identifyReachableBlocks(dag, sinkId) {
+  const reachable = /* @__PURE__ */ new Set();
+  const stack = [sinkId];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (reachable.has(id)) continue;
+    reachable.add(id);
+    const block = dag.blocks[id];
+    if (block) {
+      for (const p of block.parents) {
+        stack.push(p);
+      }
+    }
+  }
+  return Array.from(reachable).map((id) => dag.blocks[id]).filter((b) => b !== void 0);
+}
+function resolveConflictsDeterministically(txs, dag) {
+  const sortedTxs = txs.sort((a, b) => {
+    const blockA = dag.blocks[a.blockId];
+    const blockB = dag.blocks[b.blockId];
+    if (!blockA || !blockB) {
+      if (!blockA && !blockB) return a.txId.localeCompare(b.txId);
+      return !blockA ? 1 : -1;
+    }
+    const inPathA = dag.selectedPathToSink.includes(a.blockId);
+    const inPathB = dag.selectedPathToSink.includes(b.blockId);
+    if (inPathA !== inPathB) return inPathA ? -1 : 1;
+    const daaA = BigInt(blockA.daaScore);
+    const daaB = BigInt(blockB.daaScore);
+    if (daaA !== daaB) return daaA < daaB ? -1 : 1;
+    if (a.blockId !== b.blockId) return a.blockId.localeCompare(b.blockId);
+    return a.txId.localeCompare(b.txId);
+  });
+  const accepted = [];
+  const displaced = [];
+  const conflicts = [];
+  const spent = /* @__PURE__ */ new Map();
+  for (const tx of sortedTxs) {
+    let conflictFound = false;
+    for (const input of tx.inputs) {
+      if (spent.has(input)) {
+        const winner = spent.get(input);
+        let c = conflicts.find((x) => x.outpoint === input);
+        if (!c) {
+          c = { outpoint: input, winnerTxId: winner, loserTxIds: [] };
+          conflicts.push(c);
+        }
+        c.loserTxIds.push(tx.txId);
+        conflictFound = true;
+        break;
+      }
+    }
+    if (conflictFound) {
+      displaced.push(tx.txId);
+    } else {
+      accepted.push(tx.txId);
+      for (const input of tx.inputs) {
+        spent.set(input, tx.txId);
+      }
+    }
+  }
+  return { accepted, displaced, conflicts };
+}
+export {
+  DUST_LIMIT_SOMPI,
+  SimulatedKaspaChain,
+  addSimulatedBlock,
+  applySimulatedPayment,
+  applySimulatedPlan,
+  calculateAccountsHash,
+  calculateStateHash,
+  calculateUtxoSetHash,
+  createDeterministicAccounts,
+  createInitialLocalnetState,
+  createLocalnetSnapshot,
+  createSimulatedDag,
+  fundAddress,
+  getAccountBalanceSompi,
+  getAddressBalanceSompi,
+  getDefaultLocalnetDir,
+  getDefaultLocalnetStatePath,
+  getDefaultReceiptsDir,
+  getDefaultTracesDir,
+  getReceiptPath,
+  getSimulatedReplaySummary,
+  getSpendableUtxos,
+  getTracePath,
+  listSimulatedReceipts,
+  listSimulatedTraces,
+  loadLocalnetState,
+  loadOrCreateLocalnetState,
+  loadSimulatedReceipt,
+  loadSimulatedTrace,
+  moveSink,
+  resetLocalnetState,
+  resolveAccountAddress,
+  resolveAccountAddressFromState,
+  resolveConflictsDeterministically,
+  restoreLocalnetSnapshot,
+  saveLocalnetState,
+  saveSimulatedReceipt,
+  saveSimulatedTrace,
+  startSimulatedDevnet,
+  verifyReplay,
+  verifySnapshot
+};

package/dist/receipts-ICI3GEJW.js

@@ -0,0 +1,14 @@
+import {
+  getDefaultReceiptsDir,
+  getReceiptPath,
+  listSimulatedReceipts,
+  loadSimulatedReceipt,
+  saveSimulatedReceipt
+} from "./chunk-CXDVB3K4.js";
+export {
+  getDefaultReceiptsDir,
+  getReceiptPath,
+  listSimulatedReceipts,
+  loadSimulatedReceipt,
+  saveSimulatedReceipt
+};

package/dist/traces-DSACQ53V.js

@@ -0,0 +1,14 @@
+import {
+  getDefaultTracesDir,
+  getTracePath,
+  listSimulatedTraces,
+  loadSimulatedTrace,
+  saveSimulatedTrace
+} from "./chunk-W7ZBGUNK.js";
+export {
+  getDefaultTracesDir,
+  getTracePath,
+  listSimulatedTraces,
+  loadSimulatedTrace,
+  saveSimulatedTrace
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@hardkas/localnet",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@hardkas/core": "0.1.0",
+    "@hardkas/query": "0.1.0",
+    "@hardkas/artifacts": "0.1.0",
+    "@hardkas/tx-builder": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "license": "MIT",
+  "author": "Javier Rodriguez",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jrodrg92/Hardkas.git",
+    "directory": "packages/localnet"
+  },
+  "bugs": {
+    "url": "https://github.com/jrodrg92/Hardkas/issues"
+  },
+  "homepage": "https://github.com/jrodrg92/Hardkas/tree/main/packages/localnet#readme",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --external kaspa",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}