@hardkas/sdk 0.8.16-alpha → 0.8.19-alpha

package/dist/client.d.ts

@@ -0,0 +1,84 @@
+interface HardkasClientOptions {
+    baseUrl?: string;
+    network?: string;
+}
+interface ClientEnvelope<T> {
+    ok: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+    warnings: string[];
+    meta: {
+        workspace: string;
+        network: string;
+        mode?: string;
+    };
+}
+declare function createHardkasClient(options?: HardkasClientOptions): {
+    accounts: {
+        list: () => Promise<ClientEnvelope<any[]>>;
+    };
+    tx: {
+        plan: (params: {
+            from: string;
+            to: string;
+            amountSompi: string;
+            feeRate?: string;
+        }) => Promise<ClientEnvelope<any>>;
+        sign: (params: {
+            planId: string;
+            account: string;
+        }) => Promise<ClientEnvelope<any>>;
+        send: (params: {
+            signedTxId?: string;
+            from?: string;
+            to?: string;
+            amountSompi?: string;
+            feeRate?: string;
+            allowDevAutoSign?: boolean;
+        }) => Promise<ClientEnvelope<any>>;
+        receipt: (id: string) => Promise<ClientEnvelope<any>>;
+    };
+    artifacts: {
+        explain: (id: string) => Promise<ClientEnvelope<any>>;
+        replay: (id: string) => Promise<ClientEnvelope<any>>;
+        watch: (callback: (artifact: any) => void, options?: {
+            type?: string;
+            lineage?: boolean;
+            replay?: boolean;
+            transport?: "sse" | "poll";
+            intervalMs?: number;
+        }) => () => void;
+    };
+    workflow: {
+        transfer: (params: {
+            from: string;
+            to: string;
+            amountSompi: string;
+            feeRate?: string;
+            allowDevAutoSign?: boolean;
+        }) => Promise<ClientEnvelope<any>>;
+    };
+    localnet: {
+        status: () => Promise<ClientEnvelope<any>>;
+    };
+    dev: {
+        status: () => Promise<ClientEnvelope<any>>;
+    };
+    session: {
+        start: () => Promise<ClientEnvelope<any>>;
+        snapshot: () => Promise<ClientEnvelope<any>>;
+        replay: (options?: {
+            untilArtifact?: string;
+            strict?: boolean;
+        }) => Promise<ClientEnvelope<any>>;
+        diffReplay: (artifactId: string) => Promise<ClientEnvelope<any>>;
+        timeTravel: (artifactId: string) => Promise<ClientEnvelope<any>>;
+        export: () => Promise<ClientEnvelope<any>>;
+        import: (data: any, force?: boolean) => Promise<ClientEnvelope<any>>;
+    };
+};
+
+export { type ClientEnvelope, type HardkasClientOptions, createHardkasClient };

package/dist/index.d.ts

