@hazbase/simplicity 0.4.6 → 0.4.7

package/README.md

@@ -12,6 +12,21 @@ It is intentionally narrower than a full market stack. It does **not** try to be
 
 This SDK is designed to help Node developers get productive quickly, but it is still opinionated, early-stage, and best suited today to permissioned settlement pilots on Liquid.
 
+## Version 0.4.7
+
+This release extends strict-policy positions from ordinary transfers to a
+complete controlled lifecycle:
+
+- ordinary transfers remain restricted to the approved holder whitelist;
+- redemptions return the position to a bound vault under an authority signature;
+- governance can rotate the verifier to a reviewed successor without moving the
+  protected asset; and
+- browser wallets can provide their own audited crypto implementation before
+  any strict-policy helper loads, avoiding extension CSP violations.
+
+For policy-locked redemptions, Liquid x402 now binds a wallet-created holder
+signature for the locally recomputed transaction hash into the payment payload.
+
 ## What You Can Build
 
 With the current public SDK you can build and test:
@@ -22,6 +37,7 @@ With the current public SDK you can build and test:
 - receivable repayment-first funding / partial repayment / closing flows
 - RWA delivery-versus-payment flows over Liquid PSETs and Liquid x402
 - atomic Liquid DvP proposals where service delivery and buyer payment settle in one PSET
+- canonical, signed policy snapshots for strict DAMP-compatible wallet validation
 - evidence, trust summary, lineage, and finality exports
 
 ## Public Architecture
@@ -34,6 +50,8 @@ The public SDK is organized into domain clients and lower-level payment helpers:
 - `sdk.receivables`: repayment-first receivable business layer
 - `sdk.rwaDvp`: RWA purchase terms, payment requirements, claim descriptors, and evidence
 - `sdk.payments.x402`: Liquid x402 assets, PSET payment helpers, verification, and settlement
+- root exports such as `prepareStrictPolicySnapshot(...)` and
+  `verifyStrictPolicySnapshot(...)`: canonical policy snapshot and authority-proof validation
 
 A useful mental model is:
 - `sdk.outputBinding` + `sdk.policies` provide the shared settlement kernel
@@ -82,6 +100,110 @@ npx simplicity-cli --help
 
 For richer walkthroughs and sample JSON / `.simf` files, use [`docs/definitions/README.md`](./docs/definitions/README.md).
 
