Jadi teman-teman, kita terus mempelajari Petunjuk Aleo. Selanjutnya adalah Panduan Bahasa. Ayo pergi!

Diketik Secara Statis​

Instruksi Aleo adalah bahasa yang diketik secara statis, yang berarti kita harus mengetahui tipe setiap variabel sebelum mengeksekusi suatu rangkaian.

Jenis Eksplisit Diperlukan​

Tidak ada nilai undefined atau null dalam instruksi Aleo. Saat menetapkan variabel baru, jenis nilainya harus dinyatakan secara eksplisit.

Lewati Nilai​

Ekspresi dalam instruksi Aleo selalu diteruskan berdasarkan nilai, yang berarti nilainya selalu disalin ketika digunakan sebagai input fungsi atau di sisi kanan tugas.

Daftar berdasarkan​

Tidak ada nama variabel dalam instruksi Aleo. Semua variabel disimpan dalam register yang dilambangkan rX dengan X adalah bilangan bulat non-negatif yang dimulai dari 0 r0, r1, r2, etc..

Tipe dan Nilai Data​

Boolean""

Instruksi Aleo mendukung nilai boolean true atau false tradisional. Tipe boolean yang eksplisit untuk boolean dalam pernyataan diperlukan.

function main:
    input r0: boolean.private;

bilangan bulat""

Instruksi Aleo mendukung tipe integer bertanda i8, i16, i32, i64, i128 dan tipe integer tak bertanda u8, u16, u32, u64, u128.

function main:
    input r0: u8.public;

INFORMASI

Bilangan bulat dengan panjang bit yang lebih tinggi menghasilkan lebih banyak batasan dalam rangkaian, yang dapat memperlambat waktu komputasi.

Elemen Bidang​

Instruksi Aleo mendukung tipe field untuk elemen bidang dasar kurva elips. Ini adalah bilangan bulat tak bertanda di bawah modulus bidang dasar.

function main:
    input r0: field.private;

Elemen Grup​

Himpunan titik-titik affine pada kurva elips yang diteruskan ke penyusun instruksi Aleo membentuk sebuah grup. Leo mendukung subgrup dari grup ini, yang dihasilkan oleh titik generator, sebagai tipe data primitif. Elemen grup bersifat spesial karena nilainya dapat ditentukan dari koordinat x dari pasangan koordinat, misalnya 0group. Kata kunci tipe grup group harus digunakan saat menentukan nilai grup.

function main:
    input r0: group.private;

Elemen Skalar""

Instruksi Aleo mendukung tipe scalar untuk elemen bidang skalar dari subgrup kurva elips. Ini adalah bilangan bulat tak bertanda di bawah modulus bidang skalar.

function main:
    input r0: scalar.private;

Alamat​

Alamat didefinisikan untuk mengaktifkan rutinitas yang dioptimalkan kompiler untuk penguraian dan pengoperasian melalui alamat.

function main:
    input r0: address.private;

Tata Letak Program Aleo​

Sebuah program Aleo berisi deklarasi dari ID Program, Impor, Fungsi, Penutupan, Struktur, Catatan, Pemetaan, dan Finalisasi. Pemesanan hanya diberlakukan untuk impor yang harus berada di bagian atas file. Deklarasi dapat diakses secara lokal dalam file program. Jika Anda memerlukan deklarasi dari file program lain, Anda harus mengimpornya.

ID Program​

ID program dinyatakan sebagai {name}.{network}. Karakter pertama dari name harus huruf kecil. name dapat berisi huruf kecil, angka, dan garis bawah. Saat ini, aleo adalah satu-satunya domain network yang didukung.

program hello.aleo; // valid
program Foo.aleo;   // invalid
program baR.aleo;   // invalid
program 0foo.aleo;  // invalid
program 0_foo.aleo; // invalid
program _foo.aleo;  // invalid

Impor​

Impor dideklarasikan sebagai import {ProgramID};.
Impor mengambil deklarasi lain berdasarkan ID programnya dan membawanya ke dalam cakupan file saat ini. Anda dapat mengimpor dependensi yang diunduh ke direktori imports.

