repository·main·Indexed 41 days ago
https://github.com/nethermindeth/starknetbyexampleA collection of practical code examples for developers learning to write smart contracts in Cairo for the Starknet blockchain. The documentation covers account abstraction, implementing the SNIP-6 standard account interface, and interacting with contracts using starknet.js, as well as providing guidance on using the Foundry toolkit (Forge, Cast, Anvil, and Chisel) for Ethereum application development.
Foundry is a fast, portable, and modular toolkit for Ethereum application development written in Rust. It is composed of four primary tools:
The Staking contract allows users to stake an ERC20 token to earn rewards in a different (or the same) ERC20 token over a specified duration.
A Constant Product Automated Market Maker (AMM) implements the formula $x imes y = k$ to ensure the product of two token reserves remains constant during trades. This allows users to swap between two tokens or provide/remove liquidity from a pool. This implementation is a Cairo adaptation of the Solidity by Example Constant Product AMM.
// [!include ~/listings/applications/constant_product_amm/src/contracts.cairo:ConstantProductAmmContract]Sierra is a linear intermediate representation (IR) that bridges high-level Cairo 1 code and low-level Cairo Assembly (CASM). It is designed to ensure that programs are always provable by preventing infinite loops and invalid constraints.
Key characteristics:
Compiler plugins in Cairo allow for the generation of additional code for specific items during the compilation process. They are used to extend the language's capabilities by automating repetitive tasks or adding new syntax/functionality.
Core examples of built-in plugins include:
#[derive]: Automatically implements traits for a struct or enum.#[cfg]: Enables conditional compilation based on specific flags.#[generate_trait]: Generates trait implementations.#[derive(starknet::Store)] on a struct, Cairo automatically generates storage pointers for every member of that struct. This allows you to read or modify individual fields of a stored struct directly without having to load and rewrite the entire struct manually.Contract storage is implemented as a key-value store using a struct marked with the #[storage] attribute. A contract must have exactly one storage definition. This struct represents the persistent state of the contract on the blockchain, which is maintained between different contract executions.
#[starknet::contract]
mod MyContract {
#[storage]
struct Storage {
a: u128,
b: u8,
c: u256,
}
// ...
}In Cairo, felt252 is the fundamental data type from which all other data types are derived. It is used to represent field elements. Additionally, felt252 can be used to store 'short string representations' with a maximum length of 31 characters.
// Example of felt252 usagestdStorage is a wrapper around the record and accesses cheatcodes. It allows you to find and write to storage slots associated with specific variables without knowing the storage layout. It works by recording SLOAD and SSTORE operations during a function call.
.target(address).sig(selector).find() to locate a slot..checked_write(value) to write to a found slot..with_key(key) before calling .find()..depth(n) to specify the field depth (0 for the first field, 1 for the second, etc.).sload with a random hash).Caveat: While it can find slots for packed storage variables, you cannot safely write to them; execution will throw an error unless the slot is uninitialized (bytes32(0)).
import "forge-std/Test.sol";
contract TestContract is Test {
using stdStorage for StdStorage;
Storage test;
function setUp() public {
test = new Storage();
}
function testFindExists() public {
uint256 slot = stdstore.target(address(test)).sig("exists()").find();
assertEq(slot, 0);
}
function testWriteExists() public {
stdstore.target(address(test)).sig("exists()").checked_write(100);
assertEq(test.exists(), 100);
}
function testFindMapping() public {
uint256 slot = stdstore
.target(address(test))
.sig(test.map_addr.selector)
.with_key(address(this))
.find();
assertEq(uint(vm.load(address(test), bytes32(slot))), 1);
}
function testFindStruct() public {
uint256 slot_for_a_field = stdstore
.target(address(test))
.sig(test.basicStruct.selector)
.depth(0)
.find();
assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1);
}
}You can upgrade a deployed contract's implementation by updating its associated class hash. This is achieved by calling the replace_class_syscall function.
Key behavior:
When using custom types in Starknet contract entrypoints, you must manage the conversion between your high-level types and the low-level format used by the Starknet VM.
Entrypoints require data to be in specific formats because:
felt252.felt252.