Executefromvar

bindings/ergo-lib-c-core/src/context_extension.rs

@@ -3,11 +3,11 @@ use crate::{
     util::{const_ptr_as_ref, mut_ptr_as_mut},
     Error,
 };
-use ergo_lib::ergotree_interpreter::sigma_protocol::prover;
+use ergo_lib::ergotree_ir::chain::context_extension;
 
 /// User-defined variables to be put into context
 #[derive(PartialEq, Eq, Debug, Clone)]
-pub struct ContextExtension(pub prover::ContextExtension);
+pub struct ContextExtension(pub context_extension::ContextExtension);
 pub type ContextExtensionPtr = *mut ContextExtension;
 pub type ConstContextExtensionPtr = *const ContextExtension;
 
@@ -17,7 +17,7 @@ pub unsafe fn context_extension_empty(
 ) -> Result<(), Error> {
     let context_extension_out = mut_ptr_as_mut(context_extension_out, "context_extension_out")?;
     *context_extension_out = Box::into_raw(Box::new(ContextExtension(
-        prover::ContextExtension::empty(),
+        context_extension::ContextExtension::empty(),
     )));
     Ok(())
 }

bindings/ergo-lib-wasm/src/context_extension.rs

@@ -10,16 +10,14 @@ use derive_more::{From, Into};
 /// User-defined variables to be put into context
 #[wasm_bindgen]
 #[derive(PartialEq, Eq, Debug, Clone, From, Into)]
-pub struct ContextExtension(
-    ergo_lib::ergotree_interpreter::sigma_protocol::prover::ContextExtension,
-);
+pub struct ContextExtension(ergo_lib::ergotree_ir::chain::context_extension::ContextExtension);
 
 #[wasm_bindgen]
 impl ContextExtension {
     /// Create new ContextExtension instance
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
-        Self(ergo_lib::ergotree_interpreter::sigma_protocol::prover::ContextExtension::empty())
+        Self(ergo_lib::ergotree_ir::chain::context_extension::ContextExtension::empty())
     }
 
     /// Set the supplied pair in the ContextExtension
@@ -29,13 +27,11 @@ impl ContextExtension {
 
     /// Returns the number of elements in the collection
     pub fn len(&self) -> usize {
-        let wrapped: ergo_lib::ergotree_interpreter::sigma_protocol::prover::ContextExtension =
-            self.0.clone();
-        wrapped.values.len()
+        self.0.values.len()
     }
     /// get from map or fail if key is missing
     pub fn get(&self, key: u8) -> Result<Constant, JsValue> {
-        let wrapped: ergo_lib::ergotree_interpreter::sigma_protocol::prover::ContextExtension =
+        let wrapped: ergo_lib::ergotree_ir::chain::context_extension::ContextExtension =
             self.0.clone();
         Ok(wrapped
             .values
@@ -47,7 +43,7 @@ impl ContextExtension {
 
     /// Returns all keys in the map
     pub fn keys(&self) -> Vec<u8> {
-        let wrapped: ergo_lib::ergotree_interpreter::sigma_protocol::prover::ContextExtension =
+        let wrapped: ergo_lib::ergotree_ir::chain::context_extension::ContextExtension =
             self.0.clone();
         wrapped.values.keys().cloned().collect()
     }

bindings/ergo-lib-wasm/tests/transaction.rs

@@ -7,6 +7,7 @@ use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
 
+#[allow(dead_code)]
 #[wasm_bindgen_test]
 fn test_random() {
     let sk1 = SecretKey::random_dlog();

ergo-chain-generation/src/chain_generation.rs

@@ -3,6 +3,7 @@
 
 use std::convert::TryFrom;
 
+use ergo_lib::ergotree_ir::chain::context_extension::ContextExtension;
 use ergo_lib::{
     chain::{
         ergo_box::box_builder::ErgoBoxCandidateBuilder,
@@ -12,10 +13,7 @@ use ergo_lib::{
 };
 use ergo_lib::{
     ergo_chain_types::ADDigest,
-    ergotree_interpreter::sigma_protocol::{
-        private_input::DlogProverInput,
-        prover::{ContextExtension, ProofBytes},
-    },
+    ergotree_interpreter::sigma_protocol::{private_input::DlogProverInput, prover::ProofBytes},
 };
 use ergo_lib::{
     ergo_chain_types::{blake2b256_hash, AutolykosSolution, Header, Votes},

ergo-lib/src/chain/json/context_extension.rs

@@ -1,4 +1,4 @@
-use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
+use ergotree_ir::chain::context_extension::ContextExtension;
 use ergotree_ir::{mir::constant::Constant, serialization::SigmaSerializable};
 use indexmap::IndexMap;
 use serde::{ser::SerializeMap, Deserialize, Serialize};

ergo-lib/src/chain/transaction.rs

@@ -9,8 +9,6 @@ pub mod unsigned;
 
 use bounded_vec::BoundedVec;
 use ergo_chain_types::blake2b256_hash;
-use ergotree_interpreter::eval::context::Context;
-pub use ergotree_interpreter::eval::context::TxIoVec;
 use ergotree_interpreter::eval::env::Env;
 use ergotree_interpreter::eval::extract_sigma_boolean;
 use ergotree_interpreter::eval::EvalError;
@@ -20,6 +18,8 @@ use ergotree_interpreter::sigma_protocol::verifier::TestVerifier;
 use ergotree_interpreter::sigma_protocol::verifier::VerificationResult;
 use ergotree_interpreter::sigma_protocol::verifier::Verifier;
 use ergotree_interpreter::sigma_protocol::verifier::VerifierError;
+use ergotree_ir::chain::context::Context;
+pub use ergotree_ir::chain::context::TxIoVec;
 use ergotree_ir::chain::ergo_box::BoxId;
 use ergotree_ir::chain::ergo_box::ErgoBox;
 use ergotree_ir::chain::ergo_box::ErgoBoxCandidate;

ergo-lib/src/chain/transaction/ergo_transaction.rs

@@ -1,8 +1,6 @@
 //! Exposes common properties for signed and unsigned transactions
-use ergotree_interpreter::sigma_protocol::{
-    prover::ContextExtension,
-    verifier::{VerificationResult, VerifierError},
-};
+use ergotree_interpreter::sigma_protocol::verifier::{VerificationResult, VerifierError};
+use ergotree_ir::chain::context_extension::ContextExtension;
 use ergotree_ir::{
     chain::{
         ergo_box::{box_value::BoxValue, BoxId, ErgoBox},

ergo-lib/src/chain/transaction/input.rs

@@ -2,8 +2,8 @@
 
 pub mod prover_result;
 
-use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
 use ergotree_interpreter::sigma_protocol::prover::ProofBytes;
+use ergotree_ir::chain::context_extension::ContextExtension;
 use ergotree_ir::chain::ergo_box::BoxId;
 use ergotree_ir::serialization::sigma_byte_reader::SigmaByteRead;
 use ergotree_ir::serialization::sigma_byte_writer::SigmaByteWrite;

ergo-lib/src/chain/transaction/input/prover_result.rs

@@ -1,7 +1,7 @@
 //! Proof generated by the prover in Sigma protocol
 
-use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
 use ergotree_interpreter::sigma_protocol::prover::ProofBytes;
+use ergotree_ir::chain::context_extension::ContextExtension;
 use ergotree_ir::serialization::sigma_byte_reader::SigmaByteRead;
 use ergotree_ir::serialization::sigma_byte_writer::SigmaByteWrite;
 use ergotree_ir::serialization::SigmaParsingError;

ergo-lib/src/chain/transaction/input/prover_result/json.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use crate::chain::json::context_extension::ContextExtensionSerde;
-use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
+use ergotree_ir::chain::context_extension::ContextExtension;
 use serde::ser::SerializeStruct;
 use serde::Serialize;
 

ergo-lib/src/chain/transaction/reduced.rs

@@ -2,8 +2,8 @@
 //! is augmented with ReducedInput which contains a script reduction result.
 
 use ergotree_interpreter::eval::reduce_to_crypto;
-use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
 use ergotree_interpreter::sigma_protocol::prover::ProverError;
+use ergotree_ir::chain::context_extension::ContextExtension;
 use ergotree_ir::serialization::sigma_byte_reader::SigmaByteRead;
 use ergotree_ir::serialization::sigma_byte_writer::SigmaByteWrite;
 use ergotree_ir::serialization::SigmaParsingError;
@@ -78,12 +78,7 @@ pub fn reduce_tx(
             let input_box = tx_context
                 .get_input_box(&input.box_id)
                 .ok_or(TransactionContextError::InputBoxNotFound(idx))?;
-            let expr = input_box
-                .ergo_tree
-                .proposition()
-                .map_err(ProverError::ErgoTreeError)
-                .map_err(|e| TxSigningError::ProverError(e, idx))?;
-            let reduction_result = reduce_to_crypto(&expr, &ctx)
+            let reduction_result = reduce_to_crypto(&input_box.ergo_tree, &ctx)
                 .map_err(ProverError::EvalError)
                 .map_err(|e| TxSigningError::ProverError(e, idx))?;
             Ok(ReducedInput {

ergo-lib/src/chain/transaction/storage_rent.rs

@@ -1,4 +1,5 @@
-use ergotree_interpreter::{eval::context::Context, sigma_protocol::prover::ProofBytes};
+use ergotree_interpreter::sigma_protocol::prover::ProofBytes;
+use ergotree_ir::chain::context::Context;
 use ergotree_ir::chain::ergo_box::ErgoBox;
 use ergotree_ir::{
     chain::ergo_box::RegisterId, mir::constant::TryExtractInto, serialization::SigmaSerializable,

ergo-lib/src/wallet/multi_sig.rs

@@ -251,12 +251,7 @@ pub fn generate_commitments(
         let input_box = tx_context
             .get_input_box(&input.box_id)
             .ok_or(TransactionContextError::InputBoxNotFound(i))?;
-        let tree = input_box.ergo_tree.clone();
-        let exp = tree
-            .proposition()
-            .map_err(ProverError::ErgoTreeError)
-            .map_err(|e| TxSigningError::ProverError(e, i))?;
-        let reduction_result = reduce_to_crypto(&exp, &ctx)
+        let reduction_result = reduce_to_crypto(&input_box.ergo_tree, &ctx)
             .map_err(ProverError::EvalError)
             .map_err(|e| TxSigningError::ProverError(e, i))?;
 
@@ -280,12 +275,7 @@ pub fn extract_hints(
         let input_box = tx_context
             .get_input_box(&input.box_id)
             .ok_or(TransactionContextError::InputBoxNotFound(i))?;
-        let tree = input_box.ergo_tree.clone();
-        let exp = tree
-            .proposition()
-            .map_err(ProverError::ErgoTreeError)
-            .map_err(|e| TxSigningError::ProverError(e, i))?;
-        let reduction_result = reduce_to_crypto(&exp, &ctx)
+        let reduction_result = reduce_to_crypto(&input_box.ergo_tree, &ctx)
             .map_err(ProverError::EvalError)
             .map_err(|e| TxSigningError::ProverError(e, i))?;
         let sigma_tree = reduction_result.sigma_prop;
@@ -389,7 +379,6 @@ pub fn generate_commitments_for(
 mod tests {
     use super::*;
     use crate::chain::transaction::Transaction;
-    use crate::ergotree_interpreter::eval::context::Context;
     use crate::ergotree_interpreter::eval::reduce_to_crypto;
     use crate::ergotree_interpreter::sigma_protocol::private_input::{
         DlogProverInput, PrivateInput,
@@ -406,6 +395,7 @@ mod tests {
     use ergo_chain_types::Base16DecodedBytes;
     use ergotree_interpreter::sigma_protocol::private_input::DhTupleProverInput;
     use ergotree_interpreter::sigma_protocol::wscalar::Wscalar;
+    use ergotree_ir::chain::context::Context;
     use ergotree_ir::mir::atleast::Atleast;
     use ergotree_ir::mir::constant::{Constant, Literal};
     use ergotree_ir::mir::sigma_or::SigmaOr;
@@ -466,8 +456,7 @@ mod tests {
         let tree_m: ErgoTree = ErgoTree::sigma_parse_bytes(&bytes_m.0).unwrap();
 
         let contx = force_any_val::<Context>();
-        let exp = tree_m.proposition().unwrap();
-        let reduction_result = reduce_to_crypto(&exp, &contx).unwrap();
+        let reduction_result = reduce_to_crypto(&tree_m, &contx).unwrap();
         let sigma_tree = reduction_result.sigma_prop;
         let stx: Transaction = serde_json::from_str(signed_tx).unwrap();
         let test: ProofBytes = stx.inputs.first().clone().spending_proof.proof;
@@ -675,7 +664,7 @@ mod tests {
         .into();
         let tree_and = ErgoTree::try_from(expr.clone()).unwrap();
 
-        let cand = reduce_to_crypto(&expr, &ctx).unwrap().sigma_prop;
+        let cand = reduce_to_crypto(&tree_and, &ctx).unwrap().sigma_prop;
         let generate_for: Vec<SigmaBoolean> = vec![SigmaBoolean::ProofOfKnowledge(
             SigmaProofOfKnowledgeTree::ProveDlog(pk2),
         )];
@@ -747,7 +736,7 @@ mod tests {
 
         let tree_expr = ErgoTree::try_from(expr.clone()).unwrap();
 
-        let expr_reduced = reduce_to_crypto(&expr, &ctx).unwrap().sigma_prop;
+        let expr_reduced = reduce_to_crypto(&tree_expr, &ctx).unwrap().sigma_prop;
         let mut generate_for: Vec<SigmaBoolean> = vec![SigmaBoolean::ProofOfKnowledge(
             SigmaProofOfKnowledgeTree::ProveDlog(pk2),
         )];
@@ -882,7 +871,7 @@ mod tests {
         .into();
         let exp: Expr = SigmaAnd::new(vec![first_expr, second_expr]).unwrap().into();
         let tree = ErgoTree::try_from(exp.clone()).unwrap();
-        let ctree = reduce_to_crypto(&exp, &ctx).unwrap().sigma_prop;
+        let ctree = reduce_to_crypto(&tree, &ctx).unwrap().sigma_prop;
         let mut generate_for: Vec<SigmaBoolean> = vec![SigmaBoolean::ProofOfKnowledge(
             SigmaProofOfKnowledgeTree::ProveDlog(pk_alice.clone()),
         )];
@@ -993,7 +982,7 @@ mod tests {
 
         let tree_expr = ErgoTree::try_from(expr.clone()).unwrap();
 
-        let expr_reduced = reduce_to_crypto(&expr, &ctx).unwrap().sigma_prop;
+        let expr_reduced = reduce_to_crypto(&tree_expr, &ctx).unwrap().sigma_prop;
         let message = vec![0u8; 100];
 
         let hints_from_bob: HintsBag = generate_commitments_for(&expr_reduced, &[bob_pk.into()]);
@@ -1089,7 +1078,7 @@ mod tests {
 
         let tree_expr = ErgoTree::try_from(expr.clone()).unwrap();
 
-        let expr_reduced = reduce_to_crypto(&expr, &ctx).unwrap().sigma_prop;
+        let expr_reduced = reduce_to_crypto(&tree_expr, &ctx).unwrap().sigma_prop;
         let message = vec![0u8; 100];
 
         let bob_hints: HintsBag = generate_commitments_for(&expr_reduced, &[bob_pk.into()]);
@@ -1262,7 +1251,7 @@ mod tests {
         .into();
         let expr: Expr = Atleast::new(bound, input).unwrap().into();
         let tree_expr = ErgoTree::try_from(expr.clone()).unwrap();
-        let expr_reduced = reduce_to_crypto(&expr, &ctx).unwrap().sigma_prop;
+        let expr_reduced = reduce_to_crypto(&tree_expr, &ctx).unwrap().sigma_prop;
         let message = vec![0u8; 100];
 
         // only actors 1, 2, 3, 4, 5, 6, 7 are signing, others are simulated (see bag_one below)

ergo-lib/src/wallet/signing.rs

@@ -14,11 +14,11 @@ use ergotree_ir::sigma_protocol::sigma_boolean::SigmaBoolean;
 
 use crate::chain::transaction::storage_rent::check_storage_rent_conditions;
 use crate::wallet::multi_sig::TransactionHintsBag;
-use ergotree_interpreter::eval::context::Context;
 use ergotree_interpreter::sigma_protocol::prover::ProofBytes;
 use ergotree_interpreter::sigma_protocol::prover::Prover;
 use ergotree_interpreter::sigma_protocol::prover::ProverError;
 use ergotree_interpreter::sigma_protocol::prover::ProverResult;
+use ergotree_ir::chain::context::Context;
 use thiserror::Error;
 
 pub use super::tx_context::TransactionContext;
@@ -260,17 +260,17 @@ pub fn sign_tx_input<'ctx>(
 #[allow(clippy::unwrap_used, clippy::panic)]
 mod tests {
     use super::*;
-    use ergotree_interpreter::eval::context::TxIoVec;
     use ergotree_interpreter::sigma_protocol::private_input::DlogProverInput;
     use ergotree_interpreter::sigma_protocol::private_input::PrivateInput;
-    use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
     use ergotree_interpreter::sigma_protocol::prover::TestProver;
     use ergotree_interpreter::sigma_protocol::verifier::verify_signature;
     use ergotree_interpreter::sigma_protocol::verifier::TestVerifier;
     use ergotree_interpreter::sigma_protocol::verifier::Verifier;
     use ergotree_interpreter::sigma_protocol::verifier::VerifierError;
     use ergotree_ir::chain::address::AddressEncoder;
     use ergotree_ir::chain::address::NetworkPrefix;
+    use ergotree_ir::chain::context::TxIoVec;
+    use ergotree_ir::chain::context_extension::ContextExtension;
     use ergotree_ir::chain::ergo_box::box_value::BoxValue;
     use ergotree_ir::chain::ergo_box::ErgoBox;
     use ergotree_ir::chain::ergo_box::NonMandatoryRegisters;

ergo-lib/src/wallet/tx_builder.rs

@@ -1,7 +1,7 @@
 //! Builder for an UnsignedTransaction
 
-use ergotree_interpreter::eval::context::TxIoVec;
-use ergotree_interpreter::sigma_protocol::prover::ContextExtension;
+use ergotree_ir::chain::context::TxIoVec;
+use ergotree_ir::chain::context_extension::ContextExtension;
 use ergotree_ir::chain::token::TokenAmount;
 use ergotree_ir::chain::token::TokenAmountError;
 use ergotree_ir::ergo_tree::ErgoTree;

ergo-lib/src/wallet/tx_context.rs

@@ -7,8 +7,8 @@ use crate::chain::ergo_state_context::ErgoStateContext;
 use crate::chain::transaction::ergo_transaction::{ErgoTransaction, TxValidationError};
 use crate::chain::transaction::{verify_tx_input_proof, Transaction, TransactionError};
 use crate::ergotree_ir::chain::ergo_box::BoxId;
-use ergotree_interpreter::eval::context::TxIoVec;
 use ergotree_interpreter::sigma_protocol::verifier::VerificationResult;
+use ergotree_ir::chain::context::TxIoVec;
 use ergotree_ir::chain::ergo_box::box_value::BoxValue;
 use ergotree_ir::chain::ergo_box::{BoxTokens, ErgoBox};
 use ergotree_ir::chain::token::{TokenAmount, TokenId};
@@ -288,8 +288,9 @@ pub enum TransactionContextError {
 mod test {
     use std::collections::HashMap;
 
-    use ergotree_interpreter::eval::context::TxIoVec;
-    use ergotree_interpreter::sigma_protocol::prover::{ContextExtension, ProofBytes};
+    use ergotree_interpreter::sigma_protocol::prover::ProofBytes;
+    use ergotree_ir::chain::context::TxIoVec;
+    use ergotree_ir::chain::context_extension::ContextExtension;
     use ergotree_ir::chain::ergo_box::arbitrary::ArbBoxParameters;
     use ergotree_ir::chain::ergo_box::box_value::BoxValue;
     use ergotree_ir::chain::ergo_box::{

ergo-p2p/src/message/handshake.rs

@@ -9,6 +9,8 @@ use crate::PeerSpec;
 /// peerSpec - general (declared) information about peer
 /// time     - handshake time
 pub struct Handshake {
+    /// Peer specification
     pub peer_spec: PeerSpec,
+    /// Handshake time
     pub time: SystemTime,
 }