import foo.aleo; // Import the `foo.aleo` program into the `hello.aleo` program.
program hello.aleo;

Fungsi ​

Suatu fungsi dideklarasikan sebagai function {name}:.
Fungsi berisi instruksi yang dapat menghitung nilai. Fungsi harus berada dalam lingkup program saat ini agar dapat dipanggil.

function foo:
    input r0 as field.public;
    input r1 as field.private;
    add r0 r1 into r2;
    output r2 as field.private;

Masukan Fungsi​

Input fungsi dideklarasikan sebagai input {register} as {type}.{visibility};.
Input fungsi harus dideklarasikan tepat setelah deklarasi nama fungsi.

// The function `foo` takes a single input `r0` with type `field` and visibility `public`.
function foo:
    input r0 as field.public;

Keluaran Fungsi​

Output fungsi dideklarasikan sebagai output {register} as {type}.{visibility};.
Output fungsi harus dideklarasikan di akhir definisi fungsi.

...
    output r0 as field.public;

Panggil Fungsi​

Dalam protokol Aleo, pemanggilan suatu fungsi akan menciptakan transisi yang dapat menggunakan dan menghasilkan catatan secara on-chain. Gunakan perintah aleo run CLI untuk meneruskan input ke suatu fungsi dan menjalankan program.
Di Testnet3, fungsi program tidak dapat memanggil fungsi program internal lainnya. Jika Anda ingin mengembangkan 'fungsi pembantu' yang dipanggil secara internal dalam suatu program, cobalah menulis closure.

Memanggil Fungsi yang Diimpor​

Program Aleo dapat memanggil program Aleo lainnya secara eksternal menggunakan instruksi call {program}/{function} {register} into {register}.

import foo.aleo;
program bar.aleo;
function call_external:
    input r0 as u64.private;
    call foo.aleo/baz r0 into r1; // Externally call function `baz` in foo.aleo with argument `r0` and store the result in `r1`.
    output r1;

Penutupan""

Penutupan dinyatakan sebagai closure {name}:.
Penutupan berisi instruksi yang dapat menghitung nilai. Penutupan adalah fungsi pembantu yang tidak dapat dijalankan secara langsung. Penutupan dapat dipanggil oleh fungsi lain.

closure foo:
    input r0 as field;
    input r1 as field;
    add r0 r1 into r2;
    output r2 as field;

Panggil Penutupan""

Program Aleo dapat memanggil penutupan Aleo lainnya secara internal menggunakan instruksi call {name} {register} into {register}.

program bar.aleo;
function call_internal:
    input r0 as u64.private;
    call foo r0 into r1; // Internally call closure `foo` with argument `r0` and store the result in `r1`.
    output r1;

Struktur​

Struct adalah tipe data yang dideklarasikan sebagai struct {name}:.
Struct berisi deklarasi komponen {name} as {type}.

struct array3:
    a0 as u32;
    a1 as u32;
    a2 as u32;

Untuk membuat instance struct dalam suatu program gunakan instruksi cast.

function new_array3:
    input r0 as u32.private;
    input r1 as u32.private;
    input r2 as u32.private;
    cast r0 r1 r2 into r3 as array3;
    output r3;

Rekam ​

Tipe record dideklarasikan sebagai record {name}:.
Records berisi deklarasi komponen {name} as {type}.{visibility};.
Struktur data record harus berisi deklarasi owner seperti yang ditunjukkan di bawah ini.
Saat meneruskan record sebagai input ke fungsi program deklarasi _nonce as group.{visibility} juga diperlukan.

record token:
    // The token owner.
    owner as address.private;
    // The Aleo balance (in microcredits).
    microcredits as u64.private;
    // The token amount.
    amount as u64.private;

Untuk membuat instance record dalam suatu program gunakan instruksi cast.

function new_token:
    input r0 as address.private;
    input r1 as u64.private;
    input r2 as u64.private;
    cast r0 r1 r2 into r3 as token.record;
    output r3;

Pemetaan​

Pemetaan dinyatakan sebagai mapping {name}:.
Pemetaan berisi pasangan nilai kunci. Pemetaan harus didefinisikan dalam lingkup program. Pemetaan disimpan secara publik secara on-chain. Tidak mungkin menyimpan data secara pribadi dalam pemetaan.

// On-chain storage of an `account` map, with `owner` as the key,
// and `amount` as the value.
mapping account:
    // The token owner.
    key owner as address.public;
    // The token amount.
    value amount as u64.public;

Berisi ​

Perintah berisi yang memeriksa apakah ada kunci dalam pemetaan, mis. contains accounts[r0] into r1;.

Dapatkan ​

Perintah get yang mengambil nilai dari pemetaan, mis. get accounts[r0] into r1;.

Dapatkan atau Gunakan ​

Perintah get yang menggunakan default yang disediakan jika terjadi kegagalan, mis. get.or_use accounts[r0] r1 into r2;.

finalize transfer_public:
    // Input the sender.
    input r0 as address.public;
    // Input the receiver.
    input r1 as address.public;
    // Input the amount.
    input r2 as u64.public;
    
    // Decrements `account[r0]` by `r2`.
    // If `account[r0]` does not exist, 0u64 is used.
    // If `account[r0] - r2` underflows, `transfer_public` is reverted.
    get.or_use account[r0] 0u64 into r3;
    sub r3 r2 into r4;
    set r4 into account[r0];
    
    // Increments `account[r1]` by `r2`.
    // If `account[r1]` does not exist, 0u64 is used.
    // If `account[r1] + r2` overflows, `transfer_public` is reverted.
    get.or_use account[r1] 0u64 into r5;
    add r5 r2 into r6;
    set r6 into account[r1];

Setel ​

Perintah set yang menetapkan nilai dalam pemetaan, mis. set r0 into accounts[r0];.

Hapus ​

Perintah hapus yang menghapus pasangan nilai kunci dari pemetaan, mis. remove accounts[r0];.

