Modify static buffer size via env var

.gitlab-ci.yml

@@ -384,7 +384,11 @@ examples-test:
         cargo test --verbose --manifest-path ${example}/Cargo.toml --features "foo, bar";
         fi;
         if grep -q "e2e-tests = \[\]" "${example}/Cargo.toml"; then
-          cargo test --verbose --manifest-path ${example}/Cargo.toml --features e2e-tests;
+          if [ "$example" = "integration-tests/static-buffer/" ]; then
+            cargo clean && STATIC_BUFFER_SIZE=30 cargo test --verbose --manifest-path ${example}/Cargo.toml --features e2e-tests && cargo clean;
+          else
+            cargo test --verbose --manifest-path ${example}/Cargo.toml --features e2e-tests;
+          fi;
         else
           cargo test --verbose --manifest-path ${example}/Cargo.toml;
         fi;

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 - Stabilize `call_runtime` ‒ [#1749](https://github.com/paritytech/ink/pull/1749)
 - Make E2E testcases generic over `E2EBackend` trait - [#1867](https://github.com/paritytech/ink/pull/1867)
+- Modify static buffer size via environmental variables - [#1869](https://github.com/paritytech/ink/pull/1869)
 
 ### Added
 - Schema generation - [#1765](https://github.com/paritytech/ink/pull/1765)

crates/env/Cargo.toml

@@ -4,6 +4,7 @@ version.workspace = true
 authors = ["Parity Technologies <[email protected]>", "Robin Freyler <[email protected]>"]
 edition.workspace = true
 rust-version = "1.68"
+build = "build.rs"
 
 license.workspace = true
 readme = "README.md"
@@ -54,6 +55,10 @@ scale-info = { workspace = true, features = ["derive"], optional = true }
 [dev-dependencies]
 ink = { workspace = true }
 
+[build-dependencies]
+const-gen = "1.4"
+dotenvy = "0.15"
+
 [features]
 default = ["std"]
 std = [

crates/env/build.rs

@@ -0,0 +1,23 @@
+use const_gen::*;
+use std::{
+    env,
+    fs,
+    path::Path,
+};
+
+fn main() {
+    // Default size of the buffer: 16 kB.
+    let mut size: usize = 1 << 14;
+    // if environmental variable is present we update the size.
+    if let Ok(size_str) = std::env::var("STATIC_BUFFER_SIZE") {
+        if let Ok(new_size) = size_str.parse::<usize>() {
+            size = new_size;
+        }
+    }
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("const_gen.rs");
+    // create a constant with the specified value.
+    let const_decl = const_declaration!(STATIC_BUFFER_SIZE = size);
+    // Appends it to a file with constants.
+    fs::write(dest_path, const_decl).unwrap();
+}

crates/env/src/engine/off_chain/impls.rs

@@ -48,10 +48,14 @@ use ink_engine::{
 };
 use ink_storage_traits::Storable;
 
+// Injected constants from the build script.
+include!(concat!(env!("OUT_DIR"), "/const_gen.rs"));
+
 /// The capacity of the static buffer.
 /// This is the same size as the ink! on-chain environment. We chose to use the same size
 /// to be as close to the on-chain behavior as possible.
-const BUFFER_SIZE: usize = 1 << 14; // 16 kB
+/// The value is copied from the injected constant from the build script.
+const BUFFER_SIZE: usize = STATIC_BUFFER_SIZE;
 
 impl CryptoHash for Blake2x128 {
     fn hash(input: &[u8], output: &mut <Self as HashOutput>::Type) {

crates/env/src/engine/on_chain/buffer.rs

@@ -12,15 +12,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/// A static buffer with 16 kB of capacity.
+// Injected constants from the build script.
+include!(concat!(env!("OUT_DIR"), "/const_gen.rs"));
+
+/// A static buffer of variable capacity.
 pub struct StaticBuffer {
-    /// The static buffer with a total capacity of 16 kB.
+    /// A static buffer of variable capacity.
     buffer: [u8; Self::CAPACITY],
 }
 
 impl StaticBuffer {
     /// The capacity of the static buffer.
-    const CAPACITY: usize = 1 << 14; // 16 kB
+    /// Usually set to 16 kB.
+    /// Can be modified by setting `STATIC_BUFFER_SIZE` environmental variable.
+    const CAPACITY: usize = STATIC_BUFFER_SIZE;
 
     /// Creates a new static buffer.
     pub const fn new() -> Self {

integration-tests/static-buffer/.gitignore

@@ -0,0 +1,9 @@
+# Ignore build artifacts from the local tests sub-crate.
+/target/
+
+# Ignore backup files creates by cargo fmt.
+**/*.rs.bk
+
+# Remove Cargo.lock when creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

integration-tests/static-buffer/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "static-buffer"
+version = "4.2.0"
+authors = ["Parity Technologies <[email protected]>"]
+edition = "2021"
+publish = false
+
+[dependencies]
+ink = { path = "../../crates/ink", default-features = false }
+
+scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
+scale-info = { version = "2.6", default-features = false, features = ["derive"], optional = true }
+
+[dev-dependencies]
+ink_e2e = { path = "../../crates/e2e" }
+
+[lib]
+path = "lib.rs"
+
+[features]
+default = ["std"]
+std = [
+    "ink/std",
+    "scale/std",
+    "scale-info/std",
+]
+ink-as-dependency = []
+e2e-tests = []

integration-tests/static-buffer/README.md

@@ -0,0 +1,18 @@
+# Static buffer configuration demo
+
+This is a dummy contract illustrating how the [static buffer](/ARCHITECTURE.md#communication-with-the-pallet)
+can be be configured using the environmental variables.
+
+Simply, run:
+```bash
+cargo clean
+STATIC_BUFFER_SIZE=30 cargo test -F e2e-tests
+```
+
+This will configure the buffer to have enough space to instantiate the contract,
+but not enough space to retrieve the caller's address as it is of 32 bytes,
+but we only allocated 30 bytes to the contract.
+
+## Note
+You must run `cargo clean` every time you want to modify the buffer size
+because the value is baked into the binaries.

integration-tests/static-buffer/lib.rs

@@ -0,0 +1,71 @@
+#![cfg_attr(not(feature = "std"), no_std, no_main)]
+
+#[ink::contract]
+pub mod static_buffer {
+    #[ink(storage)]
+    pub struct StaticBuffer {
+        value: bool,
+    }
+
+    impl StaticBuffer {
+        /// Creates a dummy smart contract.
+        #[ink(constructor)]
+        pub fn new(init_value: bool) -> Self {
+            Self { value: init_value }
+        }
+
+        /// Sets a default value.
+        #[ink(constructor)]
+        pub fn new_default() -> Self {
+            Self::new(Default::default())
+        }
+
+        /// Returns the caller of the contract.
+        /// Should panic if the buffer size is less than 32 bytes.
+        #[ink(message)]
+        pub fn get_caller(&self) -> AccountId {
+            self.env().caller()
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        #[ink::test]
+        #[should_panic(expected = "the output buffer is too small!")]
+        fn run_out_buffer_memory() {
+            let flipper = StaticBuffer::new(false);
+            flipper.get_caller()
+        }
+    }
+
+    #[cfg(all(test, feature = "e2e-tests"))]
+    mod e2e_tests {
+        use super::*;
+        use ink_e2e::ContractsBackend;
+
+        type E2EResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+        #[ink_e2e::test]
+        async fn e2e_run_out_of_buffer_memory<Client: E2EBackend>(
+            mut client: Client,
+        ) -> E2EResult<()> {
+            // given
+            let constructor = StaticBufferRef::new(false);
+            let contract = client
+                .instantiate("static_buffer", &ink_e2e::alice(), constructor, 0, None)
+                .await
+                .expect("instantiate failed");
+            let call = contract.call::<StaticBuffer>();
+
+            // when
+            let get = call.get_caller();
+            // then panics if `STATIC_BUFFER_SIZE` is less than 32 bytes.
+            let res = client.call_dry_run(&ink_e2e::bob(), &get, 0, None).await;
+            assert!(res.is_err());
+
+            Ok(())
+        }
+    }
+}