Verify Off-chain Results and Whitelist With ECDSA in Solidity Using OpenZeppelin and Ethers.js
Offloading expensive computation to off-chain for saving gas, as simple & fast as possible
Table of Contentsi. Introduction
ii. Practical example
iii. Conclusion
Introduction
Ethereum’s high gas problem should not be unfamiliar to you, as a crypto trader, a blockchain developer, or just an enthusiast in the space. With Ether's price standing strong in the $3000 area and gas price on the rise averaging 50–70 Gwei, the gas fee for every transaction is getting more expensive and takes about $4 USD for a simple transfer.
There is a way to go around the gas problem, is to put this computation off-chain and let the server do the work.
A lot of tutorials online teaching ECDSA involves the use of maths, something about s, r, v, which we all developers (code monkeys) can agree, is boring and difficult to implement without bugs. So in this article, we are just gonna use the built-in functions from contracts written by OpenZeppelin and Ethers.js to build this feature.
Practical example
In this project, we are going to use a common use case for ECDSA to demonstrate the method, which is setting up a whitelist for an NFT project, and include code snippets to help you get started.
This project is written in JavaScript and Solidity.
1. Setup
To prepare for ECDSA, you should create a new wallet and use it only for this project as the signature signer. Do not use this wallet for any other purpose but only for signing the message in this project.
After creating the wallet, save its private key for later use.
2. Off-chain Signature
2.1. To get started, we will need to first install Ether.js by running:
npm run ethersand importing it into the project by:
import ethers from ethers2.2. Then we can initialize the signer instance by creating a new Wallet using the library:
const signer = new ethers.Wallet("0x" + "<your private key>");Remember to add 0x in the prefix of your private key if you exported directly from Metamask.
2.3. Pack the message together, and we can try to pack the address and the nonce for whitelisting:
let message = ethers.utils.solidityPack(["address", "uint256"], ["0xabc", "0"]);This is to concatenate the message together to be hashed in the next section. Ethers.js supports a wide range of variables, including string and array like uint256[]:
2.4. Hash the message with keccak256 and sign with the signer wallet:
message = ethers.utils.solidityKeccak256(["bytes"], [message]);
const signature = await signer.signMessage(ethers.utils.arrayify(message));This signature is the signature signed for the message with the signer's private key.
We can pass this signature along with the verified parameters into the blockchain to ensure that the parameters are valid.
The whole code snippet:
3. On-chain Verification
3.1. To verify the signature on-chain, we can make use of the contract EDCSA written by OpenZeppelin. To use it, install Openzepplin locally or use it in Remix:
npm install @openzeppelin/contracts3.2. Set up the storage for signer on-chain with a setter:
address signer;function setSigner(address _signer) external {
signer = _signer;
}
3.3. Then pack the values together by abi.encodePacked and hash it with keccack256:
bytes32 hash = keccak256(abi.encodePacked(msg.sender, nonce));3.4. Turn the signature to an Ethereum signed message:
bytes32 message = ECDSA.toEthSignedMessageHash(hash);3.5. Recover the signer address from the signature:
address receivedAddress = ECDSA.recover(message, signature);3.6. Check if the signer of the message matches the signer store on-chain, only approve if the signer matches:
require(receivedAddress != address(0) && receivedAddress == signer);The whole code snippet is:
Conclusion
And now you learned how to use ECDSA as simply as possible, without the use of any complex maths. However, there are also tradeoffs of putting computation off-chain but that is beyond the scope of this article. I am going to explain more on this so follow to stay tuned!
