refactor: turn witnet_stack crate into module inside witnet_data_structures

Author: tmpolaczyk

Cargo.lock

@@ -11,7 +11,7 @@ description = "An in-progress open source implementation of the Witnet protocol
 edition = "2021"
 
 [workspace]
-members = ["config", "node", "crypto", "data_structures", "p2p", "storage", "wallet", "validations", "protected", "reputation", "net", "toolkit", "stack", "bridges/ethereum", "bridges/centralized-ethereum", "futures_utils"]
+members = ["config", "node", "crypto", "data_structures", "p2p", "storage", "wallet", "validations", "protected", "reputation", "net", "toolkit", "bridges/ethereum", "bridges/centralized-ethereum", "futures_utils"]
 
 [features]
 default = ["wallet", "node", "telemetry"]
@@ -47,7 +47,6 @@ witnet_crypto = { path = "./crypto" }
 witnet_data_structures = { path = "./data_structures" }
 witnet_node = { path = "./node", optional = true }
 witnet_rad = { path = "./rad" }
-witnet_stack = { path = "./stack" }
 witnet_util = { path = "./util" }
 witnet_validations = { path = "./validations" }
 witnet_wallet = { path = "./wallet", optional = true }

Cargo.toml

@@ -29,6 +29,7 @@ serde = { version = "1.0.104", features = ["derive"] }
 serde_cbor = "0.11.1"
 serde_json = "1.0.48"
 vrf = "0.2.3"
+scriptful = { version = "0.4", features = ["use_serde"] }
 
 witnet_crypto = { path = "../crypto" }
 witnet_reputation = { path = "../reputation", features = ["serde"] }

data_structures/Cargo.toml

@@ -59,6 +59,9 @@ pub mod radon_error;
 /// Module containing RadonReport structures
 pub mod radon_report;
 
+/// Module containing scripting logic
+pub mod stack;
+
 /// Serialization boilerplate to allow serializing some data structures as
 /// strings or bytes depending on the serializer.
 mod serialization_helpers;

data_structures/src/lib.rs

@@ -1,9 +1,9 @@
 use scriptful::{core::machine::Machine, core::Script, core::ScriptRef};
 
-pub use crate::error::ScriptError;
-pub use crate::operators::{MyOperator, MyValue};
+pub use self::error::ScriptError;
+pub use self::operators::{MyOperator, MyValue};
+use crate::chain::Hash;
 pub use scriptful::core::item::Item;
-use witnet_data_structures::chain::Hash;
 
 mod error;
 mod operators;

stack/src/error.rs renamed to data_structures/src/stack/error.rs

@@ -1,9 +1,9 @@
-use crate::{ScriptContext, ScriptError};
+use super::{ScriptContext, ScriptError};
+use crate::chain::{Hash, PublicKey, Secp256k1Signature, Signature};
+use crate::chain::{KeyedSignature, PublicKeyHash};
 use scriptful::prelude::{ConditionStack, Stack};
 use serde::{Deserialize, Serialize};
 use witnet_crypto::hash::{calculate_sha256, Sha256};
-use witnet_data_structures::chain::{Hash, PublicKey, Secp256k1Signature, Signature};
-use witnet_data_structures::chain::{KeyedSignature, PublicKeyHash};
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 // TODO: Include more operators

stack/src/lib.rs renamed to data_structures/src/stack/mod.rs

@@ -1,4 +1,4 @@
-use crate::{MyOperator, MyValue};
+use super::{MyOperator, MyValue};
 use scriptful::prelude::Item;
 use std::str::FromStr;
 
