@hardkas/artifacts 0.7.1-alpha → 0.7.4-alpha

package/dist/index.d.ts

@@ -15,7 +15,7 @@ declare const ARTIFACT_SCHEMAS: {
     readonly IGRA_SIGNED_TX: "hardkas.igraSignedTx.v1";
     readonly IGRA_TX_RECEIPT: "hardkas.igraTxReceipt.v1";
 };
-type HardkasArtifactSchema = typeof ARTIFACT_SCHEMAS[keyof typeof ARTIFACT_SCHEMAS] | string;
+type HardkasArtifactSchema = (typeof ARTIFACT_SCHEMAS)[keyof typeof ARTIFACT_SCHEMAS] | string;
 type HardkasArtifactMode = "simulated" | "node" | "rpc" | "l2-rpc" | "real";
 
 declare const ARTIFACT_VERSION = "1.0.0-alpha";
@@ -968,6 +968,26 @@ declare const TxReceiptSchema: z.ZodObject<{
     errors?: string[] | undefined;
     metadata?: any;
 }>;
+declare const SignatureEntrySchema: z.ZodObject<{
+    signer: z.ZodString;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    signer: string;
+    signature: string;
+}, {
+    signer: string;
+    signature: string;
+}>;
+declare const SignatureMetadataEntrySchema: z.ZodObject<{
+    signer: z.ZodString;
+    signedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    signer: string;
+    signedAt: string;
+}, {
+    signer: string;
+    signedAt: string;
+}>;
 declare const SignedTxSchema: z.ZodObject<{
     schemaVersion: z.ZodOptional<z.ZodString>;
     hardkasVersion: z.ZodString;
@@ -1020,7 +1040,7 @@ declare const SignedTxSchema: z.ZodObject<{
     }>>;
 } & {
     schema: z.ZodLiteral<"hardkas.signedTx">;
-    status: z.ZodLiteral<"signed">;
+    status: z.ZodEnum<["partially_signed", "signed"]>;
     signedId: z.ZodString;
     sourcePlanId: z.ZodString;
     networkId: z.ZodEnum<["mainnet", "testnet-10", "testnet-11", "testnet-12", "simnet", "simnet-1", "devnet", "simulated"]>;
@@ -1052,7 +1072,8 @@ declare const SignedTxSchema: z.ZodObject<{
         input?: string | undefined;
     }>;
     amountSompi: z.ZodString;
-    signedTransaction: z.ZodObject<{
+    unsignedPayloadHash: z.ZodOptional<z.ZodString>;
+    signedTransaction: z.ZodOptional<z.ZodObject<{
         format: z.ZodString;
         payload: z.ZodString;
     }, "strip", z.ZodTypeAny, {
@@ -1061,11 +1082,49 @@ declare const SignedTxSchema: z.ZodObject<{
     }, {
         format: string;
         payload: string;
-    }>;
+    }>>;
     txId: z.ZodOptional<z.ZodString>;
+    multisig: z.ZodOptional<z.ZodObject<{
+        threshold: z.ZodNumber;
+        requiredSigners: z.ZodArray<z.ZodString, "many">;
+        signatures: z.ZodArray<z.ZodObject<{
+            signer: z.ZodString;
+            signature: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            signer: string;
+            signature: string;
+        }, {
+            signer: string;
+            signature: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        threshold: number;
+        requiredSigners: string[];
+        signatures: {
+            signer: string;
+            signature: string;
+        }[];
+    }, {
+        threshold: number;
+        requiredSigners: string[];
+        signatures: {
+            signer: string;
+            signature: string;
+        }[];
+    }>>;
+    signatureMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        signer: z.ZodString;
+        signedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        signer: string;
+        signedAt: string;
+    }, {
+        signer: string;
+        signedAt: string;
+    }>, "many">>;
     metadata: z.ZodOptional<z.ZodAny>;
 }, "strip", z.ZodTypeAny, {
-    status: "signed";
+    status: "partially_signed" | "signed";
     version: "1.0.0-alpha";
     schema: "hardkas.signedTx";
     hardkasVersion: string;
@@ -1085,10 +1144,14 @@ declare const SignedTxSchema: z.ZodObject<{
     amountSompi: string;
     signedId: string;
     sourcePlanId: string;
-    signedTransaction: {
-        format: string;
-        payload: string;
-    };
+    multisig?: {
+        threshold: number;
+        requiredSigners: string[];
+        signatures: {
+            signer: string;
+            signature: string;
+        }[];
+    } | undefined;
     schemaVersion?: string | undefined;
     hashVersion?: string | number | undefined;
     contentHash?: string | undefined;
@@ -1113,8 +1176,17 @@ declare const SignedTxSchema: z.ZodObject<{
     } | undefined;
     txId?: string | undefined;
     metadata?: any;
+    unsignedPayloadHash?: string | undefined;
+    signedTransaction?: {
+        format: string;
+        payload: string;
+    } | undefined;
+    signatureMetadata?: {
+        signer: string;
+        signedAt: string;
+    }[] | undefined;
 }, {
-    status: "signed";
+    status: "partially_signed" | "signed";
     version: "1.0.0-alpha";
     schema: "hardkas.signedTx";
     hardkasVersion: string;
@@ -1134,10 +1206,14 @@ declare const SignedTxSchema: z.ZodObject<{
     amountSompi: string;
     signedId: string;
     sourcePlanId: string;
-    signedTransaction: {
-        format: string;
-        payload: string;
-    };
+    multisig?: {
+        threshold: number;
+        requiredSigners: string[];
+        signatures: {
+            signer: string;
+            signature: string;
+        }[];
+    } | undefined;
     schemaVersion?: string | undefined;
     hashVersion?: string | number | undefined;
     contentHash?: string | undefined;
@@ -1162,6 +1238,15 @@ declare const SignedTxSchema: z.ZodObject<{
     } | undefined;
     txId?: string | undefined;
     metadata?: any;
+    unsignedPayloadHash?: string | undefined;
+    signedTransaction?: {
+        format: string;
+        payload: string;
+    } | undefined;
+    signatureMetadata?: {
+        signer: string;
+        signedAt: string;
+    }[] | undefined;
 }>;
 declare const TxTraceSchema: z.ZodObject<{
     schemaVersion: z.ZodOptional<z.ZodString>;
@@ -2045,7 +2130,7 @@ interface TxPlanArtifact extends BaseArtifact<"txPlan"> {
     } | undefined;
 }
 interface SignedTxArtifact extends BaseArtifact<"signedTx"> {
-    status: "signed";
+    status: "partially_signed" | "signed";
     signedId: ArtifactId;
     sourcePlanId: string;
     from: {
@@ -2059,11 +2144,24 @@ interface SignedTxArtifact extends BaseArtifact<"signedTx"> {
         input?: string | undefined;
     };
     amountSompi: string;
-    signedTransaction: {
+    unsignedPayloadHash?: string | undefined;
+    signedTransaction?: {
         format: string;
         payload: string;
-    };
+    } | undefined;
     txId?: TxId | undefined;
+    multisig?: {
+        threshold: number;
+        requiredSigners: string[];
+        signatures: Array<{
+            signer: string;
+            signature: string;
+        }>;
+    } | undefined;
+    signatureMetadata?: Array<{
+        signer: string;
+        signedAt: string;
+    }> | undefined;
     metadata?: any | undefined;
 }
 interface TxReceiptArtifact extends BaseArtifact<"txReceipt"> {
@@ -2208,7 +2306,7 @@ declare const STRICT_PATH_KEYS: Set<string>;
  * Excludes fields in SEMANTIC_EXCLUSIONS during serialization.
  * Skips keys with undefined values (matching JSON.stringify behavior).
  */
-declare function canonicalStringify(obj: unknown, version?: number, keyName?: string): string;
+declare function canonicalStringify(obj: unknown, version?: number, keyName?: string, isRoot?: boolean): string;
 /**
  * Calculates a SHA-256 hash of the canonical JSON representation.
  * Always excludes fields in SEMANTIC_EXCLUSIONS from the calculation.
@@ -2732,4 +2830,4 @@ declare function listDeployments(rootDir: string, networkId?: string): Promise<D
 declare function updateDeployment(rootDir: string, networkId: string, label: string, update: Partial<DeploymentRecord>): Promise<DeploymentRecord>;
 declare function deleteDeployment(rootDir: string, networkId: string, label: string): Promise<boolean>;
 
-export { ARTIFACT_SCHEMAS, ARTIFACT_VERSION, AccountRefSchema, type ArtifactDiff, type ArtifactExplanation, ArtifactLineageSchema, type ArtifactLookup, type ArtifactPayload, type ArtifactValidationResult, type ArtifactVerificationResult, type AssumptionLevel, type BaseArtifact, BaseArtifactSchema, BasicCorrelationInvariant, BasicLineageInvariant, CURRENT_HASH_VERSION, type Clock, type CreateTxPlanArtifactOptions, type DagContext, DagContextSchema, type DeploymentIndex, type DeploymentRecord, type DeploymentSummary, type DiffEntry, type DraftArtifact, type FeeAuditResult, HARDKAS_VERSION, type HardkasArtifactBase, type HardkasArtifactMode, type HardkasArtifactSchema, HashInvariant, type IgraSignedTxArtifact, type IgraTxPlanArtifact, type IgraTxReceiptArtifact, type IgraTxRequestArtifact, type Invariant, type InvariantContext, type InvariantViolation, InvariantWatcher, LifecycleInvariant, type LineageOptions, type LineageValidationResult, LocalnetUtxoSchemaV2, type MigrationResult, type MigrationStep, NetworkInvariant, ReplayInvariant, type RuntimeSession, RuntimeSessionSchema, SEMANTIC_EXCLUSIONS, STRICT_PATH_KEYS, SchemaInvariant, type ScriptCapability, ScriptCapabilitySchema, ScriptMetadataSchema, type SignedTx, type SignedTxArtifact, type SignedTxArtifactV1, SignedTxSchema, type Snapshot, type SnapshotArtifact, SnapshotSchema, type TxOutputArtifact, type TxPlan, type TxPlanArtifact, type TxPlanArtifactV1, TxPlanSchema, type TxReceipt, type TxReceiptArtifact, type TxReceiptArtifactV1, TxReceiptSchema, type TxTrace, type TxTraceArtifact, type TxTraceArtifactV1, TxTraceSchema, type UtxoArtifact, type VerificationContext, type VerificationIssue, type VerificationSeverity, type WatcherOptions, type Workflow, type WorkflowArtifact, WorkflowSchema, assertDecimalBigIntString, assertEvmAddress, assertEvmTxHash, assertHexData, assertValidIgraSignedTxArtifact, assertValidIgraTxPlanArtifact, assertValidIgraTxReceiptArtifact, assertValidSignedTxArtifact, assertValidTxPlanArtifact, assertValidTxReceiptArtifact, bigIntReplacer, calculateContentHash, canMigrate, canonicalStringify, createDeploymentRecord, createIgraDeployPlanId, createIgraPlanId, createIgraSignedId, createSimulatedSignedTxArtifact, createSimulatedTxReceipt, createTxPlanArtifact, defaultClock, deleteDeployment, detectArtifactVersion, diffArtifacts, explainArtifact, formatSignedTxArtifact, formatTxPlanArtifact, formatTxReceiptArtifact, getBroadcastableSignedTransaction, getDefaultL2ReceiptsDir, getDefaultReceiptPath, getL2ReceiptPath, getMigrationPath, getRegisteredMigrationSteps, isIgraTxPlanArtifact, listDeployments, listIgraTxReceiptArtifacts, loadDeployment, loadIgraTxReceiptArtifact, migrateArtifactPayload, migrateToCanonical, readArtifact, readSignedTxArtifact, readTxPlanArtifact, readTxReceiptArtifact, recomputeMass, registerMigrationStep, saveDeployment, saveIgraTxReceiptArtifact, sortUtxosByOutpoint, txOutputFromArtifact, txOutputToArtifact, updateDeployment, updateDeploymentStatus, utxoFromArtifact, utxoToArtifact, validateArtifact, validateIgraSignedTxArtifact, validateIgraTxPlanArtifact, validateIgraTxReceiptArtifact, validateSignedTxArtifact, validateTxPlanArtifact, validateTxReceiptArtifact, verifyArtifact, verifyArtifactFile, verifyArtifactIntegrity, verifyArtifactReplay, verifyArtifactSemantics, verifyFeeSemantics, verifyLineage, writeArtifact };
+export { ARTIFACT_SCHEMAS, ARTIFACT_VERSION, AccountRefSchema, type ArtifactDiff, type ArtifactExplanation, ArtifactLineageSchema, type ArtifactLookup, type ArtifactPayload, type ArtifactValidationResult, type ArtifactVerificationResult, type AssumptionLevel, type BaseArtifact, BaseArtifactSchema, BasicCorrelationInvariant, BasicLineageInvariant, CURRENT_HASH_VERSION, type Clock, type CreateTxPlanArtifactOptions, type DagContext, DagContextSchema, type DeploymentIndex, type DeploymentRecord, type DeploymentSummary, type DiffEntry, type DraftArtifact, type FeeAuditResult, HARDKAS_VERSION, type HardkasArtifactBase, type HardkasArtifactMode, type HardkasArtifactSchema, HashInvariant, type IgraSignedTxArtifact, type IgraTxPlanArtifact, type IgraTxReceiptArtifact, type IgraTxRequestArtifact, type Invariant, type InvariantContext, type InvariantViolation, InvariantWatcher, LifecycleInvariant, type LineageOptions, type LineageValidationResult, LocalnetUtxoSchemaV2, type MigrationResult, type MigrationStep, NetworkInvariant, ReplayInvariant, type RuntimeSession, RuntimeSessionSchema, SEMANTIC_EXCLUSIONS, STRICT_PATH_KEYS, SchemaInvariant, type ScriptCapability, ScriptCapabilitySchema, ScriptMetadataSchema, SignatureEntrySchema, SignatureMetadataEntrySchema, type SignedTx, type SignedTxArtifact, type SignedTxArtifactV1, SignedTxSchema, type Snapshot, type SnapshotArtifact, SnapshotSchema, type TxOutputArtifact, type TxPlan, type TxPlanArtifact, type TxPlanArtifactV1, TxPlanSchema, type TxReceipt, type TxReceiptArtifact, type TxReceiptArtifactV1, TxReceiptSchema, type TxTrace, type TxTraceArtifact, type TxTraceArtifactV1, TxTraceSchema, type UtxoArtifact, type VerificationContext, type VerificationIssue, type VerificationSeverity, type WatcherOptions, type Workflow, type WorkflowArtifact, WorkflowSchema, assertDecimalBigIntString, assertEvmAddress, assertEvmTxHash, assertHexData, assertValidIgraSignedTxArtifact, assertValidIgraTxPlanArtifact, assertValidIgraTxReceiptArtifact, assertValidSignedTxArtifact, assertValidTxPlanArtifact, assertValidTxReceiptArtifact, bigIntReplacer, calculateContentHash, canMigrate, canonicalStringify, createDeploymentRecord, createIgraDeployPlanId, createIgraPlanId, createIgraSignedId, createSimulatedSignedTxArtifact, createSimulatedTxReceipt, createTxPlanArtifact, defaultClock, deleteDeployment, detectArtifactVersion, diffArtifacts, explainArtifact, formatSignedTxArtifact, formatTxPlanArtifact, formatTxReceiptArtifact, getBroadcastableSignedTransaction, getDefaultL2ReceiptsDir, getDefaultReceiptPath, getL2ReceiptPath, getMigrationPath, getRegisteredMigrationSteps, isIgraTxPlanArtifact, listDeployments, listIgraTxReceiptArtifacts, loadDeployment, loadIgraTxReceiptArtifact, migrateArtifactPayload, migrateToCanonical, readArtifact, readSignedTxArtifact, readTxPlanArtifact, readTxReceiptArtifact, recomputeMass, registerMigrationStep, saveDeployment, saveIgraTxReceiptArtifact, sortUtxosByOutpoint, txOutputFromArtifact, txOutputToArtifact, updateDeployment, updateDeploymentStatus, utxoFromArtifact, utxoToArtifact, validateArtifact, validateIgraSignedTxArtifact, validateIgraTxPlanArtifact, validateIgraTxReceiptArtifact, validateSignedTxArtifact, validateTxPlanArtifact, validateTxReceiptArtifact, verifyArtifact, verifyArtifactFile, verifyArtifactIntegrity, verifyArtifactReplay, verifyArtifactSemantics, verifyFeeSemantics, verifyLineage, writeArtifact };

package/dist/index.js

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@hardkas/artifacts",
-  version: "0.7.0-alpha",
+  version: "0.7.4-alpha",
   type: "module",
   license: "MIT",
   author: "Javier Rodriguez",
@@ -62,9 +62,11 @@ function isIgraTxPlanArtifact(value) {
 }
 function validateIgraTxPlanArtifact(value) {
   const errors = [];
-  if (typeof value !== "object" || value === null) return { ok: false, errors: ["Artifact must be an object"] };
+  if (typeof value !== "object" || value === null)
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = value;
-  if (v.schema !== ARTIFACT_SCHEMAS.IGRA_TX_PLAN) errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.IGRA_TX_PLAN}'`);
+  if (v.schema !== ARTIFACT_SCHEMAS.IGRA_TX_PLAN)
+    errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.IGRA_TX_PLAN}'`);
   validateCommon(v, errors);
   if (v.status !== "built") errors.push("Invalid status: expected 'built'");
   if (typeof v.planId !== "string" || !v.planId) errors.push("Missing planId");
@@ -84,29 +86,36 @@ function validateIgraTxPlanArtifact(value) {
     assertHexData(r.data, "request.data", errors);
     assertDecimalBigIntString(r.valueWei, "request.valueWei", errors);
     if (r.gasLimit) assertDecimalBigIntString(r.gasLimit, "request.gasLimit", errors);
-    if (r.gasPriceWei) assertDecimalBigIntString(r.gasPriceWei, "request.gasPriceWei", errors);
+    if (r.gasPriceWei)
+      assertDecimalBigIntString(r.gasPriceWei, "request.gasPriceWei", errors);
     if (r.nonce) assertDecimalBigIntString(r.nonce, "request.nonce", errors);
   }
   if (v.estimatedGas) assertDecimalBigIntString(v.estimatedGas, "estimatedGas", errors);
-  if (v.estimatedFeeWei) assertDecimalBigIntString(v.estimatedFeeWei, "estimatedFeeWei", errors);
+  if (v.estimatedFeeWei)
+    assertDecimalBigIntString(v.estimatedFeeWei, "estimatedFeeWei", errors);
   return { ok: errors.length === 0, errors };
 }
 function assertValidIgraTxPlanArtifact(value) {
   const result = validateIgraTxPlanArtifact(value);
   if (!result.ok) {
-    throw new Error(`Invalid Igra tx plan artifact:
-${result.errors.map((e) => `- ${e}`).join("\n")}`);
+    throw new Error(
+      `Invalid Igra tx plan artifact:
+${result.errors.map((e) => `- ${e}`).join("\n")}`
+    );
   }
 }
 function validateIgraSignedTxArtifact(value) {
   const errors = [];
-  if (typeof value !== "object" || value === null) return { ok: false, errors: ["Artifact must be an object"] };
+  if (typeof value !== "object" || value === null)
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = value;
-  if (v.schema !== ARTIFACT_SCHEMAS.IGRA_SIGNED_TX) errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.IGRA_SIGNED_TX}'`);
+  if (v.schema !== ARTIFACT_SCHEMAS.IGRA_SIGNED_TX)
+    errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.IGRA_SIGNED_TX}'`);
   validateCommon(v, errors);
   if (v.status !== "signed") errors.push("Invalid status: expected 'signed'");
   if (typeof v.signedId !== "string" || !v.signedId) errors.push("Missing signedId");
-  if (typeof v.sourcePlanId !== "string" || !v.sourcePlanId) errors.push("Missing sourcePlanId");
+  if (typeof v.sourcePlanId !== "string" || !v.sourcePlanId)
+    errors.push("Missing sourcePlanId");
   assertHexData(v.rawTransaction, "rawTransaction", errors);
   if (v.txHash) assertEvmTxHash(v.txHash, "txHash", errors);
   return { ok: errors.length === 0, errors };
@@ -114,17 +123,22 @@ function validateIgraSignedTxArtifact(value) {
 function assertValidIgraSignedTxArtifact(value) {
   const result = validateIgraSignedTxArtifact(value);
   if (!result.ok) {
-    throw new Error(`Invalid Igra signed tx artifact:
-${result.errors.map((e) => `- ${e}`).join("\n")}`);
+    throw new Error(
+      `Invalid Igra signed tx artifact:
+${result.errors.map((e) => `- ${e}`).join("\n")}`
+    );
   }
 }
 function validateIgraTxReceiptArtifact(value) {
   const errors = [];
-  if (typeof value !== "object" || value === null) return { ok: false, errors: ["Artifact must be an object"] };
+  if (typeof value !== "object" || value === null)
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = value;
-  if (v.schema !== ARTIFACT_SCHEMAS.IGRA_TX_RECEIPT) errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.IGRA_TX_RECEIPT}'`);
+  if (v.schema !== ARTIFACT_SCHEMAS.IGRA_TX_RECEIPT)
+    errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.IGRA_TX_RECEIPT}'`);
   validateCommon(v, errors);
-  if (!["submitted", "confirmed", "failed"].includes(v.status)) errors.push("Invalid status");
+  if (!["submitted", "confirmed", "failed"].includes(v.status))
+    errors.push("Invalid status");
   assertEvmTxHash(v.txHash, "txHash", errors);
   if (typeof v.rpcUrl !== "string" || !v.rpcUrl) errors.push("Missing rpcUrl");
   if (v.blockNumber) assertDecimalBigIntString(v.blockNumber, "blockNumber", errors);
@@ -133,8 +147,10 @@ function validateIgraTxReceiptArtifact(value) {
 function assertValidIgraTxReceiptArtifact(value) {
   const result = validateIgraTxReceiptArtifact(value);
   if (!result.ok) {
-    throw new Error(`Invalid Igra tx receipt artifact:
-${result.errors.map((e) => `- ${e}`).join("\n")}`);
+    throw new Error(
+      `Invalid Igra tx receipt artifact:
+${result.errors.map((e) => `- ${e}`).join("\n")}`
+    );
   }
 }
 function validateCommon(v, errors) {
@@ -161,7 +177,9 @@ function assertEvmAddress(value, field, errors) {
 }
 function assertEvmTxHash(value, field, errors) {
   if (typeof value !== "string" || !/^0x[a-fA-F0-9]{64}$/.test(value)) {
-    errors.push(`Invalid ${field}: must be a 0x-prefixed 64-character EVM transaction hash`);
+    errors.push(
+      `Invalid ${field}: must be a 0x-prefixed 64-character EVM transaction hash`
+    );
   }
 }
 function createIgraPlanId(hash) {
@@ -202,7 +220,10 @@ var SEMANTIC_EXCLUSIONS = /* @__PURE__ */ new Set([
   "sourceSignedId",
   "submittedAt",
   "confirmedAt",
-  "dagContext"
+  "dagContext",
+  "executionId",
+  "workflowId",
+  "signatureMetadata"
 ]);
 var CURRENT_HASH_VERSION = 3;
 var STRICT_PATH_KEYS = /* @__PURE__ */ new Set([
@@ -216,7 +237,16 @@ var STRICT_PATH_KEYS = /* @__PURE__ */ new Set([
   "relativePath",
   "absolutePath"
 ]);
-function canonicalStringify(obj, version = CURRENT_HASH_VERSION, keyName) {
+function canonicalStringify(obj, version = CURRENT_HASH_VERSION, keyName, isRoot = true) {
+  if (typeof obj === "symbol" || typeof obj === "function") {
+    throw new Error(`Type ${typeof obj} is not canonicalizable.`);
+  }
+  if (typeof obj === "undefined") {
+    if (isRoot) {
+      throw new Error(`Type undefined is not canonicalizable at the root.`);
+    }
+    return "null";
+  }
   if (obj === null || typeof obj !== "object") {
     if (typeof obj === "bigint") {
       if (version >= 2) {
@@ -234,7 +264,7 @@ function canonicalStringify(obj, version = CURRENT_HASH_VERSION, keyName) {
     return JSON.stringify(obj);
   }
   if (Array.isArray(obj)) {
-    return "[" + obj.map((item) => canonicalStringify(item, version, keyName)).join(",") + "]";
+    return "[" + obj.map((item) => canonicalStringify(item, version, keyName, false)).join(",") + "]";
   }
   if (obj instanceof Map) {
     throw new Error("Map is not canonicalizable. Use a plain object.");
@@ -254,7 +284,7 @@ function canonicalStringify(obj, version = CURRENT_HASH_VERSION, keyName) {
   ).sort(deterministicCompare);
   const result = sortedKeys.map((key) => {
     const value = obj[key];
-    return JSON.stringify(key) + ":" + canonicalStringify(value, version, key);
+    return JSON.stringify(key) + ":" + canonicalStringify(value, version, key, false);
   }).join(",");
   return "{" + result + "}";
 }
@@ -265,7 +295,10 @@ function calculateContentHash(obj, version = CURRENT_HASH_VERSION) {
 
 // src/schemas.ts
 import { z } from "zod";
-import { kaspaNetworkIdSchema, executionModeSchema } from "@hardkas/core";
+import {
+  kaspaNetworkIdSchema,
+  executionModeSchema
+} from "@hardkas/core";
 var ARTIFACT_VERSION = "1.0.0-alpha";
 var ArtifactLineageSchema = z.object({
   artifactId: z.string(),
@@ -322,17 +355,21 @@ var TxPlanSchema = BaseArtifactSchema.extend({
   amountSompi: z.string(),
   estimatedFeeSompi: z.string(),
   estimatedMass: z.string(),
-  inputs: z.array(z.object({
-    outpoint: z.object({
-      transactionId: z.string(),
-      index: z.number()
-    }),
-    amountSompi: z.string()
-  })),
-  outputs: z.array(z.object({
-    address: z.string(),
-    amountSompi: z.string()
-  })),
+  inputs: z.array(
+    z.object({
+      outpoint: z.object({
+        transactionId: z.string(),
+        index: z.number()
+      }),
+      amountSompi: z.string()
+    })
+  ),
+  outputs: z.array(
+    z.object({
+      address: z.string(),
+      amountSompi: z.string()
+    })
+  ),
   change: z.object({
     address: z.string(),
     amountSompi: z.string()
@@ -346,11 +383,13 @@ var DagContextSchema = z.object({
   branchId: z.string().optional(),
   acceptedTxIds: z.array(z.string()).optional(),
   displacedTxIds: z.array(z.string()).optional(),
-  conflictSet: z.array(z.object({
-    outpoint: z.string(),
-    winnerTxId: z.string(),
-    loserTxIds: z.array(z.string())
-  })).optional(),
+  conflictSet: z.array(
+    z.object({
+      outpoint: z.string(),
+      winnerTxId: z.string(),
+      loserTxIds: z.array(z.string())
+    })
+  ).optional(),
   nonSelectedContext: z.boolean().optional()
 });
 var LocalnetUtxoSchemaV2 = z.object({
@@ -367,10 +406,12 @@ var SnapshotSchema = BaseArtifactSchema.extend({
   accountsHash: z.string().optional(),
   utxoSetHash: z.string().optional(),
   stateHash: z.string().optional(),
-  accounts: z.array(z.object({
-    name: z.string(),
-    address: z.string()
-  })),
+  accounts: z.array(
+    z.object({
+      name: z.string(),
+      address: z.string()
+    })
+  ),
   utxos: z.array(LocalnetUtxoSchemaV2)
 });
 var TxReceiptSchema = BaseArtifactSchema.extend({
@@ -399,9 +440,17 @@ var TxReceiptSchema = BaseArtifactSchema.extend({
   errors: z.array(z.string()).optional(),
   metadata: z.any().optional()
 });
+var SignatureEntrySchema = z.object({
+  signer: z.string(),
+  signature: z.string()
+});
+var SignatureMetadataEntrySchema = z.object({
+  signer: z.string(),
+  signedAt: z.string().datetime()
+});
 var SignedTxSchema = BaseArtifactSchema.extend({
   schema: z.literal("hardkas.signedTx"),
-  status: z.literal("signed"),
+  status: z.enum(["partially_signed", "signed"]),
   signedId: z.string(),
   sourcePlanId: z.string(),
   networkId: kaspaNetworkIdSchema,
@@ -409,11 +458,18 @@ var SignedTxSchema = BaseArtifactSchema.extend({
   from: AccountRefSchema,
   to: AccountRefSchema,
   amountSompi: z.string(),
+  unsignedPayloadHash: z.string().optional(),
   signedTransaction: z.object({
     format: z.string(),
     payload: z.string()
-  }),
+  }).optional(),
   txId: z.string().optional(),
+  multisig: z.object({
+    threshold: z.number(),
+    requiredSigners: z.array(z.string()),
+    signatures: z.array(SignatureEntrySchema)
+  }).optional(),
+  signatureMetadata: z.array(SignatureMetadataEntrySchema).optional(),
   metadata: z.any().optional()
 });
 var TxTraceSchema = BaseArtifactSchema.extend({
@@ -421,12 +477,14 @@ var TxTraceSchema = BaseArtifactSchema.extend({
   txId: z.string(),
   networkId: kaspaNetworkIdSchema,
   mode: executionModeSchema,
-  steps: z.array(z.object({
-    phase: z.string(),
-    status: z.string(),
-    timestamp: z.string().datetime(),
-    details: z.any().optional()
-  })),
+  steps: z.array(
+    z.object({
+      phase: z.string(),
+      status: z.string(),
+      timestamp: z.string().datetime(),
+      details: z.any().optional()
+    })
+  ),
   dagContext: DagContextSchema.optional()
 });
 var WorkflowSchema = BaseArtifactSchema.extend({
@@ -434,14 +492,16 @@ var WorkflowSchema = BaseArtifactSchema.extend({
   workflowId: z.string(),
   status: z.enum(["pending", "running", "completed", "failed"]),
   inputs: z.record(z.any()).optional(),
-  steps: z.array(z.object({
-    type: z.string(),
-    status: z.enum(["pending", "success", "failed", "skipped"]),
-    startedAt: z.string().datetime().optional(),
-    completedAt: z.string().datetime().optional(),
-    producedArtifactId: z.string().optional(),
-    error: z.string().optional()
-  })),
+  steps: z.array(
+    z.object({
+      type: z.string(),
+      status: z.enum(["pending", "success", "failed", "skipped"]),
+      startedAt: z.string().datetime().optional(),
+      completedAt: z.string().datetime().optional(),
+      producedArtifactId: z.string().optional(),
+      error: z.string().optional()
+    })
+  ),
   parentArtifacts: z.array(z.string()).optional(),
   producedArtifacts: z.array(z.string()),
   generationRange: z.object({
@@ -513,8 +573,14 @@ function verifyFeeSemantics(artifact) {
     const plan = artifact;
     artifactMass = BigInt(plan.estimatedMass || 0);
     artifactFee = BigInt(plan.estimatedFeeSompi || 0);
-    inputTotal = (plan.inputs || []).reduce((sum, i) => sum + BigInt(i.amountSompi || 0), 0n);
-    outputTotal = (plan.outputs || []).reduce((sum, o) => sum + BigInt(o.amountSompi || 0), 0n);
+    inputTotal = (plan.inputs || []).reduce(
+      (sum, i) => sum + BigInt(i.amountSompi || 0),
+      0n
+    );
+    outputTotal = (plan.outputs || []).reduce(
+      (sum, o) => sum + BigInt(o.amountSompi || 0),
+      0n
+    );
     if (plan.change) outputTotal += BigInt(plan.change.amountSompi || 0);
   } else if (artifact.schema === "hardkas.txReceipt") {
     const receipt = artifact;
@@ -524,15 +590,21 @@ function verifyFeeSemantics(artifact) {
   }
   const recomputedMass = recomputeMass(artifact);
   if (recomputedMass !== artifactMass && artifactMass !== 0n) {
-    issues.push(`Mass mismatch: artifact reports ${artifactMass}, recomputed ${recomputedMass}`);
+    issues.push(
+      `Mass mismatch: artifact reports ${artifactMass}, recomputed ${recomputedMass}`
+    );
   }
   const impliedFeeRate = artifactMass > 0n ? artifactFee / artifactMass : 1n;
   const recomputedFee = recomputedMass * impliedFeeRate;
   if (recomputedFee !== artifactFee && artifactFee !== 0n) {
-    issues.push(`Fee mismatch: artifact reports ${artifactFee}, recomputed ${recomputedFee} (at rate ${impliedFeeRate})`);
+    issues.push(
+      `Fee mismatch: artifact reports ${artifactFee}, recomputed ${recomputedFee} (at rate ${impliedFeeRate})`
+    );
   }
   if (inputTotal > 0n && inputTotal < outputTotal + artifactFee) {
-    issues.push(`Economic violation: Total inputs (${inputTotal}) less than outputs + fee (${outputTotal + artifactFee})`);
+    issues.push(
+      `Economic violation: Total inputs (${inputTotal}) less than outputs + fee (${outputTotal + artifactFee})`
+    );
   }
   if (artifactFee < 0n) {
     issues.push("Economic violation: Negative fee detected");
@@ -577,17 +649,26 @@ function verifyLineage(artifact, parent, options = {}) {
   }
   const isHash = (s) => typeof s === "string" && /^[0-9a-f]{64}$/i.test(s);
   if (!lineage.artifactId || !lineage.lineageId || !lineage.rootArtifactId) {
-    addIssue("INVALID_LINEAGE_STRUCTURE", "Lineage block is missing required fields (artifactId, lineageId, or rootArtifactId)");
+    addIssue(
+      "INVALID_LINEAGE_STRUCTURE",
+      "Lineage block is missing required fields (artifactId, lineageId, or rootArtifactId)"
+    );
   } else {
-    if (!isHash(lineage.artifactId)) addIssue("INVALID_LINEAGE_FORMAT", "artifactId must be a 64-char hex string");
-    if (!isHash(lineage.lineageId)) addIssue("INVALID_LINEAGE_FORMAT", "lineageId must be a 64-char hex string");
-    if (!isHash(lineage.rootArtifactId)) addIssue("INVALID_LINEAGE_FORMAT", "rootArtifactId must be a 64-char hex string");
+    if (!isHash(lineage.artifactId))
+      addIssue("INVALID_LINEAGE_FORMAT", "artifactId must be a 64-char hex string");
+    if (!isHash(lineage.lineageId))
+      addIssue("INVALID_LINEAGE_FORMAT", "lineageId must be a 64-char hex string");
+    if (!isHash(lineage.rootArtifactId))
+      addIssue("INVALID_LINEAGE_FORMAT", "rootArtifactId must be a 64-char hex string");
     if (lineage.parentArtifactId && !isHash(lineage.parentArtifactId)) {
       addIssue("INVALID_LINEAGE_FORMAT", "parentArtifactId must be a 64-char hex string");
     }
   }
   if (artifact.contentHash && lineage.artifactId !== artifact.contentHash) {
-    addIssue("LINEAGE_IDENTITY_MISMATCH", `Lineage artifactId (${lineage.artifactId}) does not match contentHash (${artifact.contentHash})`);
+    addIssue(
+      "LINEAGE_IDENTITY_MISMATCH",
+      `Lineage artifactId (${lineage.artifactId}) does not match contentHash (${artifact.contentHash})`
+    );
   }
   if (parent) {
     const parentLineage = parent.lineage;
@@ -595,28 +676,50 @@ function verifyLineage(artifact, parent, options = {}) {
       addIssue("PARENT_MISSING_LINEAGE", "Parent artifact has no lineage metadata");
     } else {
       if (!lineage.parentArtifactId) {
-        addIssue("MISSING_PARENT_ID", "Artifact is missing parentArtifactId reference, but parent was provided for verification.");
+        addIssue(
+          "MISSING_PARENT_ID",
+          "Artifact is missing parentArtifactId reference, but parent was provided for verification."
+        );
       } else if (lineage.parentArtifactId !== parentLineage.artifactId) {
-        addIssue("PARENT_ID_MISMATCH", `Parent Artifact ID mismatch: expected ${parentLineage.artifactId}, got ${lineage.parentArtifactId}`);
+        addIssue(
+          "PARENT_ID_MISMATCH",
+          `Parent Artifact ID mismatch: expected ${parentLineage.artifactId}, got ${lineage.parentArtifactId}`
+        );
       }
       if (lineage.lineageId !== parentLineage.lineageId) {
-        addIssue("LINEAGE_ID_MISMATCH", `Lineage ID mismatch: expected ${parentLineage.lineageId}, got ${lineage.lineageId}`);
+        addIssue(
+          "LINEAGE_ID_MISMATCH",
+          `Lineage ID mismatch: expected ${parentLineage.lineageId}, got ${lineage.lineageId}`
+        );
       }
       if (lineage.rootArtifactId !== parentLineage.rootArtifactId) {
-        addIssue("ROOT_ARTIFACT_ID_MISMATCH", `Root Artifact ID mismatch: expected ${parentLineage.rootArtifactId}, got ${lineage.rootArtifactId}`);
+        addIssue(
+          "ROOT_ARTIFACT_ID_MISMATCH",
+          `Root Artifact ID mismatch: expected ${parentLineage.rootArtifactId}, got ${lineage.rootArtifactId}`
+        );
       }
       if (lineage.sequence !== void 0 && parentLineage.sequence !== void 0) {
         if (lineage.sequence <= parentLineage.sequence) {
           const severity = options.strict ? "error" : "warning";
-          addIssue("NON_MONOTONIC_SEQUENCE", `Non-monotonic sequence: current (${lineage.sequence}) <= parent (${parentLineage.sequence}).`, severity);
+          addIssue(
+            "NON_MONOTONIC_SEQUENCE",
+            `Non-monotonic sequence: current (${lineage.sequence}) <= parent (${parentLineage.sequence}).`,
+            severity
+          );
         }
       }
     }
     if (artifact.networkId !== parent.networkId) {
-      addIssue("NETWORK_MISMATCH", `Network mismatch: parent is ${parent.networkId}, current is ${artifact.networkId}`);
+      addIssue(
+        "NETWORK_MISMATCH",
+        `Network mismatch: parent is ${parent.networkId}, current is ${artifact.networkId}`
+      );
     }
     if (artifact.mode !== parent.mode) {
-      addIssue("MODE_MISMATCH", `Mode mismatch: parent is ${parent.mode}, current is ${artifact.mode}`);
+      addIssue(
+        "MODE_MISMATCH",
+        `Mode mismatch: parent is ${parent.mode}, current is ${artifact.mode}`
+      );
     }
     if (lineage.artifactId === lineage.parentArtifactId) {
       addIssue("SELF_PARENT", "Artifact cannot be its own parent.");
@@ -630,7 +733,10 @@ function verifyLineage(artifact, parent, options = {}) {
     };
     const allowed = validTransitions[parent.schema] || [];
     if (!allowed.includes(artifact.schema)) {
-      addIssue("INVALID_TRANSITION", `Invalid lineage transition: ${parent.schema} -> ${artifact.schema}`);
+      addIssue(
+        "INVALID_TRANSITION",
+        `Invalid lineage transition: ${parent.schema} -> ${artifact.schema}`
+      );
     }
   }
   return {
@@ -692,13 +798,19 @@ async function verifyArtifactIntegrity(artifactOrPath) {
       return result;
     }
     if (!v.version || !v.schema) {
-      addError("ARTIFACT_SCHEMA_MISSING", "Missing version or schema (Artifact might be v1 or legacy)");
+      addError(
+        "ARTIFACT_SCHEMA_MISSING",
+        "Missing version or schema (Artifact might be v1 or legacy)"
+      );
       return result;
     }
     const [currentMajor] = ARTIFACT_VERSION.split(".");
     const [artifactMajor] = v.version.split(".");
     if (currentMajor !== artifactMajor) {
-      addError("ARTIFACT_SCHEMA_INVALID", `Incompatible version: current system is v${currentMajor}, artifact is v${artifactMajor}`);
+      addError(
+        "ARTIFACT_SCHEMA_INVALID",
+        `Incompatible version: current system is v${currentMajor}, artifact is v${artifactMajor}`
+      );
       return result;
     }
     const hashVersion = v.hashVersion || 1;
@@ -707,7 +819,10 @@ async function verifyArtifactIntegrity(artifactOrPath) {
     if (!v.contentHash) {
       addError("ARTIFACT_HASH_MISMATCH", "Missing contentHash field");
     } else if (actualHash !== v.contentHash) {
-      addError("ARTIFACT_HASH_MISMATCH", `Hash mismatch: expected ${v.contentHash}, got ${actualHash}`);
+      addError(
+        "ARTIFACT_HASH_MISMATCH",
+        `Hash mismatch: expected ${v.contentHash}, got ${actualHash}`
+      );
     }
     let schema;
     switch (v.schema) {
@@ -739,9 +854,14 @@ async function verifyArtifactIntegrity(artifactOrPath) {
         });
       }
     } else {
-      addError("ARTIFACT_SCHEMA_INVALID", `Unsupported or unknown artifact schema: ${v.schema}`);
+      addError(
+        "ARTIFACT_SCHEMA_INVALID",
+        `Unsupported or unknown artifact schema: ${v.schema}`
+      );
     }
-    result.ok = result.issues.every((i) => i.severity !== "error" && i.severity !== "critical");
+    result.ok = result.issues.every(
+      (i) => i.severity !== "error" && i.severity !== "critical"
+    );
     return result;
   } catch (e) {
     if (e instanceof SyntaxError) {
@@ -765,7 +885,8 @@ function verifyArtifactSemantics(artifact, context = {}) {
   const addIssue = (issue) => {
     if (issue.severity === "error" || issue.severity === "critical") result.ok = false;
     result.issues.push(issue);
-    if (issue.severity === "error" || issue.severity === "critical") result.errors.push(issue.message);
+    if (issue.severity === "error" || issue.severity === "critical")
+      result.errors.push(issue.message);
   };
   const feeAudit = verifyFeeSemantics(artifact);
   if (!feeAudit.ok) {
@@ -803,13 +924,43 @@ function verifyArtifactSemantics(artifact, context = {}) {
     });
   }
   if (strict) {
-    if (!v.workflowId) addIssue({ code: "MISSING_WORKFLOW_ID", severity: "error", message: "Strict mode requires workflowId" });
-    if (!v.assumptionLevel && v.schema !== "hardkas.workflow.v1") addIssue({ code: "MISSING_ASSUMPTION_LEVEL", severity: "error", message: "Strict mode requires assumptionLevel" });
-    if (!v.executionMode && !v.mode) addIssue({ code: "MISSING_EXECUTION_MODE", severity: "error", message: "Strict mode requires executionMode" });
+    if (!v.workflowId)
+      addIssue({
+        code: "MISSING_WORKFLOW_ID",
+        severity: "error",
+        message: "Strict mode requires workflowId"
+      });
+    if (!v.assumptionLevel && v.schema !== "hardkas.workflow.v1")
+      addIssue({
+        code: "MISSING_ASSUMPTION_LEVEL",
+        severity: "error",
+        message: "Strict mode requires assumptionLevel"
+      });
+    if (!v.executionMode && !v.mode)
+      addIssue({
+        code: "MISSING_EXECUTION_MODE",
+        severity: "error",
+        message: "Strict mode requires executionMode"
+      });
   } else {
-    if (!v.workflowId) addIssue({ code: "MISSING_WORKFLOW_ID", severity: "warning", message: "Missing workflowId" });
-    if (!v.assumptionLevel && v.schema !== "hardkas.workflow.v1") addIssue({ code: "MISSING_ASSUMPTION_LEVEL", severity: "warning", message: "Missing assumptionLevel" });
-    if (!v.executionMode && !v.mode) addIssue({ code: "MISSING_EXECUTION_MODE", severity: "warning", message: "Missing executionMode" });
+    if (!v.workflowId)
+      addIssue({
+        code: "MISSING_WORKFLOW_ID",
+        severity: "warning",
+        message: "Missing workflowId"
+      });
+    if (!v.assumptionLevel && v.schema !== "hardkas.workflow.v1")
+      addIssue({
+        code: "MISSING_ASSUMPTION_LEVEL",
+        severity: "warning",
+        message: "Missing assumptionLevel"
+      });
+    if (!v.executionMode && !v.mode)
+      addIssue({
+        code: "MISSING_EXECUTION_MODE",
+        severity: "warning",
+        message: "Missing executionMode"
+      });
   }
   const networkId = context.networkId || v.networkId;
   const networkIdStr = networkId;
@@ -840,11 +991,13 @@ function verifyArtifactSemantics(artifact, context = {}) {
 async function verifyArtifactReplay(artifact, _context = {}) {
   return {
     ok: false,
-    issues: [{
-      code: "REPLAY_UNSUPPORTED_CHECK",
-      severity: "warning",
-      message: "Replay verification (full consensus simulation) is currently unsupported in this build."
-    }],
+    issues: [
+      {
+        code: "REPLAY_UNSUPPORTED_CHECK",
+        severity: "warning",
+        message: "Replay verification (full consensus simulation) is currently unsupported in this build."
+      }
+    ],
     errors: ["Replay verification (consensus) unsupported"]
   };
 }
@@ -863,12 +1016,16 @@ var HashInvariant = class {
     if (typeof contentHash !== "string") return [];
     const actualHash = calculateContentHash(v);
     if (actualHash !== contentHash) {
-      return [{
-        code: this.id,
-        severity: "error",
-        message: `Hash mismatch: expected ${contentHash}, got ${actualHash}`,
-        metadata: { artifactId: typeof v.artifactId === "string" ? v.artifactId : void 0 }
-      }];
+      return [
+        {
+          code: this.id,
+          severity: "error",
+          message: `Hash mismatch: expected ${contentHash}, got ${actualHash}`,
+          metadata: {
+            artifactId: typeof v.artifactId === "string" ? v.artifactId : void 0
+          }
+        }
+      ];
     }
     return [];
   }
@@ -883,19 +1040,23 @@ var SchemaInvariant = class {
     const schema = v.schema;
     const version = v.version;
     if (typeof schema !== "string" || typeof version !== "string") {
-      return [{
-        code: this.id,
-        severity: "error",
-        message: "Artifact missing schema or version metadata"
-      }];
+      return [
+        {
+          code: this.id,
+          severity: "error",
+          message: "Artifact missing schema or version metadata"
+        }
+      ];
     }
     const supportedSchemas = Object.values(ARTIFACT_SCHEMAS);
     if (!supportedSchemas.includes(schema)) {
-      return [{
-        code: this.id,
-        severity: "error",
-        message: `Unsupported schema: ${schema}`
-      }];
+      return [
+        {
+          code: this.id,
+          severity: "error",
+          message: `Unsupported schema: ${schema}`
+        }
+      ];
     }
     return [];
   }
@@ -938,12 +1099,16 @@ var BasicLineageInvariant = class {
     if (!lineage || typeof parentArtifactId !== "string" || !artifactStore) return [];
     const parent = await artifactStore.getArtifact(parentArtifactId);
     if (!parent) {
-      return [{
-        code: this.id,
-        severity: "warning",
-        message: `Parent artifact ${parentArtifactId} not found in store`,
-        metadata: { childId: typeof v.artifactId === "string" ? v.artifactId : void 0 }
-      }];
+      return [
+        {
+          code: this.id,
+          severity: "warning",
+          message: `Parent artifact ${parentArtifactId} not found in store`,
+          metadata: {
+            childId: typeof v.artifactId === "string" ? v.artifactId : void 0
+          }
+        }
+      ];
     }
     return [];
   }
@@ -971,7 +1136,13 @@ var ReplayInvariant = class {
 };
 
 // src/invariants/watcher.ts
-import { createEventEnvelope, asWorkflowId, asCorrelationId, asNetworkId, asEventSequence } from "@hardkas/core";
+import {
+  createEventEnvelope,
+  asWorkflowId,
+  asCorrelationId,
+  asNetworkId,
+  asEventSequence
+} from "@hardkas/core";
 var InvariantWatcher = class {
   invariants;
   eventBus;
@@ -1109,9 +1280,7 @@ function getMigrationPath(fromVersion, toVersion) {
   visited.add(fromVersion);
   while (queue.length > 0) {
     const current = queue.shift();
-    const outgoing = migrationRegistry.filter(
-      (s) => s.fromVersion === current.version
-    );
+    const outgoing = migrationRegistry.filter((s) => s.fromVersion === current.version);
     for (const step of outgoing) {
       const newPath = [...current.path, step];
       if (step.toVersion === toVersion) {
@@ -1210,7 +1379,9 @@ async function readArtifact(filePath) {
     if (error.code === "ENOENT") {
       throw new Error(`Artifact file not found at ${filePath}`);
     }
-    throw new Error(`Failed to read/parse artifact at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    throw new Error(
+      `Failed to read/parse artifact at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
 }
 async function readTxPlanArtifact(filePath) {
@@ -1297,13 +1468,20 @@ function formatSignedTxArtifact(artifact) {
   lines.push("");
   lines.push(`Network:      ${artifact.networkId}`);
   lines.push(`Mode:         ${artifact.mode}`);
+  lines.push(`Status:       ${(artifact.status || "signed").toUpperCase()}`);
   lines.push("");
   lines.push(`From:         ${artifact.from.address}`);
   lines.push(`To:           ${artifact.to.address}`);
   lines.push(`Amount:       ${formatSompi(BigInt(artifact.amountSompi))}`);
   lines.push("");
-  lines.push(`Format:       ${artifact.signedTransaction.format}`);
-  lines.push(`Tx ID:        ${artifact.txId || "unknown (pending broadcast)"}`);
+  if (artifact.signedTransaction) {
+    lines.push(`Format:       ${artifact.signedTransaction.format}`);
+    lines.push(`Tx ID:        ${artifact.txId || "unknown (pending broadcast)"}`);
+  } else if (artifact.multisig) {
+    lines.push(
+      `Signatures:   ${artifact.multisig.signatures.length} of ${artifact.multisig.threshold} collected`
+    );
+  }
   return lines.join("\n");
 }
 
@@ -1330,7 +1508,12 @@ function utxoFromArtifact(artifact) {
     address: artifact.address,
     amountSompi: safeParseBigInt(artifact.amountSompi, "UtxoArtifact.amountSompi"),
     scriptPublicKey: artifact.scriptPublicKey,
-    ...artifact.blockDaaScore !== void 0 ? { blockDaaScore: safeParseBigInt(artifact.blockDaaScore, "UtxoArtifact.blockDaaScore") } : {},
+    ...artifact.blockDaaScore !== void 0 ? {
+      blockDaaScore: safeParseBigInt(
+        artifact.blockDaaScore,
+        "UtxoArtifact.blockDaaScore"
+      )
+    } : {},
     ...artifact.isCoinbase !== void 0 ? { isCoinbase: artifact.isCoinbase } : {}
   };
 }
@@ -1388,7 +1571,8 @@ function createTxPlanArtifact(options) {
       address: o.address,
       amountSompi: o.amountSompi.toString()
     })),
-    rpcUrl: options.rpcUrl
+    rpcUrl: options.rpcUrl,
+    ...options.ctx.workflowId ? { workflowId: options.ctx.workflowId } : {}
   };
   if (options.plan.change) {
     artifact.change = {
@@ -1422,7 +1606,8 @@ function createSimulatedSignedTxArtifact(plan, payload, ctx) {
     signedTransaction: {
       format: "simulated",
       payload
-    }
+    },
+    ...plan.workflowId ? { workflowId: plan.workflowId } : {}
   };
   const hash = calculateContentHash(artifact, CURRENT_HASH_VERSION);
   artifact.signedId = `signed-${hash.slice(0, 16)}`;
@@ -1451,7 +1636,8 @@ function createSimulatedTxReceipt(plan, txId, ctx, extra) {
     daaScore: extra?.daaScore,
     preStateHash: extra?.preStateHash,
     postStateHash: extra?.postStateHash,
-    dagContext: extra?.dagContext
+    dagContext: extra?.dagContext,
+    ...plan.workflowId ? { workflowId: plan.workflowId } : {}
   };
   const hash = calculateContentHash(artifact, CURRENT_HASH_VERSION);
   artifact.contentHash = hash;
@@ -1470,13 +1656,17 @@ function getBroadcastableSignedTransaction(artifact) {
 // src/validate.ts
 function validateTxPlanArtifact(value) {
   const errors = [];
-  if (typeof value !== "object" || value === null) return { ok: false, errors: ["Artifact must be an object"] };
+  if (typeof value !== "object" || value === null)
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = value;
-  if (v.schema !== ARTIFACT_SCHEMAS.TX_PLAN) errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.TX_PLAN}'`);
+  if (v.schema !== ARTIFACT_SCHEMAS.TX_PLAN)
+    errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.TX_PLAN}'`);
   validateCommon2(v, errors);
   if (typeof v.planId !== "string" || !v.planId) errors.push("Missing planId");
-  if (!v.from || typeof v.from.address !== "string") errors.push("Missing or invalid 'from' address");
-  if (!v.to || typeof v.to.address !== "string") errors.push("Missing or invalid 'to' address");
+  if (!v.from || typeof v.from.address !== "string")
+    errors.push("Missing or invalid 'from' address");
+  if (!v.to || typeof v.to.address !== "string")
+    errors.push("Missing or invalid 'to' address");
   assertDecimalBigIntString2(v.amountSompi, "amountSompi", errors);
   if (!Array.isArray(v.inputs)) errors.push("Missing or invalid 'inputs' array");
   if (!Array.isArray(v.outputs)) errors.push("Missing or invalid 'outputs' array");
@@ -1484,18 +1674,24 @@ function validateTxPlanArtifact(value) {
 }
 function assertValidTxPlanArtifact(value) {
   const result = validateTxPlanArtifact(value);
-  if (!result.ok) throw new Error(`Invalid tx plan artifact:
-${result.errors.map((e) => `- ${e}`).join("\n")}`);
+  if (!result.ok)
+    throw new Error(
+      `Invalid tx plan artifact:
+${result.errors.map((e) => `- ${e}`).join("\n")}`
+    );
 }
 function validateSignedTxArtifact(value) {
   const errors = [];
-  if (typeof value !== "object" || value === null) return { ok: false, errors: ["Artifact must be an object"] };
+  if (typeof value !== "object" || value === null)
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = value;
-  if (v.schema !== ARTIFACT_SCHEMAS.SIGNED_TX) errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.SIGNED_TX}'`);
+  if (v.schema !== ARTIFACT_SCHEMAS.SIGNED_TX)
+    errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.SIGNED_TX}'`);
   validateCommon2(v, errors);
   if (v.status !== "signed") errors.push("Invalid status: expected 'signed'");
   if (typeof v.signedId !== "string" || !v.signedId) errors.push("Missing signedId");
-  if (typeof v.sourcePlanId !== "string" || !v.sourcePlanId) errors.push("Missing sourcePlanId");
+  if (typeof v.sourcePlanId !== "string" || !v.sourcePlanId)
+    errors.push("Missing sourcePlanId");
   if (!v.signedTransaction) {
     errors.push("Missing signedTransaction object");
   } else {
@@ -1508,16 +1704,22 @@ function validateSignedTxArtifact(value) {
 }
 function assertValidSignedTxArtifact(value) {
   const result = validateSignedTxArtifact(value);
-  if (!result.ok) throw new Error(`Invalid signed tx artifact:
-${result.errors.map((e) => `- ${e}`).join("\n")}`);
+  if (!result.ok)
+    throw new Error(
+      `Invalid signed tx artifact:
+${result.errors.map((e) => `- ${e}`).join("\n")}`
+    );
 }
 function validateTxReceiptArtifact(value) {
   const errors = [];
-  if (typeof value !== "object" || value === null) return { ok: false, errors: ["Artifact must be an object"] };
+  if (typeof value !== "object" || value === null)
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = value;
-  if (v.schema !== ARTIFACT_SCHEMAS.TX_RECEIPT) errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.TX_RECEIPT}'`);
+  if (v.schema !== ARTIFACT_SCHEMAS.TX_RECEIPT)
+    errors.push(`Invalid schema: expected '${ARTIFACT_SCHEMAS.TX_RECEIPT}'`);
   validateCommon2(v, errors);
-  if (!["submitted", "confirmed", "failed"].includes(v.status)) errors.push("Invalid status");
+  if (!["submitted", "confirmed", "failed"].includes(v.status))
+    errors.push("Invalid status");
   if (typeof v.txId !== "string" || !v.txId) errors.push("Missing txId");
   assertDecimalBigIntString2(v.amountSompi, "amountSompi", errors);
   assertDecimalBigIntString2(v.feeSompi, "feeSompi", errors);
@@ -1525,11 +1727,15 @@ function validateTxReceiptArtifact(value) {
 }
 function assertValidTxReceiptArtifact(value) {
   const result = validateTxReceiptArtifact(value);
-  if (!result.ok) throw new Error(`Invalid tx receipt artifact:
-${result.errors.map((e) => `- ${e}`).join("\n")}`);
+  if (!result.ok)
+    throw new Error(
+      `Invalid tx receipt artifact:
+${result.errors.map((e) => `- ${e}`).join("\n")}`
+    );
 }
 function validateArtifact(data) {
-  if (!data || typeof data !== "object") return { ok: false, errors: ["Artifact must be an object"] };
+  if (!data || typeof data !== "object")
+    return { ok: false, errors: ["Artifact must be an object"] };
   const v = data;
   const schema = v.schema;
   switch (schema) {
@@ -1552,7 +1758,8 @@ function validateArtifact(data) {
 function validateCommon2(v, errors) {
   if (!v.hardkasVersion) errors.push("Missing hardkasVersion");
   if (typeof v.networkId !== "string" || !v.networkId) errors.push("Missing networkId");
-  if (!["simulated", "node", "rpc", "l2-rpc", "real"].includes(v.mode)) errors.push("Invalid mode");
+  if (!["simulated", "node", "rpc", "l2-rpc", "real"].includes(v.mode))
+    errors.push("Invalid mode");
   if (!v.createdAt) errors.push("Missing createdAt");
 }
 function assertDecimalBigIntString2(value, field, errors) {
@@ -1589,9 +1796,18 @@ async function explainArtifact(artifactUnknown) {
     security: {
       strictOk: status === "valid",
       issues: [
-        ...integrity.issues.map((i) => ({ ...i, severity: i.severity })),
-        ...semantic.issues.map((i) => ({ ...i, severity: i.severity })),
-        ...lineage.issues.map((i) => ({ ...i, severity: i.severity }))
+        ...integrity.issues.map((i) => ({
+          ...i,
+          severity: i.severity
+        })),
+        ...semantic.issues.map((i) => ({
+          ...i,
+          severity: i.severity
+        })),
+        ...lineage.issues.map((i) => ({
+          ...i,
+          severity: i.severity
+        }))
       ]
     },
     metadata: artifact.metadata || {}
@@ -1603,9 +1819,17 @@ async function explainArtifact(artifactUnknown) {
     let changeAmount = 0n;
     if (type === "txPlan") {
       const plan = artifact;
-      inputTotal = (plan.inputs || []).reduce((sum, i) => sum + BigInt(i.amountSompi || 0), 0n);
-      outputTotal = (plan.outputs || []).reduce((sum, o) => sum + BigInt(o.amountSompi || 0), 0n);
-      changeAmount = plan.change ? BigInt(plan.change.amountSompi || 0) : 0n;
+      inputTotal = (plan.inputs || []).reduce(
+        (sum, i) => sum + BigInt(i.amountSompi || 0),
+        0n
+      );
+      outputTotal = (plan.outputs || []).reduce(
+        (sum, o) => sum + BigInt(o.amountSompi || 0),
+        0n
+      );
+      changeAmount = plan.change ? BigInt(
+        plan.change.amountSompi || 0
+      ) : 0n;
     }
     explanation.economics = {
       ok: feeAudit.ok,
@@ -1678,7 +1902,9 @@ async function listIgraTxReceiptArtifacts(options) {
 }
 function validateTxHash(txHash) {
   if (!/^0x[a-fA-F0-9]{64}$/.test(txHash)) {
-    throw new Error(`Invalid EVM txHash: must be a 0x-prefixed 64-character hex string. Got: ${txHash}`);
+    throw new Error(
+      `Invalid EVM txHash: must be a 0x-prefixed 64-character hex string. Got: ${txHash}`
+    );
   }
 }
 
@@ -1757,7 +1983,10 @@ function createDeploymentRecord(opts) {
     ...opts.payloadHash ? { payloadHash: opts.payloadHash } : {},
     ...opts.notes ? { notes: opts.notes } : {}
   };
-  const contentHash = calculateContentHash(recordDraft, CURRENT_HASH_VERSION);
+  const contentHash = calculateContentHash(
+    recordDraft,
+    CURRENT_HASH_VERSION
+  );
   return {
     ...recordDraft,
     contentHash
@@ -1770,7 +1999,10 @@ function updateDeploymentStatus(record, newStatus, txId) {
     deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...txId ? { txId } : {}
   };
-  const contentHash = calculateContentHash(updatedDraft, CURRENT_HASH_VERSION);
+  const contentHash = calculateContentHash(
+    updatedDraft,
+    CURRENT_HASH_VERSION
+  );
   return {
     ...updatedDraft,
     contentHash
@@ -1789,7 +2021,13 @@ async function saveDeployment(rootDir, record) {
   return targetPath;
 }
 async function loadDeployment(rootDir, networkId, label) {
-  const targetPath = path3.join(rootDir, ".hardkas", "deployments", networkId, `${label}.json`);
+  const targetPath = path3.join(
+    rootDir,
+    ".hardkas",
+    "deployments",
+    networkId,
+    `${label}.json`
+  );
   if (!existsSync(targetPath)) return null;
   const content = await fs4.readFile(targetPath, "utf-8");
   return JSON.parse(content);
@@ -1821,7 +2059,9 @@ async function listDeployments(rootDir, networkId) {
       }
     }
   }
-  return summaries.sort((a, b) => new Date(b.deployedAt).getTime() - new Date(a.deployedAt).getTime());
+  return summaries.sort(
+    (a, b) => new Date(b.deployedAt).getTime() - new Date(a.deployedAt).getTime()
+  );
 }
 async function updateDeployment(rootDir, networkId, label, update) {
   const existing = await loadDeployment(rootDir, networkId, label);
@@ -1837,7 +2077,13 @@ async function updateDeployment(rootDir, networkId, label, update) {
   return updated;
 }
 async function deleteDeployment(rootDir, networkId, label) {
-  const targetPath = path3.join(rootDir, ".hardkas", "deployments", networkId, `${label}.json`);
+  const targetPath = path3.join(
+    rootDir,
+    ".hardkas",
+    "deployments",
+    networkId,
+    `${label}.json`
+  );
   if (!existsSync(targetPath)) return false;
   await fs4.unlink(targetPath);
   return true;
@@ -1865,6 +2111,8 @@ export {
   SchemaInvariant,
   ScriptCapabilitySchema,
   ScriptMetadataSchema,
+  SignatureEntrySchema,
+  SignatureMetadataEntrySchema,
   SignedTxSchema,
   SnapshotSchema,
   TxPlanSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/artifacts",
-  "version": "0.7.1-alpha",
+  "version": "0.7.4-alpha",
   "type": "module",
   "license": "MIT",
   "author": "Javier Rodriguez",
@@ -24,8 +24,8 @@
   "types": "./dist/index.d.ts",
   "dependencies": {
     "zod": "^3.24.1",
-    "@hardkas/core": "0.7.1-alpha",
-    "@hardkas/tx-builder": "0.7.1-alpha"
+    "@hardkas/tx-builder": "0.7.4-alpha",
+    "@hardkas/core": "0.7.4-alpha"
   },
   "devDependencies": {
     "tsup": "^8.3.5",