Bloggen over IT

Als je overweegt een kleine community-token op een blockchain te creëren, of je wilt gewoon meer gaan snappen over de architectuur en mogelijkheden van een publieke blockchain, waar kun je dan het beste beginnen? Stel dat je een programmeerachtergrond hebt en zelf aan de slag wilt door je eigen code te schrijven op een Layer 1-blockchain, dan zou naar mijn mening Solana een goede keuze. Het is één van de snelst draaiende blockchains van dit moment met zeer lage transactiekosten. Voor ontwikkelaars die op kleine schaal willen werken, biedt Solana de mogelijkheid om tokens te minten en te lanceren tegen zeer lage kosten. Er zijn SDK’s beschikbaar in low-level programmeertalen zoals Python en TypeScript; je hoeft je dus niet eerst een nieuwe taal als Rust eigen te maken.

Wanneer je begint met ontwikkelen op een Layer 1 blockchain, dan zou het vreemd zijn als je niet in eerste instantie wat weerstand zou voelen. Het vangnet dat andere platforms bieden in geval van een fout, zoals het terugdraaien van een SQL-transactie in een relationele database, ontbreekt hier. Eén van de gevolgen van een fout zou kunnen resulteren in het permanent verloren gaan van geld (coins). Maar zolang je hiervan bewust bent is er een belangrijke winst, namelijk dat je de volledige controle hebt over je activa; jij en jij alléén. Beschouw je angstgevoelens niet als een drempel, maar als een goede adviseur op de achtergrond die je helpt bij het bouwen van een veilig en veerkrachtig systeem.

In deze post deel ik enkele inzichten die ik zelf heb opgedaan op het Solana-platform. Deze kunnen nuttig zijn om beginnersfouten te voorkomen en een goede start te maken.

Welke programmeertaal te gebruiken

Rust

Rust is de primaire programmeertaal die wordt gebruikt om ‘on-chain’ programma’s (smart contracts) voor de Solana-blockchain te schrijven. Het strikte ‘compile-time’ geheugenbeheer van Rust (zonder een garbage collector) is berucht lastig onder de knie te krijgen. Daarnaast moet je in deze specialistische low-level taal alle security checks en serialisatie/deserialisatie zelf implementeren. Tenzij je complexe smart contracts wilt schrijven, raad ik je aan een SDK te gebruiken in Python of TypeScript; daarmee kun je prima een non-fungible token (NFT) in de markt zetten.

Python

Ik waardeer Python ontzettend vanwege zijn leesbare syntaxis en zeer uitgebreide software library. Het zou daarom zeker mijn voorkeur hebben, maar als je serieus tokens wilt creëren met Solana-innovaties zoals de metadata-extension, zul je al snel merken dat de Python SDK (solana.py) de onderliggende Rust-programma’s in het snel evoluerende Solana-ecosysteem niet heeft kunnen bijbenen. Je kunt dan proberen om bepaalde zaken vanuit Python ‘low-level’ uit te voeren, zoals de borsh-parser gebruiken ten behoeve van het zelf (de-)serialiseren van instructions en account data. Maar mijn ervaring hiermee is dat (hoewel het zeker leerzaam is!), je toch steeds weer vastloopt met dezelfde error-meldingen.

TypeScript (of JavaScript?)

Tja, JavaScript of TypeScript … Vanuit het oogpunt van beveiliging en nauwkerigheid zou ik direct TypeScript aanraden. JavaScript is het meest gebruikte framework voor webontwikkeling, maar gebruik het niet als je jezelf als een serieuze blockchainprogrammeur beschouwt. Solana-instructies vereisen een strikte behandeling van complexe gegevenstypen, zoals 32-byte Pubkeys (voor adressen), u64-numbers (voor token amounts) en binaire instruction-data. In tegenstelling tot JavaScript kun je in TypeScript de data-types voor variabelen en function-arguments expliciet definiëren. In JavaScript verschijnen fouten in data-types pas tijdens runtime, terwijl ze in TypeScript al tijdens de compilatie worden gedetecteerd. Dit kan potentieel kostbare fouten voorkómen als je uiteindelijk in productie gaat draaien.

En het allerbelangrijkste: in tegenstelling tot de Python SDK worden de nieuwste innovaties in Solana ondersteund in TypeScript, zoals in de Solana Kit library (die zelf ook in TypeScript is ontwikkeld).

Een lokale TypeScript-ontwikkelomgeving opzetten

Wanneer je begint, is het eerste wat je dient te doen het opzetten van een lokaal geïnstalleerde test-validator blockchain, de zogenaamde LocalNet. Dit wordt je testomgeving voor de komende periode, waar jouw on-chain data zullen blijven bestaan. Op DevNet worden ze namelijk regelmatig verwijderd door een externe ‘system refresh’.

LocalNet draait op Linux, dus als je lokaal op Windows draait, dan dien je daar eerst Windows Subsystem for Linux (WSL) op te installeren. Vervolgens kun je vanuit je WSL/Ubuntu-opdrachtprompt de Rust-compiler en de Solana CLI installeren. Zie voor deze installaties deze handleiding, waarin ook staat hoe je LocalNet kunt starten, dat op de achtergrond blijft draaien. In je TypeScript-programma kun je dan een client-connection object aanmaken voor deze LocalNet-omgeving. Dit object wordt dan gebruikt om transacties via LocalNet te ondertekenen (signen) en te verzenden naar je lokale blockchain.