@@ -143,7 +143,7 @@ pub fn parse_operator(s: &str) -> Option<MyOperator> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use witnet_data_structures::chain::PublicKey;
+    use crate::chain::PublicKey;
 
     #[test]
     fn script_to_string_multisig() {

stack/src/operators.rs renamed to data_structures/src/stack/operators.rs

@@ -1,9 +1,9 @@
-use crate::{
+use super::{
     encode, execute_complete_script, execute_locking_script, execute_redeem_script, execute_script,
     Item, MyOperator, MyValue, ScriptContext, ScriptError,
 };
+use crate::chain::KeyedSignature;
 use witnet_crypto::hash::calculate_sha256;
-use witnet_data_structures::chain::KeyedSignature;
 
 const EQUAL_OPERATOR_HASH: [u8; 20] = [
     52, 128, 191, 80, 253, 28, 169, 253, 237, 29, 0, 51, 201, 0, 31, 203, 157, 99, 218, 210,
@@ -142,7 +142,7 @@ fn test_ks_id(id: u8) -> KeyedSignature {
     let secret_key =
         witnet_crypto::secp256k1::SecretKey::from_slice(&mk).expect("32 bytes, within curve order");
     let public_key = witnet_crypto::secp256k1::PublicKey::from_secret_key_global(&secret_key);
-    let public_key = witnet_data_structures::chain::PublicKey::from(public_key);
+    let public_key = crate::chain::PublicKey::from(public_key);
     // TODO: mock this signature, it is not even validated in tests but we need a valid signature to
     // test signature deserialization
     let signature = witnet_crypto::signature::sign(secret_key, &[0x01; 32]).unwrap();

stack/src/parser.rs renamed to data_structures/src/stack/parser.rs

@@ -36,7 +36,6 @@ witnet_futures_utils = { path = "../futures_utils" }
 witnet_p2p = { path = "../p2p" }
 witnet_protected = { path = "../protected", features = ["with-serde"]  }
 witnet_rad = { path = "../rad" }
-witnet_stack = { path = "../stack" }
 witnet_storage = { path = "../storage", features = ["rocksdb-backend"] }
 witnet_util = { path = "../util" }
 witnet_validations = { path = "../validations" }

stack/src/tests.rs renamed to data_structures/src/stack/tests.rs

@@ -1306,7 +1306,7 @@ impl Handler<BuildScriptTransaction> for ChainManager {
                 // Script transactions are not signed by this method because the witness may need
                 // something more aside from a single signature, so script transactions need to be
                 // manually signed using other methods.
-                let empty_witness = witnet_stack::encode(&[]).unwrap();
+                let empty_witness = witnet_data_structures::stack::encode(&[]).unwrap();
                 let num_inputs = vtt.inputs.len();
                 let transaction = Transaction::ValueTransfer(VTTransaction {
                     body: vtt,

node/Cargo.toml

@@ -20,6 +20,7 @@ use witnet_crypto::{
     hash::calculate_sha256,
     key::{ExtendedPK, ExtendedSK},
 };
+use witnet_data_structures::stack::{Item, MyOperator, MyValue};
 use witnet_data_structures::{
     chain::{
         Block, ConsensusConstants, DataRequestInfo, DataRequestOutput, Environment, Epoch, Hash,
@@ -40,7 +41,6 @@ use witnet_node::actors::{
     messages::{BuildScriptTransaction, BuildVtt, GetReputationResult, SignalingInfo},
 };
 use witnet_rad::types::RadonTypes;
-use witnet_stack::{Item, MyOperator, MyValue};
 use witnet_util::{credentials::create_credentials_file, timestamp::pretty_print};
 use witnet_validations::validations::{
     run_tally_panic_safe, validate_data_request_output, validate_rad_request, Wit,
@@ -735,7 +735,8 @@ pub fn create_multisig_address(
         Item::Operator(MyOperator::CheckMultiSig),
     ]);
 
-    let script_address = PublicKeyHash::from_script_bytes(&witnet_stack::encode(&redeem_script)?);
+    let script_address =
+        PublicKeyHash::from_script_bytes(&witnet_data_structures::stack::encode(&redeem_script)?);
 
     println!(
         "Created {}-of-{} multisig address {} composed of {:?}",
@@ -776,7 +777,7 @@ pub fn create_opened_multisig(
         Item::Value(MyValue::Integer(i128::from(n))),
         Item::Operator(MyOperator::CheckMultiSig),
     ]);
-    let redeem_script_bytes = witnet_stack::encode(&redeem_script)?;
+    let redeem_script_bytes = witnet_data_structures::stack::encode(&redeem_script)?;
     let vt_outputs = vec![ValueTransferOutput {
         pkh: address,
         value,
@@ -907,11 +908,11 @@ pub fn sign_tx(
                 // TODO: this only works if the witness field represents a script
                 // It could also represent a signature in the case of normal value transfer
                 // transactions. It would be nice to also support signing normal transactions here
-                let mut script = witnet_stack::decode(&vtt.witness[input_index])?;
+                let mut script = witnet_data_structures::stack::decode(&vtt.witness[input_index])?;
 
                 println!(
                     "-----------------------\nPrevious witness:\n-----------------------\n{}",
-                    witnet_stack::parser::script_to_string(&script)
+                    witnet_data_structures::stack::parser::script_to_string(&script)
                 );
 
                 script.insert(
@@ -921,9 +922,9 @@ pub fn sign_tx(
 
                 println!(
                     "-----------------------\nNew witness:\n-----------------------\n{}",
-                    witnet_stack::parser::script_to_string(&script)
+                    witnet_data_structures::stack::parser::script_to_string(&script)
                 );
-                let encoded_script = witnet_stack::encode(&script)?;
+                let encoded_script = witnet_data_structures::stack::encode(&script)?;
 
                 vtt.witness[input_index] = encoded_script;
 
@@ -988,9 +989,9 @@ pub fn address_to_bytes(address: PublicKeyHash) -> Result<(), failure::Error> {
 /// Convert script text file into hex bytes
 pub fn encode_script(script_file: &Path) -> Result<(), failure::Error> {
     let script_str = std::fs::read_to_string(script_file)?;
-    let script = witnet_stack::parser::parse_script(&script_str)
+    let script = witnet_data_structures::stack::parser::parse_script(&script_str)
         .map_err(|e| format_err!("Failed to parse script: {:?}", e))?;
-    let script_bytes = witnet_stack::encode(&script)?;
+    let script_bytes = witnet_data_structures::stack::encode(&script)?;
     let script_hex = hex::encode(&script_bytes);
     let script_pkh = PublicKeyHash::from_script_bytes(&script_bytes);
     println!("Script address: {}", script_pkh);
@@ -1006,9 +1007,9 @@ pub fn decode_script(hex: String, script_file: Option<&Path>) -> Result<(), fail
     let script_pkh = PublicKeyHash::from_script_bytes(&script_bytes);
     println!("Script address: {}", script_pkh);
 
-    let script = witnet_stack::decode(&script_bytes)?;
+    let script = witnet_data_structures::stack::decode(&script_bytes)?;
 
-    let script_str = witnet_stack::parser::script_to_string(&script);
+    let script_str = witnet_data_structures::stack::parser::script_to_string(&script);
 
     match script_file {
         Some(script_file) => {

node/src/actors/chain_manager/handlers.rs

@@ -14,7 +14,6 @@ log = "0.4.8"
 witnet_crypto = { path = "../crypto" }
 witnet_data_structures = { path = "../data_structures" }
 witnet_rad = { path = "../rad" }
-witnet_stack = { path = "../stack" }
 
 [dev-dependencies]
 approx = "0.5.0"

src/cli/node/json_rpc_client.rs

@@ -12,6 +12,7 @@ use witnet_crypto::{
     merkle::{merkle_tree_root as crypto_merkle_tree_root, ProgressiveMerkleTree},
     signature::{verify, PublicKey, Signature},
 };
+use witnet_data_structures::stack::{execute_complete_script, Item, ScriptContext};
 use witnet_data_structures::{
     chain::{
         Block, BlockMerkleRoots, CheckpointBeacon, CheckpointVRF, ConsensusConstants,
@@ -44,7 +45,6 @@ use witnet_rad::{
     script::{create_radon_script_from_filters_and_reducer, unpack_radon_script},
     types::{serial_iter_decode, RadonTypes},
 };
-use witnet_stack::{execute_complete_script, Item, ScriptContext};
 
 /// Returns the fee of a value transfer transaction.
 ///
@@ -1256,7 +1256,7 @@ pub fn validate_transaction_signatures(
                 &signature,
             );
         } else {
-            let witness_script = witnet_stack::decode(witness)?;
+            let witness_script = witnet_data_structures::stack::decode(witness)?;
             // Operators are not allowed in witness script
             for item in witness_script {
                 match item {