Skip to content

Latest commit

 

History

History
99 lines (75 loc) · 4.86 KB

README.md

File metadata and controls

99 lines (75 loc) · 4.86 KB
Raw

Proxy Contracts Solidity

Solidity proxy contracts based on unstructured storage pattern. Upgrade your contracts safely.

Read more about proxy patterns from OpenZeppelin article.

I chose this pattern for implementation because it is the most convenient in its further support. So, no implementation of a proxied contract should know about the proxy contract storage structure. However, all implementations must inherit all of the storage variables that were declared in their ancestors.

The address of the current implementation is stored in a constant pseudorandom slot of the contract proxy contract (slot number obtained as a result of hashing a certain message), the probability of rewriting which is almost zero.

If you want to set the initial implementation state, use a separate initialize function for it, which will essentially be the "constructor" of the contract. This is due to the fact that the proxy does not reflect in any way the changes that you make in the constructor of the contract, therefore it can be considered useless.

When creating a contract, the sender of this transaction will be assigned as its owner. The address of the owner is stored in a manner similar to the implementation address.

You can change the owner using the following function:

/// @notice The owner can transfer control of the contract to the new owner
/// @param _newOwner New proxy owner
function transferOwnership(address _newOwner) external

You can change current implementation after its deployment using the following function:

/// @notice Sets new implementation of contract as current
/// @param _newImplementation New contract implementation address
function setImplementation(address _newImplementation) public

Or if you want to set some initial state for it use the following function:

/// @notice Sets new implementation and call new implementation to initialize what is needed on it
/// @dev New implementation call is a low level delegatecall
/// @param _newImplementation representing the address of the new implementation to be set.
/// @param _newImplementaionCallData represents the msg.data to bet sent in the low level call. This parameter may include the function
/// signature of the implementation to be called with the needed payload
function setImplementationAndCall(address _newImplementation, bytes calldata _newImplementaionCallData) external payable

You can use any function of the implementation contract as usual, however, the address should be the address of its proxy contract. This is because the implementation functions will be called using the delegate call from the context of the proxy contract using the fallback function.

Install and use

Copy/paste

Just copy .sol files from contracts folder and use them with your contracts

Yarn

  1. Install node.js and yarn if you haven't yet
  2. Install package
yarn add upgradeable-contracts-solidity
  1. There are 2 ways
    1. Deploy proxy using bytecode from this file:
    ../node_modules/upgradeable-contracts-solidity/build/Proxy.json
    1. Import Proxy.sol into your NewProxy.sol file, inherit from Proxy contract, save and deploy it. Feel free to add your functionality (DO NOT add storage variables if you don't completely understand how it works)
    pragma solidity ^0.5.0;

import "../node_modules/upgradeable-contracts-solidity/contracts/Proxy.sol";

contract YoursContract is Proxy {}
  2. Deploy and set implementation as described above

Build and test

  1. Install node.js and yarn if you haven't yet
  2. Clone repo
git clone https://github.com/BaldyAsh/upgradeable-contracts-solidity
  1. Go to downloaded folder and install dependencies
yarn
  1. Compile contracts and run tests
yarn test

Credits

Anton Grigorev, @baldyash

Contribute

Donate

License

This project is available under the MIT license. See the LICENSE for details.