[sozo] generate JSON manifest

.gitignore

@@ -15,3 +15,4 @@ output.txt
 **/katana-logs
 crates/benches/bench_results.txt
 **/generated
+.vscode

crates/dojo-lang/src/compiler.rs

@@ -17,7 +17,7 @@ use cairo_lang_utils::UpcastMut;
 use camino::Utf8PathBuf;
 use convert_case::{Case, Casing};
 use dojo_world::manifest::{
-    Class, ComputedValueEntrypoint, DojoContract, DojoModel, Manifest, ManifestMethods,
+    AbiFormat, Class, ComputedValueEntrypoint, DojoContract, DojoModel, Manifest, ManifestMethods,
     BASE_CONTRACT_NAME, WORLD_CONTRACT_NAME,
 };
 use itertools::Itertools;
@@ -451,7 +451,7 @@ where
     let relative_abi_path = relative_abis_dir.join(name.clone()).with_extension("json");
 
     if abi.is_some() {
-        manifest.inner.set_abi(Some(relative_abi_path.clone()));
+        manifest.inner.set_abi(Some(AbiFormat::Path(relative_abi_path.clone())));
     }
 
     let manifest_toml = toml::to_string_pretty(&manifest)?;

crates/dojo-world/src/manifest.rs

@@ -9,6 +9,7 @@
 use serde_with::serde_as;
 use smol_str::SmolStr;
 use starknet::core::serde::unsigned_field_element::UfeHex;
+use starknet::core::types::contract::AbiEntry;
 use starknet::core::types::{
     BlockId, BlockTag, EmittedEvent, EventFilter, FieldElement, FunctionCall, StarknetError,
 };
@@ -75,13 +76,14 @@
 
 /// Represents a declaration of a model.
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 #[serde(tag = "kind")]
 pub struct DojoModel {
     pub members: Vec<Member>,
     #[serde_as(as = "UfeHex")]
     pub class_hash: FieldElement,
-    pub abi: Option<Utf8PathBuf>,
+    pub abi: Option<AbiFormat>,
 }
 
 /// System input ABI.
@@ -110,57 +112,100 @@
     pub model: Option<String>,
 }
 
+/// Format of the ABI into the manifest.
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum AbiFormat {
+    /// Only a relative path to the ABI file is stored.
+    Path(Utf8PathBuf),
+    /// The full ABI is embedded.
+    Embed(Vec<AbiEntry>),
+}
+
+#[cfg(test)]
+impl PartialEq for AbiFormat {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (AbiFormat::Path(p1), AbiFormat::Path(p2)) => p1 == p2,
+            (AbiFormat::Embed(e1), AbiFormat::Embed(e2)) => {
+                // Currently, [`AbiEntry`] does not implement [`PartialEq`] so we cannot compare
+                // them directly.
+                let e1_json = serde_json::to_string(e1).expect("valid JSON from ABI");
+                let e2_json = serde_json::to_string(e2).expect("valid JSON from ABI");
+                e1_json == e2_json
+            }
+            _ => false,
+        }
+    }
+}
+
+impl AbiFormat {
+    pub fn to_path(&self) -> Option<&Utf8PathBuf> {
+        match self {
+            AbiFormat::Path(p) => Some(p),
+            AbiFormat::Embed(_) => None,
+        }
+    }
+}
+
+#[serde_as]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 #[serde(tag = "kind")]
 pub struct DojoContract {
     #[serde_as(as = "Option<UfeHex>")]
     pub address: Option<FieldElement>,
     #[serde_as(as = "UfeHex")]
     pub class_hash: FieldElement,
-    pub abi: Option<Utf8PathBuf>,
+    pub abi: Option<AbiFormat>,
     pub reads: Vec<String>,
     pub writes: Vec<String>,
     pub computed: Vec<ComputedValueEntrypoint>,
 }
 
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
-
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OverlayDojoContract {
     pub name: SmolStr,
     pub reads: Option<Vec<String>>,
     pub writes: Option<Vec<String>>,
 }
 
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OverlayDojoModel {}
 
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OverlayContract {}
 
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OverlayClass {}
 
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 #[serde(tag = "kind")]
 pub struct Class {
     #[serde_as(as = "UfeHex")]
     pub class_hash: FieldElement,
-    pub abi: Option<Utf8PathBuf>,
+    pub abi: Option<AbiFormat>,
 }
 
 #[serde_as]
