Fase 1 · Solidity & Smart Contract

Solidity — sintaks dasar & tipe data

Solidity terlihat mirip TypeScript atau Java kalau dilihat sepintas. Tapi beberapa perbedaan kecil di tipe data dan struktur kontraknya bukan gaya penulisan — melainkan konsekuensi langsung dari berjalan di lingkungan yang setiap byte-nya berbayar dan setiap state-nya permanen.

Sumber asli docs.soliditylang.org Resmi Rangkuman ~8 menit baca

Intisari

Satu file Solidity diawali pragma solidity ^0.8.x — menyatakan compiler mana yang boleh dipakai, mencegah kontrak ter-compile dengan versi yang perilakunya berbeda.
Tipe angka Solidity tidak punya desimal/float — uint256 adalah bilangan bulat tanpa tanda 256-bit. Uang direpresentasikan sebagai integer dengan satuan terkecil (mis. wei), persis pola "simpan uang sebagai integer sen" yang sudah kamu kenal dari database.
Sejak Solidity 0.8.0, overflow/underflow aritmetika otomatis revert — bukan lagi wrap-around diam-diam seperti versi sebelumnya.
mapping mirip HashMap/associative array, dengan satu perbedaan besar: tidak bisa di-iterasi dan tidak menyimpan daftar key-nya sendiri.
Visibility (public/private/internal/external) berlaku untuk state variable dan fungsi — tapi "private" di sini cuma soal siapa yang bisa memanggil, bukan soal kerahasiaan data (data di blockchain selalu bisa dibaca siapa saja, dibahas di Fase 4).

Kerangka satu kontrak

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Sertifikat {
    // State variable — permanen, tersimpan di storage on-chain
    address public penerbit;
    uint256 public totalDiterbitkan;

    // Reference type: mapping, tidak bisa di-iterasi
    mapping(address => uint256) public saldo;

    constructor() {
        penerbit = msg.sender;   // pembuat kontrak, tercatat sekali di awal
    }

    function terbitkan(address ke, uint256 jumlah) external {
        require(msg.sender == penerbit, "Hanya penerbit");
        saldo[ke] += jumlah;
        totalDiterbitkan += jumlah;
    }
}

Bagian	Analog	Catatan
`pragma solidity`	`package.json` "engines"	Wajib di baris pertama; compiler menolak jika versi tidak cocok
`contract`	`class`	Satu file boleh berisi banyak kontrak; satu deploy = satu instance on-chain
State variable	Kolom tabel database	Setiap penulisan berharga gas — lihat Fase 0 soal storage
`constructor`	Constructor kelas	Jalan satu kali, saat deploy — tidak bisa dipanggil lagi setelahnya
`msg.sender`	`request.user`	Address yang memanggil fungsi saat ini — sumber otorisasi paling umum

Tipe data: tidak ada float, dan itu keputusan sadar

Tipe	Artinya	Analog
`uint256`	Integer tanpa tanda, 256-bit — tipe angka paling umum dipakai	`BigInteger` unsigned di Java
`int256`	Integer bertanda, 256-bit	`BigInteger` biasa
`address`	20 byte, alamat akun/kontrak	Foreign key ke "tabel" akun
`address payable`	`address` yang boleh menerima native coin	—
`bool`	true/false	Sama seperti bahasa lain
`bytes32`	32 byte tetap, sering untuk hash/ID	`binary(32)` di MySQL
`string`	UTF-8 dinamis	Mahal disimpan di storage — hindari untuk data besar
`mapping(K => V)`	Key-value, tidak bisa di-iterasi	`HashMap<K,V>` tanpa `.keys()`

Tidak ada tipe desimal karena EVM tidak punya floating point sama sekali. Representasi uang di Solidity selalu integer dalam satuan terkecil — persis pola "simpan harga sebagai sen, bukan float" yang sudah jadi praktik baik di database keuangan mana pun. Token dengan "18 desimal" (standar ERC-20) berarti 1 token utuh = 1_000_000_000_000_000_000 unit integer di balik layar.

Overflow: dulu bug diam-diam, sekarang error keras

Sebelum Solidity 0.8.0, uint8 x = 255; x += 1; akan diam-diam menjadi 0 — celah keamanan klasik yang pernah dieksploitasi di banyak kontrak nyata. Sejak 0.8.0, operasi aritmetika standar otomatis memeriksa overflow/underflow dan revert transaksi kalau terjadi:

uint8 x = 255;
x += 1;   // REVERT sejak 0.8.0 — bukan lagi diam-diam jadi 0

// Kalau kamu YAKIN overflow tidak mungkin terjadi dan mau menghemat gas
// dari pengecekan otomatis, harus eksplisit:
unchecked {
    x += 1;   // sekarang berperilaku seperti versi lama — wrap ke 0
}

Visibility — bukan soal kerahasiaan

Visibility	Bisa dipanggil dari
`public`	Di mana saja — dalam kontrak, kontrak turunan, kontrak lain, transaksi eksternal
`external`	Hanya dari luar kontrak (transaksi/kontrak lain) — lebih murah gas untuk parameter besar
`internal`	Kontrak ini dan turunannya saja
`private`	Hanya kontrak ini, tidak diwariskan

Jebakan konseptual paling penting di seluruh Solidity: private dan internal hanya membatasi siapa yang boleh memanggil fungsi lewat bytecode kontrak itu sendiri. Semua data — termasuk state variable private — tetap bisa dibaca siapa saja langsung dari storage node lewat RPC (eth_getStorageAt), karena blockchain publik memang didesain transparan sepenuhnya. Jangan pernah menyimpan data rahasia (harga jual sebelum diumumkan, kata sandi, dsb.) di state variable — private Solidity bukan private Java.

Latihan: tulis kontrak Sertifikat di atas di Remix, deploy ke JavaScript VM (in-browser, gratis). Panggil terbitkan() dari akun selain penerbit dan amati pesan revert-nya. Lalu buka tab "Storage" debugger Remix dan cari nilai saldo milik satu address — buktikan sendiri bahwa data itu terlihat penuh meski variabelnya dideklarasikan public.

Rangkuman ini sengaja dipangkas ke bagian yang dipakai di roadmap. Buka sumber aslinya saat kamu butuh detail lengkap atau referensi parameter.