Precautions for scalable contract solution based on openzeppelin

be based on Openzeppelin Considerations for scalable contract solutions

matters needing attention

Constructors

Please Do not use Constructors contructor(), We know that the runtime logic of scalable contracts is separated from data , Contract data is stored in Agency contract in , The contract we wrote is Logical contract , When the contract is deployed , Logical contract call contructor() The initialization data is Logical contract Of , Agency contract The data in is not initialized , So it's invalid .
Include Global variables Assign initial value when declaring , Because this is equivalent to the constructor contructor() Set these values in .

Parent contract initialization

If MyContract Inherited from contract BaseContract, that BaseContract Contract initialization function initialize() Of modifier( Decorators ) You have to use onlyInitializing, such as ：

contract BaseContract is Initializable {
    
    uint256 public y;

    function initialize() public onlyInitializing {
    
        y = 42;
    }
}
// BaseContract  Inherited from  Initializable, There is no need to repeat explicit inheritance  Initializable
contract MyContract is BaseContract {
    
    int storageValue;

    // modifier( Decorators ) initializer  To ensure that initialize Will only be called once 
    function initialize(int initValue) public initializer {
    
        BaseContract.initialize();
        storageValue = initValue;
    }
    ......
}

Declare state variables

• When declaring state variables , It cannot be assigned Initial value

It's wrong to do like this

contract MyContract is Initializable {
    
    int storageValue = 666; // Invalid initial value 

    function initialize() public initializer {
    
    }
    ......
}

Because this is equivalent to the constructor contructor() Set these values in , Therefore, it does not apply to scalable conventions .

• Defining constant state variables can still

It's OK like this

contract MyContract is Initializable {
    
    // constant  Constant keyword 
    int public constant storageValue = 666; // It works 

    function initialize() public initializer {
    
    }
    ......
}

Create a new contract instance in the contract code

• Do not create new contract instances in the contract , The contract created is not scalable

like this , Even if MyContract It's upgradeable , but ERC20 Instances cannot be upgraded

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyContract is Initializable {
    
    ERC20 public token;
    
    function initialize() public initializer {
    
        token = new ERC20("Test", "TST"); //  This contract cannot be upgraded 
    }
    ......
}

• If you want to MyContract Quote other upgradeable contracts , Then inject the deployed scalable contract instance into MyContract in , It's a good solution

like this

import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";

contract MyContract is Initializable {
    
    IERC20Upgradeable public token;

    function initialize(IERC20Upgradeable _token) public initializer {
    
        token = _token;
    }
    ......
}

Declare the state variable when upgrading the contract

When writing a new version of the contract , Whether due to new features or bug Repair , There is an additional limitation to be observed ： The declaration order of contract state variables cannot be changed , Nor can you change its type .

For example, the current version （V1） Contract state variable layout

contract MyContractV1 {
    
    uint256 private x;
    string private y;
}

When writing the new version of the contract , Please avoid the wrong operation ：

• Change the type of variable

This is wrong

contract MyContractV2 {
    
    string private x;
    string private y;
}

• Change the order in which they are declared

This is wrong

contract MyContractV2 {
    
    string private y;
    uint256 private x;
}

• Introduce a new variable before the existing variable

This is wrong

contract MyContractV2 {
    
    bytes private a;
    uint256 private x;
    string private y;
}

That's right

contract MyContractV2 {
    
    uint256 private x;
    string private y;
    bytes private a;
}

• Delete existing variables

This is wrong

contract MyContractV2 {
    
    string private y;
}

Reference documents ：
Openzeppelin Write upgradeable contracts ：https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable