@hazbase/simplicity 0.4.7 → 0.4.9

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
@@ -112,6 +112,7 @@ import {
   buildStrictPolicyWhitelist,
   deriveStrictPolicyHolderPosition,
   inspectStrictPolicyTransactionWithProofs,
+  normalizeStrictPolicyVerifierCovenantParams,
   prepareStrictPolicySnapshot,
   verifyStrictPolicySnapshot,
 } from "@hazbase/simplicity";
@@ -170,10 +171,43 @@ output zero and exposes three mutually exclusive paths:
 - 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.
+### Verifier resource profiles
+
+`strict_v2` is the default profile for the general strict-policy lifecycle. It
+permits up to 16 transaction inputs, 8 outputs, and a 256-owner whitelist;
+larger transactions fail closed.
+
+`strict_v2_compact` is an explicit, tightly bounded profile for a controlled
+two-owner lifecycle, such as issuer inventory to an approved holder. It permits
+at most 3 inputs, 4 outputs, and 2 whitelist owners. It retains the complete
+holder signature and whitelist checks while making the verifier witness small
+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.
+
+```ts
+const verifier = normalizeStrictPolicyVerifierCovenantParams({
+  assetId,
+  feeAssetId,
+  redemptionScriptHash,
+  authorityXonly,
+  resourceProfile: "strict_v2_compact",
+});
+```
+
+The verifier parameters 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

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

@@ -1,4 +1,5 @@
 import type { SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { type StrictPolicyVerifierResourceProfileId } from "./dampPolicy";
 export declare const STRICT_POLICY_SNAPSHOT_SCHEMA: "hazbase_strict_policy_snapshot_v1";
 export declare const STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA: "hazbase_strict_policy_snapshot_approval_v1";
 export declare const STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN: "HAZBASE-RWA-POLICY-SNAPSHOT-V1";
@@ -72,6 +73,7 @@ export interface StrictPolicyVerifierCovenantParams {
     whitelistRoot: string;
     redemptionScriptHash: string;
     authorityXonly: string;
+    resourceProfile?: StrictPolicyVerifierResourceProfileId;
 }
 export declare function normalizeStrictPolicySnapshotPayload(value: unknown): StrictPolicySnapshotPayload;
 export declare function normalizeStrictPolicySnapshotAuthority(value: unknown): StrictPolicySnapshotAuthority;
@@ -81,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

@@ -213,6 +213,7 @@ function normalizeStrictPolicyVerifierCovenantParams(value) {
         whitelistRoot: hexValue(record.whitelistRoot, "verifierCovenant.whitelistRoot", 32),
         redemptionScriptHash: hexValue(record.redemptionScriptHash, "verifierCovenant.redemptionScriptHash", 32),
         authorityXonly: hexValue(record.authorityXonly, "verifierCovenant.authorityXonly", 32),
+        resourceProfile: (0, dampPolicy_1.resolveStrictPolicyVerifierResourceProfile)(record.resourceProfile).id,
     };
 }
 function strictPolicyHolderCovenantTemplatePath() {
@@ -241,12 +242,16 @@ async function compileStrictPolicyHolderCovenant(config, value) {
         },
     });
 }
