<?php

class block

{

  public $hash   = null;

  public $height = null;

  public $name   = null;

  public $desc   = null;

  function __construct($ahash, $aheight, $aname = null, $adesc = null)

  {

    $this->hash   = $ahash;

    $this->height = $aheight;

    $this->name   = $aname;

    $this->desc   = $adesc;

  }

}

class blockchain

{

  private static $url_info = 'https://blockchain.info/fr';

  private static $offline_block = OFFLINE_PATH.'/offline_block.zip';

  /*

   * Liste de blocks spéciaux dans l'histoire du Bitcoin

   *

   * 'GENESIS'      - Premier block de la blochain

   * 'THE_ANSWER'   - Block 42 (pour le fun)

   * 'HAL_FINLEY'   - Hal Finley has mined this block

   * 'FIRST_TX'     - First exchange between Satoshi and Hal Finley

   * 'LUCIFER'      - Block 666 (pour le fun)

   * 'LEET'         - Block 1337 (pour le fun)

   * 'FISRT_USD_TX' - Martti Malmi change 5000 BTC for 5,02 $

   * 'PIZZA'        - Block 57035 : le block du pizza day, 22 05 2010

   * 'HALVING_1'    - First halving, block 2100000, 28 11 2012

   * 'HALVING_2'    - Second halving, block 420000, 09 07 2017

   * 'BIP_91_LOCK'  - Block 477120 : Verouillage du BIP 91, 23/07/2017

   * 'BCC'          - Block 478558 : Bitcoin Cash Fork 01/08/2017

   * 'SEGWIT_LOCK'  - Block 479808 SEGWIT est verrouillé 09 08 2017

   * 'SEGWIT'       - Block 481823 SEGWIT est activé 24 08 2017

   * 'HALVING_3'    - Third Hhalving, block 630000, 11 05 2020

   * 'DORMEUR'      - Block 631058 Une adresse datant de 2009 dépense ses 50 BTC de reward

   *                 TX : cb1440c787d8a46977886405a34da89939e1b04907f567bf182ef27ce53a8d71

   *

   *  ____JUMP______ : Lorsque le cours atteint certains palier (à la hausse ou à la baisse)

   *  WHALE____   : Lorsqu'une baleine remonte respirer (grosse TX)

   *  GOLGOTH____ : Lorsque le GOLGOTH pousse fort ... (grosse TX)

   */

  private static $special_blocks = null;

  // ----

  // --   Des fonctions outils

  // --   Parce que depuis PHP.7.0.33-10, file_get_contents ne focnitonne plus en HTTPS

  // ----

  private static function get_curl_data($url)

  {

    $ch = curl_init();

    $timeout = 5;

    curl_setopt($ch,CURLOPT_URL,$url);

    curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);

    curl_setopt($ch,CURLOPT_CONNECTTIMEOUT,$timeout);

    $data = curl_exec($ch);

    curl_close($ch);

