Feat/sdk

crates/sdk/Cargo.toml

@@ -15,4 +15,4 @@ simplex-runtime = { workspace = true }
 thiserror = { workspace = true }
 sha2 = { workspace = true }
 minreq = { workspace = true }
-simplicityhl = { workspace = true }
+simplicityhl = { workspace = true }

crates/sdk/src/constants.rs

@@ -4,12 +4,15 @@ use simplicityhl::simplicity::hashes::{Hash, sha256};
 use std::str::FromStr;
 
 pub const PUBLIC_SECRET_BLINDER_KEY: [u8; 32] = [1; 32];
+pub const DUMMY_SIGNATURE: [u8; 64] = [1; 64];
 
 pub const DEFAULT_TARGET_BLOCKS: u32 = 0;
 pub const DEFAULT_FEE_RATE: f32 = 100.0;
-pub const WITNESS_SCALE_FACTOR: usize = 4;
+pub const MIN_FEE: u64 = 10;
 pub const PLACEHOLDER_FEE: u64 = 1;
 
+pub const WITNESS_SCALE_FACTOR: usize = 4;
+
 /// Policy asset id (hex, BE) for Liquid mainnet.
 pub const LIQUID_POLICY_ASSET_STR: &str = "6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d";
 

crates/sdk/src/error.rs

@@ -2,6 +2,15 @@ use simplicityhl::elements::secp256k1_zkp;
 
 #[derive(Debug, thiserror::Error)]
 pub enum SimplexError {
+    #[error("Fee amount is too low: {0}")]
+    PstFailure(#[from] simplicityhl::elements::pset::Error),
+
+    #[error("Fee amount is too low: {0}")]
+    DustAmount(u64),
+
+    #[error("Not enough fee amount {0} to cover transaction costs: {1}")]
+    NotEnoughFeeAmount(u64, u64),
+
     #[error("Failed to compile Simplicity program: {0}")]
     Compilation(String),
 

crates/sdk/src/lib.rs

@@ -1,9 +1,10 @@
-pub mod arguments;
-pub mod constants;
-pub mod error;
+pub mod witness_transaction;
 pub mod program;
-pub mod provider;
-pub mod signed_transaction;
+pub mod arguments;
+pub mod witness;
 pub mod signer;
+pub mod provider;
 pub mod utils;
-pub mod witness;
+pub mod constants;
+pub mod error;
+pub mod presets;

crates/sdk/src/presets/mod.rs

@@ -0,0 +1 @@
+pub mod p2pk;

crates/sdk/src/presets/p2pk.rs

@@ -0,0 +1,130 @@
+use crate::arguments::ArgumentsTrait;
+use crate::program::Program;
+
+use simplicityhl::simplicity::bitcoin::XOnlyPublicKey;
+
+// TODO macro
+pub struct P2PK<'a> {
+    program: Program<'a>,
+}
+
+impl<'a> P2PK<'a> {
+    pub const SOURCE: &'static str = include_str!("./simf/p2pk.simf");
+
+    pub fn new(public_key: &'a XOnlyPublicKey, arguments: &'a impl ArgumentsTrait) -> Self {
+        Self {
+            program: Program::new(Self::SOURCE, public_key, arguments),
+        }
+    }
+
+    pub fn get_program(&self) -> &Program<'a> {
+        &self.program
+    }
+
+    pub fn get_program_mut(&mut self) -> &mut Program<'a> {
+        &mut self.program
+    }
+}
+
+pub mod p2pk_build {
+    use crate::arguments::ArgumentsTrait;
+    use crate::witness::WitnessTrait;
+    use simplicityhl::num::U256;
+    use simplicityhl::str::WitnessName;
+    use simplicityhl::types::TypeConstructible;
+    use simplicityhl::value::UIntValue;
+    use simplicityhl::value::ValueConstructible;
+    use simplicityhl::{Arguments, ResolvedType, Value, WitnessValues};
+    use std::collections::HashMap;
+
+    pub struct P2PKWitness {
+        pub signature: [u8; 64usize],
+    }
+
+    pub struct P2PKArguments {
+        pub public_key: [u8; 32],
+    }
+
+    impl WitnessTrait for P2PKWitness {
+        fn build_witness(&self) -> WitnessValues {
+            WitnessValues::from(HashMap::from([(WitnessName::from_str_unchecked("SIGNATURE"), {
+                let elements = [
+                    Value::from(UIntValue::U8(self.signature[0])),
+                    Value::from(UIntValue::U8(self.signature[1])),
+                    Value::from(UIntValue::U8(self.signature[2])),
+                    Value::from(UIntValue::U8(self.signature[3])),
+                    Value::from(UIntValue::U8(self.signature[4])),
+                    Value::from(UIntValue::U8(self.signature[5])),
+                    Value::from(UIntValue::U8(self.signature[6])),
+                    Value::from(UIntValue::U8(self.signature[7])),
+                    Value::from(UIntValue::U8(self.signature[8])),
+                    Value::from(UIntValue::U8(self.signature[9])),
+                    Value::from(UIntValue::U8(self.signature[10])),
+                    Value::from(UIntValue::U8(self.signature[11])),
+                    Value::from(UIntValue::U8(self.signature[12])),
+                    Value::from(UIntValue::U8(self.signature[13])),
+                    Value::from(UIntValue::U8(self.signature[14])),
+                    Value::from(UIntValue::U8(self.signature[15])),
+                    Value::from(UIntValue::U8(self.signature[16])),
+                    Value::from(UIntValue::U8(self.signature[17])),
+                    Value::from(UIntValue::U8(self.signature[18])),
+                    Value::from(UIntValue::U8(self.signature[19])),
+                    Value::from(UIntValue::U8(self.signature[20])),
+                    Value::from(UIntValue::U8(self.signature[21])),
+                    Value::from(UIntValue::U8(self.signature[22])),
+                    Value::from(UIntValue::U8(self.signature[23])),
+                    Value::from(UIntValue::U8(self.signature[24])),
+                    Value::from(UIntValue::U8(self.signature[25])),
+                    Value::from(UIntValue::U8(self.signature[26])),
+                    Value::from(UIntValue::U8(self.signature[27])),
+                    Value::from(UIntValue::U8(self.signature[28])),
+                    Value::from(UIntValue::U8(self.signature[29])),
+                    Value::from(UIntValue::U8(self.signature[30])),
+                    Value::from(UIntValue::U8(self.signature[31])),
+                    Value::from(UIntValue::U8(self.signature[32])),
+                    Value::from(UIntValue::U8(self.signature[33])),
+                    Value::from(UIntValue::U8(self.signature[34])),
+                    Value::from(UIntValue::U8(self.signature[35])),
+                    Value::from(UIntValue::U8(self.signature[36])),
+                    Value::from(UIntValue::U8(self.signature[37])),
+                    Value::from(UIntValue::U8(self.signature[38])),
+                    Value::from(UIntValue::U8(self.signature[39])),
+                    Value::from(UIntValue::U8(self.signature[40])),
+                    Value::from(UIntValue::U8(self.signature[41])),
+                    Value::from(UIntValue::U8(self.signature[42])),
+                    Value::from(UIntValue::U8(self.signature[43])),
+                    Value::from(UIntValue::U8(self.signature[44])),
+                    Value::from(UIntValue::U8(self.signature[45])),
+                    Value::from(UIntValue::U8(self.signature[46])),
+                    Value::from(UIntValue::U8(self.signature[47])),
+                    Value::from(UIntValue::U8(self.signature[48])),
+                    Value::from(UIntValue::U8(self.signature[49])),
+                    Value::from(UIntValue::U8(self.signature[50])),
+                    Value::from(UIntValue::U8(self.signature[51])),
+                    Value::from(UIntValue::U8(self.signature[52])),
+                    Value::from(UIntValue::U8(self.signature[53])),
+                    Value::from(UIntValue::U8(self.signature[54])),
+                    Value::from(UIntValue::U8(self.signature[55])),
+                    Value::from(UIntValue::U8(self.signature[56])),
+                    Value::from(UIntValue::U8(self.signature[57])),
+                    Value::from(UIntValue::U8(self.signature[58])),
+                    Value::from(UIntValue::U8(self.signature[59])),
+                    Value::from(UIntValue::U8(self.signature[60])),
+                    Value::from(UIntValue::U8(self.signature[61])),
+                    Value::from(UIntValue::U8(self.signature[62])),
+                    Value::from(UIntValue::U8(self.signature[63])),
+                ];
+                Value::array(elements, ResolvedType::u8())
+            })]))
+        }
+    }
+
+    impl ArgumentsTrait for P2PKArguments {
+        fn build_arguments(&self) -> Arguments {
+            Arguments::from(HashMap::from([(
+                WitnessName::from_str_unchecked("PUBLIC_KEY"),
+                Value::from(UIntValue::U256(U256::from_byte_array(self.public_key))),
+            )]))
+        }
+    }
+}

