@hardkas/sdk 0.7.1-alpha → 0.7.4-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.

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,26 +73,50 @@ 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;
-    const rpcUtxos = await this.sdk.rpc.getUtxosByAddress(fromAccount.address);
-    const builderUtxos = rpcUtxos.map((u) => ({
-      outpoint: {
-        transactionId: u.outpoint.transactionId,
-        index: u.outpoint.index
-      },
-      address: u.address,
-      amountSompi: u.amountSompi,
-      scriptPublicKey: u.scriptPublicKey || ""
-    }));
+    let builderUtxos = [];
+    if (this.sdk.network === "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) => {
+        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"
+        };
+      });
+    } else {
+      const rpcUtxos = await this.sdk.rpc.getUtxosByAddress(fromAccount.address);
+      builderUtxos = rpcUtxos.map((u) => ({
+        outpoint: {
+          transactionId: u.outpoint.transactionId,
+          index: u.outpoint.index
+        },
+        address: u.address,
+        amountSompi: u.amountSompi,
+        scriptPublicKey: u.scriptPublicKey || ""
+      }));
+    }
     const builderPlan = buildPaymentPlan({
       fromAddress: fromAccount.address,
       availableUtxos: builderUtxos,
-      outputs: [{
-        address: toAccount.address,
-        amountSompi
-      }],
+      outputs: [
+        {
+          address: toAccount.address,
+          amountSompi
+        }
+      ],
       feeRateSompiPerMass: options.feeRate ?? 1n
     });
     return createTxPlanArtifact({
@@ -108,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.
@@ -148,11 +361,15 @@ 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 simResult = applySimulatedPayment(
+      state,
+      {
+        from: signedArtifact.from.input || signedArtifact.from.address,
+        to: signedArtifact.to.input || signedArtifact.to.address,
+        amountSompi: BigInt(signedArtifact.amountSompi)
+      },
+      systemRuntimeContext
+    );
     coreEvents.normalizeAndEmit({
       kind: "workflow.submitted",
       txId: simResult.receipt.txId,
@@ -160,10 +377,13 @@ var HardkasTx = class {
     });
     events.push({ type: "phase.completed", phase: "send", timestamp: Date.now() });
     await saveLocalnetState(simResult.state);
-    const receiptPath = await saveSimulatedReceipt(simResult.receipt);
+    const receiptPath = await saveSimulatedReceipt(
+      simResult.receipt
+    );
     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,
@@ -213,6 +433,22 @@ var HardkasTx = class {
       events,
       receiptPath
     });
+    coreEvents.normalizeAndEmit({
+      kind: "artifact.created",
+      schema: receipt.schema,
+      artifactId: receipt.txId,
+      network: receipt.networkId,
+      mode: receipt.mode,
+      path: receiptPath
+    });
+    coreEvents.normalizeAndEmit({
+      kind: "tx.confirmed",
+      txId: receipt.txId,
+      network: receipt.networkId,
+      mode: receipt.mode,
+      amountSompi: receipt.amountSompi,
+      feeSompi: receipt.feeSompi
+    });
     return {
       receipt,
       receiptPath,
@@ -225,7 +461,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;
@@ -252,9 +490,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);
@@ -266,10 +508,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.
@@ -352,16 +591,43 @@ 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) {
-    const artifactDir = options.path ? path.resolve(this.sdk.config.cwd, options.path) : this.sdk.config.cwd;
-    if (options.path && !fs.existsSync(path.join(artifactDir, "hardkas.config.ts"))) {
-      throw new Error(`Workspace not found at ${options.path}`);
+    let artifactDir = this.sdk.config.cwd;
+    let planPath = path.join(artifactDir, "tx-plan.json");
+    let receiptPath = path.join(artifactDir, "tx-receipt.json");
+    if (options.path) {
+      const fullPath = path.resolve(this.sdk.config.cwd, options.path);
+      if (fs.existsSync(fullPath)) {
+        if (fs.statSync(fullPath).isFile()) {
+          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");
+          receiptPath = path.join(artifactDir, "tx-receipt.json");
+        }
+      } else {
+        throw new Error(`Path not found: ${options.path}`);
+      }
+    }
+    if (!fs.existsSync(path.join(this.sdk.config.cwd, "hardkas.config.ts"))) {
+      throw new Error(`Workspace not found at ${this.sdk.config.cwd}`);
     }
-    const planPath = path.join(artifactDir, "tx-plan.json");
-    const receiptPath = path.join(artifactDir, "tx-receipt.json");
     const canonicalDirs = [
       path.join(artifactDir, ".hardkas", "receipts"),
       path.join(artifactDir, ".hardkas", "traces"),
@@ -406,7 +672,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;
@@ -427,7 +698,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`);
@@ -436,7 +710,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) {
@@ -459,8 +736,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) {
@@ -586,18 +865,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,
@@ -632,7 +913,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;
@@ -673,60 +954,139 @@ 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 });
+                if (!options.dryRun) {
+                  await this.sdk.artifacts.write(plan);
+                }
+                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);
+                if (!options.dryRun) {
+                  await this.sdk.artifacts.write(signed);
+                }
+                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);
+                if (!options.dryRun) await this.sdk.artifacts.write(res.receipt);
+                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);
+                if (!options.dryRun) await this.sdk.artifacts.write(res.receipt);
+                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);
           }
           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);
           }
           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);
             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);
+            const { receipt } = this.sdk.network === "simulated" ? await this.sdk.tx.simulate(lastSigned) : await this.sdk.tx.send(lastSigned);
             if (!options.dryRun) await this.sdk.artifacts.write(receipt);
             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",
@@ -768,8 +1128,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()
@@ -788,7 +1150,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;
   }
@@ -919,16 +1283,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.1-alpha",
+  "version": "0.7.4-alpha",
   "type": "module",
   "files": [
     "dist",
@@ -23,22 +23,23 @@
     }
   },
   "dependencies": {
-    "@hardkas/core": "0.7.1-alpha",
-    "@hardkas/artifacts": "0.7.1-alpha",
-    "@hardkas/accounts": "0.7.1-alpha",
-    "@hardkas/localnet": "0.7.1-alpha",
-    "@hardkas/l2": "0.7.1-alpha",
-    "@hardkas/config": "0.7.1-alpha",
-    "@hardkas/kaspa-rpc": "0.7.1-alpha",
-    "@hardkas/tx-builder": "0.7.1-alpha",
-    "@hardkas/query": "0.7.1-alpha",
-    "@hardkas/simulator": "0.7.1-alpha",
-    "@hardkas/wallet-adapter": "0.7.1-alpha"
+    "@hardkas/accounts": "0.7.4-alpha",
+    "@hardkas/config": "0.7.4-alpha",
+    "@hardkas/core": "0.7.4-alpha",
+    "@hardkas/artifacts": "0.7.4-alpha",
+    "@hardkas/kaspa-rpc": "0.7.4-alpha",
+    "@hardkas/l2": "0.7.4-alpha",
+    "@hardkas/simulator": "0.7.4-alpha",
+    "@hardkas/localnet": "0.7.4-alpha",
+    "@hardkas/tx-builder": "0.7.4-alpha",
+    "@hardkas/query": "0.7.4-alpha",
+    "@hardkas/wallet-adapter": "0.7.4-alpha"
   },
   "devDependencies": {
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.8",
+    "@hardkas/query-store": "0.7.4-alpha"
   },
   "license": "MIT",
   "author": "Javier Rodriguez",