@hardkas/sdk 0.7.3-alpha → 0.7.5-alpha

package/dist/{chunk-RCCELGL3.js → chunk-V32UCCTZ.js}

@@ -18,7 +18,11 @@ function createHardkasClient(options = {}) {
         ok: false,
         error: { code: "FETCH_FAILED", message: e.message },
         warnings: [],
-        meta: { workspace: "unknown", network: options.network || "simulated", mode: "unknown" }
+        meta: {
+          workspace: "unknown",
+          network: options.network || "simulated",
+          mode: "unknown"
+        }
       };
     }
   }
@@ -76,7 +80,10 @@ function createHardkasClient(options = {}) {
     },
     workflow: {
       transfer: (params) => {
-        return fetchApi("/api/tx/send", { method: "POST", body: JSON.stringify(params) });
+        return fetchApi("/api/tx/send", {
+          method: "POST",
+          body: JSON.stringify(params)
+        });
       }
     },
     localnet: {
@@ -88,11 +95,20 @@ function createHardkasClient(options = {}) {
     session: {
       start: () => fetchApi("/api/session/start", { method: "POST" }),
       snapshot: () => fetchApi("/api/session/snapshot", { method: "POST" }),
-      replay: (options2) => fetchApi("/api/session/replay", { method: "POST", body: JSON.stringify(options2 || {}) }),
+      replay: (options2) => fetchApi("/api/session/replay", {
+        method: "POST",
+        body: JSON.stringify(options2 || {})
+      }),
       diffReplay: (artifactId) => fetchApi(`/api/session/diff-replay/${artifactId}`, { method: "POST" }),
-      timeTravel: (artifactId) => fetchApi("/api/session/time-travel", { method: "POST", body: JSON.stringify({ artifactId }) }),
+      timeTravel: (artifactId) => fetchApi("/api/session/time-travel", {
+        method: "POST",
+        body: JSON.stringify({ artifactId })
+      }),
       export: () => fetchApi("/api/session/export"),
-      import: (data, force) => fetchApi("/api/session/import", { method: "POST", body: JSON.stringify({ data, force }) })
+      import: (data, force) => fetchApi("/api/session/import", {
+        method: "POST",
+        body: JSON.stringify({ data, force })
+      })
     }
   };
 }

package/dist/client.js

@@ -1,6 +1,6 @@
 import {
   createHardkasClient
-} from "./chunk-RCCELGL3.js";
+} from "./chunk-V32UCCTZ.js";
 export {
   createHardkasClient
 };

package/dist/index.d.ts

@@ -47,11 +47,16 @@ declare class HardkasTx {
         to: string | HardkasAccount;
         amount: string | bigint;
         feeRate?: bigint;
+        workflowId?: string;
     }): Promise<TxPlanArtifact>;
     /**
      * Signs a transaction plan.
      */
