Moving from App to Account terminology - Part 6

crates/codec/src/api/json/receipt.rs

@@ -4,9 +4,9 @@ use crate::api::json::{self, JsonError};
 use crate::receipt;
 
 use svm_types::RuntimeError;
-use svm_types::{CallReceipt, Receipt, ReceiptLog, SpawnReceipt, TemplateReceipt};
+use svm_types::{CallReceipt, DeployReceipt, Receipt, ReceiptLog, SpawnReceipt};
 
-/// Given a binary Receipt wrappend inside a JSON,
+/// Given a binary Receipt wrapped inside a JSON,
 /// decodes it into a user-friendly JSON.
 pub fn decode_receipt(json: &Value) -> Result<Value, JsonError> {
     let data = json::as_string(json, "data")?;
@@ -19,9 +19,9 @@ pub fn decode_receipt(json: &Value) -> Result<Value, JsonError> {
 
     let json = if receipt.success() {
         match receipt {
-            Receipt::DeployTemplate(receipt) => decode_deploy_template(&receipt, ty),
-            Receipt::SpawnApp(receipt) => decode_spawn_app(&receipt, ty),
-            Receipt::ExecApp(receipt) => decode_exe_app(&receipt, ty),
+            Receipt::Deploy(receipt) => decode_deploy_template(&receipt, ty),
+            Receipt::Spawn(receipt) => decode_spawn_app(&receipt, ty),
+            Receipt::Call(receipt) => decode_exe_app(&receipt, ty),
         }
     } else {
         let ty = receipt_type(&receipt);
@@ -36,9 +36,9 @@ pub fn decode_receipt(json: &Value) -> Result<Value, JsonError> {
 
 fn receipt_type(receipt: &Receipt) -> &'static str {
     match receipt {
-        Receipt::DeployTemplate(..) => "deploy-template",
-        Receipt::SpawnApp(..) => "spawn-app",
-        Receipt::ExecApp(..) => "exec-app",
+        Receipt::Deploy(..) => "deploy-template",
+        Receipt::Spawn(..) => "spawn-app",
+        Receipt::Call(..) => "exec-app",
     }
 }
 
@@ -135,11 +135,11 @@ fn decode_error(ty: &'static str, err: &RuntimeError, logs: &[ReceiptLog]) -> Va
     map.into()
 }
 
-fn decode_deploy_template(receipt: &TemplateReceipt, ty: &'static str) -> Value {
+fn decode_deploy_template(receipt: &DeployReceipt, ty: &'static str) -> Value {
     debug_assert!(receipt.success);
     debug_assert!(receipt.error.is_none());
 
-    let TemplateReceipt {
+    let DeployReceipt {
         addr,
         gas_used,
         logs,
@@ -224,7 +224,7 @@ mod tests {
             },
         ];
 
-        let receipt = TemplateReceipt {
+        let receipt = DeployReceipt {
             version: 0,
             success: true,
             error: None,

crates/codec/src/receipt/deploy_template.rs

@@ -13,15 +13,15 @@
 
 use std::io::Cursor;
 
-use svm_types::TemplateReceipt;
+use svm_types::DeployReceipt;
 
 use super::{decode_error, encode_error, gas, logs, types};
 
 use crate::version;
 use crate::{ReadExt, WriteExt};
 
 /// Encodes a `deploy-template` into its binary format.
-pub fn encode_template_receipt(receipt: &TemplateReceipt) -> Vec<u8> {
+pub fn encode_template_receipt(receipt: &DeployReceipt) -> Vec<u8> {
     let mut w = Vec::new();
 
     w.write_byte(types::DEPLOY_TEMPLATE);
@@ -42,7 +42,7 @@ pub fn encode_template_receipt(receipt: &TemplateReceipt) -> Vec<u8> {
 }
 
 /// Decodes a binary `deploy-template` transaction into its Rust struct.
-pub fn decode_template_receipt(bytes: &[u8]) -> TemplateReceipt {
+pub fn decode_template_receipt(bytes: &[u8]) -> DeployReceipt {
     let mut cursor = Cursor::new(bytes);
 
     let ty = cursor.read_byte().unwrap();
@@ -57,14 +57,14 @@ pub fn decode_template_receipt(bytes: &[u8]) -> TemplateReceipt {
         false => {
             let (err, logs) = decode_error(&mut cursor);
 
-            TemplateReceipt::from_err(err, logs)
+            DeployReceipt::from_err(err, logs)
         }
         true => {
             let addr = cursor.read_address().expect("expected an address");
             let gas_used = gas::decode_gas_used(&mut cursor).unwrap();
             let logs = logs::decode_logs(&mut cursor).unwrap();
 
-            TemplateReceipt {
+            DeployReceipt {
                 version,
                 success: true,
                 error: None,
@@ -76,13 +76,13 @@ pub fn decode_template_receipt(bytes: &[u8]) -> TemplateReceipt {
     }
 }
 
-fn encode_version(receipt: &TemplateReceipt, w: &mut Vec<u8>) {
+fn encode_version(receipt: &DeployReceipt, w: &mut Vec<u8>) {
     let v = receipt.version;
 
     version::encode_version(v, w);
 }
 
-fn encode_template_addr(receipt: &TemplateReceipt, w: &mut Vec<u8>) {
+fn encode_template_addr(receipt: &DeployReceipt, w: &mut Vec<u8>) {
     debug_assert!(receipt.success);
 
     let addr = receipt.template_addr();
@@ -94,15 +94,15 @@ fn encode_template_addr(receipt: &TemplateReceipt, w: &mut Vec<u8>) {
 mod tests {
     use super::*;
 
-    use svm_types::{Address, Gas, TemplateReceipt};
+    use svm_types::{Address, DeployReceipt, Gas};
 
     use crate::receipt::decode_receipt;
 
     #[test]
     fn encode_decode_deploy_template_receipt() {
         let addr = Address::repeat(0xAB);
 
-        let receipt = TemplateReceipt {
+        let receipt = DeployReceipt {
             version: 0,
             success: true,
             error: None,
@@ -114,6 +114,6 @@ mod tests {
         let bytes = encode_template_receipt(&receipt);
         let decoded = decode_receipt(&bytes);
 
-        assert_eq!(decoded.into_deploy_template(), receipt);
+        assert_eq!(decoded.into_deploy(), receipt);
     }
 }

crates/codec/src/receipt/mod.rs

@@ -29,15 +29,15 @@ pub fn decode_receipt(bytes: &[u8]) -> Receipt {
     match ty {
         types::DEPLOY_TEMPLATE => {
             let receipt = decode_template_receipt(bytes);
-            Receipt::DeployTemplate(receipt)
+            Receipt::Deploy(receipt)
         }
         types::SPAWN_APP => {
             let receipt = decode_app_receipt(bytes);
-            Receipt::SpawnApp(receipt)
+            Receipt::Spawn(receipt)
         }
         types::EXEC_APP => {
             let receipt = decode_exec_receipt(bytes);
-            Receipt::ExecApp(receipt)
+            Receipt::Call(receipt)
         }
         _ => unreachable!(),
     }

crates/runtime-ffi/tests/api_tests.rs

@@ -163,8 +163,7 @@ fn svm_runtime_failure() {
         assert!(res.is_ok());
 
         // extract the `Template Address` out of the `Receipt`
-        let receipt =
-            receipt::decode_receipt(template_receipt.clone().into()).into_deploy_template();
+        let receipt = receipt::decode_receipt(template_receipt.clone().into()).into_deploy();
         let template_addr: &Address = receipt.template_addr().inner();
         let template_addr: svm_byte_array = (TEMPLATE_ADDR, template_addr).into();
 
@@ -304,8 +303,7 @@ fn svm_runtime_success() {
         assert!(res.is_ok());
 
         // extract the `template-address` out of the receipt
-        let receipt =
-            receipt::decode_receipt(template_receipt.clone().into()).into_deploy_template();
+        let receipt = receipt::decode_receipt(template_receipt.clone().into()).into_deploy();
         let template_addr: &Address = receipt.template_addr().inner();
         let template_addr: svm_byte_array = (TEMPLATE_ADDR, template_addr).into();
 

crates/runtime/src/runtime/default.rs

@@ -5,7 +5,7 @@ use svm_storage::app::AppStorage;
 use svm_types::GasMode;
 use svm_types::SectionKind;
 use svm_types::{AccountAddr, DeployerAddr, SpawnerAddr, State, Template};
-use svm_types::{CallReceipt, ReceiptLog, SpawnReceipt, TemplateReceipt};
+use svm_types::{CallReceipt, DeployReceipt, ReceiptLog, SpawnReceipt};
 use svm_types::{Gas, OOGError};
 use svm_types::{RuntimeError, Transaction};
 use wasmer::{Instance, Module, WasmPtr, WasmTypeList};
@@ -583,7 +583,7 @@ where
         bytes: &[u8],
         _deployer: &DeployerAddr,
         gas_limit: Gas,
-    ) -> TemplateReceipt {
+    ) -> DeployReceipt {
         info!("Deploying a template.");
 
         let template = self.env.parse_deploy_template(bytes, None).unwrap();
@@ -595,9 +595,9 @@ where
             let addr = self.env.compute_template_addr(&template);
 
             self.env.store_template(&template, &addr);
-            TemplateReceipt::new(addr, gas_used)
+            DeployReceipt::new(addr, gas_used)
         } else {
-            TemplateReceipt::new_oog()
+            DeployReceipt::new_oog()
         }
     }
 

crates/runtime/src/runtime/mod.rs

@@ -24,8 +24,8 @@ pub use default::DefaultRuntime;
 pub use ptr::RuntimePtr;
 
 use svm_types::{
-    CallReceipt, DeployerAddr, Gas, RuntimeError, SpawnReceipt, SpawnerAddr, State,
-    TemplateReceipt, Transaction,
+    CallReceipt, DeployReceipt, DeployerAddr, Gas, RuntimeError, SpawnReceipt, SpawnerAddr, State,
+    Transaction,
 };
 
 use crate::error::ValidateError;
@@ -51,7 +51,7 @@ pub trait Runtime {
         bytes: &[u8],
         deployer: &DeployerAddr,
         gas_limit: Gas,
-    ) -> TemplateReceipt;
+    ) -> DeployReceipt;
 
     /// Spawns a new app out of an existing app-template.
     fn spawn_app(&mut self, bytes: &[u8], spawner: &SpawnerAddr, gas_limit: Gas) -> SpawnReceipt;

crates/runtime/tests/runtime_tests.rs

@@ -12,7 +12,7 @@ use svm_layout::FixedLayout;
 use svm_runtime::{testing, Runtime, ValidateError};
 
 use svm_types::{Address, Gas, RuntimeError};
-use svm_types::{SpawnReceipt, TemplateReceipt};
+use svm_types::{DeployReceipt, SpawnReceipt};
 
 fn memory_runtime() -> impl Runtime {
     let state_kv = testing::memory_state_kv_init();
@@ -97,7 +97,7 @@ fn memory_runtime_deploy_template_reaches_oog() {
         include_str!("wasm/runtime_app_ctor.wast").into(),
     );
 
-    let expected = TemplateReceipt::new_oog();
+    let expected = DeployReceipt::new_oog();
     let actual = runtime.deploy_template(&bytes, &deployer, maybe_gas);
     assert_eq!(expected, actual);
 }

crates/types/src/lib.rs

@@ -34,7 +34,7 @@ pub use gas::{Gas, GasMode, OOGError};
 mod receipt;
 
 pub use receipt::{
-    into_spawn_receipt, CallReceipt, Receipt, ReceiptLog, ReceiptRef, SpawnReceipt, TemplateReceipt,
+    into_spawn_receipt, CallReceipt, DeployReceipt, Receipt, ReceiptLog, ReceiptRef, SpawnReceipt,
 };
 
 /// Address-related types

crates/types/src/receipt/deploy_template.rs

@@ -7,7 +7,7 @@ use crate::{Gas, TemplateAddr};
 /// [`TemplateReceipt`] should *not* be wrapped in a [`Result`] for failure
 /// detection; error detection is built-in the type itself.
 #[derive(Debug, PartialEq, Clone)]
-pub struct TemplateReceipt {
+pub struct DeployReceipt {
     /// Transaction format version
     pub version: u16,
 
@@ -27,7 +27,7 @@ pub struct TemplateReceipt {
     pub logs: Vec<ReceiptLog>,
 }
 
-impl TemplateReceipt {
+impl DeployReceipt {
     /// Creates a [`TemplateReceipt`] which indicates a successful deployment of
     /// the template located at `addr` which cost `gas_used`.
     pub fn new(addr: TemplateAddr, gas_used: Gas) -> Self {