@hazbase/simplicity 0.4.5 → 0.4.7

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),
+        },
+    }
+}

package/dist/domain/damp.d.ts

@@ -0,0 +1,94 @@
+import type { SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+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";
+export declare const STRICT_POLICY_AUTHORITY_SET_DOMAIN: "HAZBASE-RWA-POLICY-AUTHORITY-SET-V1";
+export declare const STRICT_POLICY_VERIFIER_MAX_INPUTS: 16;
+export declare const STRICT_POLICY_VERIFIER_MAX_OUTPUTS: 8;
+export type StrictPolicyNetwork = "liquid-regtest" | "liquid-testnet" | "liquid-mainnet";
+export interface StrictPolicyVerifierReference {
+    outpoint: {
+        txid: string;
+        vout: number;
+    };
+    assetId: string;
+    amountAtomic: string;
+    cmr: string;
+    scriptHash: string;
+}
+export interface StrictPolicySnapshotPayload {
+    schema: typeof STRICT_POLICY_SNAPSHOT_SCHEMA;
+    network: StrictPolicyNetwork;
+    liquidGenesisHash: string;
+    assetBindingId: string;
+    liquidAssetId: string;
+    epoch: string;
+    previousSnapshotHash: string | null;
+    policyRoot: string;
+    whitelistRoot: string;
+    verifier: StrictPolicyVerifierReference;
+    effectiveAt: string;
+    validUntil: string | null;
+}
+export interface StrictPolicySnapshotAuthority {
+    authorityType: "issuer_single";
+    authorityId: string;
+    authorityVersion: string;
+    authoritySetHash: string;
+    approvalScheme: "bip340-sha256";
+    approvalThreshold: 1;
+    signerXonly: string;
+    approvedAt: string;
+}
+export interface StrictPolicySnapshotApprovalProof {
+    type: "issuer_single_v1";
+    signerXonly: string;
+    signatureHex: string;
+}
+export interface PreparedStrictPolicySnapshot {
+    payload: StrictPolicySnapshotPayload;
+    authority: StrictPolicySnapshotAuthority;
+    canonicalPayload: string;
+    snapshotHash: string;
+    canonicalApprovalMessage: string;
+    approvalMessageHash: string;
+}
+export interface StrictPolicySnapshotEnvelope extends PreparedStrictPolicySnapshot {
+    approvalProof: StrictPolicySnapshotApprovalProof;
+    approvalProofHash: string;
+}
+export interface StrictPolicyHolderCovenantParams {
+    strictAssetIdJetHex: string;
+    verifierAssetIdJetHex: string;
+    verifierAmountAtomic: string;
+    numsInternalKey: string;
+}
+export interface StrictPolicyVerifierCovenantParams {
+    strictAssetIdJetHex: string;
+    verifierAssetIdJetHex: string;
+    verifierAmountAtomic: string;
+    holderProgramCmr: string;
+    holderNumsInternalKey: string;
+    whitelistRoot: string;
+    redemptionScriptHash: string;
+    authorityXonly: string;
+}
+export declare function normalizeStrictPolicySnapshotPayload(value: unknown): StrictPolicySnapshotPayload;
+export declare function normalizeStrictPolicySnapshotAuthority(value: unknown): StrictPolicySnapshotAuthority;
+export declare function normalizeStrictPolicySnapshotApprovalProof(value: unknown): StrictPolicySnapshotApprovalProof;
+export declare function normalizeStrictPolicyHolderCovenantParams(value: StrictPolicyHolderCovenantParams | unknown): StrictPolicyHolderCovenantParams;
+export declare function normalizeStrictPolicyVerifierCovenantParams(value: StrictPolicyVerifierCovenantParams | unknown): StrictPolicyVerifierCovenantParams;
+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 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;
+export declare function computeStrictPolicyAuthoritySetHash(signerXonlyValue: string): string;
+export declare function prepareStrictPolicySnapshot(input: {
+    payload: StrictPolicySnapshotPayload | unknown;
+    authority: StrictPolicySnapshotAuthority | unknown;
+}): PreparedStrictPolicySnapshot;
+export declare function finalizeStrictPolicySnapshot(prepared: PreparedStrictPolicySnapshot, proofValue: StrictPolicySnapshotApprovalProof | unknown): StrictPolicySnapshotEnvelope;
+export declare function verifyStrictPolicySnapshot(envelopeValue: StrictPolicySnapshotEnvelope): Promise<PreparedStrictPolicySnapshot>;