Program

Di Solana, "smart contract" disebut program. Program di-deploy ke rantai pada akun yang berisi binary executable program yang telah dikompilasi. Pengguna berinteraksi dengan program dengan mengirim transaksi yang berisi instruksi yang memberi tahu program apa yang harus dilakukan.

Poin Penting

• Program adalah akun yang berisi kode yang dapat dieksekusi, diorganisir menjadi fungsi yang disebut instruksi.
• Meskipun program bersifat stateless, mereka dapat menyertakan instruksi yang membuat dan memperbarui akun lain untuk menyimpan data.
• Otoritas upgrade dapat memperbarui program. Setelah otoritas ini dihapus, program menjadi tidak dapat diubah.
• Pengguna dapat memverifikasi data akun program on-chain cocok dengan kode sumbernya yang dipublikasikan melalui build yang dapat diverifikasi.

Menulis Program Solana

Program Solana sebagian besar ditulis dalam bahasa pemrograman Rust, dengan dua pendekatan umum untuk pengembangan:

• Anchor: Framework yang dirancang untuk pengembangan program Solana. Framework ini menyediakan cara yang lebih cepat dan sederhana untuk menulis program, menggunakan makro Rust untuk mengurangi kode boilerplate. Untuk pemula, disarankan untuk memulai dengan framework Anchor.

• Native Rust: Pendekatan ini melibatkan penulisan program Solana dalam Rust tanpa memanfaatkan framework apapun. Pendekatan ini menawarkan fleksibilitas lebih tetapi dengan kompleksitas yang lebih tinggi.

Memperbarui Program Solana

Untuk mempelajari lebih lanjut tentang men-deploy dan meng-upgrade program, lihat halaman deploying programs.

Program dapat dimodifikasi secara langsung oleh akun yang ditunjuk sebagai "otoritas upgrade", yang biasanya adalah akun yang awalnya men-deploy program tersebut. Jika otoritas upgrade dicabut dan diatur ke None, program menjadi tidak dapat diubah dan tidak dapat lagi diperbarui.

Program yang Dapat Diverifikasi

Build yang dapat diverifikasi memungkinkan siapa pun untuk memeriksa apakah kode on-chain program sesuai dengan kode sumber publiknya, sehingga memungkinkan untuk mendeteksi perbedaan antara versi sumber dan yang di-deploy.

Komunitas pengembang Solana telah memperkenalkan alat untuk mendukung build yang dapat diverifikasi, memungkinkan baik pengembang maupun pengguna untuk memverifikasi bahwa program on-chain mencerminkan kode sumber yang dibagikan secara publik dengan akurat.

• Mencari Program Terverifikasi: Untuk memeriksa program terverifikasi dengan cepat, pengguna dapat mencari alamat program di Solana Explorer. Lihat contoh program terverifikasi di sini.

• Alat Verifikasi: Solana Verifiable Build CLI oleh Ellipsis Labs memungkinkan pengguna untuk secara independen memverifikasi program on-chain terhadap kode sumber yang dipublikasikan.

• Dukungan untuk Build yang Dapat Diverifikasi di Anchor: Anchor menyediakan dukungan bawaan untuk build yang dapat diverifikasi. Detail dapat ditemukan di dokumentasi Anchor.

Berkeley Packet Filter (BPF)

Solana menggunakan LLVM (Low Level Virtual Machine) untuk mengompilasi program menjadi file ELF (Executable and Linkable Format). File-file ini berisi versi kustom Solana dari bytecode eBPF, yang disebut "Solana Bytecode Format" (sBPF). File ELF berisi biner program dan disimpan on-chain dalam akun yang dapat dieksekusi ketika program di-deploy.

Program Bawaan

Program Loader

Setiap program itu sendiri dimiliki oleh program lain, yang merupakan loader-nya. Saat ini, ada lima program loader yang ada:

Loader ini diperlukan untuk membuat dan mengelola program kustom:

• Menerapkan program atau buffer baru
• Menutup program atau buffer
• Menerapkan ulang / meningkatkan program yang ada
• Mentransfer otoritas atas program
• Menyelesaikan program

Loader-v3 dan loader-v4 mendukung modifikasi pada program setelah penerapan awalnya. Izin untuk melakukannya diatur oleh otoritas program karena kepemilikan akun setiap program berada pada loader.

Program Terkompilasi

Program Ed25519

Program ed25519 memproses instruksi. u8 pertama adalah jumlah tanda tangan yang akan diperiksa, yang diikuti oleh satu byte padding. Setelah itu, struktur berikut diserialisasi, satu untuk setiap tanda tangan yang akan diperiksa.

struct Ed25519SignatureOffsets {
    signature_offset: u16,             // offset to ed25519 signature of 64 bytes
    signature_instruction_index: u16,  // instruction index to find signature
    public_key_offset: u16,            // offset to public key of 32 bytes
    public_key_instruction_index: u16, // instruction index to find public key
    message_data_offset: u16,          // offset to start of message data
    message_data_size: u16,            // size of message data
    message_instruction_index: u16,    // index of instruction data to get message data
}

Kode semu dari verifikasi tanda tangan:

