Introduction to Ethereum Shanghai Upgrade 🎉

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!

🥢 Ethereum Shanghai Upgrade was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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

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

A Deep Dive into Laika and Osmosis: How Laika help you build faster was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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!

Introduction to Laika-Labs-CLI was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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!

Laika Labs on Twitter: "@osmosiszone 🧪 devs can now use https://t.co/VUgRXeEL7Q 🐶 to build the interchain ecosystem now! pic.twitter.com/dFrTJCxW2G / Twitter"

@osmosiszone 🧪 devs can now use https://t.co/VUgRXeEL7Q 🐶 to build the interchain ecosystem now! pic.twitter.com/dFrTJCxW2G

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

Let’s see how to use it!

1. Clone Laika Proxy Extension from GitHub

git clone https://github.com/laika-lab/laika-extension

2. Install dependencies

cd laika-extension

npm install
# or
yarn install

3. Build the extension

npm 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

Introduction to Laika Proxy Extension was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

The Lens Protocol is a Web3 social graph on the Polygon Proof-of-Stake blockchain. It is designed to empower creators to own the links between themselves and their community, forming a fully composable, user-owned social graph. The protocol is built from the ground up with modularity in mind, allowing new features and fixes to be added while ensuring immutable user-owned content and social relationships.

— https://docs.lens.xyz/docs/what-is-lens

This article aims to be a small article in that we’re going to explore how we can use Laika to interact with Lens Protocol (It’s going to be a fairly short article)

But here’s the list of what we’re going to do. In which I hope you could get a glimpse of how you can interact with Lens Protocol through Laika

What we’re going to do

• We going to explore Lens Protocol on Polygon Mumbai Testnet
• Create our own Lens Handle (xxx.lens) through MockProfileCreationProxy contract
• Create a new post on Lens through LensHub Proxy

Lens Protocol Overview

The team at Lens Protocol designed it to be modular. this is so it is easy to scale the community of Lens Protocol itself. Lens Protocol tokenizes a lot of functionality into ERC721-compliant. So if someone wanted to add more features to Lens Protocol. They just write a new module and then plug it into it. Simple as that!

The smart contract that you’ll be going to interact with a lot is called “Lens Hub”. This is where Lens Protocol places the entry point for the majority of interactions with its protocol.

For the list of contracts deployed on each chain you can look for it here: https://docs.lens.xyz/docs/deployed-contract-addresses

Before beginning with anything make sure you have MATIC in your wallet on Mumbai Testnet. You can request tokens here https://faucet.polygon.technology/

Create Lens Profile

To create a Lens Profile on Polygon Mumbai is using a little bit different way than other interactions. As I wrote above that you’ll have to interact with Lens Hub. Well, this is not the case haha.

Lens Protocol has a whitelist of people who could create a Lens Profile. Typically, Our address is not in there. But we could create Lens Profile by creating it through the MockProfileCreationProxy contract. Which is going to be a proxy that gave us permission to create a new Profile.

For Polygon Mumbai MockProfileCreationProxy is deployed at 0x420f0257D43145bb002E69B14FF2Eb9630Fc4736

Alright! Let’s do it then.

To make it easier for you guys to follow this tutorial. I exported collections that we’re going to use in this article. You can download it from gist here.

Then open Laika at web.getlaika.app Click on Import Collection. Then drop in the JSON file you just downloaded.

You’re going to see lists of requests that I’ve prepared. Feels free to look around!

The request that we’re going to use to create a profile is called “proxyCreateProfile” so let’s get to it!

But before we’re doing anything you’ll notice that. it shows an Invalid address under the contract address field. This is because I put in the environment variable with the name MOCK_PROFILE_CREATOR_PROXY.

We have to set this up before going next!

Let’s hit the environment variables button (The globe icon) on the left side of the UI. Then hit New Button to create a new one.

Now just add new variables to it.

