@hazbase/simplicity 0.0.5 → 0.2.0

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

@@ -0,0 +1,67 @@
+/*
+ * 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 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 refund_path(
+    expected_output_hash: u256,
+    expected_output_script_hash: u256,
+    binding_mode: u8,
+    lp_signature: Signature
+) {
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    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 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;
+    refund_path(expected_output_hash, expected_output_script_hash, binding_mode, 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"
+}

package/dist/docs/definitions/fund-distribution-claim.simf

@@ -0,0 +1,57 @@
+/*
+ * LP distribution claim contract.
+ *
+ * Fund admin prepares the distribution state off-chain, then the LP claims the
+ * payout in a one-shot spend. Runtime output binding is optional.
+ */
+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 main() {
+    require_definition_anchor();
+    require_state_anchor();
+    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;
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    let lp: Pubkey = 0x{{LP_XONLY}};
+    jet::bip_0340_verify((lp, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

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

@@ -0,0 +1,9 @@
+{
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "currencyAssetId": "bitcoin",
+  "faceValue": 10000,
+  "dueDate": "2027-12-31T00:00:00Z",
+  "controllerXonly": "1111111111111111111111111111111111111111111111111111111111111111"
+}

package/dist/docs/definitions/receivable-funding-claim.json

@@ -0,0 +1,13 @@
+{
+  "claimId": "REC-001-FUNDING-CLAIM",
+  "claimKind": "FUNDING",
+  "receivableId": "REC-001",
+  "currentStateHash": "7a61cc669844f3fd96165c99e3ca42cfae916e824dec4d60e51d56ef574e041a",
+  "currentStatus": "FUNDED",
+  "payerEntityId": "fund-1",
+  "payeeEntityId": "originator-1",
+  "claimantXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "currencyAssetId": "bitcoin",
+  "amountSat": 10000,
+  "eventTimestamp": "2027-01-02T00:00:00Z"
+}

package/dist/docs/definitions/receivable-funding-claim.simf

@@ -0,0 +1,58 @@
+/*
+ * Receivable funding claim contract.
+ *
+ * After a receivable moves into FUNDED state off-chain, the funder/SPV funds
+ * this one-shot claim contract and the committed claimant releases the payout
+ * to the originator-side destination. Runtime output binding is optional.
+ */
+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 main() {
+    require_definition_anchor();
+    require_state_anchor();
+    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;
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    let claimant: Pubkey = 0x{{CLAIMANT_XONLY}};
+    jet::bip_0340_verify((claimant, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/receivable-repayment-claim.json

@@ -0,0 +1,13 @@
+{
+  "claimId": "REC-001-REPAYMENT-CLAIM",
+  "claimKind": "REPAYMENT",
+  "receivableId": "REC-001",
+  "currentStateHash": "13ae81254644a47f33492812584e169b4ae2051dfedc5ad46d00510c137dc333",
+  "currentStatus": "REPAID",
+  "payerEntityId": "debtor-1",
+  "payeeEntityId": "fund-1",
+  "claimantXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "currencyAssetId": "bitcoin",
+  "amountSat": 10000,
+  "eventTimestamp": "2027-02-01T00:00:00Z"
+}

package/dist/docs/definitions/receivable-repayment-claim.simf

@@ -0,0 +1,59 @@
+/*
+ * Receivable repayment claim contract.
+ *
+ * After a receivable moves into PARTIALLY_REPAID or REPAID state off-chain,
+ * the debtor-side payment funds this one-shot claim contract and the committed
+ * claimant releases the payout to the current holder-side destination. Runtime
+ * output binding is optional.
+ */
+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 main() {
+    require_definition_anchor();
+    require_state_anchor();
+    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;
+    require_output_shape(expected_output_hash, expected_output_script_hash, binding_mode);
+    let claimant: Pubkey = 0x{{CLAIMANT_XONLY}};
+    jet::bip_0340_verify((claimant, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/receivable-state-funded.json

@@ -0,0 +1,20 @@
+{
+  "stateId": "REC-001-S1",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "fund-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "faceValue": 10000,
+  "outstandingAmount": 10000,
+  "repaidAmount": 0,
+  "status": "FUNDED",
+  "createdAt": "2027-01-02T00:00:00Z",
+  "previousStateHash": "575a96c8f73f9a68d8bc76f5683cf042f89dcff73c7136939daf26be6128d935",
+  "lastTransition": {
+    "type": "FUND",
+    "amount": 10000,
+    "at": "2027-01-02T00:00:00Z"
+  }
+}

package/dist/docs/definitions/receivable-state-originated.json

@@ -0,0 +1,19 @@
+{
+  "stateId": "REC-001-S0",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "originator-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "faceValue": 10000,
+  "outstandingAmount": 10000,
+  "repaidAmount": 0,
+  "status": "ORIGINATED",
+  "createdAt": "2027-01-01T00:00:00Z",
+  "lastTransition": {
+    "type": "ORIGINATE",
+    "amount": 10000,
+    "at": "2027-01-01T00:00:00Z"
+  }
+}

package/dist/docs/definitions/receivable-state-repaid.json

@@ -0,0 +1,20 @@
+{
+  "stateId": "REC-001-S2",
+  "receivableId": "REC-001",
+  "originatorEntityId": "originator-1",
+  "debtorEntityId": "debtor-1",
+  "holderEntityId": "fund-1",
+  "currencyAssetId": "bitcoin",
+  "controllerXonly": "1111111111111111111111111111111111111111111111111111111111111111",
+  "faceValue": 10000,
+  "outstandingAmount": 0,
+  "repaidAmount": 10000,
+  "status": "REPAID",
+  "createdAt": "2027-02-01T00:00:00Z",
+  "previousStateHash": "7a61cc669844f3fd96165c99e3ca42cfae916e824dec4d60e51d56ef574e041a",
+  "lastTransition": {
+    "type": "REPAY",
+    "amount": 10000,
+    "at": "2027-02-01T00:00:00Z"
+  }
+}

package/dist/docs/definitions/recursive-delay-direct-next.simf

@@ -0,0 +1,60 @@
+/*
+ * Recursive delay policy direct-transfer state contract.
+ *
+ * This variant is used for 1tx required-mode transfers. The current recipient
+ * can spend only after the configured relative delay, and only into the next
+ * constrained output shape committed through witness values at execution time.
+ */
+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_policy_hash_anchor() {
+    let anchored_policy_hash: u256 = 0x{{POLICY_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_policy_hash, zero_hash)));
+}
+
+fn require_required_mode() {
+    assert!(jet::eq_8({{PROPAGATION_MODE_8}}, 1));
+}
+
+fn require_next_transition_witness(next_policy_hash: u256, next_output_descriptor_hash: u256) {
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(next_policy_hash, zero_hash)));
+    assert!(not(jet::eq_256(next_output_descriptor_hash, zero_hash)));
+}
+
+fn require_output_shape(expected_next_output_script_hash: u256) {
+    assert!(jet::eq_32(jet::num_outputs(), 2));
+    assert!(unwrap(jet::output_is_fee(1)));
+    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_state_anchor();
+    require_policy_hash_anchor();
+    require_required_mode();
+    let next_policy_hash: u256 = witness::NEXT_POLICY_HASH;
+    let next_output_descriptor_hash: u256 = witness::NEXT_OUTPUT_DESCRIPTOR_HASH;
+    let expected_next_output_script_hash: u256 = witness::EXPECTED_NEXT_OUTPUT_SCRIPT_HASH;
+    require_next_transition_witness(next_policy_hash, next_output_descriptor_hash);
+    require_output_shape(expected_next_output_script_hash);
+    jet::check_lock_distance({{LOCK_DISTANCE}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/recursive-delay-optional.simf

@@ -0,0 +1,88 @@
+/*
+ * Recursive delay policy state contract for optional / terminating propagation.
+ *
+ * The current recipient can spend only after the configured relative delay.
+ * In optional mode, callers may either exit plainly or provide witness values
+ * that bind the next constrained output script hash in the same transaction.
+ */
+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_policy_hash_anchor() {
+    let anchored_policy_hash: u256 = 0x{{POLICY_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_policy_hash, zero_hash)));
+}
+
+fn require_next_transition_witness(next_policy_hash: u256, next_output_descriptor_hash: u256) {
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(next_policy_hash, zero_hash)));
+    assert!(not(jet::eq_256(next_output_descriptor_hash, zero_hash)));
+}
+
+fn maybe_require_recursive_branch(
+    next_policy_hash: u256,
+    next_output_descriptor_hash: u256,
+    expected_next_output_hash: u256,
+    expected_next_output_script_hash: u256
+) {
+    match jet::eq_8({{PROPAGATION_MODE_8}}, 2) {
+        true => {
+            let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+            match not(jet::eq_256(expected_next_output_script_hash, zero_hash)) {
+                true => {
+                    require_next_transition_witness(next_policy_hash, next_output_descriptor_hash);
+                    assert!(jet::eq_32(jet::num_outputs(), 2));
+                    assert!(unwrap(jet::output_is_fee(1)));
+                    match not(jet::eq_256(expected_next_output_hash, zero_hash)) {
+                        true => {
+                            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));
+                        },
+                        false => {
+                            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));
+                        },
+                    }
+                },
+                false => {},
+            }
+        },
+        false => {},
+    }
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    require_policy_hash_anchor();
+    let next_policy_hash: u256 = witness::NEXT_POLICY_HASH;
+    let next_output_descriptor_hash: u256 = witness::NEXT_OUTPUT_DESCRIPTOR_HASH;
+    let expected_next_output_hash: u256 = witness::EXPECTED_NEXT_OUTPUT_HASH;
+    let expected_next_output_script_hash: u256 = witness::EXPECTED_NEXT_OUTPUT_SCRIPT_HASH;
+    maybe_require_recursive_branch(
+        next_policy_hash,
+        next_output_descriptor_hash,
+        expected_next_output_hash,
+        expected_next_output_script_hash
+    );
+    jet::check_lock_distance({{LOCK_DISTANCE}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/recursive-delay-required.simf

@@ -0,0 +1,72 @@
+/*
+ * Recursive delay policy state contract for required propagation.
+ *
+ * The current recipient can spend only after the configured relative delay,
+ * and only into the next constrained output shape supplied at execution time.
+ */
+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_policy_hash_anchor() {
+    let anchored_policy_hash: u256 = 0x{{POLICY_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_policy_hash, zero_hash)));
+}
+
+fn require_required_mode() {
+    assert!(jet::eq_8({{PROPAGATION_MODE_8}}, 1));
+}
+
+fn require_next_transition_witness(next_policy_hash: u256, next_output_descriptor_hash: u256) {
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(next_policy_hash, zero_hash)));
+    assert!(not(jet::eq_256(next_output_descriptor_hash, zero_hash)));
+}
+
+fn require_output_shape(expected_next_output_hash: u256, expected_next_output_script_hash: u256) {
+    assert!(jet::eq_32(jet::num_outputs(), 2));
+    assert!(unwrap(jet::output_is_fee(1)));
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    match not(jet::eq_256(expected_next_output_hash, zero_hash)) {
+        true => {
+            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));
+        },
+        false => {
+            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_state_anchor();
+    require_policy_hash_anchor();
+    require_required_mode();
+    let next_policy_hash: u256 = witness::NEXT_POLICY_HASH;
+    let next_output_descriptor_hash: u256 = witness::NEXT_OUTPUT_DESCRIPTOR_HASH;
+    let expected_next_output_hash: u256 = witness::EXPECTED_NEXT_OUTPUT_HASH;
+    let expected_next_output_script_hash: u256 = witness::EXPECTED_NEXT_OUTPUT_SCRIPT_HASH;
+    require_next_transition_witness(next_policy_hash, next_output_descriptor_hash);
+    require_output_shape(expected_next_output_hash, expected_next_output_script_hash);
+    jet::check_lock_distance({{LOCK_DISTANCE}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}

package/dist/docs/definitions/recursive-delay.simf

@@ -0,0 +1,83 @@
+/*
+ * Recursive delay policy state contract.
+ *
+ * This contract commits the policy template hash, the concrete policy state hash,
+ * and a policy hash that binds recipient + params + propagation mode. The holder
+ * can spend only after the configured relative delay.
+ *
+ * In required propagation mode it also enforces a first hop into the generic
+ * recursive policy router machine, so the current state cannot directly exit to
+ * a plain address.
+ */
+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_policy_hash_anchor() {
+    let anchored_policy_hash: u256 = 0x{{POLICY_HASH}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    assert!(not(jet::eq_256(anchored_policy_hash, zero_hash)));
+}
+
+fn require_router_machine_anchor() {
+    let router_machine_script_hash: u256 = 0x{{ROUTER_MACHINE_SCRIPT_HASH_256}};
+    let zero_hash: u256 = 0x0000000000000000000000000000000000000000000000000000000000000000;
+    match not(jet::eq_8({{PROPAGATION_MODE_8}}, 3)) {
+        true => assert!(not(jet::eq_256(router_machine_script_hash, zero_hash))),
+        false => {},
+    }
+}
+
+fn require_required_machine_hop() {
+    match jet::eq_8({{REQUIRE_MACHINE_HOP_8}}, 1) {
+        true => {
+            assert!(jet::eq_32(jet::num_outputs(), 2));
+            assert!(unwrap(jet::output_is_fee(1)));
+            let router_machine_script_hash: u256 = 0x{{ROUTER_MACHINE_SCRIPT_HASH_256}};
+            let next_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+            assert!(jet::eq_256(router_machine_script_hash, next_output_script_hash));
+        },
+        false => {},
+    }
+}
+
+fn require_optional_machine_hop_if_selected() {
+    match jet::eq_8({{PROPAGATION_MODE_8}}, 2) {
+        true => {
+            let router_machine_script_hash: u256 = 0x{{ROUTER_MACHINE_SCRIPT_HASH_256}};
+            let next_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+            match jet::eq_256(router_machine_script_hash, next_output_script_hash) {
+                true => {
+                    assert!(jet::eq_32(jet::num_outputs(), 2));
+                    assert!(unwrap(jet::output_is_fee(1)));
+                },
+                false => {},
+            }
+        },
+        false => {},
+    }
+}
+
+fn main() {
+    require_definition_anchor();
+    require_state_anchor();
+    require_policy_hash_anchor();
+    require_router_machine_anchor();
+    require_required_machine_hop();
+    require_optional_machine_hop_if_selected();
+    jet::check_lock_distance({{LOCK_DISTANCE}});
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}