+## Strict Policy Snapshots And Covenants
+
+The root-level strict policy helpers provide the strict-asset validation and
+covenant layer. They canonicalize and verify an approved snapshot, derive the
+canonical holder output `CU(X)`, build fixed-depth owner whitelist proofs, and
+render or compile matching holder and verifier covenants.
+
+```ts
+import {
+  buildStrictPolicyWhitelist,
+  deriveStrictPolicyHolderPosition,
+  inspectStrictPolicyTransactionWithProofs,
+  prepareStrictPolicySnapshot,
+  verifyStrictPolicySnapshot,
+} from "@hazbase/simplicity";
+
+const prepared = prepareStrictPolicySnapshot({ payload, authority });
+console.log(prepared.snapshotHash, prepared.approvalMessageHash);
+
+await verifyStrictPolicySnapshot({
+  ...prepared,
+  approvalProof,
+  approvalProofHash,
+});
+
+const whitelist = buildStrictPolicyWhitelist([recipientXonly, changeXonly]);
+if (whitelist.root !== prepared.payload.whitelistRoot) {
+  throw new Error("Whitelist does not match the active policy snapshot");
+}
+const recipientPosition = await deriveStrictPolicyHolderPosition({
+  holderProgramCmr,
+  numsInternalKey,
+  holderXonly: recipientXonly,
+});
+const proofFor = (ownerXonly: string) => {
+  const entry = whitelist.entries.find((candidate) => candidate.ownerXonly === ownerXonly);
+  if (!entry) throw new Error("Owner is not in the active whitelist");
+  return entry.proof;
+};
+const strictOutputAuthorizations = [
+  { outputIndex: 1, ownerXonly: recipientXonly, proof: proofFor(recipientXonly) },
+  { outputIndex: 2, ownerXonly: changeXonly, proof: proofFor(changeXonly) },
+];
+
+const inspection = await inspectStrictPolicyTransactionWithProofs(decodedTransaction, {
+  operation: "transfer",
+  snapshot: prepared.payload,
+  feeAssetId,
+  maxFeeAmountAtomic: "500",
+  holderProgramCmr,
+  holderNumsInternalKey: numsInternalKey,
+  strictOutputAuthorizations,
+});
+console.log(recipientPosition.scriptPubKey, inspection.summaryHash);
+```
+
+The current public schema deliberately supports `issuer_single` only. Its
+authority fields are typed so a separately specified quorum or multisig scheme
+can be added later without treating unknown proof types as valid.
+`strict-holder-input-v1.simf` proves the owner-bound `CU(X)` and holder
+signature. `strict-verifier-ordinary-v1.simf` fixes the verifier at input and
+output zero and exposes three mutually exclusive paths:
+
+- ordinary transfer: every strict output must be a canonical `CU(X)` for a key
+  proven under the active whitelist root;
+- redemption: every strict output must return to the configured vault and the
+  configured authority signs the complete transaction; and
+- governance: the authority signs a verifier-only transition to a reviewed
+  successor contract, without moving any strict asset.
+
+The pilot bound is 16 inputs, 8 outputs, and 256 whitelist owners; larger
+transactions fail closed. The verifier parameters now require both
+`redemptionScriptHash` and `authorityXonly`, so callers must bind the vault and
+the authority explicitly when compiling a new verifier.
+
+`inspectStrictPolicyTransactionWithProofs(...)` is the recommended wallet API.
+It validates every strict output by index, verifies its owner proof, derives the
+destination script locally, and then checks verifier continuity, asset
+conservation, issuance absence, and the fee ceiling. The lower-level
+`inspectStrictPolicyTransaction(...)` remains available for adapters that have
+already completed that proof-to-script derivation.
+
+`inspectStrictPolicyPsetForSigning(...)` is the signing boundary for a complete
+PSET. Supply a local lossless decoder through `decodePset`; the SDK then binds
+the canonical PSET bytes to the decoded transaction, validates the snapshot,
+CMR, verifier, every strict output and fee limit, and returns only the locally
+recomputed Simplicity `sig_all_hash`. A service-provided hash is accepted only
+as a comparison hint and causes rejection when it differs.
+
+The settlement repository includes
+`hazbase-simplicity-inspect-pset`, a native reference decoder built on the
+official `hal-simplicity` sighash implementation. A browser wallet still needs
+to connect an equivalent lossless WASM decoder to the SDK callback.
+The SDK supplies the canonical schema, compiler inputs and x402 holder-signature
+payload binding. A wallet must still decode the complete PSET locally, derive
+the exact `sig_all_hash`, construct the branch witness, and verify the active
+snapshot before signing. Transaction-level regtest/testnet vectors remain
+release gates; these templates and checks alone are not a production activation.
+
+The pinned public vector is
+[`strict-policy-snapshot-golden-v1.json`](./docs/definitions/strict-policy-snapshot-golden-v1.json).
+The holder-output and whitelist vector is
+[`strict-cu-whitelist-golden-v1.json`](./docs/definitions/strict-cu-whitelist-golden-v1.json).
+
 ## Domain Overview
 
 ### Policy
