SOC 2 Type II 인증 · ISO 27001

Building Upgradable Solidity Smart Contracts

Zeppelin OS Introduction

Zeppelin is all about Smart Contract development. The team has helped many developers build Smart Contracts with openzeppelin-solidity, one most downloaded web3 libraries on NPM (with over 10k downloads every week!). According to Zeppelin’s website:

What problem does it solve?

ZeppelinOS helps developers build upgradable smart contracts using libraries that anyone can use on the Ethereum blockchain. Unlike traditional contracts (which can remain frozen forever on the blockchain, with mistakes, limited functionalities, etc...), ZeppelinOS allows users to opt-in & allow upgrades of contracts, opening the doors to a more sustainable process for developing web3 blockchain projects. With upgrades, we can make iterative releases, quickly add small pieces of functionalities (that we can adjust according to the always changing goals of our users), and of course, we can implement fixes for bugs we had introduced on previous iterations.

Building on ZeppelinOS

Let’s build an upgradable CrudApp contract! We will deploy CrudApp.sol and then update it while preserving its data… so let’s start:

1- Create a project and install dependencies

2- Initialize your project

This command will create a zos.json file, which contains all the information about the project. For details about this file, see the configuration files page.

The command will also initialize Truffle. So by now, inside the crud directory you should have a package.json file (created by npm), two empty directories named contracts 그리고 migrations, a truffle-config.js file (created by zos for Truffle), and a zos.json file (created by zos for ZeppelinOS).

3- Add CrudApp.sol contract

Let’s add our CurdApp.sol now. We will make some changes in our previous Smart Contract, so let’s understand them:

Removing Constructor and adding an Initializer

“You can use your Solidity contracts in ZeppelinOS without any modifications, except for their constructors. Due to a requirement of the proxy-based upgradeability system, no constructors can be used in upgradeable contracts. You can read in-depth about the reasons behind this restriction in the ZeppelinOS Upgrades Pattern page.”

This means that, when using a contract within ZeppelinOS, you need to change its constructor into a regular function, typically named initialize, where you run all the setup logic:

You need to import Initializable.sol too for this to work:

Install Ganache and deploy your project

We will use Ganache (local blockchain) to deploy our Smart Contract. You can change network settings in truffle-config.js if you want to use a different network. Open a different terminal and run below commands:

npm install -g ganache-cliganache-cli --port 9545 --deterministic

Now go back to the previous terminal and run below commands to start a session. We are using --network option for local network and --from [address] to provide an Ethereum address (which we are going use to deploy the smart contract). We are using a default Ganache address (you can see it on the Ganache terminal) and we are also using an additional expires flag to define the number of seconds this session will be valid (1 hour in this case).

Now let’s deploy our project:

This command deploys CrudApp to the local network and prints its address. You can deploy more contracts using add command and they will also get deployed after this command.

그 push command also creates a zos.dev-<network_id>.json file with all the information about your project in this specific network, including the addresses of the deployed contract implementations in contracts["MyContract"].address. You can read more about this file format in the configuration files section.

Upgrade the Project

push command deploys logic contracts which are not intended to be used directly, so instead we need an upgradable instance (we will cover logic contracts and ZeppelinOS Upgrades Pattern page in our future blogs).

Now let’s create an upgradeable instance of our CrudApp.sol:

그 zos create command uses optional --init [function-name] with the function name (which is initialize in our case). You can also pass arguments for this function (which is 200, limitation of countries) in our case. This will also print a Smart Contract address, which we will use while interacting with it.

Interacting with the Contract

Now let’s interact with our contract and insert some countries. To get to the Truffle console, run below command:

You will now see the Truffle console. Let’s run some commands and insert some countries:

We have inserted one entry in our Smart Contract. Let’s update our CrudApp!

Adding a function

We will add an extra function at the end of our Smart Contract and update it. So, for now, we already have a getCountry() function… we will add one more getLeader() function in our Smart Contract.

Now let’s update our Smart Contract. We need to run below commands for that:

This will print a new Smart Contract address which we’ll use for testing our updated contract.

Testing updated Smart Contract

Now let’s test our Smart Contract. It should preserve our previous data and we can access our new getLeader() function. So let’s interact with our Smart Contract again:

You will see able to see the results, that the Smart Contract was updated just like any other piece of code. 🍰 — We will build an upgradable ERC-20 token in our next article!

Conclusion

Though it seems pretty easy, we need to be pretty careful while using ZeppelingOS because of Solidity storage management. You can check here about the thing you need to pay extra attention to while updating your Smart Contract. ZeppelinOS is a great value addition to the Ethereum ecosystem!

Let us know what you want to learn about in the comment section.👇

Need help with your project or have questions? Contact us via this form, on Twitter @Quicknode, or ping us on Discord!