Added object version and digest to Publish event (MystenLabs#6609)

* Added object version and digest to Publish event

* Changed object_digest() of EventStore

* Changes on object_digest()

* Changed Hex::endode

* Change in sui-indexer/models/packages.rs

* Changed to Base64 encoding/decoding

* Change openrpc.json

* Run cargo fmt

crates/sui-indexer/src/models/packages.rs

@@ -42,7 +42,9 @@ pub async fn commit_packages_from_events(
     events: Vec<SuiEvent>,
 ) -> Result<usize, IndexerError> {
     let sender_pkg_pair_iter = events.into_iter().filter_map(|event| match event {
-        SuiEvent::Publish { sender, package_id } => Some((sender, package_id)),
+        SuiEvent::Publish {
+            sender, package_id, ..
+        } => Some((sender, package_id)),
         _ => None,
     });
 

crates/sui-json-rpc-types/src/lib.rs

@@ -2074,6 +2074,8 @@ pub enum SuiEvent {
     Publish {
         sender: SuiAddress,
         package_id: ObjectID,
+        version: SequenceNumber,
+        digest: ObjectDigest,
     },
     /// Coin balance changing event
     #[serde(rename_all = "camelCase")]
@@ -2153,7 +2155,17 @@ impl TryFrom<SuiEvent> for Event {
                 type_: parse_sui_struct_tag(&type_)?,
                 contents: bcs,
             },
-            SuiEvent::Publish { sender, package_id } => Event::Publish { sender, package_id },
+            SuiEvent::Publish {
+                sender,
+                package_id,
+                version,
+                digest,
+            } => Event::Publish {
+                sender,
+                package_id,
+                version,
+                digest,
+            },
             SuiEvent::TransferObject {
                 package_id,
                 transaction_module,
@@ -2273,7 +2285,17 @@ impl SuiEvent {
                     bcs,
                 }
             }
-            Event::Publish { sender, package_id } => SuiEvent::Publish { sender, package_id },
+            Event::Publish {
+                sender,
+                package_id,
+                version,
+                digest,
+            } => SuiEvent::Publish {
+                sender,
+                package_id,
+                version,
+                digest,
+            },
             Event::TransferObject {
                 package_id,
                 transaction_module,
@@ -2416,9 +2438,20 @@ impl PartialEq<SuiEvent> for Event {
             Event::Publish {
                 sender: self_sender,
                 package_id: self_package_id,
+                version: self_version,
+                digest: self_digest,
             } => {
-                if let SuiEvent::Publish { package_id, sender } = other {
-                    package_id == self_package_id && self_sender == sender
+                if let SuiEvent::Publish {
+                    package_id,
+                    sender,
+                    version,
+                    digest,
+                } = other
+                {
+                    package_id == self_package_id
+                        && self_sender == sender
+                        && self_version == version
+                        && self_digest == digest
                 } else {
                     false
                 }

crates/sui-open-rpc/spec/openrpc.json

@@ -2735,15 +2735,23 @@
               "publish": {
                 "type": "object",
                 "required": [
+                  "digest",
                   "packageId",
-                  "sender"
+                  "sender",
+                  "version"
                 ],
                 "properties": {
+                  "digest": {
+                    "$ref": "#/components/schemas/ObjectDigest"
+                  },
                   "packageId": {
                     "$ref": "#/components/schemas/ObjectID"
                   },
                   "sender": {
                     "$ref": "#/components/schemas/SuiAddress"
+                  },
+                  "version": {
+                    "$ref": "#/components/schemas/SequenceNumber"
                   }
                 }
               }

crates/sui-storage/Cargo.toml

@@ -40,6 +40,8 @@ telemetry-subscribers = { path = "../../crates/telemetry-subscribers"}
 workspace-hack.workspace = true
 eyre = "0.6.8"
 
+fastcrypto = { workspace = true, features = ["copy_key"] }
+
 [dev-dependencies]
 anyhow = "1.0.64"
 criterion = { version = "0.4.0", features = ["async", "async_tokio"] }

crates/sui-storage/src/event_store/mod.rs

@@ -18,6 +18,7 @@ use std::usize;
 use anyhow::anyhow;
 use async_trait::async_trait;
 use enum_dispatch::enum_dispatch;
+use fastcrypto::encoding::{Base64, Encoding};
 use flexstr::SharedStr;
 use futures::prelude::stream::BoxStream;
 use move_core_types::identifier::Identifier;
@@ -28,7 +29,9 @@ use tokio_stream::StreamExt;
 
 pub use sql::SqlEventStore;
 use sui_json_rpc_types::{SuiEvent, SuiEventEnvelope};
-use sui_types::base_types::{ObjectID, SequenceNumber, SuiAddress, TransactionDigest};
+use sui_types::base_types::{
+    ObjectDigest, ObjectID, SequenceNumber, SuiAddress, TransactionDigest,
+};
 use sui_types::error::SuiError;
 use sui_types::error::SuiError::{StorageCorruptedFieldError, StorageMissingFieldError};
 use sui_types::event::{BalanceChangeType, Event, EventID};
@@ -44,6 +47,7 @@ pub const EVENT_STORE_QUERY_MAX_LIMIT: usize = 1000;
 pub const OBJECT_VERSION_KEY: &str = "obj_ver";
 pub const AMOUNT_KEY: &str = "amount";
 pub const BALANCE_CHANGE_TYPE_KEY: &str = "change_type";
+pub const OBJECT_DIGEST_KEY: &str = "obj_dig";
 
 /// One event pulled out from the EventStore
 #[allow(unused)]
@@ -119,7 +123,18 @@ impl StoredEvent {
     pub fn into_publish(self) -> Result<SuiEvent, anyhow::Error> {
         let package_id = self.package_id()?;
         let sender = self.sender()?;
-        Ok(SuiEvent::Publish { sender, package_id })
+        let version = self.object_version()?.ok_or_else(|| {
+            anyhow::anyhow!("Can't extract object version from StoredEvent: {self:?}")
+        })?;
+        let digest = self.object_digest()?.ok_or_else(|| {
+            anyhow::anyhow!("Can't extract object digest from StoredEvent: {self:?}")
+        })?;
+        Ok(SuiEvent::Publish {
+            sender,
+            package_id,
+            version,
+            digest,
+        })
     }
 
     pub fn into_transfer_object(self) -> Result<SuiEvent, anyhow::Error> {
@@ -324,6 +339,16 @@ impl StoredEvent {
         })
     }
 
+    fn object_digest(&self) -> Result<Option<ObjectDigest>, anyhow::Error> {
+        self.extract_string_field(OBJECT_DIGEST_KEY)?
+            .map(|opt| {
+                Base64::decode(&opt)
+                    .map_err(|e| anyhow!(e))
+                    .and_then(|op| ObjectDigest::try_from(op.as_ref()).map_err(|e| anyhow!(e)))
+            })
+            .transpose()
+    }
+
     fn change_type(&self) -> Result<Option<BalanceChangeType>, anyhow::Error> {
         Ok(self
             .extract_string_field(BALANCE_CHANGE_TYPE_KEY)?

crates/sui-storage/src/event_store/sql.rs

@@ -276,6 +276,9 @@ impl SqlEventStore {
             if let Some(change_type) = event.event.balance_change_type() {
                 fields.insert(BALANCE_CHANGE_TYPE_KEY, (*change_type as usize).to_string());
             }
+            if let Some(digest) = event.event.digest() {
+                fields.insert(OBJECT_DIGEST_KEY, ObjectDigest::encode(&digest));
+            }
             json!(fields).to_string()
         }
     }
@@ -697,6 +700,7 @@ mod tests {
             queried.move_event_contents.as_deref(),
             orig.event.move_event_contents()
         );
+        assert_eq!(queried.object_digest().unwrap(), orig.event.digest());
         assert_eq!(queried.amount().unwrap(), orig.event.amount());
         let move_event_name = orig.event.move_event_name();
         assert_eq!(queried.move_event_name.as_ref(), move_event_name.as_ref());
@@ -977,7 +981,7 @@ mod tests {
             .await?;
         assert_eq!(queried_events.len(), 1);
         test_queried_event_vs_test_envelope(&queried_events[0], &to_insert[1]);
-        assert_eq!(queried_events[0].fields.len(), 0);
+        assert_eq!(queried_events[0].fields.len(), 2); // version field, digest field
 
         // Query NewObject Event
         let queried_events = db

crates/sui-storage/src/event_store/test_utils.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use sui_types::base_types::SuiAddress;
 use sui_types::event::{Event, EventEnvelope};
 use sui_types::gas_coin::GAS;
-use sui_types::object::Owner;
+use sui_types::object::{Owner, PACKAGE_VERSION};
 use sui_types::SUI_FRAMEWORK_ADDRESS;
 
 use super::*;
@@ -63,6 +63,8 @@ pub fn new_test_publish_event(
         Event::Publish {
             sender: sender.unwrap_or_else(SuiAddress::random_for_testing_only),
             package_id: ObjectID::random(),
+            version: PACKAGE_VERSION,
+            digest: ObjectDigest::random(),
         },
         None,
     )

crates/sui-types/src/event.rs

@@ -21,6 +21,7 @@ use strum::VariantNames;
 use strum_macros::{EnumDiscriminants, EnumVariantNames};
 use tracing::error;
 
+use crate::base_types::ObjectDigest;
 use crate::error::SuiError;
 use crate::object::MoveObject;
 use crate::object::ObjectFormatOptions;
@@ -160,6 +161,8 @@ pub enum Event {
     Publish {
         sender: SuiAddress,
         package_id: ObjectID,
+        version: SequenceNumber,
+        digest: ObjectDigest,
     },
     /// Coin balance changing event
     CoinBalanceChange {
@@ -471,11 +474,21 @@ impl Event {
             | Event::MutateObject { version, .. }
             | Event::CoinBalanceChange { version, .. }
             | Event::NewObject { version, .. }
-            | Event::DeleteObject { version, .. } => Some(version),
+            | Event::DeleteObject { version, .. }
+            | Event::Publish { version, .. } => Some(version),
             _ => None,
         }
     }
 
+    /// Extracts the digest from a SuiEvent::Publish event
+    pub fn digest(&self) -> Option<ObjectDigest> {
+        if let Event::Publish { digest, .. } = self {
+            Some(*digest)
+        } else {
+            None
+        }
+    }
+
     /// Extracts the amount from a SuiEvent::CoinBalanceChange event
     pub fn amount(&self) -> Option<i128> {
         if let Event::CoinBalanceChange { amount, .. } = self {

crates/sui-types/src/temporary_store.rs

@@ -307,6 +307,8 @@ impl<S> TemporaryStore<S> {
                     Event::Publish {
                         sender: ctx.sender,
                         package_id: id,
+                        version: obj.version(),
+                        digest: obj.digest(),
                     }
                 } else {
                     Event::new_object(

crates/sui-types/src/unit_tests/event_filter_tests.rs

@@ -7,7 +7,7 @@ use move_core_types::ident_str;
 use move_core_types::identifier::Identifier;
 use serde_json::json;
 
-use crate::base_types::{SuiAddress, TransactionDigest};
+use crate::base_types::{ObjectDigest, SuiAddress, TransactionDigest};
 use crate::event::EventType;
 use crate::event::{Event, EventEnvelope};
 use crate::filter::{EventFilter, Filter};
@@ -117,8 +117,15 @@ fn test_transfer_filter() {
 fn test_publish_filter() {
     let package_id = ObjectID::random();
     let sender = SuiAddress::random_for_testing_only();
+    let version = PACKAGE_VERSION;
+    let digest = ObjectDigest::random();
     // Create a test publish event.
-    let move_event = Event::Publish { sender, package_id };
+    let move_event = Event::Publish {
+        sender,
+        package_id,
+        version,
+        digest,
+    };
     let envelope = EventEnvelope {
         timestamp: 0,
         tx_digest: Some(TransactionDigest::random()),