feat(ethexe): Producer provides only promises hashes, instead of its full body

ethexe/common/src/db.rs

@@ -19,11 +19,11 @@
 //! Common db types and traits.
 
 use crate::{
-    Announce, BlockHeader, CodeBlobInfo, Digest, HashOf, ProgramStates, ProtocolTimelines,
+    Address, Announce, BlockHeader, CodeBlobInfo, Digest, HashOf, ProgramStates, ProtocolTimelines,
     Schedule, SimpleBlockData, ValidatorsVec,
     events::BlockEvent,
     gear::StateTransition,
-    injected::{InjectedTransaction, SignedInjectedTransaction},
+    injected::{InjectedTransaction, Promise, SignedInjectedTransaction},
 };
 use alloc::{
     collections::{BTreeSet, VecDeque},
@@ -34,6 +34,7 @@ use gear_core::{
     ids::{ActorId, CodeId},
 };
 use gprimitives::H256;
+use gsigner::secp256k1::Signature;
 use parity_scale_codec::{Decode, Encode};
 
 /// Ethexe metadata associated with an on-chain block.
@@ -134,11 +135,26 @@ pub trait InjectedStorageRO {
         &self,
         hash: HashOf<InjectedTransaction>,
     ) -> Option<SignedInjectedTransaction>;
+
+    /// Returns the promise by its transaction hash.
+    fn promise(&self, hash: HashOf<InjectedTransaction>) -> Option<Promise>;
+
+    ///
+    fn promise_signature(&self, hash: HashOf<InjectedTransaction>) -> Option<(Signature, Address)>;
 }
 
 #[auto_impl::auto_impl(&)]
 pub trait InjectedStorageRW: InjectedStorageRO {
     fn set_injected_transaction(&self, tx: SignedInjectedTransaction);
+
+    fn set_promise(&self, promise: Promise);
+
+    fn set_promise_signature(
+        &self,
+        hash: HashOf<InjectedTransaction>,
+        address: Address,
+        signature: Signature,
+    );
 }
 
 #[derive(Debug, Clone, Default, Encode, Decode, PartialEq, Eq, Hash)]

ethexe/common/src/injected.rs

@@ -16,11 +16,20 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Address, HashOf, ToDigest, ecdsa::SignedMessage};
-use alloc::string::{String, ToString};
+use crate::{Address, Announce, HashOf, ToDigest, ecdsa::SignedMessage};
+use alloc::{
+    string::{String, ToString},
+    vec::Vec,
+};
 use core::hash::Hash;
 use gear_core::rpc::ReplyInfo;
 use gprimitives::{ActorId, H256, MessageId};
+use gsigner::Signature;
+#[cfg(feature = "std")]
+use gsigner::{
+    PrivateKey, PublicKey, SignerError,
+    secp256k1::{Secp256k1SignerExt, Signer},
+};
 use parity_scale_codec::{Decode, Encode};
 use sha3::{Digest, Keccak256};
 use sp_core::Bytes;
