Refactor directory structure

docs/ERC721.md

@@ -250,7 +250,7 @@ Following the [contracts extensibility pattern](Extensibility.md), this implemen
 Just be sure that the exposed `external` methods invoke their imported function logic a la `approve` invokes `ERC721.approve`. As an example, see below.
 
 ```python
-from openzeppelin.token.erc721.library.ERC721 import ERC721
+from openzeppelin.token.erc721.library import ERC721
 
 @external
 func approve{

docs/Introspection.md

@@ -32,7 +32,7 @@ In order to ensure EVM/StarkNet compatibility, interface identifiers are not cal
 For a contract to declare its support for a given interface, the contract should import the ERC165 library and register its support. It's recommended to register interface support upon contract deployment through a constructor either directly or indirectly (as an initializer) like this:
 
 ```cairo
-from openzeppelin.introspection.library.ERC165 import ERC165
+from openzeppelin.introspection.erc165.library import ERC165
 
 INTERFACE_ID = 0x12345678
 
@@ -52,7 +52,7 @@ end
 To query a target contract's support for an interface, the querying contract should call `supportsInterface` through IERC165 with the target contract's address and the queried interface id. Here's an example:
 
 ```cairo
-from openzeppelin.introspection.interfaces.IERC165 import IERC165
+from openzeppelin.introspection.erc165.IERC165 import IERC165
 
 INTERFACE_ID = 0x12345678
 

docs/Security.md

@@ -19,7 +19,7 @@ The Initializable library provides a simple mechanism that mimics the functional
 The recommended pattern with Initializable is to include a check that the Initializable state is `False` and invoke `initialize` in the target function like this:
 
 ```cairo
