Utocat et Inria font avancer la recherche sur les smart contracts

Cela fait 1 an que nous travaillons avec  l’équipe de recherche Rmod (Analyse et construction de langage pour l’évolution d’applications orientées objets) de l’Inria Lille pour faire avancer les usages blockchain . Nous aboutissons aujourd’hui à un module d’exploration pour mieux voir et comprendre ce qui se passe à l’exécution d’un smart contrat.

image article utocat

La blockchain avec le smart contract est une technologie très prometteuse et porteuse. Investir dans la recherche pour en simplifier les usages et perfectionner son fonctionnement semble essentiel à son essor. Conçue pour rendre infalsifiables les données qu’elle contient, certaines blockchains, notamment Ethereum, permettent d’exploiter des « smart contracts ». Ces programmes exécutent automatiquement et sans intervention humaine les engagements d’un contrat si l’ensemble des conditions sont réunies.

2017 est l’année de l’émergence des applications basées sur les smart contracts. Avec pour l’une d’entre elle,  fizzy de AXA (assurance paramétrique de retard d’avion), un passage en production à l’échelle mondiale et de vrais utilisateurs à la clé. Les assurances paramétriques remboursent automatiquement et sans démarche les détenteurs d’un contrat d’assurance dès que les conditions de remboursement sont déclenchées. Les données étant certifiées dans la blockchain et aucune intervention humaine n’étant requise on réduit la fraude et les erreurs.

Le smart contract constitue l’une des fonctionnalités les plus prometteuses de la blockchain !

Prenons un exemple concret de fonctionnement de smart contract.

L’équipe Rmod a travaillé sur un smart contract de vote pour un sondage directement sur la blockchain Ethereum. Avec ce programme, le créateur a la possibilité de limiter l’accès au sondage en spécifiant une liste d’adresse de clés privées. Les personnes ayant reçu la permission de voter sont identifiées par les clés privées et ont le choix entre 3 types de réponses : positive, négative ou neutre.

L’intérêt de la blockchain est ici d’utiliser le système de clé privée pour limiter l’accès au sondage et ainsi empêcher les participants de voter plusieurs fois.  Le smart contract assure lui l’auto exécution des conditions : pas de votant en dehors de la liste fournie et pas plus d’une réponse possible par votant.

Le caractère public de la blockchain permet à l’ensemble des utilisateurs de consulter les résultats du sondage ainsi que le statut de ce dernier. On peut voir ici la structure du contrat. Il serait nécessaire de développer une interface utilisateur afin d’en simplifier son usage

pragma solidity ^0.4.23;

contract Public3StatesPoll {

   /* Type Definition */
    enum Choice { POSITIVE , NEGATIVE , NEUTRAL }
    struct PollEntry {  address user; Choice choice ; bool hasVoted; }
    
    uint256[] voteNumberByChoice;

    
    mapping (address => uint256) public addressToIndex;

   /* Properties */
    PollEntry[] pollTable; 
    address owner;
    uint256 voteCount = 0;
    
     /* Constructor */
    constructor() public { 
        owner = msg.sender;
        // trick to avoid problem with isRegistered function
        addVoter(0x0000000000000000000000000000000000000000);
        voteNumberByChoice.push(0);
        voteNumberByChoice.push(0);
        voteNumberByChoice.push(0);
    }
    
    /* Functions */ 
    function isRegistered (address _voterAccount) public view returns(bool){
        return (addressToIndex[_voterAccount] > 0);
    }
    
    function voterIndex (address _voterAccount) public view returns(uint256 index){
        if(addressToIndex[_voterAccount] > 0) {
            return addressToIndex[_voterAccount];
        }
        //return 0 if not found
        return 0;
    }
    
    function addVoter(address _voterAccount) public {
        assert(owner == msg.sender); 
        assert(!isRegistered(_voterAccount)); 
        pollTable.push(PollEntry(_voterAccount, Choice.NEUTRAL, false));
        addressToIndex[_voterAccount] = pollTable.length - 1;
    }
    
    function vote (Choice _choice) public {
        assert(isRegistered(msg.sender));
        uint index = uint(voterIndex(msg.sender)); 
        assert(index > 0);
        assert(!pollTable[index].hasVoted);
        pollTable[index].choice = _choice;
        pollTable[index].hasVoted = true;
        voteNumberByChoice[uint8(_choice)]++;
        voteCount++;
    }
    
    function votesFor(Choice _choice) public view returns (uint256) {
        return voteNumberByChoice[uint8(_choice)];
    }
    
    function allParticipantsHaveVoted () public view returns (bool) {
        //trick to avoid problem with isRegistered function
        if(pollTable.length - 1 == voteCount) {
            return true;
        }
        return false;
    }
}

 

Faciliter la correction du code et des bugs dans une application blockchain

La blockchain est une technologie encore en progression et certaines fonctionnalités n’existent pas encore. C’est pourquoi il est aujourd’hui très compliqué, voire impossible, de corriger des bugs sur un smart contract.

Aujourd’hui, il n’existe pas de fonction en blockchain pour regarder précisément ce qu’il se passe dans un smart contract posté. Pour le corriger il faut alors le relancer pour interpréter la cause des défauts par les résultats. Une fois les problèmes compris il faut re-développer un smart contract corrigé et le publier dans la blockchain. Par la suite toutes les transactions sont passées sur ce nouveau smart contract plutôt que sur l’ancien. En collaborant avec Rmod, nous développons des outils pour localiser la source du bug tout en le corrigeant par la suite. La solution « SmartInspector » a été créee pour permettre aux développeurs d’inspecter un smart contrat. Ils peuvent en corriger les bugs sans avoir à le re-développer.

Inspecter un smart contract avec précision et le corriger est maintenant possible.

SmartInspector, exploration de smart contrat
SmartInspector, exploration de smart contrat

La solution permet d’inspecter un smart contract avec précision en passant notamment chaque variable en revue. Les informations étant devenues accessibles l’usage des smart contracts peut plus facilement se généraliser.

Corriger un smart contract en accédant aux informations qu’il contient n’est pas contraire à l’aspect infalsifiable de la blockchain. Ce n’est pas ce qui est enregistré qui est modifié c’est uniquement le comportement anormal qui peut être rectifié.

De plus en plus de données en blockchain et peu de moyens de la retrouver.

Le volume de données stockées dans la blockchain croît en permanence et retrouver une information peut se révéler compliqué. Dans le cadre du projet avec Rmod, un langage de requêtes en blockchain a été créé. Les utilisateurs peuvent ainsi retrouver facilement et rapidement les transactions qu’ils ont réalisées et les informations associées.

Ce langage nommé Ethereum Query Language s’intéresse, pour le moment, à la blockchain Ethereum. L’objectif du langage est d’élargir le nombre de variables qui peuvent être recherchées au sein de la blockchain. Cela facilite la recherche d’éléments précis et permet de retrouver une transaction par son montant ou encore par l’adresse de l’émetteur.

Ethereum Query Language smart contract
Exemple du langage : Ethereum Query Language.