refactor: remove left over sandbox usage

Author: Daanvdplas

ARCHITECTURE.md

@@ -60,11 +60,11 @@ ink! contracts are compiled to RISC-V bytecode for
 This is how ink! smart contracts are executed on a blockchain:
 they are uploaded to a blockchain that runs PolkaVM, PolkaVM then
 interprets them.
-As contracts are executed in a sandbox execution environment on the
+As contracts are executed in an isolated runtime environment on the
 blockchain itself we compile them to a `no_std` environment.
 More specifically they are executed by the [`pallet-revive`](https://github.com/paritytech/polkadot-sdk/tree/master/substrate/frame/revive),
 a module of the Polkadot SDK blockchain framework. This module takes ink!
-smart contracts and runs them in a PolkaVM sandbox environment.
+smart contracts and runs them in a PolkaVM execution environment.
 It also provides an API to smart contracts for anything a smart contract
 needs: storing + retrieving data, calling other contracts, sending value,
 fetching the block number, ….
@@ -250,9 +250,9 @@ most smart-contract-specific events: `Called`, `ContractCodeUpdated, CodeStored`
 The `Instantiated` event was brought back in a later PR.
 
 (5) `pallet-revive` included `revm` as a non-optional dependency. As ink! has to 
-depend on `pallet-revive` for some features (e.g. sandboxed E2E testing), this 
+depend on `pallet-revive` for some features (e.g. runtime-only E2E testing), this 
 results in over 75 more child dependencies having to be build now. This increased 
-build times for sandboxed E2E tests significantly. 
+build times for runtime-only E2E tests significantly. 
 [We proposed](https://github.com/paritytech/polkadot-sdk/pull/9689) putting anything 
 `revm` behind a feature flag, but Parity is not open to it.
 

RELEASES_CHECKLIST.md

@@ -60,18 +60,18 @@ in the future.
     - Release `cargo-contract` crates.
     - Request update of `drink` client, which depends on the `cargo-contract` crates.
     - Release `ink_e2e`.
-1. The `ink_sandbox` crate depends on a git commit of `polkadot-sdk`, hence it
+1. The `ink_runtime` crate depends on a git commit of `polkadot-sdk`, hence it
    currently cannot be published to crates.io.
 1. Do a dry run:
    ```bash
    fd Cargo.toml crates/ | \
    grep -v e2e | \
-   grep -v sandbox | \
+   grep -v crates/runtime/ | \
    xargs -n1 cargo no-dev-deps publish --allow-dirty --dry-run --manifest-path
    ```
-   This command ignores the `e2e` and `sandbox` folder: The `e2e` crates depend on the `cargo-contract/contract-build`
+   This command ignores the `e2e` and `crates/runtime` folders: The `e2e` crates depend on the `cargo-contract/contract-build`
    crate, so if you want to publish those, you need to publish `cargo-contract/contract-build` first.
-   The `sandbox` is ignored, as it depends on some crates via their `git` ref.
+   The runtime emulator is ignored, as it depends on some crates via their `git` ref.
    It uses [`no-dev-deps`](https://crates.io/crates/cargo-no-dev-deps)
    for publishing, so that the `dev-dependencies` of ink! are ignored for publishing.
    They are not needed and due to a cycle it's also not possible to publish with them.

crates/e2e/macro/src/config.rs

@@ -76,16 +76,16 @@ impl Node {
 /// The runtime emulator that should be used within `TestExternalities`
 #[derive(Clone, Eq, PartialEq, Debug, darling::FromMeta)]
 pub struct RuntimeOnly {
-    /// The sandbox runtime type (e.g., `ink_runtime::DefaultRuntime`)
-    pub sandbox: syn::Path,
+    /// The runtime type (e.g., `ink_runtime::DefaultRuntime`)
+    pub runtime: syn::Path,
     /// The client type implementing the backend traits (e.g.,
     /// `ink_runtime::RuntimeClient`)
     pub client: syn::Path,
 }
 
 impl RuntimeOnly {
     pub fn runtime_path(&self) -> syn::Path {
-        self.sandbox.clone()
+        self.runtime.clone()
     }
     pub fn client_path(&self) -> syn::Path {
         self.client.clone()
@@ -234,7 +234,7 @@ impl RuntimeBackendArg {
     fn into_backend_meta(self) -> NestedMeta {
         let runtime = self.runtime();
         syn::parse_quote! {
-            backend(runtime_only(sandbox = #runtime, client = ::ink_runtime::RuntimeClient))
+            backend(runtime_only(runtime = #runtime, client = ::ink_runtime::RuntimeClient))
         }
     }
 }
@@ -254,7 +254,7 @@ mod tests {
     fn config_works_backend_runtime_only() {
         let input = quote! {
             environment = crate::CustomEnvironment,
-            backend(runtime_only(sandbox = ::ink_runtime::DefaultRuntime, client = ::ink_runtime::RuntimeClient)),
+            backend(runtime_only(runtime = ::ink_runtime::DefaultRuntime, client = ::ink_runtime::RuntimeClient)),
         };
         let config = parse_config(input);
 
@@ -266,7 +266,7 @@ mod tests {
         assert_eq!(
             config.backend(),
             Backend::RuntimeOnly(RuntimeOnly {
-                sandbox: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
+                runtime: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
                 client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
             })
         );
@@ -283,7 +283,7 @@ mod tests {
         assert_eq!(
             config.backend(),
             Backend::RuntimeOnly(RuntimeOnly {
-                sandbox: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
+                runtime: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
                 client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
             })
         );
@@ -292,14 +292,14 @@ mod tests {
     #[test]
     fn config_works_runtime_only_with_custom_backend() {
         let input = quote! {
-            backend(runtime_only(sandbox = ::ink_runtime::DefaultRuntime, client = ::ink_runtime::RuntimeClient)),
+            backend(runtime_only(runtime = ::ink_runtime::DefaultRuntime, client = ::ink_runtime::RuntimeClient)),
         };
         let config = parse_config(input);
 
         assert_eq!(
             config.backend(),
             Backend::RuntimeOnly(RuntimeOnly {
-                sandbox: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
+                runtime: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
                 client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
             })
         );
@@ -313,7 +313,7 @@ mod tests {
         assert_eq!(
             config.backend(),
             Backend::RuntimeOnly(RuntimeOnly {
-                sandbox: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
+                runtime: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
                 client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
             })
         );
@@ -327,7 +327,7 @@ mod tests {
         assert_eq!(
             config.backend(),
             Backend::RuntimeOnly(RuntimeOnly {
-                sandbox: syn::parse_quote! { crate::CustomRuntime },
+                runtime: syn::parse_quote! { crate::CustomRuntime },
                 client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
             })
         );

crates/runtime/src/api/assets_api.rs

@@ -23,7 +23,7 @@ use frame_support::{
 type AssetIdOf<T, I> = <T as pallet_assets::Config<I>>::AssetId;
 type AssetBalanceOf<T, I> = <T as pallet_assets::Config<I>>::Balance;
 
-/// Assets API for the sandbox.
+/// Assets API for the runtime.
 ///
 /// Provides methods to create, mint, and manage assets in `pallet-assets`.
 pub trait AssetsAPI<T, I = pallet_assets::Instance1>
@@ -327,52 +327,52 @@ mod tests {
 
     #[test]
     fn create_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
         let min_balance = 1u128;
 
-        let result = sandbox.create(&asset_id, &admin, min_balance);
+        let result = runtime.create(&asset_id, &admin, min_balance);
 
         assert!(result.is_ok());
-        assert!(sandbox.asset_exists(&asset_id));
+        assert!(runtime.asset_exists(&asset_id));
     }
 
     #[test]
     fn set_metadata_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
         let name = b"Test Token".to_vec();
         let symbol = b"TEST".to_vec();
         let decimals = 18u8;
 
-        let result = sandbox.set_metadata(&asset_id, &admin, name, symbol, decimals);
+        let result = runtime.set_metadata(&asset_id, &admin, name, symbol, decimals);
 
         assert!(result.is_ok());
     }
 
     #[test]
     fn metadata_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
         let name = b"Test Token".to_vec();
         let symbol = b"TEST".to_vec();
         let decimals = 18u8;
 
-        sandbox
+        runtime
             .set_metadata(&asset_id, &admin, name.clone(), symbol.clone(), decimals)
             .unwrap();
 
         let (retrieved_name, retrieved_symbol, retrieved_decimals) =
-            sandbox.metadata(&asset_id);
+            runtime.metadata(&asset_id);
 
         assert_eq!(retrieved_name, name);
         assert_eq!(retrieved_symbol, symbol);
@@ -381,133 +381,133 @@ mod tests {
 
     #[test]
     fn approve_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let spender = ink_e2e::bob().into_account_id();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
-        sandbox.mint_into(&asset_id, &admin, 1000u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.mint_into(&asset_id, &admin, 1000u128).unwrap();
 
-        let allowance_before = sandbox.allowance(&asset_id, &admin, &spender);
+        let allowance_before = runtime.allowance(&asset_id, &admin, &spender);
         assert_eq!(allowance_before, 0);
 
-        let result = sandbox.approve(&asset_id, &admin, &spender, 500u128);
+        let result = runtime.approve(&asset_id, &admin, &spender, 500u128);
 
         assert!(result.is_ok());
 
-        let allowance_after = sandbox.allowance(&asset_id, &admin, &spender);
+        let allowance_after = runtime.allowance(&asset_id, &admin, &spender);
         assert_eq!(allowance_after, 500);
     }
 
     #[test]
     fn mint_into_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
-        let balance_before = sandbox.balance_of(&asset_id, &admin);
+        let balance_before = runtime.balance_of(&asset_id, &admin);
         assert_eq!(balance_before, 0);
 
-        sandbox.mint_into(&asset_id, &admin, 100u128).unwrap();
+        runtime.mint_into(&asset_id, &admin, 100u128).unwrap();
 
-        let balance_after = sandbox.balance_of(&asset_id, &admin);
+        let balance_after = runtime.balance_of(&asset_id, &admin);
         assert_eq!(balance_after, 100);
     }
 
     #[test]
     fn transfer_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let recipient = ink_e2e::bob().into_account_id();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
-        sandbox.mint_into(&asset_id, &admin, 1000u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.mint_into(&asset_id, &admin, 1000u128).unwrap();
 
-        let admin_balance_before = sandbox.balance_of(&asset_id, &admin);
-        let recipient_balance_before = sandbox.balance_of(&asset_id, &recipient);
+        let admin_balance_before = runtime.balance_of(&asset_id, &admin);
+        let recipient_balance_before = runtime.balance_of(&asset_id, &recipient);
 
         assert_eq!(admin_balance_before, 1000);
         assert_eq!(recipient_balance_before, 0);
 
-        let result = sandbox.transfer(&asset_id, &admin, &recipient, 300u128);
+        let result = runtime.transfer(&asset_id, &admin, &recipient, 300u128);
 
         assert!(result.is_ok());
 
-        let admin_balance_after = sandbox.balance_of(&asset_id, &admin);
-        let recipient_balance_after = sandbox.balance_of(&asset_id, &recipient);
+        let admin_balance_after = runtime.balance_of(&asset_id, &admin);
+        let recipient_balance_after = runtime.balance_of(&asset_id, &recipient);
 
         assert_eq!(admin_balance_after, 700);
         assert_eq!(recipient_balance_after, 300);
     }
 
     #[test]
     fn balance_of_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
-        let balance = sandbox.balance_of(&asset_id, &admin);
+        let balance = runtime.balance_of(&asset_id, &admin);
         assert_eq!(balance, 0);
 
-        sandbox.mint_into(&asset_id, &admin, 500u128).unwrap();
+        runtime.mint_into(&asset_id, &admin, 500u128).unwrap();
 
-        let balance = sandbox.balance_of(&asset_id, &admin);
+        let balance = runtime.balance_of(&asset_id, &admin);
         assert_eq!(balance, 500);
     }
 
     #[test]
     fn total_supply_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
-        let supply_before = sandbox.total_supply(&asset_id);
+        let supply_before = runtime.total_supply(&asset_id);
         assert_eq!(supply_before, 0);
 
-        sandbox.mint_into(&asset_id, &admin, 1000u128).unwrap();
+        runtime.mint_into(&asset_id, &admin, 1000u128).unwrap();
 
-        let supply_after = sandbox.total_supply(&asset_id);
+        let supply_after = runtime.total_supply(&asset_id);
         assert_eq!(supply_after, 1000);
     }
 
     #[test]
     fn allowance_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let spender = ink_e2e::bob().into_account_id();
         let asset_id = 1u32;
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
-        let allowance = sandbox.allowance(&asset_id, &admin, &spender);
+        let allowance = runtime.allowance(&asset_id, &admin, &spender);
         assert_eq!(allowance, 0);
 
-        sandbox
+        runtime
             .approve(&asset_id, &admin, &spender, 250u128)
             .unwrap();
 
-        let allowance = sandbox.allowance(&asset_id, &admin, &spender);
+        let allowance = runtime.allowance(&asset_id, &admin, &spender);
         assert_eq!(allowance, 250);
     }
 
     #[test]
     fn asset_exists_works() {
-        let mut sandbox = DefaultRuntime::default();
+        let mut runtime = DefaultRuntime::default();
         let admin = DefaultRuntime::default_actor();
         let asset_id = 1u32;
 
-        assert!(!sandbox.asset_exists(&asset_id));
+        assert!(!runtime.asset_exists(&asset_id));
 
-        sandbox.create(&asset_id, &admin, 1u128).unwrap();
+        runtime.create(&asset_id, &admin, 1u128).unwrap();
 
-        assert!(sandbox.asset_exists(&asset_id));
+        assert!(runtime.asset_exists(&asset_id));
     }
 }