A big upgrade is on its way and it’s called the Shanghai Upgrade. This upgrade promises to bring several improvements to the Ethereum network, making it more efficient, consistent and upgradeable. The upgrade is slated to happen in March 2023, and it’s a highly anticipated event in the Ethereum community. Let’s see what we have!

For all the information used in writing this article, we compiled it from ACD wrote by Ethereum Foundation’s Tim Beiko. If you want to learn more, you can refer to the following links for additional information!

https://hackmd.io/@timbeiko/acd/

Beacon Chain Stake and Withdrawal 💰

One of the key features of the Shanghai Upgrade is the introduction of withdrawal capabilities for Beacon Chain stakers. Currently, Beacon Chain stakers can only stake ETH, but with the upcoming EIP-4895, they will now be able to withdraw their stakes as well. This is a top priority for the upgrade and is expected to bring a lot of excitement to the Ethereum community.

Ethereum Object Format (EOF) 💻

Another major highlight of the Shanghai Upgrade is the Ethereum Object Format (EOF). EOF is a suite of 5 Ethereum Improvement Proposals (EIPs) that promises to make Ethereum execution more efficient, more consistent, and more upgradeable. EOF is the first upgrade in the Ethereum Virtual Machine’s (EVM) history and it’s a big step forward for the Ethereum network. Here are the key EIPs that make up the EOF:

• EIP-3540: Changes the structure of EVM instructions, making it easier to upgrade the EVM.
• EIP-3670: Introduces code validation for smart contracts during deployment, saving execution costs.
• EIP-4200: Improves the efficiency of the Ethereum stack machine, leading to lower gas fees.
• EIP-4750: Introduces functions that the stack machine can perform, making programs more efficient.
• EIP-5450: Validates contracts during deployment, preventing stack overflows and underflows.

How it Could Impact Developer Experience? 👨‍💻

The Shanghai Upgrade and EOF in particular, has the potential to significantly improve the developer experience on the Ethereum network. With code validation during deployment, efficient stack machine operation, and easier upgradability, developers can expect their smart contracts to run more smoothly on the network. Additionally, the introduction of withdrawal capabilities for Beacon Chain stakers is also a big win for developers who have been eagerly waiting for this feature.

Can I try Ethereum Shanghai? 🤔💻

Yes, you can try Ethereum Shanghai! 🚀 As of now, We have a public testnet for the upcoming Ethereum Shanghai and it’s called Zhejiang public testnet. And luckily it is now live and you can try playing with it!

You can also try to interact with it with Laika just go ahead to https://web.getlaika.app Connect to your wallet and on the top-right pick on the chain selector and type “Zhejiang”

And Wallah! You can interact with any smart contracts on it with a few clicks away!

Closing Thoughts 🤔

In conclusion, the Ethereum Shanghai Upgrade is a big step forward for the Ethereum network and the entire community. With the introduction of withdrawal capabilities for Beacon Chain stakers, and the Ethereum Object Format (EOF), the network is expected to become more efficient, consistent, and upgradeable. Developers can look forward to a better experience building and deploying their smart contracts on the Ethereum network. 🚀 Get ready for the big launch in March 2023!

That’s it for today! Catch up with you guys later!

Connect with us

Twitter: https://twitter.com/getlaikaapp
Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf

PS. This article is co-written by ChatGPT. A big shoutout to ChatGPT for its amazing assistance in writing this article!

Hello and welcome to our article on A Deep Dive into Laika and Osmosis! If you’re interested in building decentralized applications (dApps) on the Osmosis blockchain. whether you’re a veteran builder who built for quite some time or a builder who just getting started. I’m sure that our tool that we building at Laika Labs could help you somehow!

Introduction

Laika is a request builder tool that allows users to interact with smart contracts through a graphical user interface (GUI). It allows users to create requests to call functions on contracts, view data, and even deploy new contracts, all without the need for coding. Laika is a useful tool for developers who want to test and debug their contracts quickly and easily, as well as for non-developers who want to interact with existing contracts.

What we building so far

Here’s a List of what we build that could help you build faster on Osmosis!

1. A Request Builder 👷

We create easy & intuitive UIs (with collection management supported) to interact with smart contracts on-chain so developers don’t have to spend time writing a code to send a request to the smart contract. But just make that request on the UI to help speed-up development time a lot!

