@hardkas/sdk 0.8.2-alpha → 0.8.4-alpha

package/dist/index.d.ts

@@ -66,6 +66,9 @@ declare class HardkasTx {
         amount: string | number | bigint;
         feeRate?: bigint;
         workflowId?: string;
+        policy?: string;
+        networkProfile?: string;
+        assumption?: string;
     }): Promise<TxPlanArtifact>;
     /**
      * Signs a transaction plan.
@@ -280,10 +283,18 @@ declare class HardkasArtifactsManager {
     private workspace;
     private cache;
     constructor(workspace: HardkasWorkspace);
+    /**
+     * Caches an in-memory artifact.
+     */
+    cacheArtifact(artifact: any): void;
     /**
      * Writes a valid artifact to disk (canonical or custom path).
      */
     write(artifact: HardkasArtifactBase, options?: WriteArtifactOptions): Promise<WriteArtifactResult>;
+    /**
+     * Retrieves an artifact from the in-memory cache.
+     */
+    getCached(id: string): any;
     /**
      * Reads an artifact by path or ID/hash from the workspace.
      */
@@ -306,6 +317,8 @@ declare class HardkasArtifactsManager {
      */
     verify(target: any, options?: {
         throwOnInvalid?: boolean;
+        strict?: boolean;
+        enforceMetadata?: boolean;
     }): Promise<any>;
 }
 

package/dist/index.js

@@ -200,7 +200,7 @@ var HardkasTx = class {
       feeRateSompiPerMass: options.feeRate ?? 1n
     });
     const isSimulated = activeNetwork === "simulated" || this.sdk.config.config.networks?.[activeNetwork]?.kind === "simulated";
