Pengantar pengembangan Algorand Dapp

Algorand blockchain adalah platform ramah lingkungan yang ideal untuk membangun dapps

Algorand menjalani tahun 2021 yang luar biasa, tumbuh dalam adopsi, kasus penggunaan, dan harga tokennya. ALGO memulai tahun ini dengan $0,20 dan sekarang berada di kisaran $2. Akibatnya, semakin banyak pengembang yang tertarik untuk membangun blockchain mereka sendiri dan membantu meningkatkan adopsi. Pada artikel ini, kami akan merangkum keunggulan Algorand sebelum mempelajari cara menulis transaksi menggunakan SDK-nya.

Dalam artikel ini:

Pertama, ringkasan singkat tentang nilai jual unik Algorand: biaya rendah, produktivitas tinggi, dan ini semua tentang finalitas blok. Biayanya sekitar 0,001 ALGO per transaksi – kurang dari satu sen – menjadikannya ideal untuk kasus penggunaan DeFi dan game. Blockchain juga menangani hingga 1.000 transaksi per detik, yang merupakan kedudukan lain di sabuk DeFi. Akhirnya, blok terakhir terjadi setelah satu blok, tidak seperti Bitcoin atau Ethereum. Artinya, Anda tidak perlu menunggu konfirmasi blok untuk memastikan bahwa transaksi Anda tidak terlibat dalam percabangan jalan.

Manfaat lain menjelaskan keberhasilan Algorand baru-baru ini sejalan dengan sikap global terhadap netralitas karbon dan standar ESG. Algorand berusaha untuk menjadi blockchain paling hijau di jaringan karbon-negatif. Saat ini, Algorand sudah berada di jalur yang benar, menggunakan 0,00000008 kWh/transaksi berdasarkan jaringan 4.000 validator. Angka-angka ini sangat kontras dengan Bitcoin (930 kWh/txn) atau Ethereum (70 kWh/txn) – tetapi mari kita bayangkan untuk memastikannya.

Langkah Pertama menuju Jejak Karbon Negatif

Algorand telah bersumpah untuk menjadi karbon negatif. Untuk mencapai tujuan yang mengesankan ini, blockchain dan ClimateTrade akan menerapkan “peramal keberlanjutan” yang akan memverifikasi jejak karbon algorand pada rantai untuk setiap era.

Berkat kontrak pintar canggih, Algorand akan menyimpan jumlah kredit karbon yang setara sebagai salah satu ASA (Standard Algorand Asset) di brankas hijau. Akibatnya, protokol akan berjalan sebagai karbon negatif.

Singkatnya, Algorand memberikan finalitas dan produktivitas yang cepat dengan biaya rendah. Selain itu, pohon, tupai atau sungai tidak dirugikan. Tidak heran jika harga Algorand yang mendorong kenaikan ini, dan tim di balik tagar “#GreenFi” di Twitter.

Pengkodean di Algorand

Sekarang, bagian yang penting: Belajar coding di Algorand. Dalam tutorial singkat ini, Anda akan belajar bagaimana:

• Siapkan lingkungan pengembangan Anda.
• Memahami Algordan Geometri
• Tulis transaksi di Algorand
• Kirim transaksi pada target CLI

Pertama, saat menyiapkan lingkungan pengembangan, Anda dapat memilih dari tiga opsi:

Pilihan 1
Opsi yang paling sering digunakan adalah pengaturan Algorand Sandbox. Sandbox memungkinkan pengembang untuk membuat jaringan lokal dan pribadi. Selain itu, Anda dapat dengan cepat menghapus jaringan, mengatur ulang statusnya, atau membuat yang baru. Satu-satunya persyaratan untuk menggunakan Algorand Sandbox adalah menginstal Docker dan Docker-Compose. Selain itu, Anda dapat memilih untuk terhubung ke jaringan nyata dan tetap mengikuti perkembangan terbaru.

pilihan 2
Gunakan **Layanan API Pihak Ketiga** untuk mengakses API REST Algorand asli untuk mainnet, jaringan beta, dan betanet. Ini adalah pilihan yang sangat baik jika Anda tidak ingin menyiapkan jaringan lokal dengan Docker, dan hanya ingin mencoba pengembangan Algorand terlebih dahulu. Penyedia saat ini adalah Purestake dan Rand Labs. Perlu diingat bahwa tingkat gratis dari kedua penyedia datang dengan batasan tertentu, seperti jumlah permintaan per detik (info lebih lanjut di kedua situs). Anda dapat mengakses layanan ini melalui kunci API dan alamat node Algorand.

