Learning Assembly

In some specific cases, assembly, and its full control over memory, is the most efficient way to optimize a snippet of code.

Practice using inline assembly in your Solidity smart contracts to further optimize them, to an extent vanilla Solidity does not offer!

Assembly Optimization

Equipped with the knowledge of Solidity's storage model, we can now execute some gas optimization tricks. Explore how the reordering of state variables and the use of memory caching can save some functions a considerable amount of gas.

Storage Efficiency

The Solidity compiler packs state variables in a contract's storage space in a prudent manner. Walk through how the different types of variables are interpreted and kept in storage.

Storage Layout

Although found in niche use cases, the ability to discern a delegate call from an ordinary external call could be useful. Figure out how this can be done with some simple engineering.

Delegate Call Detection

To newer developers, the use of call() and delegatecall() can be intimidating. Especially since it seems more verbose or dangerous. However, these low-level calls are crucial to many use-cases. In this quest, learn the EVM Application Binary Interface (ABI) and how to safely use these calls.

Low-Level Calls

The first of the fabled Five Pillars, The Professor is the master of languages and ways to communicate with and interpret the Weave. To pass his trial and prove yourself worthy, you must demonstrate your mastery of the old tongue. Fail, and who knows what will happen…

Inline assembly is written in the Yul language. In this quest, learn about the basics of the language and the incorporation of inline assembly into Solidity contracts.

The Professor studies the basics of Inline Assembly. Let us first understand the what is inline assembly.

As we know, when we program in Solidity, we first compile the Solidity code into assembly bytecode before we can execute it on the EVM. During compilation, Solidity code is transformed into a series of assembly instructions, where each typically consists of an opcode (i.e. a command) and some arguments.

We typically do not have to worry about assembly when developing EVM contracts as this is abstracted away from us by Solidity. However, there are times when we wish to have finer control over the resultant bytecode, and would like to program in assembly.

Solidity allows us to interleave our code with inline assembly, using an assembly block <code class="richtext rt-inlinecode">assembly { ... }</code>.

Within the assembly block, Solidity code will not be recognised. Instead, we will have to program in the Yul language. As we will see in this campaign, the Yul language closely resembles EVM assembly language.

lightBulb

Yul assembly's syntax differs wildly from Solidity syntax.

<a class="richtext rt-link" target="_blank" rel="noopener noreferrer" href="https://github.com/Nodeguardians/ng-quests/blob/develop/campaigns/learning-assembly/yul-basics/description/part1.md#managing-variables"></a>Managing Variables

All variables in inline assembly are 256 bit values. There are two ways to access variables.

     2.  Access parameters, return variables, or other local variables declared in the outer scope.

Inline assembly cannot directly access storage variables. These variables must first be copied into a local variable.

Read the description above and understand what Yul Assembly is.

Inline Yul Assembly

Cryptomancy can be a delicate art. A finer control over the magic will require a different language.

As previously mentioned, basic arithmetic operators like <code class="richtext rt-inlinecode">+</code>, <code class="richtext rt-inlinecode">-</code>, <code class="richtext rt-inlinecode">*</code>, <code class="richtext rt-inlinecode">/</code> are not readily available in inline assembly’s syntax.

Instead, we will need to use opcodes to access this feature.

Implement the functions present in <code class="richtext rt-inlinecode">Arithmetic.sol</code> using only inline assembly.

Simple Arithmetic

Prove to the Professor that you can speak in the old tongue.

Take a look at the first few rows of the Yul dialect table. You will find the opcodes you need.

You need only match each function to the needed opcode to solve the quest.

Multiplication / Division for signed integerss

Why is there signed versions for division and modulo, but not for the other operations?

Signed integers in Solidity are encoded with <a class="richtext rt-link" target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Two%27s_complement" rel="nofollow">Two's complement</a>.

Two's complement allows for seamless addition, subtraction and multiplication for both positive and negative numbers. But directly dividing integers with different signs can yield unexpected results.

Hence, special opcodes are needed to handle signed division (i.e. <code class="richtext rt-inlinecode">sdiv</code> & <code class="richtext rt-inlinecode">smod</code>).

<a class="richtext rt-link" target="_blank" rel="noopener noreferrer" href="https://github.com/Nodeguardians/ng-quests/blob/develop/campaigns/learning-assembly/yul-basics/solution/walkthrough2.md#using-the-instructions"></a>Using the instructions

The syntax for each assembly block is the same. Just replace <code>add</code> with the correct corresponding opcode.

Similarly, comparison operators like <code class="richtext rt-inlinecode">></code>, <code class="richtext rt-inlinecode">>=</code> & <code class="richtext rt-inlinecode">!=</code> are not available in Yul's syntax. Even the <code class="richtext rt-inlinecode">&&</code> and <code class="richtext rt-inlinecode">||</code> syntax are not recognised.

Like before, there are Yul opcodes to achieve these functionality.

<a class="richtext rt-link" target="_blank" rel="noopener noreferrer" href="https://github.com/Nodeguardians/ng-quests/blob/develop/campaigns/learning-assembly/yul-basics/description/part3.md#your-task"></a>Your Task

