#2 - Introduction au développement de smartcontracts sur la blockchain Partisia
Tags: blockchain, french, tutorial, rust
Published: 2022-06-13 23:23:12

_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](https://dev.to/mehdi_kernel/1-introduction-au-developpement-de-smartcontracts-sur-la-blockchain-partisia-1n5f), 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 :

```rust
#[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 :

```rust
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 :

```rust
#[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 :

```rust
#[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](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/](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](https://twitter.com/mehdi_kernel)