@@ -181,8 +303,11 @@ Liquid x402 request with `extra.redemptionSource.type:
 `buildLiquidPolicyLockedRedemptionPaymentFromProposal(...)` when a service has
 already prepared the Simplicity policy-spend PSET proposal. The helper binds the
 custom RWA asset, policy position, vault output, expiry, and summary hash into
-the `X-PAYMENT` payload, and rejects proposals that still require holder-side
-Simplicity witness construction.
+the `X-PAYMENT` payload. When the proposal requires a holder signature, supply
+the locally derived `holderSignature` for the exact `sig_all_hash`; the helper
+then carries the request and signature together without accepting a
+service-provided signing hash as authoritative. It still rejects proposals that
+require the wallet to construct an unspecified Simplicity witness.
 
 Services can prepare that policy-spend proposal with
 `sdk.policies.inspectTransfer(...)` or `sdk.policies.executeTransfer(...)`.

package/dist/core/schnorr.js

@@ -6,15 +6,9 @@ exports.schnorrPublicKeyFromPrivkeyHex = schnorrPublicKeyFromPrivkeyHex;
 exports.schnorrSignHex = schnorrSignHex;
 exports.schnorrVerifyHex = schnorrVerifyHex;
 const errors_1 = require("./errors");
-// Keep native dynamic import intact under CommonJS output so Node can load the ESM-only noble package.
-const nativeImport = new Function("specifier", "return import(specifier);");
-let schnorrPromise;
+const strictPolicyCrypto_1 = require("./strictPolicyCrypto");
 async function loadSchnorr() {
-    schnorrPromise ??= nativeImport("@noble/curves/secp256k1.js").then((module) => {
-        const typed = module;
-        return typed.schnorr;
-    });
-    return schnorrPromise;
+    return (await (0, strictPolicyCrypto_1.loadStrictPolicyCrypto)()).schnorr;
 }
 function assertHex(value, byteLength, code, message) {
     if (!/^[0-9a-f]+$/i.test(value) || value.length % 2 !== 0) {

package/dist/core/strictPolicyCrypto.d.ts

@@ -0,0 +1,8 @@
+type Secp256k1Module = typeof import("@noble/curves/secp256k1.js");
+export interface StrictPolicyCryptoProvider {
+    secp256k1: Secp256k1Module["secp256k1"];
+    schnorr: Secp256k1Module["schnorr"];
+}
+export declare function configureStrictPolicyCrypto(provider: StrictPolicyCryptoProvider): void;
+export declare function loadStrictPolicyCrypto(): Promise<StrictPolicyCryptoProvider>;
+export {};

package/dist/core/strictPolicyCrypto.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureStrictPolicyCrypto = configureStrictPolicyCrypto;
+exports.loadStrictPolicyCrypto = loadStrictPolicyCrypto;
+// Keep the native import intact under CommonJS output so Node can load noble's
+// ESM package. Construct it only for the Node fallback: Chrome extension CSP
+// rejects `new Function` when a bundled module evaluates, while browser bundles
+// inject the audited implementation through configureStrictPolicyCrypto first.
+function nativeImport(specifier) {
+    const importModule = new Function("value", "return import(value);");
+    return importModule(specifier);
+}
+let configuredProvider;
+let providerPromise;
+function configureStrictPolicyCrypto(provider) {
+    if (!provider?.secp256k1 || !provider?.schnorr) {
+        throw new TypeError("Strict policy crypto provider must include secp256k1 and schnorr");
+    }
+    if (configuredProvider
+        && (configuredProvider.secp256k1 !== provider.secp256k1
+            || configuredProvider.schnorr !== provider.schnorr)) {
+        throw new Error("Strict policy crypto provider is already configured");
+    }
+    configuredProvider = provider;
+    providerPromise = Promise.resolve(provider);
+}
+async function loadStrictPolicyCrypto() {
+    providerPromise ??= nativeImport("@noble/curves/secp256k1.js").then((module) => {
+        const typed = module;
+        return {
+            secp256k1: typed.secp256k1,
+            schnorr: typed.schnorr,
+        };
+    });
+    return providerPromise;
+}

package/dist/docs/definitions/strict-cu-whitelist-golden-v1.json

@@ -0,0 +1,63 @@
+{
+  "schema": "hazbase_strict_policy_cu_whitelist_vector_v1",
+  "holderProgramCmr": "72f400043533c5fc9d5e6865b6edb2d22732db3379e54d2643b3c02652c0c87a",
+  "numsInternalKey": "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0",
+  "whitelist": {
+    "depth": 8,
+    "root": "e3262065c02e0b42c1c63b12ef118202356430ca5b5d272b54e3715f48a7bf23",
+    "entries": [
+      {
+        "ownerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+        "leafHash": "79943062a19aed81bf32e0b826bb048a94187c52804d3343971090ed4dae8618",
+        "proof": [
+          { "siblingPosition": "right", "siblingHash": "cf74eec84a4fac9690f00fdef98466da22c68c4931be60986fea89ee99b920cd" },
+          { "siblingPosition": "right", "siblingHash": "1c8e82d1dfbc4e86bae912bdf36574b23608a1d099aba732d7ad1f8b98cf3ada" },
+          { "siblingPosition": "right", "siblingHash": "44f3a9c851a83b8b22fba37a44813b506e065776053565f486c2cd877ec4a207" },
+          { "siblingPosition": "right", "siblingHash": "b32210b7558e6c968279875cd07abccafd6dd29ca62589dd19c686fb32d997bc" },
+          { "siblingPosition": "right", "siblingHash": "4a006214dc3467b20dce046d8c0b6614e537b1c8874d0a07ef44d0e411e97a81" },
+          { "siblingPosition": "right", "siblingHash": "2b5109b939fd3ba1e538b3f0477960673b24fa9caae2f4c121ca608d44a33f9c" },
+          { "siblingPosition": "right", "siblingHash": "15869b4b05b6ac579551352dc91f4c1e06c225a233b7bbda967534b8563a461f" },
+          { "siblingPosition": "right", "siblingHash": "696cdfe69a3b0d700ad5c8ce6b14e13e1dbec6ef3283e231d37f6f648e2fbec4" }
+        ]
+      },
+      {
+        "ownerXonly": "c6047f9441ed7d6d3045406e95c07cd85a6e326c5a5fe5bdfb8f6935d3a3c96c",
+        "leafHash": "cf74eec84a4fac9690f00fdef98466da22c68c4931be60986fea89ee99b920cd",
+        "proof": [
+          { "siblingPosition": "left", "siblingHash": "79943062a19aed81bf32e0b826bb048a94187c52804d3343971090ed4dae8618" },
+          { "siblingPosition": "right", "siblingHash": "1c8e82d1dfbc4e86bae912bdf36574b23608a1d099aba732d7ad1f8b98cf3ada" },
+          { "siblingPosition": "right", "siblingHash": "44f3a9c851a83b8b22fba37a44813b506e065776053565f486c2cd877ec4a207" },
+          { "siblingPosition": "right", "siblingHash": "b32210b7558e6c968279875cd07abccafd6dd29ca62589dd19c686fb32d997bc" },
+          { "siblingPosition": "right", "siblingHash": "4a006214dc3467b20dce046d8c0b6614e537b1c8874d0a07ef44d0e411e97a81" },
+          { "siblingPosition": "right", "siblingHash": "2b5109b939fd3ba1e538b3f0477960673b24fa9caae2f4c121ca608d44a33f9c" },
+          { "siblingPosition": "right", "siblingHash": "15869b4b05b6ac579551352dc91f4c1e06c225a233b7bbda967534b8563a461f" },
+          { "siblingPosition": "right", "siblingHash": "696cdfe69a3b0d700ad5c8ce6b14e13e1dbec6ef3283e231d37f6f648e2fbec4" }
+        ]
+      }
+    ]
+  },
+  "positions": [
+    {
+      "holderProgramCmr": "72f400043533c5fc9d5e6865b6edb2d22732db3379e54d2643b3c02652c0c87a",
+      "holderTapleafHash": "892f43437d4f9992ee854f4852a4dc533bd70df011f9e8331a1b8e5edb450225",
+      "holderXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+      "ownerTapDataHash": "2726c3e2df291658a30abbf145b775c0403192b7bf16a6ee3c6243b00f445bc2",
+      "taprootRoot": "35b17c8a4e03bd30b21fc9a27bbbefec267843e6be6c2dc5becc8bfac2a8627c",
+      "numsInternalKey": "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0",
+      "outputKey": "741df228c751ac305ebf6fbd300a7c1e5eddb21415b93782709f6839fafc5931",
+      "scriptPubKey": "5120741df228c751ac305ebf6fbd300a7c1e5eddb21415b93782709f6839fafc5931",
+      "scriptHash": "14506b881f1c9ef212b7dfb93100b1067f40b876059773c846ffd6a9d9c74080"
+    },
+    {
+      "holderProgramCmr": "72f400043533c5fc9d5e6865b6edb2d22732db3379e54d2643b3c02652c0c87a",
+      "holderTapleafHash": "892f43437d4f9992ee854f4852a4dc533bd70df011f9e8331a1b8e5edb450225",
+      "holderXonly": "c6047f9441ed7d6d3045406e95c07cd85a6e326c5a5fe5bdfb8f6935d3a3c96c",
+      "ownerTapDataHash": "825cae77c977520bf404779e1a66a5f084e1c18bfecf77a9c0ded3d977368e80",
+      "taprootRoot": "012c978075295e3f5f32ded5c127050a287b465cdf076efcdb607fd2dfca4c92",
+      "numsInternalKey": "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0",
+      "outputKey": "1444e10128e2281b23fc8f1b6ef6d804cd1be4c43dbe381b4a0c89bd05111d88",
+      "scriptPubKey": "51201444e10128e2281b23fc8f1b6ef6d804cd1be4c43dbe381b4a0c89bd05111d88",
+      "scriptHash": "1e943bea5b0c861d787829dda1c2bd981c9c546cfeb5ff7567c94261acfa3548"
+    }
+  ]
+}

package/dist/docs/definitions/strict-holder-input-v1.simf

@@ -0,0 +1,62 @@
+/*
+ * Strict v2 holder input covenant, Phase 1 prototype.
+ *
+ * This leaf proves that the current strict-asset input is the canonical CU(X)
+ * for witness OWNER_XONLY and that the same transaction spends the unique
+ * verifier asset at input 0.
+ * The verifier input must separately execute the matching CV policy covenant;
+ * this holder leaf is not a complete strict-asset policy by itself.
+ *
+ * Asset constants use the byte order returned by the Simplicity Elements jets.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn canonical_holder_script_hash(owner: Pubkey) -> u256 {
+    let expected_internal_key: Pubkey = 0x{{NUMS_INTERNAL_KEY}};
+    assert!(jet::eq_256(jet::internal_key(), expected_internal_key));
+
+    let user_leaf: u256 = jet::tapleaf_hash();
+    let tapdata_ctx: Ctx8 = jet::tapdata_init();
+    let tapdata_ctx: Ctx8 = jet::sha_256_ctx_8_add_32(tapdata_ctx, owner);
+    let owner_tapdata: u256 = jet::sha_256_ctx_8_finalize(tapdata_ctx);
+    let holder_root: u256 = jet::build_tapbranch(user_leaf, owner_tapdata);
+    let output_key: u256 = jet::build_taptweak(expected_internal_key, holder_root);
+
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_init();
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_add_1(script_ctx, 0x51);
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_add_1(script_ctx, 0x20);
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_add_32(script_ctx, output_key);
+    jet::sha_256_ctx_8_finalize(script_ctx)
+}
+
+fn explicit_input_asset_amount(index: u32) -> (u256, u64) {
+    let pair: (Asset1, Amount1) = unwrap(jet::input_amount(index));
+    let (asset, amount): (Asset1, Amount1) = pair;
+    let asset_bits: u256 = unwrap_right::<(u1, u256)>(asset);
+    let amount_bits: u64 = unwrap_right::<(u1, u256)>(amount);
+    (asset_bits, amount_bits)
+}
+
+fn main() {
+    let owner: Pubkey = witness::OWNER_XONLY;
+    assert!(jet::eq_256(jet::current_script_hash(), canonical_holder_script_hash(owner)));
+
+    let current_index: u32 = jet::current_index();
+    assert!(not(jet::eq_32(current_index, 0)));
+
+    let (current_asset, current_amount): (u256, u64) =
+        explicit_input_asset_amount(current_index);
+    let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+    assert!(jet::eq_256(current_asset, strict_asset));
+    assert!(not(jet::eq_64(current_amount, 0)));
+
+    let (verifier_asset, verifier_amount): (u256, u64) =
+        explicit_input_asset_amount(0);
+    let expected_verifier_asset: u256 = 0x{{VERIFIER_ASSET_ID_JET_HEX}};
+    assert!(jet::eq_256(verifier_asset, expected_verifier_asset));
+    assert!(jet::eq_64(verifier_amount, {{VERIFIER_AMOUNT_ATOMIC}}));
+
+    jet::bip_0340_verify((owner, jet::sig_all_hash()), witness::HOLDER_SIGNATURE)
+}

package/dist/docs/definitions/strict-policy-snapshot-golden-v1.json

@@ -0,0 +1,47 @@
+{
+  "schema": "hazbase_strict_policy_snapshot_golden_vector_v1",
+  "name": "issuer_single_v1_regtest_epoch_0",
+  "notes": "Public test vector only. The private key value 1 must never be used outside tests.",
+  "testPrivateKeyHex": "0000000000000000000000000000000000000000000000000000000000000001",
+  "payload": {
+    "schema": "hazbase_strict_policy_snapshot_v1",
+    "network": "liquid-regtest",
+    "liquidGenesisHash": "1111111111111111111111111111111111111111111111111111111111111111",
+    "assetBindingId": "strict-card-pilot-1",
+    "liquidAssetId": "2222222222222222222222222222222222222222222222222222222222222222",
+    "epoch": "0",
+    "previousSnapshotHash": null,
+    "policyRoot": "3333333333333333333333333333333333333333333333333333333333333333",
+    "whitelistRoot": "4444444444444444444444444444444444444444444444444444444444444444",
+    "verifier": {
+      "outpoint": {
+        "txid": "5555555555555555555555555555555555555555555555555555555555555555",
+        "vout": 0
+      },
+      "assetId": "6666666666666666666666666666666666666666666666666666666666666666",
+      "amountAtomic": "1",
+      "cmr": "7777777777777777777777777777777777777777777777777777777777777777",
+      "scriptHash": "8888888888888888888888888888888888888888888888888888888888888888"
+    },
+    "effectiveAt": "2026-08-19T00:00:00.000Z",
+    "validUntil": null
+  },
+  "authority": {
+    "authorityType": "issuer_single",
+    "authorityId": "strict-card-pilot-authority",
+    "authorityVersion": "1",
+    "authoritySetHash": "d2e6e5ed40e4ed2eebd74e30f333f33290721291de77b4b7bbf1856afe41d995",
+    "approvalScheme": "bip340-sha256",
+    "approvalThreshold": 1,
+    "signerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+    "approvedAt": "2026-08-18T23:59:00.000Z"
+  },
+  "expected": {
+    "canonicalPayload": "{\"assetBindingId\":\"strict-card-pilot-1\",\"effectiveAt\":\"2026-08-19T00:00:00.000Z\",\"epoch\":\"0\",\"liquidAssetId\":\"2222222222222222222222222222222222222222222222222222222222222222\",\"liquidGenesisHash\":\"1111111111111111111111111111111111111111111111111111111111111111\",\"network\":\"liquid-regtest\",\"policyRoot\":\"3333333333333333333333333333333333333333333333333333333333333333\",\"previousSnapshotHash\":null,\"schema\":\"hazbase_strict_policy_snapshot_v1\",\"validUntil\":null,\"verifier\":{\"amountAtomic\":\"1\",\"assetId\":\"6666666666666666666666666666666666666666666666666666666666666666\",\"cmr\":\"7777777777777777777777777777777777777777777777777777777777777777\",\"outpoint\":{\"txid\":\"5555555555555555555555555555555555555555555555555555555555555555\",\"vout\":0},\"scriptHash\":\"8888888888888888888888888888888888888888888888888888888888888888\"},\"whitelistRoot\":\"4444444444444444444444444444444444444444444444444444444444444444\"}",
+    "snapshotHash": "1c3994d3bd78e9d8cb48b33be8fc2db4e2da2c9bde11d0bfd26ab493a46942dd",
+    "canonicalApprovalMessage": "{\"approvalScheme\":\"bip340-sha256\",\"approvalThreshold\":1,\"approvedAt\":\"2026-08-18T23:59:00.000Z\",\"assetBindingId\":\"strict-card-pilot-1\",\"authorityId\":\"strict-card-pilot-authority\",\"authoritySetHash\":\"d2e6e5ed40e4ed2eebd74e30f333f33290721291de77b4b7bbf1856afe41d995\",\"authorityType\":\"issuer_single\",\"authorityVersion\":\"1\",\"epoch\":\"0\",\"liquidAssetId\":\"2222222222222222222222222222222222222222222222222222222222222222\",\"liquidGenesisHash\":\"1111111111111111111111111111111111111111111111111111111111111111\",\"network\":\"liquid-regtest\",\"previousSnapshotHash\":null,\"schema\":\"hazbase_strict_policy_snapshot_approval_v1\",\"signerXonly\":\"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798\",\"snapshotHash\":\"1c3994d3bd78e9d8cb48b33be8fc2db4e2da2c9bde11d0bfd26ab493a46942dd\",\"verifierCmr\":\"7777777777777777777777777777777777777777777777777777777777777777\",\"verifierScriptHash\":\"8888888888888888888888888888888888888888888888888888888888888888\"}",
+    "approvalMessageHash": "6535e9cbdf029702754847a1fd7ab5e41a0606793632ab87a0c6a9f24ac59fc4",
+    "signatureHex": "14e7c165d70a0cf33cba29cc62bed4c1c55e1adbe537b5f55691e382dbf4d376eb98e48670b7238fddca222cb01b987fa2f217422dc684f8d6c7941ace6912a7",
+    "approvalProofHash": "1a657fb2cd581027b2603aad1e19f644de50d4a3ca25e1e10cd036ce3076e91a"
+  }
+}

package/dist/docs/definitions/strict-verifier-ordinary-v1.simf

@@ -0,0 +1,240 @@
+/*
+ * Strict v2 verifier covenant.
+ *
+ * One CMR exposes three explicit paths:
+ * - ordinary transfer: every strict output is a canonical whitelisted CU(X)
+ * - redemption: every strict output is returned to the configured vault
+ * - governance: the authority rotates the verifier to a reviewed successor
+ *
+ * Pilot limits are consensus-visible: at most 16 inputs, at most 8 outputs,
+ * and an 8-level owner whitelist proof. Transactions outside these bounds
+ * fail closed and require a later reviewed profile.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn explicit_input_asset_amount(index: u32) -> (u256, u64) {
+    let pair: (Asset1, Amount1) = unwrap(jet::input_amount(index));
+    let (asset, amount): (Asset1, Amount1) = pair;
+    let asset_bits: u256 = unwrap_right::<(u1, u256)>(asset);
+    let amount_bits: u64 = unwrap_right::<(u1, u256)>(amount);
+    (asset_bits, amount_bits)
+}
+
+fn explicit_output_asset_amount(index: u32) -> (u256, u64) {
+    let pair: (Asset1, Amount1) = unwrap(jet::output_amount(index));
+    let (asset, amount): (Asset1, Amount1) = pair;
+    let asset_bits: u256 = unwrap_right::<(u1, u256)>(asset);
+    let amount_bits: u64 = unwrap_right::<(u1, u256)>(amount);
+    (asset_bits, amount_bits)
+}
+
+fn whitelist_owner_leaf(owner: Pubkey) -> u256 {
+    let tag_hash: u256 = 0x{{WHITELIST_OWNER_TAG_HASH}};
+    let ctx: Ctx8 = jet::sha_256_ctx_8_init();
+    let ctx: Ctx8 = jet::sha_256_ctx_8_add_32(ctx, tag_hash);
+    let ctx: Ctx8 = jet::sha_256_ctx_8_add_32(ctx, tag_hash);
+    let ctx: Ctx8 = jet::sha_256_ctx_8_add_32(ctx, owner);
+    jet::sha_256_ctx_8_finalize(ctx)
+}
+
+fn whitelist_step(step: (bool, u256), node: u256) -> u256 {
+    let (sibling_on_left, sibling): (bool, u256) = step;
+    let tag_hash: u256 = 0x{{WHITELIST_NODE_TAG_HASH}};
+    let ctx: Ctx8 = jet::sha_256_ctx_8_init();
+    let ctx: Ctx8 = jet::sha_256_ctx_8_add_32(ctx, tag_hash);
+    let ctx: Ctx8 = jet::sha_256_ctx_8_add_32(ctx, tag_hash);
+    let ctx: Ctx8 = match sibling_on_left {
+        true => jet::sha_256_ctx_8_add_32(ctx, sibling),
+        false => jet::sha_256_ctx_8_add_32(ctx, node),
+    };
+    let ctx: Ctx8 = match sibling_on_left {
+        true => jet::sha_256_ctx_8_add_32(ctx, node),
+        false => jet::sha_256_ctx_8_add_32(ctx, sibling),
+    };
+    jet::sha_256_ctx_8_finalize(ctx)
+}
+
+fn require_whitelisted(owner: Pubkey, proof: [(bool, u256); {{WHITELIST_DEPTH}}]) {
+    let leaf: u256 = whitelist_owner_leaf(owner);
+    let root: u256 = array_fold::<whitelist_step, {{WHITELIST_DEPTH}}>(proof, leaf);
+    let expected_root: u256 = 0x{{WHITELIST_ROOT}};
+    assert!(jet::eq_256(root, expected_root));
+}
+
+fn canonical_holder_script_hash(owner: Pubkey) -> u256 {
+    let holder_cmr: u256 = 0x{{HOLDER_PROGRAM_CMR}};
+    let holder_leaf: u256 = jet::build_tapleaf_simplicity(holder_cmr);
+    let tapdata_ctx: Ctx8 = jet::tapdata_init();
+    let tapdata_ctx: Ctx8 = jet::sha_256_ctx_8_add_32(tapdata_ctx, owner);
+    let owner_tapdata: u256 = jet::sha_256_ctx_8_finalize(tapdata_ctx);
+    let holder_root: u256 = jet::build_tapbranch(holder_leaf, owner_tapdata);
+    let holder_internal_key: Pubkey = 0x{{HOLDER_NUMS_INTERNAL_KEY}};
+    let output_key: u256 = jet::build_taptweak(holder_internal_key, holder_root);
+
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_init();
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_add_1(script_ctx, 0x51);
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_add_1(script_ctx, 0x20);
+    let script_ctx: Ctx8 = jet::sha_256_ctx_8_add_32(script_ctx, output_key);
+    jet::sha_256_ctx_8_finalize(script_ctx)
+}
+
+fn next_index(index: u32) -> u32 {
+    let (carry, next): (bool, u32) = jet::add_32(index, 1);
+    assert!(not(carry));
+    next
+}
+
+fn scan_input(unused: (), state: (u32, bool)) -> (u32, bool) {
+    let (index, found_strict): (u32, bool) = state;
+    let past_end: bool = jet::le_32(jet::num_inputs(), index);
+    let found_strict: bool = match past_end {
+        true => found_strict,
+        false => {
+            let (asset, amount): (u256, u64) = explicit_input_asset_amount(index);
+            let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+            let is_positive: bool = not(jet::eq_64(amount, 0));
+            let is_strict: bool = jet::eq_256(asset, strict_asset);
+            match is_strict {
+                true => is_positive,
+                false => found_strict,
+            }
+        },
+    };
+    (next_index(index), found_strict)
+}
+
+fn scan_output_ordinary(
+    owner_proof: (Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]),
+    state: (u32, bool)
+) -> (u32, bool) {
+    let (index, found_strict): (u32, bool) = state;
+    let past_end: bool = jet::le_32(jet::num_outputs(), index);
+    let found_strict: bool = match past_end {
+        true => found_strict,
+        false => {
+            let pair: (Asset1, Amount1) = unwrap(jet::output_amount(index));
+            let (asset, amount): (Asset1, Amount1) = pair;
+            let asset: u256 = unwrap_right::<(u1, u256)>(asset);
+            let unused_amount: u64 = unwrap_right::<(u1, u256)>(amount);
+            let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+            match jet::eq_256(asset, strict_asset) {
+                true => {
+                    let (owner, proof): (Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]) = owner_proof;
+                    require_whitelisted(owner, proof);
+                    let actual_script_hash: u256 = unwrap(jet::output_script_hash(index));
+                    let expected_script_hash: u256 = canonical_holder_script_hash(owner);
+                    assert!(jet::eq_256(actual_script_hash, expected_script_hash));
+                    true
+                },
+                false => found_strict,
+            }
+        },
+    };
+    (next_index(index), found_strict)
+}
+
+fn require_verifier_successor(expected_script_hash: u256) {
+    let (verifier_asset, verifier_amount): (u256, u64) = explicit_input_asset_amount(0);
+    let expected_verifier_asset: u256 = 0x{{VERIFIER_ASSET_ID_JET_HEX}};
+    assert!(jet::eq_256(verifier_asset, expected_verifier_asset));
+    assert!(jet::eq_64(verifier_amount, {{VERIFIER_AMOUNT_ATOMIC}}));
+
+    let (successor_asset, successor_amount): (u256, u64) = explicit_output_asset_amount(0);
+    assert!(jet::eq_256(successor_asset, expected_verifier_asset));
+    assert!(jet::eq_64(successor_amount, {{VERIFIER_AMOUNT_ATOMIC}}));
+    let successor_script_hash: u256 = unwrap(jet::output_script_hash(0));
+    assert!(jet::eq_256(successor_script_hash, expected_script_hash))
+}
+
+fn scan_output_redemption(unused: (), state: (u32, bool)) -> (u32, bool) {
+    let (index, found_strict): (u32, bool) = state;
+    let past_end: bool = jet::le_32(jet::num_outputs(), index);
+    let found_strict: bool = match past_end {
+        true => found_strict,
+        false => {
+            let (asset, unused_amount): (u256, u64) = explicit_output_asset_amount(index);
+            let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+            match jet::eq_256(asset, strict_asset) {
+                true => {
+                    let actual_script_hash: u256 = unwrap(jet::output_script_hash(index));
+                    let redemption_script_hash: u256 = 0x{{REDEMPTION_SCRIPT_HASH}};
+                    assert!(jet::eq_256(actual_script_hash, redemption_script_hash));
+                    true
+                },
+                false => found_strict,
+            }
+        },
+    };
+    (next_index(index), found_strict)
+}
+
+fn strict_input_present() -> bool {
+    let input_slots: [(); {{MAX_INPUTS}}] = [{{INPUT_UNIT_SLOTS}}];
+    let input_state: (u32, bool) =
+        array_fold::<scan_input, {{MAX_INPUTS}}>(input_slots, (0, false));
+    let (unused_input_index, found_strict_input): (u32, bool) = input_state;
+    found_strict_input
+}
+
+fn ordinary_transfer(
+    output_owner_proofs: [(Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]); {{MAX_OUTPUTS}}]
+) {
+    require_verifier_successor(jet::current_script_hash());
+    assert!(strict_input_present());
+
+    let output_state: (u32, bool) =
+        array_fold::<scan_output_ordinary, {{MAX_OUTPUTS}}>(output_owner_proofs, (0, false));
+    let (unused_output_index, found_strict_output): (u32, bool) = output_state;
+    assert!(found_strict_output)
+}
+
+fn redemption(authority_signature: Signature) {
+    require_verifier_successor(jet::current_script_hash());
+    assert!(strict_input_present());
+
+    let output_slots: [(); {{MAX_OUTPUTS}}] = [{{OUTPUT_UNIT_SLOTS}}];
+    let output_state: (u32, bool) =
+        array_fold::<scan_output_redemption, {{MAX_OUTPUTS}}>(output_slots, (0, false));
+    let (unused_output_index, found_strict_output): (u32, bool) = output_state;
+    assert!(found_strict_output);
+
+    let authority: Pubkey = 0x{{AUTHORITY_XONLY}};
+    jet::bip_0340_verify((authority, jet::sig_all_hash()), authority_signature)
+}
+
+fn governance(next: (u256, Signature)) {
+    let (next_verifier_script_hash, authority_signature): (u256, Signature) = next;
+    require_verifier_successor(next_verifier_script_hash);
+    assert!(not(strict_input_present()));
+
+    let output_slots: [(); {{MAX_OUTPUTS}}] = [{{OUTPUT_UNIT_SLOTS}}];
+    let output_state: (u32, bool) =
+        array_fold::<scan_output_redemption, {{MAX_OUTPUTS}}>(output_slots, (0, false));
+    let (unused_output_index, found_strict_output): (u32, bool) = output_state;
+    assert!(not(found_strict_output));
+
+    let authority: Pubkey = 0x{{AUTHORITY_XONLY}};
+    jet::bip_0340_verify((authority, jet::sig_all_hash()), authority_signature)
+}
+
+fn main() {
+    assert!(jet::eq_32(jet::current_index(), 0));
+    assert!(jet::le_32(jet::num_inputs(), {{MAX_INPUTS}}));
+    assert!(jet::le_32(jet::num_outputs(), {{MAX_OUTPUTS}}));
+
+    let action:
+        Either<
+            [(Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]); {{MAX_OUTPUTS}}],
+            Either<Signature, (u256, Signature)>
+        > = witness::ACTION;
+    match action {
+        Left(output_owner_proofs : [(Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]); {{MAX_OUTPUTS}}]) =>
+            ordinary_transfer(output_owner_proofs),
+        Right(protected_action : Either<Signature, (u256, Signature)>) => match protected_action {
+            Left(authority_signature : Signature) => redemption(authority_signature),
+            Right(next : (u256, Signature)) => governance(next),
+        },
+    }
+}