Opsi 3
Anda dapat memutuskan untuk **menjalankan node Algorand Anda sendiri**, yang berisi implementasi penuh dari program Algorand. Solusi ini lebih kompleks dalam hal pengaturan dan juga kurang fleksibel. Tidak seperti Algorand Sandbox, Anda tidak dapat menghapus jaringan dan membuat yang baru jika Anda mau. Menyiapkan node Algorand membutuhkan waktu lebih lama daripada menyiapkan LAN pribadi menggunakan alat Sandbox.

** Rekomendasi? ** Disarankan untuk menginstal Algorand Sandbox untuk dapat menyelesaikan seluruh rangkaian tutorial! Namun, untuk tutorial ini secara khusus, Anda dapat menggunakan layanan API pihak ketiga

Berikut langkah-langkah untuk menginstal Algorand Sandbox:

```sh
// clone the Sandbox from GitHub
git clone https://github.com/algorand/Sandbox.git

// enter the Sandbox folder
cd Sandbox

// run the Sandbox executable to start a private network
./Sandbox up
```

Diperlukan beberapa menit untuk memulai Sandbox dengan perintah “naik” jika ini adalah pertama kalinya Anda memulai Sandbox. Skrip akan memastikan bahwa semua gambar Docker yang diperlukan diperiksa sebelum menyiapkan jaringan Anda.

Instalasi node yang berhasil akan mencetak daftar akun pra-dana, yang akan kita gunakan nanti. Berikut adalah contoh keluaran Sandbox.

```sh
# Available accounts
./Sandbox goal account list

# [offline]	HCNMMIL3MKYILOLUO74NF6OPCJU4RU7IE5PX6JYBIT5YHAMQIVO5YADHMU	HCNMMIL3MKYILOLUO74NF6OPCJU4RU7IE5PX6JYBIT5YHAMQIVO5YADHMU	1000000000000000 microAlgos

# [offline]	3KHVQUNTXBFKPTWPPLRYZY3MZIW4EB6XYWRTTIA36O6ZSMRLSEWA2J2HTA	3KHVQUNTXBFKPTWPPLRYZY3MZIW4EB6XYWRTTIA36O6ZSMRLSEWA2J2HTA	4000000000000000 microAlgos

# [online]	5FRKKWRG3UAJQNB7QIOWBW2JICZS4YUF2WFAETHGN3CBM4R3N27NY3T2KQ	5FRKKWRG3UAJQNB7QIOWBW2JICZS4YUF2WFAETHGN3CBM4R3N27NY3T2KQ	4000000000000000 microAlgos
```

Memahami arsitektur Algorand

Node Algorand memiliki tiga komponen utama:

– manajer kunci -> proses kmd -> menampilkan kmd REST API

_ Proses kmd bertanggung jawab untuk mengelola portofolio dan akun.

– program simpul -> proses algod -> setel algod REST API

Proses algod berisi perangkat lunak Algorand untuk mengimplementasikan konsensus dan menambahkan blok ke blockchain. Anda pada dasarnya berinteraksi dengan proses algod untuk menambahkan transaksi ke blockchain.

– Pengindeks -> proses “algorand-indexer” -> Menampilkan pengindeks REST API

_Pengindeks bukan bagian dari simpul itu sendiri. Ini menggunakan database PostgreSQL untuk menyimpan semua jenis titik data di sekitar blockchain seperti transaksi, blok, perhitungan, dan aplikasi. Pengindeks membaca dari proses kualitas. Pengembang berinteraksi dengan pengindeks REST API untuk mengambil data dari blockchain.

Ikhtisar dapat ditemukan di sini:

Diagram di atas juga menunjukkan berbagai SDK dan bagaimana mereka berinteraksi dengan Algorand. Setiap SDK membuat klien dengan kode dan alamat untuk berinteraksi dengan node. Dengan SDK, Anda dapat menggunakan banyak fungsi berguna untuk berinteraksi dengan REST API yang terbuka. Jika mau, Anda juga dapat mengirim permintaan langsung ke API yang terbuka.

Bagaimana Anda menulis transaksi pertama Anda menggunakan SDK?

Di bagian ini, Anda akan mempelajari cara mengirim transaksi pertama Anda ke jaringan Anda sendiri menggunakan SDK pilihan Anda. Anda juga akan mempelajari cara alternatif untuk mengirimkan transaksi menggunakan ‘target’ CLI dan memvalidasi transaksi melalui API pengindeks yang terbuka.