(Right now, Laika is supported on Osmosis Mainnet, Osmosis Testnet, and LocalOsmosis)

Visit: https://interchain.getlaika.app/

2. LocalOsmosis supported via Laika Proxy Extension 👩‍🔬

Laika is not just support on Osmosis Mainnet, Testnet. But you can spin your chain locally using LocalOsmosis. And you can use Laika on your local network through Laika Proxy Extension!

Introduction to Laika Proxy Extension

Hello everyone! In this article, I’m going to introduce you to Laika Proxy Extension which we’ve just released.

medium.com

3. Code Snippet Generator 🤖

Not only you can create a new request through UIs, but Laika also gives you a way to generate code snippets with ease so you can use them on your backend, bot, or anything you want.

4. Environment Variables 🌏

You can even create environment variables so they can be reused many times for any requests you build.

5. Laika Labs CLI 💻

Laika Labs CLI is a command line tool that simplifies working with web3, providing an efficient and easy way to create and test smart contracts through Laika, a request builder for web3.

We create it to make integration of Laika and Beaker possible, Osmosis’s smart contract developer can now write and check their smart contract as fast as a few clicks away!

Other than all of that we also added a lot of utility features that you can use to boost your development workflow such as

• Notes 📝 (A handy feature that you can use to jot down details of each request)
• Converter ⚖️ (To help you convert the value to make it easier for the request making)
• History 📜 (Gives you the list of past requests sent via Laika)

And much more!

That’s all for this article. Hope you guys like it! See you again next time! 😃

Connect with us

Twitter: https://twitter.com/getlaikaapp
Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf

Good day everyone! Today I’m really excited to introduce you to a tool that we’ve been building for a while now called the “Laika-Labs-CLI”.

Laika Labs CLI is a command line tool that simplifies the process of working with web3 and blockchain technology. It is built to work with Laika, the request builder for web3 that acts as the “Postman for blockchain.” And it will provide developers with an efficient and easy way to create, and test smart contracts.

Installing Laika Labs CLI

1. To install Laika Labs CLI, open a terminal window and run the command npm install -g @laika-labs/cli.
   This installs the CLI globally on your computer.
2. Verify the installation by running laika -v, which should display the version number of the CLI.

Syncing a Beaker Smart Contract to Laika via Laika Labs CLI

Beaker is a smart contract development tool that allows developers to create and deploy CosmWasm smart contracts on the blockchain. Laika, on the other hand, is a web3 request builder similar to Postman, which makes it easy to test and interact with your smart contracts.

1. To sync a Beaker project with Laika, navigate to the directory of the Beaker project in your terminal.
2. Run the command beaker wasm ts-gen to generate schema for smart contracts, and then run laika beaker sync <contract-name>, where <contract-name> is the name of the contract you want to sync.
3. A link will be generated in the terminal, click on it, and it will automatically generate a new request for you in Laika, allowing you to easily test and interact with your smart contract.

By following these steps, you can easily use Laika and Beaker together to streamline your smart contract development process.

That’s it for today! Catch up with you guys later!

Connect with us

Twitter: https://twitter.com/getlaikaapp
Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf

PS. This article is co-written by ChatGPT. A big shoutout to ChatGPT for its amazing assistance in writing this article!

Hello everyone! In this article, I’m going to introduce you to Laika Proxy Extension which we’ve just released.

To give you folks a little more context is that, We’ve just added CosmWasm support which you can explore at https://interchain.getlaika.app or look at the tweet below!

But Laika's interchain version has limitations in that it could not directly communicate with the chain running locally. Since the browser not allowed the web app to directly communicate with the local process.

And that’s why we built Laika Proxy Extension to make it possible to interact with local chains using Laika!

You can take a quick glance at Laika's official repository here

GitHub - laika-lab/laika-extension

You can't perform that action at this time. You signed in with another tab or window. You signed out in another tab or…

github.com

Let’s see how to use it!

1. Clone Laika Proxy Extension from GitHubgit clone https://github.com/laika-lab/laika-extension

2. Install dependenciescd laika-extensionnpm install
# or
yarn install

3. Build the extensionnpm run build
# or
yarn build

4. Install the extension by entering chrome://extensions/ it into your browser, You’ll be seeing something similar to this (Don’t forget to turn on Developer Mode)

