diff --git a/arbitrum-docs/stylus/how-tos/testing-contracts-OG.mdx b/arbitrum-docs/stylus/how-tos/testing-contracts-OG.mdx
new file mode 100644
index 000000000..e8470fe8f
--- /dev/null
+++ b/arbitrum-docs/stylus/how-tos/testing-contracts-OG.mdx
@@ -0,0 +1,316 @@
+import CustomDetails from '@site/src/components/CustomDetails';
+import { VanillaAdmonition } from '@site/src/components/VanillaAdmonition/';
+
+## Introduction
+
+The Stylus SDK provides a testing framework that allows developers to write and run tests directly in Rust without deploying to a blockchain. This guide will walk you through the process of writing and running tests for Stylus contracts using the built-in testing framework.
+
+The Stylus testing framework allows you to:
+
+- Simulate an Ethereum environment for your tests
+- Test storage operations
+- Mock transaction context and block information
+- Test contract-to-contract interactions
+- Verify contract logic without deployment costs
+
+### Prerequisites
+
+Before you begin, make sure you have:
+
+- Basic familiarity with Rust and smart contract development
+
+
+Rust toolchain
+
+Follow the instructions on [Rust Lang's installation page](https://www.rust-lang.org/tools/install) to install a complete Rust toolchain (v1.81 or newer) on your system. After installation, ensure you can access the programs `rustup`, `rustc`, and `cargo` from your preferred terminal application.
+
+
+
+
+
+
+Docker
+
+The testnode we will use as well as some `cargo stylus` commands require Docker to operate.
+
+You can download Docker from [Docker's website](https://www.docker.com/products/docker-desktop).
+
+
+
+
+Nitro devnode
+
+Stylus is available on Arbitrum Sepolia, but we'll use nitro devnode which has a pre-funded wallet saving us the effort of wallet provisioning or running out of tokens to send transactions.
+
+```shell title="Install your devnode"
+git clone https://github.com/OffchainLabs/nitro-devnode.git
+cd nitro-devnode
+```
+
+```shell title="Launch your devnode"
+./run-dev-node.sh
+```
+
+
+
+## Example Smart Contract
+
+Let's look at the implementation of a decentralized cupcake vending machine using the Stylus SDK.
+
+This example demonstrates the core functionality we'll test.
+We're going to test a Rust Smart Contract defining a cupcake vending machine.
+This vending machine will follow two rules:
+
+1. The vending machine will distribute a cupcake to anyone who hasn't recently received one.
+2. The vending machine's rules can't be changed by anyone.
+
+
+```rust
+//!
+//! Stylus Cupcake Example
+//!
+//! The contract is ABI-equivalent with Solidity, which means you can call it from both Solidity and Rust.
+//! To do this, run `cargo stylus export-abi`.
+//!
+//! Note: this code is a template-only and has not been audited.
+//!
+
+// Allow `cargo stylus export-abi` to generate a main function if the "export-abi" feature is enabled. #![cfg_attr(not(feature = "export-abi"), no_main)]
+extern crate alloc;
+
+use alloy_primitives::{Address, Uint};
+// Import items from the SDK. The prelude contains common traits and macros.
+use stylus_sdk::alloy_primitives::U256;
+use stylus_sdk::prelude::\*;
+use stylus_sdk::{block, console};
+
+// Define persistent storage using the Solidity ABI.
+// `VendingMachine` will be the entrypoint for the contract.
+sol_storage! { #[entrypoint]
+pub struct VendingMachine {
+// Mapping from user addresses to their cupcake balances.
+mapping(address => uint256) cupcake_balances;
+// Mapping from user addresses to the last time they received a cupcake.
+mapping(address => uint256) cupcake_distribution_times;
+}
+}
+
+// Declare that `VendingMachine` is a contract with the following external methods. #[public]
+impl VendingMachine {
+// Give a cupcake to the specified user if they are eligible (i.e., if at least 5 seconds have passed since their last cupcake).
+pub fn give_cupcake_to(&mut self, user_address: Address) -> bool {
+// Get the last distribution time for the user.
+let last_distribution = self.cupcake_distribution_times.get(user_address);
+// Calculate the earliest next time the user can receive a cupcake.
+let five_seconds_from_last_distribution = last_distribution + U256::from(5);
+
+ // Get the current block timestamp.
+ let current_time = block::timestamp();
+ // Check if the user can receive a cupcake.
+ let user_can_receive_cupcake =
+ five_seconds_from_last_distribution <= Uint::<256, 4>::from(current_time);
+
+ if user_can_receive_cupcake {
+ // Increment the user's cupcake balance.
+ let mut balance_accessor = self.cupcake_balances.setter(user_address);
+ let balance = balance_accessor.get() + U256::from(1);
+ balance_accessor.set(balance);
+
+ // Update the distribution time to the current time.
+ let mut time_accessor = self.cupcake_distribution_times.setter(user_address);
+ let new_distribution_time = block::timestamp();
+ time_accessor.set(Uint::<256, 4>::from(new_distribution_time));
+ return true;
+ } else {
+ // User must wait before receiving another cupcake.
+ console!(
+ "HTTP 429: Too Many Cupcakes (you must wait at least 5 seconds between cupcakes)"
+ );
+ return false;
+ }
+ }
+
+ // Get the cupcake balance for the specified user.
+ pub fn get_cupcake_balance_for(&self, user_address: Address) -> Uint<256, 4> {
+ // Return the user's cupcake balance from storage.
+ return self.cupcake_balances.get(user_address);
+ }
+
+}
+
+````
+
+
+## Writing Tests
+
+The Stylus SDK testing framework is available through the `stylus_sdk::testing` module, which is re-exported when targeting native architectures. This allows you to write and run tests using Rust's standard testing infrastructure.
+
+### Setting Up Your Test Environment
+
+To write tests for your contract, follow these steps:
+
+1. Create a test module in your contract file or in a separate file
+2. Import the testing framework
+3. Create a test VM environment
+4. Initialize your contract with the test VM
+5. Write your test assertions
+
+Here's a complete example of how to test our NFT contract:
+
+
+``` rust
+use stylus_sdk::{alloy_primitives::Address, prelude::*};
+use stylus_test::*;
+
+use stylus_cupcake_example::*;
+
+#[test]
+fn test_give_cupcake() {
+ // Setup test environment
+ let vm = TestVM::default();
+ let mut contract = VendingMachine::from(&vm);
+
+ // Create a test user address
+ let user = Address::from([0x1; 20]);
+
+ // First cupcake should succeed
+ assert!(contract.give_cupcake_to(user));
+
+ // Balance should be 1
+ assert_eq!(contract.get_cupcake_balance_for(user), 1.into());
+
+ // Immediate second attempt should fail (needs 5 second wait)
+ assert!(!contract.give_cupcake_to(user));
+
+ // Balance should still be 1
+ assert_eq!(contract.get_cupcake_balance_for(user), 1.into());
+
+ // Advance block timestamp by 6 seconds
+ vm.set_timestamp(6);
+
+ // Should be able to get another cupcake now
+ assert!(contract.give_cupcake_to(user));
+
+ // Balance should be 2
+ assert_eq!(contract.get_cupcake_balance_for(user), 2.into());
+}
+
+#[test]
+fn test_get_cupcake_balance() {
+ let vm = TestVM::default();
+ let mut contract = VendingMachine::from(&vm);
+
+ // Create a test user address
+ let user = Address::from([0x2; 20]);
+
+ // Initial balance should be 0
+ assert_eq!(contract.get_cupcake_balance_for(user), 0.into());
+
+ // Give a cupcake
+ assert!(contract.give_cupcake_to(user));
+
+ // Balance should be 1
+ assert_eq!(contract.get_cupcake_balance_for(user), 1.into());
+}
+```rust
+
+
+
+
+
+
+
+
+
+#### Testing Contract Interactions
+
+To test contract interactions, you can mock calls to other contracts:
+
+```rust
+#[test]
+fn test_external_contract_interaction() {
+ let vm = TestVM::default();
+
+ // Address of an external contract
+ let external_contract = Address::from([0x5; 20]);
+
+ // Mock data and response
+ let call_data = vec![/* function selector and parameters */];
+ let expected_response = vec![/* expected return data */];
+
+ // Mock the call
+ vm.mock_call(external_contract, call_data.clone(), Ok(expected_response));
+
+ // Initialize your contract
+ let contract = StylusTestNFT::from(&vm);
+
+ // Test logic that involves calling the external contract
+ // ...
+}
+```
+
+
+
+#### Testing Storage
+
+The testing framework automatically handles persistent storage simulation. Storage operations in your tests will work exactly as they would on-chain, but in a controlled test environment.
+
+```rust
+#[test]
+fn test_storage_persistence() {
+ let vm = TestVM::default();
+
+ // You can also set storage values directly
+ let key = U256::from(1);
+ let value = B256::from([0xff; 32]);
+ vm.set_storage(key, value);
+
+ // And retrieve them
+ assert_eq!(vm.get_storage(key), value);
+}
+```
+
+### Best Practices
+
+1. **Test Organization**
+
+ - Keep tests in a separate module marked with `#[cfg(test)]`
+ - Group related tests together
+
+2. **Test Isolation**
+
+ - Create a new `TestVM` instance for each test
+ - Don't rely on state from previous tests
+
+3. **Comprehensive Testing**
+
+ - Test happy paths and error cases
+ - Test edge cases and boundary conditions
+ - Test access control and authorization
+
+4. **Meaningful Assertions**
+ - Make assertions that verify the actual behavior you care about
+ - Use descriptive error messages in assertions
+
+## Running Tests
+
+### Testing with cargo-stylus
+
+When using the `cargo-stylus` CLI tool, you can run tests with:
+
+```shell
+cargo stylus test
+```
+
+You can also run specific tests by name:
+
+```shell
+cargo test test_mint
+```
+
+## Conclusion
+
+Testing is an essential part of smart contract development to ensure security, correctness, and reliability. The Stylus SDK provides powerful testing tools that allow you to thoroughly test your contracts before deployment.
+
+The ability to test Rust contracts directly, without requiring a blockchain environment, makes the development cycle faster and more efficient.
+````
diff --git a/arbitrum-docs/stylus/how-tos/testing-contracts.mdx b/arbitrum-docs/stylus/how-tos/testing-contracts.mdx
new file mode 100644
index 000000000..ed9cc88e7
--- /dev/null
+++ b/arbitrum-docs/stylus/how-tos/testing-contracts.mdx
@@ -0,0 +1,463 @@
+---
+id: 'testing-contracts'
+title: 'Testing Smart Contracts with Stylus'
+description: 'A comprehensive guide to writing and running tests for Stylus smart contracts.'
+sme: anegg0
+target_audience: 'Developers writing smart contracts using Stylus.'
+sidebar_position: 3
+---
+
+import CustomDetails from '@site/src/components/CustomDetails';
+import { VanillaAdmonition } from '@site/src/components/VanillaAdmonition/';
+
+## Introduction
+
+The Stylus SDK provides a robust testing framework that allows developers to write and run tests for their contracts directly in Rust without deploying to a blockchain. This guide will walk you through the process of writing and running tests for Stylus contracts using the built-in testing framework.
+
+The Stylus testing framework allows you to:
+
+- Simulate a complete Ethereum environment for your tests
+- Test contract storage operations and state transitions
+- Mock transaction context and block information
+- Test contract-to-contract interactions with mocked calls
+- Verify contract logic without deployment costs or delays
+- Simulate various user scenarios and edge cases
+
+### Prerequisites
+
+Before you begin, make sure you have:
+
+- Basic familiarity with Rust and smart contract development
+- Understanding of unit testing concepts
+
+
+Rust toolchain
+
+Follow the instructions on [Rust Lang's installation page](https://www.rust-lang.org/tools/install) to install a complete Rust toolchain (v1.81 or newer) on your system. After installation, ensure you can access the programs `rustup`, `rustc`, and `cargo` from your preferred terminal application.
+
+
+
+## The Stylus Testing Framework
+
+The Stylus SDK includes `stylus_test`, a module that provides all the tools you need to test your contracts. This module includes:
+
+- **TestVM**: A mock implementation of the Stylus VM that can simulate all host functions
+- **TestVMBuilder**: A builder pattern to conveniently configure the test VM
+- Built-in utilities for mocking calls, storage, and other EVM operations
+
+### Key Components
+
+Here are the key components you'll use when testing your Stylus contracts:
+
+- `TestVM`: The core component that simulates the Stylus execution environment
+- Storage accessors: For testing contract state changes
+- Call mocking: For simulating interactions with other contracts
+- Block context: For testing time-dependent logic
+
+## Example Smart Contract: Cupcake Vending Machine
+
+Let's look at a Rust-based cupcake vending machine smart contract. This contract follows two simple rules:
+
+1. The vending machine will distribute a cupcake to anyone who hasn't received one in the last 5 seconds
+2. The vending machine tracks each user's cupcake balance
+
+
+```rust
+// Allow `cargo stylus export-abi` to generate a main function if the "export-abi" feature is enabled.
+#![cfg_attr(not(feature = "export-abi"), no_main)]
+extern crate alloc;
+
+use alloy_primitives::{Address, Uint};
+// Import items from the SDK. The prelude contains common traits and macros.
+use stylus_sdk::alloy_primitives::U256;
+use stylus_sdk::console;
+use stylus_sdk::prelude::\*;
+
+// Define persistent storage using the Solidity ABI.
+// `VendingMachine` will be the entrypoint for the contract.
+sol_storage! { #[entrypoint]
+pub struct VendingMachine {
+// Mapping from user addresses to their cupcake balances.
+mapping(address => uint256) cupcake_balances;
+// Mapping from user addresses to the last time they received a cupcake.
+mapping(address => uint256) cupcake_distribution_times;
+}
+}
+
+// Declare that `VendingMachine` is a contract with the following external methods. #[public]
+impl VendingMachine {
+// Give a cupcake to the specified user if they are eligible (i.e., if at least 5 seconds have passed since their last cupcake).
+pub fn give_cupcake_to(&mut self, user_address: Address) -> Result> {
+// Get the last distribution time for the user.
+let last_distribution = self.cupcake_distribution_times.get(user_address);
+// Calculate the earliest next time the user can receive a cupcake.
+let five_seconds_from_last_distribution = last_distribution + U256::from(5);
+
+ // Get the current block timestamp using the VM pattern
+ let current_time = self.vm().block_timestamp();
+ // Check if the user can receive a cupcake.
+ let user_can_receive_cupcake =
+ five_seconds_from_last_distribution <= Uint::<256, 4>::from(current_time);
+
+ if user_can_receive_cupcake {
+ // Increment the user's cupcake balance.
+ let mut balance_accessor = self.cupcake_balances.setter(user_address);
+ let balance = balance_accessor.get() + U256::from(1);
+ balance_accessor.set(balance);
+
+ // Get current timestamp using the VM pattern BEFORE creating the mutable borrow
+ let new_distribution_time = self.vm().block_timestamp();
+
+ // Update the distribution time to the current time.
+ let mut time_accessor = self.cupcake_distribution_times.setter(user_address);
+ time_accessor.set(Uint::<256, 4>::from(new_distribution_time));
+ return Ok(true);
+ } else {
+ // User must wait before receiving another cupcake.
+ console!(
+ "HTTP 429: Too Many Cupcakes (you must wait at least 5 seconds between cupcakes)"
+ );
+ return Ok(false);
+ }
+ }
+
+ // Get the cupcake balance for the specified user.
+ pub fn get_cupcake_balance_for(&self, user_address: Address) -> Result, Vec> {
+ // Return the user's cupcake balance from storage.
+ Ok(self.cupcake_balances.get(user_address))
+ }
+
+}
+
+````
+
+
+## Writing Tests for the Vending Machine
+
+Now, let's write comprehensive tests for our vending machine contract using the Stylus testing framework. We'll create tests that verify:
+
+1. Users can get an initial cupcake
+2. Users must wait 5 seconds between cupcakes
+3. Cupcake balances are tracked correctly
+4. The contract state updates properly
+
+### Basic Test Structure
+
+Create a test file using standard Rust test patterns. Here's the basic structure:
+
+```rust
+// Import necessary dependencies
+use stylus_sdk::{alloy_primitives::Address, prelude::*};
+use stylus_test::*;
+
+// Import your contract
+use stylus_cupcake_example::*;
+
+#[test]
+fn test_give_cupcake() {
+ // Set up test environment
+// let vm = TestVM::default();
+ // let mut contract = VendingMachine::from(&vm);
+
+ // Test logic goes here...
+}
+````
+
+### Using the TestVM
+
+The `TestVM` simulates the execution environment for your Stylus contract. You can control aspects like:
+
+- Block timestamp and number
+- Account balances
+- Transaction value and sender
+- Storage state
+
+For the vending machine contract, we need to control the block timestamp to test the 5-second rule:
+
+```rust
+#[test]
+fn test_give_cupcake() {
+ // Setup test environment
+ use stylus_test::{TestVM, TestVMBuilder};
+
+ let vm = TestVM::default();
+ let mut contract = VendingMachine::from(&vm);
+
+ // Create a test user address
+ let user = Address::from([0x1; 20]);
+
+ // First cupcake should succeed
+ assert!(contract.give_cupcake_to(user));
+
+ // Balance should be 1
+ assert_eq!(contract.get_cupcake_balance_for(user), 1.into());
+
+ // Immediate second attempt should fail (needs 5 second wait)
+ assert!(!contract.give_cupcake_to(user));
+
+ // Balance should still be 1
+ assert_eq!(contract.get_cupcake_balance_for(user), 1.into());
+
+ // Advance block timestamp by 6 seconds
+ vm.set_block_timestamp(6);
+
+ // Should be able to get another cupcake now
+ assert!(contract.give_cupcake_to(user));
+
+ // Balance should be 2
+ assert_eq!(contract.get_cupcake_balance_for(user), 2.into());
+}
+```
+
+### Comprehensive Test Suite
+
+Let's create a more comprehensive test suite that covers all aspects of our contract:
+
+
+```rust
+use alloy_primitives::{address, U256};
+use stylus_sdk::testing::*;
+use stylus_testing_example::VendingMachine;
+
+#[test]
+fn test_give_cupcake_to() {
+// Create a new TestVM
+// let vm = TestVM::default();
+let vm: TestVM = TestVMBuilder::new()
+.sender(address!("dCE82b5f92C98F27F116F70491a487EFFDb6a2a9"))
+.contract_address(address!("0x11b57fe348584f042e436c6bf7c3c3def171de49"))
+.value(U256::from(1))
+.rpc_url("http://localhost:8547")
+.build();
+
+ // Initialize the contract with the VM
+ let mut contract = VendingMachine::from(&vm);
+
+ // Test address
+ let user = address!("0xCDC41bff86a62716f050622325CC17a317f99404");
+
+ // Check initial balance is zero
+ assert_eq!(contract.get_cupcake_balance_for(user).unwrap(), U256::ZERO);
+
+ // Give a cupcake and verify it succeeds
+ assert!(contract.give_cupcake_to(user).unwrap());
+
+ // Check balance is now 1
+ assert_eq!(
+ contract.get_cupcake_balance_for(user).unwrap(),
+ U256::from(1)
+ );
+
+ // Try to give another cupcake immediately - should fail due to time restriction
+ assert!(!contract.give_cupcake_to(user).unwrap());
+
+ // Balance should still be 1
+ assert_eq!(
+ contract.get_cupcake_balance_for(user).unwrap(),
+ U256::from(1)
+ );
+
+ // Advance block timestamp by 6 seconds
+ vm.set_block_timestamp(vm.block_timestamp() + 6);
+
+ // Now giving a cupcake should succeed
+ assert!(contract.give_cupcake_to(user).unwrap());
+
+ // Balance should now be 2
+ assert_eq!(
+ contract.get_cupcake_balance_for(user).unwrap(),
+ U256::from(2)
+ );
+
+}
+
+````
+
+
+## Advanced Testing Techniques
+
+### Using TestVMBuilder
+
+For more complex test setups, you can use the `TestVMBuilder` to configure the test environment:
+
+```rust
+#[test]
+fn test_with_custom_environment() {
+ // Create a custom VM with specific parameters
+ let vm = TestVMBuilder::new()
+ .sender(Address::from([0x3; 20])) // Set the transaction sender
+ .contract_address(Address::from([0x4; 20])) // Set contract address
+ .block_timestamp(100) // Set the block timestamp
+ .build();
+
+ let mut contract = VendingMachine::from(&vm);
+
+ // Your test logic here...
+}
+````
+
+### Testing Storage State
+
+You can directly inspect and manipulate the contract's storage:
+
+```rust
+#[test]
+fn test_storage_state() {
+ let vm = TestVM::default();
+ let mut contract = VendingMachine::from(&vm);
+
+ let user = Address::from([0x1; 20]);
+ contract.give_cupcake_to(user);
+
+ // Get the key for the user's balance in storage
+ let key = U256::from(keccak256(
+ &[user.as_bytes(), "cupcake_balances".as_bytes()].concat()
+ ));
+
+ // Check the raw storage value
+ let raw_value = vm.get_storage(key);
+ assert_eq!(raw_value, U256::from(1).into());
+
+ // We can also manipulate storage directly
+ vm.set_storage(key, U256::from(10).into());
+
+ // Contract should reflect the modified storage
+ assert_eq!(contract.get_cupcake_balance_for(user), 10.into());
+}
+```
+
+### Mocking Block Data
+
+For testing time-dependent logic, you can control the block data:
+
+```rust
+#[test]
+fn test_time_dependency() {
+ let vm = TestVM::default();
+ let mut contract = VendingMachine::from(&vm);
+
+ let user = Address::from([0x1; 20]);
+
+ // Set block timestamp to a known value
+ vm.set_block_timestamp(1000);
+
+ // Get the first cupcake
+ assert!(contract.give_cupcake_to(user));
+
+ // Set block timestamp to exactly 5 seconds later
+ vm.set_block_timestamp(1005);
+
+ // User can now get another cupcake
+ assert!(contract.give_cupcake_to(user));
+
+ // Check the balance is 2
+ assert_eq!(contract.get_cupcake_balance_for(user), 2.into());
+}
+```
+
+## Testing Contract Interactions
+
+If your contract interacts with other contracts, you can mock these interactions:
+
+```rust
+sol_interface! {
+ interface ICupcakeInventory {
+ function checkInventory() external view returns (uint256);
+ }
+}
+
+#[test]
+fn test_external_contract_interaction() {
+ let vm = TestVM::default();
+
+ // Address of the inventory contract
+ let inventory_contract = Address::from([0x5; 20]);
+
+ // Create the function selector for checkInventory()
+ let call_data = &function_selector!("checkInventory");
+
+ // Mock a response with 100 cupcakes available
+ let expected_response = U256::from(100).abi_encode();
+
+ // Set up the mock call
+ vm.mock_call(inventory_contract, call_data.to_vec(), Ok(expected_response));
+
+ // Now if your contract calls the inventory contract, it will get the mocked response
+ // ...
+}
+```
+
+## Running Tests
+
+To run your tests, you can use the standard Rust test command:
+
+```shell
+cargo test
+```
+
+Or with the `cargo-stylus` CLI tool:
+
+```shell
+cargo stylus test
+```
+
+To run a specific test:
+
+```shell
+cargo test test_give_cupcake
+```
+
+To see test output:
+
+```shell
+cargo test -- --nocapture
+```
+
+## Testing Best Practices
+
+1. **Test Isolation**
+
+ - Create a new `TestVM` instance for each test
+ - Avoid relying on state from previous tests
+
+2. **Comprehensive Coverage**
+
+ - Test both success and error conditions
+ - Test edge cases and boundary conditions
+ - Verify all public functions and important state transitions
+
+3. **Clear Assertions**
+
+ - Use descriptive error messages in assertions
+ - Make assertions that verify the actual behavior you care about
+
+4. **Realistic Scenarios**
+
+ - Test real-world usage patterns
+ - Include tests for authorization and access control
+
+5. **Gas and Resource Efficiency**
+ - For complex contracts, consider testing gas usage patterns
+ - Look for storage optimization opportunities
+
+## Migrating from Global Accessors to VM Accessors
+
+As of Stylus SDK 0.8.0, there's a shift away from global host function invocations to using the `.vm()` method. This is a safer approach that makes testing easier. For example:
+
+```rust
+// Old style (deprecated)
+let timestamp = block::timestamp();
+
+// New style (preferred)
+let timestamp = self.vm().block_timestamp();
+```
+
+To make your contracts more testable, make sure they access host methods through the `HostAccess` trait with the `.vm()` method.
+
+## Conclusion
+
+Testing is an essential part of smart contract development to ensure security, correctness, and reliability. The Stylus SDK provides a powerful testing framework that allows you to thoroughly verify your contracts before deployment.
+
+By using the techniques outlined in this guide, you can create comprehensive test suites that give you confidence in your contract's behavior under various conditions, without the costs or delays associated with on-chain testing.
+
+The ability to test Rust contracts natively, without requiring a blockchain environment, makes the development cycle faster and more efficient while maintaining high standards of security and correctness.
diff --git a/website/sidebars.js b/website/sidebars.js
index 16f23673e..eb684725b 100644
--- a/website/sidebars.js
+++ b/website/sidebars.js
@@ -607,6 +607,11 @@ const sidebars = {
id: 'stylus/how-tos/debugging-tx',
label: 'Debug transactions',
},
+ {
+ type: 'doc',
+ id: 'stylus/how-tos/testing-contracts',
+ label: 'Testing contracts',
+ },
{
type: 'doc',
id: 'stylus/how-tos/verifying-contracts',