Pertama, Anda harus mengatur pengaturan proyek Anda dengan menginstal dependensi yang benar. Posting blog ini mencakup JavaScript. Anda juga dapat menemukan langkah-langkah untuk menyiapkan Python, Go, dan Java.

Pastikan untuk membuat folder baru untuk proyek Anda dan lakukan langkah-langkah instalasi berikut. Anda akan menginstal Algorand JavaScript SDK untuk berinteraksi dengan algod REST API dan Indexer REST API.

```sh
// initialize project
npm init
// install Algorand sdk
npm install algosdk
// list the version
npm list algosdk

// This package provides TypeScript types, but you will need TypeScript version 4.2 or higher to use them properly.
```

Selanjutnya, mari buat akun baru yang akan Anda kirimi beberapa token dari salah satu akun yang didanai sebelumnya. Cuplikan di bawah mengimpor “algosdk” dan menggunakannya untuk membuat akun baru. Fungsi ini mencetak akun dan alamat memori.

```js
const algosdk = require('algosdk');

const createAccount =  function ()
    try  
        const myaccount = algosdk.generateAccount();
        console.log("Account Address = " + myaccount.addr);
        let account_mnemonic = algosdk.secretKeyToMnemonic(myaccount.sk);
        console.log("Account Mnemonic = "+ account_mnemonic);

        return myaccount;
    
    catch (err) 
        console.log("err", err);
    
;

createAccount();
```

Di bawah ini adalah contoh output dari potongan kode di atas.

```sh
Account Address = OXESBPM4MF7ZDLA6OR4S64E26ZDBA47EQO73BGP3XWLXU4DFOC53Q3DN4Q
Account Mnemonic = arm will clever happy organ picnic over cable large mask brother mesh spike square differ cactus road mountain pledge dust eternal zebra random absent track
```

Selain itu, mari buat beberapa kode untuk mengirim transaksi ke algod REST API. Oleh karena itu, kita perlu memanggilnya menggunakan objek klien.

Jika Anda memeriksa dokumentasi untuk Algorand Sandbox, Anda dapat menemukan detail kontak untuk semua operasi.

```
- algod:
    - address: http://localhost:4001
    - token: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- kmd:
    - address: http://localhost:4002
    - token: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
- indexer:
    - address: http://localhost:8980
```

Sebelum kita mulai, kita juga memerlukan ekspor mnemonic dari akun yang didanai sebelumnya karena kita perlu membuat kunci pribadi untuk menandatangani transaksi pada akun yang baru dibuat.

Untuk melakukan ini, Anda dapat menggunakan alat `target` CLI yang berinteraksi dengan proses kmd melalui REST API kmd yang terbuka. Gunakan akun di bawah ini. Pastikan untuk mengganti judul dengan pra-judul untuk Sandbox Anda.

```sh
// sample command
./Sandbox goal account export -a HCNMMIL3MKYILOLUO74NF6OPCJU4RU7IE5PX6JYBIT5YHAMQIVO5YADHMU

// output
Exported key for account HCNMMIL3MKYILOLUO74NF6OPCJU4RU7IE5PX6JYBIT5YHAMQIVO5YADHMU: "cloth intact extend pull sad miss popular mansion lobster napkin space oyster correct warm miss neither confirm snow virtual evoke era lock amused abandon first"

// raw command
./Sandbox goal account export -a <address>
```

Berikut cuplikan kode untuk mengirimkan transaksi pertama Anda. Pastikan untuk mengganti mnemonic untuk variabel ‘PrefundedAccount’ dan alamat variabel untuk ‘Received’.

```js
// create client object to connect to Sandbox's algod client
const algodToken = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
const algodServer = 'http://localhost';
const algodPort = 4001;
let algodClient = new algosdk.Algodv2(algodToken, algodServer, algodPort);

const prefundedAccount = algosdk.mnemonicToSecretKey("cloth intact extend pull sad miss popular mansion lobster napkin space oyster correct warm miss neither confirm snow virtual evoke era lock amused abandon first"); // replace with your mnemonic 

const receiver = "OXESBPM4MF7ZDLA6OR4S64E26ZDBA47EQO73BGP3XWLXU4DFOC53Q3DN4Q" // replace with generated receiver address

const firstTransaction = async function() 
    try 
        // check your balance
        let accountInfo = await algodClient.accountInformation(prefundedAccount.addr).do();
        console.log("Account balance: %d microAlgos", accountInfo.amount);

        // construct the transaction
        let params = await algodClient.getTransactionParams().do();
        params.fee = 1000;
        params.flatFee = true;
        const enc = new TextEncoder();
        const note = enc.encode("My first transaction");
        let amount = 1000000; // = 1 ALGO
        let sender = prefundedAccount.addr;
        let txn = algosdk.makePaymentTxnWithSuggestedParams(sender, receiver, amount, undefined, note, params);

        // Sign the transaction
        let signedTxn = txn.signTxn(prefundedAccount.sk);
        let txId = txn.txID().toString();
        console.log("Signed transaction with txID: %s", txId);

        // Submit the transaction
        await algodClient.sendRawTransaction(signedTxn).do();

        // Wait for confirmation
        let confirmedTxn = await waitForConfirmation(algodClient, txId, 4);

        // Get the completed Transaction
        console.log("Transaction " + txId + " confirmed in round " + confirmedTxn["confirmed-round"]);
     catch (error) 
        console.log("err", error);
    

```

