@hazbase/simplicity 0.0.2 → 0.0.4

package/README.md

@@ -1,4 +1,6 @@
 # @hazbase/simplicity
+[![npm version](https://badge.fury.io/js/@hazbase%2Fsimplicity.svg)](https://badge.fury.io/js/@hazbase%2Fsimplicity)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
 `@hazbase/simplicity` is a Node.js / TypeScript SDK for working with Simplicity contracts on Liquid with an EVM-like developer workflow. It lets you compile SimplicityHL (`.simf`) contracts, derive the contract address, fund that address, inspect the spend you are about to make, execute the contract, and optionally run fee-sponsored flows through a sponsor wallet or relayer. It also ships with built-in presets so you can start from known-good contract templates before moving to custom `.simf` code.
 
@@ -72,6 +74,13 @@ What that means:
 - injects `DEFINITION_HASH` and `DEFINITION_ID` into compile-time template vars when a definition is provided,
 - lets you verify later that the JSON you are reading still matches the contract/artifact it was compiled against.
 
+There are now two anchor modes:
+- `artifact-hash-anchor`: the JSON hash is anchored in the artifact and verified later against that artifact.
+- `on-chain-constant-committed`: the JSON hash is anchored in the artifact and also committed into executed contract logic, so it materially affects the compiled program, CMR, and contract address.
+
+Today, `on-chain-constant-committed` is guaranteed for custom `.simf` contracts that include the blessed `require_definition_anchor()` helper pattern. Built-in presets still default to artifact-only anchors for now.
+The SDK does **not** trust artifact JSON alone for this verdict. `trust.onChainAnchorVerified` only becomes `true` when the SDK can read the source file again and re-detect the blessed helper pattern. If the source file is unavailable, the claimed mode may still be `on-chain-constant-committed`, but `onChainAnchorVerified` will remain `false`.
+
 Minimal TypeScript flow:
 
 ```ts
@@ -92,6 +101,7 @@ const compiled = await sdk.compileFromFile({
     id: definition.definitionId,
     schemaVersion: definition.schemaVersion,
     jsonPath: definition.sourcePath,
+    anchorMode: "on-chain-constant-committed",
   },
   artifactPath: "./bond.artifact.json",
 });
@@ -104,6 +114,7 @@ const verification = await sdk.verifyDefinitionAgainstArtifact({
 });
 
 console.log(verification.ok);
+console.log(verification.trust.effectiveMode);
 ```
 
 CLI equivalents:
@@ -123,6 +134,82 @@ simplicity-cli definition verify \
 
 For a bond-oriented walkthrough, see [docs/definitions/README.md](./docs/definitions/README.md).
 
+## Trusted Issuance State JSON
+
+The same hash-anchor model now also applies to issuance state documents such as a bond issuance record.
+
+This is useful when you want to say not only:
+
+- "these are the bond terms,"
+
+but also:
+
+- "this bond was issued in this amount, with this outstanding principal, under this controller."
+
+The SDK now supports:
+
+- loading and hashing a state JSON with `sdk.loadStateDocument(...)`,
+- storing its hash in the artifact,
+- committing `STATE_HASH` into custom `.simf` contract logic,
+- verifying later that the issuance state JSON still matches the compiled contract.
+
+For Bond issuance, the recommended shape is:
+
+```json
+{
+  "issuanceId": "BOND-2026-001-ISSUE-1",
+  "bondId": "BOND-2026-001",
+  "issuerEntityId": "hazbase-treasury",
+  "issuedPrincipal": 1000000,
+  "outstandingPrincipal": 1000000,
+  "redeemedPrincipal": 0,
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "<xonly>",
+  "issuedAt": "2026-03-10T00:00:00Z",
+  "status": "ISSUED"
+}
+```
+
+Minimal TypeScript flow:
+
+```ts
+const compiled = await sdk.bonds.defineBond({
+  definitionPath: "./docs/definitions/bond-definition.json",
+  issuancePath: "./docs/definitions/bond-issuance-state.json",
+  simfPath: "./docs/definitions/bond-issuance-anchor.simf",
+  artifactPath: "./bond-issuance.artifact.json",
+});
+
+const verification = await sdk.bonds.verifyBond({
+  artifactPath: "./bond-issuance.artifact.json",
+  definitionPath: "./docs/definitions/bond-definition.json",
+  issuancePath: "./docs/definitions/bond-issuance-state.json",
+});
+
+console.log(verification.crossChecks.principalInvariantValid);
+console.log(verification.issuance.trust.effectiveMode);
+```
+
+CLI equivalents:
+
+```bash
+simplicity-cli state show \
+  --type bond-issuance \
+  --id BOND-2026-001-ISSUE-1 \
+  --json-path ./docs/definitions/bond-issuance-state.json
+
+simplicity-cli state verify \
+  --artifact ./bond-issuance.artifact.json \
+  --type bond-issuance \
+  --id BOND-2026-001-ISSUE-1 \
+  --json-path ./docs/definitions/bond-issuance-state.json
+
+simplicity-cli bond verify \
+  --artifact ./bond-issuance.artifact.json \
+  --definition-json ./docs/definitions/bond-definition.json \
+  --issuance-json ./docs/definitions/bond-issuance-state.json
+```
+
 ## Install
 
 You need three things:
@@ -800,6 +887,9 @@ These examples are included to help you jump to the right workflow quickly.
 - [gasless-transfer.ts](./examples/gasless-transfer.ts): standard relayer-backed gasless L-BTC transfer.
 - [define-bond.ts](./examples/define-bond.ts): compile a bond example with a trusted definition hash anchor.
 - [show-bond-definition.ts](./examples/show-bond-definition.ts): verify and retrieve a trusted bond definition from JSON + artifact.
+- [define-bond-issuance.ts](./examples/define-bond-issuance.ts): compile a bond example with both trusted definition and issuance state anchors.
+- [show-bond-issuance.ts](./examples/show-bond-issuance.ts): load a bond artifact together with its verified issuance state.
+- [verify-bond-issuance.ts](./examples/verify-bond-issuance.ts): run combined Bond definition/state verification and invariant checks.
 
 In addition to the in-repo examples, the package has also been validated from a blank external consumer project with:
 - `npm install @hazbase/simplicity`
@@ -828,9 +918,20 @@ When you compile with `definition: { ... }`, the artifact also carries:
 - `schemaVersion`
 - `hash`
 - `trustMode`
+- `anchorMode`
 
 That is what allows the SDK and CLI to verify that an off-chain JSON definition still matches the contract you compiled.
 
+When you also compile with `state: { ... }`, the artifact can additionally carry:
+- `stateType`
+- `stateId`
+- `schemaVersion`
+- `hash`
+- `trustMode`
+- `anchorMode`
+
+That is what allows the SDK and CLI to verify that an off-chain issuance state document still matches the contract you compiled.
+
 ### When should I use a preset instead of a custom `.simf` file?
 
 Use a preset first when you are learning the lifecycle or your use case already matches a built-in contract. Move to custom `.simf` when your business rules are app-specific.

package/dist/cli.js

@@ -8,6 +8,7 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const artifact_1 = require("./core/artifact");
 const definition_1 = require("./core/definition");
+const state_1 = require("./core/state");
 const presets_1 = require("./core/presets");
 const errors_1 = require("./core/errors");
 const SimplicityClient_1 = require("./client/SimplicityClient");
@@ -72,7 +73,8 @@ function parseDefinitionInput() {
     const jsonPath = getArg("definition-json");
     const valueJson = getArg("definition-value");
     const schemaVersion = getArg("definition-schema-version");
-    if (!type && !id && !jsonPath && !valueJson && !schemaVersion) {
+    const anchorMode = getArg("definition-anchor-mode");
+    if (!type && !id && !jsonPath && !valueJson && !schemaVersion && !anchorMode) {
         return undefined;
     }
     return {
@@ -81,6 +83,26 @@ function parseDefinitionInput() {
         schemaVersion: schemaVersion ?? undefined,
         jsonPath,
         value: valueJson ? JSON.parse(valueJson) : undefined,
+        anchorMode,
+    };
+}
+function parseStateInput() {
+    const type = getArg("state-type");
+    const id = getArg("state-id");
+    const jsonPath = getArg("state-json");
+    const valueJson = getArg("state-value");
+    const schemaVersion = getArg("state-schema-version");
+    const anchorMode = getArg("state-anchor-mode");
+    if (!type && !id && !jsonPath && !valueJson && !schemaVersion && !anchorMode) {
+        return undefined;
+    }
+    return {
+        type: type ?? "",
+        id: id ?? "",
+        schemaVersion: schemaVersion ?? undefined,
+        jsonPath,
+        value: valueJson ? JSON.parse(valueJson) : undefined,
+        anchorMode,
     };
 }
 function resolveConfig() {
@@ -382,6 +404,21 @@ function formatArtifactHelp(artifact, preset, utxos) {
             `  schema version: ${artifact.definition.schemaVersion}`,
             `  hash: ${artifact.definition.hash}`,
             `  trust mode: ${artifact.definition.trustMode}`,
+            `  anchor mode: ${artifact.definition.anchorMode}`,
+            `  on-chain helper: ${artifact.definition.onChainAnchor?.helper ?? "(none)"}`,
+            `  source verified: ${artifact.definition.onChainAnchor?.sourceVerified === true ? "yes" : "no"}`,
+        ].join("\n")
+        : "  (none)";
+    const state = artifact.state
+        ? [
+            `  type: ${artifact.state.stateType}`,
+            `  id: ${artifact.state.stateId}`,
+            `  schema version: ${artifact.state.schemaVersion}`,
+            `  hash: ${artifact.state.hash}`,
+            `  trust mode: ${artifact.state.trustMode}`,
+            `  anchor mode: ${artifact.state.anchorMode}`,
+            `  on-chain helper: ${artifact.state.onChainAnchor?.helper ?? "(none)"}`,
+            `  source verified: ${artifact.state.onChainAnchor?.sourceVerified === true ? "yes" : "no"}`,
         ].join("\n")
         : "  (none)";
     const compileSource = artifact.source.simfPath ?? artifact.legacy?.simfTemplatePath ?? "(unknown)";
@@ -405,6 +442,9 @@ function formatArtifactHelp(artifact, preset, utxos) {
         "Definition Anchor:",
         definition,
         "",
+        "State Anchor:",
+        state,
+        "",
         "Suggested Commands:",
         `  ${inspectCommand}`,
         `  ${executeCommand}`,
@@ -446,7 +486,7 @@ async function main() {
     const subcommand = process.argv[3];
     const sdk = (0, SimplicityClient_1.createSimplicityClient)(resolveConfig());
     if (!command) {
-        throw new Error("Usage: simplicity-cli <compile|presets|preset|contract|artifact|definition|gasless> ...");
+        throw new Error("Usage: simplicity-cli <compile|presets|preset|contract|artifact|definition|state|bond|gasless> ...");
     }
     if (command === "compile") {
         const result = await sdk.compileFromFile({
@@ -454,6 +494,7 @@ async function main() {
             templateVars: parseAssignments(getMultiArgs("template-var")),
             artifactPath: getArg("artifact"),
             definition: parseDefinitionInput(),
+            state: parseStateInput(),
         });
         printJson({ artifact: result.artifact, deployment: result.deployment() });
         return;
@@ -466,7 +507,10 @@ async function main() {
             value: getArg("value") ? JSON.parse(getArg("value")) : undefined,
             schemaVersion: getArg("schema-version"),
         });
-        printJson(definition);
+        printJson({
+            ...definition,
+            anchorRecommendation: "Use --definition-anchor-mode on-chain-constant-committed with a blessed custom .simf helper for on-chain enforcement",
+        });
         return;
     }
     if (command === "definition" && subcommand === "verify") {
@@ -485,6 +529,41 @@ async function main() {
             reason: verification.reason,
             definition: verification.definition,
             artifactDefinition: verification.artifactDefinition ?? null,
+            trust: verification.trust,
+        });
+        return;
+    }
+    if (command === "state" && subcommand === "show") {
+        const state = await (0, state_1.loadStateInput)({
+            type: requireArg("type"),
+            id: requireArg("id"),
+            jsonPath: getArg("json-path"),
+            value: getArg("value") ? JSON.parse(getArg("value")) : undefined,
+            schemaVersion: getArg("schema-version"),
+        });
+        printJson({
+            ...state,
+            anchorRecommendation: "Use --state-anchor-mode on-chain-constant-committed with a blessed custom .simf helper for on-chain enforcement",
+        });
+        return;
+    }
+    if (command === "state" && subcommand === "verify") {
+        const verification = await sdk.verifyStateAgainstArtifact({
+            artifactPath: requireArg("artifact"),
+            type: getArg("type"),
+            id: getArg("id"),
+            expectedType: getArg("expected-type"),
+            expectedId: getArg("expected-id"),
+            jsonPath: getArg("json-path"),
+            value: getArg("value") ? JSON.parse(getArg("value")) : undefined,
+            schemaVersion: getArg("schema-version"),
+        });
+        printJson({
+            verified: verification.ok,
+            reason: verification.reason,
+            state: verification.state,
+            artifactState: verification.artifactState ?? null,
+            trust: verification.trust,
         });
         return;
     }
@@ -534,6 +613,7 @@ async function main() {
             params,
             artifactPath: getArg("artifact"),
             definition: parseDefinitionInput(),
+            state: parseStateInput(),
         });
         printJson({ artifact: result.artifact, deployment: result.deployment() });
         return;
@@ -563,6 +643,25 @@ async function main() {
         });
         return;
     }
+    if (command === "bond" && subcommand === "define") {
+        const result = await sdk.bonds.defineBond({
+            definitionPath: getArg("definition-json"),
+            issuancePath: getArg("issuance-json"),
+            simfPath: getArg("simf"),
+            artifactPath: getArg("artifact"),
+        });
+        printJson({ artifact: result.artifact, deployment: result.deployment() });
+        return;
+    }
+    if (command === "bond" && subcommand === "verify") {
+        const result = await sdk.bonds.verifyBond({
+            artifactPath: requireArg("artifact"),
+            definitionPath: getArg("definition-json"),
+            issuancePath: getArg("issuance-json"),
+        });
+        printJson(result);
+        return;
+    }
     if (command === "contract" && subcommand === "wait-funding") {
         const compiled = await sdk.loadArtifact(requireArg("artifact"));
         const utxos = await compiled.at().waitForFunding({

package/dist/client/ContractFactory.d.ts

@@ -1,4 +1,4 @@
-import { ArtifactDefinitionMetadata, DeploymentInfo, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { ArtifactDefinitionMetadata, ArtifactStateMetadata, DeploymentInfo, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
 import { DeployedContract } from "./DeployedContract";
 export declare class CompiledContract {
     private readonly config;
@@ -8,6 +8,7 @@ export declare class CompiledContract {
     get cmr(): string;
     get program(): string;
     definition(): ArtifactDefinitionMetadata | null;
+    state(): ArtifactStateMetadata | null;
     deployment(): DeploymentInfo;
     saveArtifact(path: string): Promise<void>;
     at(addressOverride?: string): DeployedContract;

package/dist/client/ContractFactory.js

@@ -22,6 +22,9 @@ class CompiledContract {
     definition() {
         return this.artifact.definition ?? null;
     }
+    state() {
+        return this.artifact.state ?? null;
+    }
     deployment() {
         return {
             contractAddress: this.artifact.compiled.contractAddress,

package/dist/client/DeployedContract.d.ts

@@ -1,5 +1,6 @@
 import { verifyDefinitionAgainstArtifact } from "../core/definition";
-import { ArtifactDefinitionMetadata, ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig, WaitForFundingInput } from "../core/types";
+import { verifyStateAgainstArtifact } from "../core/state";
+import { ArtifactDefinitionMetadata, ArtifactStateMetadata, ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig, WaitForFundingInput } from "../core/types";
 export declare class DeployedContract {
     private readonly config;
     readonly artifact: SimplicityArtifact;
@@ -21,5 +22,19 @@ export declare class DeployedContract {
         definition: Awaited<ReturnType<typeof verifyDefinitionAgainstArtifact>>["definition"];
         artifactDefinition: ArtifactDefinitionMetadata | null;
         reason?: string;
+        trust: Awaited<ReturnType<typeof verifyDefinitionAgainstArtifact>>["trust"];
+    }>;
+    getTrustedState(input: {
+        jsonPath?: string;
+        value?: unknown;
+        type?: string;
+        id?: string;
+        schemaVersion?: string;
+    }): Promise<{
+        verified: boolean;
+        state: Awaited<ReturnType<typeof verifyStateAgainstArtifact>>["state"];
+        artifactState: ArtifactStateMetadata | null;
+        reason?: string;
+        trust: Awaited<ReturnType<typeof verifyStateAgainstArtifact>>["trust"];
     }>;
 }

package/dist/client/DeployedContract.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeployedContract = void 0;
 const executor_1 = require("../core/executor");
 const definition_1 = require("../core/definition");
+const state_1 = require("../core/state");
 const executor_2 = require("../core/executor");
 class DeployedContract {
     config;
@@ -58,6 +59,28 @@ class DeployedContract {
             definition: verification.definition,
             artifactDefinition: verification.artifactDefinition ?? null,
             reason: verification.reason,
+            trust: verification.trust,
+        };
+    }
+    async getTrustedState(input) {
+        const verification = await (0, state_1.verifyStateAgainstArtifact)({
+            artifact: this.artifact,
+            state: {
+                type: input.type ?? this.artifact.state?.stateType ?? "",
+                id: input.id ?? this.artifact.state?.stateId ?? "",
+                schemaVersion: input.schemaVersion,
+                jsonPath: input.jsonPath,
+                value: input.value,
+            },
+            expectedType: this.artifact.state?.stateType,
+            expectedId: this.artifact.state?.stateId,
+        });
+        return {
+            verified: verification.ok,
+            state: verification.state,
+            artifactState: verification.artifactState ?? null,
+            reason: verification.reason,
+            trust: verification.trust,
         };
     }
 }

package/dist/client/SimplicityClient.d.ts

@@ -1,21 +1,48 @@
 import { ElementsRpcClient } from "../core/rpc";
-import { DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { BondDefinition, BondIssuanceState, DefinitionInput, DefinitionVerificationResult, CompileFromFileInput, CompileFromPresetInput, DefinitionDescriptor, StateDocumentDescriptor, StateDocumentInput, StateVerificationResult, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
 import { RelayerClient } from "../gasless/RelayerClient";
 import { GaslessTransferInput, GaslessTransferResult, RelayerClientConfig } from "../gasless/types";
 import { CompiledContract } from "./ContractFactory";
 import { DeployedContract } from "./DeployedContract";
+import { loadBond, verifyBond } from "../domain/bond";
 export declare class SimplicityClient {
     readonly config: SimplicityClientConfig;
     readonly rpc: ElementsRpcClient;
     readonly payments: {
         gaslessTransfer: (input: GaslessTransferInput) => Promise<GaslessTransferResult>;
     };
+    readonly bonds: {
+        defineBond: (input: {
+            definitionPath?: string;
+            definitionValue?: BondDefinition;
+            issuancePath?: string;
+            issuanceValue?: BondIssuanceState;
+            simfPath?: string;
+            artifactPath?: string;
+        }) => Promise<CompiledContract>;
+        verifyBond: (input: {
+            artifactPath?: string;
+            artifact?: SimplicityArtifact;
+            definitionPath?: string;
+            definitionValue?: BondDefinition;
+            issuancePath?: string;
+            issuanceValue?: BondIssuanceState;
+        }) => ReturnType<typeof verifyBond>;
+        loadBond: (input: {
+            artifactPath: string;
+            definitionPath?: string;
+            definitionValue?: BondDefinition;
+            issuancePath?: string;
+            issuanceValue?: BondIssuanceState;
+        }) => ReturnType<typeof loadBond>;
+    };
     constructor(config: SimplicityClientConfig);
     compileFromFile(input: CompileFromFileInput): Promise<CompiledContract>;
     compileFromPreset(input: CompileFromPresetInput): Promise<CompiledContract>;
     loadArtifact(path: string): Promise<CompiledContract>;
     define(input: DefinitionInput): Promise<DefinitionDescriptor>;
     loadDefinition(input: DefinitionInput): Promise<DefinitionDescriptor>;
+    loadStateDocument(input: StateDocumentInput): Promise<StateDocumentDescriptor>;
     verifyDefinitionAgainstArtifact(input: {
         artifactPath?: string;
         artifact?: SimplicityArtifact;
@@ -27,6 +54,17 @@ export declare class SimplicityClient {
         id?: string;
         schemaVersion?: string;
     }): Promise<DefinitionVerificationResult>;
+    verifyStateAgainstArtifact(input: {
+        artifactPath?: string;
+        artifact?: SimplicityArtifact;
+        jsonPath?: string;
+        value?: unknown;
+        expectedType?: string;
+        expectedId?: string;
+        type?: string;
+        id?: string;
+        schemaVersion?: string;
+    }): Promise<StateVerificationResult>;
     fromArtifact(artifact: SimplicityArtifact): DeployedContract;
     relayer(config: RelayerClientConfig): RelayerClient;
     private gaslessTransfer;

package/dist/client/SimplicityClient.js

@@ -5,21 +5,29 @@ exports.createSimplicityClient = createSimplicityClient;
 const artifact_1 = require("../core/artifact");
 const compiler_1 = require("../core/compiler");
 const definition_1 = require("../core/definition");
+const state_1 = require("../core/state");
 const errors_1 = require("../core/errors");
 const rpc_1 = require("../core/rpc");
 const RelayerClient_1 = require("../gasless/RelayerClient");
 const ContractFactory_1 = require("./ContractFactory");
 const DeployedContract_1 = require("./DeployedContract");
+const bond_1 = require("../domain/bond");
 class SimplicityClient {
     config;
     rpc;
     payments;
+    bonds;
     constructor(config) {
         this.config = config;
         this.rpc = new rpc_1.ElementsRpcClient(config.rpc);
         this.payments = {
             gaslessTransfer: async (input) => this.gaslessTransfer(input),
         };
+        this.bonds = {
+            defineBond: async (input) => (0, bond_1.defineBond)(this, input),
+            verifyBond: async (input) => (0, bond_1.verifyBond)(this, input),
+            loadBond: async (input) => (0, bond_1.loadBond)(this, input),
+        };
     }
     async compileFromFile(input) {
         const artifact = await (0, compiler_1.compileFromFile)(this.config, input);
@@ -39,6 +47,9 @@ class SimplicityClient {
     async loadDefinition(input) {
         return (0, definition_1.loadDefinitionInput)(input);
     }
+    async loadStateDocument(input) {
+        return (0, state_1.loadStateInput)(input);
+    }
     async verifyDefinitionAgainstArtifact(input) {
         const artifact = input.artifact ?? (input.artifactPath ? await (0, artifact_1.loadArtifact)(input.artifactPath, this.config.network) : undefined);
         if (!artifact) {
@@ -57,6 +68,24 @@ class SimplicityClient {
             expectedId: input.expectedId,
         });
     }
+    async verifyStateAgainstArtifact(input) {
+        const artifact = input.artifact ?? (input.artifactPath ? await (0, artifact_1.loadArtifact)(input.artifactPath, this.config.network) : undefined);
+        if (!artifact) {
+            throw new errors_1.ValidationError("artifactPath or artifact is required");
+        }
+        return (0, state_1.verifyStateAgainstArtifact)({
+            artifact,
+            state: {
+                type: input.type ?? input.expectedType ?? artifact.state?.stateType ?? "",
+                id: input.id ?? input.expectedId ?? artifact.state?.stateId ?? "",
+                schemaVersion: input.schemaVersion,
+                jsonPath: input.jsonPath,
+                value: input.value,
+            },
+            expectedType: input.expectedType,
+            expectedId: input.expectedId,
+        });
+    }
     fromArtifact(artifact) {
         return new DeployedContract_1.DeployedContract(this.config, artifact);
     }

package/dist/core/artifact.js

@@ -17,7 +17,22 @@ function isArtifactV5(value) {
 }
 function normalizeArtifact(artifact, networkDefault = "liquidtestnet") {
     if (artifact.version === exports.SDK_ARTIFACT_VERSION) {
-        return artifact;
+        const current = artifact;
+        return {
+            ...current,
+            definition: current.definition
+                ? {
+                    ...current.definition,
+                    anchorMode: current.definition.anchorMode ?? "artifact-hash-anchor",
+                }
+                : undefined,
+            state: current.state
+                ? {
+                    ...current.state,
+                    anchorMode: current.state.anchorMode ?? "artifact-hash-anchor",
+                }
+                : undefined,
+        };
     }
     if (!isArtifactV5(artifact)) {
         throw new errors_1.ArtifactError("Unsupported artifact version", artifact);
@@ -56,6 +71,7 @@ function normalizeArtifact(artifact, networkDefault = "liquidtestnet") {
             notes: null,
         },
         definition: undefined,
+        state: undefined,
         legacy: {
             simfTemplatePath: artifact.simfTemplatePath,
             params: artifact.params,
@@ -92,6 +108,7 @@ async function loadArtifact(artifactPath, networkDefault = "liquidtestnet") {
             }
             : undefined,
         definition: normalized.definition,
+        state: normalized.state,
     };
 }
 async function saveArtifact(artifactPath, artifact) {