@@ -0,0 +1,443 @@
+import * as _hardkas_config from '@hardkas/config';
+import { LoadedHardkasConfig } from '@hardkas/config';
+export { defineHardkasConfig } from '@hardkas/config';
+import { TxPlanArtifact, SignedTxArtifact, TxReceiptArtifact, HardkasArtifactBase, WorkflowArtifact, ExternalHardkasSigner } from '@hardkas/artifacts';
+export { ARTIFACT_SCHEMAS, HARDKAS_VERSION, SignedTxArtifact, TxPlanArtifact, TxReceiptArtifact, TxTraceArtifact, createTxPlanArtifact, writeArtifact } from '@hardkas/artifacts';
+import { KaspaRpcClient } from '@hardkas/kaspa-rpc';
+import { EventEnvelope, NetworkId } from '@hardkas/core';
+export { ArtifactId, HardkasError, KaspaAddress, LineageId, NetworkId, SOMPI_PER_KAS, TxId, formatSompi, parseKasToSompi } from '@hardkas/core';
+import { HardkasAccount } from '@hardkas/accounts';
+export { signTxPlanArtifact } from '@hardkas/accounts';
+import { L2NetworkProfile } from '@hardkas/l2';
+export { buildPaymentPlan } from '@hardkas/tx-builder';
+export { ClientEnvelope, HardkasClientOptions, createHardkasClient } from './client.js';
+
+/**
+ * HardKAS Accounts Module
+ * @alpha
+ */
+declare class HardkasAccounts {
+    private sdk;
+    constructor(sdk: Hardkas);
+    /**
+     * Resolves an account by name or address.
+     */
+    resolve(nameOrAddress: string): Promise<HardkasAccount>;
+    /**
+     * Fetches the balance for an account.
+     */
+    getBalance(accountNameOrAddress: string): Promise<{
+        sompi: bigint;
+        formatted: string;
+    }>;
+    /**
+     * Alias for getBalance.
+     */
+    balance(accountNameOrAddress: string): Promise<{
+        sompi: bigint;
+        formatted: string;
+    }>;
+    /**
+     * Lists all configured account names.
+     */
+    list(): Promise<string[]>;
+    /**
+     * Funds an account from another account (defaults to 'default' account).
+     */
+    fund(accountNameOrAddress: string, options?: {
+        from?: string;
+        amount?: string | bigint;
+    }): Promise<any>;
+}
+
+/**
+ * HardKAS Transaction Module
+ * @alpha
+ */
+declare class HardkasTx {
+    private sdk;
+    constructor(sdk: Hardkas);
+    /**
+     * Plans a transaction.
+     */
+    plan(options: {
+        from: string | HardkasAccount;
+        to: string | HardkasAccount;
+        amount: string | number | bigint;
+        feeRate?: bigint;
+        workflowId?: string;
+        policy?: string;
+        networkProfile?: string;
+        assumption?: string;
+    }): Promise<TxPlanArtifact>;
+    /**
+     * Creates a transaction plan explicitly for consolidation.
+     * This overrides normal selection logic and uses precisely the provided UTXOs.
+     */
+    createConsolidationPlan(options: {
+        account: HardkasAccount | string;
+        selectedUtxos: any[];
+        destination: string;
+        network?: string;
+        feeRate?: bigint;
+        totalUtxosSeen?: number;
+    }): Promise<TxPlanArtifact>;
+    /**
+     * Signs a transaction plan.
+     */
+    sign(plan: TxPlanArtifact | SignedTxArtifact, account?: HardkasAccount | string, options?: {
+        append?: boolean;
+        threshold?: number;
+        requiredSigners?: string[];
+    }): Promise<SignedTxArtifact>;
+    /**
+     * Simulates a transaction on the local state without broadcasting to a real Kaspa node.
+     * Modifies the local deterministic state and outputs receipt/trace artifacts.
+     */
+    simulate(target: string | Partial<TxPlanArtifact> | SignedTxArtifact, options?: {
+        persist?: boolean;
+    }): Promise<{
+        receipt: TxReceiptArtifact;
+        receiptPath?: string;
+        tracePath?: string;
+    }>;
+    /**
+     * Sends a signed transaction to the real RPC network.
+     */
+    send(signedArtifact: SignedTxArtifact, urlOrOptions?: string | {
+        persist?: boolean;
+    }): Promise<{
+        receipt: TxReceiptArtifact;
+        receiptPath?: string;
+        artifactId?: string;
+        mode?: string;
+        simulated?: boolean;
+        submitted?: boolean;
+        txId?: string;
+    }>;
+    /**
+     * Explicitly appends a signature to a partially signed transaction.
+     */
+    appendSignature(plan: SignedTxArtifact, account?: HardkasAccount | string): Promise<SignedTxArtifact>;
+    /**
+     * Fetches the current status of a transaction by ID.
+     */
+    status(txId: string): Promise<any>;
+}
+
+/**
+ * HardKAS L2 Module
+ * @alpha
+ */
+declare class HardkasL2 {
+    /**
+     * Lists all available L2 network profiles.
+     */
+    listProfiles(): readonly L2NetworkProfile[];
+    /**
+     * Gets a specific L2 network profile by name.
+     */
+    getProfile(name: string): L2NetworkProfile | null;
+}
+
+/**
+ * HardKAS Operational Query Module
+ *
+ * Note: readEvents, correlate, and correlation types were removed from
+ * @hardkas/query. These will be re-implemented when the query API stabilizes.
+ * @alpha
+ */
+declare class HardkasQuery {
+    private sdk;
+    private _engine;
+    constructor(sdk: Hardkas);
+    /**
+     * Internal lazy-loaded query engine.
+     */
+    private getEngine;
+    /**
+     * Synchronizes the query store with the filesystem artifacts.
+     */
+    sync(options?: {
+        force?: boolean;
+    }): Promise<any>;
+    /**
+     * Fetches events from the query store.
+     */
+    events(filter?: {
+        domain?: string;
+        kind?: string;
+        correlationId?: string;
+        artifactId?: string;
+    }): Promise<readonly EventEnvelope[]>;
+}
+
+/**
+ * HardKAS Localnet Simulation Module
+ */
+declare class HardkasLocalnet {
+    private sdk;
+    constructor(sdk: Hardkas);
+    /**
+     * Status check for the localnet simulation.
+     */
+    isAlive(): Promise<boolean>;
+    /**
+     * Future: control localnet process/container from here.
+     */
+    start(): Promise<void>;
+    /**
+     * Resets the localnet state (simulated or node).
+     */
+    reset(): Promise<void>;
+}
+
+interface ReplayVerifyOptions {
+    path?: string;
+    workflowId?: string;
+}
+interface ReplayVerifyResult {
+    passed: boolean;
+    artifactsScanned: number;
+    lineage: "valid" | "invalid";
+    determinism: "verified" | "failed";
+    contamination: "clean" | "contaminated";
+    report: any;
+    error?: string;
+}
+declare class HardkasReplay {
+    private sdk;
+    constructor(sdk: Hardkas);
+    /**
+     * Verifies the deterministic artifact lineage of a transaction replay
+     * against the mathematically reconstructed localnet state.
+     */
+    verify(targetOrOptions?: string | {
+        schema?: string;
+        artifactId?: string;
+    } | ReplayVerifyOptions, options?: ReplayVerifyOptions): Promise<ReplayVerifyResult>;
+}
+
+/**
+ * HardKAS Lineage Module
+ * @alpha
+ */
+declare class HardkasLineage {
+    private sdk;
+    constructor(sdk: Hardkas);
+    /**
+     * Traces the lineage of an artifact, identifying ancestors and descendants.
+     */
+    trace(target: string | {
+        artifactId?: string;
+        contentHash?: string;
+    }, options?: {
+        direction?: "ancestors" | "descendants";
+    }): Promise<any>;
+}
+
+/**
+ * Deterministic Workspace Abstraction.
+ * Encapsulates all filesystem boundary interactions and isolates paths
+ * from the global process.cwd(), ensuring agent/script replayability.
+ */
+declare class HardkasWorkspace {
+    readonly root: string;
+    constructor(cwd: string);
+    get hardkasDir(): string;
+    get artifactsDir(): string;
+    get localnetStatePath(): string;
+    get keystoreDir(): string;
+    /**
+     * Safely resolves a path relative to the workspace root.
+     */
+    resolvePath(...segments: string[]): string;
+    /**
+     * Safely builds a relative path from the workspace root to the target.
+     */
+    relativeFromRoot(absolutePath: string): string;
+    /**
+     * Ensures the core .hardkas directory exists.
+     */
+    ensureHardkasDir(): void;
+}
+
+interface WriteArtifactOptions {
+    /**
+     * Explicitly override the canonical artifacts directory.
+     * By default, it writes to sdk.workspace.artifactsDir.
+     */
+    outputDir?: string;
+    /**
+     * Explicitly override the default filename.
+     * By default, it generates `${schema}-${contentHash}.json`
+     */
+    fileName?: string;
+    /**
+     * If true, verifies integrity and schema but does not touch the filesystem.
+     * Useful for Agent planning or previews.
+     */
+    dryRun?: boolean;
+    /** Telemetry for Event Sourcing */
+    workflowId?: string;
+    correlationId?: string;
+    networkId?: string;
+}
+interface WriteArtifactResult {
+    absolutePath?: string;
+    dryRun: boolean;
+    contentHash: string;
+}
+/**
+ * Deterministic Artifact I/O boundary.
+ */
+declare class HardkasArtifactsManager {
+    private workspace;
+    private cache;
+    constructor(workspace: HardkasWorkspace);
+    /**
+     * Caches an in-memory artifact.
+     */
+    cacheArtifact(artifact: any): void;
+    /**
+     * Writes a valid artifact to disk (canonical or custom path).
+     */
+    write(artifact: HardkasArtifactBase, options?: WriteArtifactOptions): Promise<WriteArtifactResult>;
+    /**
+     * Retrieves an artifact from the in-memory cache.
+     */
+    getCached(id: string): any;
+    /**
+     * Reads an artifact by path or ID/hash from the workspace.
+     */
+    read(id: string, options?: {
+        expectedSchema?: string;
+    }): Promise<any>;
+    /**
+     * Alias for read().
+     */
+    get(id: string, options?: {
+        expectedSchema?: string;
+    }): Promise<any>;
+    /**
+     * Lists all artifacts in the workspace.
+     */
+    list(): Promise<any[]>;
+    /**
+     * Cryptographically verifies the determinism and integrity of an artifact.
+     * Throws an error with details if corruption or mismatch is found.
+     */
+    verify(target: any, options?: {
+        throwOnInvalid?: boolean;
+        strict?: boolean;
+        enforceMetadata?: boolean;
+    }): Promise<any>;
+    /**
+     * Migrates a legacy artifact to v4 using a migration receipt.
+     */
+    migrate(target: any, migrationId: string): Promise<{
+        migrated: any;
+        receipt: any;
+    }>;
+}
+
+interface WorkflowRunOptions {
+    steps: Array<{
+        type: string;
+        [key: string]: any;
+    }>;
+    dryRun?: boolean;
+}
+declare class HardkasWorkflow {
+    private readonly sdk;
+    constructor(sdk: Hardkas);
+    /**
+     * Executes a sequence of declarative steps and returns a definitive WorkflowArtifact.
+     */
+    run(options: WorkflowRunOptions): Promise<WorkflowArtifact>;
+}
+
+interface TaskArgs {
+    [key: string]: string | boolean | undefined;
+}
+interface TaskContext {
+    hardkas: Hardkas;
+    args: TaskArgs;
+}
+type TaskAction = (ctx: TaskContext) => Promise<void>;
+/**
+ * Defines a new HardKAS task.
+ * Used in hardkas.config.ts to extend CLI functionality.
+ */
+declare const defineTask: {
+    (name: string, action: TaskAction): void;
+    (name: string, description: string, action: TaskAction): void;
+};
+
+interface HardkasOptions {
+    cwd?: string;
+    configPath?: string;
+    mode?: "developer" | "agent";
+    network?: string;
+    autoBootstrap?: boolean;
+    signer?: ExternalHardkasSigner;
+    logger?: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug: (msg: string) => void;
+        [key: string]: any;
+    };
+    policy?: {
+        allowNetwork?: boolean;
+        allowMainnet?: boolean;
+        allowExternalWallet?: boolean;
+        requireDryRun?: boolean;
+    };
+}
+/**
+ * HardKAS SDK - Main Entry Point
+ *
+ * Provides a high-level facade for interacting with the Kaspa ecosystem.
+ * Acts as a DI container and coordinator.
+ */
+declare class Hardkas {
+    readonly config: LoadedHardkasConfig;
+    readonly workspace: HardkasWorkspace;
+    readonly artifacts: HardkasArtifactsManager;
+    readonly accounts: HardkasAccounts;
+    readonly tx: HardkasTx;
+    readonly l2: HardkasL2;
+    readonly query: HardkasQuery;
+    readonly localnet: HardkasLocalnet;
+    readonly replay: HardkasReplay;
+    readonly lineage: HardkasLineage;
+    readonly workflow: HardkasWorkflow;
+    readonly signer?: ExternalHardkasSigner | undefined;
+    readonly mode: "developer" | "agent";
+    readonly policy: Required<NonNullable<HardkasOptions["policy"]>>;
+    readonly rpc: KaspaRpcClient;
+    private constructor();
+    private resolveRpcUrl;
+    /**
+     * Opens a HardKAS project in the given directory.
+     */
+    static open(dirOrOptions?: string | HardkasOptions): Promise<Hardkas>;
+    /**
+     * Alias for open(). Used in most examples.
+     */
+    static create(dirOrOptions?: string | HardkasOptions): Promise<Hardkas>;
+    /**
+     * Current active network name.
+     */
+    get network(): NetworkId;
+    get sdkConfig(): _hardkas_config.HardkasConfig;
+    get cwd(): string;
+    /**
+     * Validates an action against the active security policy.
+     * Throws HardkasError if the policy is violated.
+     */
+    enforcePolicy(action: "network" | "mainnet" | "external-wallet" | "mutation", context?: string): void;
+}
+
+export { Hardkas, HardkasAccounts, HardkasArtifactsManager, HardkasL2, HardkasLineage, HardkasLocalnet, type HardkasOptions, HardkasQuery, HardkasReplay, HardkasTx, HardkasWorkspace, type TaskArgs, type TaskContext, defineTask };