### Finalize
A finalize is declared as `finalize {name}:`.  
A finalize must immediately follow a [function](#function), and must have the same name;
it is associated with the function and is executed on chain,
after the zero-knowledge proof of the execution of the associated function is verified;
a finalize *finalizes* a function on chain.  
Upon success of the finalize function, the program logic is executed.  
Upon failure of the finalize function, the program logic is reverted.  
```aleo showLineNumbers
// The `transfer_public_to_private` function turns a specified amount
// from the mapping `account` into a record for the specified receiver.
//
// This function preserves privacy for the receiver's record, however
// it publicly reveals the sender and the specified amount.
function transfer_public_to_private:
    // Input the receiver.
    input r0 as address.public;
    // Input the amount.
    input r1 as u64.public;
    
    // Construct a record for the receiver.
    cast r0 r1 into r2 as credits.record;
    
    // Output the record of the receiver.
    output r2 as credits.record;
    
    // Decrement the balance of the sender publicly.
    finalize self.caller r1;
finalize transfer_public_to_private:
    // Input the sender.
    input r0 as address.public;
    // Input the amount.
    input r1 as u64.public;
    
    // Retrieve the balance of the sender.
    // If `account[r0]` does not exist, 0u64 is used.
    get.or_use account[r0] 0u64 into r2;
    
    // Decrements `account[r0]` by `r1`.
    // If `r2 - r1` underflows, `trasfer_public_to_private` is reverted.
    sub r2 r1 into r3;
    
    // Updates the balance of the sender.
    set r3 into account[r0];

Perintah​

Perintah berikut didukung dalam Petunjuk Aleo untuk menyediakan fungsionalitas program tambahan.

diri.penelepon​

Perintah self.caller mengembalikan alamat pemanggil program.
Ini berguna untuk mengelola kontrol akses ke suatu program. Dalam contoh di atas, fungsi transfer_public_to_private mengurangi saldo pengirim secara publik menggunakan self.caller.

blok.tinggi​

Perintah block.height mengembalikan tinggi blok tempat program dijalankan (tinggi blok terbaru + 1). Hal ini dapat berguna untuk mengelola kontrol akses berbasis waktu ke suatu program. Perintah block.height harus dipanggil dalam blok finalisasi.

assert.eq block.height 100u64;

rand.chacha​

Perintah rand.chacha mengembalikan nomor acak yang dihasilkan oleh algoritma ChaCha20.
Perintah ini mendukung pengambilan sampel acak address, boolean, field, group, i8, i16, i32, i64, i128, u8, u16, u32, u64 , u128, dan scalar.
Hingga dua seed tambahan dapat diberikan ke perintah rand.chacha.
Saat ini, hanya ChaCha20 yang didukung, namun, di masa mendatang, generator nomor acak lainnya mungkin didukung.

rand.chacha into r0 as field;
rand.chacha r0 into r1 as field;
rand.chacha r0 r1 into r2 as field;

hasan​

Instruksi Aleo mendukung sintaks berikut untuk hashing ke tipe standar.

hash.bhp256 r0 into r1 as address;
hash.bhp256 r0 into r1 as field;
hash.bhp256 r0 into r1 as group;
hash.bhp256 r0 into r1 as i8;
hash.bhp256 r0 into r1 as i16;
hash.bhp256 r0 into r1 as i32;
hash.bhp256 r0 into r1 as i64;
hash.bhp256 r0 into r1 as i128;
hash.bhp256 r0 into r1 as u8;
hash.bhp256 r0 into r1 as u16;
hash.bhp256 r0 into r1 as u32;
hash.bhp256 r0 into r1 as u64;
hash.bhp256 r0 into r1 as u128;
hash.bhp256 r0 into r1 as scalar;
hash.bhp512 ...;
hash.bhp768 ...;
hash.bhp1024 ...;
hash.ped64 ...;
hash.ped128 ...;
hash.psd2 ...;
hash.psd4 ...;
hash.psd8 ...;

Lihat Opcode Instruksi Aleo untuk daftar lengkap algoritma hashing yang didukung.

Berkomitmen​

Petunjuk Aleo mendukung sintaks berikut untuk berkomitmen pada tipe standar.
Perhatikan bahwa perintah commit memerlukan tipe apa pun sebagai argumen pertama, dan scalar sebagai argumen kedua.

commit.bhp256 r0 r1 into r2 as address;
commit.bhp256 r0 r1 into r2 as field;
commit.bhp256 r0 r1 into r2 as group;
commit.bhp512 ...;
commit.bhp768 ...;
commit.bhp1024 ...;
commit.ped64 ...;
commit.ped128 ...;

Lihat Opcode Instruksi Aleo untuk daftar lengkap algoritma komitmen yang didukung.

posisi, cabang.eq, cabang.neq​

Perintah position, mis. position exit, menunjukkan titik ke eksekusi cabang ke.
Perintah branch.eq, mis. branch.eq r0 r1 to exit, yang mencabangkan eksekusi ke posisi yang ditunjukkan oleh exit jika r0 dan r1 sama.
Perintah branch.neq, mis. branch.neq r0 r1 to exit, yang mencabangkan eksekusi ke posisi yang ditunjukkan oleh exit jika r0 dan r1 tidak sama.

Contoh Blok finalisasi berhasil keluar jika inputnya 0u8 dan gagal sebaliknya.

program test_branch.aleo;
function run_test:
    input r0 as u8.public;
    finalize r0;
finalize run_test:
    input r0 as u8.public;
    branch.eq r0 0u8 to exit;
    assert.eq true false;
    position exit;

Terima kasih telah membaca artikel ini sampai akhir, dan mendaftar untuk mendapatkan notifikasi.

Lihat di bawah untuk semua tautan resmi ke Aleo:

Situs web — https://www.aleo.org/
Discord — https://discord.gg/aleohq
Twitter — https://twitter.com/AleoHQ
GitHub — https://github.com/AleoHQ