add metadata to the fungible staked token

src/fungible_staked_token.cairo

@@ -29,7 +29,10 @@ pub mod FungibleStakedToken {
     use core::num::traits::zero::{Zero};
     use core::option::{OptionTrait};
     use core::traits::{Into, TryInto};
-    use governance::interfaces::erc20::{IERC20, IERC20Dispatcher, IERC20DispatcherTrait};
+    use governance::interfaces::erc20::{
+        IERC20, IERC20Metadata, IERC20MetadataDispatcher, IERC20MetadataDispatcherTrait,
+        IERC20Dispatcher, IERC20DispatcherTrait
+    };
     use governance::staker::{IStakerDispatcher, IStakerDispatcherTrait};
     use starknet::{
         get_caller_address, get_contract_address, get_block_timestamp,
@@ -43,11 +46,18 @@ pub mod FungibleStakedToken {
         delegated_to: LegacyMap<ContractAddress, ContractAddress>,
         balances: LegacyMap<ContractAddress, u128>,
         allowances: LegacyMap<(ContractAddress, ContractAddress), u128>,
+        total_supply: u128,
+        name: felt252,
+        symbol: felt252,
     }
 
     #[constructor]
-    fn constructor(ref self: ContractState, staker: IStakerDispatcher) {
+    fn constructor(
+        ref self: ContractState, staker: IStakerDispatcher, name: felt252, symbol: felt252
+    ) {
         self.staker.write(staker);
+        self.name.write(name);
+        self.symbol.write(symbol);
     }
 
     #[derive(starknet::Event, PartialEq, Debug, Drop)]
@@ -106,8 +116,28 @@ pub mod FungibleStakedToken {
         }
     }
 
+    #[abi(embed_v0)]
+    impl FungibleStakedTokenERC20Metadata of IERC20Metadata<ContractState> {
+        fn name(self: @ContractState) -> felt252 {
+            self.name.read()
+        }
+        fn symbol(self: @ContractState) -> felt252 {
+            self.symbol.read()
+        }
+        fn decimals(self: @ContractState) -> u8 {
+            IERC20MetadataDispatcher {
+                contract_address: IStakerDispatcher { contract_address: self.get_staker() }
+                    .get_token()
+            }
+                .decimals()
+        }
+    }
+
     #[abi(embed_v0)]
     impl FungibleStakedTokenERC20 of IERC20<ContractState> {
+        fn totalSupply(self: @ContractState) -> u256 {
+            self.total_supply.read().into()
+        }
         fn balanceOf(self: @ContractState, account: ContractAddress) -> u256 {
             self.balances.read(account).into()
         }
@@ -198,6 +228,7 @@ pub mod FungibleStakedToken {
             staker.stake(self.delegated_to.read(caller));
 
             self.balances.write(caller, self.balances.read(caller) + amount);
+            self.total_supply.write(self.total_supply.read() + amount);
         }
 
         fn deposit(ref self: ContractState) {
@@ -214,6 +245,7 @@ pub mod FungibleStakedToken {
             let caller = get_caller_address();
 
             self.balances.write(caller, self.balances.read(caller) - amount);
+            self.total_supply.write(self.total_supply.read() - amount);
 
             self.staker.read().withdraw_amount(self.delegated_to.read(caller), caller, amount);
         }

src/fungible_staked_token_test.cairo

@@ -24,9 +24,11 @@ use starknet::{
 };
 
 
-fn deploy(staker: IStakerDispatcher) -> IFungibleStakedTokenDispatcher {
+fn deploy(
+    staker: IStakerDispatcher, name: felt252, symbol: felt252
+) -> IFungibleStakedTokenDispatcher {
     let mut constructor_args: Array<felt252> = ArrayTrait::new();
-    Serde::serialize(@(staker), ref constructor_args);
+    Serde::serialize(@(staker, name, symbol), ref constructor_args);
 
     let (address, _) = deploy_syscall(
         FungibleStakedToken::TEST_CLASS_HASH.try_into().unwrap(), 0, constructor_args.span(), true
@@ -37,7 +39,7 @@ fn deploy(staker: IStakerDispatcher) -> IFungibleStakedTokenDispatcher {
 
 fn setup() -> (IStakerDispatcher, IERC20Dispatcher, IFungibleStakedTokenDispatcher) {
     let (staker, token) = setup_staker(1000000);
-    let fungible_staked_token = deploy(staker);
+    let fungible_staked_token = deploy(staker, 'Staked Token', 'vSTT');
 
     (staker, token, fungible_staked_token)
 }

src/interfaces/erc20.cairo

@@ -2,6 +2,7 @@ use starknet::{ContractAddress};
 
 #[starknet::interface]
 pub(crate) trait IERC20<TContractState> {
+    fn totalSupply(self: @TContractState) -> u256;
     fn balanceOf(self: @TContractState, account: ContractAddress) -> u256;
     fn allowance(self: @TContractState, owner: ContractAddress, spender: ContractAddress) -> u256;
     fn transfer(ref self: TContractState, recipient: ContractAddress, amount: u256) -> bool;
@@ -10,3 +11,10 @@ pub(crate) trait IERC20<TContractState> {
     ) -> bool;
     fn approve(ref self: TContractState, spender: ContractAddress, amount: u256) -> bool;
 }
+
+#[starknet::interface]
+pub(crate) trait IERC20Metadata<TContractState> {
+    fn name(self: @TContractState) -> felt252;
+    fn symbol(self: @TContractState) -> felt252;
+    fn decimals(self: @TContractState) -> u8;
+}

src/test/test_token.cairo

@@ -11,6 +11,7 @@ pub(crate) mod TestToken {
     struct Storage {
         balances: LegacyMap<ContractAddress, u256>,
         allowances: LegacyMap<(ContractAddress, ContractAddress), u256>,
+        total_supply: u256,
     }
 
     #[derive(starknet::Event, PartialEq, Debug, Drop)]
@@ -29,11 +30,15 @@ pub(crate) mod TestToken {
     #[constructor]
     fn constructor(ref self: ContractState, recipient: ContractAddress, amount: u256) {
         self.balances.write(recipient, amount);
-        self.emit(Transfer { from: Zero::zero(), to: recipient, value: amount })
+        self.emit(Transfer { from: Zero::zero(), to: recipient, value: amount });
+        self.total_supply.write(amount);
     }
 
     #[abi(embed_v0)]
     impl IERC20Impl of IERC20<ContractState> {
+        fn totalSupply(self: @ContractState) -> u256 {
+            self.total_supply.read()
+        }
         fn balanceOf(self: @ContractState, account: ContractAddress) -> u256 {
             self.balances.read(account).into()
         }