package/dist/index.js

@@ -23,7 +23,7 @@ var HardkasAccounts = class {
   async resolve(nameOrAddress) {
     return resolveHardkasAccount({
       nameOrAddress,
-      config: this.sdk.config.config
+      config: { ...this.sdk.config.config, cwd: this.sdk.workspace.root }
     });
   }
   /**
@@ -106,7 +106,7 @@ import {
   getBroadcastableSignedTransaction
 } from "@hardkas/artifacts";
 import { coreEvents } from "@hardkas/core";
-import { signTxPlanArtifact } from "@hardkas/accounts";
+import { signTxPlanArtifact, validateAddressNetwork } from "@hardkas/accounts";
 import { parseKasToSompi } from "@hardkas/core";
 function normalizeSimulatedPlanInput(target, fallbackId) {
   if (target.schema === ARTIFACT_SCHEMAS.TX_PLAN && Array.isArray(target.inputs)) {
@@ -158,15 +158,21 @@ var HardkasTx = class {
     if (amountSompi === 0n) {
       throw new Error("Kaspa value-transfer outputs require amount > 0.\nFor metadata/notary/DID marker transactions use --amount 1.\nFuture: hardkas tx anchor.");
     }
-    let builderUtxos = [];
     const activeNetwork = this.sdk.config.config.defaultNetwork || "simnet";
+    const allowMainnet = this.sdk.config.config.networks?.mainnet?.allowMainnet === true;
+    validateAddressNetwork(fromAccount.address, activeNetwork, allowMainnet);
+    validateAddressNetwork(toAccount.address, activeNetwork, allowMainnet);
+    if (options.changeAddress) {
+      validateAddressNetwork(options.changeAddress, activeNetwork, allowMainnet);
+    }
+    let allFetchedUtxos = [];
     if (activeNetwork === "simulated" || this.sdk.config.config.networks?.[activeNetwork]?.kind === "simulated") {
       const { loadOrCreateLocalnetState, getSpendableUtxos } = await import("@hardkas/localnet");
       const localState = await loadOrCreateLocalnetState({
         cwd: this.sdk.workspace.root
       });
       const unspent = getSpendableUtxos(localState, fromAccount.address);
-      builderUtxos = unspent.map((u) => {
+      allFetchedUtxos = unspent.map((u) => {
         const parts = u.id.split(":");
         const index = Number(parts[parts.length - 1]);
         const transactionId = parts.slice(0, -1).join(":");
@@ -179,16 +185,52 @@ var HardkasTx = class {
       });
     } else {
       const rpcUtxos = await this.sdk.rpc.getUtxosByAddress(fromAccount.address);
-      builderUtxos = rpcUtxos.map((u) => ({
+      allFetchedUtxos = rpcUtxos.map((u) => ({
         outpoint: {
           transactionId: u.outpoint.transactionId,
           index: u.outpoint.index
         },
         address: u.address,
-        amountSompi: u.amountSompi,
+        amountSompi: BigInt(u.amountSompi),
         scriptPublicKey: u.scriptPublicKey || ""
       }));
     }
+    const sortedUtxos = [...allFetchedUtxos].sort((a, b) => {
+      if (a.amountSompi > b.amountSompi) return -1;
+      if (a.amountSompi < b.amountSompi) return 1;
+      return 0;
+    });
+    const MAX_INPUTS_PER_TX = 512;
+    const WARN_INPUTS = 128;
+    const HARD_LIMIT = 1e3;
+    const MARGIN_FEE_PER_INPUT = 1500n * (options.feeRate ?? 1n);
+    let selectedAmount = 0n;
+    let selectedInputsCount = 0;
+    const builderUtxos = [];
+    for (const utxo of sortedUtxos) {
+      builderUtxos.push(utxo);
+      selectedAmount += utxo.amountSompi;
+      selectedInputsCount++;
+      const requiredTotal = amountSompi + BigInt(selectedInputsCount) * MARGIN_FEE_PER_INPUT;
+      if (selectedAmount >= requiredTotal) {
+        break;
+      }
+      if (selectedInputsCount >= HARD_LIMIT) {
+        break;
+      }
+    }
+    if (selectedAmount < amountSompi) {
+      throw new Error(`Insufficient funds: needed ${amountSompi} sompi but only found ${selectedAmount} sompi across ${selectedInputsCount} UTXOs.`);
+    }
+    if (selectedInputsCount > MAX_INPUTS_PER_TX) {
+      const err = new Error(`TOO_MANY_INPUTS_FOR_SINGLE_TX: Transaction requires ${selectedInputsCount} inputs to cover the amount, which exceeds the safe limit of ${MAX_INPUTS_PER_TX} inputs.
+Hint: Run 'hardkas accounts consolidate' to merge dust UTXOs.`);
+      err.code = "TOO_MANY_INPUTS_FOR_SINGLE_TX";
+      throw err;
+    }
+    if (selectedInputsCount >= WARN_INPUTS) {
+      console.warn(`\u26A0\uFE0F  WARNING: Transaction requires ${selectedInputsCount} inputs. Consider running 'hardkas accounts consolidate'.`);
+    }
     const builderPlan = buildPaymentPlan({
       fromAddress: fromAccount.address,
       availableUtxos: builderUtxos,
@@ -228,7 +270,12 @@ var HardkasTx = class {
       ctx: {
         ...systemRuntimeContext,
         ...options.workflowId ? { workflowId: options.workflowId } : {},
-        assumptionLevel: resolvedAssumptionLevel
+        assumptionLevel: resolvedAssumptionLevel,
+        utxoSelection: {
+          totalUtxosSeen: allFetchedUtxos.length,
+          selectedUtxos: selectedInputsCount,
+          selectionStrategy: "largest-first"
+        }
       }
     });
     if (options.policy || options.policies) {
@@ -281,6 +328,96 @@ var HardkasTx = class {
     }
     return basePlan;
   }
+  /**
+   * Creates a transaction plan explicitly for consolidation.
+   * This overrides normal selection logic and uses precisely the provided UTXOs.
+   */
+  async createConsolidationPlan(options) {
+    let resolvedAccount;
+    if (typeof options.account === "string") {
+      resolvedAccount = await this.sdk.accounts.resolve(options.account);
+    } else {
+      resolvedAccount = options.account;
+    }
+    if (!resolvedAccount.address) {
+      throw new Error(`Account '${resolvedAccount.name || options.account}' has no address.`);
+    }
+    const activeNetwork = options.network || this.sdk.config.config.defaultNetwork || "simnet";
+    const isSimulated = activeNetwork === "simulated" || this.sdk.config.config.networks?.[activeNetwork]?.kind === "simulated";
+    let totalAmount = 0n;
+    const builderUtxos = options.selectedUtxos.map((u) => {
+      const amount = BigInt(u.amountSompi);
+      totalAmount += amount;
+      return {
+        outpoint: {
+          transactionId: u.outpoint.transactionId,
+          index: u.outpoint.index
+        },
+        address: u.address,
+        amountSompi: amount,
+        scriptPublicKey: u.scriptPublicKey || ""
+      };
+    });
+    const feeRate = options.feeRate ?? 1n;
+    const massPerInput = 1500n;
+    const estimatedMass = BigInt(options.selectedUtxos.length) * massPerInput + 500n;
+    const expectedFee = estimatedMass * feeRate;
+    if (totalAmount <= expectedFee) {
+      throw new Error(`Consolidation failed: Total selected UTXO amount (${totalAmount}) is less than or equal to the estimated fee (${expectedFee}).`);
+    }
+    const outputAmount = totalAmount - expectedFee;
+    const builderPlan = buildPaymentPlan({
+      fromAddress: resolvedAccount.address,
+      availableUtxos: builderUtxos,
+      outputs: [
+        {
+          address: options.destination,
+          amountSompi: outputAmount
+        }
+      ],
+      feeRateSompiPerMass: feeRate
+    });
+    let resolvedAssumptionLevel = isSimulated ? "local-simulated" : "local-rpc";
+    const basePlan = createTxPlanArtifact({
+      networkId: activeNetwork,
+      mode: isSimulated ? "simulated" : "real",
+      from: {
+        input: resolvedAccount.name || resolvedAccount.address,
+        address: resolvedAccount.address,
+        accountName: resolvedAccount.name
+      },
+      to: {
+        input: options.destination,
+        address: options.destination
+      },
+      amountSompi: outputAmount,
+      plan: builderPlan,
+      ctx: {
+        ...systemRuntimeContext,
+        assumptionLevel: resolvedAssumptionLevel,
+        utxoSelection: {
+          strategy: "consolidation-smallest-first",
+          totalUtxosSeen: options.totalUtxosSeen ?? options.selectedUtxos.length,
+          selectedUtxos: options.selectedUtxos.length,
+          purpose: "wallet-consolidation"
+        }
+      }
+    });
+    const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2, calculateContentHash: calculateContentHash2 } = await import("@hardkas/artifacts");
+    const newHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+    basePlan.contentHash = newHash;
+    if (basePlan.lineage) {
+      basePlan.lineage.lineageId = newHash;
+      basePlan.lineage.parentArtifactId = "";
+      basePlan.lineage.rootArtifactId = newHash;
+      const finalHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+      basePlan.contentHash = finalHash;
+      basePlan.lineage.artifactId = finalHash;
+      basePlan.planId = `plan-${finalHash.slice(0, 16)}`;
+    }
+    this.sdk.artifacts.cacheArtifact(basePlan);
+    return basePlan;
+  }
   /**
    * Signs a transaction plan.
    */