Kirim transaksi

Untuk mengirim transaksi, kita perlu menyediakan parameter berikut:

1. Alamat pengirim

2. Menerima alamat

3. Jumlah yang akan dikonversi dalam mikroAlgo (1 Algo sama dengan 1000000 mikroAlgo)

4. Catatan (Opsional) -> Lulus “tidak terdefinisi” jika Anda tidak ingin menambahkan catatan dengan transaksi Anda

5. Objek `params` -> digunakan untuk mengatur biaya transaksi. Anda dapat menetapkan biaya sendiri atau menggunakan biaya 1.000 mikroAlgo default untuk setiap transaksi. Anda dapat menemukan informasi lebih lanjut tentang perbedaan antara “biaya yang disarankan” dan “biaya tetap” dalam dokumentasi.

Anda dapat menemukan referensi skema transaksi lengkap di dokumentasi Algorand. Misalnya, Anda dapat memberikan properti `closeRemainderTo` yang akan menutup akun pengirim dan memindahkan semua dana yang tersisa ke alamat yang ditentukan dalam properti ini. Anda tidak ingin menggunakan properti ini dalam contoh ini karena kami tidak ingin menutup akun pra-konfigurasi kami.

Selanjutnya, tambahkan implementasi fungsi `waitForConfirmation` di bawah kode yang sudah Anda miliki. Fungsi ini memeriksa apakah transaksi Anda termasuk dalam blok. Fungsi ini dapat digunakan oleh semua fungsi yang menulis transaksi ke blockchain. Jadi, di bagian di bawah ini, Anda akan menggunakannya setiap saat.

```js
/**
 * Wait until the transaction is confirmed or rejected, or until 'timeout'
 * number of rounds have passed.
 * @param algosdk.Algodv2 algodClient the Algod V2 client
 * @param string txId the transaction ID to wait for
 * @param number timeout maximum number of rounds to wait
 * @return Promise<*> pending transaction information
 * @throws Throws an error if the transaction is not confirmed or rejected in the next timeout rounds
 */
const waitForConfirmation = async function (algodClient, txId, timeout) {
    if (algodClient == null || txId == null || timeout < 0) 
        throw new Error("Bad arguments");
    

    const status = (await algodClient.status().do());
    if (status === undefined) 
        throw new Error("Unable to get node status");
    

    const startround = status["last-round"] + 1;
    let currentround = startround;

    while (currentround < (startround + timeout)) 
        const pendingInfo = await algodClient.pendingTransactionInformation(txId).do();
        if (pendingInfo !== undefined) 
            if (pendingInfo["confirmed-round"] !== null && pendingInfo["confirmed-round"] > 0) 
                //Got the completed Transaction
                return pendingInfo;
             else 
                if (pendingInfo["pool-error"] != null && pendingInfo["pool-error"].length > 0) 
                    // If there was a pool error, then the transaction has been rejected!
                    throw new Error("Transaction " + txId + " rejected - pool error: " + pendingInfo["pool-error"]);
                
            
        
        await algodClient.statusAfterBlock(currentround).do();
        currentround++;
    
    throw new Error("Transaction " + txId + " not confirmed after " + timeout + " rounds!");
};

firstTransaction();
```

Juga, jangan lupa untuk memanggil fungsi `firstTransaction`. Output terminal akan terlihat seperti ini ketika Anda mengganti variabel ‘PrefundedAccount’ dan ‘Receiver’ dengan benar.

```sh
Account balance: 1000247000000000 microAlgos
Signed transaction with txID: QILHNKZJN7EU4UGMEGFZCCEI5XOLEGXEEQE2IEFWE3DXPC6YY7UQ
Transaction QILHNKZJN7EU4UGMEGFZCCEI5XOLEGXEEQE2IEFWE3DXPC6YY7UQ confirmed in round 9901
```

