ERC20 contracts addes

contracts/cairo/ERC20/BridgedERC20_Mintable.cairo

@@ -0,0 +1,158 @@
+%lang starknet
+%builtins pedersen range_check
+
+from starkware.starknet.common.syscalls import get_caller_address
+from starkware.cairo.common.cairo_builtins import HashBuiltin
+from starkware.cairo.common.math import assert_not_zero
+from starkware.cairo.common.uint256 import (
+    Uint256, uint256_add, uint256_sub, uint256_le, uint256_lt, uint256_check
+)
+
+from ERC20_base import (
+    ERC20_initializer,
+    ERC20_allowances,
+    ERC20_approve,
+    ERC20_transfer,
+    ERC20_mint,
+    ERC20_burn
+)
+
+from Ownable_base import (
+    Ownable_initializer,
+    Ownable_only_owner
+)
+
+@storage_var
+func l1ERC20Address() -> (address: felt):
+end
+
+@constructor
+func constructor{
+        syscall_ptr: felt*, 
+        pedersen_ptr: HashBuiltin*,
+        range_check_ptr
+    }(
+        name: felt,
+        symbol: felt,
+        initial_supply: Uint256,
+        recipient: felt,
+        owner: felt,
+        _l1ERC20Address:felt
+    ):
+    ERC20_initializer(name, symbol, initial_supply, recipient)
+    Ownable_initializer(owner)
+    l1ERC20Address.write(_l1ERC20Address)
+    return ()
+end
+
+#
+# Externals
+#
+
+@external
+func transfer{
+        syscall_ptr : felt*, 
+        pedersen_ptr : HashBuiltin*,
+        range_check_ptr
+    }(recipient: felt, amount: Uint256) -> (success: felt):
+    let (sender) = get_caller_address()
+    ERC20_transfer(sender, recipient, amount)
+
+    # Cairo equivalent to 'return (true)'
+    return (1)
+end
+
+@external
+func transferFrom{
+        syscall_ptr : felt*, 
+        pedersen_ptr : HashBuiltin*,
+        range_check_ptr
+    }(
+        sender: felt, 
+        recipient: felt, 
+        amount: Uint256
+    ) -> (success: felt):
+    alloc_locals
+    let (local caller) = get_caller_address()
+    let (local caller_allowance: Uint256) = ERC20_allowances.read(owner=sender, spender=caller)
+
+    # validates amount <= caller_allowance and returns 1 if true   
+    let (enough_allowance) = uint256_le(amount, caller_allowance)
+    assert_not_zero(enough_allowance)
+
+    ERC20_transfer(sender, recipient, amount)
+
+    # subtract allowance
+    let (new_allowance: Uint256) = uint256_sub(caller_allowance, amount)
+    ERC20_allowances.write(sender, caller, new_allowance)
+
+    # Cairo equivalent to 'return (true)'
+    return (1)
+end
+
+@external
+func approve{
+        syscall_ptr : felt*, 
+        pedersen_ptr : HashBuiltin*,
+        range_check_ptr
+    }(spender: felt, amount: Uint256) -> (success: felt):
+    let (caller) = get_caller_address()
+    ERC20_approve(caller, spender, amount)
+
+    # Cairo equivalent to 'return (true)'
+    return (1)
+end
+
+@external
+func increaseAllowance{
+        syscall_ptr : felt*, 
+        pedersen_ptr : HashBuiltin*,
+        range_check_ptr
+    }(spender: felt, added_value: Uint256) -> (success: felt):
+    alloc_locals
+    uint256_check(added_value)
+    let (local caller) = get_caller_address()
+    let (local current_allowance: Uint256) = ERC20_allowances.read(caller, spender)
+
+    # add allowance
+    let (local new_allowance: Uint256, is_overflow) = uint256_add(current_allowance, added_value)
+    assert (is_overflow) = 0
+
+    ERC20_approve(caller, spender, new_allowance)
+
+    # Cairo equivalent to 'return (true)'
+    return (1)
+end
+
+@external
+func decreaseAllowance{
+        syscall_ptr : felt*, 
+        pedersen_ptr : HashBuiltin*,
+        range_check_ptr
+    }(spender: felt, subtracted_value: Uint256) -> (success: felt):
+    alloc_locals
+    uint256_check(subtracted_value)
+    let (local caller) = get_caller_address()
+    let (local current_allowance: Uint256) = ERC20_allowances.read(owner=caller, spender=spender)
+    let (local new_allowance: Uint256) = uint256_sub(current_allowance, subtracted_value)
+
+    # validates new_allowance < current_allowance and returns 1 if true   
+    let (enough_allowance) = uint256_lt(new_allowance, current_allowance)
+    assert_not_zero(enough_allowance)
+
+    ERC20_approve(caller, spender, new_allowance)
+
+    # Cairo equivalent to 'return (true)'
+    return (1)
+end
+
+@external
+func mint{
+        syscall_ptr: felt*,
+        pedersen_ptr: HashBuiltin*,
+        range_check_ptr
+    }(to: felt, amount: Uint256):
+    Ownable_only_owner()
+    ERC20_mint(to, amount)
+    return ()
+end