crates/sdk/src/presets/simf/p2pk.simf

@@ -0,0 +1,3 @@
+fn main() {
+    jet::bip_0340_verify((param::PUBLIC_KEY, jet::sig_all_hash()), witness::SIGNATURE)
+}

crates/sdk/src/signer.rs

@@ -31,6 +31,7 @@ impl SignerTrait for Signer {
         self.keypair.x_only_public_key().0
     }
 
+    // TODO EIP-191 or EIP-712 messages
     fn personal_sign(&self, message: Message) -> Result<Signature, SimplexError> {
         Ok(self.keypair.sign_schnorr(message))
     }

crates/sdk/src/utils.rs

@@ -1,9 +1,10 @@
 use simplicityhl::simplicity::bitcoin::secp256k1;
 
 pub fn tr_unspendable_key() -> secp256k1::XOnlyPublicKey {
     secp256k1::XOnlyPublicKey::from_slice(&[
-        0x50, 0x92, 0x9b, 0x74, 0xc1, 0xa0, 0x49, 0x54, 0xb7, 0x8b, 0x4b, 0x60, 0x35, 0xe9, 0x7a, 0x5e, 0x07, 0x8a,
-        0x5a, 0x0f, 0x28, 0xec, 0x96, 0xd5, 0x47, 0xbf, 0xee, 0x9a, 0xce, 0x80, 0x3a, 0xc0,
+        0x50, 0x92, 0x9b, 0x74, 0xc1, 0xa0, 0x49, 0x54, 0xb7, 0x8b, 0x4b, 0x60, 0x35, 0xe9, 0x7a,
+        0x5e, 0x07, 0x8a, 0x5a, 0x0f, 0x28, 0xec, 0x96, 0xd5, 0x47, 0xbf, 0xee, 0x9a, 0xce, 0x80,
+        0x3a, 0xc0,
     ])
     .expect("key should be valid")
 }