Vesting Component (#1116)

* Add ERC20 utils

* Add finance module and vesting submodule

* Add interface for Vesting Component

* Implement Vesting Component

* Implement VestingWallet preset

* Run linter

* Update VestingSchedule trait to expect contract state as input param

* Add mocks for vesting tests

* Add tests for Vesting component

* Add tests for Vesting preset

* Add in-code documentation

* Add entry to changelog

* Fix linter issues

* Fix tests

* Fix batch of review issues

* Lint files

* Move default TestData init to helper function

* Fix review issues

* Fix review issues

* Add test_release_after_ownership_transferred test case

* Change the order of the events

* Fix minor review issues

* Fix compilation issues

* Add readme and update Scarb.toml

* Add tests for failed transfer assertion

* Fix readme, remove vesting keyword, add missing trait import

* Fix typo

* Make final review fixes

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - `into_base_16_string_no_padding` function to the test helpers (#1137)
+- Vesting component and VestingWallet preset (#334)
 
 ### Changed
 

Scarb.lock

@@ -7,6 +7,7 @@ version = "0.16.0"
 dependencies = [
  "openzeppelin_access",
  "openzeppelin_account",
+ "openzeppelin_finance",
  "openzeppelin_governance",
  "openzeppelin_introspection",
  "openzeppelin_merkle_tree",
@@ -42,6 +43,17 @@ dependencies = [
  "snforge_std",
 ]
 
+[[package]]
+name = "openzeppelin_finance"
+version = "0.16.0"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_test_common",
+ "openzeppelin_testing",
+ "openzeppelin_token",
+ "snforge_std",
+]
+
 [[package]]
 name = "openzeppelin_governance"
 version = "0.16.0"
@@ -72,6 +84,7 @@ version = "0.16.0"
 dependencies = [
  "openzeppelin_access",
  "openzeppelin_account",
+ "openzeppelin_finance",
  "openzeppelin_introspection",
  "openzeppelin_test_common",
  "openzeppelin_testing",
@@ -94,6 +107,7 @@ version = "0.16.0"
 dependencies = [
  "openzeppelin_access",
  "openzeppelin_account",
+ "openzeppelin_finance",
  "openzeppelin_testing",
  "openzeppelin_token",
  "openzeppelin_upgrades",

Scarb.toml

@@ -2,6 +2,7 @@
 members = [
     "packages/access",
     "packages/account",
+    "packages/finance",
     "packages/governance",
     "packages/introspection",
     "packages/merkle_tree",
@@ -47,6 +48,7 @@ snforge_std = "0.30.0"
 starknet.workspace = true
 openzeppelin_access = { path = "packages/access" }
 openzeppelin_account = { path = "packages/account" }
+openzeppelin_finance = { path = "packages/finance" }
 openzeppelin_governance = { path = "packages/governance" }
 openzeppelin_introspection = { path = "packages/introspection" }
 openzeppelin_merkle_tree = { path = "packages/merkle_tree" }

packages/account/src/utils.cairo

@@ -22,7 +22,7 @@ pub fn execute_calls(mut calls: Array<Call>) -> Array<Span<felt252>> {
                 let _res = execute_single_call(call);
                 res.append(_res);
             },
-            Option::None(_) => { break (); },
+            Option::None => { break (); },
         };
     };
     res

packages/finance/README.md

@@ -0,0 +1,11 @@
+## Finance
+
+This crate includes primitives for financial systems.
+
+### Interfaces
+
+- `IVesting`
+
+### Components
+
+- `VestingComponent`

packages/finance/Scarb.toml

@@ -0,0 +1,39 @@
+[package]
+name = "openzeppelin_finance"
+readme = "README.md"
+keywords = [
+    "openzeppelin",
+    "starknet",
+    "contracts",
+    "finance",
+    "vesting"
+]
+version.workspace = true
+edition.workspace = true
+cairo-version.workspace = true
+scarb-version.workspace = true
+authors.workspace = true
+description.workspace = true
+documentation.workspace = true
+repository.workspace = true
+license-file.workspace = true
+
+[tool]
+fmt.workspace = true
+
+[dependencies]
+starknet.workspace = true
+openzeppelin_access = { path = "../access" }
+openzeppelin_token = { path = "../token" }
+
+[dev-dependencies]
+snforge_std.workspace = true
+openzeppelin_testing = { path = "../testing" }
+openzeppelin_test_common = { path = "../test_common" }
+
+[lib]
+
+[[target.starknet-contract]]
+allowed-libfuncs-list.name = "experimental"
+sierra = true
+casm = false

packages/finance/src/lib.cairo

@@ -0,0 +1,2 @@
+mod tests;
+pub mod vesting;

packages/finance/src/tests.cairo

@@ -0,0 +1,7 @@
+#[cfg(test)]
+pub(crate) mod common;
+pub(crate) mod mocks;
+#[cfg(test)]
+mod test_vesting_linear;
+#[cfg(test)]
+mod test_vesting_steps;

packages/finance/src/tests/common.cairo

@@ -0,0 +1,71 @@
+use openzeppelin_finance::vesting::interface::IVestingDispatcher;
+use openzeppelin_testing as utils;
+use openzeppelin_testing::constants;
+use openzeppelin_token::erc20::interface::IERC20Dispatcher;
+use openzeppelin_utils::serde::SerializedAppend;
+use starknet::{ContractAddress, SyscallResultTrait};
+
+#[derive(Copy, Drop)]
+pub(crate) enum VestingStrategy {
+    Linear,
+    Steps: u64
+}
+
+#[derive(Copy, Drop)]
+pub(crate) struct TestData {
+    pub strategy: VestingStrategy,
+    pub total_allocation: u256,
+    pub beneficiary: ContractAddress,
+    pub start: u64,
+    pub duration: u64,
+    pub cliff_duration: u64
+}
+
+fn deploy_vesting_mock(data: TestData) -> IVestingDispatcher {
+    let contract_address = match data.strategy {
+        VestingStrategy::Linear => {
+            let mut calldata = array![];
+            calldata.append_serde(data.beneficiary);
+            calldata.append_serde(data.start);
+            calldata.append_serde(data.duration);
+            calldata.append_serde(data.cliff_duration);
+            utils::declare_and_deploy("LinearVestingMock", calldata)
+        },
+        VestingStrategy::Steps(total_steps) => {
+            let mut calldata = array![];
+            calldata.append_serde(total_steps);
+            calldata.append_serde(data.beneficiary);
+            calldata.append_serde(data.start);
+            calldata.append_serde(data.duration);
+            calldata.append_serde(data.cliff_duration);
+            utils::declare_and_deploy("StepsVestingMock", calldata)
+        }
+    };
+    IVestingDispatcher { contract_address }
+}
+
+fn deploy_erc20_mock(recipient: ContractAddress, initial_supply: u256) -> IERC20Dispatcher {
+    let mut calldata = array![];
+    calldata.append_serde(constants::NAME());
+    calldata.append_serde(constants::SYMBOL());
+    calldata.append_serde(initial_supply);
+    calldata.append_serde(recipient);
+
+    let contract_address = utils::declare_and_deploy("ERC20Mock", calldata);
+    IERC20Dispatcher { contract_address }
+}
+
+pub(crate) fn setup(data: TestData) -> (IVestingDispatcher, ContractAddress) {
+    let vesting = deploy_vesting_mock(data);
+    let token = deploy_erc20_mock(vesting.contract_address, data.total_allocation);
+    (vesting, token.contract_address)
+}
+
+pub(crate) fn set_transfer_to_fail(token: ContractAddress, should_fail: bool) {
+    let mut calldata = array![];
+    calldata.append_serde(true);
+    starknet::syscalls::call_contract_syscall(
+        token, selector!("set_transfer_should_fail"), calldata.span()
+    )
+        .unwrap_syscall();
+}

packages/finance/src/tests/mocks.cairo

@@ -0,0 +1,2 @@
+pub(crate) mod erc20_mocks;
+pub(crate) mod vesting_mocks;

packages/finance/src/tests/mocks/erc20_mocks.cairo

@@ -0,0 +1,91 @@
+#[starknet::contract]
+pub(crate) mod ERC20Mock {
+    use openzeppelin_token::erc20::interface::IERC20;
+    use openzeppelin_token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+
+    #[abi(embed_v0)]
+    impl ERC20MetadataImpl = ERC20Component::ERC20MetadataImpl<ContractState>;
+
+    impl InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        transfer_should_fail: bool,
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        name: ByteArray,
+        symbol: ByteArray,
+        initial_supply: u256,
+        recipient: ContractAddress
+    ) {
+        self.erc20.initializer(name, symbol);
+        self.erc20.mint(recipient, initial_supply);
+    }
+
+    #[abi(embed_v0)]
+    impl ERC20Impl of IERC20<ContractState> {
+        fn total_supply(self: @ContractState) -> u256 {
+            self.erc20.total_supply()
+        }
+
+        fn balance_of(self: @ContractState, account: ContractAddress) -> u256 {
+            self.erc20.balance_of(account)
+        }
+
+        fn allowance(
+            self: @ContractState, owner: ContractAddress, spender: ContractAddress
+        ) -> u256 {
+            self.erc20.allowance(owner, spender)
+        }
+
+        fn transfer(ref self: ContractState, recipient: ContractAddress, amount: u256) -> bool {
+            if self.transfer_should_fail.read() {
+                false
+            } else {
+                self.erc20.transfer(recipient, amount)
+            }
+        }
+
+        fn transfer_from(
+            ref self: ContractState,
+            sender: ContractAddress,
+            recipient: ContractAddress,
+            amount: u256
+        ) -> bool {
+            if self.transfer_should_fail.read() {
+                false
+            } else {
+                self.erc20.transfer_from(sender, recipient, amount)
+            }
+        }
+
+        fn approve(ref self: ContractState, spender: ContractAddress, amount: u256) -> bool {
+            self.erc20.approve(spender, amount)
+        }
+    }
+
+    #[generate_trait]
+    #[abi(per_item)]
+    impl ExternalImpl of ExternalTrait {
+        #[external(v0)]
+        fn set_transfer_should_fail(ref self: ContractState, should_fail: bool) {
+            self.transfer_should_fail.write(should_fail);
+        }
+    }
+}