-from openzeppelin.security.library.Initializable import Initializable
+from openzeppelin.security.initializable.library import Initializable
 
 @external
 func foo{
@@ -44,7 +44,7 @@ The Pausable library allows contracts to implement an emergency stop mechanism.
 To use the Pausable library, the contract should include `pause` and `unpause` functions (which should be protected). For methods that should be available only when not paused, insert `assert_not_paused`. For methods that should be available only when paused, insert `assert_paused`. For example:
 
 ```cairo
-from openzeppelin.security.library.Pausable import Pausable
+from openzeppelin.security.pausable.library import Pausable
 
 @external
 func whenNotPaused{
@@ -85,7 +85,7 @@ A [reentrancy attack](https://gus-tavo-guim.medium.com/reentrancy-attack-on-smar
 Since Cairo does not support modifiers like Solidity, the [`reentrancy_guard`](../src/openzeppelin/security/reentrancyguard/library.cairo) library exposes two methods `_start` and `_end` to protect functions against reentrancy attacks. The protected function must call `ReentrancyGuard._start` before the first function statement, and `ReentrancyGuard._end` before the return statement, as shown below:
 
 ```cairo
-from openzeppelin.security.library.ReentrancyGuard import ReentrancyGuard
+from openzeppelin.security.reentrancyguard.library import ReentrancyGuard
 
 func test_function{
         syscall_ptr : felt*,
@@ -108,7 +108,7 @@ The SafeUint256 namespace in the [SafeMath library](../src/openzeppelin/security
 Using SafeUint256 methods is rather straightforward. Simply import SafeUint256 and insert the arithmetic method like this:
 
 ```cairo
-from openzeppelin.security.library.SafeMath import SafeUint256
+from openzeppelin.security.safemath.library import SafeUint256
 
 func add_two_uints{
         syscall_ptr: felt*,

src/openzeppelin/access/accesscontrol/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Cairo Contracts v0.2.0 (access/accesscontrol/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (access/accesscontrol/library.cairo)
 
 %lang starknet
 

src/openzeppelin/access/ownable/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (access/ownable/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (access/ownable/library.cairo)
 
 %lang starknet
 

src/openzeppelin/account/presets/Account.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (account/presets/Account.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (account/presets/Account.cairo)
 
 %lang starknet
 

src/openzeppelin/account/presets/AddressRegistry.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (account/presets/AddressRegistry.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (account/presets/AddressRegistry.cairo)
 
 %lang starknet
 

src/openzeppelin/account/presets/EthAccount.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (account/presets/EthAccount.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (account/presets/EthAccount.cairo)
 
 %lang starknet
 from starkware.cairo.common.cairo_builtins import HashBuiltin, SignatureBuiltin, BitwiseBuiltin

src/openzeppelin/introspection/erc165/IERC165.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (introspection/erc165/IERC165.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (introspection/erc165/IERC165.cairo)
 
 %lang starknet
 

src/openzeppelin/introspection/erc165/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (introspection/erc165/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (introspection/erc165/library.cairo)
 
 %lang starknet
 

src/openzeppelin/proxy/library.cairo

@@ -0,0 +1,131 @@
+# SPDX-License-Identifier: MIT
+# OpenZeppelin Contracts for Cairo v0.2.1 (upgrades/proxy/library.cairo)
+
+%lang starknet
+
+from starkware.starknet.common.syscalls import get_caller_address
+from starkware.cairo.common.cairo_builtins import HashBuiltin
+from starkware.cairo.common.bool import TRUE, FALSE
+from starkware.cairo.common.math import assert_not_zero
+
+#
+# Events
+#
+
+@event
+func Upgraded(implementation: felt):
+end
+
+@event
+func AdminChanged(previousAdmin: felt, newAdmin: felt):
+end
+
+#
+# Storage variables
+#
+
+@storage_var
+func Proxy_implementation_hash() -> (class_hash: felt):
+end
+
+@storage_var
+func Proxy_admin() -> (proxy_admin: felt):
+end
+
+@storage_var
+func Proxy_initialized() -> (initialized: felt):
+end
+
+namespace Proxy:
+    #
+    # Initializer
+    #
+
+    func initializer{
+            syscall_ptr: felt*,
+            pedersen_ptr: HashBuiltin*,
+            range_check_ptr
+        }(proxy_admin: felt):
+        let (initialized) = Proxy_initialized.read()
+        with_attr error_message("Proxy: contract already initialized"):
+            assert initialized = FALSE
+        end
+
+        Proxy_initialized.write(TRUE)
+        _set_admin(proxy_admin)
+        return ()
+    end
+
+    #
+    # Guards
+    #
+
+    func assert_only_admin{
+            syscall_ptr: felt*,
+            pedersen_ptr: HashBuiltin*,
+            range_check_ptr
+        }():
+        let (caller) = get_caller_address()
+        let (admin) = Proxy_admin.read()
+        with_attr error_message("Proxy: caller is not admin"):
+            assert admin = caller
+        end
+        return ()
+    end
+
+    #
+    # Getters
+    #
+
+    func get_implementation_hash{
+            syscall_ptr: felt*,
+            pedersen_ptr: HashBuiltin*,
+            range_check_ptr
+        }() -> (implementation: felt):
+        let (implementation) = Proxy_implementation_hash.read()
+        return (implementation)
+    end
+
+    func get_admin{
+            syscall_ptr: felt*,
+            pedersen_ptr: HashBuiltin*,
+            range_check_ptr
+        }() -> (admin: felt):
+        let (admin) = Proxy_admin.read()
+        return (admin)
+    end
+
+    #
+    # Unprotected
+    #
+
+    func _set_admin{
+            syscall_ptr: felt*,
+            pedersen_ptr: HashBuiltin*,
+            range_check_ptr
+        }(new_admin: felt):
+        let (previous_admin) = get_admin()
+        Proxy_admin.write(new_admin)
+        AdminChanged.emit(previous_admin, new_admin)
+        return ()
+    end
+
+    #
+    # Upgrade
+    #
+
+    func _set_implementation_hash{
+            syscall_ptr: felt*,
+            pedersen_ptr: HashBuiltin*,
+            range_check_ptr
+        }(new_implementation: felt):
+        with_attr error_message("Proxy: implementation hash cannot be zero"):
+            assert_not_zero(new_implementation)
+        end
+
+        Proxy_implementation_hash.write(new_implementation)
+        Upgraded.emit(new_implementation)
+        return ()
+    end
+
+end

src/openzeppelin/proxy/presets/Proxy.cairo

@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: MIT
+# OpenZeppelin Contracts for Cairo v0.2.1 (upgrades/proxy/presets/Proxy.cairo)
+
+%lang starknet
+
+from starkware.cairo.common.cairo_builtins import HashBuiltin
+from starkware.starknet.common.syscalls import (
+    library_call,
+    library_call_l1_handler
+)
+from openzeppelin.upgrades.proxy.library import Proxy
+
+#
+# Constructor
+#
+
+@constructor
+func constructor{
+        syscall_ptr: felt*,
+        pedersen_ptr: HashBuiltin*,
+        range_check_ptr
+    }(implementation_hash: felt):
+    Proxy._set_implementation_hash(implementation_hash)
+    return ()
+end
+
+#
+# Fallback functions
+#
+
+@external
+@raw_input
+@raw_output
+func __default__{
+        syscall_ptr: felt*,
+        pedersen_ptr: HashBuiltin*,
+        range_check_ptr
+    }(
+        selector: felt,
+        calldata_size: felt,
+        calldata: felt*
+    ) -> (
+        retdata_size: felt,
+        retdata: felt*
+    ):
+    let (class_hash) = Proxy.get_implementation_hash()
+
+    let (retdata_size: felt, retdata: felt*) = library_call(
+        class_hash=class_hash,
+        function_selector=selector,
+        calldata_size=calldata_size,
+        calldata=calldata,
+    )
+    return (retdata_size=retdata_size, retdata=retdata)
+end
+
+
+@l1_handler
+@raw_input
+func __l1_default__{
+        syscall_ptr: felt*,
+        pedersen_ptr: HashBuiltin*,
+        range_check_ptr
+    }(
+        selector: felt,
+        calldata_size: felt,
+        calldata: felt*
+    ):
+    let (class_hash) = Proxy.get_implementation_hash()
+
+    library_call_l1_handler(
+        class_hash=class_hash,
+        function_selector=selector,
+        calldata_size=calldata_size,
+        calldata=calldata,
+    )
+    return ()
+end

src/openzeppelin/security/initializable/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (security/initializable/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (security/initializable/library.cairo)
 
 %lang starknet
 

src/openzeppelin/security/pausable/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (security/pausable/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (security/pausable/library.cairo)
 
 %lang starknet
 

src/openzeppelin/security/reentrancyguard/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (security/reentrancyguard/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (security/reentrancyguard/library.cairo)
 
 %lang starknet
 

src/openzeppelin/security/safemath/library.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (security/safemath/library.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (security/safemath/library.cairo)
 
 %lang starknet
 

src/openzeppelin/token/erc20/IERC20.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (token/erc20/IERC20.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (token/erc20/IERC20.cairo)
 
 %lang starknet
 

src/openzeppelin/token/erc20/library.cairo

@@ -9,8 +9,8 @@ from starkware.cairo.common.math import assert_not_zero, assert_lt
 from starkware.cairo.common.bool import FALSE
 from starkware.cairo.common.uint256 import Uint256, uint256_check, uint256_eq, uint256_not
 
-from openzeppelin.utils.constants.library import UINT8_MAX
 from openzeppelin.security.safemath.library import SafeUint256
+from openzeppelin.utils.constants.library import UINT8_MAX
 
 #
 # Events

src/openzeppelin/token/erc20/presets/ERC20.cairo

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (token/erc20/presets/ERC20.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (token/erc20/presets/ERC20.cairo)
 
 %lang starknet
 

src/openzeppelin/token/erc20/presets/ERC20Mintable.cairo

@@ -1,15 +1,14 @@
 # SPDX-License-Identifier: MIT
-# OpenZeppelin Contracts for Cairo v0.2.0 (token/erc20/presets/ERC20Mintable.cairo)
+# OpenZeppelin Contracts for Cairo v0.2.1 (token/erc20/presets/ERC20Mintable.cairo)
 
 %lang starknet
 
 from starkware.cairo.common.cairo_builtins import HashBuiltin
 from starkware.cairo.common.uint256 import Uint256
 from starkware.cairo.common.bool import TRUE
 
-from openzeppelin.token.erc20.library import ERC20
-
 from openzeppelin.access.ownable.library import Ownable
+from openzeppelin.token.erc20.library import ERC20
 
 @constructor
 func constructor{