-function strictPolicyVerifierCovenantTemplatePath() {
+function strictPolicyVerifierCovenantTemplatePath(resourceProfile = "strict_v2") {
+    if (resourceProfile === "strict_v2_confidential") {
+        return `${__dirname}/../docs/definitions/strict-verifier-confidential-v1.simf`;
+    }
     return `${__dirname}/../docs/definitions/strict-verifier-ordinary-v1.simf`;
 }
 function strictPolicyVerifierTemplateVars(value) {
     const params = normalizeStrictPolicyVerifierCovenantParams(value);
     const tagHashes = (0, dampPolicy_1.strictPolicyWhitelistTagHashes)();
+    const resourceProfile = (0, dampPolicy_1.resolveStrictPolicyVerifierResourceProfile)(params.resourceProfile);
     return {
         STRICT_ASSET_ID_JET_HEX: params.strictAssetIdJetHex,
         VERIFIER_ASSET_ID_JET_HEX: params.verifierAssetIdJetHex,
@@ -258,22 +263,24 @@ function strictPolicyVerifierTemplateVars(value) {
         AUTHORITY_XONLY: params.authorityXonly,
         WHITELIST_OWNER_TAG_HASH: tagHashes.owner,
         WHITELIST_NODE_TAG_HASH: tagHashes.node,
-        WHITELIST_DEPTH: dampPolicy_1.STRICT_POLICY_WHITELIST_DEPTH,
-        MAX_INPUTS: exports.STRICT_POLICY_VERIFIER_MAX_INPUTS,
-        MAX_OUTPUTS: exports.STRICT_POLICY_VERIFIER_MAX_OUTPUTS,
-        INPUT_UNIT_SLOTS: Array.from({ length: exports.STRICT_POLICY_VERIFIER_MAX_INPUTS }, () => "()").join(", "),
-        OUTPUT_UNIT_SLOTS: Array.from({ length: exports.STRICT_POLICY_VERIFIER_MAX_OUTPUTS }, () => "()").join(", "),
+        WHITELIST_DEPTH: resourceProfile.whitelistDepth,
+        MAX_INPUTS: resourceProfile.maxInputs,
+        MAX_OUTPUTS: resourceProfile.maxOutputs,
+        INPUT_UNIT_SLOTS: Array.from({ length: resourceProfile.maxInputs }, () => "()").join(", "),
+        OUTPUT_UNIT_SLOTS: Array.from({ length: resourceProfile.maxOutputs }, () => "()").join(", "),
     };
 }
 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

@@ -1,5 +1,37 @@
 export declare const STRICT_POLICY_WHITELIST_DEPTH: 8;
 export declare const STRICT_POLICY_MAX_WHITELIST_OWNERS: number;
+export declare const STRICT_POLICY_COMPACT_WHITELIST_DEPTH: 1;
+export declare const STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS: number;
+/**
+ * Consensus-visible resource bounds for strict verifier covenants. The
+ * compact profile is for the bounded one-position testnet lifecycle only;
+ * the general strict_v2 profile remains the default.
+ */
+export declare const STRICT_POLICY_VERIFIER_RESOURCE_PROFILES: {
+    readonly strict_v2: {
+        readonly id: "strict_v2";
+        readonly maxInputs: 16;
+        readonly maxOutputs: 8;
+        readonly whitelistDepth: 8;
+        readonly maxWhitelistOwners: number;
+    };
+    readonly strict_v2_compact: {
+        readonly id: "strict_v2_compact";
+        readonly maxInputs: 3;
+        readonly maxOutputs: 4;
+        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;
+    };
+};
+export type StrictPolicyVerifierResourceProfileId = keyof typeof STRICT_POLICY_VERIFIER_RESOURCE_PROFILES;
+export type StrictPolicyVerifierResourceProfile = (typeof STRICT_POLICY_VERIFIER_RESOURCE_PROFILES)[StrictPolicyVerifierResourceProfileId];
 export declare const STRICT_POLICY_WHITELIST_OWNER_DOMAIN: "HAZBASE-RWA-STRICT-WHITELIST-OWNER-V1";
 export declare const STRICT_POLICY_WHITELIST_EMPTY_DOMAIN: "HAZBASE-RWA-STRICT-WHITELIST-EMPTY-V1";
 export declare const STRICT_POLICY_WHITELIST_NODE_DOMAIN: "HAZBASE-RWA-STRICT-WHITELIST-NODE-V1";
@@ -29,7 +61,7 @@ export interface StrictPolicyWhitelistEntry {
     proof: StrictPolicyWhitelistProofStep[];
 }
 export interface StrictPolicyWhitelist {
-    depth: typeof STRICT_POLICY_WHITELIST_DEPTH;
+    depth: number;
     root: string;
     entries: StrictPolicyWhitelistEntry[];
 }
@@ -37,6 +69,7 @@ export interface StrictPolicyWhitelistProof {
     ownerXonly: string;
     proof: StrictPolicyWhitelistProofStep[];
 }
+export declare function resolveStrictPolicyVerifierResourceProfile(value?: unknown): StrictPolicyVerifierResourceProfile;
 export declare function computeStrictPolicyHolderTapleafHash(holderProgramCmrValue: string): string;
 export declare function computeStrictPolicyOwnerTapDataHash(holderXonlyValue: string): string;
 export declare function computeElementsTapBranch(leftValue: string, rightValue: string): string;
@@ -44,15 +77,19 @@ export declare function deriveStrictPolicyHolderPosition(value: StrictPolicyHold
 export declare function computeStrictPolicyWhitelistOwnerLeaf(ownerXonlyValue: string): string;
 export declare function computeStrictPolicyWhitelistEmptyLeaf(): string;
 export declare function computeStrictPolicyWhitelistNode(leftValue: string, rightValue: string): string;
-export declare function buildStrictPolicyWhitelist(ownerXonlyValues: readonly string[]): StrictPolicyWhitelist;
+export declare function buildStrictPolicyWhitelist(ownerXonlyValues: readonly string[], options?: {
+    depth?: number;
+}): StrictPolicyWhitelist;
 export declare function verifyStrictPolicyWhitelistProof(input: {
     ownerXonly: string;
     proof: readonly StrictPolicyWhitelistProofStep[];
     expectedRoot: string;
+    depth?: number;
 }): boolean;
 export declare function normalizeStrictPolicyWhitelistProof(input: {
     ownerXonly: string;
     proof: readonly StrictPolicyWhitelistProofStep[];
+    depth?: number;
 }): StrictPolicyWhitelistProof;
 export declare function strictPolicyWhitelistTagHashes(): {
     owner: string;

package/dist/domain/dampPolicy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_WHITELIST_DEPTH = void 0;
+exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES = exports.STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_COMPACT_WHITELIST_DEPTH = exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_WHITELIST_DEPTH = void 0;
+exports.resolveStrictPolicyVerifierResourceProfile = resolveStrictPolicyVerifierResourceProfile;
 exports.computeStrictPolicyHolderTapleafHash = computeStrictPolicyHolderTapleafHash;
 exports.computeStrictPolicyOwnerTapDataHash = computeStrictPolicyOwnerTapDataHash;
 exports.computeElementsTapBranch = computeElementsTapBranch;
@@ -17,6 +18,38 @@ const errors_1 = require("../core/errors");
 const strictPolicyCrypto_1 = require("../core/strictPolicyCrypto");
 exports.STRICT_POLICY_WHITELIST_DEPTH = 8;
 exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = 1 << exports.STRICT_POLICY_WHITELIST_DEPTH;
+exports.STRICT_POLICY_COMPACT_WHITELIST_DEPTH = 1;
+exports.STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS = 1 << exports.STRICT_POLICY_COMPACT_WHITELIST_DEPTH;
+/**
+ * Consensus-visible resource bounds for strict verifier covenants. The
+ * compact profile is for the bounded one-position testnet lifecycle only;
+ * the general strict_v2 profile remains the default.
+ */
+exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES = {
+    strict_v2: {
+        id: "strict_v2",
+        maxInputs: 16,
+        maxOutputs: 8,
+        whitelistDepth: exports.STRICT_POLICY_WHITELIST_DEPTH,
+        maxWhitelistOwners: exports.STRICT_POLICY_MAX_WHITELIST_OWNERS,
+    },
+    strict_v2_compact: {
+        id: "strict_v2_compact",
+        maxInputs: 3,
+        maxOutputs: 4,
+        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,
+    },
+};
 exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-OWNER-V1";
 exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-EMPTY-V1";
 exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = "HAZBASE-RWA-STRICT-WHITELIST-NODE-V1";
@@ -26,6 +59,12 @@ function validationError(field, message) {
         field,
     });
 }
+function resolveStrictPolicyVerifierResourceProfile(value = "strict_v2") {
+    if (typeof value !== "string" || !(value in exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES)) {
+        validationError("resourceProfile", "must be strict_v2, strict_v2_compact, or strict_v2_confidential");
+    }
+    return exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES[value];
+}
 function hex32(value, field) {
     if (typeof value !== "string")
         validationError(field, "must be 32 bytes of hex");
@@ -121,12 +160,14 @@ function computeStrictPolicyWhitelistNode(leftValue, rightValue) {
     const right = hex32(rightValue, "right");
     return taggedHashHex(exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN, concat(bytes(left), bytes(right)));
 }
-function buildStrictPolicyWhitelist(ownerXonlyValues) {
+function buildStrictPolicyWhitelist(ownerXonlyValues, options = {}) {
+    const depth = strictPolicyWhitelistDepth(options.depth);
+    const maxOwners = 1 << depth;
     if (!Array.isArray(ownerXonlyValues) || ownerXonlyValues.length === 0) {
         validationError("ownerXonlyValues", "must contain at least one owner");
     }
-    if (ownerXonlyValues.length > exports.STRICT_POLICY_MAX_WHITELIST_OWNERS) {
-        validationError("ownerXonlyValues", `must contain at most ${exports.STRICT_POLICY_MAX_WHITELIST_OWNERS} owners`);
+    if (ownerXonlyValues.length > maxOwners) {
+        validationError("ownerXonlyValues", `must contain at most ${maxOwners} owners`);
     }
     const owners = ownerXonlyValues
         .map((owner, index) => hex32(owner, `ownerXonlyValues[${index}]`))
@@ -135,10 +176,10 @@ function buildStrictPolicyWhitelist(ownerXonlyValues) {
         validationError("ownerXonlyValues", "must not contain duplicates");
     }
     const emptyLeaf = computeStrictPolicyWhitelistEmptyLeaf();
-    const leaves = Array.from({ length: exports.STRICT_POLICY_MAX_WHITELIST_OWNERS }, (_, index) => (index < owners.length ? computeStrictPolicyWhitelistOwnerLeaf(owners[index]) : emptyLeaf));
+    const leaves = Array.from({ length: maxOwners }, (_, index) => (index < owners.length ? computeStrictPolicyWhitelistOwnerLeaf(owners[index]) : emptyLeaf));
     const levels = [leaves];
-    for (let depth = 0; depth < exports.STRICT_POLICY_WHITELIST_DEPTH; depth += 1) {
-        const current = levels[depth];
+    for (let level = 0; level < depth; level += 1) {
+        const current = levels[level];
         const next = [];
         for (let index = 0; index < current.length; index += 2) {
             next.push(computeStrictPolicyWhitelistNode(current[index], current[index + 1]));
@@ -148,11 +189,11 @@ function buildStrictPolicyWhitelist(ownerXonlyValues) {
     const entries = owners.map((ownerXonly, ownerIndex) => {
         const proof = [];
         let index = ownerIndex;
-        for (let depth = 0; depth < exports.STRICT_POLICY_WHITELIST_DEPTH; depth += 1) {
+        for (let level = 0; level < depth; level += 1) {
             const siblingIndex = index ^ 1;
             proof.push({
                 siblingPosition: siblingIndex < index ? "left" : "right",
-                siblingHash: levels[depth][siblingIndex],
+                siblingHash: levels[level][siblingIndex],
             });
             index = Math.floor(index / 2);
         }
@@ -163,8 +204,8 @@ function buildStrictPolicyWhitelist(ownerXonlyValues) {
         };
     });
     return {
-        depth: exports.STRICT_POLICY_WHITELIST_DEPTH,
-        root: levels[exports.STRICT_POLICY_WHITELIST_DEPTH][0],
+        depth,
+        root: levels[depth][0],
         entries,
     };
 }
@@ -182,8 +223,9 @@ function verifyStrictPolicyWhitelistProof(input) {
 }
 function normalizeStrictPolicyWhitelistProof(input) {
     const ownerXonly = hex32(input.ownerXonly, "ownerXonly");
-    if (!Array.isArray(input.proof) || input.proof.length !== exports.STRICT_POLICY_WHITELIST_DEPTH) {
-        validationError("proof", `must contain exactly ${exports.STRICT_POLICY_WHITELIST_DEPTH} sibling hashes`);
+    const depth = strictPolicyWhitelistDepth(input.depth);
+    if (!Array.isArray(input.proof) || input.proof.length !== depth) {
+        validationError("proof", `must contain exactly ${depth} sibling hashes`);
     }
     const proof = input.proof.map((step, index) => {
         if (!step || typeof step !== "object") {
@@ -199,6 +241,14 @@ function normalizeStrictPolicyWhitelistProof(input) {
     });
     return { ownerXonly, proof };
 }
+function strictPolicyWhitelistDepth(value) {
+    if (value === undefined)
+        return exports.STRICT_POLICY_WHITELIST_DEPTH;
+    if (!Number.isInteger(value) || value < 1 || value > exports.STRICT_POLICY_WHITELIST_DEPTH) {
+        validationError("depth", `must be an integer between 1 and ${exports.STRICT_POLICY_WHITELIST_DEPTH}`);
+    }
+    return value;
+}
 function strictPolicyWhitelistTagHashes() {
     return {
         owner: sha256(Buffer.from(exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN, "utf8")).toString("hex"),

package/dist/index.d.ts

@@ -25,8 +25,8 @@ export { configureStrictPolicyCrypto, } from "./core/strictPolicyCrypto";
 export type { StrictPolicyCryptoProvider, } from "./core/strictPolicyCrypto";
 export { STRICT_POLICY_SNAPSHOT_SCHEMA, STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA, STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN, STRICT_POLICY_AUTHORITY_SET_DOMAIN, STRICT_POLICY_VERIFIER_MAX_INPUTS, STRICT_POLICY_VERIFIER_MAX_OUTPUTS, normalizeStrictPolicySnapshotPayload, normalizeStrictPolicySnapshotAuthority, normalizeStrictPolicySnapshotApprovalProof, taggedHashHexUtf8, computeStrictPolicyAuthoritySetHash, normalizeStrictPolicyHolderCovenantParams, normalizeStrictPolicyVerifierCovenantParams, strictPolicyHolderCovenantTemplatePath, strictPolicyVerifierCovenantTemplatePath, renderStrictPolicyHolderCovenantSource, renderStrictPolicyVerifierCovenantSource, compileStrictPolicyHolderCovenant, compileStrictPolicyVerifierCovenant, prepareStrictPolicySnapshot, finalizeStrictPolicySnapshot, verifyStrictPolicySnapshot, } from "./domain/damp";
 export type { StrictPolicyNetwork, StrictPolicyVerifierReference, StrictPolicySnapshotPayload, StrictPolicySnapshotAuthority, StrictPolicySnapshotApprovalProof, PreparedStrictPolicySnapshot, StrictPolicySnapshotEnvelope, StrictPolicyHolderCovenantParams, StrictPolicyVerifierCovenantParams, } from "./domain/damp";
-export { STRICT_POLICY_WHITELIST_DEPTH, STRICT_POLICY_MAX_WHITELIST_OWNERS, STRICT_POLICY_WHITELIST_OWNER_DOMAIN, STRICT_POLICY_WHITELIST_EMPTY_DOMAIN, STRICT_POLICY_WHITELIST_NODE_DOMAIN, computeStrictPolicyHolderTapleafHash, computeStrictPolicyOwnerTapDataHash, computeElementsTapBranch, deriveStrictPolicyHolderPosition, computeStrictPolicyWhitelistOwnerLeaf, computeStrictPolicyWhitelistEmptyLeaf, computeStrictPolicyWhitelistNode, buildStrictPolicyWhitelist, normalizeStrictPolicyWhitelistProof, verifyStrictPolicyWhitelistProof, strictPolicyWhitelistTagHashes, } from "./domain/dampPolicy";
-export type { StrictPolicyHolderPositionParams, StrictPolicyHolderPosition, StrictPolicyWhitelistProofStep, StrictPolicyWhitelistProof, StrictPolicyWhitelistEntry, StrictPolicyWhitelist, } from "./domain/dampPolicy";
+export { STRICT_POLICY_WHITELIST_DEPTH, STRICT_POLICY_MAX_WHITELIST_OWNERS, STRICT_POLICY_COMPACT_WHITELIST_DEPTH, STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS, STRICT_POLICY_VERIFIER_RESOURCE_PROFILES, STRICT_POLICY_WHITELIST_OWNER_DOMAIN, STRICT_POLICY_WHITELIST_EMPTY_DOMAIN, STRICT_POLICY_WHITELIST_NODE_DOMAIN, computeStrictPolicyHolderTapleafHash, computeStrictPolicyOwnerTapDataHash, computeElementsTapBranch, deriveStrictPolicyHolderPosition, computeStrictPolicyWhitelistOwnerLeaf, computeStrictPolicyWhitelistEmptyLeaf, computeStrictPolicyWhitelistNode, buildStrictPolicyWhitelist, normalizeStrictPolicyWhitelistProof, verifyStrictPolicyWhitelistProof, strictPolicyWhitelistTagHashes, resolveStrictPolicyVerifierResourceProfile, } from "./domain/dampPolicy";
+export type { StrictPolicyHolderPositionParams, StrictPolicyHolderPosition, StrictPolicyWhitelistProofStep, StrictPolicyWhitelistProof, StrictPolicyWhitelistEntry, StrictPolicyWhitelist, StrictPolicyVerifierResourceProfile, StrictPolicyVerifierResourceProfileId, } from "./domain/dampPolicy";
 export { STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA, normalizeStrictPolicyDecodedTransaction, inspectStrictPolicyTransaction, inspectStrictPolicyTransactionWithProofs, } from "./domain/dampTransaction";
 export type { StrictPolicyOperation, StrictPolicyTransactionOutpoint, StrictPolicyDecodedInput, StrictPolicyDecodedOutput, StrictPolicyDecodedTransaction, StrictPolicyTransactionExpectation, StrictPolicyTransactionSummary, StrictPolicyTransactionInspection, StrictPolicyOutputAuthorization, StrictPolicyProofBackedTransactionExpectation, StrictPolicyVerifiedOutputAuthorization, StrictPolicyProofBackedTransactionInspection, } from "./domain/dampTransaction";
 export { STRICT_POLICY_PSET_INSPECTION_SCHEMA, normalizeStrictPolicyPsetInspection, inspectStrictPolicyPsetForSigning, } from "./domain/dampPset";

package/dist/index.js

@@ -18,7 +18,7 @@ exports.signPositionReceipt = exports.verifyCapitalCall = exports.executeCapital
 exports.validateFundDefinition = exports.summarizeFundFinalityPayload = exports.summarizeFundClosingDescriptor = exports.summarizeDistributionDescriptor = exports.summarizeLPPositionReceipt = exports.summarizeCapitalCallState = exports.summarizeFundDefinition = exports.validateBondSettlementMatchesExpected = exports.validateBondSettlementDescriptor = exports.summarizeBondSettlementDescriptor = exports.verifyBondIssuanceHistory = exports.summarizeBondIssuanceState = exports.buildRedeemedBondIssuanceState = exports.validateBondStateTransition = exports.validateBondCrossChecks = exports.validateBondIssuanceState = exports.validateBondDefinition = exports.exportReceivableFinalityPayload = exports.exportReceivableEvidence = exports.verifyReceivableStateHistory = exports.verifyReceivableClosing = exports.prepareReceivableClosing = exports.verifyReceivableWriteOff = exports.prepareReceivableWriteOff = exports.verifyReceivableRepaymentClaim = exports.executeReceivableRepaymentClaim = exports.inspectReceivableRepaymentClaim = exports.prepareReceivableRepaymentClaim = exports.verifyReceivableRepayment = exports.prepareReceivableRepayment = exports.verifyReceivableFundingClaim = exports.executeReceivableFundingClaim = exports.inspectReceivableFundingClaim = exports.prepareReceivableFundingClaim = exports.verifyReceivableFunding = exports.prepareReceivableFunding = exports.loadReceivable = exports.verifyReceivable = exports.defineReceivable = exports.exportFundFinalityPayload = exports.exportFundEvidence = exports.verifyFundClosing = exports.prepareFundClosing = exports.verifyDistribution = exports.executeDistributionClaim = exports.inspectDistributionClaim = exports.reconcilePosition = exports.prepareDistribution = exports.verifyPositionReceiptChain = exports.verifyPositionReceipt = void 0;
 exports.inspectRwaDvpDeliveryClaim = exports.exportRwaDvpEvidence = exports.executeRwaDvpRefundClaim = exports.executeRwaDvpDeliveryClaim = exports.defineRwaDvpPurchase = exports.compileRwaDvpEscrowContract = exports.buildRwaDvpPaymentRequirements = exports.RWA_DVP_VERIFICATION_SCHEMA_VERSION = exports.RWA_DVP_REFUND_CLAIM_SCHEMA_VERSION = exports.RWA_DVP_PURCHASE_SCHEMA_VERSION = exports.RWA_DVP_EVIDENCE_SCHEMA_VERSION = exports.RWA_DVP_DELIVERY_CLAIM_SCHEMA_VERSION = exports.verifyReceivableStateHistoryValidation = exports.validateReceivableWriteOffTransition = exports.validateReceivableRepaymentTransition = exports.validateReceivableFundingTransition = exports.validateReceivableCrossChecks = exports.validateReceivableState = exports.validateReceivableRepaymentClaimDescriptor = exports.validateReceivableRepaymentClaimAgainstState = exports.validateReceivableFundingClaimDescriptor = exports.validateReceivableFundingClaimAgainstState = exports.validateReceivableDefinition = exports.validateReceivableClosingDescriptor = exports.validateReceivableClosingAgainstState = exports.summarizeReceivableState = exports.summarizeReceivableRepaymentClaimDescriptor = exports.summarizeReceivableFundingClaimDescriptor = exports.summarizeReceivableDefinition = exports.summarizeReceivableClosingDescriptor = exports.buildReceivableRepaymentClaimDescriptor = exports.buildReceivableFundingClaimDescriptor = exports.buildReceivableClosingDescriptor = exports.buildFundedReceivableState = exports.buildDefaultedReceivableState = exports.applyReceivableRepayment = exports.buildFundClosingDescriptor = exports.buildDistributionDescriptor = exports.applyDistributionsToReceipt = exports.applyDistributionToReceipt = exports.buildLPPositionReceipt = exports.buildRefundedCapitalCallState = exports.buildClaimedCapitalCallState = exports.validateClosingAgainstReceipt = exports.validateDistributionAgainstReceipt = exports.validateFundCrossChecks = exports.validateFundClosingDescriptor = exports.validateDistributionDescriptor = exports.validateLPPositionReceipt = exports.validateCapitalCallState = void 0;
 exports.verifyStrictPolicySnapshot = exports.finalizeStrictPolicySnapshot = exports.prepareStrictPolicySnapshot = exports.compileStrictPolicyVerifierCovenant = exports.compileStrictPolicyHolderCovenant = exports.renderStrictPolicyVerifierCovenantSource = exports.renderStrictPolicyHolderCovenantSource = exports.strictPolicyVerifierCovenantTemplatePath = exports.strictPolicyHolderCovenantTemplatePath = exports.normalizeStrictPolicyVerifierCovenantParams = exports.normalizeStrictPolicyHolderCovenantParams = exports.computeStrictPolicyAuthoritySetHash = exports.taggedHashHexUtf8 = exports.normalizeStrictPolicySnapshotApprovalProof = exports.normalizeStrictPolicySnapshotAuthority = exports.normalizeStrictPolicySnapshotPayload = exports.STRICT_POLICY_VERIFIER_MAX_OUTPUTS = exports.STRICT_POLICY_VERIFIER_MAX_INPUTS = exports.STRICT_POLICY_AUTHORITY_SET_DOMAIN = exports.STRICT_POLICY_SNAPSHOT_APPROVAL_DOMAIN = exports.STRICT_POLICY_SNAPSHOT_APPROVAL_SCHEMA = exports.STRICT_POLICY_SNAPSHOT_SCHEMA = exports.configureStrictPolicyCrypto = exports.validatePolicyTransferDescriptor = exports.validatePolicyOutputDescriptor = exports.validatePolicyState = exports.summarizePolicyTransferDescriptor = exports.summarizePolicyOutputDescriptor = exports.summarizePolicyState = exports.exportPolicyEvidence = exports.verifyTransfer = exports.verifyState = exports.inspectTransfer = exports.executeTransfer = exports.prepareTransfer = exports.issue = exports.validatePolicyTemplateParams = exports.describePolicyTemplate = exports.validatePolicyTemplateManifest = exports.loadPolicyTemplateManifest = exports.listPolicyTemplates = exports.buildPolicyOutputDescriptor = exports.compilePolicyStateContract = exports.verifyRwaDvpRefundClaim = exports.verifyRwaDvpPaymentPset = exports.verifyRwaDvpDeliveryClaim = exports.summarizeRwaDvpPurchase = exports.prepareRwaDvpRefundClaim = exports.prepareRwaDvpDeliveryClaim = exports.inspectRwaDvpRefundClaim = void 0;
-exports.inspectStrictPolicyPsetForSigning = exports.normalizeStrictPolicyPsetInspection = exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA = exports.inspectStrictPolicyTransactionWithProofs = exports.inspectStrictPolicyTransaction = exports.normalizeStrictPolicyDecodedTransaction = exports.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA = exports.strictPolicyWhitelistTagHashes = exports.verifyStrictPolicyWhitelistProof = exports.normalizeStrictPolicyWhitelistProof = exports.buildStrictPolicyWhitelist = exports.computeStrictPolicyWhitelistNode = exports.computeStrictPolicyWhitelistEmptyLeaf = exports.computeStrictPolicyWhitelistOwnerLeaf = exports.deriveStrictPolicyHolderPosition = exports.computeElementsTapBranch = exports.computeStrictPolicyOwnerTapDataHash = exports.computeStrictPolicyHolderTapleafHash = exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_WHITELIST_DEPTH = void 0;
+exports.inspectStrictPolicyPsetForSigning = exports.normalizeStrictPolicyPsetInspection = exports.STRICT_POLICY_PSET_INSPECTION_SCHEMA = exports.inspectStrictPolicyTransactionWithProofs = exports.inspectStrictPolicyTransaction = exports.normalizeStrictPolicyDecodedTransaction = exports.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA = exports.resolveStrictPolicyVerifierResourceProfile = exports.strictPolicyWhitelistTagHashes = exports.verifyStrictPolicyWhitelistProof = exports.normalizeStrictPolicyWhitelistProof = exports.buildStrictPolicyWhitelist = exports.computeStrictPolicyWhitelistNode = exports.computeStrictPolicyWhitelistEmptyLeaf = exports.computeStrictPolicyWhitelistOwnerLeaf = exports.deriveStrictPolicyHolderPosition = exports.computeElementsTapBranch = exports.computeStrictPolicyOwnerTapDataHash = exports.computeStrictPolicyHolderTapleafHash = exports.STRICT_POLICY_WHITELIST_NODE_DOMAIN = exports.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN = exports.STRICT_POLICY_WHITELIST_OWNER_DOMAIN = exports.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES = exports.STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_COMPACT_WHITELIST_DEPTH = exports.STRICT_POLICY_MAX_WHITELIST_OWNERS = exports.STRICT_POLICY_WHITELIST_DEPTH = void 0;
 var SimplicityClient_1 = require("./client/SimplicityClient");
 Object.defineProperty(exports, "createSimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.createSimplicityClient; } });
 Object.defineProperty(exports, "SimplicityClient", { enumerable: true, get: function () { return SimplicityClient_1.SimplicityClient; } });
@@ -246,6 +246,9 @@ Object.defineProperty(exports, "verifyStrictPolicySnapshot", { enumerable: true,
 var dampPolicy_1 = require("./domain/dampPolicy");
 Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_DEPTH", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_DEPTH; } });
 Object.defineProperty(exports, "STRICT_POLICY_MAX_WHITELIST_OWNERS", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_MAX_WHITELIST_OWNERS; } });
+Object.defineProperty(exports, "STRICT_POLICY_COMPACT_WHITELIST_DEPTH", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_COMPACT_WHITELIST_DEPTH; } });
+Object.defineProperty(exports, "STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_COMPACT_MAX_WHITELIST_OWNERS; } });
+Object.defineProperty(exports, "STRICT_POLICY_VERIFIER_RESOURCE_PROFILES", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_VERIFIER_RESOURCE_PROFILES; } });
 Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_OWNER_DOMAIN", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_OWNER_DOMAIN; } });
 Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_EMPTY_DOMAIN", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_EMPTY_DOMAIN; } });
 Object.defineProperty(exports, "STRICT_POLICY_WHITELIST_NODE_DOMAIN", { enumerable: true, get: function () { return dampPolicy_1.STRICT_POLICY_WHITELIST_NODE_DOMAIN; } });
@@ -260,6 +263,7 @@ Object.defineProperty(exports, "buildStrictPolicyWhitelist", { enumerable: true,
 Object.defineProperty(exports, "normalizeStrictPolicyWhitelistProof", { enumerable: true, get: function () { return dampPolicy_1.normalizeStrictPolicyWhitelistProof; } });
 Object.defineProperty(exports, "verifyStrictPolicyWhitelistProof", { enumerable: true, get: function () { return dampPolicy_1.verifyStrictPolicyWhitelistProof; } });
 Object.defineProperty(exports, "strictPolicyWhitelistTagHashes", { enumerable: true, get: function () { return dampPolicy_1.strictPolicyWhitelistTagHashes; } });
+Object.defineProperty(exports, "resolveStrictPolicyVerifierResourceProfile", { enumerable: true, get: function () { return dampPolicy_1.resolveStrictPolicyVerifierResourceProfile; } });
 var dampTransaction_1 = require("./domain/dampTransaction");
 Object.defineProperty(exports, "STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA", { enumerable: true, get: function () { return dampTransaction_1.STRICT_POLICY_TRANSACTION_SUMMARY_SCHEMA; } });
 Object.defineProperty(exports, "normalizeStrictPolicyDecodedTransaction", { enumerable: true, get: function () { return dampTransaction_1.normalizeStrictPolicyDecodedTransaction; } });

package/package.json

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