\documentclass{beamer}
%\documentclass[ignorenonframetext,handout]{beamer}
%\usepackage{pgfpages}
%\pgfpagesuselayout{2 on 1}[a4paper,border shrink=5mm]

\usetheme{JuanLesPins}
\usepackage[french]{babel}
\usepackage[utf8x]{inputenc}
\usepackage{bortzmeyer-utils}

\title{Développer un contrat/programme sur Ethereum}
\author{Stéphane Bortzmeyer\\\texttt{stephane+pses@bortzmeyer.org}}
\date{Pas Sage en Seine / Hacker Space Festival, 2 juillet 2016}
% https://www.pseshsf.org/fr/programme/2016/#event-436
% Développement d'un programme sur la chaîne de blocs Ethereum : les
% concepts, les outils disponibles, les pièges et les avantages. (Une heure)
% Au moment de PSESHSF, il y aura un an que le premier bloc officiel
% de la chaîne de blocs Ethereum aura été généré. Contrairement à la
% plupart des chaînes de blocs, Ethereum ne stocke pas que des données
% mais aussi des programmes, exécutés par tous les nœuds. D'une
% certaine façon, Ethereum est donc un ordinateur réparti, pas un
% simple espace de stockage. Nous montrerons comment en écrire (et
% déboguer !) un de ces programmes. Et nous discuterons de quelques
% pièges comme la validation des programmes à qui on envoie son
% cryptoargent.

%\setlength{\parskip}{1ex plus 0.5ex minus 0.2ex} 
%\setlength{\parskip}{15pt} 
\setlength{\parskip}{15pt plus 10pt minus 10pt} 

\begin{document}

\maketitle

\begin{frame}
  \titlepage
\end{frame}

\begin{frame}
  \frametitle{Qu'est-ce qu'Ethereum}
  \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Une \emph{chaîne de blocs}\only<2>{ (oui, comme Bitcoin)}
  \item<3->Haut niveau : une structure de données publique et
    sécurisée.\only<2>{ Tout le monde peut vérifier. Pas d'organisme
      de confiance.}
  \item<4->Bas niveau : les transactions sont signées par l'envoyeur,
    regroupées en \emph{blocs}, et les blocs sont chaînés.\only<4>{ Insérer un
      bloc nécessite une \emph{preuve de travail}.}
  \item<5->Une transaction exécute du code\only<5>{ (un petit programme)}
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Les ethers}
  \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->La monnaie d'Ethereum
  \item<3->Générée par le \emph{minage}\only<3>{ (le même processus
    qui insère les blocs)}
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Mon fric}
  \begin{info}
> cab()
  eth.accounts[0]: 0xaf8e19438e05c68cbdafe33ff15a439ce6742972
      balance: 121.560302052611260406 ether
  eth.accounts[1]: 0x2dda57ee99c806477ba05114801543f48ab3d338
      balance: 0 ether

> eth.sendTransaction({from: eth.accounts[0],
        value: web3.toWei(25, 'ether'),  to: eth.accounts[1]})
"0xa8845821d8454637c7882fac583390d46850a03302f031a5cbf039c6987930d7"

> cab()
   eth.accounts[0]: 0xaf8e19438e05c68cbdafe33ff15a439ce6742972
       balance: 96.559882052611260406 ether
   eth.accounts[1]: 0x2dda57ee99c806477ba05114801543f48ab3d338
       balance: 25 ether
  \end{info}
\end{frame}

\begin{frame}
  \frametitle{Programmable}
  \begin{itemize}
  \item<2->Jusque là, aucune différence avec le Bitcoin
  \item<3->L'importante nouveauté d'Ethereum : c'est une machine de
    Turing. Le code exécuté est écrit dans un langage de Turing.
  \item<4->On peut donc tout faire (tout ce qu'on sait programmer)
  \item<5->Ethereum n'est pas que pour la monnaie  
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{À quoi ça sert}
  \begin{overlayarea}{\textwidth}{.6\textheight}
    \begin{itemize}
  \item<2->Tout ce qui doit être vérifiable par tous et contrôlé par
    personne
  \item<3->Monnaie, cadastre, registre de noms (cf. Namecoin),
    « uberiser Uber (disruption !) »
  \item<4->En revanche, inadapté aux gros calculs\only<4>{ : la
    machine virtuelle Ethereum est lente et chère}
  \item<5->Ces programmes sont nommés des \emph{contrats}
   \item<6->Ils peuvent s'exécuter sans intervention humaine\only<6>{
     (conséquences philosophiques, légales et politiques importantes)} 
    \end{itemize}
    \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Le langage machine}
  \begin{overlayarea}{\textwidth}{.6\textheight}
    \begin{itemize}
    \item<2->Niveau assembleur\only<2>{ (une machine à pile)}
    \item<3->\computer{PUSH1 0x60 PUSH1 0x40 MSTORE PUSH1 0x90 DUP1
      PUSH1 0x11 PUSH1 0x0
      CODECOPY PUSH1 0x0 RETURN STOP PUSH1 0x60
      PUSH1 0x40 MSTORE PUSH1 0x0 CALLDATALOAD}
    \item<4->On ne va pas l'utiliser pour programmer mais il faut se
      rappeler que c'est ça qui est stocké et exécuté dans la chaîne  
    \end{itemize}
        \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Solidity}
  \begin{itemize}
  \item<2->Le principal langage de programmation utilisé actuellement
  \item<3->Langage impératif
  \item<4->Un contrat est composé de variables globales, rémanentes,
    et de fonctions
  \item<5->Un contrat peut appeler d'autres contrats  
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Un environnement très spécial}
    \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Attention, la chaîne de blocs peut être déroutante
  \item<3->On modifie une variable, on ne verra le résultat que
    lorsque le bloc aura été miné
  \item<4->Interactions avec l'extérieur très limitées\only<4>{ (tous les
    mineurs doivent avoir le même résultat : pas question de requêtes
    HTTP externes)} % http://ethereum.stackexchange.com/questions/301/why-cant-contracts-make-api-calls
  \item<5->Déboguage très difficile (pas d'interface utilisateur)
  \item<6->Ordre des transactions pas contrôlable  
  \end{itemize}
    \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Un contrat : Soleau} 
  \begin{overlayarea}{\textwidth}{.6\textheight}
    \begin{itemize}
  \item<2->But : permettre de prouver l'antériorité d'un fichier
    \only<2>{ (roman, chanson, programme, données)} pas encore publié,
    en stockant son
    condensat\only<2>{ (\foreign{hash})} dans la chaîne\only<2>{
      (donc, sans révéler le contenu). \foreign{Trusted Timestamping}}
  \item<3->La chaîne est ordonnée : chaque bloc a un numéro, croissant
    de manière monotone\only<3>{ (et le bloc a 
      une date)}
  \item<4->On enregistre le condensat, la date et l'adresse du
    déposant
  \item<5->Plus tard, il suffira de produire le fichier pour prouver à
    tous son antériorité
    \end{itemize}
    \end{overlayarea}
\end{frame}

\begin{frame}[fragile]
  \frametitle{soleau.sol 1/3}
  \begin{info}
contract Soleau {

  uint price = 1 ether;
  struct Record {
    address holder;
    bool exists; 
    uint created; 
  }
  mapping (string => Record) _records;
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{soleau.sol 2/3}
  \begin{info}
  function record(string hash) returns (bool success,
                                  bool already, uint block) {
    if (msg.value < price) {
      success = false;
      msg.sender.send(msg.value); /* We're nice, we refund */
      return;
    } /* Else we keep the money */
    if (_records[hash].exists) {
      success = true;
      already = true;
      block = _records[hash].created;
    } else {
      _records[hash].exists = true;
      _records[hash].holder = msg.sender;
      _records[hash].created = now;
      success = true;
      already = false;
      block = _records[hash].created;
    }
  }
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{soleau.sol 3/3}
  \begin{info}
  function get(string hash) returns (bool success,
                            uint block, address holder) {
    if (_records[hash].exists) {
      success = true;
      block = _records[hash].created;
      holder = _records[hash].holder;
    } else {
      success = false;
    }
  }
}    
  \end{info}
\end{frame}

\begin{frame}
  \frametitle{Un contrat : FindByHash}
    \begin{overlayarea}{\textwidth}{.6\textheight}
    \begin{itemize}
  \item<2->But : accès par le contenu\only<2>{ (ICN,
    \foreign{Information-Centric Networking}, cf. RFC 7476 et RFC 6920)}
  \item<3->Stocker le·s URL permettant d'accéder à un contenu donné
  \item<4->Contenu identifié par son condensat  
    \end{itemize}
    \end{overlayarea}
\end{frame}

\begin{frame}[fragile]
  \frametitle{findhash.sol 1/4}
  \begin{info}
contract FindHash {

  uint price = 0.01 ether;

  address _manager;
  
  struct Bucket {
    bool exists;
    uint num; // Never decreases: we can only add records, not remove them.
    mapping(uint => Record) records; // Multi-valued mappings not
    // possible, we need two levels of mapping
  } 
  struct Record {
    bool exists;
    string uri;
  }
  mapping(string => Bucket) data;
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{findhash.sol 2/4}
  \begin{info}
  function FindHash() {
    _manager = msg.sender;
  }

  function set(string key, string value) returns (bool) {
    bool result;
    // We do not check that key is a hash: it allows the caller to
    // choose the algorithm s·he likes
    if (msg.value < price) {
      msg.sender.send(msg.value); /* We're nice, we refund */
      return false;
    } else { // Gimme money
      result = _manager.send(msg.value);
      if (!result) {
          throw;
      }
    }
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{findhash.ol 3/4}
  \begin{info}
    if (data[key].exists) {
      data[key].records[data[key].num] = Record(true, value);  
    }
    else {
      data[key].exists = true;
      data[key].records[0] = Record(true, value); // We do not check the syntax of the
						  // URI
    }
    data[key].num++;
    return true;
  }
\end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{findhash.sol 4/4}
  \begin{info}
  // Retrieve the values
    
  function num_of(string key) constant returns (uint) {
    return data[key].num; 
  }
     
  function get(string key, uint index) constant returns (bool, string) {
    if (!data[key].exists || !data[key].records[index].exists) {
      return (false, "");
    }
    return (true, data[key].records[index].uri);
  }
}    
  \end{info}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Récupérer les valeurs depuis la console JavaScript}
  \begin{info}