-    return createTxPlanArtifact({
+    const basePlan = createTxPlanArtifact({
       networkId: activeNetwork,
       mode: isSimulated ? "simulated" : "real",
       from: {
@@ -216,13 +216,63 @@ var HardkasTx = class {
       plan: builderPlan,
       ctx: options.workflowId ? { ...systemRuntimeContext, workflowId: options.workflowId } : systemRuntimeContext
     });
+    if (options.policy || options.policies) {
+      const inputPolicies = options.policies || (options.policy ? [options.policy] : []);
+      const resolvedRefs = [];
+      for (const p of inputPolicies) {
+        try {
+          const pol = await this.sdk.artifacts.read(p);
+          resolvedRefs.push(pol.contentHash || pol.artifactId || p);
+        } catch (e) {
+          resolvedRefs.push(p);
+        }
+      }
+      if (resolvedRefs.length > 0) {
+        basePlan.policyRefs = resolvedRefs;
+        basePlan.policyRef = resolvedRefs[0];
+      }
+    }
+    if (options.networkProfile) {
+      try {
+        const net = await this.sdk.artifacts.read(options.networkProfile);
+        basePlan.networkProfileRef = net.contentHash || net.artifactId || options.networkProfile;
+      } catch (e) {
+        basePlan.networkProfileRef = options.networkProfile;
+      }
+    }
+    if (options.assumption) {
+      try {
+        const asm = await this.sdk.artifacts.read(options.assumption);
+        basePlan.assumptionRef = asm.contentHash || asm.artifactId || options.assumption;
+      } catch (e) {
+        basePlan.assumptionRef = options.assumption;
+      }
+    }
+    const { CURRENT_HASH_VERSION: CURRENT_HASH_VERSION2, calculateContentHash: calculateContentHash2 } = await import("@hardkas/artifacts");
+    const newHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+    basePlan.contentHash = newHash;
+    if (basePlan.lineage) {
+      basePlan.lineage.artifactId = newHash;
+      basePlan.lineage.parentArtifactId = newHash;
+      basePlan.lineage.rootArtifactId = newHash;
+      const finalHash = calculateContentHash2(basePlan, CURRENT_HASH_VERSION2);
+      basePlan.contentHash = finalHash;
+      basePlan.lineage.artifactId = finalHash;
+      basePlan.lineage.parentArtifactId = finalHash;
+      basePlan.lineage.rootArtifactId = finalHash;
+    }
+    this.sdk.artifacts.cacheArtifact(basePlan);
+    if (basePlan.policyRefs && basePlan.policyRefs.length > 0) {
+      await this.sdk.artifacts.verify(basePlan, { throwOnInvalid: true, strict: true, enforceMetadata: false });
+    }
+    return basePlan;
   }
   /**
    * Signs a transaction plan.
    */
   async sign(plan, account, options) {
     if (typeof plan === "object" && plan !== null && plan.contentHash) {
-      await this.sdk.artifacts.verify(plan, { throwOnInvalid: true });
+      await this.sdk.artifacts.verify(plan, { throwOnInvalid: true, strict: true, enforceMetadata: false });
     }
     let resolvedAccount;
     if (typeof account === "string") {
@@ -301,7 +351,7 @@ var HardkasTx = class {
         lineage: {
           artifactId: "",
           // To be computed from contentHash
-          lineageId: partialTx.lineage?.lineageId || `lineage-${Math.random().toString(36).slice(2, 10)}`,
+          lineageId: partialTx.lineage?.lineageId || partialTx.contentHash || "0".repeat(64),
           parentArtifactId: partialTx.contentHash || partialTx.signedId,
           rootArtifactId: partialTx.lineage?.rootArtifactId || partialTx.sourcePlanId
         }
@@ -320,7 +370,7 @@ var HardkasTx = class {
       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;
+      if (draft.lineage) draft.lineage.artifactId = hash;
       signedArtifact = draft;
     } else if (plan.schema === "hardkas.txPlan") {
       if (options?.append) {
@@ -385,7 +435,7 @@ var HardkasTx = class {
           lineage: {
             artifactId: "",
             // To be computed
-            lineageId: plan.lineage?.lineageId || `lineage-${Math.random().toString(36).slice(2, 10)}`,
+            lineageId: plan.lineage?.lineageId || plan.contentHash || "0".repeat(64),
             parentArtifactId: plan.contentHash || plan.planId,
             rootArtifactId: plan.contentHash || plan.planId
           },
@@ -401,7 +451,7 @@ var HardkasTx = class {
         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;
+        if (draft.lineage) draft.lineage.artifactId = hash;
         signedArtifact = draft;
       } else {
         if (resolvedAccount.address !== plan.from.address) {
@@ -444,9 +494,22 @@ var HardkasTx = class {
    */
   async simulate(target, options = {}) {
     if (typeof target === "object" && target !== null && target.contentHash) {
-      await this.sdk.artifacts.verify(target, { throwOnInvalid: true });
+      await this.sdk.artifacts.verify(target, { throwOnInvalid: true, strict: true, enforceMetadata: false });
     }
     const persist = options.persist ?? true;
+    if (typeof target === "object" && target !== null) {
+      const checkTxId = target.txId || (target.schema === ARTIFACT_SCHEMAS.SIGNED_TX ? `simulated-${target.sourcePlanId || "unknown"}-tx` : `simulated-${target.planId || target.id || "unknown"}-tx`);
+      if (checkTxId) {
+        try {
+          const existingReceipt = await this.sdk.artifacts.read(checkTxId, { expectedSchema: ARTIFACT_SCHEMAS.TX_RECEIPT });
+          if (existingReceipt && existingReceipt.schema === ARTIFACT_SCHEMAS.TX_RECEIPT) {
+            const receiptPath2 = getDefaultReceiptPath(checkTxId, this.sdk.config.cwd);
+            return { receipt: existingReceipt, receiptPath: receiptPath2 };
+          }
+        } catch (e) {
+        }
+      }
+    }
     const {
       loadOrCreateLocalnetState,
       saveLocalnetState,
@@ -477,10 +540,13 @@ var HardkasTx = class {
       signedId = targetObj.signedId || targetObj.id || "unknown";
       sourcePlanId = targetObj.sourcePlanId || "unknown";
       txId = targetObj.txId || `simulated-${sourcePlanId}-tx`;
-      try {
-        planArtifact = await this.sdk.artifacts.read(sourcePlanId, { expectedSchema: ARTIFACT_SCHEMAS.TX_PLAN });
-      } catch (e) {
-        planArtifact = targetObj;
+      planArtifact = this.sdk.artifacts.getCached(sourcePlanId);
+      if (!planArtifact) {
+        try {
+          planArtifact = await this.sdk.artifacts.read(sourcePlanId, { expectedSchema: ARTIFACT_SCHEMAS.TX_PLAN });
+        } catch (e) {
+          throw new Error("parent_plan_unresolved");
+        }
       }
     } else {
       planArtifact = targetObj;
@@ -546,9 +612,22 @@ var HardkasTx = class {
       submittedAt: simResult.receipt.createdAt,
       confirmedAt: simResult.receipt.createdAt,
       rpcUrl: "simulated://local",
-      tracePath
+      tracePath,
+      lineage: {
+        artifactId: "",
+        // To be computed
+        lineageId: targetObj.lineage?.lineageId || targetObj.contentHash || "0".repeat(64),
+        parentArtifactId: targetObj.contentHash || "0".repeat(64),
+        rootArtifactId: targetObj.lineage?.rootArtifactId || "0".repeat(64),
+        sequence: (targetObj.lineage?.sequence || 1) + 1
+      }
     };
     receiptBase.contentHash = calculateContentHash(receiptBase, CURRENT_HASH_VERSION);
+    if (receiptBase.lineage) {
+      receiptBase.lineage.artifactId = receiptBase.contentHash;
+      receiptBase.contentHash = calculateContentHash(receiptBase, CURRENT_HASH_VERSION);
+      receiptBase.lineage.artifactId = receiptBase.contentHash;
+    }
     const receipt = Object.freeze(receiptBase);
     const traceSteps = events.map((ev) => ({
       phase: ev.phase || ev.message || "unknown",
@@ -606,7 +685,7 @@ var HardkasTx = class {
    */
   async send(signedArtifact, urlOrOptions) {
     if (typeof signedArtifact === "object" && signedArtifact !== null && signedArtifact.contentHash) {
-      await this.sdk.artifacts.verify(signedArtifact, { throwOnInvalid: true });
+      await this.sdk.artifacts.verify(signedArtifact, { throwOnInvalid: true, strict: true, enforceMetadata: false });
     }
     const verification = verifySignedTxSemantics(signedArtifact);
     if (!verification.ok) {
@@ -687,12 +766,26 @@ var HardkasTx = class {
       feeSompi: signedArtifact.metadata?.estimatedFeeSompi || "0",
       submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...url ? { rpcUrl: url } : {},
-      ...signedArtifact.workflowId ? { workflowId: signedArtifact.workflowId } : {}
+      ...signedArtifact.workflowId ? { workflowId: signedArtifact.workflowId } : {},
+      tracePath: void 0,
+      lineage: {
+        artifactId: "",
+        // To be computed
+        lineageId: signedArtifact.lineage?.lineageId || signedArtifact.contentHash || "0".repeat(64),
+        parentArtifactId: signedArtifact.contentHash || "0".repeat(64),
+        rootArtifactId: signedArtifact.lineage?.rootArtifactId || "0".repeat(64),
+        sequence: (signedArtifact.lineage?.sequence || 1) + 1
+      }
     };
     realReceiptBase.contentHash = calculateContentHash(
       realReceiptBase,
       CURRENT_HASH_VERSION
     );
+    if (realReceiptBase.lineage) {
+      realReceiptBase.lineage.artifactId = realReceiptBase.contentHash;
+      realReceiptBase.contentHash = calculateContentHash(realReceiptBase, CURRENT_HASH_VERSION);
+      realReceiptBase.lineage.artifactId = realReceiptBase.contentHash;
+    }
     const receipt = realReceiptBase;
     const receiptPath = getDefaultReceiptPath(receipt.txId, this.sdk.config.cwd);
     await writeArtifact(receiptPath, receipt);
@@ -997,8 +1090,20 @@ var HardkasReplay = class {
    * against the mathematically reconstructed localnet state.
    */
   async verify(targetOrOptions, options) {
+    const throwOnInvalid = options?.throwOnInvalid !== false;
     if (typeof targetOrOptions === "object" && targetOrOptions !== null && targetOrOptions.contentHash) {
-      await this.sdk.artifacts.verify(targetOrOptions, { throwOnInvalid: true });
+      const verifyRes = await this.sdk.artifacts.verify(targetOrOptions, { throwOnInvalid, strict: true });
+      if (!verifyRes.valid && !throwOnInvalid) {
+        return {
+          passed: false,
+          artifactsScanned: 1,
+          lineage: "invalid",
+          determinism: "failed",
+          contamination: "clean",
+          report: null,
+          error: `Artifact verification failed: ${verifyRes.reason}`
+        };
+      }
     }
     let opts = options || {};
     if (typeof targetOrOptions === "string") {
@@ -1247,6 +1352,17 @@ var HardkasArtifactsManager = class {
   }
   workspace;
   cache = /* @__PURE__ */ new Map();
+  /**
+   * Caches an in-memory artifact.
+   */
+  cacheArtifact(artifact) {
+    const record = artifact;
+    const hash = record.contentHash || "unknown";
+    if (record.planId) this.cache.set(record.planId, artifact);
+    if (record.signedId) this.cache.set(record.signedId, artifact);
+    if (record.txId) this.cache.set(record.txId, artifact);
+    this.cache.set(hash, artifact);
+  }
   /**
    * Writes a valid artifact to disk (canonical or custom path).
    */
@@ -1306,17 +1422,16 @@ var HardkasArtifactsManager = class {
       contentHash: hash
     };
   }
+  /**
+   * Retrieves an artifact from the in-memory cache.
+   */
+  getCached(id) {
+    return this.cache.get(id);
+  }
   /**
    * Reads an artifact by path or ID/hash from the workspace.
    */
   async read(id, options) {
-    if (this.cache.has(id)) {
-      const cached = this.cache.get(id);
-      if (options?.expectedSchema && cached.schema !== options.expectedSchema) {
-        throw new Error(`Artifact ${id} has schema '${cached.schema}' but expected '${options.expectedSchema}'`);
-      }
-      return cached;
-    }
     const { readArtifact } = await import("@hardkas/artifacts");
     let filePath = id;
     let resolvedPath = path3.resolve(this.workspace.root, filePath);
@@ -1333,7 +1448,27 @@ var HardkasArtifactsManager = class {
       if (!fs3.existsSync(filePath)) {
         if (fs3.existsSync(this.workspace.artifactsDir)) {
           const files = fs3.readdirSync(this.workspace.artifactsDir);
-          const found = files.find((f) => f === `${id}.json` || f.startsWith(`${id}-`) || f.startsWith(`${id}.`));
+          let found = files.find(
+            (f) => f === `${id}.json` || f.startsWith(`${id}-`) || f.startsWith(`${id}.`) || f.endsWith(`-${id}.json`) || f.endsWith(`-${id}.plan.json`) || f.endsWith(`-${id}.signed.json`) || f.endsWith(`-${id}.receipt.json`)
+          );
+          if (!found) {
+            const shortId = id.startsWith("plan-") || id.startsWith("signed-") ? id : id.slice(0, 16);
+            for (const file of files) {
+              if (!file.endsWith(".json")) continue;
+              if (file.includes(id) || file.includes(shortId) || file.includes(id.slice(0, 8))) {
+                const fp = path3.join(this.workspace.artifactsDir, file);
+                try {
+                  const content = fs3.readFileSync(fp, "utf-8");
+                  const obj = JSON.parse(content);
+                  if (obj.contentHash === id || obj.artifactId === id || obj.planId === id || obj.signedId === id || obj.txId === id) {
+                    found = file;
+                    break;
+                  }
+                } catch {
+                }
+              }
+            }
+          }
           if (found) {
             filePath = path3.join(this.workspace.artifactsDir, found);
           } else {
@@ -1383,6 +1518,8 @@ var HardkasArtifactsManager = class {
    */
   async verify(target, options = {}) {
     const throwOnInvalid = options.throwOnInvalid ?? true;
+    const strict = options.strict ?? false;
+    const enforceMetadata = options.enforceMetadata ?? true;
     let artifact;
     let id;
     if (typeof target === "string") {
@@ -1401,10 +1538,23 @@ var HardkasArtifactsManager = class {
       artifact = target;
       id = artifact.artifactId || artifact.contentHash || "";
     }
-    const { verifyArtifactIntegrity: verifyArtifactIntegrity2 } = await import("@hardkas/artifacts");
+    const { verifyArtifactIntegrity: verifyArtifactIntegrity2, verifyArtifactSemantics } = await import("@hardkas/artifacts");
     const result = await verifyArtifactIntegrity2(artifact);
+    if (result.ok && strict) {
+      const semResult = verifyArtifactSemantics(artifact, {
+        strict: true,
+        artifactsDir: this.workspace.artifactsDir,
+        enforceMetadata,
+        resolveArtifact: (id2) => this.cache.get(id2)
+      });
+      if (!semResult.ok) {
+        result.ok = false;
+        result.errors.push(...semResult.errors);
+        result.issues.push(...semResult.issues);
+      }
+    }
     if (!result.ok) {
-      const mappedReason = result.issues[0]?.code === "HASH_MISMATCH" ? "content_hash_mismatch" : result.issues[0]?.code === "MISSING_CONTENT_HASH" ? "missing_content_hash" : result.issues[0]?.code === "MISSING_SIGNATURE" ? "missing_signature" : "schema_invalid";
+      const mappedReason = result.issues[0]?.code === "HASH_MISMATCH" ? "content_hash_mismatch" : result.issues[0]?.code === "MISSING_CONTENT_HASH" ? "missing_content_hash" : result.issues[0]?.code === "MISSING_SIGNATURE" ? "missing_signature" : result.issues[0]?.code === "REFERENCE_MISSING" ? "reference_missing" : result.issues[0]?.code === "REFERENCE_HASH_MISMATCH" ? "reference_hash_mismatch" : result.issues[0]?.code === "POLICY_VIOLATION" ? "policy_violation" : result.issues[0]?.code === "PARENT_MISSING" ? "parent_missing" : "schema_invalid";
       if (throwOnInvalid) {
         throw new Error(`Artifact ${id} corrupted or invalid: ` + JSON.stringify(result.issues, null, 2));
       }
@@ -1757,8 +1907,8 @@ var Hardkas = class _Hardkas {
   resolveRpcUrl() {
     const networkId = this.config.config.defaultNetwork || "simnet";
     const target = this.config.config.networks?.[networkId];
-    if (target && (target.kind === "kaspa-rpc" || target.kind === "igra" || target.kind === "kaspa-node")) {
-      return target.rpcUrl || "ws://127.0.0.1:18210";
+    if (target && "rpcUrl" in target && typeof target.rpcUrl === "string") {
+      return target.rpcUrl;
     }
     return "ws://127.0.0.1:18210";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hardkas/sdk",
-  "version": "0.8.2-alpha",
+  "version": "0.8.4-alpha",
   "type": "module",
   "files": [
     "dist",
@@ -23,18 +23,18 @@
     }
   },
   "dependencies": {
-    "@hardkas/artifacts": "0.8.2-alpha",
-    "@hardkas/config": "0.8.2-alpha",
-    "@hardkas/kaspa-rpc": "0.8.2-alpha",
-    "@hardkas/core": "0.8.2-alpha",
-    "@hardkas/l2": "0.8.2-alpha",
-    "@hardkas/accounts": "0.8.2-alpha",
-    "@hardkas/localnet": "0.8.2-alpha",
-    "@hardkas/query": "0.8.2-alpha",
-    "@hardkas/simulator": "0.8.2-alpha",
-    "@hardkas/tx-builder": "0.8.2-alpha",
-    "@hardkas/wallet-adapter": "0.8.2-alpha",
-    "@hardkas/query-store": "0.8.2-alpha"
+    "@hardkas/accounts": "0.8.4-alpha",
+    "@hardkas/config": "0.8.4-alpha",
+    "@hardkas/artifacts": "0.8.4-alpha",
+    "@hardkas/core": "0.8.4-alpha",
+    "@hardkas/kaspa-rpc": "0.8.4-alpha",
+    "@hardkas/l2": "0.8.4-alpha",
+    "@hardkas/localnet": "0.8.4-alpha",
+    "@hardkas/query": "0.8.4-alpha",
+    "@hardkas/wallet-adapter": "0.8.4-alpha",
+    "@hardkas/query-store": "0.8.4-alpha",
+    "@hardkas/simulator": "0.8.4-alpha",
+    "@hardkas/tx-builder": "0.8.4-alpha"
   },
   "devDependencies": {
     "tsup": "^8.3.5",