change Simfony references to SimplicityHL

Author: imaginator

Cargo.lock

@@ -1,16 +1,16 @@
 [package]
-name = "simfony"
+name = "simplicityhl"
 version = "0.1.0"
 authors = ["sanket1729 <sanket1729@gmail.com>"]
 license = "CC0-1.0"
-homepage = "https://github.com/BlockstreamResearch/simfony/"
-repository = "https://github.com/BlockstreamResearch/simfony/"
+homepage = "https://github.com/BlockstreamResearch/SimplicityHL"
+repository = "https://github.com/BlockstreamResearch/SimplicityHL"
 description = "Rust-like language that compiles to Simplicity bytecode."
 edition = "2021"
 rust-version = "1.78.0"
 
 [lib]
-name = "simfony"
+name = "simplicityhl"
 path = "src/lib.rs"
 
 [[bin]]

Cargo.toml

@@ -5,7 +5,7 @@ authors = ["sanket1729 <sanket1729@gmail.com>"]
 edition = "2021"
 
 [dependencies]
-simfony = { path = ".." }
+simplicityhl = { path = ".." }
 elementsd = { version = "0.11.0" }
 actual-rand = { package = "rand", version = "0.8.4" }
 secp256k1 = { version = "0.29.0", features = ["rand-std"] }

bitcoind-tests/Cargo.lock

@@ -5,7 +5,7 @@ use elements::hex::FromHex;
 use elementsd::bitcoincore_rpc::jsonrpc::serde_json::{json, Value};
 use elementsd::bitcoind::bitcoincore_rpc::RpcApi;
 use elementsd::ElementsD;
-use simfony::elements;
+use simplicityhl::elements;
 
 // We are not using pegins right now, but it might be required in case in future
 // if we extend the tests to check pegins etc.

bitcoind-tests/Cargo.toml

@@ -5,18 +5,18 @@ use elements::pset::PartiallySignedTransaction as Psbt;
 use elements::{confidential, secp256k1_zkp as secp256k1};
 use elementsd::ElementsD;
 use secp256k1::XOnlyPublicKey;
-use simfony::{elements, simplicity};
 use simplicity::jet::elements::{ElementsEnv, ElementsUtxo};
+use simplicityhl::{elements, simplicity};
 
 use crate::common::daemon::Call;
 
-type FnWitness = fn([u8; 32]) -> simfony::WitnessValues;
+type FnWitness = fn([u8; 32]) -> simplicityhl::WitnessValues;
 
 #[derive(Clone)]
 pub struct TestCase<'a> {
     pub name: &'static str,
-    template: Option<simfony::TemplateProgram>,
-    compiled: Option<simfony::CompiledProgram>,
+    template: Option<simplicityhl::TemplateProgram>,
+    compiled: Option<simplicityhl::CompiledProgram>,
     witness: FnWitness,
     lock_time: elements::LockTime,
     sequence: elements::Sequence,
