Guía Cairo 1 Test

Author: Nadai2010

README.md

@@ -1078,7 +1078,7 @@ Aquí deberemos pasar los argumentos del constructor, en este caso pasamos `name
 
 
 ```bash
-starknet deploy --class_hash 0x0731affa00504b8311180a11585108f15296bf91b024c76a96057959c608d037 --inputs 336641417577 5128521 18 1000000000 0 1795950254530259382270168937734171348535331377400385313842303804539016002736 --account Nadai
+starknet deploy --class_hash 0x0731affa00504b8311180a11585108f15296bf91b024c76a96057959c608d037 --inputs 336641417577 5128521 18 --account Nadai
 ```
 
 Si todo ha ido bien deberá salir la transacción con la diección del contrato que ha desplagado.

src/ERC20.cairo

@@ -1,166 +1,126 @@
+use starknet::ContractAddress;
+
+trait IERC20 {
+    fn name() -> felt252;
+    fn symbol() -> felt252;
+    fn decimals() -> u8;
+    fn total_supply() -> u256;
+    fn balanceOf(account: ContractAddress) -> u256;
+    fn allowance(owner: ContractAddress, spender: ContractAddress) -> u256;
+    fn transfer(recipient: ContractAddress, amount: u256) -> bool;
+    fn transferFrom(sender: ContractAddress, recipient: ContractAddress, amount: u256) -> bool;
+    fn approve(spender: ContractAddress, amount: u256) -> bool;
+}
+
 #[contract]
-mod ERC20Contract {
-    ////////////////////////////////
-    // library imports
-    ////////////////////////////////
-    use zeroable::Zeroable;
+mod ERC20 {
     use starknet::get_caller_address;
     use starknet::ContractAddress;
-    use starknet::contract_address_try_from_felt252;
-    use traits::Into;
-    use traits::TryInto;
-    use option::OptionTrait;
-
-    ////////////////////////////////
-    // storage variables
-    ////////////////////////////////
+    use zeroable::Zeroable;
+    use super::IERC20;
+
     struct Storage {
-        name: felt252,
-        symbol: felt252,
-        decimals: u8,
-        total_supply: u256,
-        balances: LegacyMap::<ContractAddress, u256>,
-        allowances: LegacyMap::<(ContractAddress, ContractAddress), u256>,
+        _name: felt252,
+        _symbol: felt252,
+        _decimals: u8,
+        _total_supply: u256,
+        _balances: LegacyMap<ContractAddress, u256>,
+        _allowances: LegacyMap<(ContractAddress, ContractAddress), u256>,
     }
 
-    ////////////////////////////////
-    // Transfer event emitted on token transfer
-    ////////////////////////////////
     #[event]
     fn Transfer(from: ContractAddress, to: ContractAddress, value: u256) {}
 
-    ////////////////////////////////
-    // Approval event emitted on token approval
-    ////////////////////////////////
     #[event]
     fn Approval(owner: ContractAddress, spender: ContractAddress, value: u256) {}
 
-    ////////////////////////////////
-    // Constructor - initialized on deployment
-    ////////////////////////////////
     #[constructor]
-    fn constructor(
-        name_: felt252,
-        symbol_: felt252,
-        decimals_: u8,
-        initial_supply: u256,
-        recipient: ContractAddress
-    ){
-        name::write(name_);
-        symbol::write(symbol_);
-        decimals::write(decimals_);
-        assert(recipient.is_non_zero(), 'ERC20: mint to the 0 address');
-        total_supply::write(initial_supply);
-        balances::write(recipient, initial_supply);
-        Transfer(Zeroable::zero(), recipient, initial_supply);
+    fn constructor(name: felt252, symbol: felt252, decimals: u8) {
+        _name::write(name);
+        _symbol::write(symbol);
+        _decimals::write(decimals);
     }
 
-    ////////////////////////////////
-    // get_name function returns token name
-    ////////////////////////////////
     #[view]
-    fn get_name() -> felt252 {
-        name::read()
+    fn name() -> felt252 {
+        _name::read()
     }
 
-    ////////////////////////////////
-    // get_symbol function returns token symbol
-    ////////////////////////////////
     #[view]
-    fn get_symbol() -> felt252 {
-        symbol::read()
+    fn symbol() -> felt252 {
+        _symbol::read()
     }
 
-    ////////////////////////////////
-    // get_decimals function returns token decimals
-    ////////////////////////////////
     #[view]
-    fn get_decimals() -> u8 {
-        decimals::read()
+    fn decimals() -> u8 {
+        _decimals::read()
     }
 
-    ////////////////////////////////
-    // get_total_supply function returns token total total_supply
-    ////////////////////////////////
     #[view]
-    fn get_total_supply() -> u256 {
-        total_supply::read()
+    fn total_supply() -> u256 {
+        _total_supply::read()
     }
 
-    ////////////////////////////////
-    // balance_of function returns balance of an account
-    ////////////////////////////////
     #[view]
-    fn balance_of(account: ContractAddress) -> u256 {
-        balances::read(account)
+    fn balanceOf(account: ContractAddress) -> u256 {
+        _balances::read(account)
     }
 
-    ////////////////////////////////
-    // allowance function returns total allowamnce given to an account
-    ////////////////////////////////
     #[view]
     fn allowance(owner: ContractAddress, spender: ContractAddress) -> u256 {
-        allowances::read((owner, spender))
+        _allowances::read((owner, spender))
     }
 
-    ////////////////////////////////
-    // transfer function for transferring tokens from one account to another
-    ////////////////////////////////
     #[external]
-    fn transfer(recipient: ContractAddress, amount: u256) {
-        let sender = get_caller_address();
-        transfer_helper(sender, recipient, amount);
+    fn approve(spender: ContractAddress, amount: u256) -> bool {
+        let owner = get_caller_address();
+
+        _allowances::write((owner, spender), amount);
+
+        Approval(owner, spender, amount);
+
+        true
     }
 
-    ////////////////////////////////
-    // transfer_from function for transferring tokens on behalf of another user
-    ////////////////////////////////
     #[external]
-    fn transfer_from(sender: ContractAddress, recipient: ContractAddress, amount: u256) {
-        let caller = get_caller_address();
-        spend_allowance(sender, caller, amount);
-        transfer_helper(sender, recipient, amount);
+    fn mint(amount: u256) {
+        let sender = get_caller_address();
+
+        _total_supply::write(_total_supply::read() + amount);
+        _balances::write(sender, _balances::read(sender) + amount);
     }
 
-    ////////////////////////////////
-    // approve function for approving another user to spend from an account balance
-    ////////////////////////////////
     #[external]
-    fn approve(spender: ContractAddress, amount: u256) {
-        let caller = get_caller_address();
-        approve_helper(caller, spender, amount);
-    }
+    fn transfer(to: ContractAddress, amount: u256) -> bool {
+        let from = get_caller_address();
+
+        _balances::write(from, _balances::read(from) - amount);
+        _balances::write(to, _balances::read(to) + amount);
+
+        Transfer(from, to, amount);
 
-    ////////////////////////////////
-    // internal function that contains the tranfer logic
-    ////////////////////////////////
-    fn transfer_helper(sender: ContractAddress, recipient: ContractAddress, amount: u256) {
-        assert(!sender.is_zero(), 'ERC20: transfer from 0');
-        assert(!recipient.is_zero(), 'ERC20: transfer to 0');
-        balances::write(sender, balances::read(sender) - amount);
-        balances::write(recipient, balances::read(recipient) + amount);
-        Transfer(sender, recipient, amount);
+        true
     }
 
-    ////////////////////////////////
-    // internal function implementing checks against unlimited allowance
-    ////////////////////////////////
-    fn spend_allowance(owner: ContractAddress, spender: ContractAddress, amount: u256) {
-        let current_allowance = allowances::read((owner, spender));
+    #[external]
+    fn transferFrom(from: ContractAddress, to: ContractAddress, amount: u256) -> bool {
+        let caller = get_caller_address();
+        let allowed: u256 = _allowances::read((from, caller));
+
         let ONES_MASK = 0xffffffffffffffffffffffffffffffff_u128;
-        let is_unlimited_allowance =
-            current_allowance.low == ONES_MASK & current_allowance.high == ONES_MASK;
-        if !is_unlimited_allowance {
-            approve_helper(owner, spender, current_allowance - amount);
+
+        let is_max = (allowed.low == ONES_MASK) & (allowed.high == ONES_MASK);
+
+        if !is_max {
+            _allowances::write((from, caller), allowed - amount);
+            Approval(from, caller, allowed - amount);
         }
-    }
 
-    ////////////////////////////////
-    // internal function containing the approval logic
-    ////////////////////////////////
-    fn approve_helper(owner: ContractAddress, spender: ContractAddress, amount: u256) {
-        assert(!spender.is_zero(), 'ERC20: approve from 0');
-        allowances::write((owner, spender), amount);
-        Approval(owner, spender, amount);
+        _balances::write(from, _balances::read(from) - amount);
+        _balances::write(to, _balances::read(to) + amount);
+
+        Transfer(from, to, amount);
+
+        true
     }
 }