@@ -150,6 +159,66 @@ impl ToDigest for Promise {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct PromisesNetworkBundle {
+    /// The hash of [`Announce`] for which promises was created.
+    pub announce: HashOf<Announce>,
+    /// The hashes of transactions with signatures
+    pub promises: Vec<CompactSignedPromise>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct CompactSignedPromise {
+    /// The hash of transaction, for which promise was created.
+    tx_hash: HashOf<InjectedTransaction>,
+    /// The address converted from public key of block producer.
+    address: Address,
+    /// The signature over the [`Promise`] for `tx_hash`.
+    signature: Signature,
+}
+
+#[cfg(feature = "std")]
+impl CompactSignedPromise {
+    pub fn create(
+        signer: &Signer,
+        public_key: PublicKey,
+        promise: Promise,
+    ) -> Result<Self, SignerError> {
+        let tx_hash = promise.tx_hash;
+        let (address, signature) = signer
+            .signed_message(public_key, promise, None)
+            .map(|message| (message.address(), message.into_parts().1))?;
+
+        Ok(Self {
+            tx_hash,
+            address,
+            signature,
+        })
+    }
+
+    pub fn create_from_private_key(
+        private_key: &PrivateKey,
+        promise: Promise,
+    ) -> Result<Self, SignerError> {
+        let tx_hash = promise.tx_hash;
+        let signature = Signature::create(private_key, promise)?;
+        let address = private_key.public_key().to_address();
+        Ok(Self {
+            tx_hash,
+            signature,
+            address,
+        })
+    }
+
+    pub fn tx_hash(&self) -> HashOf<InjectedTransaction> {
+        self.tx_hash
+    }
+
+    pub fn into_parts(self) -> (HashOf<InjectedTransaction>, Address, Signature) {
+        (self.tx_hash, self.address, self.signature)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

ethexe/common/src/mock.rs

@@ -26,10 +26,14 @@ use crate::{
     ecdsa::{PrivateKey, SignedMessage},
     events::BlockEvent,
     gear::{BatchCommitment, ChainCommitment, CodeCommitment, Message, StateTransition},
-    injected::{AddressedInjectedTransaction, InjectedTransaction},
+    injected::{AddressedInjectedTransaction, InjectedTransaction, Promise},
 };
 use alloc::{collections::BTreeMap, vec};
-use gear_core::code::{CodeMetadata, InstrumentedCode};
+use gear_core::{
+    code::{CodeMetadata, InstrumentedCode},
+    message::{ReplyCode, SuccessReplyReason},
+    rpc::ReplyInfo,
+};
 use gprimitives::{CodeId, H256};
 use itertools::Itertools;
 use std::collections::{BTreeSet, VecDeque};
@@ -650,3 +654,16 @@ impl Mock<HashOf<Announce>> for ComputedAnnounce {
         }
     }
 }
+
+impl Mock<HashOf<InjectedTransaction>> for Promise {
+    fn mock(tx_hash: HashOf<InjectedTransaction>) -> Self {
+        Self {
+            tx_hash,
+            reply: ReplyInfo {
+                payload: vec![],
+                value: 0,
+                code: ReplyCode::Success(SuccessReplyReason::Manual),
+            },
+        }
+    }
+}

ethexe/compute/src/compute.rs

@@ -21,7 +21,7 @@ use ethexe_common::{
     Announce, ComputedAnnounce, HashOf, SimpleBlockData,
     db::{
         AnnounceStorageRO, AnnounceStorageRW, BlockMetaStorageRO, CodesStorageRW,
-        LatestDataStorageRO, LatestDataStorageRW, OnChainStorageRO,
+        InjectedStorageRW, LatestDataStorageRO, LatestDataStorageRW, OnChainStorageRO,
     },
     events::BlockEvent,
 };
@@ -201,6 +201,11 @@ impl<P: ProcessorExt> ComputeSubService<P> {
         })
         .ok_or(ComputeError::LatestDataNotFound)?;
 
+        // TODO: remove in this PR ComputedAnnounce struct.
+        promises.clone().into_iter().for_each(|promise| {
+            db.set_promise(promise);
+        });
+
         Ok(ComputedAnnounce {
             announce_hash,
             promises,

ethexe/consensus/src/lib.rs

@@ -36,7 +36,9 @@ use anyhow::Result;
 use ethexe_common::{
     Announce, ComputedAnnounce, Digest, HashOf, SimpleBlockData,
     consensus::{BatchCommitmentValidationReply, VerifiedAnnounce, VerifiedValidationRequest},
-    injected::{SignedInjectedTransaction, SignedPromise},
+    injected::{
+         PromisesNetworkBundle, SignedInjectedTransaction, 
+    },
     network::{AnnouncesRequest, AnnouncesResponse, SignedValidatorMessage},
 };
 use futures::{Stream, stream::FusedStream};
@@ -124,5 +126,5 @@ pub enum ConsensusEvent {
     Warning(String),
     /// Promises for [`ethexe_common::injected::InjectedTransaction`]s execution in some announce.
     #[from]
-    Promises(Vec<SignedPromise>),
+    Promises(PromisesNetworkBundle),
 }

ethexe/consensus/src/validator/producer.rs

@@ -24,11 +24,14 @@ use crate::{
     announces::{self, DBAnnouncesExt},
     validator::DefaultProcessing,
 };
-use anyhow::{Context as _, Result, anyhow};
+use anyhow::{ Result, anyhow};
 use derive_more::{Debug, Display};
 use ethexe_common::{
-    Announce, ComputedAnnounce, HashOf, SimpleBlockData, ValidatorsVec, db::BlockMetaStorageRO,
-    gear::BatchCommitment, network::ValidatorMessage,
+    Announce, ComputedAnnounce, HashOf, SimpleBlockData, ValidatorsVec,
+    db::BlockMetaStorageRO,
+    gear::BatchCommitment,
+    injected::{CompactSignedPromise, PromisesNetworkBundle},
+    network::ValidatorMessage,
 };
 use ethexe_service_utils::Timer;
 use futures::{FutureExt, future::BoxFuture};
@@ -82,17 +85,22 @@ impl StateHandler for Producer {
                 if *expected == computed_data.announce_hash =>
             {
                 if !computed_data.promises.is_empty() {
-                    let signed_promises = computed_data
+                    let promises = computed_data
                         .promises
                         .into_iter()
                         .map(|promise| {
-                            self.ctx
-                                .sign_message(promise)
-                                .context("producer: failed to sign promise")
+                            CompactSignedPromise::create(
+                                &self.ctx.core.signer,
+                                self.ctx.core.pub_key,
+                                promise,
+                            )
                         })
                         .collect::<Result<_, _>>()?;
-
-                    self.ctx.output(ConsensusEvent::Promises(signed_promises));
+                    let bundle = PromisesNetworkBundle {
+                        announce: computed_data.announce_hash,
+                        promises,
+                    };
+                    self.ctx.output(ConsensusEvent::Promises(bundle));
                 }
 
                 // Aggregate commitment for the block and use `announce_hash` as head for chain commitment.

ethexe/db/Cargo.toml

@@ -12,6 +12,7 @@ ethexe-common = { workspace = true, features = ["std"] }
 ethexe-runtime-common = { workspace = true, features = ["std"] }
 gear-core = { workspace = true, features = ["std"] }
 gprimitives = { workspace = true, features = ["std"] }
+gsigner = {workspace = true, features = ["secp256k1", "codec"]}
 
 anyhow.workspace = true
 dashmap.workspace = true

ethexe/db/src/database.rs

@@ -23,8 +23,8 @@ use crate::{
     overlay::{CASOverlay, KVOverlay},
 };
 use ethexe_common::{
-    Announce, BlockHeader, CodeBlobInfo, HashOf, ProgramStates, ProtocolTimelines, Schedule,
-    ValidatorsVec,
+    Address, Announce, BlockHeader, CodeBlobInfo, HashOf, ProgramStates, ProtocolTimelines,
+    Schedule, ValidatorsVec,
     db::{
         AnnounceMeta, AnnounceStorageRO, AnnounceStorageRW, BlockMeta, BlockMetaStorageRO,
         BlockMetaStorageRW, CodesStorageRO, CodesStorageRW, HashStorageRO, InjectedStorageRO,
@@ -33,9 +33,8 @@ use ethexe_common::{
     },
     events::BlockEvent,
     gear::StateTransition,
-    injected::{InjectedTransaction, SignedInjectedTransaction},
+    injected::{InjectedTransaction, Promise, SignedInjectedTransaction},
 };
-
 use ethexe_runtime_common::state::{
     Allocations, DispatchStash, Mailbox, MemoryPages, MemoryPagesRegion, MessageQueue,
     ProgramState, Storage, UserMailbox, Waitlist,
@@ -47,6 +46,7 @@ use gear_core::{
     memory::PageBuf,
 };
 use gprimitives::H256;
+use gsigner::secp256k1::Signature;
 use parity_scale_codec::{Decode, Encode};
 use std::collections::BTreeSet;
 
@@ -76,7 +76,10 @@ enum Key {
     Timelines = 15,
 
     // TODO kuzmindev: temporal solution - must move into block meta or something else.
-    LatestEraValidatorsCommitted(H256),
+    LatestEraValidatorsCommitted(H256) = 16,
+
+    Promise(HashOf<InjectedTransaction>) = 17,
+    PromiseSignature(HashOf<InjectedTransaction>) = 18,
 }
 
 impl Key {
@@ -103,7 +106,9 @@ impl Key {
             | Self::AnnounceSchedule(hash)
             | Self::AnnounceMeta(hash) => [prefix.as_ref(), hash.inner().as_ref()].concat(),
 
-            Self::InjectedTransaction(hash) => [prefix.as_ref(), hash.inner().as_ref()].concat(),
+            Self::InjectedTransaction(hash)
+            | Self::Promise(hash)
+            | Self::PromiseSignature(hash) => [prefix.as_ref(), hash.inner().as_ref()].concat(),
 
             Self::ProgramToCodeId(program_id) => [prefix.as_ref(), program_id.as_ref()].concat(),
 
@@ -619,6 +624,24 @@ impl InjectedStorageRO for Database {
                     .expect("Failed to decode data into `SignedInjectedTransaction`")
             })
     }
+
+    fn promise(&self, tx_hash: HashOf<InjectedTransaction>) -> Option<Promise> {
+        self.kv.get(&Key::Promise(tx_hash).to_bytes()).map(|data| {
+            Promise::decode(&mut data.as_slice()).expect("Failed to decode data into Promise")
+        })
+    }
+
+    fn promise_signature(
+        &self,
+        tx_hash: HashOf<InjectedTransaction>,
+    ) -> Option<(Signature, Address)> {
+        self.kv
+            .get(&Key::PromiseSignature(tx_hash).to_bytes())
+            .map(|data| {
+                <(Signature, Address)>::decode(&mut data.as_slice())
+                    .expect("Failed to decode data into `(Signature, Address)`")
+            })
+    }
 }
 
 impl InjectedStorageRW for Database {
@@ -629,6 +652,27 @@ impl InjectedStorageRW for Database {
         self.kv
             .put(&Key::InjectedTransaction(tx_hash).to_bytes(), tx.encode());
     }
+
+    fn set_promise(&self, promise: Promise) {
+        tracing::trace!(promise_tx_hash = ?promise.tx_hash, "Set promise for injected transaction");
+
+        self.kv
+            .put(&Key::Promise(promise.tx_hash).to_bytes(), promise.encode())
+    }
+
+    fn set_promise_signature(
+        &self,
+        hash: HashOf<InjectedTransaction>,
+        address: Address,
+        signature: Signature,
+    ) {
+        tracing::trace!(tx_hash = ?hash, ?signature, ?address, "Set `(Signature, Address)` for injected transaction promise");
+
+        self.kv.put(
+            &Key::PromiseSignature(hash).to_bytes(),
+            (signature, address).encode(),
+        );
+    }
 }
 
 impl AnnounceStorageRO for Database {