add time locked transactions example (#201)

* add time locked transactions example

* install snforge in gh-action

* fix: refactor timelock example

.github/workflows/verify_cairo_programs.yml

@@ -4,6 +4,7 @@ on:
  pull_request:
  branches:
  - main
+ workflow_dispatch:
 
 jobs:
  compile_and_verify:
@@ -14,7 +15,7 @@ jobs:
  uses: actions/checkout@v4
  with:
  fetch-depth: 0
- 
+
  - name: Configure upstream repository
  run: |
  git remote add upstream https://github.com/NethermindEth/StarknetByExample
@@ -23,6 +24,9 @@ jobs:
  - name: Install scarb
  uses: software-mansion/setup-scarb@v1
 
+ - name: Install snforge
+ uses: foundry-rs/setup-snfoundry@v3
+
  - name: Run build script
  run: |
  chmod +x scripts/cairo_programs_verifier.sh

.tool-versions

@@ -1 +1,2 @@
-scarb 2.6.4
+scarb 2.6.4
+starknet-foundry 0.24.0

Scarb.lock

@@ -101,6 +101,11 @@ version = "0.1.0"
 name = "simple_vault"
 version = "0.1.0"
 
+[[package]]
+name = "snforge_std"
+version = "0.24.0"
+source = "git+https://github.com/foundry-rs/starknet-foundry.git?tag=v0.24.0#95e9fb09cb91b3c05295915179ee1b55bf923653"
+
 [[package]]
 name = "staking"
 version = "0.1.0"
@@ -132,6 +137,15 @@ version = "0.1.0"
 name = "testing_how_to"
 version = "0.1.0"
 
+[[package]]
+name = "timelock"
+version = "0.1.0"
+dependencies = [
+ "components",
+ "openzeppelin",
+ "snforge_std",
+]
+
 [[package]]
 name = "upgradeable_contract"
 version = "0.1.0"

Scarb.toml

@@ -13,10 +13,11 @@ test = "$(git rev-parse --show-toplevel)/scripts/test_resolver.sh"
 
 [workspace.dependencies]
 starknet = ">=2.6.3"
-# snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.11.0" }
 openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", tag="v0.11.0" }
+components = { path = "listings/applications/components" }
 
 # [workspace.dev-dependencies]
+snforge_std = { git = "https://github.com/foundry-rs/starknet-foundry.git", tag = "v0.24.0" }
 # openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", tag="v0.11.0" }
 
 [workspace.package]

listings/applications/components/src/ownable.cairo

@@ -7,7 +7,7 @@ pub trait IOwnable<TContractState> {
  fn renounce_ownership(ref self: TContractState);
 }
 
-mod Errors {
+pub mod Errors {
  pub const UNAUTHORIZED: felt252 = 'Not owner';
  pub const ZERO_ADDRESS_OWNER: felt252 = 'Owner cannot be zero';
  pub const ZERO_ADDRESS_CALLER: felt252 = 'Caller cannot be zero';
@@ -43,7 +43,7 @@ pub mod ownable_component {
  }
 
  #[embeddable_as(Ownable)]
- impl OwnableImpl<
+ pub impl OwnableImpl<
  TContractState, +HasComponent<TContractState>
  > of super::IOwnable<ComponentState<TContractState>> {
  fn owner(self: @ComponentState<TContractState>) -> ContractAddress {

listings/applications/timelock/.gitignore

@@ -0,0 +1 @@
+target

listings/applications/timelock/Scarb.toml

@@ -0,0 +1,19 @@
+[package]
+name = "timelock"
+version.workspace = true
+edition = "2023_11"
+
+[dependencies]
+starknet.workspace = true
+# Starknet Foundry:
+snforge_std.workspace = true
+# OpenZeppelin:
+openzeppelin.workspace = true
+# StarknetByExample Components
+components.workspace = true
+
+[scripts]
+test.workspace = true
+
+[[target.starknet-contract]]
+casm = true

listings/applications/timelock/src/erc721.cairo

@@ -0,0 +1,44 @@
+#[starknet::contract]
+pub mod ERC721 {
+ use starknet::ContractAddress;
+ use openzeppelin::introspection::src5::SRC5Component;
+ use openzeppelin::token::erc721::ERC721Component;
+
+ component!(path: SRC5Component, storage: src5, event: SRC5Event);
+ component!(path: ERC721Component, storage: erc721, event: ERC721Event);
+
+ // ERC20Mixin
+ #[abi(embed_v0)]
+ impl ERC721MixinImpl = ERC721Component::ERC721MixinImpl<ContractState>;
+ impl ERC721InternalImpl = ERC721Component::InternalImpl<ContractState>;
+
+ #[storage]
+ struct Storage {
+ #[substorage(v0)]
+ src5: SRC5Component::Storage,
+ #[substorage(v0)]
+ erc721: ERC721Component::Storage,
+ }
+
+ #[event]
+ #[derive(Drop, starknet::Event)]
+ enum Event {
+ #[flat]
+ SRC5Event: SRC5Component::Event,
+ #[flat]
+ ERC721Event: ERC721Component::Event,
+ }
+
+ #[constructor]
+ fn constructor(
+ ref self: ContractState,
+ name: ByteArray,
+ symbol: ByteArray,
+ base_uri: ByteArray,
+ recipient: ContractAddress,
+ token_id: u256
+ ) {
+ self.erc721.initializer(name, symbol, base_uri);
+ self.erc721._mint(recipient, token_id);
+ }
+}

listings/applications/timelock/src/lib.cairo

@@ -0,0 +1,8 @@
+#[cfg(test)]
+mod tests {
+ #[feature("safe_dispatcher")]
+ mod timelock;
+ mod utils;
+}
+mod erc721;
+mod timelock;

listings/applications/timelock/src/tests/timelock.cairo

@@ -0,0 +1,228 @@
+use core::panic_with_felt252;
+use starknet::get_block_timestamp;
+use starknet::account::Call;
+use core::poseidon::{PoseidonTrait, poseidon_hash_span};
+use core::hash::{HashStateTrait, HashStateExTrait};
+use snforge_std::{
+ cheat_caller_address, cheat_block_timestamp, CheatSpan, spy_events, SpyOn, EventSpy,
+ EventAssertions
+};
+use openzeppelin::token::erc721::interface::IERC721DispatcherTrait;
+use openzeppelin::token::erc721::erc721::ERC721Component;
+use components::ownable;
+use timelock::timelock::{TimeLock, ITimeLockDispatcherTrait, ITimeLockSafeDispatcherTrait};
+use timelock::tests::utils::{TimeLockTestTrait, TOKEN_ID, OTHER};
+
+#[test]
+fn test_get_tx_id_success() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let timestamp = timelock_test.get_timestamp();
+ let tx_id = timelock_test.timelock.get_tx_id(timelock_test.get_call(), timestamp);
+ let Call { to, selector, calldata } = timelock_test.get_call();
+ let hash = PoseidonTrait::new()
+ .update(to.into())
+ .update(selector.into())
+ .update(poseidon_hash_span(calldata))
+ .update(timestamp.into())
+ .finalize();
+ assert_eq!(tx_id, hash);
+}
+
+#[test]
+fn test_queue_only_owner() {
+ let timelock_test = TimeLockTestTrait::setup();
+ cheat_caller_address(timelock_test.timelock_address, OTHER(), CheatSpan::TargetCalls(1));
+ match timelock_test
+ .timelock_safe
+ .queue(timelock_test.get_call(), timelock_test.get_timestamp()) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => { assert_eq!(*panic_data.at(0), ownable::Errors::UNAUTHORIZED); }
+ }
+}
+
+#[test]
+fn test_queue_already_queued() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let timestamp = timelock_test.get_timestamp();
+ timelock_test.timelock.queue(timelock_test.get_call(), timestamp);
+ match timelock_test.timelock_safe.queue(timelock_test.get_call(), timestamp) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => {
+ assert_eq!(*panic_data.at(0), TimeLock::Errors::ALREADY_QUEUED);
+ }
+ }
+}
+
+#[test]
+fn test_queue_timestamp_not_in_range() {
+ let timelock_test = TimeLockTestTrait::setup();
+ match timelock_test.timelock_safe.queue(timelock_test.get_call(), 0) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => {
+ assert_eq!(*panic_data.at(0), TimeLock::Errors::TIMESTAMP_NOT_IN_RANGE);
+ }
+ }
+ match timelock_test
+ .timelock_safe
+ .queue(timelock_test.get_call(), timelock_test.get_timestamp() + TimeLock::MAX_DELAY) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => {
+ assert_eq!(*panic_data.at(0), TimeLock::Errors::TIMESTAMP_NOT_IN_RANGE);
+ }
+ }
+}
+
+#[test]
+fn test_queue_success() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let mut spy = spy_events(SpyOn::One(timelock_test.timelock_address));
+ let timestamp = timelock_test.get_timestamp();
+ let tx_id = timelock_test.timelock.queue(timelock_test.get_call(), timestamp);
+ spy
+ .assert_emitted(
+ @array![
+ (
+ timelock_test.timelock_address,
+ TimeLock::Event::Queue(
+ TimeLock::Queue { tx_id, call: timelock_test.get_call(), timestamp }
+ )
+ )
+ ]
+ );
+ assert_eq!(tx_id, timelock_test.timelock.get_tx_id(timelock_test.get_call(), timestamp));
+}
+
+#[test]
+fn test_execute_only_owner() {
+ let timelock_test = TimeLockTestTrait::setup();
+ cheat_caller_address(timelock_test.timelock_address, OTHER(), CheatSpan::TargetCalls(1));
+ match timelock_test
+ .timelock_safe
+ .execute(timelock_test.get_call(), timelock_test.get_timestamp()) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => { assert_eq!(*panic_data.at(0), ownable::Errors::UNAUTHORIZED); }
+ }
+}
+
+#[test]
+fn test_execute_not_queued() {
+ let timelock_test = TimeLockTestTrait::setup();
+ match timelock_test
+ .timelock_safe
+ .execute(timelock_test.get_call(), timelock_test.get_timestamp()) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => { assert_eq!(*panic_data.at(0), TimeLock::Errors::NOT_QUEUED); }
+ }
+}
+
+#[test]
+fn test_execute_timestamp_not_passed() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let timestamp = timelock_test.get_timestamp();
+ timelock_test.timelock.queue(timelock_test.get_call(), timestamp);
+ match timelock_test.timelock_safe.execute(timelock_test.get_call(), timestamp) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => {
+ assert_eq!(*panic_data.at(0), TimeLock::Errors::TIMESTAMP_NOT_PASSED);
+ }
+ }
+}
+
+#[test]
+fn test_execute_timestamp_expired() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let timestamp = timelock_test.get_timestamp();
+ timelock_test.timelock.queue(timelock_test.get_call(), timestamp);
+ cheat_block_timestamp(
+ timelock_test.timelock_address,
+ timestamp + TimeLock::GRACE_PERIOD + 1,
+ CheatSpan::TargetCalls(1)
+ );
+ match timelock_test.timelock_safe.execute(timelock_test.get_call(), timestamp) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => {
+ assert_eq!(*panic_data.at(0), TimeLock::Errors::TIMESTAMP_EXPIRED);
+ }
+ }
+}
+
+#[test]
+fn test_execute_success() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let timestamp = timelock_test.get_timestamp();
+ let tx_id = timelock_test.timelock.get_tx_id(timelock_test.get_call(), timestamp);
+ timelock_test.timelock.queue(timelock_test.get_call(), timestamp);
+ timelock_test.erc721.approve(timelock_test.timelock_address, TOKEN_ID);
+ cheat_block_timestamp(timelock_test.timelock_address, timestamp + 1, CheatSpan::TargetCalls(1));
+ let mut spy = spy_events(SpyOn::One(timelock_test.timelock_address));
+ timelock_test.timelock.execute(timelock_test.get_call(), timestamp);
+ spy
+ .assert_emitted(
+ @array![
+ (
+ timelock_test.timelock_address,
+ TimeLock::Event::Execute(
+ TimeLock::Execute { tx_id, call: timelock_test.get_call(), timestamp }
+ )
+ )
+ ]
+ );
+}
+
+#[test]
+fn test_execute_failed() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let timestamp = timelock_test.get_timestamp();
+ timelock_test.timelock.queue(timelock_test.get_call(), timestamp);
+ cheat_block_timestamp(timelock_test.timelock_address, timestamp + 1, CheatSpan::TargetCalls(1));
+ match timelock_test.timelock_safe.execute(timelock_test.get_call(), timestamp) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => {
+ assert_eq!(*panic_data.at(0), ERC721Component::Errors::UNAUTHORIZED);
+ }
+ }
+}
+
+#[test]
+fn test_cancel_only_owner() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let tx_id = timelock_test
+ .timelock
+ .get_tx_id(timelock_test.get_call(), timelock_test.get_timestamp());
+ cheat_caller_address(timelock_test.timelock_address, OTHER(), CheatSpan::TargetCalls(1));
+ match timelock_test.timelock_safe.cancel(tx_id) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => { assert_eq!(*panic_data.at(0), ownable::Errors::UNAUTHORIZED); }
+ }
+}
+
+#[test]
+fn test_cancel_not_queued() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let tx_id = timelock_test
+ .timelock
+ .get_tx_id(timelock_test.get_call(), timelock_test.get_timestamp());
+ match timelock_test.timelock_safe.cancel(tx_id) {
+ Result::Ok(_) => panic_with_felt252('FAIL'),
+ Result::Err(panic_data) => { assert_eq!(*panic_data.at(0), TimeLock::Errors::NOT_QUEUED); }
+ }
+}
+
+#[test]
+fn test_cancel_success() {
+ let timelock_test = TimeLockTestTrait::setup();
+ let tx_id = timelock_test
+ .timelock
+ .queue(timelock_test.get_call(), timelock_test.get_timestamp());
+ let mut spy = spy_events(SpyOn::One(timelock_test.timelock_address));
+ timelock_test.timelock.cancel(tx_id);
+ spy
+ .assert_emitted(
+ @array![
+ (
+ timelock_test.timelock_address,
+ TimeLock::Event::Cancel(TimeLock::Cancel { tx_id })
+ )
+ ]
+ );
+}