5. Click on Load unpacked and pick dist from the folder that we built on step (3)

6. Wallah! We just installed Laika Proxy Extension!

Now you can use Laika with chain running using LocalOsmosis just as you use with other chains that we’ve supported

That’s all for this article. Hope you guys like it! See you again next time! 😃

Connect with us

Twitter: https://twitter.com/getlaikaapp
Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf

As you might know, OpenSea just released the new SeaPort, a brand new NFT Marketplace that is efficient in terms of gas-saving (and more).

This article will be about what Seaport does for their gas optimization as well as how you can poke Seaport smart contracts using Laika.

My inspiration for this article came from gist posted by ecmendenhall here. I liked the way they (OpenSea) did for their smart contracts optimization so I figured let’s take some part of it to be article!

In this article, we’re going to talk a little bit about Ethereum Calldata. If you never heard of it before I advise you quickly check the article below here before continuing here:

Get to know Ethereum Calldata

This article explain what Ethereum Calldata is and how it’s structured.

medium.com

And some of the Assembly here:

Solidity Tutorial : all about Assembly

What is Assembly ?

jeancvllr.medium.com

The smart contract that we’re going to look at today is going to be Seaport smart contract. And to be more specific we’re going to look at how they implement their transfer on their _performERC20Transfer() function. So let’s look into it!

As you can see that it is fairly long here. To make it easier to look at, I’m going to summarize what they do before we’re going to look at it.

They simply optimize their token transfer by instead of calling a function from another smart contract the ordinary way we use in Solidity they turn it into assembly and perform the call process by themself. (As you can see from lines 10–199)

Their smart contract consists of a few parts where they have to

• Constructing Ethereum Call data
• Call it on another smart contract
• Handle Errors
• Clean up

Let’s look into it part by part!

1. Constructing Ethereum Calldata

The code above is from lines 11–22. What they do is just load new memory using mload and call that memPointer.

After that things were fairly simple. They add numbers of values into that memory by storing them using mstore function.

After this finish, the memPointer would be storing something similar to(Function Signature) + (from arg) + (to arg) + (amount arg)

then we’re ready to go to the next part.

2. Call it on another smart contract

For this part, we use the calldata we construct on the above to call to another smart contract. Hereafter the contract is called we store the data into the variable callStatus. and then check if the call is a success by using a beautiful trick on lines 37–46

3. Handle Errors

Alright, this is the part where it’s the longest. But the reason that it’s quite long is that there are a number of cases where the call could go wrong not because it was complicated.

To make this article small I will show you just how we could add a revert message using Solidity. (If you are interesting in a more complicated situation I advise you look deeply into the codebase)// Otherwise revert with error about token not having code:        mstore(NoContract_error_sig_ptr, NoContract_error_signature)        mstore(NoContract_error_token_ptr, token)        revert(NoContract_error_sig_ptr, NoContract_error_length)

This is from lines 137–140. As you can see it’s quite similar to what we do at 1. Constructing Ethereum Calldata. What we’re doing here was to store the data into some memory and then just call revert() to let it revert the transaction.

4. Clean up// Restore the original free memory pointer.            mstore(FreeMemoryPointerSlot, memPointer)// Restore the zero slot to zero.
mstore(ZeroSlot, 0)

To clean up the memory there were simply just 2 lines of code (from lines 195–199)

We clean up the memory since there might be some function that runs after this function that wants to use a memory.

Alright! So this is just a small walkthrough of _performERC20Transfer() there were several examples like this in Seaport smart contract which really fun to look at. And if you want to look at their smart contracts Laika would be really helpful when you want to try to look at some functions.

Let’s see how we could use Laika to help poke their smart contract!

But first let's get where the smart contracts are you can look where they deploy their smart contracts here: https://github.com/ProjectOpenSea/seaport

(I will use Rinkeby in this case)

To import their smart contract in Laika is fairly simple just click on the New button here.

Select Chain Explorer

Copy and Paste the address, Pick your desired chain. and then hit import button

Done! Here’s a list of requests that you can try playing with their smart contracts.

Another really cool feature in Laika is that it can auto-generate the Ethereum Call Data for you. This would be really convenient if you want to try to optimize your smart contract using Assembly

Alright! That’s it for today. Hope you find it useful 😃 See you next time!

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp

