@hazbase/simplicity 0.4.8 → 0.4.10

package/README.md

@@ -12,7 +12,7 @@ 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
+## Strict policy lifecycle
 
 This release extends strict-policy positions from ordinary transfers to a
 complete controlled lifecycle:
@@ -24,7 +24,7 @@ complete controlled lifecycle:
 - 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
+For policy-locked redemptions, Liquid x402 binds a wallet-created holder
 signature for the locally recomputed transaction hash into the payment payload.
 
 ## What You Can Build
@@ -185,6 +185,23 @@ enough for the bounded transaction shape. Do not use it for a secondary market,
 additional intermediaries, or transactions that need more inputs, outputs, or
 approved holders.
 
+`strict_v2_confidential` is a separate verifier profile for Atomic DvP
+purchases. It keeps the protected RWA inputs and outputs explicit, while the
+single treasury-payment output at index 2 uses standard Liquid confidentiality.
+The verifier still checks strict-asset conservation and rejects confidential
+strict outputs. A wallet must inspect the complete explicit proposal first,
+blind only that fixed payment output locally, and sign the resulting PSET. The
+treasury then independently unblinds and checks the payment before service
+finalization. Existing `strict_v2` and `strict_v2_compact` positions are not
+changed or reinterpreted by this profile.
+
+`strict_v2_compact_confidential` applies the same fixed payment-output
+confidentiality to the bounded pilot envelope: at most 3 inputs, 4 outputs,
+and 2 approved holders. It is intended for one-position issuance and purchase
+flows where the general profile would exceed the network execution budget. It
+does not weaken the holder signature, whitelist, asset-conservation, or
+fixed-index payment checks.
+
 ```ts
 const verifier = normalizeStrictPolicyVerifierCovenantParams({
   assetId,

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

@@ -0,0 +1,265 @@
+/*
+ * Strict v2 confidential-value verifier covenant.
+ *
+ * This is a distinct profile from strict-verifier-ordinary-v1. It permits a
+ * single, designated confidential payment output at index 2. Every strict
+ * RWA input and output remains explicit, and the covenant requires their
+ * aggregate amounts to match. This prevents a strict RWA from being moved
+ * through the confidential payment output while allowing standard PSET
+ * value-and-asset blinding for the payment itself.
+ */
+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 add_amount(left: u64, right: u64) -> u64 {
+    let (carry, sum): (bool, u64) = jet::add_64(left, right);
+    assert!(not(carry));
+    sum
+}
+
+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, u64)) -> (u32, u64) {
+    let (index, strict_total): (u32, u64) = state;
+    let past_end: bool = jet::le_32(jet::num_inputs(), index);
+    let strict_total: u64 = match past_end {
+        true => strict_total,
+        false => {
+            let (asset, amount): (u256, u64) = explicit_input_asset_amount(index);
+            let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+            let is_strict: bool = jet::eq_256(asset, strict_asset);
+            match is_strict {
+                true => add_amount(strict_total, amount),
+                false => strict_total,
+            }
+        },
+    };
+    (next_index(index), strict_total)
+}
+
+fn scan_output_ordinary(
+    owner_proof: (Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]),
+    state: (u32, u64)
+) -> (u32, u64) {
+    let (index, strict_total): (u32, u64) = state;
+    let past_end: bool = jet::le_32(jet::num_outputs(), index);
+    let strict_total: u64 = match past_end {
+        true => strict_total,
+        false => {
+            let pair: (Asset1, Amount1) = unwrap(jet::output_amount(index));
+            let (asset, amount): (Asset1, Amount1) = pair;
+            match asset {
+                // PSET supports standard confidential outputs only when both
+                // asset and value are blinded. This profile permits exactly
+                // the atomic purchase payment at output 2 to use that form.
+                Left(unused_confidential_asset: (u1, u256)) => {
+                    assert!(jet::eq_32(index, 2));
+                    strict_total
+                },
+                Right(asset_bits: u256) => {
+                    let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+                    match jet::eq_256(asset_bits, strict_asset) {
+                        true => {
+                            let amount_bits: u64 = unwrap_right::<(u1, u256)>(amount);
+                            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));
+                            add_amount(strict_total, amount_bits)
+                        },
+                        false => strict_total,
+                    }
+                },
+            }
+        },
+    };
+    (next_index(index), strict_total)
+}
+
+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, u64)) -> (u32, u64) {
+    let (index, strict_total): (u32, u64) = state;
+    let past_end: bool = jet::le_32(jet::num_outputs(), index);
+    let strict_total: u64 = match past_end {
+        true => strict_total,
+        false => {
+            let pair: (Asset1, Amount1) = unwrap(jet::output_amount(index));
+            let (asset, amount): (Asset1, Amount1) = pair;
+            match asset {
+                Left(unused_confidential_asset: (u1, u256)) => {
+                    assert!(false);
+                    strict_total
+                },
+                Right(asset_bits: u256) => {
+                    let strict_asset: u256 = 0x{{STRICT_ASSET_ID_JET_HEX}};
+                    match jet::eq_256(asset_bits, strict_asset) {
+                        true => {
+                            let amount_bits: u64 = unwrap_right::<(u1, u256)>(amount);
+                            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));
+                            add_amount(strict_total, amount_bits)
+                        },
+                        false => strict_total,
+                    }
+                },
+            }
+        },
+    };
+    (next_index(index), strict_total)
+}
+
+fn strict_input_total() -> u64 {
+    let input_slots: [(); {{MAX_INPUTS}}] = [{{INPUT_UNIT_SLOTS}}];
+    let input_state: (u32, u64) =
+        array_fold::<scan_input, {{MAX_INPUTS}}>(input_slots, (0, 0));
+    let (unused_input_index, strict_total): (u32, u64) = input_state;
+    strict_total
+}
+
+fn ordinary_transfer(
+    output_owner_proofs: [(Pubkey, [(bool, u256); {{WHITELIST_DEPTH}}]); {{MAX_OUTPUTS}}]
+) {
+    require_verifier_successor(jet::current_script_hash());
+    let strict_inputs: u64 = strict_input_total();
+    assert!(not(jet::eq_64(strict_inputs, 0)));
+
+    let output_state: (u32, u64) =
+        array_fold::<scan_output_ordinary, {{MAX_OUTPUTS}}>(output_owner_proofs, (0, 0));
+    let (unused_output_index, strict_outputs): (u32, u64) = output_state;
+    assert!(jet::eq_64(strict_inputs, strict_outputs))
+}
+
+fn redemption(authority_signature: Signature) {
+    require_verifier_successor(jet::current_script_hash());
+    let strict_inputs: u64 = strict_input_total();
+    assert!(not(jet::eq_64(strict_inputs, 0)));
+
+    let output_slots: [(); {{MAX_OUTPUTS}}] = [{{OUTPUT_UNIT_SLOTS}}];
+    let output_state: (u32, u64) =
+        array_fold::<scan_output_redemption, {{MAX_OUTPUTS}}>(output_slots, (0, 0));
+    let (unused_output_index, strict_outputs): (u32, u64) = output_state;
+    assert!(jet::eq_64(strict_inputs, strict_outputs));
+
+    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!(jet::eq_64(strict_input_total(), 0));
+
+    let output_slots: [(); {{MAX_OUTPUTS}}] = [{{OUTPUT_UNIT_SLOTS}}];
+    let output_state: (u32, u64) =
+        array_fold::<scan_output_redemption, {{MAX_OUTPUTS}}>(output_slots, (0, 0));
+    let (unused_output_index, strict_outputs): (u32, u64) = output_state;
+    assert!(jet::eq_64(strict_outputs, 0));
+
+    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),
+        },
+    }
+}

package/dist/domain/damp.d.ts

@@ -83,7 +83,7 @@ export declare function normalizeStrictPolicyVerifierCovenantParams(value: Stric
 export declare function strictPolicyHolderCovenantTemplatePath(): string;
 export declare function renderStrictPolicyHolderCovenantSource(value: StrictPolicyHolderCovenantParams | unknown): Promise<string>;
 export declare function compileStrictPolicyHolderCovenant(config: SimplicityClientConfig, value: StrictPolicyHolderCovenantParams | unknown): Promise<SimplicityArtifact>;
-export declare function strictPolicyVerifierCovenantTemplatePath(): string;
+export declare function strictPolicyVerifierCovenantTemplatePath(resourceProfile?: StrictPolicyVerifierResourceProfileId): string;
 export declare function renderStrictPolicyVerifierCovenantSource(value: StrictPolicyVerifierCovenantParams | unknown): Promise<string>;
 export declare function compileStrictPolicyVerifierCovenant(config: SimplicityClientConfig, value: StrictPolicyVerifierCovenantParams | unknown): Promise<SimplicityArtifact>;
 export declare function taggedHashHexUtf8(tag: string, canonicalPayload: string): string;

package/dist/domain/damp.js

@@ -242,7 +242,11 @@ async function compileStrictPolicyHolderCovenant(config, value) {
         },
     });
 }
-function strictPolicyVerifierCovenantTemplatePath() {
+function strictPolicyVerifierCovenantTemplatePath(resourceProfile = "strict_v2") {
+    if (resourceProfile === "strict_v2_confidential"
+        || resourceProfile === "strict_v2_compact_confidential") {
+        return `${__dirname}/../docs/definitions/strict-verifier-confidential-v1.simf`;
+    }
     return `${__dirname}/../docs/definitions/strict-verifier-ordinary-v1.simf`;
 }
 function strictPolicyVerifierTemplateVars(value) {
@@ -268,14 +272,16 @@ function strictPolicyVerifierTemplateVars(value) {
     };
 }
 async function renderStrictPolicyVerifierCovenantSource(value) {
-    const source = await readTemplateFile(strictPolicyVerifierCovenantTemplatePath());
-    return (0, templating_1.renderTemplate)(source, strictPolicyVerifierTemplateVars(value));
+    const params = normalizeStrictPolicyVerifierCovenantParams(value);
+    const source = await readTemplateFile(strictPolicyVerifierCovenantTemplatePath(params.resourceProfile));
+    return (0, templating_1.renderTemplate)(source, strictPolicyVerifierTemplateVars(params));
 }
 async function compileStrictPolicyVerifierCovenant(config, value) {
     const { compileFromFile } = await loadCompiler();
+    const params = normalizeStrictPolicyVerifierCovenantParams(value);
     return compileFromFile(config, {
-        simfPath: strictPolicyVerifierCovenantTemplatePath(),
-        templateVars: strictPolicyVerifierTemplateVars(value),
+        simfPath: strictPolicyVerifierCovenantTemplatePath(params.resourceProfile),
+        templateVars: strictPolicyVerifierTemplateVars(params),
     });
 }
 function taggedHashHexUtf8(tag, canonicalPayload) {

package/dist/domain/dampPolicy.d.ts

@@ -22,6 +22,20 @@ export declare const STRICT_POLICY_VERIFIER_RESOURCE_PROFILES: {
         readonly whitelistDepth: 1;
         readonly maxWhitelistOwners: number;
     };
+    readonly strict_v2_confidential: {
+        readonly id: "strict_v2_confidential";
+        readonly maxInputs: 16;
+        readonly maxOutputs: 8;
+        readonly whitelistDepth: 8;
+        readonly maxWhitelistOwners: number;
+    };
+    readonly strict_v2_compact_confidential: {
+        readonly id: "strict_v2_compact_confidential";
+        readonly maxInputs: 3;
+        readonly maxOutputs: 4;
+        readonly whitelistDepth: 1;
+        readonly maxWhitelistOwners: number;
+    };
 };
 export type StrictPolicyVerifierResourceProfileId = keyof typeof STRICT_POLICY_VERIFIER_RESOURCE_PROFILES;
 export type StrictPolicyVerifierResourceProfile = (typeof STRICT_POLICY_VERIFIER_RESOURCE_PROFILES)[StrictPolicyVerifierResourceProfileId];

package/dist/domain/dampPolicy.js

@@ -40,6 +40,24 @@ exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES = {
         whitelistDepth: exports.STRICT_POLICY_COMPACT_WHITELIST_DEPTH,
         maxWhitelistOwners: exports.STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS,
     },
+    // This profile permits one full confidential treasury payment output while
+    // strict RWA inputs and outputs remain explicit for deterministic checks.
+    strict_v2_confidential: {
+        id: "strict_v2_confidential",
+        maxInputs: 16,
+        maxOutputs: 8,
+        whitelistDepth: exports.STRICT_POLICY_WHITELIST_DEPTH,
+        maxWhitelistOwners: exports.STRICT_POLICY_MAX_WHITELIST_OWNERS,
+    },
+    // Keeps the confidential treasury-payment path within the same bounded
+    // execution envelope as the initial one-position pilot.
+    strict_v2_compact_confidential: {
+        id: "strict_v2_compact_confidential",
+        maxInputs: 3,
+        maxOutputs: 4,
+        whitelistDepth: exports.STRICT_POLICY_COMPACT_WHITELIST_DEPTH,
+        maxWhitelistOwners: exports.STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS,
+    },
 };
 exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-OWNER-V1";
 exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-EMPTY-V1";
@@ -52,7 +70,7 @@ function validationError(field, message) {
 }
 function resolveStrictPolicyVerifierResourceProfile(value = "strict_v2") {
     if (typeof value !== "string" || !(value in exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES)) {
-        validationError("resourceProfile", "must be strict_v2 or strict_v2_compact");
+        validationError("resourceProfile", "must be strict_v2, strict_v2_compact, strict_v2_confidential, or strict_v2_compact_confidential");
     }
     return exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES[value];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazbase/simplicity",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "An SDK for Simplicity on Liquid",
   "author": "IndieSquare Inc <info@hazbase.com>",
   "keywords": [