Сегодня Fuel Labs представляет Yul+, добавляет различные функции QoL к Yul, низкоуровневому промежуточному языку для виртуальной машины Ethereum (EVM).

Yul — невероятно маленький язык, написанный разработчиками Solidity в качестве цели компиляции для дальнейшей оптимизации. У него упрощенная и функциональная низкоуровневая грамматика. Это позволяет разработчику приблизиться к необработанной EVM, чем Solidity, и вместе с этим обещает значительно улучшить использование газа.

Компания Fuel Labs реализовала свой первоначальный контракт optimistic rollup на открытом бета-тестирования с основой Yul+, но мы заметили, что с добавлением даже небольшого количества базовых языковых дополнений, наш код может стать более разборчивым и эффективным.

Yul+ можно рассматривать как экспериментальное обновление для Yul, и Yul может попытаться интегрировать некоторые из его функций позже.

Базовый контракт Yul с конструктором и выполнением по времени:

object "EmptyContract" {
  code {

    // Your constructor code

    datacopy(0, dataoffset("Runtime"), datasize("Runtime"))
    return(0, datasize("Runtime"))
  }
  object "Runtime" {
    code {

       // Your runtime code

    }
  }
}

Обработка вызова данных:

// copy calldata to memory
// this copies 36 bytes of transaction calldata to memory position 0

calldatacopy(0, 0, 36)

Управление памятью:

// store and read memory
// store 0xaa at memory position 100

mstore(100, 0xaa)

// load 32 byte chunk from memory position 100 and assign to someVar

let someVar := mload(100)

Хеширование:

// hash memory position 0 to 0+32, assign result to someHash

let someHash := keccak256(0, 32)

Хранилище состояния:

// store value 0xaa in state storage slot 3

sstore(3, 0xaa)

// get value from state storage 3 and assign to someVar

let someVar := sload(3)

Функции, условия, циклы и переключатели:

// Functions and conditions

function someMethod(someVar, someOther) -> someResult {
   if eq(someVar, someOther) {
      someResult := 0x45
   }
}

// Loops

for { let i := 0 } lt(i, 100) { i := add(i, 1) } {
   // some loop code
}

// Switches

switch someVar
case 0 {
   // when someVar == 0
}

case 1 {
   // when someVar == 1
}

default {
   // default
}

• Все существующие функции языка Yul;

• Перечисления (enum);

• Константы (const);

• Генерация стандартной подписи ABI Ethereum (функция sig);

• Логические значения (истина, ложь);

• Безопасная математика по умолчанию (т. е. защита от переполнения/недостатка потока для сложения, вычитания, умножения);

• Внедряемые методы (mslice и require);

• Структуры памяти (mstruct);

Перечисления, константы и логические значения:

enum Colors (
   Red, // 0
   Blue, // 1
   Green // 2
)

// Constant someConst will equal 1

const someColor := Colors.Blue

// Constant someBool will equal 0x1

const someBool := true

Генерация стандартного ABI-подписи на Ethereum для методов sigs и тем:

// someVar will equal 4 byte method signature 0x6057361d

let someVar := sig”function store(uint256 val)”

// someTopic will equal 32 byte topic hash 0x69404ebde4a368ae324ed310becfefc3edfe9e5ebca74464e37ffffd8309a3c1

let someTopic := topic”event Store(uint256 val)”

Все математические операции теперь безопасны по умолчанию, при желании можно отключить в компиляторе:

let someVar := add(3, sub(4, 2))

// will compile to this, with safeAdd, safeSub methods injected

let someVar := safeAdd(3, safeSub(4, 2))

Добавляем для удобства часть памяти mslice и требуем, если правда:

mstore(300, 0xaabbccdd) // note, mstore left pads zeros by 28 bytes

let someVal := mslice(328, 3) // will return 0xaabbcc

require(gt(someVal, 0)) // someVal > 0 or revert(0, 0) nicely

Наконец, мы включаем структуры памяти. Они используются для описания уже существующих структур в памяти, таких как вызов данных, хэш-данные или любые данные со структурой, записанные в память.

Он предлагает широкий спектр функций позиционирования, смещения, хэширования, индексирования и организации для лучшего управления памятью с помощью аккуратных и эффективных готовых функций, внедряемых по запросу. Мы по-прежнему продолжаем использовать функциональную нотацию внедряемых функций, которая не нарушает существующий стиль грамматики Yul.

// Let’s assume we assign some calldata to memory position 0

// this describes an abstract memory construction:

mstruct SomeCalldata(
   signature: 4,
   value: 32,
)

let methodSig := SomeCalldata.signature(0) // slices out sig
let someVal := SomeCalldata.value(0) // slices out value

// we also get some nice indexing and offset features

SomeCalldata.value.position(0) // equals 4 (i.e. 0 + 4)

// Index ordering values as well

SomeCalldata.signature.index() // equals 0

SomeCalldata.value.index() // equal 1

// Keccak hashing

SomeCalldata.value.keccak256(0) // equals 32 byte hash of value

// Calculate entire size of calldata structure

SomeCalldata.size(0) // equals 36 (i.e. 4 + 32)

object “SimpleStore” {
   code {
      datacopy(0, dataoffset(“Runtime”), datasize(“Runtime”))
      return(0, datasize(“Runtime”))
   }
   object “Runtime” {
      code {
         calldatacopy(0, 0, 36) // copy calldata into memory

         mstruct Calldata( // mstruct describes calldata
            sig: 4,
            val: 32
         )

         switch Calldata.sig(0) // get signature at positive zero

         case sig”function store(uint256 val)” { // store method
            sstore(0, Calldata.val(0))
         }

         case sig”function get() returns (uint256)” { // get method
            mstore(100, sload(0))

            return (100, 32)
         }
      }
   }
}

Yul+ - Low-Level Ethereum DevepmentFuel is a trustless scalable Ethereum side-chain implimentation which can quadratically scale to 2 million TPS.yulp.fuel.sh

В заключение, команда Fuel Labs надеется расширить возможности виртуальной машины Ethereum, создав более низкоуровневые альтернативы, которые мы используем каждый день для создания высокопроизводительной optimistic rollup для масштабирования экосистемы.

А пока, чтобы получить дополнительную информацию и быть в курсе наших работ:

Сайт | Twitter | GitHub | Gitcoin