Hi, Buidlers! 🙌 In this article I want to introduce you to another great thing that we’ve been working on lately. It’s a Hardhat plugin called “hardhat-laika”

What is hardhat-laika ?

hardhat-laika is a Hardhat plugin that helps you sync your compiled contract with Laika. So you can make a request without having to write a single line of code.

And also, Boost your performance when working with Hardhat 💪

Let’s try it out!

First, you going to need to start a new Hardhat project.npx hardhat init

Then, pick a configuration you like (I pick this specific configuration because I need Greeter.sol as an example contract so we could get going easily)√ What do you want to do? · Create a basic sample project
√ Hardhat project root: · /path/to/project/
√ Do you want to add a .gitignore? (Y/n) · y
√ Do you want to install this sample project's dependencies with npm (...)? (Y/n) · y

After the setup is completed let’s install hardhat-laikanpm i hardhat-laika

Now, import it to your hardhat.config.js (By adding require(…) on the top)

Alright, now we’re all set. Let’s try to use it!

There are 2 ways to use hardhat-laika 1. using it through the command line and 2. using it through your own scripts (hardhat-laika define task is hre so you can use it easily)

Let’s try the first way.

1. Command-Line way

First, Let’s compile our contract so we get the ABIs.npx hardhat compile

Then, use the laika-sync task to sync it to Laikanpx hardhat laika-sync --contract <contract_name> --address <OPTIONAL address_of_that_contract>

For this example, I’ll use the commandnpx hardhat laika-sync --contract Greeter --address 0x5FbDB2315678afecb367f032d93F642f64180aa

You should be able to see something like this.

2. Script way

Let’s take a look at scripts/sample-script.js

I just have to simply add hre.run() to line 25 and we’ll all set! Let’s run it using the command.npx hardhat run scripts/sample-script.js

You should be able to see something like this.

Alright! That’s it for today. Hope you find it useful 😃 See you next time!

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp

If you’ve been using Hardhat for a while, there might be some situations where you have some tasks that you perform regularly (eg. remove console.log from your code). In that case, it would be really helpful to create some tasks or some plugins to reuse later.

So, in this article, we’re going to walk through how we can create a new custom hardhat plugin from scratch (really really from scratch).

What we going to create

In this article, I’m going to walk through how I write a custom plugin called hardhat-laika which is the plugin that going to sync ABI of artifacts generate from Hardhat to an application called Laika

If you don’t know what Laika is, Laika is a Blockchain development tool that helps you request smart contracts without having the hassle of writing a single line of code — a postman for web3!

How does it work?

How hardhat-laika is going to work is really simple. It works as follows.

1. get the compiled artifacts from specific contracts
2. send its ABI to https://api.getlaika.app
3. get a response from it then generate a new URL so user can access their own contract through Laika

Alright, as you can see the purpose of it is pretty specific (it is not too simple or too complicated so I think it would be a pretty good example to walk through together).

So I want to encourage you guys to think about something you want to do yourself and follow along.

And by all means, I’m no expert in building a custom Hardhat plugin so if you want to add some suggestions I’m really welcome for it!

What exactly are Hardhat plugins?

According to https://hardhat.org/advanced/building-plugins.html

Hardhat plugins are reusable configurations or anything you can add to your config file you can pack it together to create another plugin.

Yep, so the easiest way to build a Hardhat plugin is to get started on your hardhat.config.js!

So what can you do with the Hardhat plugin?

As said in the documentation, you can do whatever you want on your config file. Let’s list them out so we can get the idea.

• Extending environment (adding a new property to “hre” object)
• Extending configurations
• Create some tasks (https://hardhat.org/guides/create-task.html)

and that’s about it!

Let’s scaffold our plugin on the config file

Before anything else, let’s create a new Hardhat project by using the commandnpx hardhat init

Then, set it up however you like, but for me, I will use this configuration.√ What do you want to do? · Create a basic sample project
√ Hardhat project root: · /path/to/project/
√ Do you want to add a .gitignore? (Y/n) · y
√ Do you want to install this sample project's dependencies with npm (...)? (Y/n) · y

Because I want my hardhat-laika plugin that when I install it I would be able to do something like.npx hardhat laika-sync --contract <name> --address <address>

Absolutely, The first thing I have to do is to create a new task for that.

The things that we are doing with this task are really simple and the thing is that this is all we have to do for the task that I want. We get the ABI and contract address upload it to Laika’s backend then generate a new URL so users can access it through the browsers.

Notice that I’ve been using “open” (to open up the browser) and node-fetch so don’t forget to install it!

Alright, let’s try it :))

