# SYD - TP Blockchain - Build Your Blockchain

[Github](https://github.com/dreimert/BuildYourBlockChain/tree/etape-3)

###### tags: `SYD` `TP`

## Lancement

Pour lancer un noeud, il faut au préalable créer un wallet à l'aide du CLI.

node cli.js create

On rentre ensuite le nom du wallet

Nom du wallet ? (default) NomDuWallet
Nom du wallet : NomDuWallet

On peut alors lancer un noeud et l'associer au wallet qui va le contrôler. On peut éventuellement préciser le numéro de port si un autre noeud est ouvert sur la même machine sur le port 3000.

node noeud.js -w NomDuWallet

## A deux (ou plus), c'est mieux !

Pour synchroniser les noeuds, il faut les lancer en leur donnant le même timestamp. On lance aussi le minage

node noeud.js -w NomDuWallet -b 1 -m

Avec le CLI, on les ajoute mutuellement comme peers avec la commande addPeers

node cli.js addPeer http://localhost:3001

Le noeuds sont alors synchronisés.

*NB: Les noeuds doivent être contrôlés par le même wallet*

Modifications de ```noeud.js``` pour que la commande ```node cli.js mine <state>``` fonctionne.

// # gestion des commandes authentifiées
network.on('cmd', function (socket, cmd, callback) {
  cmd = Command.fromObject(cmd)

  if (cmd.user !== publicKey || !cmd.verify()) {
    const error = new Error('cmd error : vous n\'avez pas les droits')
    log.info(error)
    callback(error.message)
  } else if (cmd.type === 'set') {
    log.info('cmd::set', cmd.params.key, cmd.params.value)
    const transaction = Transaction.fromCommand(cmd)
    if (blockchain.addTransaction(transaction)) {
      network.notifyNeighbors('transaction', transaction)
      callback()
    } else {
      const error = new Error('cmd error : cette transaction existe déjà')
      log.info(error)
      callback(error.message)
    }
  } else if (cmd.type === 'addPeer') {
    log.info('cmd::addPeer', cmd.params.url, cmd.params.port)
    const s = network.addPeer(cmd.params.url, cmd.params.port, callback)

    if (s) {
      s.emit('last', (error, last) => {
        if (error) {
          log.error('addPeer::last fail:', error)
        }

        setBlock(Block.fromObject(last), s, callback)
      })
    }
      
/***** Début modifications *****/
  } else if (cmd.type === 'mine'){
    log.info('cmd::mine', cmd.params.state)
    if(cmd.params.state == "start"){
      log.info('Minage activé')
      miner.findPow(blockchain.buildNextBlock())
      argv.mine = true
      callback()
    } else if (cmd.params.state == "stop") {
      log.info('Minage désactivé')
      argv.mine = false
      callback()
    } else {
      const error = new Error(`State ${state} n'existe pas`)
    }
/***** Fin modifications *****/
      
  } else {
    const error = new Error('cmd error : type inconnue')
    log.info(error)
    callback(error.message)
  }
})

## Connectons-nous !

Pour être synchronisés, il faut que notre noeud ait le même timestamp que celui qui tourne sur https://syd.reimert.fr

Pour cela, on récupère le timestamp du bloc 0 grâce à la commande ```blockByIndex```

node cli.js -u https://syd.reimert.fr -p 443 blockByIndex 0

On lance ensuite notre noeud avec le timestamp obtenu

node noeud.js -b timestamp

On ajoute ensuite le noeud public comme peer de notre noeud

node cli.js addPeer https://syd.reimert.fr:443

Notre noeud est alors synchronisé au noeud public.

## Laisser une trace dans ce monde

Modification de ```noeud.js``` pour que la commande ```node cli.js identity <name>``` fonctionne.

// # gestion des commandes authentifiées
network.on('cmd', function (socket, cmd, callback) {
  cmd = Command.fromObject(cmd)

  if (cmd.user !== publicKey || !cmd.verify()) {
    const error = new Error('cmd error : vous n\'avez pas les droits')
    log.info(error)
    callback(error.message)
  } else if (cmd.type === 'set') {
    log.info('cmd::set', cmd.params.key, cmd.params.value)
    const transaction = Transaction.fromCommand(cmd)
    if (blockchain.addTransaction(transaction)) {
      network.notifyNeighbors('transaction', transaction)
      callback()
    } else {
      const error = new Error('cmd error : cette transaction existe déjà')
      log.info(error)
      callback(error.message)
    }
  } else if (cmd.type === 'addPeer') {
    log.info('cmd::addPeer', cmd.params.url, cmd.params.port)
    const s = network.addPeer(cmd.params.url, cmd.params.port, callback)

    if (s) {
      s.emit('last', (error, last) => {
        if (error) {
          log.error('addPeer::last fail:', error)
        }

        setBlock(Block.fromObject(last), s, callback)
      })
    }
  } else if (cmd.type === 'mine'){
    log.info('cmd::mine', cmd.params.state)
    if(cmd.params.state == "start"){
      log.info('Minage activé')
      miner.findPow(blockchain.buildNextBlock())
      argv.mine = true
      callback()
    } else if (cmd.params.state == "stop") {
      log.info('Minage désactivé')
      argv.mine = false
      callback()
    } else {
      const error = new Error(`State ${state} n'existe pas`)
    }
      
/***** Début modifications *****/
  } else if (cmd.type === 'identity') {
    log.info('cmd::identity', cmd.params.name)
    const transaction = Transaction.fromCommand(cmd)
    if (blockchain.addTransaction(transaction)) {
      network.notifyNeighbors('transaction', transaction)
      callback()
    } else {
      const error = new Error('cmd error : cette transaction existe déjà')
      log.info(error)
      callback(error.message)
    }
/***** Fin modifications *****/
      
  } else {
    const error = new Error('cmd error : type inconnue')
    log.info(error)
    callback(error.message)
  }
})

## Contribuer au réseau

Modification de ```noeud.js``` pour ajouter une transaction de type ```reward``` aux blocs minés

async function setBlock (block, socket, callback = () => {}) {
  if (!block.isValid()) {
    const error = new Error('block error : block invalid')
    log.warn(error, block)
    callback(error.message)
  } else {
    if (await blockchain.addBlock(block, socket)) {
      network.notifyNeighbors('block', block)
      if (argv.mine) {
        const nextBlock = blockchain.buildNextBlock()

        /***** Ajout d'une transaction reward *****/
        const publicKey = fs.readFileSync(`./wallets/${argv.wallet}/pub`, 'utf8')
        const privateKey = fs.readFileSync(`./wallets/${argv.wallet}/priv`, 'utf8')
        const params = null
        const transaction = new Transaction('reward', params, publicKey)
        transaction.sign(privateKey)
        nextBlock.transactions.unshift(transaction)
        /******************************************/

        // reward here ;)
        // indice : https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift
        // indice : pour créer une transaction, vous pouvez regarder comment cli.js crée une command

        log.info(`Search for the hash of block ${nextBlock.index}`)

        miner.findPow(nextBlock)
      }
    }

    callback()
  }
}