Contract Testing

Testing plays a crucial role in software development, especially for smart contracts. In this section, we'll guide you through the basics of testing a smart contract on Starknet with scarb.

Let's start with a simple smart contract as an example:

use starknet::ContractAddress;

pub trait ISimpleContract<TContractState> {
    fn get_value(self: @TContractState) -> u32;
    fn get_owner(self: @TContractState) -> ContractAddress;
    fn set_value(ref self: TContractState, value: u32);

pub mod SimpleContract {
    use starknet::{get_caller_address, ContractAddress};

    struct Storage {
        value: u32,
        owner: ContractAddress

    fn constructor(ref self: ContractState, initial_value: u32) {

    impl SimpleContract of super::ISimpleContract<ContractState> {
        fn get_value(self: @ContractState) -> u32 {

        fn get_owner(self: @ContractState) -> ContractAddress {

        fn set_value(ref self: ContractState, value: u32) {
            assert( == get_caller_address(), 'Not owner');

Now, take a look at the tests for this contract:

mod tests {
    // Import the interface and dispatcher to be able to interact with the contract.
    use testing_how_to::contract::{
        ISimpleContract, SimpleContract, ISimpleContractDispatcher, ISimpleContractDispatcherTrait

    // Import the deploy syscall to be able to deploy the contract.
    use starknet::{
        ContractAddress, get_caller_address, get_contract_address, contract_address_const
    use starknet::SyscallResultTrait;
    use starknet::syscalls::deploy_syscall;

    // Use starknet test utils to fake the transaction context.
    use starknet::testing::{set_caller_address, set_contract_address};

    // Deploy the contract and return its dispatcher.
    fn deploy(initial_value: u32) -> ISimpleContractDispatcher {
        // Set up constructor arguments.
        let mut calldata = array![];
        initial_value.serialize(ref calldata);

        // Declare and deploy
        let (contract_address, _) = deploy_syscall(
            SimpleContract::TEST_CLASS_HASH.try_into().unwrap(), 0, calldata.span(), false

        // Return the dispatcher.
        // The dispatcher allows to interact with the contract based on its interface.
        ISimpleContractDispatcher { contract_address }

    fn test_deploy() {
        let initial_value: u32 = 10;
        let contract = deploy(initial_value);

        assert(contract.get_value() == initial_value, 'wrong initial value');
        assert(contract.get_owner() == get_contract_address(), 'wrong owner');

    fn test_set_as_owner() {
        // Fake the caller address to address 1
        let owner = contract_address_const::<1>();

        let contract = deploy(10);
        assert(contract.get_owner() == owner, 'wrong owner');

        // Fake the contract address to address 1
        let new_value: u32 = 20;

        assert(contract.get_value() == new_value, 'wrong value');

    fn test_set_not_owner() {
        let owner = contract_address_const::<1>();

        let contract = deploy(10);

        let not_owner = contract_address_const::<2>();

        let new_value: u32 = 20;

To define our test, we use scarb, which allows us to create a separate module guarded with #[cfg(test)]. This ensures that the test module is only compiled when running tests using scarb test.

Each test is defined as a function with the #[test] attribute. You can also check if a test panics using the #[should_panic] attribute.

As we are in the context of a smart contract, it's essential to set up the gas limit. You do this by using the #[available_gas(X)] attribute to specify the gas limit for a test. This is also a great way to ensure that your contract's features stay under a certain gas limit!

Note: The term "gas" here refers to Sierra gas, not L1 gas

Now, let's move on to the testing process:

  • Use the deploy function logic to declare and deploy your contract.
  • Use assert to verify that the contract behaves as expected in the given context.

To make testing more convenient, the testing module of the corelib provides some helpful functions:

  • set_caller_address(address: ContractAddress)
  • set_contract_address(address: ContractAddress)
  • set_block_number(block_number: u64)
  • set_block_timestamp(block_timestamp: u64)
  • set_account_contract_address(address: ContractAddress)
  • set_max_fee(fee: u128)

You may also need the info module from the corelib, which allows you to access information about the current execution context (see syscalls):

  • get_caller_address() -> ContractAddress
  • get_contract_address() -> ContractAddress
  • get_block_info() -> Box<BlockInfo>
  • get_tx_info() -> Box<TxInfo>
  • get_block_timestamp() -> u64
  • get_block_number() -> u64

You can found the full list of functions in the Starknet Corelib repo. You can also find a detailed explanation of testing in cairo in the Cairo book - Chapter 9.

Starknet Foundry

Starknet Foundry is a powerful toolkit for developing smart contracts on Starknet. It offers support for testing Starknet smart contracts on top of scarb with the Forge tool.

Testing with snforge is similar to the process we just described but simplified. Moreover, additional features are on the way, including cheatcodes or parallel tests execution. We highly recommend exploring Starknet Foundry and incorporating it into your projects.

For more detailed information about testing contracts with Starknet Foundry, check out the Starknet Foundry Book - Testing Contracts.

Last change: 2024-02-15, commit: 89037ca