First I use the command

Then the plugin would open up the browser and we’ll see the collection that is going to be imported.

Cool!

Now Let’s move it to Plugin

When building a new plugin, I really recommend you to use boilerplate provided by Nomiclabs which you can find here https://github.com/nomiclabs/hardhat-ts-plugin-boilerplate/

Try looking around the repo to see how things link together.

Another great way to explore how things link together is by looking around other plugins if you’re really getting started there are a lot of small plugins that you could go look around.

eg.

• hardhat-fund-link (https://github.com/appliedblockchain/chainlink-consumer/tree/master/plugins/fund-link)
• hardhat-log-remover (https://github.com/ItsNickBarry/hardhat-log-remover)

Alright so first thing first let’s clone the boilerplate to our Hardhat project (You can also click use as a template and just clone that repo)

git clone https://github.com/nomiclabs/hardhat-ts-plugin-boilerplate.git

Then let’s head to type-extensions.ts (I find it easier for me to set things up what it should look like first)

I’m going to put this code in that file.

This chunk of code is where I describe the interface of the task I created (laikaSync)

Next, let’s move our task to the plugin. I’m going to create a new folder call tasks and create a new file in that folder name laika-sync.ts (So when we have more and more tasks every task will not be mixed up in index.ts)

I move the task from hardhat.config.js to here. You might notice that I have changed the code structure a little bit to make it more versatile (hopefully lol). Also, you might notice that I have imported endpoint URL from config

So let’s create it.

Yep, this is quite simple. Now let’s move to our index.ts

Also, quite simple haha. In this file, I just extend the environment by adding laikaSync to the hre. And this is about it! your plugin is ready 👀

Let’s test it & publish

Because our plugin is written in Typescript so don’t forget to build it!

After I clone the boilerplate I change the name to hardhat-laika

So when I’m going to use it I would have to add require(”./hardhat-laika”) to my hardhat.config.js (the root of project one)

Yep! It’s still working like expected! Anyway, It would be a great idea if we write a test script for it but that’s the topic for another article! 👀

If you want to publish to npm and have never done it before just head to https://docs.npmjs.com/cli/v8/commands/npm-publish for more information.

Phew~, That was a lot to cover. Thanks a lot for reading up until this point! Hope you get a grasp of how to build a new Hardhat plugin.

Anyway if you have time I really encourage you to try hardhat-laika with Laika out here: https://www.npmjs.com/package/hardhat-laika

We will surely have more articles about how to use hardhat-laika out soon. Stay tuned!

See ya next time 😃

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp

Hello there! 😃 It’s nice to see you guys again!

This blog is intended to be the update of what we have been doing since the last update. Let’s go!👀

1. Variable Suggestion 🤖

We added the variable suggestions (for environment variables, etc.) hope this comes in handy!

2. Theme sync with System 🌓

A small thing to update but the Theme is now syncing with your system!

3. Chain Switcher 🎛

This came in handy when you want to work with a new chain (eg. REI)

Also, when you select a new chain that never use before it would auto add that new chain to your Metamask!

4. Home Revamp 🏠

We revamp our home interface a bit. You should be able to quickly create a new Request or Look at the documentation from here 👀

5. Rei Chain Support 🤝

We’ve just partner with REI Chain to make it easier to work with the Rei chain. Using Laika it was really easy to work with the Rei chain. You can directly import ABI from the reiscan.

If you never used the REI chain before you can just click on chain switcher and pick Rei Chain we’ll automatically add it for you!

Check out REI here: https://reichain.io/

6. Token Transfer Inspector 🔭

You can now inspect token transfer directly in Laika 👀 If you’re working with requests involving Tokens this should come in handy!

7. Hardhat Integrations 🛠

This feature is not come out yet. But just to hype you guy a little bit Laika team just start working on the Hardhat plugin that will sync your Hardhat project with Laika!

Stay tuned!

And there’s a lot more! Just try it at https://getlaika.app

See ya next time! 🤗

#BUIDL #getlaikaapp

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp

Hello! It’s nice to see you again :)

We’ve been working on a lot of things for the past few weeks and there’s a lot of new features since our last update. Let’s see what is it! 👀

1. Chain Request (Beta) ⛓

Want to test with a scenario? There’s some method you want to call first and then another? Chain Request come here to help!

You can structure requests in a flow and easily look at the result one by one!

(Note: Chain Request is currently in Beta)

2. Environment Variables 🏕

Have a lot of repeating values? Let’s make it an Environment variable and just reuse it!

Laika is now supporting Environment Variables just click on the 🌍 icon on the left bar add a new variable.

when you want to use it just put a {{ variable_name }} on any field!

3. Calldata Inspector 🔭

You can now inspect the Calldata of each request with the Call Data tab! This makes it easier to inspect the request byte by byte 👀

4. Sighash Request #️⃣

Another cool thing is you can now use Sighash as a method name! just put Sighash to the method name field and that was it!

5. Hash Converter ⚖️

We added Hash Converter into the right toolbar! Hope this comes in handy 🤗

And there’s a lot more! Just try it at https://getlaika.app

See ya next time! 🤗

#BUIDL #getlaikaapp

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp

Why do we need to upgrade Smart Contracts?

Normally, when we deploy smart contracts on the blockchain, it is impossible to edit the code deployed. And it should be totally fine that way. The fact that it could not be deployed to replace the existing codes means that that particular contract can not be modified afterward. (this increase safety of people who interact with that contract)

However, we might really want to edit the code on the contracts in some circumstances like spotting a severe bug on the smart contract that we just have to fix but we can not do so because of the mechanism. What we can do best is to deploy another smart contract that has the bug fixed, and all information migrated. Not only that, but we also need to fix the references that are tied to the old smart contracts, plus telling users to also migrate to use our services on the new contract.

Feel a bit overwhelmed with the process right? We also felt the same (been there, done that.) With our experiences, we found one use case that helps us with addressing the complex procedures. Let’s take a look at it!

Introducing “Upgradable Contract”

An Upgradable contract is a contract that can be (kind of) altered, after the deployment. At the time this article was written, to use an upgradeable smart contract, there is a tool, or plugin, to help us build. This plugin is introduced by OpenZeppelin.

How to use the plugin? Well, it is not that complicated. Just use this plugin to deploy contracts on hardhat or truffle. Whenever you want to edit the smart contracts, just use the same address to deploy the upgraded contracts via the plugin without worrying about transferring any state in the old implementation.

The method OpenZeppelin uses is the design pattern named “proxy pattern.” We will have two deployable contracts. The first one is the storage layer, which stores various states in smart contracts. The second is the logic layer where the contract runs its logic.

Whenever we interact with the contract, we interact through the proxy contract and then the proxy contract will pass on to the logic contract before sending the output back to us. That being said, imagine you want to change the logic of your smart contracts, you will just need to tell the proxy to refer to the new smart contracts and that is it! Users no longer need to switch the smart contract to interact, they can interact as usual (Super convenient, isn’t it?)

Should you wish to dig deeper, please refer to the official blog of OpenZeppelin here (link)

How to do it?

Let’s begin by building a new project, in this case, I will use hardhat to do so. To build a project just npx hardhat and choose the configuration as you wish. Here’s my config for illustration.

After we have set up the new project and added contract files, we then install the plugin to upgrade the contract mentioned earlier by using this command below.

npm install — save-dev @openzeppelin/hardhat-upgrades

After the installation, we have to add this config in the hardhat.config.jsrequire(‘@nomiclabs/hardhat-ethers’);require(‘@openzeppelin/hardhat-upgrades’);

to let hardhat know that we are using the plugin.

That is done for the first step. Let’s try it out by clicking on Greeter.sol, the contract the hardhat generated for us.//SPDX-License-Identifier: Unlicensepragma solidity ^0.8.0;import “hardhat/console.sol”;contract Greeter {string private greeting;/*Comment this part out since upgradable contract don't use constructorconstructor(string memory _greeting) {console.log(“Deploying a Greeter with greeting:”, _greeting);greeting = _greeting;}*/function greet() public view returns (string memory) {return greeting;}function setGreeting(string memory _greeting) public {console.log(“Changing greeting from ‘%s’ to ‘%s’”, greeting,     _greeting);greeting = _greeting;}}

To glance at how it works, we run our local blockchain using npx hardhat node.

To interact with the chain we use

npx hardhat console — network localhost

(Do not forget to choose localhost for the network)

Then try to deploy using the upgradable plugin.

const { ethers, upgrades } = require(‘hardhat’);const Greeter = await ethers.getContractFactory(‘Greeter’);const greeter = await upgrades.deployProxy(Greeter, [‘Hola!’], { initializer: ‘setGreeting’ });console.log(‘Greeter deployed to:’, greeter.address);

After the deployment, just copy the address to use to eye the results.

To view the contract that has been deployed, Laika Blockchain Lab is developing a tool called Laika that helps us make requests to interact with the smart contract without writing a single line of code. We are now under the incubation program of SCB10X, to learn more about us please visit this link

Laika can help us with this step. Wonder how? Let’s try it out. First, we visit the Laika application here https://web.getlaika.app and connect the wallet.

The goal, now, is we want to view the information on the localhost network. Please make sure that you have already had Hardhat set in place, if not, go here is how you can set it up.

In our Laika platform, to make a request, select the “New” button to create a new collection.

Then click the 3 buttons on the right to choose “New Method”. In this case, we will name it “greet.”

Here’s what it will look like. Next, we paste the contract address from the Hardhat console, change the method to “View”, and choose parameters and returns that you want.

After finishing setting up, we press “Send” and the results will show as the above picture. We can see that the value is “Hola!”, the same as what we set when we deployed.

Now, let’s build a contract and try to upgrade it with the new one. (I create GreeterV2.sol for another file, separately)//SPDX-License-Identifier: Unlicensepragma solidity ^0.8.0;import “hardhat/console.sol”;contract GreeterV2 {string private greeting;// I added _name param to greet functionfunction greet(string memory _name) public view returns (string memory) {// It would simply concat our greeting word with name that pass by callerreturn string(abi.encodePacked(greeting, “ “, _name));}function setGreeting(string memory _greeting) public {console.log(“Changing greeting from ‘%s’ to ‘%s’”, greeting, _greeting);greeting = _greeting;}}

We open the console and add in the code as follow:

const { ethers, upgrades } = require(‘hardhat’);const GreeterV2 = await ethers.getContractFactory(‘GreeterV2’);// Put the same address of Greeter that deploy earlierawait upgrades.upgradeProxy(‘0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0’, GreeterV2);

After we upgrade, let’s take a look again at the contract. Because we changed the function parameter, we have to also align with the new contract. Press “Send” to see the result.

All in all, OpenZeppelin can help us upgrade the smart contract, and it is very easy to do so. It is almost the same as when we normally deploy the smart contract. I encourage you to try it out, if there are any questions, feel free to reach out to us!

Are there any cons?

The con about the upgradeable smart contract is the fact that we can mend the implementation of the contract. This means that we can change the logic of how a contract works. The admin can edit the contract and get away with the money in it. Or it can be like the Fulcrum incident that the hacker steals the admin’s key and change all of the implementations and get away with the money. We must weigh the pros and cons before we decide to use it.

That’s a lot for today. The article better ends here. Thank you for reading through this article. Hope you find it useful!

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp

Hello! Nice to meet you guys again. Happy new year!

This is the first update of Laika for this year. We’ve added a lot of features for the past few weeks. Let’s see what we’ve got! 👀

1. Code Generator 🧑‍💻

We’ve had a lot of requests for code generator recently and it’s here! you can just create your request and copy the code snippet from the toolbar on the right side!

2. Drag and Drop 🤏

The request is now drag ‘n drop -able! This makes it easier to manage your workspace.

3. Unit Converter ⚖️

We’ve integrated the unit converter right into the right sidebar (No pun intended!) Hope this comes in handy!

4. More data on selected chain ⛓

We’ve changed the interface a bit. Laika now shows the ChainID of your selected chain so it would be easier to recognize which chain you’re in.

5. A bit of UI Change 💄

We’ve changed the UI a bit. if you want to have an array type of parameters you can just tick the array checkbox a lot more simpler!

And there’s a lot more! Just try it at https://getlaika.app

See ya next time! 🤗

#BUIDL #getlaikaapp

Connect with us

Facebook: https://www.facebook.com/getlaikaapp/
Discord: https://discord.gg/4DzwHuxhcf
Twitter: https://twitter.com/getlaikaapp