-#[derive(Clone, Default, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 #[serde(tag = "kind")]
 pub struct Contract {
     #[serde_as(as = "UfeHex")]
     pub class_hash: FieldElement,
-    pub abi: Option<Utf8PathBuf>,
+    pub abi: Option<AbiFormat>,
     #[serde_as(as = "Option<UfeHex>")]
     pub address: Option<FieldElement>,
     #[serde_as(as = "Option<UfeHex>")]
@@ -170,7 +215,8 @@
     pub seed: Option<String>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct BaseManifest {
     pub world: Manifest<Class>,
     pub base: Manifest<Class>,
@@ -202,20 +248,23 @@
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct DeploymentManifest {
     pub world: Manifest<Contract>,
     pub base: Manifest<Class>,
     pub contracts: Vec<Manifest<DojoContract>>,
     pub models: Vec<Manifest<DojoModel>>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct OverlayManifest {
     pub contracts: Vec<OverlayDojoContract>,
 }
 
-#[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[cfg_attr(test, derive(PartialEq))]
 pub struct Manifest<T>
 where
     T: ManifestMethods,
@@ -236,8 +285,8 @@
 
 pub trait ManifestMethods {
     type OverlayType;
-    fn abi(&self) -> Option<&Utf8PathBuf>;
-    fn set_abi(&mut self, abi: Option<Utf8PathBuf>);
+    fn abi(&self) -> Option<&AbiFormat>;
+    fn set_abi(&mut self, abi: Option<AbiFormat>);
     fn class_hash(&self) -> &FieldElement;
     fn set_class_hash(&mut self, class_hash: FieldElement);
 
@@ -300,7 +349,7 @@
         self.world.inner.seed = previous.world.inner.seed;
     }
 
-    pub fn write_to_path(&self, path: &Utf8PathBuf) -> Result<()> {
+    pub fn write_to_path_toml(&self, path: &Utf8PathBuf) -> Result<()> {
         fs::create_dir_all(path.parent().unwrap())?;
 
         let deployed_manifest = toml::to_string_pretty(&self)?;
@@ -309,6 +358,25 @@
         Ok(())
     }
 
+    pub fn write_to_path_json(&self, path: &Utf8PathBuf, manifest_dir: &Utf8PathBuf) -> Result<()> {
+        fs::create_dir_all(path.parent().unwrap())?;
+
+        // Embedding ABIs into the manifest.
+        let mut manifest_with_abis = self.clone();
+        for contract in &mut manifest_with_abis.contracts {
+            if let Some(AbiFormat::Path(abi_path)) = &contract.inner.abi {
+                let mut abi_file = std::fs::File::open(manifest_dir.join(abi_path))?;
+                let abi_entries: Vec<AbiEntry> = serde_json::from_reader(&mut abi_file)?;
+                contract.inner.abi = Some(AbiFormat::Embed(abi_entries));
+            }
+        }
+
+        let deployed_manifest = serde_json::to_string_pretty(&manifest_with_abis)?;
+        fs::write(path, deployed_manifest)?;
+
+        Ok(())
+    }
+
     /// Construct a manifest of a remote World.
     ///
     /// # Arguments
@@ -628,11 +696,11 @@
 impl ManifestMethods for DojoContract {
     type OverlayType = OverlayDojoContract;
 
-    fn abi(&self) -> Option<&Utf8PathBuf> {
+    fn abi(&self) -> Option<&AbiFormat> {
         self.abi.as_ref()
     }
 
-    fn set_abi(&mut self, abi: Option<Utf8PathBuf>) {
+    fn set_abi(&mut self, abi: Option<AbiFormat>) {
         self.abi = abi;
     }
 
@@ -657,11 +725,11 @@
 impl ManifestMethods for DojoModel {
     type OverlayType = OverlayDojoModel;
 
-    fn abi(&self) -> Option<&Utf8PathBuf> {
+    fn abi(&self) -> Option<&AbiFormat> {
         self.abi.as_ref()
     }
 
-    fn set_abi(&mut self, abi: Option<Utf8PathBuf>) {
+    fn set_abi(&mut self, abi: Option<AbiFormat>) {
         self.abi = abi;
     }
 
@@ -679,11 +747,11 @@
 impl ManifestMethods for Contract {
     type OverlayType = OverlayContract;
 
-    fn abi(&self) -> Option<&Utf8PathBuf> {
+    fn abi(&self) -> Option<&AbiFormat> {
         self.abi.as_ref()
     }
 
-    fn set_abi(&mut self, abi: Option<Utf8PathBuf>) {
+    fn set_abi(&mut self, abi: Option<AbiFormat>) {
         self.abi = abi;
     }
 
@@ -701,11 +769,11 @@
 impl ManifestMethods for Class {
     type OverlayType = OverlayClass;
 
-    fn abi(&self) -> Option<&Utf8PathBuf> {
+    fn abi(&self) -> Option<&AbiFormat> {
         self.abi.as_ref()
     }
 
-    fn set_abi(&mut self, abi: Option<Utf8PathBuf>) {
+    fn set_abi(&mut self, abi: Option<AbiFormat>) {
         self.abi = abi;
     }
 

crates/sozo/ops/src/events.rs

@@ -6,7 +6,7 @@ use cainome::parser::tokens::{CompositeInner, CompositeInnerKind, CoreBasic, Tok
 use cainome::parser::AbiParser;
 use camino::Utf8PathBuf;
 use dojo_lang::compiler::{DEPLOYMENTS_DIR, MANIFESTS_DIR};
-use dojo_world::manifest::{DeploymentManifest, ManifestMethods};
+use dojo_world::manifest::{AbiFormat, DeploymentManifest, ManifestMethods};
 use starknet::core::types::{BlockId, EventFilter, FieldElement};
 use starknet::core::utils::{parse_cairo_short_string, starknet_keccak};
 use starknet::providers::jsonrpc::HttpTransport;
@@ -104,14 +104,14 @@ fn extract_events(
     let mut events_map = HashMap::new();
 
     for contract in &manifest.contracts {
-        if let Some(abi_path) = contract.inner.abi() {
+        if let Some(AbiFormat::Path(abi_path)) = contract.inner.abi() {
             let full_abi_path = manifest_dir.join(abi_path);
             process_abi(&mut events_map, &full_abi_path)?;
         }
     }
 
     for model in &manifest.contracts {
-        if let Some(abi_path) = model.inner.abi() {
+        if let Some(AbiFormat::Path(abi_path)) = model.inner.abi() {
             let full_abi_path = manifest_dir.join(abi_path);
             process_abi(&mut events_map, &full_abi_path)?;
         }

crates/sozo/ops/src/migration/mod.rs

@@ -7,7 +7,7 @@
 use dojo_world::contracts::cairo_utils;
 use dojo_world::contracts::world::WorldContract;
 use dojo_world::manifest::{
-    AbstractManifestError, BaseManifest, DeploymentManifest, DojoContract, Manifest,
+    AbiFormat, AbstractManifestError, BaseManifest, DeploymentManifest, DojoContract, Manifest,
     ManifestMethods, OverlayManifest,
 };
 use dojo_world::metadata::dojo_metadata_from_workspace;
@@ -133,6 +133,10 @@
     Ok(())
 }
 
+fn build_deployed_path(manifest_dir: &Utf8PathBuf, chain_id: &str, extension: &str) -> Utf8PathBuf {
+    manifest_dir.join(MANIFESTS_DIR).join(DEPLOYMENTS_DIR).join(chain_id).with_extension(extension)
+}
+
 async fn update_manifests_and_abis(
     ws: &Workspace<'_>,
     local_manifest: BaseManifest,
@@ -145,11 +149,8 @@
     let ui = ws.config().ui();
     ui.print("\n✨ Updating manifests...");
 
-    let deployed_path = manifest_dir
-        .join(MANIFESTS_DIR)
-        .join(DEPLOYMENTS_DIR)
-        .join(chain_id)
-        .with_extension("toml");
+    let deployed_path = build_deployed_path(manifest_dir, chain_id, "toml");
+    let deployed_path_json = build_deployed_path(manifest_dir, chain_id, "json");
 
     let mut local_manifest: DeploymentManifest = local_manifest.into();
 
@@ -185,7 +186,8 @@
     // local_manifest
     update_manifest_abis(&mut local_manifest, manifest_dir, chain_id).await;
 
-    local_manifest.write_to_path(&deployed_path)?;
+    local_manifest.write_to_path_toml(&deployed_path)?;
+    local_manifest.write_to_path_json(&deployed_path_json, manifest_dir)?;
     ui.print("\n✨ Done.");
 
     Ok(())
@@ -204,8 +206,9 @@
     where
         T: ManifestMethods,
     {
-        // unwraps in call to abi is safe because we always write abis for DojoContracts
-        let base_relative_path = manifest.inner.abi().unwrap();
+        // unwraps in call to abi is safe because we always write abis for DojoContracts as relative
+        // path.
+        let base_relative_path = manifest.inner.abi().unwrap().to_path().unwrap();
         let deployed_relative_path =
             Utf8PathBuf::new().join(ABIS_DIR).join(DEPLOYMENTS_DIR).join(chain_id).join(
                 base_relative_path
@@ -220,7 +223,7 @@
             .await
             .expect("Failed to create folder");
         fs::copy(full_base_path, full_deployed_path).await.expect("Failed to copy abi file");
-        manifest.inner.set_abi(Some(deployed_relative_path));
+        manifest.inner.set_abi(Some(AbiFormat::Path(deployed_relative_path)));
     }
 
     for contract in local_manifest.contracts.iter_mut() {

examples/spawn-and-move/abis/base/contracts/actions.json

@@ -235,7 +235,7 @@
       {
         "name": "player",
         "type": "core::starknet::contract_address::ContractAddress",
-        "kind": "data"
+        "kind": "key"
       },
       {
         "name": "direction",