@@ -655,7 +792,6 @@ var HardkasTx = class {
       ...planArtifact.policyRefs ? { policyRefs: planArtifact.policyRefs } : {},
       ...planArtifact.networkProfileRef ? { networkProfileRef: planArtifact.networkProfileRef } : {},
       ...planArtifact.assumptionRef ? { assumptionRef: planArtifact.assumptionRef } : {},
-      sourceSignedId: signedId !== "unknown" ? signedId : void 0,
       lineage: {
         artifactId: "",
         // To be computed
@@ -822,7 +958,6 @@ var HardkasTx = class {
       ...signedArtifact.policyRefs ? { policyRefs: signedArtifact.policyRefs } : {},
       ...signedArtifact.networkProfileRef ? { networkProfileRef: signedArtifact.networkProfileRef } : {},
       ...signedArtifact.assumptionRef ? { assumptionRef: signedArtifact.assumptionRef } : {},
-      sourceSignedId: signedArtifact.contentHash || signedArtifact.signedId,
       tracePath: void 0,
       lineage: createLineageTransition(signedArtifact, "hardkas.txReceipt")
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/sdk",
-  "version": "0.8.16-alpha",
+  "version": "0.8.19-alpha",
   "type": "module",
   "files": [
     "dist",
@@ -24,18 +24,18 @@
   },
   "dependencies": {
     "@kaspa/core-lib": "^1.6.5",
-    "@hardkas/accounts": "0.8.16-alpha",
-    "@hardkas/config": "0.8.16-alpha",
-    "@hardkas/artifacts": "0.8.16-alpha",
-    "@hardkas/core": "0.8.16-alpha",
-    "@hardkas/kaspa-rpc": "0.8.16-alpha",
-    "@hardkas/l2": "0.8.16-alpha",
-    "@hardkas/localnet": "0.8.16-alpha",
-    "@hardkas/query-store": "0.8.16-alpha",
-    "@hardkas/query": "0.8.16-alpha",
-    "@hardkas/tx-builder": "0.8.16-alpha",
-    "@hardkas/simulator": "0.8.16-alpha",
-    "@hardkas/wallet-adapter": "0.8.16-alpha"
+    "@hardkas/accounts": "0.8.19-alpha",
+    "@hardkas/config": "0.8.19-alpha",
+    "@hardkas/artifacts": "0.8.19-alpha",
+    "@hardkas/core": "0.8.19-alpha",
+    "@hardkas/kaspa-rpc": "0.8.19-alpha",
+    "@hardkas/l2": "0.8.19-alpha",
+    "@hardkas/query": "0.8.19-alpha",
+    "@hardkas/localnet": "0.8.19-alpha",
+    "@hardkas/query-store": "0.8.19-alpha",
+    "@hardkas/simulator": "0.8.19-alpha",
+    "@hardkas/tx-builder": "0.8.19-alpha",
+    "@hardkas/wallet-adapter": "0.8.19-alpha"
   },
   "devDependencies": {
     "@types/node": "^20.12.7",