Zoals al eerder besproken, kiezen we ervoor om de TypeScript SDK te gebruiken voor onze Solana-scripts. Gebruik dan de nieuwe @solana/kit library in plaats van de oude @solana/web3.js library. Het is echter nog beter is het om de Gill library te gebruiken. Gill abstraheert de syntax van @solana/kit naar veel simpelere aanroepen en de gill npm-package bevat alles wat je voor je programmeeravonturen nodig hebt. En vergeet vooral niet om, voordat je begint, deze informatieve videotutorial over Gill te bekijken. Je kunt vervolgens deze Git-repository downloaden die boilerplate-code bevat met startvoorbeelden om zelf aan te passen.

Ik zou Visual Studio Code (VSCode) aanraden als TypeScript-editor. Het bevat IntelliSense en built-in Git. Je kunt er Solana-gerelateerde extensions installeren, zoals de Rust-analyzer en Remote – WSL, maar alléén als je denkt dat ze je meerwaarde bieden. Een ‘nadeel bij een voordeel’ van het bouwen van TypeScript-modules in VSCode is dat je voortdurend tegen data-type errors aanloopt die niet altijd even eenvoudig zijn op te lossen of te omzeilen. Deze ‘errors’ zijn vooral warnings en spelen meestal geen enkele rol meer zo snel je je script gaat runnen. Probeer ze zoveel mogelijk in je code op te lossen, maar de naam zegt het al: TypeScript.

Nu je op het LocalNet werkt, kun je daar je wallet-keypair aanmaken en er vervolgens wat SOL’s in airdroppen om de transactiekosten te betalen. Uiteraard kost het je niets op je lokale blockchain want de SOLs zijn daar fictief. Experimenteer met het aanmaken van accounts, het overmaken van SOLs, het aanmaken van mint-accounts en van token-accounts, het mint-en van tokens, het transfer-en van tokens, enzovoort. Je vind hiervan code-voorbeelden in het Solana Cookbook.

Sta er eens bij stil. Je het nu de mogelijkheid in handen om met open-source tooling een top-rated blockchain-systeem (namelijk Solana) te gaan verkennen. Je volgende stap kan dan zijn dat je jouw code oplevert op het Solana DevNet. Dit is ook een sandbox-omgeving, maar dan een onderdeel van het Solana-ecosysteem, dat is ontworpen om applicaties te bouwen, te implementeren en te testen zonder dat het je echt geld gaat kosten. DevNet maakt namelijk gebruik van fake-SOLs.

Waar zal jouw Solana-reis eindigen? Op het Solana MainNet? Wie weet!

Tips aangaande veiligheid

• Voer altijd gedegen tests uit en gebruik de Solana deploymentstraat. Als je begint met ontwikkelen, gebruik dan je lokale Solana blockchain. Start hiervoor vanuit je Unix commandprompt het solana-test-validator commando om een LocalNet-blockchain instance te starten. Daarna kun je verder implementeren op Solana DevNet, TestNet en uiteindelijk op MainNet (‘productie’).

• Valideer ALLES in je code: de URL van de omgeving waarop je werkt, de adressen die je gebruikt, de SOL-berekeningen van Lamports, enzovoort.

• Programmeer NOOIT programma-ID’s of adressen ‘hard-coded’, maar haal ze altijd op vanuit een veilige locatie.

• Definieer een freeze authority en/of een close authority om een ​​tokenaccount in geval van nood snel te kunnen blokkeren of verwijderen.

• Transacties op het Solana Mainnet dienen altijd te worden ge-signed vanuit je wallet op een hardware-ledger, zoals de Ledger Nano S Plus. Hier vindt de signing plaats binnen je hardware-apparaatje, waar je private key zich bevindt. Gebruik in productie NOOIT een wallet-extension in je browser; deze wordt in a flash gedetecteerd, overgenomen en leeggehaald door kwaadaardige search bots.

• Maak op het MainNet NOOIT een nieuw signer-account (zoals een mint authority) aan in je code, en zeker niet vanuit een webapplicatie-wrapper. De kans is groot dat het bijbehorende keypair wordt ge-sniffed en gestolen. Maak de signer van tevoren aan in een veilige locatie, en haal deze pas op vlak voordat je hem in je code wilt gebruiken.

• Gebruik NOOIT een recent opgehaalde blockhash opnieuw, bijvoorbeeld door deze in een variabele op te slaan. Voer de functie getLatestBlockhash altijd direct opnieuw uit voordat je een transactie gaat signen. Oude blockhashes kunnen lang genoeg geldig blijven om het risico op double spending te vergroten.

• Het spreekt voor zich, maar ik zeg het toch maar even: wees je bewust van de mogelijke beveiligingsrisico’s op je thuiscomputer.

Nog wat tips

• Houd rekening met mogelijke rent exemption op op je accounts. Deze zouden hierdoor zomaar onverwacht kunnen worden afgesloten.

• Zorg voor een degelijke error-exception handling en logging in je code. Dit zal van onschatbare waarde blijken wanneer transacties mislukken met onduidelijke foutmeldingen.

• Definieer een upgrade authority. Mogelijk wil je bepaalde tokengegevens om welke reden dan ook een keer aanpassen.

Kortom: veel experimenteer- en programmeerplezier. Enjoy!