    return $data;

  }

  private static function get_data($url, $with_curl = true)

  {

    if (!$with_curl)

        return file_get_contents($url);

    return self::get_curl_data($url);

  }

  //

  // Init special blocks array ...

  // 

  public static function init()

  {

    self::$special_blocks = array ();

    self::$special_blocks[] = new block(

      '0000000000000000000b7b8574bc6fd285825ec2dbcbeca149121fc05b0c828c',

      666666,

      'MORNING_STAR'

    );

    self::$special_blocks[] = new block(

      '000000000000000000070daa5861fe1e7064ef8007825431229c6c1cab2c766f',

      654364,

      'WHALE20201026'

    );

    self::$special_blocks[] = new block(

      '00000000000000000005c0f74e8b00c3961d6dfbf32936edeaa300015949f3c4',

      632676,

      '2020JUMP10000'

    );

    self::$special_blocks[] = new block(

      '00000000000000000000f811e171eee52157e9a95963140e62fa83610f23ea7e',

      631058,

      'DORMEUR'

    );

    self::$special_blocks[] = new block(

      '000000000000000000024bead8df69990852c202db0e0097c1a12ea637d7e96d',

      630000,

      'HALVING_3'

    );

    self::$special_blocks[] = new block(

      '0000000000000000001186079bbf9a5d945231236135af7a766bd34d814e7319',

      628710,

      'RIP_STEEVE'

    );

    self::$special_blocks[] = new block(

      '000000000000000000099457d2aeb2b7fc8ad8adb1490814cb674dc5767ae9b9',

      622453,

      'COVID19'

    );

    self::$special_blocks[] = new block(

      '00000000000000000001a3c68111789a6c2cc76f1209d1dae63b05460053eb2b',

      619165,

      'EQUILIBRE202002'

    );

    self::$special_blocks[] = new block(

      '0000000000000000000f2306f08e8f34872a24dfaad3423801a91ee1626e9ea4',

      618986,

      'SOPHIA202002'

    );

    self::$special_blocks[] = new block(

      '0000000000000000001085a869441fa2aa77f149a887af0ce59846ef51da6e4c',

      616193,

      'EQUILIBRE'

    );

    self::$special_blocks[] = new block(

      '0000000000000000000b05f877e6e49b380f4f78b3cfb605b67439f825dba197',

      613470,

      '2020JUMP9000'

    );

    self::$special_blocks[] = new block(

      '00000000000000000009e8fb4ac719a362c1c4e3df439740069ee58e2a713258',

      612149,

      'DEMISSION20200110'

    );

    self::$special_blocks[] = new block(

      '000000000000000000051f84a7a1d0f5b2ddaf5682cbec5f7acb2bf5fa339725',

      593879,

      'GOLGOTH201909'

    );

    // 94 500 BTC, soit environ 1 milliards de dollars, 700 dollars de fees ...

    self::$special_blocks[] = new block(

      '00000000000000000014fcb29e6e3b0ead3bd2e307d7f619a935f1d5323e9013',

      593468,

      'WHALE201909'

    );

    self::$special_blocks[] = new block(

      '0000000000000000000f9f2dadfb8f312572183272802cbfcc4ff95b4ee6777d',

      545911,

      'WHALE201810'

    );

    self::$special_blocks[] = new block(

      '00000000000000000021e800c1e8df51b22c1588e5a624bea17e9faa34b2dc4a',

      528249,

      'BLOCK21E800'

    );

    self::$special_blocks[] = new block(

      '0000000000000000000fe6d521a187a5523d5cef6f6c178923ff82ffe5a0f372',

      506734,

      'HURRICANE_1'

    );

    self::$special_blocks[] = new block(

      '0000000000000000004b27f9ee7ba33d6f048f684aaeb0eea4befd80f1701126',

      501726,

      'NO_REWARD'

    );

    self::$special_blocks[] = new block(

      '000000000000000000cbeff0b533f8e1189cf09dfbebf57a8ebe349362811b80',

      481823,

      'SEGWIT'

    );

    self::$special_blocks[] = new block(

      '0000000000000000012e6060980c6475a9a8e62a1bf44b76c5d51f707d54522c',

      479808,

      'SEGWIT_LOCK'

    );

    self::$special_blocks[] = new block(

      '00000000000000000019f112ec0a9982926f1258cdcc558dd7c3b7e5dc7fa148',

      478559,

      'BCC'

    );

    self::$special_blocks[] = new block(

      '0000000000000000015411ca4b35f7b48ecab015b14de5627b647e262ba0ec40',

      477120,

      'BIP_91_LOCK'

    );

    self::$special_blocks[] = new block(

      '000000000000000002cce816c0ab2c5c269cb081896b7dcb34b8422d6b74ffa1',

      420000,

      'HALVING_2'

    );

    self::$special_blocks[] = new block(

      '0000000000000001bc7156dd1183c87859b326affa3a5cdd157e809537f0b284',

      270953,

      'WHALE201311'

    );

    self::$special_blocks[] = new block(

      '000000000000048b95347e83192f69cf0366076336c639f9b7228e9ba171342e',

      210000,

      'HALVING_1'

    );

    self::$special_blocks[] = new block(

      '000000000000041c718cd2fa4270ab80c917bb94caa79c84b417b7924a867a68',

      196883,

      'JOHN_CONWAY'

    );

    self::$special_blocks[] = new block(

      '00000000006de085dadb3ec413ef074022fe781121b467e98960280dd246bb00',

      57035,

      'PIZZA'

    );

    self::$special_blocks[] = new block(

      '00000000132fbe8314fc571c0be60b31ccd461c9ee85f42bde8c6d160a9dacc0',

      24835,

      'FIRST_USD_TX'

    );

    self::$special_blocks[] = new block(

      '000000000a73e64735a2b75c97ea674950a9018da1420d01328a918c9ff9852c',

      5637,

      'TOPISTO'

    );

    self::$special_blocks[] = new block(

      '00000000a70ba4a405c67310757606dd955cf1a3a8e5c042335d78394ea6cb67',

      3654,

      'DORMEUR_ORIGINE'

    );

    self::$special_blocks[] = new block(

      '000000008bf44a528a09d203203a6a97c165cf53a92ecc27aed0b49b86a19564',

      1337,

      'LEET'

    );

    self::$special_blocks[] = new block(

      '00000000fc5b3c76f27f810ee775e480ae7fd604fd196b2d8da4257fcd39f4f9',

      666,

      'LUCIFER'

    );

    self::$special_blocks[] = new block(

      '00000000d1145790a8694403d4063f323d499e655c83426834d4ce2f8dd4a2ee',

      170,

      'FIRST_TX'

    );

    self::$special_blocks[] = new block(

      '00000000a2886c95400fd3b263b9920af80b118b28fee5d2a162a18e4d9d8b2f',

      78,

      'HAL_FINLEY'

    );

    self::$special_blocks[] = new block(

      '00000000314e90489514c787d615cea50003af2023796ccdd085b6bcc1fa28f5',

      42,

      'THE_ANSWER'

    );

    self::$special_blocks[] = new block(

      '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f',

      0,

      'GENESIS'

    );

  }

  // ---

  // --- Retourne le JSON du tableau des blocs speciaux

  // --- 

  public static function getSpecialBlocksJSON()

  {

    return json_encode(self::$special_blocks);

  }

  // ---

  // --- Retourne le nom d'un block à partir de son hash

  // ---   si ce n'est pas un block special, on renvoie le hash

  // --- 

  public static function hash2SpecialName($block_hash)

  {

    foreach(self::$special_blocks as $value)

      if ($block_hash == $value->hash) return $value->name;

    return $block_hash;

  }

  // ---

  // --- Accès aux blocks spéciaux

  // ---    On en rajoute un : le LAST block

  // ---    En fait toute valeur ne faisant pas partie des blocks connus

  // --- 

  public static function getSpecialBlock($nom_du_block)

  {

    $block_hash = '';

    foreach(self::$special_blocks as $value)

    {

      if ($nom_du_block == $value->name) 

      {

        $block_hash = $value->hash;

        break;

      }

    }

    if (file_exists(self::$offline_block)) $block_hash = 'offline';

    if ($block_hash == '') $block_hash = self::getLastBlockHash();

    return self::getBlockWithHash($block_hash);

  }

  // ---

  // --- Accès au dernier block en cache ...

  // --- 

  public static function getLastCacheBlockHash()

  {

    // on commence par le cache d'images

    $myarray = glob(DATA_PATH.'/hasard/*.png');

    if (isset($myarray[0]))

    {

      usort( $myarray, function( $a, $b ) { return filemtime($b) - filemtime($a); } );

      return substr(basename($myarray[0],'.png'),0,strlen(self::$special_blocks[0]->hash));

    }

    // S'il n'y a rien dans le cache d'images

    $filename=DATA_PATH.'/finished_block_list.txt';

    if (file_exists($filename))

    {

      $handle = fopen($filename, "r");

      if ($handle)

      {

        while (($buffer = fgets($handle, 4096)) !== false) {

          $valeurs = explode(" ",$buffer);

          if ($valeurs[0] == 'LAST') return $valeurs[1];

        }

      }

    }

    return NULL;

  }

  // ---

  // --- Accès au dernier block

  // --- 

  public static function getLastBlockHash()

  {

    if (file_exists(self::$offline_block)) return 'offline';

    $filename=self::$url_info.'/latestblock';

    $message=self::get_data($filename);

    if ($message === FALSE) return FALSE;

    $the_block = json_decode($message);

    return $the_block->hash;

  }

  // ---

  // --- Accès à partir du hash

  // --- 

  public static function getBlockWithHash($block_hash)

  {

    // Si on est offline, peut importe le hash passé

    if (!file_exists(self::$offline_block)) 

    {

      if (!file_exists(DATA_PATH."/json/$block_hash.zip"))

      {

      	$filename=self::$url_info.'/rawblock/'.$block_hash;

      	$message=self::get_data($filename);

      	if ( $message === FALSE ) return FALSE;

      	$the_block = json_decode($message);

      	return self::saveBlockInTmpDir($the_block);

      }

      touch(DATA_PATH."/json/$block_hash.zip");

    }

    return self::zip2Block($block_hash);

  }

  // ---

  // --- Gestion du cache

  // ---

  private static function saveBlockInTmpDir($the_block)

  {

    if (file_exists(DATA_PATH.'/json/'.$the_block->hash.'.zip')) return $the_block;

    // Blockchain.info renvoie des nonces négatifs

    // Je repasse par la forme binaire pour retrouver

    // une valeur positive

    $the_block->nonce_binary_str = decbin($the_block->nonce);

    if (strlen($the_block->nonce_binary_str) > 32) $the_block->nonce_binary_str = substr($the_block->nonce_binary_str,-32,32);

    $the_block->topisto_nonce_blockchain_info = $the_block->nonce;

    $the_block->nonce = bindec($the_block->nonce_binary_str);   

    if (!isset($the_block->topisto_inputs))

    {

      $the_block->topisto_inputs  = 0;

      $the_block->topisto_outputs = 0;

      $the_block->topisto_fees    = 0;

      $the_block->topisto_reward  = 0;

      foreach($the_block->tx as $transaction)

      {

        $tx_inputs = 0;

        $tx_outputs = 0;

        if (isset($transaction->inputs))

          foreach($transaction->inputs as $input)

            if (isset($input->prev_out->value))

              $tx_inputs += $input->prev_out->value;

        if (isset($transaction->out))

          foreach($transaction->out as $output)

            if (isset($output->value))

              $tx_outputs += $output->value;

        $tx_fees = abs($tx_inputs - $tx_outputs);

        $the_block->topisto_inputs  += $tx_inputs;

        if ($tx_inputs == 0)

        {

          $the_block->topisto_reward += $tx_outputs;

          continue;

        }

        $the_block->topisto_outputs += $tx_outputs;

        $the_block->topisto_fees += $tx_fees;

      }

      // On retire les frais de la récompense

      $the_block->topisto_reward -= $the_block->topisto_fees;

      self::block2zip($the_block);

    }

    return $the_block;

  }

  private static function block2zip($the_block)

  {

    $zip = new ZipArchive();

    if($zip->open(DATA_PATH.'/json/'.$the_block->hash.'.zip', ZipArchive::CREATE) === true)

    {

      $zip->addFromString($the_block->hash.'.json', json_encode($the_block));

      $zip->close();

    }

  }

  private static function zip2Block($the_block_hash)

  {

    $local_hash = $the_block_hash;

    $zipBlock = DATA_PATH."/json/$the_block_hash.zip";

    if (file_exists(self::$offline_block)) 

    {

      $local_hash = 'offline';

      $zipBlock = self::$offline_block;

    }

    $zip = new ZipArchive;

    if ($zip->open($zipBlock) === TRUE) {

      $the_block = json_decode($zip->getFromName("$local_hash.json"));

      $zip->close();

      return $the_block;

    }

    return NULL;

  }

  public static function DrawBlockHeaderFooter($the_block, $vImage, $hauteur, $couleur = -1)

  {

    $color_tab = [

      [

        [19,15,64],

        [255,255,255]

      ],

      [

        [106,176,76],

        [0,0,0]

      ],

      [

        [106,176,76],

        [255,255,255]

      ],

      [

        [240,147,43],

        [0,0,0]

      ],

      [

        [34,166,179],

        [0,0,0]

      ],

      [

        [240,147,43],

        [255,255,255]

      ],

      //  pour splinelineblack

      [

        [17,61,86],

        [254,254,254]

      ],

      [

        [17,61,86],

        [255,134,63]

      ],

      [

        [234,220,207],

        [127,106,85]

      ],

      [

        [48,51,107],

        [255,255,255]

      ],

      [

        [246, 229, 141],

        [235,77,75]

      ],

      [

        [40, 40, 40],

        [158,227,253]

      ],

      [

        [255, 255, 255],

        [0, 0, 0]

      ],

      [

        [0, 0, 0],

        [255, 255, 255]

      ],

      [

        [255, 255, 255],

        [255, 0, 0]

      ]

    ];

    $color = $couleur;

    if (($color == -1) || ($color > (count($color_tab)-1))) $color = rand(0,count($color_tab)-1);

    // Rajout des HASHES

    $white = imagecolorallocate($vImage, 254, 254, 254);

    $black = imagecolorallocate($vImage, $color_tab[$color][1][0], $color_tab[$color][1][1], $color_tab[$color][1][2]);

    $fond  = imagecolorallocate($vImage, $color_tab[$color][0][0], $color_tab[$color][0][1], $color_tab[$color][0][2]);

    $w = imagesx($vImage);

    $h = imagesy($vImage);

    // On rend le blanc transparent

    imagecolortransparent($vImage, $white);

    // On place un fond transparent

    imagefilledrectangle($vImage, 0, 0, $w, $h, $white);

    $len     = strlen($the_block->hash);

    $ratio_w = ($w - 10) / $len;

    $ratio_h = $hauteur / 32; // car hexadécimal

    // Récupérer les hashes dans 2 tableaux

    $tableau1 = str_split($the_block->hash);

    $tableau2 = str_split($the_block->prev_block);

    // Convertir les tableaux en liste de points

    $points1 = [];

    $points2 = [];

    $points1[] = 0;

    $points1[] = $hauteur - 1;

    $points2[] = 0;

    $points2[] = $hauteur - 1;

    for($i=0;$i<$len;$i++)

    {

      // Le HASH

      $coin_x1 = $ratio_w * $i; 

      $coin_x2 = $ratio_w * ($i + 1);

      $coin_y1 = $hauteur;

      $coin_y2 = 5 + hexdec($tableau1[$i])*$ratio_h;

      $points1[] = $coin_x1;

      $points1[] = $coin_y2;

      $points1[] = $coin_x2;

      $points1[] = $coin_y2;

      // Le PREV HASH 

      $coin_x1 = $ratio_w * $i; 

      $coin_x2 = $ratio_w * ($i + 1);

      $coin_y1 = $hauteur;

      $coin_y2 = 25 - hexdec($tableau2[$i])*$ratio_h;

      $points2[] = $coin_x1;

      $points2[] = $coin_y2;

      $points2[] = $coin_x2;

      $points2[] = $coin_y2;

    }

    // Rajouter une barre au HASH

    $coin_x1 = $ratio_w * $i; 

    $coin_x2 = $ratio_w * ($i + 1);

    $coin_y1 = $hauteur;

    $coin_y2 = 5;

    $points1[] = $coin_x1;

    $points1[] = $coin_y2;

    $points1[] = $coin_x2;

    $points1[] = $coin_y2;

    // Rajouter une barre au PREV HASH 

    $coin_x1 = $ratio_w * $i; 

    $coin_x2 = $ratio_w * ($i + 1);

    $coin_y1 = $hauteur;

    $coin_y2 = 25;

    $points2[] = $coin_x1;

    $points2[] = $coin_y2;

    $points2[] = $coin_x2;

    $points2[] = $coin_y2;

    // Rajouter un coin

    $points1[] = $w;

    $points1[] = $hauteur - 1;

    $points2[] = $w;

    $points2[] = $hauteur - 1;

    // Inverser le PREV HASH

    for($i=0;$i<count($points2);$i+=2)

    {

      $points2[$i+1] = $h - $points2[$i+1];

      if ($points2[$i+1] >= $h) $points2[$i+1] = $h - 1;

    }

    // Dessiner le HASH

    imagefilledpolygon($vImage, $points1, (count($points1)/2), $fond);

    imagepolygon($vImage, $points1, (count($points1)/2), $black);

    // Dessiner le PREV HASH

    imagefilledpolygon($vImage, $points2, (count($points2)/2), $fond);

    imagepolygon($vImage, $points2, (count($points2)/2), $black);

    // Rajout des textes

    $the_name = blockchain::hash2SpecialName($the_block->hash);

    if ($the_name == $the_block->hash) $the_name = date('Ymd H:i:s', $the_block->time);

    putenv('GDFONTPATH='.RESS_PATH.'/fonts/');

    $font = 'DS-DIGIB.TTF';

    $the_texte = "Height : ".$the_block->height;

    imagettftext($vImage,18, 0, 5, $hauteur-5, $black, $font, $the_texte);

    $the_texte = "Inputs : ".$the_block->topisto_inputs;

    if (count($the_block->tx)==1) $the_texte = "Reward : ".$the_block->topisto_reward;

    imagettftext($vImage, 15, 0, 25, ($h - $hauteur)+18, $black, $font, $the_texte);

    $bbox = imagettfbbox(14, 0, $font, $the_name);

    imagettftext($vImage, 14, 0, ($w-3)-($bbox[2]-$bbox[0]), ($hauteur-5), $black, $font, $the_name);

    return [$white, $fond, $black, $font, $color_tab[$color][1], $color_tab[$color][0]];

  }

  public static function getTransactionData($the_block, $type=1)

  {

    // Cela a déjà été calculé 

    if (isset($the_block->data[$type])) return $the_block->data[$type];

    $data = [];

    foreach($the_block->tx as $transaction)

    {

      $total_outputs = 0;

      $total_inputs  = 0;

      $value         = 0;

      if (isset($transaction->out))

        foreach($transaction->out as $output)

          if (isset($output->value))

            $total_outputs += $output->value;

      if (isset($transaction->inputs))

        foreach($transaction->inputs as $input)

          if (isset($input->prev_out->value))

            $total_inputs += $input->prev_out->value;

      switch($type)

      {

        // OUTPUTS

        case 1:

          if ($total_inputs != 0)

            $data[] = ["hash" => $transaction->hash, "value" => $total_outputs];

          break;

        // INPUTS

        case 2:

          $data[] = ["hash" => $transaction->hash, "value" => $total_inputs];

          break;

        // FEES

        case 3:

          if ($total_inputs != 0)

            $data[] = ["hash" => $transaction->hash, "value" => ($total_outputs-$total_inputs)];

          break;

        // REWARD

        case 4:

          if ($total_inputs == 0)

            $data[] = ["hash" => $transaction->hash, "value" => $total_outputs];

          break;

      }

    }

    if (!isset($the_block->data)) $the_block->data = [];

    $the_block->data[$type] = $data;

    return $data;

  }  

}

blockchain::init();

?>