feat: Generate default program with first key

The secret keys were randomized in the previous commit. This commit
adapts the default program to be P2PK for the first of these keys.

The signature data is currently not being generated and it will not
match the program. The program will fail to run, unless the user updates
the signatures.

To ensure that there is a first key, this commit makes the key count
NonZeroU32.

Author: uncomputable

src/components/app.rs

@@ -13,12 +13,13 @@ pub struct ActiveRunTab(pub RwSignal<&'static str>);
 pub fn App() -> impl IntoView {
     let url_params = use_query_map().get_untracked();
 
-    let program = Program::default();
+    let signing_keys = SigningKeys::from_map(&url_params).unwrap_or_default();
+    provide_context(signing_keys);
+    let program = Program::new(signing_keys.first_public_key());
     provide_context(program);
     let tx_params = TxParams::from_map(&url_params).unwrap_or_default();
     let tx_env = TxEnv::new(program, tx_params);
     provide_context(tx_env);
-    provide_context(SigningKeys::from_map(&url_params).unwrap_or_default());
     provide_context(SignedData::new(tx_env.lazy_env));
     provide_context(HashedData::from_map(&url_params).unwrap_or_default());
     provide_context(Runtime::new(program, tx_env.lazy_env));

src/components/program_window/program_tab.rs

@@ -1,16 +1,20 @@
-use crate::components::copy_to_clipboard::CopyToClipboard;
-use crate::function::Runner;
+use std::sync::Arc;
+
+use hex_conservative::DisplayHex;
 use itertools::Itertools;
 use leptos::{
     component, create_node_ref, create_rw_signal, ev, event_target_value, html, spawn_local,
     use_context, view, with, IntoView, NodeRef, RwSignal, Signal, SignalGetUntracked, SignalSet,
     SignalUpdate, SignalWith,
 };
+use simfony::elements::secp256k1_zkp as secp256k1;
 use simfony::parse::ParseFromStr;
 use simfony::simplicity::jet::elements::ElementsEnv;
 use simfony::{elements, simplicity};
 use simfony::{CompiledProgram, SatisfiedProgram, WitnessValues};
-use std::sync::Arc;
+
+use crate::components::copy_to_clipboard::CopyToClipboard;
+use crate::function::Runner;
 
 #[derive(Copy, Clone, Debug)]
 pub struct Program {
@@ -21,9 +25,22 @@ pub struct Program {
 }
 
 impl Program {
-    pub fn new(program_text: String) -> Self {
+    pub fn new(key: secp256k1::XOnlyPublicKey) -> Self {
+        let text = format!(
+            r#"mod witness {{
+    const SIG: Signature = 0x1d7d93f350e2db564f90da49fb00ee47294bb6d8f061929818b26065a3e50fdd87e0e8ab45eecd04df0b92b427e6d49a5c96810c23706566e9093c992e075dc5; // TODO: update this
+}}
+
+fn main() {{
+    let pk: Pubkey = 0x{};
+    let msg: u256 = jet::sig_all_hash();
+    jet::bip_0340_verify((pk, msg), witness::SIG)
+}}"#,
+            key.serialize().as_hex()
+        );
+
         Self {
-            text: create_rw_signal(program_text),
+            text: create_rw_signal(text),
             cached_text: create_rw_signal("".to_string()),
             lazy_cmr: create_rw_signal(Err("".to_string())),
             lazy_satisfied: create_rw_signal(Err("".to_string())),
@@ -60,15 +77,6 @@ impl Program {
     }
 }
 
-impl Default for Program {
-    fn default() -> Self {
-        let text = crate::examples::get("✍️️ P2PK")
-            .expect("P2PK example should exist")
-            .program_text();
-        Self::new(text.to_string())
-    }
-}
-
 #[derive(Copy, Clone)]
 pub struct Runtime {
     program: Program,

src/components/run_window/key_store_tab.rs

@@ -1,3 +1,4 @@
+use std::num::NonZeroU32;
 use std::sync::Arc;
 
 use elements::hashes::{sha256, Hash};
@@ -16,23 +17,23 @@ use crate::components::copy_to_clipboard::CopyToClipboard;
 #[derive(Copy, Clone, Debug)]
 pub struct SigningKeys {
     pub key_offset: RwSignal<u32>,
-    pub key_count: RwSignal<u32>,
-    secret_keys: Memo<Vec<secp256k1_zkp::Keypair>>,
-    public_keys: Memo<Vec<secp256k1_zkp::XOnlyPublicKey>>,
+    pub key_count: RwSignal<NonZeroU32>,
+    pub secret_keys: Memo<Vec<secp256k1_zkp::Keypair>>,
+    pub public_keys: Memo<Vec<secp256k1_zkp::XOnlyPublicKey>>,
 }
 
 impl Default for SigningKeys {
     fn default() -> Self {
-        Self::new(rand::random(), 1)
+        Self::new(rand::random(), NonZeroU32::MIN)
     }
 }
 
 impl SigningKeys {
-    pub fn new(key_offset: u32, key_count: u32) -> Self {
+    pub fn new(key_offset: u32, key_count: NonZeroU32) -> Self {
         let key_offset = create_rw_signal(key_offset);
         let key_count = create_rw_signal(key_count);
         let secret_keys = create_memo(move |_| {
-            (0..key_count.get())
+            (0..key_count.get().get())
                 .map(|index| new_key(key_offset.get(), index))
                 .collect::<Vec<secp256k1_zkp::Keypair>>()
         });
@@ -52,14 +53,18 @@ impl SigningKeys {
         }
     }
 
+    pub fn first_public_key(&self) -> secp256k1_zkp::XOnlyPublicKey {
+        self.public_keys.get_untracked()[0]
+    }
+
     pub fn push_key(&self) {
-        self.key_count.update(|n| *n += 1);
+        self.key_count.update(|n| *n = n.saturating_add(1));
     }
 
     pub fn pop_key(&self) {
-        let n = self.key_count.get();
-        if 1 < n {
-            self.key_count.set(n - 1);
+        let n = self.key_count.get().get();
+        if let Some(n_minus_one) = NonZeroU32::new(n - 1) {
+            self.key_count.set(n_minus_one);
         }
     }
 

src/components/state.rs

@@ -1,3 +1,5 @@
+use std::num::NonZeroU32;
+
 use leptos::{use_context, SignalGetUntracked};
 use leptos_router::ParamsMap;
 
@@ -19,7 +21,7 @@ pub trait ToParams {
 impl FromParams for SigningKeys {
     fn from_map(map: &ParamsMap) -> Option<Self> {
         let key_offset = map.get("seed").and_then(|s| s.parse::<u32>().ok())?;
-        let key_count = map.get("keys").and_then(|s| s.parse::<u32>().ok())?;
+        let key_count = map.get("keys").and_then(|s| s.parse::<NonZeroU32>().ok())?;
         Some(Self::new(key_offset, key_count))
     }
 }