Verifikasi transaksi melalui pengindeks

Anda selalu dapat memeriksa ulang transaksi Anda dengan membuka tautan berikut di browser Anda. Pastikan untuk mengganti ID Transaksi dengan ID Transaksi Anda.

```sh
http://localhost:8980/v2/transactions/QILHNKZJN7EU4UGMEGFZCCEI5XOLEGXEEQE2IEFWE3DXPC6YY7UQ

// Raw link
http://localhost:8980/v2/transactions/<transaction-ID>
```

Browser Anda akan mencetak objek JSON untuk transaksi yang dikonfirmasi. Perhatikan properti ‘tx-type “:” pay’ yang menunjukkan bahwa ini adalah transaksi pembayaran. Anda dapat menemukan ikhtisar semua jenis transaksi di dokumentasi Algorand.

```json

  "current-round": 10288,
  "transaction": 
    "close-rewards": 0,
    "closing-amount": 0,
    "confirmed-round": 9901,
    "fee": 1000,
    "first-valid": 9899,
    "genesis-hash": "OM/i1PkIYLDm/D5MeFJehTOpoLRX1hrVdu0PeGbHY00=",
    "genesis-id": "sandnet-v1",
    "id": "QILHNKZJN7EU4UGMEGFZCCEI5XOLEGXEEQE2IEFWE3DXPC6YY7UQ",
    "intra-round-offset": 0,
    "last-valid": 10899,
    "note": "TXkgZmlyc3QgdHJhbnNhY3Rpb24=",
    "payment-transaction": 
      "amount": 1000000,
      "close-amount": 0,
      "receiver": "OXESBPM4MF7ZDLA6OR4S64E26ZDBA47EQO73BGP3XWLXU4DFOC53Q3DN4Q"
    ,
    "receiver-rewards": 0,
    "round-time": 1635332957,
    "sender": "HCNMMIL3MKYILOLUO74NF6OPCJU4RU7IE5PX6JYBIT5YHAMQIVO5YADHMU",
    "sender-rewards": 247000000000,
    "signature": 
      "sig": "4n68QeEYY79IeVJD9+4fMUZeA51Flx1lDqOPG++YaBLid0YvfvFPhBEEcDAolbxMHx8AsOktWYpq+/YF7KN1AA=="
    ,
    "tx-type": "pay"
  

```

Kirim transaksi menggunakan alat CLI target

Atau, Anda dapat mengirim transaksi lebih cepat menggunakan alat target CLI. Anda dapat menemukan detail lengkap dari perintah “send starter target” di dokumentasi.

Pada perintah di bawah, ‘-a’ mewakili jumlah yang ingin Anda konversi di microAlgos. Tanda “-f” menunjukkan akun tempat Anda mengirim uang. ‘-t’ menunjukkan akun tujuan pengiriman uang. Manfaat menggunakan Target adalah ia berinteraksi dengan kmd REST API dan tidak mengharuskan Anda untuk memberikan kunci pribadi Anda untuk menandatangani transaksi jika dompet Sandbox mengelola akun Anda, seperti yang telah didanai sebelumnya. Anda dapat menemukan dokumen referensi untuk “Kirim Penulis Target” di sini.

```sh
./Sandbox goal clerk send -a 125000 -f HCNMMIL3MKYILOLUO74NF6OPCJU4RU7IE5PX6JYBIT5YHAMQIVO5YADHMU -t OXESBPM4MF7ZDLA6OR4S64E26ZDBA47EQO73BGP3XWLXU4DFOC53Q3DN4Q
```

kesimpulan

Tutorial ini memperkenalkan Anda pada dasar-dasar pengembangan Algorand. Bagaimana Anda dapat menggunakan SDK untuk berinteraksi dengan blockchain Algorand melalui API, tetapi yang lebih penting, mengapa Anda harus membangun di Algorand.

Pastikan untuk membaca artikel kami yang akan datang yang akan mengajari Anda cara membangun Algorand. Mereka mencakup Algorand Standard Assets (ASAs) dan bagaimana Anda dapat mengelolanya dengan kode dan menggunakan alat target CLI.

penafian – Ini adalah artikel bersponsor. DappRadar tidak mendukung konten atau produk apa pun di halaman ini. DappRadar bertujuan untuk memberikan informasi yang akurat, tetapi pembaca harus selalu melakukan penelitian sebelum mengambil tindakan apa pun. Artikel DappRadar tidak dapat dianggap sebagai saran investasi.