Here I added
LENS_HUB = 0x60Ae865ee4C725cd04353b5AAb364553f56ceF82
MOCK_PROFILE_CREATOR_PROXY = 0x420f0257D43145bb002E69B14FF2Eb9630Fc4736
Which is address of both of these contracts on Polygon Mumbai

And then change our Environment variables to the environment we just created.

Now Let’s fill in the parameters.

to = your address
handle = your desired lens handle
imageURI = link to your profile pic
followModule = address to follow module (This is add when you want some fancy logic happen when someone follow you. In this case we just put Null Address to it)
followModuleInitData = data that use to initialized follow module
followNFTURI = uri for followNFT

And here is a list of what I put

to = <My Address>
handle = <My Desired Handle>
imageURI = https://ipfs.io/ipfs/QmY9dUwYu67puaWBMxRKW98LPbXCznPwHUbhX5NeWnCJbX
followModule = 0x0000000000000000000000000000000000000000
followModuleInitData = 0x00
followNFTURI = https://ipfs.io/ipfs/QmTFLSXdEQ6qsSzaXaCSNtiv6wA56qq87ytXJ182dXDQJS

Now that you filled all of the parameters. Let’s go ahead and click send to create a new Profile!

And then after the transaction is complete. You’re going to have a new Lens Profile of yourself. (You can check the transaction at Polygonscan to verify it too)

Let’s see what it looks like!

I go to tokenOfOwnerByIndex of LensHub contract. go ahead and just out our address (That we just minted a new profile by) and index of 0

It’s going to return us the tokenID of our profile. So that we can use it to query for data again via getProfile request.

Now I just query for the getProfile method. You’ll see the details of my Lens Profile here.

There are also a lot of other methods to call to get data like tokenURI, tokenDataOf But I’ll leave it for you guys to check out!

Tips: We’re going to reuse ProfileID a lot it will be really handy if we store it as a Environment Variable!

Publish a Post

Now that we have our own Lens Profile. Let’s get to create a new post!

Just look for the method post inside the Lens Hub folder. This is the method we’re going to use to publish a post.

Now Let’s fill in the parameters

profileId = your profile id from previous
contentURI = URI to the content of the post
collectModule = address to collect module (remember about follow module? this is similar to it. since anyone can collect any post you who post the content can specify how the collect process is going to be like)
collectModuleInitData = data that use to initialized collect module
referenceModule = address to reference module
collectModuleInitData = data that use to initialized reference module

Again here’s a list of what I put

profileId = 13329
contentURI = https://ipfs.io/ipfs/Qmby8QocUU2sPZL46rZeMctAuF5nrCc7eR1PPkooCztWPz
collectModule = 0x0BE6bD7092ee83D44a6eC1D949626FeE48caB30c
collectModuleInitData = 0x0000000000000000000000000000000000000000000000000000000000000001
referenceModule = 0x0000000000000000000000000000000000000000
collectModuleInitData = 0x00

And after we publish a new post you can read it using method getPub

Here I put pubId = 1 because the index in Lens starts with 1!

And Wallah! We’ve got our post now!

And that’s it! We just create a new Lens Profile and Publish a new post on Lens Protocol! For more information about Lens Protocol please refer to their official documentation at https://docs.lens.xyz/docs

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

Connect with us

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

Explore Lens Protocol with Laika was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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

And some of the Assembly here:

Solidity Tutorial : all about Assembly

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

Explore Seaport Gas Optimization with Laika was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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-laika

npm 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 Laika

npx hardhat laika-sync --contract <contract_name> --address <OPTIONAL address_of_that_contract>

For this example, I’ll use the command

npx 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

Introduction to hardhat-laika was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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 command

npx 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

Building your own Custom Hardhat Plugins from scratch was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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

Laika Blockchain Lab (12 Feb 2022 Update) was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.

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

Laika Blockchain Lab (19 Jan 2022 Update) was originally published in Laika Labs on Medium, where people are continuing the conversation by highlighting and responding to this story.