@hazbase/simplicity 0.0.5 → 0.1.1

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

package/dist/docs/definitions/recursive-policy-transfer-machine.simf

@@ -0,0 +1,65 @@
+/*
+ * Recursive policy transfer machine.
+ *
+ * This machine is generic for a given current policy state. The next policy hash
+ * and output descriptor commitments are supplied at execution time through witness
+ * values, while the current state still commits the router machine as the only
+ * allowed first hop in required propagation mode.
+ */
+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 require_output_shape(expected_next_output_hash: u256, expected_next_output_script_hash: u256, binding_mode: u8) {
+    assert!(jet::eq_32(jet::num_outputs(), 2));
+    assert!(unwrap(jet::output_is_fee(1)));
+    let actual_next_output_hash: u256 = match jet::output_hash(0) {
+        Some(output_hash : u256) => output_hash,
+        None => panic!(),
+    };
+    let actual_next_output_script_hash: u256 = unwrap(jet::output_script_hash(0));
+
+    match jet::eq_8(binding_mode, 0x01) {
+        true => assert!(jet::eq_256(actual_next_output_hash, expected_next_output_hash)),
+        false => 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();
+    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;
+    let binding_mode: u8 = witness::OUTPUT_BINDING_MODE;
+    require_next_transition_witness(next_policy_hash, next_output_descriptor_hash);
+    require_output_shape(expected_next_output_hash, expected_next_output_script_hash, binding_mode);
+    let signer: Pubkey = 0x{{SIGNER_XONLY}};
+    jet::bip_0340_verify((signer, jet::sig_all_hash()), witness::SIGNER_SIGNATURE)
+}