Learning Assembly

The&nbsp;Professor&nbsp;studies the basics of&nbsp;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&nbsp;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&nbsp;inline assembly, using an assembly block&nbsp;<code><code class="inline-code">assembly { ... }</code></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 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.

&nbsp; &nbsp; &nbsp;2.&nbsp;&nbsp;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="inline-code">+</code>, <code class="inline-code">-</code>, <code class="inline-code">*</code>, <code class="inline-code">/</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="inline-code">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&nbsp;<a 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.&nbsp;<code><code class="inline-code">sdiv</code></code>&nbsp;&amp;&nbsp;<code><code class="inline-code">smod</code></code>).

<a 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&nbsp;<code>add</code>&nbsp;with the correct corresponding opcode.

Similarly, comparison operators like&nbsp;<code><code class="inline-code">&gt;</code></code>,&nbsp;<code><code class="inline-code">&gt;=</code></code>&nbsp;&amp;&nbsp;<code><code class="inline-code">!=</code></code>&nbsp;are not available in Yul's syntax. Even the&nbsp;<code><code class="inline-code">&amp;&amp;</code></code>&nbsp;and&nbsp;<code><code class="inline-code">||</code></code>&nbsp;syntax are not recognised.

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

<a 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&nbsp;<code><code class="inline-code">Comparisons.sol</code></code>&nbsp;using&nbsp;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&nbsp;<a href="https://docs.soliditylang.org/en/v0.8.9/yul.html#evm-dialect">EVM dialect table</a>):

There is no opcode for&nbsp;<code class="inline-code">&lt;=</code>&nbsp;and&nbsp;<code class="inline-code">&gt;=</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&nbsp;<code class="inline-code">if</code>&nbsp;statement.

Implement the function present in <code class="inline-code">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&nbsp;<code class="inline-code">if</code>&nbsp;syntax in assembly is almost the same as the one in Solidity.

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

If we want to handle multiple potential conditions, we can use a&nbsp;<code><code class="inline-code">switch</code></code>.

<code><code class="inline-code">Switch.sol</code></code>&nbsp;wishes to implement the following function.

Implement the function present in&nbsp;<code><code class="inline-code">Switch.sol</code></code>&nbsp;using&nbsp;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&nbsp;<code><code class="inline-code">break</code></code>&nbsp;or&nbsp;<code><code class="inline-code">continue</code></code>.

<code><code class="inline-code">For.sol</code></code>&nbsp;wishes to implement the following function.

Implement the function present in&nbsp;<code><code class="inline-code">For.sol</code></code>&nbsp;using&nbsp;only inline assembly.

Assembly For statement

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

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 functionsx in&nbsp;<code><code class="inline-code">SafeMath.sol</code></code>&nbsp;using&nbsp;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.&nbsp;

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.&nbsp;

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.&nbsp;

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.&nbsp;

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.

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

Yul Basics

prelude