Titres Titres
Le monde de la Blockchain est très très vaste, des centaines de blockchains différentes existent avec des fonctionnalités, des protocoles et des performances différentes mais aujourd’hui l’une d’entre elles a retenu mon attention : Algorand !
La raison derrière cela est bien résumée ici.
Du coup, j’aimerais mieux comprendre les particularités de cette blockchain en mettant la main à la pâte dans le code. Pour commencer ce voyage, je veux commencer par des choses de base telles que :
- Comment puis-je me connecter à un nœud blockchain ?
- Comment puis-je signer et envoyer des transactions ?
- Quels outils et bibliothèques sont disponibles ?
Bien! Pour cela quoi de mieux que de réaliser un jeu ?
Les règles du jeu doivent être aussi simples que possible, alors j’ai imaginé que jouer au jeu de pièces à pile ou face est assez simple pour le but.
Le schéma ci-dessus montre les règles du jeu :
- Pour jouer, vous devez payer une certaine quantité d’Algos.
- Ensuite, vous devez choisir entre la tête ou la queue.
- La pièce est retournée.
- Si vous gagnez, vous recevrez des Algos, si vous perdez, nous sommes amis comme avant.
Pour rendre le jeu équitable, je souhaite fixer à 0,1 Algos le montant à payer pour jouer au jeu et à 0,2 Algos les gains si vous devinez le bon côté de la pièce.
D’accord! Qu’y a-t-il sur ma liste de choses à faire ?
- Comprendre le fonctionnement d’une transaction de paiement sur Algorand.
- Quelle source fiable de hasard utiliser.
En tant que « maison » du jeu, au cas où, je dois payer le joueur pour ses gains. Cela peut être fait du côté backend d’une application Web par un SDK Algorand qui est censé faire ce travail.
En tant que joueur du jeu, avant chaque pile ou face, je dois payer. Ici, l’hypothèse est que le joueur a un portefeuille Algorand avec un compte et Algos dessus. D’autre part, le frontal de l’application doit intégrer la fonctionnalité de signature du portefeuille pour finaliser le paiement de l’utilisateur.
Paiements avec Algorand SDK
Algorand est livré avec 4 SDK :
Faisons un choix très courant : Javascript SDK.
Voici ce dont j’ai besoin pour effectuer et envoyer une transaction de paiement sur Algorand :
- un compte Algorand avec une phrase de départ mnémonique et, bien sûr, quelques Algos
- un moyen de connecter une application cliente au réseau Algorand.
Voici comment créer un compte Algorand avec le SDK Javascript (algosdk) :
import algosdk from "algosdk";
const myaccount = algosdk.generateAccount();
console.log("Account Address = " + myaccount.addr);
let account_mnemonic = algosdk.secretKeyToMnemonic(myaccount.sk);
console.log("Account Mnemonic = " + account_mnemonic);
Pour approvisionner le compte avec Algos sur testnet, collez votre adresse au distributeur Algorand ici : https://bank.testnet.algorand.network/.
Si vous avez déjà un compte Algorand avec une phrase de départ mnémonique, voici comment l’importer dans votre code :
const myAccount = algosdk.mnemonicToSecretKey(“MNEMONIC HERE”);
Client d’Algod
La façon de connecter une application à la blockchain Algorand se fait via un client algod. Le client algod nécessite une adresse de point de terminaison REST valide et un jeton valide d’un nœud Algorand connecté au réseau avec lequel vous prévoyez d’interagir.
Vous pouvez exécuter votre nœud Algorand et vous y connecter ou utiliser un service tiers qui exécute un nœud pour vous et donne accès à ce nœud via ses clés API.
J’ai choisi la dernière option (je n’avais pas envie d’installer et de configurer un nœud Algorand à ce stade de ma vie) et j’ai obtenu ma clé API et mon point de terminaison API sur https://developer.purestake.io/.
Nous sommes maintenant prêts à instancier un client Algod :
const algodClient = new algosdk.Algodv2(
{
'X-API-Key': “API KEY HERE”
},
“API ENDPOINT HERE”,
""
);
Envoyer une opération de paiement
Le code ci-dessous obtient les paramètres de transaction suggérés, crée une transaction de paiement, la signe et l’envoie à Algorand.
let params = await algodClient.getTransactionParams().do();
const enc = new TextEncoder();
let note = enc.encode("Win Flip Coin Game");
let txn = algosdk.makePaymentTxnWithSuggestedParams(myAccount.addr, “RECEIVER ADDRESS HERE”, 200000, undefined, note, params);
let signedTxn = txn.signTxn(myAccount.sk);
let txIdResult = txn.txID().toString();
console.log("Signed transaction with txID: %s", txIdResult);
let tx = await algodClient.sendRawTransaction(signedTxn).do();
Intégration de portefeuille : comment signer des transactions
Nous pouvons maintenant signer et envoyer des transactions de paiement à Algorand avec notre clé privée, mais de quelle manière pouvons-nous permettre à un utilisateur de faire la même chose sur notre application Web ? Bien sûr, nous ne pouvons pas signer de transactions pour lui, nous devons donc intégrer la fonctionnalité de signature d’un portefeuille Algorand.
Il existe de nombreux portefeuilles Algorand, mais mon attention a été attirée par My Algo Wallet. Il s’agit d’un portefeuille où tous les processus sont gérés dans le navigateur sans avoir besoin de service backend, d’extensions ou de plugins de navigateur. Il utilise un middleware javascript Communication-Bridge pour échanger des messages, permettant la signature sécurisée des transactions.
Cela me semble nouveau. Je veux l’essayer!
Nous pouvons récupérer les informations de compte de cette manière :
import MyAlgoConnect from '@randlabs/myalgo-connect'
private myAlgoConnect = new MyAlgoConnect();
let accounts = await this.myAlgoConnect.connect({
shouldSelectOneAccount: true,
openManager: false
}
);
et signer les transactions de cette manière :
const txn = … //make a transaction as seen before with algosdk
…
const sigTxn = await this.myAlgoConnect.signTransaction(txn.toByte());
…
// send the transaction as seen before with an Algod client
Cela déclenche une fenêtre contextuelle dans un nouvel onglet du navigateur demandant à l’utilisateur de déverrouiller son portefeuille et demandant un mot de passe. Ensuite, My Algo Wallet relie la fonction de signature à l’application Web (plus d’informations ici).
Dans le schéma ci-dessous, toutes les interactions entre les acteurs sont illustrées. Le déroulement du jeu est séparé en 3 étapes :
- Paiement du jeu
- Tirage au sort
- Vérification des gains
Paiement du jeu
Le joueur connecte son portefeuille à l’application web. Ensuite, une transaction de paiement à la « maison » de 0.1 Algos est créée et envoyée au portefeuille pour la signature. Le portefeuille demande à l’utilisateur de déverrouiller son portefeuille. Ensuite, la transaction signée est envoyée à la blockchain Algorand. Le frontal reçoit l’ID de transaction du paiement.
Coin Flip
Le joueur fait une supposition (tête dans ce cas), puis envoie à la fois la supposition et l’ID de transaction de paiement au backend. Le Backend vérifie que le paiement de 0,1 Algos a été effectué à son adresse. Si le paiement est correct, il récupère le dernier bloc miné et le renvoie à l’interface. Le joueur sait maintenant pour quel bloc sa supposition a été enregistrée, de cette façon, s’il perd, il peut toujours récupérer le hachage du bloc et vérifier par lui-même l’exactitude du jeu.
Le calcul sur le hachage utilisé par le backend est codé ci-dessous :
function flip(hash) {
var a = 1, c = 0, h, o;
if (hash) {
a = 0;
for (h = hash.length - 1; h >= 0; h--) {
o = hash.charCodeAt(h);
a = (a << 6 & 268435455) + o + (o << 14);
c = a & 266338304;
a = c !== 0 ? a ^ c >> 21 : a;
}
}
var result = a % 2;
return result;
}
Vérification des gains
En arrière-plan, le backend attend le prochain bloc et lorsqu’il est prêt, calcule son hachage pour vérifier le résultat du pari du joueur. Si le joueur gagne, un paiement de 0,2 Algos est versé sur le portefeuille du joueur.
Source https://medium.com/coinmonks/flipping-coins-on-algorand-fa3d17e0664f?source=rss—-721b17443fd5—4
