@hazbase/simplicity 0.0.5 → 0.1.1

package/dist/docs/definitions/bond-descriptor-bound-settlement-machine.simf

@@ -0,0 +1,144 @@
+/*
+ * Bond descriptor-bound settlement machine contract.
+ *
+ * This machine commits the full settlement descriptor and additionally binds
+ * the next non-fee output by its runtime output hash. This is stronger than
+ * the script-bound machine because it constrains the full output descriptor
+ * represented by output_hash(0), not just the next output script.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_previous_state_anchor() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(previous_state_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_next_contract_address_anchor() {
+    let next_contract_address_hash: u256 = 0x{{NEXT_CONTRACT_ADDRESS_HASH_256}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(next_contract_address_hash, zero_hash)));
+}
+
+fn require_settlement_descriptor_anchor() {
+    let settlement_descriptor_hash: u256 = 0x{{SETTLEMENT_DESCRIPTOR_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(settlement_descriptor_hash, zero_hash)));
+}
+
+fn require_expected_output_descriptor_anchor() {
+    let expected_output_descriptor_hash: u256 = 0x{{EXPECTED_OUTPUT_DESCRIPTOR_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(expected_output_descriptor_hash, zero_hash)));
+}
+
+fn require_expected_next_output_hash_anchor() {
+    let expected_next_output_hash: u256 = 0x{{EXPECTED_NEXT_OUTPUT_HASH_256}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(expected_next_output_hash, zero_hash)));
+}
+
+fn require_distinct_transition_state() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let next_state_hash: u256 = 0x{{STATE_HASH}};
+    assert!(not(jet::eq_256(previous_state_hash, next_state_hash)));
+}
+
+fn require_transition_kind() {
+    let transition_kind: u256 = 0x{{TRANSITION_KIND_256}};
+    let redeem_kind: u256 = 0x0000000000000000000000000000000000000000000000000000000000000001;
+    assert!(jet::eq_256(transition_kind, redeem_kind));
+}
+
+fn require_redeem_amount() {
+    let redeem_amount: u256 = 0x{{REDEEM_AMOUNT_256}};
+    let zero_amount: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(redeem_amount, zero_amount)));
+}
+
+fn require_status_progression() {
+    let previous_status: u32 = 0x{{PREVIOUS_STATUS_32}};
+    let next_status: u32 = 0x{{NEXT_STATUS_32}};
+    let issued_status: u32 = 0x00000001;
+    let partial_status: u32 = 0x00000002;
+    let redeemed_status: u32 = 0x00000003;
+
+    match jet::eq_32(previous_status, issued_status) {
+        true => {},
+        false => assert!(jet::eq_32(previous_status, partial_status)),
+    };
+
+    match jet::eq_32(next_status, partial_status) {
+        true => {},
+        false => assert!(jet::eq_32(next_status, redeemed_status)),
+    };
+}
+
+fn require_principal_arithmetic() {
+    let previous_outstanding: u32 = 0x{{PREVIOUS_OUTSTANDING_32}};
+    let previous_redeemed: u32 = 0x{{PREVIOUS_REDEEMED_32}};
+    let next_outstanding: u32 = 0x{{NEXT_OUTSTANDING_32}};
+    let next_redeemed: u32 = 0x{{NEXT_REDEEMED_32}};
+    let redeem_amount: u32 = 0x{{REDEEM_AMOUNT_32}};
+    let partial_status: u32 = 0x00000002;
+    let redeemed_status: u32 = 0x00000003;
+    let next_status: u32 = 0x{{NEXT_STATUS_32}};
+    let zero: u32 = 0x00000000;
+
+    let (underflow, computed_next_outstanding): (bool, u32) = jet::subtract_32(previous_outstanding, redeem_amount);
+    assert!(not(underflow));
+    assert!(jet::eq_32(computed_next_outstanding, next_outstanding));
+
+    let (overflow, computed_next_redeemed): (bool, u32) = jet::add_32(previous_redeemed, redeem_amount);
+    assert!(not(overflow));
+    assert!(jet::eq_32(computed_next_redeemed, next_redeemed));
+
+    match jet::eq_32(next_outstanding, zero) {
+        true => assert!(jet::eq_32(next_status, redeemed_status)),
+        false => assert!(jet::eq_32(next_status, partial_status)),
+    };
+}
+
+fn require_output_shape() {
+    assert!(jet::eq_32(jet::num_outputs(), 2));
+    assert!(unwrap(jet::output_is_fee(1)));
+    let expected_next_output_hash: u256 = 0x{{EXPECTED_NEXT_OUTPUT_HASH_256}};
+    let actual_next_output_hash: u256 = match jet::output_hash(0) {
+        Some(output_hash : u256) => output_hash,
+        None => panic!(),
+    };
+    assert!(jet::eq_256(actual_next_output_hash, expected_next_output_hash));
+}
+
+fn main() {
+    require_definition_anchor();
+    require_previous_state_anchor();
+    require_state_anchor();
+    require_next_contract_address_anchor();
+    require_settlement_descriptor_anchor();
+    require_expected_output_descriptor_anchor();
+    require_expected_next_output_hash_anchor();
+    require_distinct_transition_state();
+    require_transition_kind();
+    require_redeem_amount();
+    require_status_progression();
+    require_principal_arithmetic();
+    require_output_shape();
+    jet::check_lock_height({{MIN_HEIGHT}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/bond-issuance-anchor.simf

@@ -0,0 +1,26 @@
+/*
+ * Bond definition and issuance state hash anchors via executed logic.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    jet::check_lock_height({{MIN_HEIGHT}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/bond-issuance-state-partial-redemption.json

@@ -0,0 +1,18 @@
+{
+  "issuanceId": "BOND-2026-001-ISSUE-1",
+  "bondId": "BOND-2026-001",
+  "issuerEntityId": "hazbase-treasury",
+  "issuedPrincipal": 1000000,
+  "outstandingPrincipal": 750000,
+  "redeemedPrincipal": 250000,
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+  "issuedAt": "2026-03-10T00:00:00Z",
+  "status": "PARTIALLY_REDEEMED",
+  "previousStateHash": "83a003a8b1146e839f55df4cb668eb90157fb2de4f612408fe45a82f4d22b435",
+  "lastTransition": {
+    "type": "REDEEM",
+    "amount": 250000,
+    "at": "2027-03-10T00:00:00Z"
+  }
+}

package/dist/docs/definitions/bond-issuance-state-redeemed.json

@@ -0,0 +1,18 @@
+{
+  "issuanceId": "BOND-2026-001-ISSUE-1",
+  "bondId": "BOND-2026-001",
+  "issuerEntityId": "hazbase-treasury",
+  "issuedPrincipal": 1000000,
+  "outstandingPrincipal": 0,
+  "redeemedPrincipal": 1000000,
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+  "issuedAt": "2026-03-10T00:00:00Z",
+  "status": "REDEEMED",
+  "previousStateHash": "83a003a8b1146e839f55df4cb668eb90157fb2de4f612408fe45a82f4d22b435",
+  "lastTransition": {
+    "type": "REDEEM",
+    "amount": 1000000,
+    "at": "2027-03-10T00:00:00Z"
+  }
+}

package/dist/docs/definitions/bond-issuance-state.json

@@ -0,0 +1,12 @@
+{
+  "issuanceId": "BOND-2026-001-ISSUE-1",
+  "bondId": "BOND-2026-001",
+  "issuerEntityId": "hazbase-treasury",
+  "issuedPrincipal": 1000000,
+  "outstandingPrincipal": 1000000,
+  "redeemedPrincipal": 0,
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+  "issuedAt": "2026-03-10T00:00:00Z",
+  "status": "ISSUED"
+}

package/dist/docs/definitions/bond-redemption-state-machine.simf

@@ -0,0 +1,118 @@
+/*
+ * Bond redemption state machine contract.
+ * Commits definition hash, previous state hash, next state hash,
+ * transition kind, redeem amount, status progression,
+ * principal arithmetic, the expected next state contract address,
+ * and the settlement descriptor hash
+ * via executed logic.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_previous_state_anchor() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(previous_state_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_next_contract_address_anchor() {
+    let next_contract_address_hash: u256 = 0x{{NEXT_CONTRACT_ADDRESS_HASH_256}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(next_contract_address_hash, zero_hash)));
+}
+
+fn require_settlement_descriptor_anchor() {
+    let settlement_descriptor_hash: u256 = 0x{{SETTLEMENT_DESCRIPTOR_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(settlement_descriptor_hash, zero_hash)));
+}
+
+fn require_distinct_transition_state() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let next_state_hash: u256 = 0x{{STATE_HASH}};
+    assert!(not(jet::eq_256(previous_state_hash, next_state_hash)));
+}
+
+fn require_transition_kind() {
+    let transition_kind: u256 = 0x{{TRANSITION_KIND_256}};
+    let redeem_kind: u256 = 0x0000000000000000000000000000000000000000000000000000000000000001;
+    assert!(jet::eq_256(transition_kind, redeem_kind));
+}
+
+fn require_redeem_amount() {
+    let redeem_amount: u256 = 0x{{REDEEM_AMOUNT_256}};
+    let zero_amount: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(redeem_amount, zero_amount)));
+}
+
+fn require_status_progression() {
+    let previous_status: u32 = 0x{{PREVIOUS_STATUS_32}};
+    let next_status: u32 = 0x{{NEXT_STATUS_32}};
+    let issued_status: u32 = 0x00000001;
+    let partial_status: u32 = 0x00000002;
+    let redeemed_status: u32 = 0x00000003;
+
+    match jet::eq_32(previous_status, issued_status) {
+        true => {},
+        false => assert!(jet::eq_32(previous_status, partial_status)),
+    };
+
+    match jet::eq_32(next_status, partial_status) {
+        true => {},
+        false => assert!(jet::eq_32(next_status, redeemed_status)),
+    };
+}
+
+fn require_principal_arithmetic() {
+    let previous_outstanding: u32 = 0x{{PREVIOUS_OUTSTANDING_32}};
+    let previous_redeemed: u32 = 0x{{PREVIOUS_REDEEMED_32}};
+    let next_outstanding: u32 = 0x{{NEXT_OUTSTANDING_32}};
+    let next_redeemed: u32 = 0x{{NEXT_REDEEMED_32}};
+    let redeem_amount: u32 = 0x{{REDEEM_AMOUNT_32}};
+    let partial_status: u32 = 0x00000002;
+    let redeemed_status: u32 = 0x00000003;
+    let next_status: u32 = 0x{{NEXT_STATUS_32}};
+    let zero: u32 = 0x00000000;
+
+    let (underflow, computed_next_outstanding): (bool, u32) = jet::subtract_32(previous_outstanding, redeem_amount);
+    assert!(not(underflow));
+    assert!(jet::eq_32(computed_next_outstanding, next_outstanding));
+
+    let (overflow, computed_next_redeemed): (bool, u32) = jet::add_32(previous_redeemed, redeem_amount);
+    assert!(not(overflow));
+    assert!(jet::eq_32(computed_next_redeemed, next_redeemed));
+
+    match jet::eq_32(next_outstanding, zero) {
+        true => assert!(jet::eq_32(next_status, redeemed_status)),
+        false => assert!(jet::eq_32(next_status, partial_status)),
+    };
+}
+
+fn main() {
+    require_definition_anchor();
+    require_previous_state_anchor();
+    require_state_anchor();
+    require_next_contract_address_anchor();
+    require_settlement_descriptor_anchor();
+    require_distinct_transition_state();
+    require_transition_kind();
+    require_redeem_amount();
+    require_status_progression();
+    require_principal_arithmetic();
+    jet::check_lock_height({{MIN_HEIGHT}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/bond-redemption-transition.simf

@@ -0,0 +1,41 @@
+/*
+ * Bond redemption transition contract.
+ * Commits definition hash, previous issuance state hash, and next issuance state hash.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_previous_state_anchor() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(previous_state_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_distinct_transition_state() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let next_state_hash: u256 = 0x{{STATE_HASH}};
+    assert!(not(jet::eq_256(previous_state_hash, next_state_hash)));
+}
+
+fn main() {
+    require_definition_anchor();
+    require_previous_state_anchor();
+    require_state_anchor();
+    require_distinct_transition_state();
+    jet::check_lock_height({{MIN_HEIGHT}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/bond-script-bound-settlement-machine.simf

@@ -0,0 +1,142 @@
+/*
+ * Bond script-bound settlement machine contract.
+ *
+ * This machine keeps the existing redemption commitments and additionally
+ * constrains the settlement shape to a two-output transaction with a fee
+ * output in the configured fee slot. The next contract address and expected
+ * output descriptor remain committed data; runtime script binding is currently
+ * limited to output count and fee position.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_previous_state_anchor() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(previous_state_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_next_contract_address_anchor() {
+    let next_contract_address_hash: u256 = 0x{{NEXT_CONTRACT_ADDRESS_HASH_256}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(next_contract_address_hash, zero_hash)));
+}
+
+fn require_settlement_descriptor_anchor() {
+    let settlement_descriptor_hash: u256 = 0x{{SETTLEMENT_DESCRIPTOR_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(settlement_descriptor_hash, zero_hash)));
+}
+
+fn require_expected_output_descriptor_anchor() {
+    let expected_output_descriptor_hash: u256 = 0x{{EXPECTED_OUTPUT_DESCRIPTOR_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(expected_output_descriptor_hash, zero_hash)));
+}
+
+fn require_expected_next_output_script_hash_anchor() {
+    let expected_next_output_script_hash: u256 = 0x{{EXPECTED_NEXT_OUTPUT_SCRIPT_HASH_256}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(expected_next_output_script_hash, zero_hash)));
+}
+
+fn require_distinct_transition_state() {
+    let previous_state_hash: u256 = 0x{{PREVIOUS_STATE_HASH}};
+    let next_state_hash: u256 = 0x{{STATE_HASH}};
+    assert!(not(jet::eq_256(previous_state_hash, next_state_hash)));
+}
+
+fn require_transition_kind() {
+    let transition_kind: u256 = 0x{{TRANSITION_KIND_256}};
+    let redeem_kind: u256 = 0x0000000000000000000000000000000000000000000000000000000000000001;
+    assert!(jet::eq_256(transition_kind, redeem_kind));
+}
+
+fn require_redeem_amount() {
+    let redeem_amount: u256 = 0x{{REDEEM_AMOUNT_256}};
+    let zero_amount: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(redeem_amount, zero_amount)));
+}
+
+fn require_status_progression() {
+    let previous_status: u32 = 0x{{PREVIOUS_STATUS_32}};
+    let next_status: u32 = 0x{{NEXT_STATUS_32}};
+    let issued_status: u32 = 0x00000001;
+    let partial_status: u32 = 0x00000002;
+    let redeemed_status: u32 = 0x00000003;
+
+    match jet::eq_32(previous_status, issued_status) {
+        true => {},
+        false => assert!(jet::eq_32(previous_status, partial_status)),
+    };
+
+    match jet::eq_32(next_status, partial_status) {
+        true => {},
+        false => assert!(jet::eq_32(next_status, redeemed_status)),
+    };
+}
+
+fn require_principal_arithmetic() {
+    let previous_outstanding: u32 = 0x{{PREVIOUS_OUTSTANDING_32}};
+    let previous_redeemed: u32 = 0x{{PREVIOUS_REDEEMED_32}};
+    let next_outstanding: u32 = 0x{{NEXT_OUTSTANDING_32}};
+    let next_redeemed: u32 = 0x{{NEXT_REDEEMED_32}};
+    let redeem_amount: u32 = 0x{{REDEEM_AMOUNT_32}};
+    let partial_status: u32 = 0x00000002;
+    let redeemed_status: u32 = 0x00000003;
+    let next_status: u32 = 0x{{NEXT_STATUS_32}};
+    let zero: u32 = 0x00000000;
+
+    let (underflow, computed_next_outstanding): (bool, u32) = jet::subtract_32(previous_outstanding, redeem_amount);
+    assert!(not(underflow));
+    assert!(jet::eq_32(computed_next_outstanding, next_outstanding));
+
+    let (overflow, computed_next_redeemed): (bool, u32) = jet::add_32(previous_redeemed, redeem_amount);
+    assert!(not(overflow));
+    assert!(jet::eq_32(computed_next_redeemed, next_redeemed));
+
+    match jet::eq_32(next_outstanding, zero) {
+        true => assert!(jet::eq_32(next_status, redeemed_status)),
+        false => assert!(jet::eq_32(next_status, partial_status)),
+    };
+}
+
+fn require_output_shape() {
+    assert!(jet::eq_32(jet::num_outputs(), 2));
+    assert!(unwrap(jet::output_is_fee(1)));
+    let expected_next_output_script_hash: u256 = 0x{{EXPECTED_NEXT_OUTPUT_SCRIPT_HASH_256}};
+    let actual_next_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+    assert!(jet::eq_256(actual_next_output_script_hash, expected_next_output_script_hash));
+}
+
+fn main() {
+    require_definition_anchor();
+    require_previous_state_anchor();
+    require_state_anchor();
+    require_next_contract_address_anchor();
+    require_settlement_descriptor_anchor();
+    require_expected_output_descriptor_anchor();
+    require_expected_next_output_script_hash_anchor();
+    require_distinct_transition_state();
+    require_transition_kind();
+    require_redeem_amount();
+    require_status_progression();
+    require_principal_arithmetic();
+    require_output_shape();
+    jet::check_lock_height({{MIN_HEIGHT}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/fund-capital-call-open.simf

@@ -0,0 +1,82 @@
+/*
+ * LP capital call open contract.
+ *
+ * LP funds the contract. The manager may claim immediately with their signature.
+ * After the configured cutoff height, anyone may roll the UTXO into the
+ * refund-only capital call state. Strict refund-only semantics are therefore
+ * consensus-enforced only after the rollover transaction confirms.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn require_output_shape(expected_output_hash: u256, expected_output_script_hash: u256, binding_mode: u8) {
+    match jet::eq_8(binding_mode, 1) {
+        true => {
+            let actual_output_hash: u256 = match jet::output_hash(0) {
+                Some(output_hash : u256) => output_hash,
+                None => panic!(),
+            };
+            assert!(jet::eq_32(jet::num_outputs(), 2));
+            assert!(unwrap(jet::output_is_fee(1)));
+            assert!(jet::eq_256(actual_output_hash, expected_output_hash));
+        },
+        false => {
+            match jet::eq_8(binding_mode, 2) {
+                true => {
+                    let actual_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+                    assert!(jet::eq_32(jet::num_outputs(), 2));
+                    assert!(unwrap(jet::output_is_fee(1)));
+                    assert!(jet::eq_256(actual_output_script_hash, expected_output_script_hash));
+                },
+                false => {},
+            }
+        },
+    }
+}
+
+fn claim_path(
+    expected_output_hash: u256,
+    expected_output_script_hash: u256,
+    binding_mode: u8,
+    manager_signature: Signature
+) {
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    let manager: Pubkey = 0x{{MANAGER_XONLY}};
+    jet::bip_0340_verify((manager, jet::sig_all_hash()), manager_signature)
+}
+
+fn rollover_path() {
+    let refund_only_script_hash: u256 = 0x{{REFUND_ONLY_SCRIPT_HASH}};
+    jet::check_lock_height({{CLAIM_CUTOFF_HEIGHT}});
+    let actual_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+    assert!(jet::eq_32(jet::num_outputs(), 2));
+    assert!(unwrap(jet::output_is_fee(1)));
+    assert!(jet::eq_256(actual_output_script_hash, refund_only_script_hash));
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    let action_8: u8 = witness::ACTION_8;
+    let expected_output_hash: u256 = witness::EXPECTED_PAYOUT_OUTPUT_HASH;
+    let expected_output_script_hash: u256 = witness::EXPECTED_PAYOUT_OUTPUT_SCRIPT_HASH;
+    let binding_mode: u8 = witness::OUTPUT_BINDING_MODE;
+    let signer_signature: Signature = witness::SIGNER_SIGNATURE;
+    match jet::eq_8(action_8, 1) {
+        true => claim_path(expected_output_hash, expected_output_script_hash, binding_mode, signer_signature),
+        false => rollover_path(),
+    }
+}

package/dist/docs/definitions/fund-capital-call-refund-only.simf

@@ -0,0 +1,33 @@
+/*
+ * LP capital call refund-only contract.
+ *
+ * This artifact is reached only after the open capital call is explicitly
+ * rolled over post-cutoff. Once in this state, only the LP refund path remains.
+ */
+fn not(bit: bool) -> bool {
+    <u1>::into(jet::complement_1(<bool>::into(bit)))
+}
+
+fn require_definition_anchor() {
+    let anchored_definition_hash: u256 = 0x{{DEFINITION_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_definition_hash, zero_hash)));
+}
+
+fn require_state_anchor() {
+    let anchored_state_hash: u256 = 0x{{STATE_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_state_hash, zero_hash)));
+}
+
+fn refund_path(lp_signature: Signature) {
+    let lp: Pubkey = 0x{{LP_XONLY}};
+    jet::bip_0340_verify((lp, jet::sig_all_hash()), lp_signature)
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    let signer_signature: Signature = witness::SIGNER_SIGNATURE;
+    refund_path(signer_signature)
+}

package/dist/docs/definitions/fund-capital-call-state.json

@@ -0,0 +1,11 @@
+{
+  "callId": "CALL-001",
+  "fundId": "FUND-2026-ALPHA",
+  "lpId": "lp-a",
+  "currencyAssetId": "bitcoin",
+  "amount": 6000,
+  "lpXonly": "f9308a019258c3106ac5d2d1c1d7d7f3c2e5f5b7a9e3d5f2c1a6b8c9d0e1f2a3",
+  "managerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+  "status": "OPEN",
+  "claimCutoffHeight": 2345678
+}

package/dist/docs/definitions/fund-definition.json

@@ -0,0 +1,8 @@
+{
+  "fundId": "FUND-2026-ALPHA",
+  "managerEntityId": "manager-a",
+  "managerXonly": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+  "currencyAssetId": "bitcoin",
+  "jurisdiction": "JP",
+  "vintage": "2026"
+}