process_instruction() {
    for i in 0..count {
        // i'th index values referenced:
        instructions = &transaction.message().instructions
        instruction_index = ed25519_signature_instruction_index != u16::MAX ? ed25519_signature_instruction_index : current_instruction;
        signature = instructions[instruction_index].data[ed25519_signature_offset..ed25519_signature_offset + 64]
        instruction_index = ed25519_pubkey_instruction_index != u16::MAX ? ed25519_pubkey_instruction_index : current_instruction;
        pubkey = instructions[instruction_index].data[ed25519_pubkey_offset..ed25519_pubkey_offset + 32]
        instruction_index = ed25519_message_instruction_index != u16::MAX ? ed25519_message_instruction_index : current_instruction;
        message = instructions[instruction_index].data[ed25519_message_data_offset..ed25519_message_data_offset + ed25519_message_data_size]
        if pubkey.verify(signature, message) != Success {
            return Error
        }
    }
    return Success
}

Program Secp256k1

Program secp256k1 memproses instruksi yang mengambil byte pertama sebagai jumlah struktur berikut yang diserialisasi dalam instruction data:

struct Secp256k1SignatureOffsets {
    secp_signature_offset: u16,            // offset to [signature,recovery_id] of 64+1 bytes
    secp_signature_instruction_index: u8,  // instruction index to find signature
    secp_pubkey_offset: u16,               // offset to ethereum_address pubkey of 20 bytes
    secp_pubkey_instruction_index: u8,     // instruction index to find pubkey
    secp_message_data_offset: u16,         // offset to start of message data
    secp_message_data_size: u16,           // size of message data
    secp_message_instruction_index: u8,    // instruction index to find message data
}

Kode semu dari verifikasi pemulihan:

process_instruction() {
  for i in 0..count {
      // i'th index values referenced:
      instructions = &transaction.message().instructions
      signature = instructions[secp_signature_instruction_index].data[secp_signature_offset..secp_signature_offset + 64]
      recovery_id = instructions[secp_signature_instruction_index].data[secp_signature_offset + 64]
      ref_eth_pubkey = instructions[secp_pubkey_instruction_index].data[secp_pubkey_offset..secp_pubkey_offset + 20]
      message_hash = keccak256(instructions[secp_message_instruction_index].data[secp_message_data_offset..secp_message_data_offset + secp_message_data_size])
      pubkey = ecrecover(signature, recovery_id, message_hash)
      eth_pubkey = keccak256(pubkey[1..])[12..]
      if eth_pubkey != ref_eth_pubkey {
          return Error
      }
  }
  return Success
}

Ini memungkinkan pengguna untuk menentukan instruction data apa pun dalam transaksi untuk data tanda tangan dan pesan. Dengan menentukan sysvar instruksi khusus, seseorang juga dapat menerima data dari transaksi itu sendiri.

Biaya transaksi akan menghitung jumlah tanda tangan yang akan diverifikasi dikalikan dengan pengali biaya verifikasi tanda tangan.

Program Secp256r1

Program secp256r1 memproses sebuah instruksi. Byte pertama u8 adalah hitungan jumlah tanda tangan yang akan diperiksa, diikuti oleh satu byte padding. Setelah itu, struct berikut diserialisasi, satu untuk setiap tanda tangan yang akan diperiksa:

struct Secp256r1SignatureOffsets {
    signature_offset: u16,             // offset to compact secp256r1 signature of 64 bytes
    signature_instruction_index: u16,  // instruction index to find signature
    public_key_offset: u16,            // offset to compressed public key of 33 bytes
    public_key_instruction_index: u16, // instruction index to find public key
    message_data_offset: u16,          // offset to start of message data
    message_data_size: u16,            // size of message data
    message_instruction_index: u16,    // index of instruction data to get message data
}

Kode pseudo dari verifikasi tanda tangan:

process_instruction() {
    if data.len() < SIGNATURE_OFFSETS_START {
        return Error
    }

    num_signatures = data[0] as usize
    if num_signatures == 0 || num_signatures > 8 {
        return Error
    }

    expected_data_size = num_signatures * SIGNATURE_OFFSETS_SERIALIZED_SIZE + SIGNATURE_OFFSETS_START
    if data.len() < expected_data_size {
        return Error
    }

    for i in 0..num_signatures {
        offsets = parse_signature_offsets(data, i)

        signature = get_data_slice(data, instruction_datas, offsets.signature_instruction_index, offsets.signature_offset, SIGNATURE_SERIALIZED_SIZE)

        if s > half_curve_order {
            return Error
        }

        pubkey = get_data_slice(data, instruction_datas, offsets.public_key_instruction_index, offsets.public_key_offset, COMPRESSED_PUBKEY_SERIALIZED_SIZE)

        message = get_data_slice(data, instruction_datas, offsets.message_instruction_index, offsets.message_data_offset, offsets.message_data_size)

        if !verify_signature(signature, pubkey, message) {
            return Error
        }
    }

    return Success
}

Catatan: Nilai S rendah diberlakukan untuk semua tanda tangan untuk menghindari kemungkinan kerentanan tanda tangan.

Program Inti

Genesis cluster Solana mencakup daftar program khusus yang menyediakan fungsionalitas inti untuk jaringan. Secara historis, program-program ini disebut sebagai program "native" dan dulunya didistribusikan bersama dengan kode validator.