DEV Community: Kernel 🏴‍☠️

#2 - Introduction au développement de smartcontracts sur la blockchain Partisia

Kernel 🏴‍☠️ — Mon, 13 Jun 2022 23:23:12 +0000

Dans cette série d’articles je découvre l’écosystème Partisia Blockchain, la fameuse blockchain qui permet de développer des smartcontracts avec une part de confidentialité (une première pour une blockchain qui permet de déployer des smartcontracts).

Je vais donc documenter cette exploration sur plusieurs articles en fonction de mes découvertes.

Dans le premier article disponible en cliquant sur ce lien, nous avons vu comment installer les outils nécessaires au développement, et comment déployer un smartcontract classique.

Dans ce second article, nous allons entrer dans les détails d’un smart contract écrit pour Partisia en Rust.

Tout d’abord il faut savoir qu’un smartcontract se compose de 3 elements : les states, les actions et l’ initializer.

Ces 3 elements se déclarent avec ce qu’on appelle des macros :

[#state] : Les états du contract. Peut aussi être compris comme la “base de donnée” de notre smartcontract. C’est là que nous stockerons les données.
[#action] : Ce sont end-points pour interagir avec notre smartcontract, à savoir modifier les states.
[#init] : La fonction d’initialisation du smartcontract, elle n’est lancée qu’une seule fois : au moment du déploiement du smartcontract et permet notamment d’initialiser les states.

1. State

Dans notre exemple example-token-contract la state ressemble à ceci :

#[state]
pub struct TokenContractState {
  name: String,
  decimals: u8,
  symbol: String,
  owner: Address,
  total_supply: u64,
  balances: BTreeMap<Address, u64>,
  allowed: BTreeMap<Address, BTreeMap<Address, u64>>,
}

À noter qu’il est possible d’ajouter des méthodes à notre state pour pouvoir servir des données plus simplement. Dans notre exemple, nous avons ajouté une implémentation à la struct TokenContractState.

Voici à quoi ça ressemble :

impl TokenContractState {
  pub fn balance_of(&mut self, owner: Address) -> u64 {
    *self.balances.entry(owner).or_insert(0)
  }
  pub fn total_supply(&self) -> u64 {
    self.total_supply
  }
  pub fn allowance(&mut self, owner: Address, spender: Address) -> u64 {
    let allowed_from_owner = self.allowed.entry(owner).or_insert_with(BTreeMap::new);
    let allowance = allowed_from_owner.entry(spender).or_insert(0);
    *allowance
  }
  fn update_allowance(&mut self, owner: Address, spender: Address, value: u64) {
    let allowed_from_owner = self.allowed.entry(owner).or_insert_with(BTreeMap::new);
    allowed_from_owner.insert(spender, value);
  }
}

Pour ceux qui ne connaissent pas Rust, vous noterez que certaines lignes finissent pas ; et d’autres non. Le fait de ne pas terminer la ligne par un ; signifie simplement que l’on retourne la valeur. Ce qui nous permet d’écrire moins de code ;)

2. Action

Comme dit précédemment, les actions servent à modifier nos states.

Dans notre exemple, nous avons l’action transfer qui ressemble à ceci :

#[action]
pub fn transfer(
  context: ContractContext,
  state: TokenContractState,
  to: Address,
  value: u64,
) -> (TokenContractState, Vec<EventGroup>) {
  let mut new_state = state;
  let from_amount = new_state.balance_of(context.sender);
  let o_new_from_amount = from_amount.checked_sub(value);
  match o_new_from_amount {
    Some(new_from_amount) => {
      new_state.balances.insert(context.sender, new_from_amount);
    }
    None => {
      panic!(“Underflow in transfer — owner did not have enough tokens”);
    }
  }
  let to_amount = new_state.balance_of(to);
  new_state.balances.insert(to, to_amount.add(value));
  if new_state.balance_of(context.sender) == 0 {
    new_state.balances.remove(&context.sender);
  };
  (new_state, vec![])
}

L’action reçoit en premier argument le context, puis en second argument la state non-modifiable du contract, et ensuite tous les arguments nécessaires à son execution, définis par le développeur.

L’action doit aussi nécessairement retourner la nouvelle state modifiée et un vecteur d’évènements, qui sont une liste d’interactions avec d’autres contracts.

On remarquera que la première instruction dans notre action est let mut new_state = state;. Ici mut nous permet de spécifier que new_state sera mutable, comprendre modifiable, et que new_state se réfère à la state.

C’est cette ligne qui nous permet de modifier la new_state dans les lignes qui suivent, pour au final la retourner à la dernière ligne afin de pouvoir modifier la state du contrat.

Finalement, étant donné que dans ce cas, nous n’interagissons pas avec d’autres smartcontract, nous retournons simplement une liste vide pour le vecteur d’évènement : vec![].

3. Init

La macro [#init] quant à elle se rapproche beaucoup de la macro [#action] à la différence que c’est une action n’a pas d’argument state et que cette action n’est lancée qu’une seule fois : Lors de la création du smartcontract.

Si la fonction init échoue, alors le smartcontract n’est pas créé.

Dans notre exemple, voici à quoi ressemble la fonction d’initialisation :

#[init]
pub fn initialize(
  ctx: ContractContext,
  name: String,
  symbol: String,
  decimals: u8,
  total_supply: u64,
) -> (TokenContractState, Vec<EventGroup>) {
  let mut balances = BTreeMap::new();
  balances.insert(ctx.sender, total_supply);
  let state = TokenContractState {
    name,
    symbol,
    decimals,
    owner: ctx.sender,
    total_supply,
    balances,
    allowed: BTreeMap::new(),
  };
  (state, vec![])
}

Pour en apprendre plus sur Rust, voici un lien intéressant pour les développeurs en reconversion : https://www.educative.io/courses/learn-rust-from-scratch/R1GjgxmKKJw

Pour en savoir plus sur Partisia, voici le lien vers la documentation officielle : https://partisiablockchain.gitlab.io/documentation/

Et si vous voulez, vous pouvez aussi me suivre sur twitter pour des infos plus concises sur Partisia, la blockchain en général et un peu d’économie : https://twitter.com/mehdi_kernel

#1 - Introduction au développement de smartcontracts sur la blockchain Partisia

Kernel 🏴‍☠️ — Mon, 13 Jun 2022 22:54:13 +0000

Aujourd’hui je commence l’exploration de l’écosystème Partisia Blockchain, la fameuse blockchain qui permet de développer des smartcontracts avec une part de confidentialité (une première pour une blockchain qui permet de déployer des smartcontracts).

Je vais donc documenter cette exploration sur plusieurs articles en fonction de mes découvertes.

La première étape est d’installer tous les outils dont nous aurons besoin pour développer nos smartcontracts :

Rust : https://rustup.rs/
Ajouter la target wasm32 à rust via ces 2 commandes :

rustup update
rustup target add wasm32-unknown-unknown

Télécharger le SDK Partisia : https://partisiablockchain.gitlab.io/documentation/partisia-sdk-7.0.0.zip

Puis aller dans le repo cargo-partisia-contract et faire les installations nécessaires via cargo (ça va être long) :

cd partisia-sdk-7.0.0/cargo-partisia-contract
cargo install --path .

Si tout s’est bien passé vous devriez voir apparaitre la version de partisia-contract en tapant cargo partisia-contract —-version dans votre terminal.

Félicitation, si vous en êtes arrivés là, c’est que vous avez tout installé correctement 🎉

Maintenant que nous avons nos outils, nous allons passer à la compilation d’un smartcontract d’exemple.

Dans le repo partisia-sdk-7.0.0 que vous avez téléchargé, vous trouverez quelques exemple de smartcontracts dans le repository contracts .

On va s’intéresser au contract appelé example-token-contract.

Dans ce dossier, vous trouverez un fichier Cargo.toml contenant les dépendances nécessaires à la compilation de ce smartcontract, et un dossier src contenant un fichier lib.rs avec le code de notre smartcontract. Nous allons nous intéresser à ce bout de code un peu plus tard.

Donc dans notre dossier example-token-contract on va lancer la commande :

cargo partisia-contract build --release

Ce qui va compiler le smartcontract et on va se retrouver avec un nouveau fichier Cargo.lock qui est un semblant de yarn.lock pour les développeurs JS, et un dossier target où va se trouver l’output de notre compilation.

Dans ce dossier target on aura :

un binaire wasm32-unknown-unknown/release/token_contract.wasm
une abi wasm32-unknown-unknown/release/token_contract.abi

Ce sont ces 2 fichiers dont nous aurons besoin pour déployer notre smartcontract.

Une fois qu’on a ces 2 fichiers, il est possible de déployer le smartcontract en visitant https://dashboard.partisiablockchain.com/wallet/upload_wasm ou https://mpcexplorer.com/deploy-contract

Veillez à bien sélectionner token_contract.wasm pour le contrat et token_contract.abi pour l’ABI. Ensuite, entrer les données d’initialisation du contract : nom du token, symbol, nombre de décimales, la supply totale. Et enfin, envoyer la transaction.

A noter que dans cet exemple, on déploie sur le mainnet de Partisia. Vous aurez donc besoin de MPC tokens pour payer le gas.

Félicitation (bis), si vous en êtes arrivés là, c’est que vous avez déployé votre premier smartcontract sur la blockchain Partisia avec succès 🎉

Dans de prochains articles nous verrons comment interagir avec le smartcontract, la structure des smartcontracts, comment déployer sur testnet, et bien plus encore.

Pour patienter, voici une video de l’interaction avec le smartcontract depuis l’interface utilisateur 👉 https://www.youtube.com/watch?v=qV2grtWDxUE

Si vous souhaitez en savoir plus sur Partisia, voici le lien vers la documentation officielle : https://partisiablockchain.gitlab.io/documentation/

Et si vous voulez, vous pouvez aussi me suivre sur twitter pour des infos plus concises sur Partisia, la blockchain en général et un peu d’économie : https://twitter.com/mehdi_kernel