@@ -53,7 +53,7 @@ impl<'a> TestCase<'a> {
 
     pub fn program_path<P: AsRef<std::path::Path>>(mut self, path: P) -> Self {
         let text = std::fs::read_to_string(path).expect("path should be readable");
-        let compiled = simfony::CompiledProgram::new(text.as_str(), simfony::Arguments::default(), false)
+        let compiled = simplicityhl::CompiledProgram::new(text.as_str(), simplicityhl::Arguments::default(), false)
             .expect("program should compile");
         self.compiled = Some(compiled);
         self
@@ -62,12 +62,12 @@ impl<'a> TestCase<'a> {
     pub fn template_path<P: AsRef<std::path::Path>>(mut self, path: P) -> Self {
         let text = std::fs::read_to_string(path).expect("path should be readable");
         let template =
-            simfony::TemplateProgram::new(text.as_str()).expect("program should compile");
+            simplicityhl::TemplateProgram::new(text.as_str()).expect("program should compile");
         self.template = Some(template);
         self
     }
 
-    pub fn arguments(mut self, arguments: simfony::Arguments) -> Self {
+    pub fn arguments(mut self, arguments: simplicityhl::Arguments) -> Self {
         let compiled = self
             .template
             .as_ref()
@@ -220,6 +220,6 @@ impl<'a> TestCase<'a> {
     }
 }
 
-fn empty_witness(_sighash_all: [u8; 32]) -> simfony::WitnessValues {
-    simfony::WitnessValues::default()
+fn empty_witness(_sighash_all: [u8; 32]) -> simplicityhl::WitnessValues {
+    simplicityhl::WitnessValues::default()
 }

bitcoind-tests/tests/common/daemon.rs

@@ -11,8 +11,8 @@ pub fn sign_schnorr(secret_key: u32, message: [u8; 32]) -> [u8; 64] {
     key_pair.sign_schnorr(message).serialize()
 }
 
-pub fn xonly_public_key(secret_key: u32) -> simfony::num::U256 {
+pub fn xonly_public_key(secret_key: u32) -> simplicityhl::num::U256 {
     let key_pair = key_pair(secret_key);
     let bytes = key_pair.x_only_public_key().0.serialize();
-    simfony::num::U256::from_byte_array(bytes)
+    simplicityhl::num::U256::from_byte_array(bytes)
 }

bitcoind-tests/tests/common/test.rs

@@ -3,10 +3,10 @@ use std::collections::HashMap;
 use elements::hashes::Hash;
 use elements::secp256k1_zkp as secp256k1;
 use secp256k1::hashes::{sha256, HashEngine};
-use simfony::str::WitnessName;
-use simfony::types::TypeConstructible;
-use simfony::value::ValueConstructible;
-use simfony::{elements, ResolvedType, Value};
+use simplicityhl::str::WitnessName;
+use simplicityhl::types::TypeConstructible;
+use simplicityhl::value::ValueConstructible;
+use simplicityhl::{elements, ResolvedType, Value};
 
 mod common;
 use common::daemon::{self, Call};
@@ -49,7 +49,7 @@ fn spend_utxo() {
     }
 }
 
-fn hodl_vault(sighash_all: [u8; 32]) -> simfony::WitnessValues {
+fn hodl_vault(sighash_all: [u8; 32]) -> simplicityhl::WitnessValues {
     let mut witness_values = HashMap::new();
     let oracle_height = 1000;
     witness_values.insert(
@@ -73,24 +73,24 @@ fn hodl_vault(sighash_all: [u8; 32]) -> simfony::WitnessValues {
         WitnessName::from_str_unchecked("OWNER_SIG"),
         Value::byte_array(util::sign_schnorr(2, sighash_all)),
     );
-    simfony::WitnessValues::from(witness_values)
+    simplicityhl::WitnessValues::from(witness_values)
 }
 
-fn p2pk_args() -> simfony::Arguments {
-    simfony::Arguments::from(HashMap::from([(
+fn p2pk_args() -> simplicityhl::Arguments {
+    simplicityhl::Arguments::from(HashMap::from([(
         WitnessName::from_str_unchecked("ALICE_PUBLIC_KEY"),
         Value::u256(util::xonly_public_key(1)),
     )]))
 }
 
-fn p2pk(sighash_all: [u8; 32]) -> simfony::WitnessValues {
-    simfony::WitnessValues::from(HashMap::from([(
+fn p2pk(sighash_all: [u8; 32]) -> simplicityhl::WitnessValues {
+    simplicityhl::WitnessValues::from(HashMap::from([(
         WitnessName::from_str_unchecked("ALICE_SIGNATURE"),
         Value::byte_array(util::sign_schnorr(1, sighash_all)),
     )]))
 }
 
-fn p2pkh(sighash_all: [u8; 32]) -> simfony::WitnessValues {
+fn p2pkh(sighash_all: [u8; 32]) -> simplicityhl::WitnessValues {
     let mut witness_values = HashMap::new();
     witness_values.insert(
         WitnessName::from_str_unchecked("PK"),
@@ -100,16 +100,16 @@ fn p2pkh(sighash_all: [u8; 32]) -> simfony::WitnessValues {
         WitnessName::from_str_unchecked("SIG"),
         Value::byte_array(util::sign_schnorr(1, sighash_all)),
     );
-    simfony::WitnessValues::from(witness_values)
+    simplicityhl::WitnessValues::from(witness_values)
 }
 
-fn p2ms(sighash_all: [u8; 32]) -> simfony::WitnessValues {
+fn p2ms(sighash_all: [u8; 32]) -> simplicityhl::WitnessValues {
     let mut witness_values = HashMap::new();
     let sig1 = Value::some(Value::byte_array(util::sign_schnorr(1, sighash_all)));
     let sig2 = Value::none(ResolvedType::byte_array(64));
     let sig3 = Value::some(Value::byte_array(util::sign_schnorr(3, sighash_all)));
     let ty = sig1.ty().clone();
     let maybe_sigs = Value::array([sig1, sig2, sig3], ty);
     witness_values.insert(WitnessName::from_str_unchecked("MAYBE_SIGS"), maybe_sigs);
-    simfony::WitnessValues::from(witness_values)
+    simplicityhl::WitnessValues::from(witness_values)
 }

bitcoind-tests/tests/common/util.rs

@@ -3,4 +3,4 @@ authors = ["Christian Lewe"]
 language = "en"
 multilingual = false
 src = "src"
-title = "The Simfony Programming Language"
+title = "The SimplicityHL Programming Language"

bitcoind-tests/tests/spend_utxo.rs

@@ -31,12 +31,12 @@ let z: u32 = add(40, 2);
 
 ## No early returns
 
-Simfony has no support for an early return via a "return" keyword.
+SimplicityHL has no support for an early return via a "return" keyword.
 The only branching that is available is via [match expressions](./match_expression.md).
 
 ## No recursion
 
-Simfony has no support for recursive function calls.
+SimplicityHL has no support for recursive function calls.
 A function can be called inside a function body if it has been defined before.
 This means that a function cannot call itself.
 Loops, where `f` calls `g` and `g` calls `f`, are also impossible.
@@ -75,7 +75,7 @@ fn g() -> u32 {
 
 ## Main function
 
-The `main` function is the entry point of each Simfony program.
+The `main` function is the entry point of each SimplicityHL program.
 Running a program means running its `main` function.
 Other functions are called from the `main` function.
 
@@ -86,7 +86,7 @@ fn main() {
 ```
 
 The `main` function is a reserved name and must exist in every program.
-Simfony programs are always "binaries".
+SimplicityHL programs are always "binaries".
 There is no support for "libraries".
 
 ## Jets