Belajar Solidity - Advanced: Assembly (Yul) & Meta-Programming

#Pendahuluan

Setelah di episode 20 kalian memahami L2 dan evolusi EVM, pada episode ini kita mencapai level lanjutan: assembly (Yul) dan pola-pola meta-programming yang dipakai protokol canggih.

Mengapa episode ini penting? Karena di sinilah kalian membedakan diri sebagai developer. Memahami opcode dan pola lanjutan bukan hanya soal efisiensi — ia membuka kemampuan membaca kontrak kompleks (seperti protokol besar), men-debug masalah gas yang sulit, dan merancang arsitektur modular. Episode 19 memperkenalkan assembly; di sini kita dalami plus tiga EIP yang membentuk masa depan.

#Inline Assembly: Bekerja di Level Opcode

assembly memungkinkan kalian menulis Yul — bahasa tingkat rendah yang dipetakan hampir 1:1 ke opcode EVM. Contoh khas: membaca seluruh slot dengan presisi.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.36;
 
contract AssemblyReader {
    uint256 private constant DATA_SLOT = 0;
 
    function readSlot() external view returns (uint256 value) {
        assembly {
            value := sload(DATA_SLOT)
        }
    }
 
    // Simpan 128-bit tinggi + 128-bit rendah dalam satu slot
    function pack(uint128 high, uint128 low) external pure returns (uint256) {
        assembly {
            let result := shl(128, high)
            result := or(result, low)
            mstore(0, result)
            return(0, 32)
        }
    }
}

Beberapa opcode yang paling sering dipakai:

Yul juga bisa menangani error dengan biaya minimal (revert dengan data custom yang lebih ringkas daripada string) dan mengoptimalkan hot path — persis seperti yang kita lihat di episode 19.

#Optimasi Storage Read/Write dengan Yul

Pola produksi nyata: menggabungkan beberapa field kecil dalam satu uint256 dan memprosesnya dengan assembly — satu SLOAD/SSTORE untuk semua field:

uint256 private packed; // [16 bit][16 bit][128 bit][96 bit]
 
function set(uint128 amount, uint96 limit) external {
    assembly {
        let current := sload(packed.slot)
        // timpa 128-bit pertama dengan amount, 96-bit berikutnya dengan limit
        let mask := sub(0, shl(128, 1)) // mask 128-bit
        current := and(current, shl(128, not(mask))) // bersihkan field amount
        current := or(current, amount)
        sstore(packed.slot, current)
    }
}

Ini bentuk paling agresif dari teknik packing episode 6 — satu SSTORE menggantikan banyak, dan pembacaan lengkap cukup satu SLOAD. Dipakai oleh protokol yang sangat sadar gas.

#Diamond: EIP-2535

Diamond (EIP-2535) adalah pola modularitas ekstrem: satu kontrak (diamond) yang men-delegatecall ke banyak facet (implementasi), di mana setiap facet menangani sekelompok fungsi.

Keuntungannya:

• Modular — setiap fitur di kontrak terpisah, mudah di-audit dan di-upgrade terpisah.
• Mengatasi batas ukuran kontrak — bytecode tak lagi dibatasi 24KB; diamond bisa "menumbuhkan" fungsi baru.
• Upgrade per-fiturt — menambah/mengganti satu facet tanpa menyentuh yang lain.

Kekurangannya: kompleksitas selector routing dan manajemen storage antar-facet yang harus sangat hati-hati. Diamond cocok untuk protokol sangat besar; untuk sebagian besar proyek, UUPS lebih sederhana dan cukup.

#Account Abstraction: ERC-4337

ERC-4337 membawa account abstraction ke Ethereum tanpa perubahan protokol. Alih-alih wallet EOA klasik, pengguna memakai smart accounts yang dikendalikan logika:

• Multi-sig & recovery — wallet bisa diatur tanpa kunci tunggal; kehilangan key tidak berarti kehilangan dana.
• Social recovery — pemulihan lewat penjaga.
• Gas sponsorship — transaksi bisa dibayar pihak lain (paymaster).
• Batching & automation — beberapa operasi dalam satu transaksi, termasuk transaksi yang dipicu otomatis.

Cara kerjanya: UserOperation (deskripsi aksi user) diproses off-chain, dibundle oleh relayer, dan diverifikasi on-chain melalui EntryPoint. Kontrak kalian tidak perlu berubah untuk dipakai smart accounts — karena EntryPoint menandatangani dengan sender yang benar.

#Token-Bound Accounts: ERC-6551

ERC-6551 memberikan setiap NFT akun sendiri — wallet kecil yang dikendalikan oleh pemegang NFT. Implikasinya besar:

• NFT bisa menyimpan aset (token, NFT lain, bahkan posisi DeFi).
• NFT bisa berinteraksi dengan protokol — game item yang "memegang" perlengkapan, avatar yang memiliki koleksi.
• Setiap token tetap portable — pindah kepemilikan NFT berarti pindah akunnya.

Implementasinya: registry men-deploy/me-resolve akun per (tokenContract, tokenId) via create2 — alamat deterministik tanpa deploy manual.

#Menyusun Strategi: Kapan Pakai Apa

#Penutup

Inti yang harus dibawa pulang:

• Yul memberi kendali opcode: sload/sstore/shl/call — hemat gas tapi wajib fuzz test.
• Diamond (EIP-2535) memecah kontrak raksasa jadi facet modular yang bisa di-upgrade terpisah.
• ERC-4337 menghadirkan smart accounts: recovery, gasless, batching tanpa ubah protokol.
• ERC-6551 memberi tiap NFT akun sendiri untuk menyimpan aset dan berinteraksi dengan protokol.
• Pakai pola canggih hanya saat kebutuhan jelas — kompleksitas adalah biaya.

Di episode 22 selanjutnya, episode pamungkas, kita akan membahas ekosistem, alternatif & refleksi akhir — perbandingan Solidity vs Vyper vs Rust (Solana) vs Move (Aptos/Sui) vs Cairo (Starknet), kapan memilih tiap bahasa, rekap seluruh series, dan checklist production untuk deploy kontrak profesional. Sampai jumpa di episode 22!