In Solidity, several key functions for encoding and decoding data are encode, encodePacked decode string.concat ,bytes.concat and finally, type casting using bytes or strings.
These functions allow you to convert Solidity data types like strings, integers, addresses, etc., into a compact binary representation and back again.
Understanding how to encode and decode data properly is essential when building smart contracts that need to emit events, return data to clients, or interact with external contracts and protocols.
Not having a good idea of how to get this done can lead to bugs, unintended behavior, or wasted gas fees.
In this article, we will take a low-level look at how these Solidity encoding functions work under the hood. We'll explore the key differences between encode and encodePacked and when to use each. We'll also cover some common pitfalls and issues that can arise when encoding and decoding data in your contracts.
Like Patrick will say, let's dive into the rabbit hole. Hope to see you on the other side.
Prerequisite
Basic knowledge of Solidity or any programming language
abi.encode
abi.encode is a function in Solidity that is part of the Application Binary Interface (ABI) encoding mechanism. It mostly encodes multiple values in a tightly packed binary format.
function encodeValue() public pure returns (bytes memory){
bytes memory vals = abi.encode("Scofield course", "is easy to grasp");
return vals;
}
For example, we want to encode "scofield course" and "is easy to grasp" We create our function and set the memory to bytes memory, remembering anything stored on the memory is not retained, unlike storage that stores value.
We create a bytes variable, encode our value into it, and then return the value in vals
while abi.encode packs all the values together. There is quite many padding, and this is why the need for abi.encodePacked is needed
abi.encodePacked
Next is abi.encodePacked this function is specifically designed for tightly packing multiple values without adding any padding. It concatenates the raw binary data of each parameter.
An example
function encodeValue2() public pure returns (bytes memory){
bytes memory vals = abi.encodePacked("Scofield course", "is easy to grasp");
return vals;
}
Same example as above, but we only changed how it is packed, so here is the result.
The packed version removes all padding while we only get the value in return, saving us gas and allowing us to still use the byte's value retrieved.
TypeCasting
Typecasting refers to the explicit conversion of a variable from one data type to another.
If you know a bit about typecasting, you can argue, why don’t we just typecast and get the same result? If you are a beginner, check this article to learn more about typecasting,
function encodeB() public pure returns(bytes memory) {
bytes memory value = bytes("Scofield course", "is easy to grasp");
return value;
}
We tested that and got this error.
TypeError: Exactly one argument expected for explicit type conversion.
--> encode.sol:18:30:
|
18 | bytes memory value = bytes("Scofield course", "is easy to grasp");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
We could only take one argument at a time, which, if we still went to use this method, we might have to set more bytes memory like so
function encodeB() public pure returns(bytes memory, bytes memory) {
bytes memory value1 = bytes("Scofield course");
bytes memory value2 = bytes("is easy to grasp");
return (value1, value2);
Notice we still have to separate them, and the result, even if they are are same, but we have them in separate memory, which is not what we are after.
bytes.concat
bytes.concat specializes in concatenating together raw byte arrays, ensuring the result is a properly aligned byte array. It lacks abi.encodePacked's versatility around handling multiple data types.
function encodB() public pure returns(bytes memory) {
bytes memory value = bytes.concat("my name is ", "scofield");
return value;
}
bytes.concat joins byte arrays end-to-end, preserving alignment. It only works on byte arrays.
Remember, it can only work for certain data types and not for all, like encode
string.concat
The string.concat function in Solidity allows you to join multiple strings together into a new single string. This avoids having to add them together with basic string addition manually.
function encodB() public pure returns(string memory) {
string memory value = string.concat("my name is ", "scofield");
return value;
}
Here, we added ‘my name is” to “scofield and the result below is
abi.decode
If you are wondering if we might be able to get our converted value back after conversion, then you are right; we can, with the abi.decode.
abi.decode allows you to decode encoded parameters from external contract calls. It unpacks encoded data so your Solidity contract can work with the original values again.
Decoding data parameters with abi.decode is essential for working with return values from external contract function calls. It also enables your contract to accept and process encoded input parameters from users and other contracts.
For example
function decodeValue() public pure returns (string memory){
string memory vals = abi.decode(encodeValue() , (string));
return vals;
}
we have to change memory from bytes to strings as we convert back to strings and then copy the function encodeValue() plus the (string), which outputs this.
OH NO!!!!
We only get back half of our encoded value; what happened to the other half? if you can figure it out, leave a comment below to let me know.