Programma's

Op Solana worden "smart contracts" programma's genoemd. Programma's worden op de blockchain geïmplementeerd in accounts die de gecompileerde uitvoerbare binaire bestanden van het programma bevatten. Gebruikers interacteren met programma's door transacties te versturen die instructies bevatten die het programma vertellen wat te doen.

Belangrijke punten

• Programma's zijn accounts die uitvoerbare code bevatten, georganiseerd in functies die instructies worden genoemd.
• Hoewel programma's stateless zijn, kunnen ze instructies bevatten die andere accounts aanmaken en bijwerken om gegevens op te slaan.
• Een upgrade authority kan programma's bijwerken. Zodra deze autoriteit wordt verwijderd, wordt het programma onveranderlijk.
• Gebruikers kunnen verifiëren of de gegevens van een on-chain programma-account overeenkomen met de openbare broncode via verifieerbare builds.

Solana programma's schrijven

Solana programma's worden voornamelijk geschreven in de Rust programmeertaal, met twee gebruikelijke benaderingen voor ontwikkeling:

• Anchor: Een framework ontworpen voor Solana programma-ontwikkeling. Het biedt een snellere en eenvoudigere manier om programma's te schrijven, met behulp van Rust macros om boilerplate code te verminderen. Voor beginners wordt aangeraden om te starten met het Anchor framework.

• Native Rust: Deze benadering omvat het schrijven van Solana programma's in Rust zonder gebruik te maken van frameworks. Het biedt meer flexibiliteit maar komt met verhoogde complexiteit.

Solana programma's bijwerken

Om meer te leren over het implementeren en upgraden van programma's, zie de programma's implementeren pagina.

Programma's kunnen direct worden gewijzigd door een account dat is aangewezen als de "upgrade authority", wat meestal het account is dat oorspronkelijk het programma heeft geïmplementeerd. Als de upgrade authority wordt ingetrokken en ingesteld op None, wordt het programma onveranderlijk en kan het niet langer worden bijgewerkt.

Verifieerbare programma's

Verifieerbare builds stellen iedereen in staat om te controleren of de on-chain code van een programma overeenkomt met de publieke broncode, waardoor het mogelijk wordt om verschillen tussen bron- en geïmplementeerde versies te detecteren.

De Solana-ontwikkelaarsgemeenschap heeft tools geïntroduceerd die verifieerbare builds ondersteunen, waardoor zowel ontwikkelaars als gebruikers kunnen verifiëren dat on-chain programma's nauwkeurig hun openbaar gedeelde broncode weerspiegelen.

• Zoeken naar geverifieerde programma's: Om snel te controleren op geverifieerde programma's kunnen gebruikers zoeken naar een programma-adres op Solana Explorer. Bekijk een voorbeeld van een geverifieerd programma hier.

• Verificatietools: De Solana Verifiable Build CLI van Ellipsis Labs stelt gebruikers in staat om on-chain programma's onafhankelijk te verifiëren tegen gepubliceerde broncode.

• Ondersteuning voor verifieerbare builds in Anchor: Anchor biedt ingebouwde ondersteuning voor verifieerbare builds. Details zijn te vinden in de Anchor documentatie.

Berkeley Packet Filter (BPF)

Solana gebruikt LLVM (Low Level Virtual Machine) om programma's te compileren naar ELF (Executable and Linkable Format) bestanden. Deze bestanden bevatten Solana's aangepaste versie van eBPF bytecode, genaamd "Solana Bytecode Format" (sBPF). Het ELF-bestand bevat de binaire code van het programma en wordt on-chain opgeslagen in een uitvoerbare account wanneer het programma wordt geïmplementeerd.

Ingebouwde programma's

Loader-programma's

Elk programma is zelf eigendom van een ander programma, namelijk de loader. Momenteel bestaan er vijf loader-programma's:

Deze loaders zijn nodig om aangepaste programma's te maken en te beheren:

• Een nieuw programma of buffer implementeren
• Een programma of buffer sluiten
• Een bestaand programma opnieuw implementeren / upgraden
• De autoriteit over een programma overdragen
• Een programma finaliseren

Loader-v3 en loader-v4 ondersteunen wijzigingen aan programma's na hun initiële implementatie. Toestemming hiervoor wordt gereguleerd door de autoriteit van een programma omdat het accounteigendom van elk programma bij de loader berust.

Voorgecompileerde programma's

Ed25519-programma

Het ed25519-programma verwerkt een instructie. De eerste u8 is een telling van het aantal handtekeningen dat moet worden gecontroleerd, gevolgd door een enkele byte padding. Daarna wordt de volgende struct geserialiseerd, één voor elke te controleren handtekening.

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
}

De pseudocode van de handtekeningverificatie:

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
}

Secp256k1-programma

Het secp256k1-programma verwerkt een instructie die als eerste byte een telling neemt van de volgende struct die in de instructiedata is geserialiseerd:

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
}

De pseudocode van de recovery-verificatie:

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
}

Dit stelt de gebruiker in staat om willekeurige instructiedata in de transactie te specificeren voor handtekening- en berichtgegevens. Door een speciale instructions sysvar te specificeren, kan men ook gegevens ontvangen van de transactie zelf.

De kosten van de transactie worden berekend door het aantal te verifiëren handtekeningen te vermenigvuldigen met de vermenigvuldigingsfactor voor handtekeningverificatie.

Secp256r1 Programma

Het secp256r1 programma verwerkt een instructie. De eerste u8 is een telling van het aantal te controleren handtekeningen, gevolgd door één byte padding. Daarna wordt de volgende struct geserialiseerd, één voor elke te controleren handtekening:

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
}

De pseudocode van de handtekeningverificatie:

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
}

Opmerking: Lage S-waarden worden afgedwongen voor alle handtekeningen om onbedoelde handtekeningveranderlijkheid te voorkomen.

Core Programma's

De Solana cluster genesis bevat een lijst met speciale programma's die kernfunctionaliteiten voor het netwerk bieden. Historisch werden deze aangeduid als "native" programma's en ze werden voorheen samen met de validator-code gedistribueerd.