-    sign(plan: TxPlanArtifact, account?: HardkasAccount | string): Promise<SignedTxArtifact>;
+    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.
@@ -202,6 +207,7 @@ interface WriteArtifactResult {
  */
 declare class HardkasArtifactsManager {
     private workspace;
+    private cache;
     constructor(workspace: HardkasWorkspace);
     /**
      * Writes a valid artifact to disk (canonical or custom path).

package/dist/index.js

@@ -1,16 +1,16 @@
 import {
   createHardkasClient
-} from "./chunk-RCCELGL3.js";
+} from "./chunk-V32UCCTZ.js";
 
 // src/index.ts
-import { loadHardkasConfig as loadConfig } from "@hardkas/config";
+import {
+  loadHardkasConfig as loadConfig
+} from "@hardkas/config";
 import { JsonWrpcKaspaClient } from "@hardkas/kaspa-rpc";
 import { HardkasError as HardkasError2 } from "@hardkas/core";
 
 // src/accounts.ts
-import {
-  resolveHardkasAccount
-} from "@hardkas/accounts";
+import { resolveHardkasAccount } from "@hardkas/accounts";
 import { formatSompi } from "@hardkas/core";
 var HardkasAccounts = class {
   constructor(sdk) {
@@ -31,7 +31,8 @@ var HardkasAccounts = class {
    */
   async getBalance(accountNameOrAddress) {
     const account = await this.resolve(accountNameOrAddress);
-    if (!account.address) throw new Error(`Account ${accountNameOrAddress} has no address`);
+    if (!account.address)
+      throw new Error(`Account ${accountNameOrAddress} has no address`);
     const { balanceSompi } = await this.sdk.rpc.getBalanceByAddress(account.address);
     const sompi = BigInt(balanceSompi);
     return {
@@ -72,13 +73,17 @@ var HardkasTx = class {
   async plan(options) {
     const fromAccount = typeof options.from === "string" ? await this.sdk.accounts.resolve(options.from) : options.from;
     const toAccount = typeof options.to === "string" ? await this.sdk.accounts.resolve(options.to) : options.to;
-    if (!fromAccount.address) throw new Error(`From account ${fromAccount.name} has no address.`);
-    if (!toAccount.address) throw new Error(`To account ${toAccount.name} has no address.`);
+    if (!fromAccount.address)
+      throw new Error(`From account ${fromAccount.name} has no address.`);
+    if (!toAccount.address)
+      throw new Error(`To account ${toAccount.name} has no address.`);
     const amountSompi = typeof options.amount === "string" ? parseKasToSompi(options.amount) : typeof options.amount === "number" ? BigInt(options.amount) : options.amount;
     let builderUtxos = [];
     if (this.sdk.network === "simulated") {
       const { loadOrCreateLocalnetState, getSpendableUtxos } = await import("@hardkas/localnet");
-      const localState = await loadOrCreateLocalnetState({ cwd: this.sdk.workspace.root });
+      const localState = await loadOrCreateLocalnetState({
+        cwd: this.sdk.workspace.root
+      });
       const unspent = getSpendableUtxos(localState, fromAccount.address);
       builderUtxos = unspent.map((u) => {
         const parts = u.id.split(":");
@@ -106,10 +111,12 @@ var HardkasTx = class {
     const builderPlan = buildPaymentPlan({
       fromAddress: fromAccount.address,
       availableUtxos: builderUtxos,
-      outputs: [{
-        address: toAccount.address,
-        amountSompi
-      }],
+      outputs: [
+        {
+          address: toAccount.address,
+          amountSompi
+        }
+      ],
       feeRateSompiPerMass: options.feeRate ?? 1n
     });
     return createTxPlanArtifact({
@@ -126,27 +133,215 @@ var HardkasTx = class {
       },
       amountSompi,
       plan: builderPlan,
-      ctx: systemRuntimeContext
+      ctx: options.workflowId ? { ...systemRuntimeContext, workflowId: options.workflowId } : systemRuntimeContext
     });
   }
   /**
    * Signs a transaction plan.
    */
-  async sign(plan, account) {
+  async sign(plan, account, options) {
     let resolvedAccount;
     if (typeof account === "string") {
       resolvedAccount = await this.sdk.accounts.resolve(account);
     } else if (account) {
       resolvedAccount = account;
     } else {
-      if (!plan.from.accountName) throw new Error("Plan does not specify an account name and no account was provided for signing.");
-      resolvedAccount = await this.sdk.accounts.resolve(plan.from.accountName);
+      const fromName = plan.from?.accountName || plan.from?.input || plan.from?.address;
+      if (!fromName)
+        throw new Error(
+          "Plan does not specify an account name and no account was provided for signing."
+        );
+      resolvedAccount = await this.sdk.accounts.resolve(fromName);
     }
-    return signTxPlanArtifact({
-      planArtifact: plan,
-      account: resolvedAccount,
-      config: this.sdk.config.config
+    let signedArtifact;
+    if (plan.schema === "hardkas.signedTx") {
+      if (plan.status === "signed") {
+        throw new Error(
+          "Cannot append signature to an already completed signed transaction."
+        );
+      }
+      if (!options?.append) {
+        throw new Error(
+          "Input file is a partially signed transaction. Use the --append flag to add your signature."
+        );
+      }
+      const partialTx = plan;
+      if (!partialTx.multisig) {
+        throw new Error(
+          "Input file is a signed transaction but does not contain multisig configuration."
+        );
+      }
+      const signerAddress = resolvedAccount.address;
+      if (!signerAddress) {
+        throw new Error(`Signer account '${resolvedAccount.name}' has no address.`);
+      }
+      const required = partialTx.multisig.requiredSigners;
+      if (required && required.length > 0 && !required.includes(signerAddress)) {
+        throw new Error(
+          `Signer '${signerAddress}' is not an authorized signer for this transaction.`
+        );
+      }
+      const sigs = partialTx.multisig.signatures || [];
+      if (sigs.some((s) => s.signer === signerAddress)) {
+        throw new Error(
+          `Account '${signerAddress}' has already signed this transaction.`
+        );
+      }
+      const signatureEntry = {
+        signer: signerAddress,
+        signature: `simulated-signature-of-${signerAddress}`
+      };
+      const newSignatures = [...sigs, signatureEntry].sort(
+        (a, b) => a.signer.localeCompare(b.signer)
+      );
+      const newMeta = [
+        ...partialTx.signatureMetadata || [],
+        {
+          signer: signerAddress,
+          signedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      const thresholdReached = newSignatures.length >= partialTx.multisig.threshold;
+      const finalStatus = thresholdReached ? "signed" : "partially_signed";
+      const draft = {
+        ...partialTx,
+        status: finalStatus,
+        multisig: {
+          ...partialTx.multisig,
+          signatures: newSignatures
+        },
+        signatureMetadata: newMeta,
+        lineage: {
+          artifactId: "",
+          // To be computed from contentHash
+          lineageId: partialTx.lineage?.lineageId || `lineage-${Math.random().toString(36).slice(2, 10)}`,
+          parentArtifactId: partialTx.contentHash || partialTx.signedId,
+          rootArtifactId: partialTx.lineage?.rootArtifactId || partialTx.sourcePlanId
+        }
+      };
+      if (thresholdReached) {
+        draft.signedTransaction = {
+          format: "simulated",
+          payload: `simulated-signed-tx:${partialTx.sourcePlanId}-with-${newSignatures.map((s) => s.signer).join(",")}`
+        };
+        draft.txId = `simulated-${partialTx.sourcePlanId}-tx`;
+      } else {
+        delete draft.signedTransaction;
+        delete draft.txId;
+      }
+      const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2 } = await import("@hardkas/artifacts");
+      const hash = calculateContentHash(draft, CURRENT_HASH_VERSION2);
+      draft.signedId = `signed-${hash.slice(0, 16)}`;
+      draft.contentHash = hash;
+      if (draft.lineage) draft.lineage.artifactId = draft.signedId;
+      signedArtifact = draft;
+    } else if (plan.schema === "hardkas.txPlan") {
+      if (options?.append) {
+        throw new Error(
+          "Do not use --append for the first signature of a transaction plan."
+        );
+      }
+      const threshold = options?.threshold || 1;
+      if (threshold > 1) {
+        const signerAddress = resolvedAccount.address;
+        if (!signerAddress) {
+          throw new Error(`Signer account '${resolvedAccount.name}' has no address.`);
+        }
+        const requiredSigners = options?.requiredSigners || [signerAddress];
+        if (!requiredSigners.includes(signerAddress)) {
+          throw new Error(
+            `Signer '${signerAddress}' is not an authorized signer for this transaction.`
+          );
+        }
+        const signatureEntry = {
+          signer: signerAddress,
+          signature: `simulated-signature-of-${signerAddress}`
+        };
+        const signatures = [signatureEntry].sort(
+          (a, b) => a.signer.localeCompare(b.signer)
+        );
+        const signatureMetadata = [
+          {
+            signer: signerAddress,
+            signedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ];
+        const thresholdReached = signatures.length >= threshold;
+        const finalStatus = thresholdReached ? "signed" : "partially_signed";
+        const { HARDKAS_VERSION: HARDKAS_VERSION4, ARTIFACT_VERSION: ARTIFACT_VERSION2, CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2 } = await import("@hardkas/artifacts");
+        const draft = {
+          schema: "hardkas.signedTx",
+          schemaVersion: "hardkas.artifact.v1",
+          hardkasVersion: HARDKAS_VERSION4,
+          version: ARTIFACT_VERSION2,
+          hashVersion: CURRENT_HASH_VERSION2,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status: finalStatus,
+          sourcePlanId: plan.planId,
+          networkId: plan.networkId,
+          mode: plan.mode,
+          from: plan.from,
+          to: plan.to,
+          amountSompi: plan.amountSompi,
+          unsignedPayloadHash: plan.contentHash,
+          multisig: {
+            threshold,
+            requiredSigners,
+            signatures
+          },
+          signatureMetadata,
+          lineage: {
+            artifactId: "",
+            // To be computed
+            lineageId: plan.lineage?.lineageId || `lineage-${Math.random().toString(36).slice(2, 10)}`,
+            parentArtifactId: plan.contentHash || plan.planId,
+            rootArtifactId: plan.contentHash || plan.planId
+          },
+          ...plan.workflowId ? { workflowId: plan.workflowId } : {}
+        };
+        if (thresholdReached) {
+          draft.signedTransaction = {
+            format: "simulated",
+            payload: `simulated-signed-tx:${plan.planId}-with-${signatures.map((s) => s.signer).join(",")}`
+          };
+          draft.txId = `simulated-${plan.planId}-tx`;
+        }
+        const hash = calculateContentHash(draft, CURRENT_HASH_VERSION2);
+        draft.signedId = `signed-${hash.slice(0, 16)}`;
+        draft.contentHash = hash;
+        if (draft.lineage) draft.lineage.artifactId = draft.signedId;
+        signedArtifact = draft;
+      } else {
+        signedArtifact = await signTxPlanArtifact({
+          planArtifact: plan,
+          account: resolvedAccount,
+          config: this.sdk.config.config,
+          allowMainnet: false
+        });
+      }
+    } else {
+      throw new Error(`Unsupported artifact schema for signing: ${plan.schema}`);
+    }
+    const { absolutePath } = await this.sdk.artifacts.write(signedArtifact);
+    const { coreEvents: coreEvents2 } = await import("@hardkas/core");
+    const signedRecord = signedArtifact;
+    const artifactId = signedRecord.artifactId || signedArtifact.signedId || signedRecord.contentHash;
+    coreEvents2.normalizeAndEmit({
+      kind: "artifact.created",
+      schema: signedArtifact.schema,
+      artifactId,
+      network: signedArtifact.networkId,
+      mode: signedArtifact.mode,
+      path: absolutePath
+    });
+    coreEvents2.normalizeAndEmit({
+      kind: "tx.signed",
+      txId: signedArtifact.txId || artifactId,
+      network: signedArtifact.networkId,
+      mode: signedArtifact.mode,
+      amountSompi: signedArtifact.amountSompi
     });
+    return signedArtifact;
   }
   /**
    * Simulates a transaction on the local state without broadcasting to a real Kaspa node.
@@ -156,7 +351,8 @@ var HardkasTx = class {
     const {
       loadOrCreateLocalnetState,
       saveLocalnetState,
-      applySimulatedPayment,
+      getDefaultLocalnetStatePath,
+      applySimulatedPlan,
       saveSimulatedReceipt,
       saveSimulatedTrace
     } = await import("@hardkas/localnet");
@@ -166,22 +362,31 @@ var HardkasTx = class {
     const events = [
       { type: "phase.started", phase: "send", timestamp: startTime }
     ];
-    const simResult = applySimulatedPayment(state, {
-      from: signedArtifact.from.input || signedArtifact.from.address,
-      to: signedArtifact.to.input || signedArtifact.to.address,
-      amountSompi: BigInt(signedArtifact.amountSompi)
-    }, systemRuntimeContext);
+    const planArtifact = await this.sdk.artifacts.read(signedArtifact.sourcePlanId);
+    const simResult = applySimulatedPlan(
+      state,
+      planArtifact,
+      systemRuntimeContext,
+      { txId: signedArtifact.txId || `simulated-${signedArtifact.sourcePlanId}-tx` }
+    );
+    if (!simResult.ok) {
+      throw new Error(`Strict validation failed: ${simResult.errors?.join(", ")}`);
+    }
     coreEvents.normalizeAndEmit({
       kind: "workflow.submitted",
       txId: simResult.receipt.txId,
       endpoint: "simulated://local"
     });
     events.push({ type: "phase.completed", phase: "send", timestamp: Date.now() });
-    await saveLocalnetState(simResult.state);
-    const receiptPath = await saveSimulatedReceipt(simResult.receipt);
+    await saveLocalnetState(simResult.state, getDefaultLocalnetStatePath(this.sdk.workspace.root));
+    const receiptPath = await saveSimulatedReceipt(
+      simResult.receipt,
+      { cwd: this.sdk.workspace.root }
+    );
     const tracePath = receiptPath.replace(".json", ".trace.json");
     const receiptBase = {
       schema: ARTIFACT_SCHEMAS.TX_RECEIPT,
+      schemaVersion: "hardkas.receipt.v1",
       hardkasVersion: HARDKAS_VERSION,
       version: ARTIFACT_VERSION,
       hashVersion: CURRENT_HASH_VERSION,
@@ -230,7 +435,7 @@ var HardkasTx = class {
       ...traceBase,
       events,
       receiptPath
-    });
+    }, { cwd: this.sdk.workspace.root });
     coreEvents.normalizeAndEmit({
       kind: "artifact.created",
       schema: receipt.schema,
@@ -259,7 +464,9 @@ var HardkasTx = class {
   async send(signedArtifact, url) {
     const verification = verifySignedTxSemantics(signedArtifact);
     if (!verification.ok) {
-      throw new Error(`Pre-broadcast semantic verification failed: ${verification.issues.map((i) => i.message).join(", ")}`);
+      throw new Error(
+        `Pre-broadcast semantic verification failed: ${verification.issues.map((i) => i.message).join(", ")}`
+      );
     }
     const broadcastable = getBroadcastableSignedTransaction(signedArtifact);
     const broadcastRecord = broadcastable.rawTransaction;
@@ -286,9 +493,13 @@ var HardkasTx = class {
       amountSompi: signedArtifact.amountSompi,
       feeSompi: signedArtifact.metadata?.estimatedFeeSompi || "0",
       submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...url ? { rpcUrl: url } : {}
+      ...url ? { rpcUrl: url } : {},
+      ...signedArtifact.workflowId ? { workflowId: signedArtifact.workflowId } : {}
     };
-    realReceiptBase.contentHash = calculateContentHash(realReceiptBase, CURRENT_HASH_VERSION);
+    realReceiptBase.contentHash = calculateContentHash(
+      realReceiptBase,
+      CURRENT_HASH_VERSION
+    );
     const receipt = realReceiptBase;
     const receiptPath = getDefaultReceiptPath(receipt.txId, this.sdk.config.cwd);
     await writeArtifact(receiptPath, receipt);
@@ -300,10 +511,7 @@ var HardkasTx = class {
 };
 
 // src/l2.ts
-import {
-  listL2Profiles,
-  getL2Profile
-} from "@hardkas/l2";
+import { listL2Profiles, getL2Profile } from "@hardkas/l2";
 var HardkasL2 = class {
   /**
    * Lists all available L2 network profiles.
@@ -386,7 +594,7 @@ var HardkasReplay = class {
   }
   sdk;
   /**
-   * Verifies the deterministic artifact lineage of a transaction replay 
+   * Verifies the deterministic artifact lineage of a transaction replay
    * against the mathematically reconstructed localnet state.
    */
   async verify(options) {
@@ -400,6 +608,17 @@ var HardkasReplay = class {
           planPath = fullPath;
           artifactDir = path.dirname(fullPath);
           receiptPath = fullPath.replace("tx-plan", "tx-receipt");
+          try {
+            let content = fs.readFileSync(fullPath, "utf-8");
+            if (content.charCodeAt(0) === 65279) {
+              content = content.slice(1);
+            }
+            const json = JSON.parse(content);
+            if (json && json.schema === "hardkas.workflow.v1" && json.workflowId) {
+              options.workflowId = json.workflowId;
+            }
+          } catch (e) {
+          }
         } else {
           artifactDir = fullPath;
           planPath = path.join(artifactDir, "tx-plan.json");
@@ -456,7 +675,12 @@ var HardkasReplay = class {
         if (json && json.schema && typeof json.schema === "string" && json.schema.startsWith("hardkas.")) {
           artifactCount++;
           if (isContaminated(json)) contaminationOk = false;
-          const isCoreArtifact = ["hardkas.txPlan", "hardkas.signedTx", "hardkas.txReceipt", "hardkas.snapshot"].includes(json.schema);
+          const isCoreArtifact = [
+            "hardkas.txPlan",
+            "hardkas.signedTx",
+            "hardkas.txReceipt",
+            "hardkas.snapshot"
+          ].includes(json.schema);
           if (isCoreArtifact) {
             const integrity = await verifyArtifactIntegrity(json);
             if (!integrity.ok) determinismOk = false;
@@ -477,7 +701,10 @@ var HardkasReplay = class {
       try {
         const wfArtifactPath = fs.readdirSync(this.sdk.workspace.artifactsDir).find((f) => f.includes(options.workflowId) && f.endsWith(".json"));
         if (!wfArtifactPath) throw new Error("Workflow artifact not found");
-        const wfArtifactStr = fs.readFileSync(path.join(this.sdk.workspace.artifactsDir, wfArtifactPath), "utf-8");
+        const wfArtifactStr = fs.readFileSync(
+          path.join(this.sdk.workspace.artifactsDir, wfArtifactPath),
+          "utf-8"
+        );
         const wfArtifact = JSON.parse(wfArtifactStr);
         if (wfArtifact.schema !== "hardkas.workflow.v1") {
           throw new Error(`Artifact ${options.workflowId} is not a workflow artifact`);
@@ -486,7 +713,10 @@ var HardkasReplay = class {
         for (const childId of childArtifacts) {
           const childFile = fs.readdirSync(this.sdk.workspace.artifactsDir).find((f) => f.includes(childId) && f.endsWith(".json"));
           if (!childFile) throw new Error(`Child artifact ${childId} not found`);
-          const childStr = fs.readFileSync(path.join(this.sdk.workspace.artifactsDir, childFile), "utf-8");
+          const childStr = fs.readFileSync(
+            path.join(this.sdk.workspace.artifactsDir, childFile),
+            "utf-8"
+          );
           const child = JSON.parse(childStr);
           const integrity = await verifyArtifactIntegrity(child);
           if (!integrity.ok) {
@@ -509,8 +739,10 @@ var HardkasReplay = class {
       }
     } else if (options.path) {
       try {
-        if (!fs.existsSync(planPath)) throw new Error(`Transaction plan artifact is missing at: ${planPath}`);
-        if (!fs.existsSync(receiptPath)) throw new Error(`Transaction receipt artifact is missing at: ${receiptPath}`);
+        if (!fs.existsSync(planPath))
+          throw new Error(`Transaction plan artifact is missing at: ${planPath}`);
+        if (!fs.existsSync(receiptPath))
+          throw new Error(`Transaction receipt artifact is missing at: ${receiptPath}`);
         plan = await readTxPlanArtifact(planPath);
         receipt = await readTxReceiptArtifact2(receiptPath);
       } catch (err) {
@@ -601,12 +833,17 @@ var HardkasArtifactsManager = class {
     this.workspace = workspace;
   }
   workspace;
+  cache = /* @__PURE__ */ new Map();
   /**
    * Writes a valid artifact to disk (canonical or custom path).
    */
   async write(artifact, options = {}) {
     const record = artifact;
     const hash = record.contentHash || "unknown";
+    if (record.planId) this.cache.set(record.planId, artifact);
+    if (record.signedId) this.cache.set(record.signedId, artifact);
+    if (record.txId) this.cache.set(record.txId, artifact);
+    this.cache.set(hash, artifact);
     if (options.dryRun) {
       return {
         dryRun: true,
@@ -636,18 +873,20 @@ var HardkasArtifactsManager = class {
     const cId = options.correlationId || wId;
     const netId = options.networkId || record.networkId || "unknown";
     const artifactId = record.artifactId || hash;
-    coreEvents2.emit(createEventEnvelope({
-      kind: "artifact.written",
-      domain: "integrity",
-      workflowId: asWorkflowId(wId),
-      correlationId: asCorrelationId(cId),
-      networkId: asNetworkId(netId),
-      payload: { artifactId: asArtifactId(artifactId), path: absolutePath },
-      sequenceNumber: asEventSequence(1),
-      globalOffset: 0,
-      sourceSubsystem: "sdk:artifacts-manager",
-      artifactId: asArtifactId(artifactId)
-    }));
+    coreEvents2.emit(
+      createEventEnvelope({
+        kind: "artifact.written",
+        domain: "integrity",
+        workflowId: asWorkflowId(wId),
+        correlationId: asCorrelationId(cId),
+        networkId: asNetworkId(netId),
+        payload: { artifactId: asArtifactId(artifactId), path: absolutePath },
+        sequenceNumber: asEventSequence(1),
+        globalOffset: 0,
+        sourceSubsystem: "sdk:artifacts-manager",
+        artifactId: asArtifactId(artifactId)
+      })
+    );
     return {
       absolutePath,
       dryRun: false,
@@ -658,6 +897,9 @@ var HardkasArtifactsManager = class {
    * Reads an artifact by path or ID/hash from the workspace.
    */
   async read(id) {
+    if (this.cache.has(id)) {
+      return this.cache.get(id);
+    }
     const { readArtifact } = await import("@hardkas/artifacts");
     let filePath = id;
     if (!fs3.existsSync(filePath)) {
@@ -682,7 +924,7 @@ var HardkasArtifactsManager = class {
 
 // src/workflow.ts
 import { HARDKAS_VERSION as HARDKAS_VERSION2 } from "@hardkas/artifacts";
-import { HardkasError } from "@hardkas/core";
+import { HardkasError, deterministicCompare } from "@hardkas/core";
 var HardkasWorkflow = class {
   constructor(sdk) {
     this.sdk = sdk;
@@ -723,60 +965,131 @@ var HardkasWorkflow = class {
     let errorEnvelope = void 0;
     let lastPlan = null;
     let lastSigned = null;
+    const stepsResults = {};
     for (const step of options.steps) {
       const startedAt = (/* @__PURE__ */ new Date()).toISOString();
       try {
         if (step.type === "simulate-failure") {
           if (this.sdk.mode === "agent") {
-            throw new HardkasError("POLICY_DENIED", "simulate-failure is strictly prohibited in agent mode");
+            throw new HardkasError(
+              "POLICY_DENIED",
+              "simulate-failure is strictly prohibited in agent mode"
+            );
           }
           throw new HardkasError("MOCKED_FAIL", "Simulated failure for contract tests");
         }
         let producedArtifactId = void 0;
-        if (step.type === "network.switch") {
+        let result = void 0;
+        if (step.type === "script") {
+          const AsyncFunction = Object.getPrototypeOf(async function() {
+          }).constructor;
+          const fn = new AsyncFunction("ctx", "steps", step.script);
+          const scriptCtx = {
+            tx: {
+              plan: async (opts) => {
+                if (this.sdk.network !== "simulated") {
+                  this.sdk.enforcePolicy(
+                    "network",
+                    "Workflow script requested transaction planning"
+                  );
+                }
+                const plan = await this.sdk.tx.plan({ ...opts, workflowId });
+                await this.sdk.artifacts.write(plan, { dryRun: options.dryRun ?? false });
+                const planRecord = plan;
+                const id = planRecord.contentHash || planRecord.artifactId || plan.planId;
+                if (id) producedArtifacts.push(id);
+                lastPlan = plan;
+                return plan;
+              },
+              sign: async (plan, account) => {
+                const signed = await this.sdk.tx.sign(plan, account);
+                await this.sdk.artifacts.write(signed, { dryRun: options.dryRun ?? false });
+                const signedRecord = signed;
+                const id = signedRecord.contentHash || signedRecord.artifactId || signed.signedId;
+                if (id) producedArtifacts.push(id);
+                lastSigned = signed;
+                return signed;
+              },
+              send: async (signed) => {
+                this.sdk.enforcePolicy(
+                  "mutation",
+                  "Workflow script requested real broadcast"
+                );
+                const res = this.sdk.network === "simulated" ? await this.sdk.tx.simulate(signed) : await this.sdk.tx.send(signed);
+                await this.sdk.artifacts.write(res.receipt, { dryRun: options.dryRun ?? false });
+                const receiptRecord = res.receipt;
+                const id = receiptRecord.contentHash || receiptRecord.artifactId || receiptRecord.txId;
+                if (id) producedArtifacts.push(id);
+                return res;
+              },
+              simulate: async (signed) => {
+                const res = await this.sdk.tx.simulate(signed);
+                await this.sdk.artifacts.write(res.receipt, { dryRun: options.dryRun ?? false });
+                const receiptRecord = res.receipt;
+                const id = receiptRecord.contentHash || receiptRecord.artifactId || receiptRecord.txId;
+                if (id) producedArtifacts.push(id);
+                return res;
+              }
+            },
+            sdk: this.sdk
+          };
+          result = await fn(scriptCtx, stepsResults);
+        } else if (step.type === "network.switch") {
           const targetNetwork = step.args?.network || step.network;
           if (targetNetwork === "mainnet") {
-            this.sdk.enforcePolicy("mainnet", "Workflow requested network switch to mainnet");
+            this.sdk.enforcePolicy(
+              "mainnet",
+              "Workflow requested network switch to mainnet"
+            );
           }
         } else if (step.type === "tx.plan") {
-          this.sdk.enforcePolicy("network", "Workflow requested transaction planning");
+          if (this.sdk.network !== "simulated") {
+            this.sdk.enforcePolicy("network", "Workflow requested transaction planning");
+          }
           lastPlan = await this.sdk.tx.plan({
             from: step.args?.from || step.from,
             to: step.args?.to || step.to,
-            amount: step.args?.amount || step.amount
+            amount: step.args?.amount || step.amount,
+            workflowId
           });
-          if (!options.dryRun) {
-            await this.sdk.artifacts.write(lastPlan);
-          }
+          await this.sdk.artifacts.write(lastPlan, { dryRun: options.dryRun ?? false });
           const planRecord = lastPlan;
-          producedArtifactId = lastPlan.artifactId || planRecord.contentHash;
+          producedArtifactId = planRecord.contentHash || planRecord.artifactId || lastPlan.planId;
           if (producedArtifactId) producedArtifacts.push(producedArtifactId);
+          result = lastPlan;
         } else if (step.type === "tx.simulate" || step.type === "tx.send") {
-          if (!lastPlan) throw new Error("Cannot sign or send without a prior tx.plan step");
+          if (!lastPlan)
+            throw new Error("Cannot sign or send without a prior tx.plan step");
           if (step.type === "tx.send") {
-            this.sdk.enforcePolicy("mutation", "Workflow requested real broadcast via tx.send");
+            this.sdk.enforcePolicy(
+              "mutation",
+              "Workflow requested real broadcast via tx.send"
+            );
           }
           lastSigned = await this.sdk.tx.sign(lastPlan);
-          if (!options.dryRun) {
-            await this.sdk.artifacts.write(lastSigned);
-          }
+          await this.sdk.artifacts.write(lastSigned, { dryRun: options.dryRun ?? false });
           const signedRecord = lastSigned;
-          const signedId = lastSigned.artifactId || signedRecord.contentHash;
+          const signedId = signedRecord.contentHash || signedRecord.artifactId || lastSigned.signedId;
           if (signedId) producedArtifacts.push(signedId);
           if (step.type === "tx.simulate") {
             const { receipt } = await this.sdk.tx.simulate(lastSigned);
-            if (!options.dryRun) await this.sdk.artifacts.write(receipt);
+            await this.sdk.artifacts.write(receipt, { dryRun: options.dryRun ?? false });
             const receiptRecord = receipt;
-            producedArtifactId = receiptRecord.artifactId || receiptRecord.contentHash;
+            producedArtifactId = receiptRecord.contentHash || receiptRecord.artifactId || receiptRecord.txId;
             if (producedArtifactId) producedArtifacts.push(producedArtifactId);
+            result = receipt;
           } else {
-            const { receipt } = await this.sdk.tx.send(lastSigned);
-            if (!options.dryRun) await this.sdk.artifacts.write(receipt);
+            const { receipt } = this.sdk.network === "simulated" ? await this.sdk.tx.simulate(lastSigned) : await this.sdk.tx.send(lastSigned);
+            await this.sdk.artifacts.write(receipt, { dryRun: options.dryRun ?? false });
             const receiptRecord = receipt;
-            producedArtifactId = receiptRecord.artifactId || receiptRecord.contentHash;
+            producedArtifactId = receiptRecord.contentHash || receiptRecord.artifactId || receiptRecord.txId;
             if (producedArtifactId) producedArtifacts.push(producedArtifactId);
+            result = receipt;
           }
         }
+        if (step.id) {
+          stepsResults[step.id] = { result };
+        }
         const stepRecord = {
           type: step.type,
           status: "success",
@@ -818,8 +1131,10 @@ var HardkasWorkflow = class {
       artifactId: workflowId,
       status,
       steps: artifactSteps,
-      parentArtifacts,
-      producedArtifacts,
+      parentArtifacts: parentArtifacts.sort(deterministicCompare),
+      producedArtifacts: Array.from(new Set(producedArtifacts)).sort(
+        deterministicCompare
+      ),
       generationRange: {
         start: generationStart,
         end: Date.now().toString()
@@ -838,7 +1153,9 @@ var HardkasWorkflow = class {
     artifact.contentHash = calculateContentHash2(artifact, 1);
     if (!options.dryRun) {
       this.sdk.enforcePolicy("mutation", "Workflow Runtime saving artifact");
-      await this.sdk.artifacts.write(artifact, { fileName: `workflow.v1-${workflowId}.json` });
+      await this.sdk.artifacts.write(artifact, {
+        fileName: `workflow.v1-${workflowId}.json`
+      });
     }
     return artifact;
   }
@@ -969,16 +1286,20 @@ var Hardkas = class _Hardkas {
     const msg = (policy) => `Agent Mode Policy Violation: '${action}' is restricted by policy '${policy}'. ${context || ""}`;
     switch (action) {
       case "network":
-        if (!this.policy.allowNetwork) throw new HardkasError2("POLICY_VIOLATION", msg("allowNetwork"));
+        if (!this.policy.allowNetwork)
+          throw new HardkasError2("POLICY_VIOLATION", msg("allowNetwork"));
         break;
       case "mainnet":
-        if (!this.policy.allowMainnet) throw new HardkasError2("POLICY_VIOLATION", msg("allowMainnet"));
+        if (!this.policy.allowMainnet)
+          throw new HardkasError2("POLICY_VIOLATION", msg("allowMainnet"));
         break;
       case "external-wallet":
-        if (!this.policy.allowExternalWallet) throw new HardkasError2("POLICY_VIOLATION", msg("allowExternalWallet"));
+        if (!this.policy.allowExternalWallet)
+          throw new HardkasError2("POLICY_VIOLATION", msg("allowExternalWallet"));
         break;
       case "mutation":
-        if (this.policy.requireDryRun) throw new HardkasError2("POLICY_VIOLATION", msg("requireDryRun"));
+        if (this.policy.requireDryRun)
+          throw new HardkasError2("POLICY_VIOLATION", msg("requireDryRun"));
         break;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/sdk",
-  "version": "0.7.3-alpha",
+  "version": "0.7.5-alpha",
   "type": "module",
   "files": [
     "dist",
@@ -23,22 +23,23 @@
     }
   },
   "dependencies": {
-    "@hardkas/accounts": "0.7.3-alpha",
-    "@hardkas/config": "0.7.3-alpha",
-    "@hardkas/core": "0.7.3-alpha",
-    "@hardkas/artifacts": "0.7.3-alpha",
-    "@hardkas/query": "0.7.3-alpha",
-    "@hardkas/l2": "0.7.3-alpha",
-    "@hardkas/localnet": "0.7.3-alpha",
-    "@hardkas/simulator": "0.7.3-alpha",
-    "@hardkas/kaspa-rpc": "0.7.3-alpha",
-    "@hardkas/wallet-adapter": "0.7.3-alpha",
-    "@hardkas/tx-builder": "0.7.3-alpha"
+    "@hardkas/accounts": "0.7.5-alpha",
+    "@hardkas/artifacts": "0.7.5-alpha",
+    "@hardkas/l2": "0.7.5-alpha",
+    "@hardkas/core": "0.7.5-alpha",
+    "@hardkas/config": "0.7.5-alpha",
+    "@hardkas/query": "0.7.5-alpha",
+    "@hardkas/kaspa-rpc": "0.7.5-alpha",
+    "@hardkas/simulator": "0.7.5-alpha",
+    "@hardkas/tx-builder": "0.7.5-alpha",
+    "@hardkas/localnet": "0.7.5-alpha",
+    "@hardkas/wallet-adapter": "0.7.5-alpha"
   },
   "devDependencies": {
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.8",
+    "@hardkas/query-store": "0.7.5-alpha"
   },
   "license": "MIT",
   "author": "Javier Rodriguez",