/* Get all the URIs for a given hash */

findhashC = eth.contract(abi);
findhash = findhashC.at("0x78db9a1dfe1b46c4361ac91cda111f5366ddc0e5");

function getAlls(hash) {
    for (var i = 0; i < findhash.num_of(hash); i++) { 
        result = findhash.get(hash, i);
        console.log("#" + i + " " + result);
    }
}
  \end{info}
  \begin{info}
%  geth  --preload get-urls.js --exec 'getAlls("cf4163b8f4c13b915e246ea7d2792156");' attach  
#0 true,https://localhost/
#1 true,https://www.bortzmeyer.org/toto
  \end{info}
\end{frame}

\begin{frame}
  \frametitle{Piège : la sécurité}
      \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Langage de Turing $\longrightarrow$ tout est possible. Y
    compris du code malveillant\only<2>{ (ce n'est pas par hasard que
      le langage de Bitcoin est si limité)}
  \item<3->Environnement nouveau et surprenant pour les programmeurs
  \item<4->De l'argent en jeu\only<4>{ (et l'argent rend fou)}
  \item<5->Les contrats sont censés se débrouiller seuls. Que faire en
    cas de bogue ?  
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{La crise de The DAO}
      \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Un fonds d'investissement en ethers.\only<2>{ Des gens
    mettent des ethers, d'autres proposent des projets à financer, les
    investisseurs votent. Pas d'entreprise ou d'association.}
  \item<3->Dans les 100 Meuros récoltés
  \item<4->Un voleur a trouvé une bogue et a volé le tiers des fonds
  \item<5->Une intervention manuelle a permis de fruster le voleur
    (alors que le contrat était censé être la loi, et être autonome)  
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Exemples de pièges pour le programmeur}
      \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Un contrat peut en appeler en autre mais cet autre ne fait
    pas partie de la transaction (exceptions non propagées
    $\rightarrow$ testez le code de retour !)
  \item<3->Pas de distinction entre compte et contrat : vous croyez
    envoyer de l'argent à une adresse mais vous exécutez du code
    (\foreign{fallback function})
  \item<4->Si une fonction n'est pas réentrante, un appel par un
    contrat que vous appelez peut changer l'état
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Leçons à en tirer}
   \begin{overlayarea}{\textwidth}{.6\textheight}
  Pour tous :
  \begin{itemize}
  \item<2->Les contrats ont des bogues
  \item<3->Réfléchissez avant d'investir ! Pour adultes seulement !
  \item<4->Imaginez ce que serait devenu le Web s'il y avait des
    bogues\only<4>{ dans les codes PHP et JavaScript}
  \end{itemize}
    Pour les programmeurs :
  \begin{itemize}
  \item<5->Solidity ne vous empêche pas de vous tirer une balle dans
    le pied
  \item<6->Keep calm et relisez et faites relire vos programmes\only<6>{
    (attention à l'hubris)}
  \item<7->Passer à des langages fonctionnels ?
  \item<8->Validation formelle du code ?  
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Piège : la confiance et la validation}
      \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Pourquoi les gens enverraient-ils du fric à votre contrat ?
  \item<3->Une bonne idée ne suffit pas\only<3>{, il faut aussi avoir
    confiance dans sa réalisation}
  \item<4->D'où vient la confiance ?
    \begin{itemize}
    \item<5->Code source disponible et lisible\only<5>{ (c'est le
      minimum)}
    \item<6->Évaluation par plusieurs experts
    \item<7->Mais la chaîne exécute du code machine : il faut aussi
      vérifier que ce code correspond au source.  
    \end{itemize}
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Piège : la mise à jour}
  \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Tous les programmes ont des bogues
  \item<3->Les contrats aussi
  \item<4->Comment mettre à jour ?\only<4>{ Le code à une adresse donnée de la
    chaîne est immuable.}
    \begin{itemize}
    \item<5->Prévoir la possibilité de migrer les fonds vers le
      nouveau contrat (cela ouvre une nouvelle voie d'attaque)
    \item<6->Avoir une indirection entre le nom et l'adresse du
      contrat (cela ouvre une nouvelle voie d'attaque)  
    \end{itemize}
  \end{itemize}
  \end{overlayarea}
\end{frame}

\begin{frame}
  \frametitle{Conclusion}
  \begin{overlayarea}{\textwidth}{.6\textheight}
  \begin{itemize}
  \item<2->Une technologie géniale
  \item<3->Plein de distractions pour les informaticiens
  \item<4->C'est nouveau et disruptif. Donc :
    \begin{enumerate}
    \item<5->Attention avant d'y confier trop d'argent
    \item<6->Difficile de prévoir le futur  
    \end{enumerate}
  \item<7->Pour les pionniers et les courageux explorateurs  
  \end{itemize}
  \end{overlayarea}
\end{frame}

\end{document}