Implement the functions present in <code class="richtext rt-inlinecode">Comparisons.sol</code> using only inline assembly.

Comparisons

The Professor smiles, seeing you begin to understand, then continues testing your abilities with the old tongue.

Here is a summary of the relevant opcodes (all found in the <a class="richtext rt-link" target="_blank" rel="noopener noreferrer" href="https://docs.soliditylang.org/en/v0.8.9/yul.html#evm-dialect">EVM dialect table</a>):

There is no opcode for <code class="richtext rt-inlinecode"><=</code> and <code class="richtext rt-inlinecode">>=</code>. However, these can be emulated with two comparison checks.

Also, recall that all variables in assembly are 256 bit values, even booleans. All of the instructions shown in the table above return a 256 bit value (either 0 or 1).

Just as in higher level programming languages, control flow is possible with inline assembly. The most basic way to do this is through the <code class="richtext rt-inlinecode">if</code> statement.

Implement the function present in <code class="richtext rt-inlinecode">If.sol</code> using only inline assembly.

Assembly If statement

The moment you think you’ve got a grasp of the old tongue, the Professor begins using even more tricky and arcane phrases.

The <code class="richtext rt-inlinecode">if</code> syntax in assembly is almost the same as the one in Solidity.

In order to revert from assembly, we need the <code class="richtext rt-inlinecode">revert(x, y)</code> instruction. There is no need to concern ourselves with what <code class="richtext rt-inlinecode">x</code> and <code class="richtext rt-inlinecode">y</code> is for now. For this quest, we can safely revert using <code class="richtext rt-inlinecode">revert(0, 0)</code>.

If we want to handle multiple potential conditions, we can use a <code class="richtext rt-inlinecode">switch</code>.

<code class="richtext rt-inlinecode">Switch.sol</code> wishes to implement the following function.

Implement the function present in <code class="richtext rt-inlinecode">Switch.sol</code> using only inline assembly.

Assembly Switch statement

For the first time, you begin to worry. The Professor knows words in the old tongue you’ve never heard before.

A switch statement allows you to handle several potential values easily. The syntax is similar to the one in most other languages.

Looping is also supported in inline assembly, with the ability to <code class="richtext rt-inlinecode">break</code> or <code class="richtext rt-inlinecode">continue</code>.

<code class="richtext rt-inlinecode">For.sol</code> wishes to implement the following function.

Implement the function present in <code class="richtext rt-inlinecode">For.sol</code> using only inline assembly.

Assembly For statement

You begin to sweat. The Professor now seems to be deliberately trying to trip you up. 

You have reached the final phase of the Professor’s trial. You will need to put what you have learnt so far to the test.

Since v0.8.0, Solidity arithmetics supports overflow and underflow checks. For example:

Inline assembly, being more primitive, does not support these checks.

Using inline assembly, let us mimic Solidity arithmetics by building a contract that supports safe operations:

For all these operations, execution should revert if there will be integer overflow or underflow.

Implement the functions in <code class="richtext rt-inlinecode">SafeMath.sol</code> using only inline assembly.

Assembly SafeMath

It seems you can understand the mystical language. But are you truly fluent?

You lose track of time, answering the Professor’s many questions and riddles as fast as you can. You thought you knew the old tongue pretty well, but he makes you feel like a beginner. 

Then, just as you begin to feel you’re completely out of your depth, he stops and lets a slight grin touch his lips.

Well done, Guardian. You can color me impressed! Not many people, even in the Academy, have such a grasp of the ancient languages.

You smile. I get the impression he isn’t impressed by many people. It appears your years of study have paid off. 

But if this was only the first test, you dread to think what’s coming next…

You have traveled far, and now stand facing the hidden door to the Pillars’ sanctum. A place of legends, known only by those deemed worthy.

Before you can knock, the door opens, and you find yourself facing an eccentric old man. He wears a simple robe, and has a deeply knowing look in his eyes. 

Guardian, you have answered our call. I am the Professor, first of the Pillars. I only hope you will prove to be enough…

Ushering you through the door, the Professor fills you in on what you have let yourself in for. You must pass four perilous trials, one set by each of the living Pillars. Pass all four, and you will be accepted into their number. Fail, and… well, you would not be the first to pass through these doors never to return. Only the most brilliant can join the Pillars, and anyone who fails to prove themselves can’t be allowed to speak of what they saw down here.

Let the trials begin. You will have to first face the Professor’s test to proceed…

In this quest, we have learnt how to use basic inline assembly syntax to:

These seem like a lot of opcodes. However, just like programming in most languages, there is no need to memorize syntax nor function names. All we need to know is that they are available and which documentation we can refer to.

Inline assembly creates more complex and less readable code than regular Solidity. Furthermore, without type checking, variables can silently underflow or overflow, resulting in sneaky vulnerabilities in our smart contracts.

So why do we use it? Inline assembly gives us more control over the final compiled bytecode. As we will see further into the campaign, this allows interesting actions and gas optimizations.

Yul Basics

prelude