Les dernières mises à jour du 1er Juin 2020

Les Bases

Configurer un Noeud

Configurer un Baker

https://github.com/obsidiansystems/ledger-app-tezos Proof-of-stake documentation for Tezos "It's a Baker's Life for me: being a Tezos validator" Join the Obsidian Baker Slack Documentation Proof-of-stake pour Tezos "It's a Baker's Life for me: being a Tezos validator"

Comptes de levée de Fonds

Activer son compte

https://tezos.com/get-started#activate https://check.tezos.com/ https://verification.tezos.com/ https://activate.tezos.com/

Support de la Fondation Tezos

Support Reach out to the Tezos Foundation support for issues regarding activation. If you have lost your password you can use try the Tezos Foundation recovery tool, the guides below, or reach out in the Tezos Recovery channel for a bit of help.

Email de Support: [email protected]

Support de la Communauté

Réseaux Sociaux

Telegram Chat (Anglais) Telegram Chat (Russe)

Tutoriels

Guide de récupération de mot de passe pour Windows Guide de récupération de mot de passe pour Mac

Les Bases

L'auto-modification permet à Tezos d'auto-évoluer sans devoir partager (“fork”) le réseau eu deux différentes blockchains. Ceci est important car la suggestion ou l'attente d'une "fork" peut diviser la communauté, et perturber les effets du réseau qui se forment au fil du temps. En raison de l'auto-modification, les coûts de coordination et d'exécution des mises à niveau de protocole sont réduits et les futures innovations peuvent être implémentées de manière transparente.

Dans Tezos, toutes les parties prenantes peuvent participer sur la gouvernance du protocole. Le cycle des élections fournit une procédure formelle et systématique permettant aux parties prenantes de parvenir à un accord sur les amendements proposés. En combinant ce mécanisme on-chain (en-chaîne), Tezos peut changer ce processus électoral initial afin d'adopter de meilleurs mécanismes de gouvernance lorsqu'ils sont découverts.

Les amendements proposés acceptés par les parties prenantes peuvent inclure le paiement à des personnes ou des groupes qui améliorent le protocole. Ce mécanisme de financement encourage une participation solide et décentralisera la maintenance du réseau. Favoriser un écosystème de développeurs actif, ouvert et décentralisé, incité à contribuer au protocole, facilitera le développement et l'adoption de Tezos.

Tezos offre une plateforme pour créer des contrats intelligents et construire des applications décentralisées ne pouvant être censurées ou fermées par des tiers. De plus, Tezos facilite la vérification formelle, une technique utilisée pour améliorer la sécurité en prouvant mathématiquement les propriétés de programmes comme les contrats intelligents. Cette technique, si utilisée correctement, peut aider à éviter des erreurs coûteuses et des débats litigieux qui peuvent survenir.

Les participants ("noeuds") des réseaux peer-to-peer décentralisés fournissent les ressources de calcul nécessaire pour maintenir un réseau opérationnel. La "preuve d'enjeu" (PoS) est le mécanisme par lequel les différents participants à Tezos parviennent à un consensus sur l'état de la blockchain. Contrairement à d'autres protocoles PoS, n'importe quel participant peut prendre part au processus de consensus de Tezos, et être récompensé par le protocole de par sa contribution à la sécurité et stabilité du réseau. De plus, PoS est moins coûteux que les autres mécanismes de consensus et abaissent les barrières pour participer.

Dans la "preuve d'enjeu", un dépôt de garantie est requis afin de participer au processus de consensus et évite d'être dilué par l'inflation. Comme avec la "preuve-de-travail", le protocole de consensus s'appuie sur une majorité honnête pour sa sécurité qui est directement incitée par le protocole Tezos en pénalisant les comportements malhonnêtes et en récompensant les comportement honnêtes. Les utilisateurs qui ne souhaitent pas participer directement au protocole de consensus ont l'option de déléguer leurs droits aux autres utilisateurs pour participer en leur nom.

Ressources:

Développement & Outils Testnet • Magic Faucet • TPlus • Truffle

Connectez-vous via CLI sans exécuter un noeud?

./tezos-client -A rpctest.tzbeta.net -P 443 -S transfer

1. Temps de confirmation des transactions sur les sites d'échanges

2. Code d'erreurs sur les portefeuilles

3. Support des Portefeuilles

TODO: Fill it up!

Introduction

Tezos est une blockchain auto-évolutive qui utilise un processus "onchain" pour proposer, sélectionner, tester et activer des mises à niveau de protocole sans avoir besoin de hard fork. Dans la pratique, cela permet à Tezos de s'améliorer au fil du temps via un processus structuré mais décentralisé tout en préservant un haut niveau de consensus. Tezos permet également aux parties prenantes de mettre à niveau le processus de modification lui-même. Par conséquent, les détails du mécanisme décrit ci-dessous représentent le mécanisme actuel et sont susceptibles de changer. Cette page évoluera à mesure que le réseau évolue.

Votants / Bakers

Le "Baking" est la façon dont les blocs sont produits et validés sur la blockchain Tezos à l'aide de Liquid Proof-of-Stake. Les "Bakers" (également appelés «délégués») obtiennent le droit de créer (c.-à-d. de "cuire") un bloc lorsqu'un roll de jetons (1 roll = 8 000 ꜩ) qu'ils possèdent (ou qui leur est délégué) est sélectionné au hasard pour produire ou valider un bloquer. En tant que responsables du réseau Tezos, les "Bakers" sont également les électeurs d'un processus de mise à niveau formel de Tezos, avec leurs votes proportionnels à la taille de leur participation (y compris les délégations).

Votes / Rolls

Pour accélérer les calculs afin de décider quels délégués sont sélectionnés pour "cuire", le registre Tezos suit les jetons à des fins de jalonnement et de gouvernance sous forme de «rolls». Les rolls sont agrégés au niveau des délégués, ce qui signifie que le pouvoir de "cuire" d'un Baker est proportionnel à la quantité de jetons qui leur sont délégués, arrondi au rouleau le plus proche. Un rôle est actuellement fixé à 8,000 ꜩ.

Délégués

Si quelqu'un n'a pas 8 000 ꜩ ou ne souhaite pas configurer l'infrastructure informatique pour "cuire" des blocs, il peut déléguer ses jetons à un "Baker". Le "baker" ne possède ni ne contrôle les jetons délégués en aucune façon. Il ne peut donc pas les dépenser. Cependant, si et quand l'un de ces jetons est sélectionné au hasard pour "cuire" un bloc, ce droit appartiendra au "baker". En pratique, les "bakers" partagent généralement les revenus supplémentaires générés par les jetons délégués avec le détenteur de pièces.

Les 4 stages de la Gouvernance Tezos

Le processus de modification peut être divisé en quatre périodes distinctes: la période de proposition, la période d'exploration, la période de test et la période de promotion. Chacune de ces quatre périodes dure huit cycles de "cuisson" (soit 32768 blocs ou environ 22 jours, 18 heures), comprenant presque exactement trois mois de la proposition à l'activation.

Comme résumé dans le diagramme ci-dessous, tout échec à passer à la période suivante ramène le réseau à une période de proposition. En d'autres termes, l'échec de la procédure redémarre l'ensemble du processus de modification.

Période de proposition

Le processus de modification de Tezos commence par la période de proposition, au cours de laquelle les "bakers" peuvent soumettre des propositions onchain à l'aide de l'opération de propositions, ce qui implique de spécifier un ou plusieurs hachages de protocole, chacun représentant une archive tar de fichiers source .ml /.mli.

Les "bakers" peuvent soumettre jusqu'à 20 propositions au cours de chaque période de proposition. Lors de la soumission d'une proposition, le "baker" soumet également un vote pour cette proposition, équivalent au nombre de rouleaux dans son solde de jalonnement au début de la période.

Pour ceux qui souhaitent suivre, et d'autres explorateurs de blocs Tezos tels que vous permettent de regarder les propositions entrantes. D'autres "bakers" peuvent ensuite voter sur les propositions en soumettant leurs propres opérations. Comme décrit dans le , le vote de la période de proposition se fait via le vote d'approbation, ce qui signifie que chaque "baker" peut voter une fois sur jusqu'à 20 propositions.

Considérez-le comme une forme de «vote positif». À la fin de la période de proposition, le réseau compte les votes de proposition. Pour qu'une proposition soit considérée comme valide, elle doit avoir suffisamment de votes positifs pour atteindre un quorum de 5%. Si la proposition ayant reçu le plus de votes a au moins 5% du nombre de votes possibles la soutenant, la proposition passe à la période d'exploration. Si le quorum de 5% n'est pas atteint, qu'aucune proposition n'a été soumise ou qu'il y a un lien entre les propositions, le processus de modification reprend une nouvelle période de proposition.

Période d'exploration

Pendant la période d'exploration, les "bakers" peuvent voter sur la proposition la mieux classée de la période de proposition précédente en utilisant le scrutin. Les "bakers" ont le droit de voter "Yay", "Nay" ou "Pass" sur une proposition spécifique. "Passer" signifie simplement s'abstenir de voter pour ou contre une proposition.

Comme dans la période de proposition, le vote d'un "bakers" est basé sur le nombre de "rolls" dans son solde de jalonnement au début de la période. À la fin de la période d'exploration, le réseau compte les votes. Si la participation au vote atteint le quorum et qu'une majorité de 80% de "bakers" non abstinents approuve, la proposition passe à la période de test.

Si la participation au vote n'atteint pas le quorum ou si la majorité majoritaire de 80% n'est pas atteinte, le processus de modification reprend au début de la période de proposition. Quel que soit le résultat du vote, le quorum est mis à jour en fonction des taux de participation antérieurs.

Période de test

Si la proposition est approuvée pendant la période d'exploration, la période de test commence par un fork "testnet" qui fonctionne en parallèle avec le réseau principal pendant 48 heures.

Cette période d'essai est utilisée pour déterminer si une proposition est un amendement valable au protocole. Ce “testnet" garantit que la mise à niveau ne corrompe pas le réseau de la chaîne de blocs; si la mise à niveau était adoptée, le réseau continuerait à effectuer des transitions d'état valides.

Période de promotion

À la fin de la période de test, la période de promotion commence. Pendant cette période, le réseau décide d'adopter ou non l'amendement sur la base des discussions "off-chain" et de son comportement pendant la période de test.

Comme dans la période d'exploration, les "bakers" soumettent leurs votes en utilisant le scrutin, leurs votes étant pondérés proportionnellement au nombre de "rolls" dans leur solde de jalonnement. À la fin de la période de promotion, le réseau compte le nombre de votes. Si le taux de participation atteint le quorum et qu'une majorité de 80% de boulangers non abstinents votent «Oui», alors la proposition est activée en tant que nouveau réseau principal.

Quel que soit le résultat du vote, le processus revient à la période de proposition et le quorum est mis à jour en fonction des taux de participation antérieurs.

La Supermajorité et les Conditions du Quorum

Période de proposition

Une proposition soumise pendant une période de proposition doit atteindre un quorum (taux de participation minimum) pour passer à la période d'exploration.

Conditions du Quorum: Le nombre de votes pour la proposition la plus votée divisé par le nombre de votes possibles doit être supérieur ou égal à 5%.

Périodes d'Exploration & de Promotion

Un vote pendant une période de vote (Exploration & Promotion) doit atteindre à la fois une supermajorité et un quorum (taux de participation minimum) pour réussir.

Conditions de la Supermajorité: Le nombre de votes "Yay" divisé par le nombre de votes "Yay" et "Nay" doit être supérieur ou égal à 80%.

Conditions du Quorum: Le nombre de votes "Yay", "Nay" et "Pass" divisé par le nombre de votes possibles doit être supérieur ou égal au quorum actuel.

Contrairement à l'exigence de supermajorité qui est fixée à 80%, l'exigence de quorum est mise à jour à la fin de chaque période de vote en utilisant la formule suivante, où Q est le quorum pendant la période de vote et q est le taux de participation pendant la période de vote:

En d'autres termes, le quorum essaie de faire correspondre la moyenne mobile exponentielle du taux de participation passé.

Organigramme du processus de modification de Tezos

Commandes Client Tezos

Voter pendant une période de proposition

Voter pendant une période d'Exploration ou de Promotion

Vérifier le Statut de la Période de Vote

Ressources Additionnelles

• de Nomadic Labs

• de Jacob Arluck

Obtenez des Super Pouvoirs

Devenez un super héros est un processus assez simple:

Une fois que vous êtes assez forts, sauvez le monde:

Ce robinet permet de demander aux développeurs et aux utilisateurs que les tokens Tezos (tez) soient utilisés sur le réseau principal Tezos. Ce sont de vrais tez (mainnet) et ont une valeur marchande. Buvez les avec responsabilité:

> Mainnet Tezos Robinet (Nécessite un Numéro de Téléphone)

> Testnet Tezos Magic Robinet

Déléguer vos Tez

Si vous n'avez pas encore trouvé votre Baker, veuillez lire Comment choisir un Baker pour en savoir plus sur. Nous vous recommandons de stocker sur un "cold wallet", un portefeuille matériel, comme Ledger, Trezor ou AirGap où vous contrôlez vos fonds. Nous vous déconseillons de déléguer sur un échange car vous perdez le contrôle de vos clés à un tiers. Si vous souhaitez miser avec un échange, voir Echanges & Swaps, ou ci-dessous

Galleon

Kukai

Airgap

Trustwallet

Exodus

Déléguez vos Tez sur des échanges

Information et contacts support pour les délégations par échange:

• Binance

• Coinbase

• Kraken

• Gate.io

• OKEx

• Kucoin

Bienvenue dans les guides d'utilisation de Tezos! Il s'agit d'un référentiel utile pour les guides de l'écosystème.

Guide de Migration

1. Qu'est-ce qu'un portefeuille?

2. Reconnaissez votre type de portefeuille

Comment les utilisateurs peuvent identifier s'ils ont un portefeuille logiciel ou matériel.

3. Sélectionner son nouveau portefeuille

4. Migrer vers un nouveau portefeuille

Articles

e.g. Cryptium Labs Medium, Nomadic Labs Blog, Arthur Blog, TQ Medium, Jacob Arluck Medium, Baking Bad, Tezos Nodes, MyTezosBaker, Tezos <Ask Community Groups>

Videos Explicatives

Interviews

Podcasts

Tezonomics

TezTalks

TezTalks a commencé comme en direct en 2019, conçu pour mettre en évidence la vision des développeurs, des innovateurs et des entrepreneurs qui construisent l'écosystème Tezos de demain. TezTalks Radio Podcast et TezTalks Live ont été lancés en 2020 pour ouvrir cette expérience à notre communauté mondiale native numérique.

Importer les Snapshots

De Zéro

Step 1: Set up a Node; following Step by Step Guide.

Step 2: Download the Full or rolling mode Snapshot File

Step 3: Copy the file into /tezos folder

Step 4: “./tezos-node snapshot import *Blockhash*.full”

Step 5: Delete the *Blockhash*.full file after succesful import.

Step 6: Start the Node “./tezos-node run –rpc addr 127.0.0.1:8732″

Running Node

• Download the Full or rolling mode Snapshot File.

1. Copy the file into the /tezos folder

2. Update your Tezos Node with

Step 4: If your node is running, stop the Node with Ctrl-c

Step 5: Backup your current ./tezos-node folder

(Especially the identity.json and peers.json)

Step 6: Delete your ./tezos-node Folder

Step 7: “./tezos-node snapshot import *Blockhash*.full”

Step 8: Delete the *Blockhash*.full file after succesful import

Step 9: Copy the backuped identity.json and peers.json into the ./tezos-node folder

Step 10: Start the Node “./tezos-node run –rpc addr 127.0.0.1:8732”

Qu'est-ce qu'un portefeuille?

Un portefeuille de crypto-monnaie est un appareil, un support physique, un programme ou un service qui stocke des clefs publiques et/ou des clefs privées et peut être suivi pour suivre la propriété, recevoir et envoyer des crypto-monnaies.

Il est à noter que la crypto-monnaie elle-même n'est pas un portefeuille. Dans le cas de Tezos et des crypto-monnaies qui en dérivent, la crypto-monnaie est stocker de manière décentralisée et conservée dans un registre accessible au public appelé la blockchain.

Le portefeuille est simplement une interface permettant d'interagir avec une chaîne, et vous pouvez vous déplacer librement entre eux à condition qu'ils opèrent de manière similaire. Vous n'êtes pas généralement pas limités au portefeuille avec lequel vous avez créé votre compte.

Il existe un certain nombre de portefeuilles Tezos pour chaque plateforme ci-dessous:

https://github.com/obsidiansystems/ledger-app-tezos

Earn Tezos

Tezos est une cryptomonnaie et une blockchain conçues pour la sécurité, la participation ouverte et l'évolutivité. Découvrez comment cela fonctionne et vous gagnerez jusqu'à 6 $ en XTZ.

Découvrez plus sur https://www.coinbase.com/earn/tezos

Tezos Leçon 01

Tezos Leçon 02

Tezos Leçon 03

Develop

Site d'échanges principaux

Coin Swaps

Atomic Swaps

Learn more about atomic swaps on

Uniswap

• Dexter by CamlCase (Coming Soon)

How to run a Tezos Node with Docker

‌In this Guide, we will look at how to run a Tezos Node with Docker on Linux, this Guide is primarily meant for people who want to run a public node to use the RPC API, or as a baking fronted node, or similar.

Docker is a platform that allows users to run applications as “Containers” without the need to compile Source Code, you simply download a ready-made container image and start it, the same Container Image can run on many different operating systems, so there is no need to manually deal with OS-specific dependencies and libraries, this is by far the easiest way to run a tezos node.

Official docker images for tezos are premade and can be found here:

https://hub.docker.com/r/tezos/tezos​

In the “Tags” section of this website, you will find all current versions of Tezos, we will have a look at this later, let’s make sure you have a running Docker setup first

Install Docker on Linux

Installing Docker on any modern Linux Distribution is quite easy, all we need to do is open a terminal and type this command:

$ curl https://get.docker.com | bash

After this we have to make sure your current user is allowed to execute docker commands, we can do that with:

$ usermod -aG docker $USER

For this change to take effect you will have to log out and log in again, after that you are able to create a test docker container with:

$ docker run hello-world

If this command succeeds, you have installed docker correctly, to make things easier here is a video of the entire process:

Sart a Tezos Container

At this point we can start a tezos node with one single command:

$ docker run --rm -it tezos/tezos:mainnet tezos-node

This is just a test to see that everything works, this will tell docker to download the official tezos image from dockerhub and run the tezos-node command inside the docker container.

The command uses two special flags, the first one is –rm, this flag tells Docker to delete the container after it has exited, we usually don’t want this but for a testing container, this is ok.

The second flag is -it, which makes sure docker attaches the container to your open terminal, later when we want to run docker in the background we have to omit this.

After some time your tezos node will have found enough connections to other nodes and start syncing blocks, if it does not start immediately have patience, it should look like this:

Start a Tezos Container like a Pro

In this section we will look at different Options and Settings we can tweak when running a Tezos Node with Docker, and also install Prometheus and Grafana, a comprehensive Monitoring System.

First, we will need to enable “Swarm Mode” of our docker installation. Swarm Mode allows docker to do many awesome things like Load-balancing across multiple machines, we will not take advantage of many of those great features in this Guide, we just use it because it makes our life a lot easier, so let’s enable docker swarm:

$ docker swarm init

This will generate Output about how to add other machines for more complicated setups, we will ignore this.

We are gonna need a location where the tezos node will store its data, so let’s create a directory for that:

$ sudo mkdir /data  && sudo mkdir /data/tezos

and set permissions for that folder:

$ sudo chown $USER /data/tezos

Tezos Configuration

In the above directory, we will create a config.json file that holds all configuration options for tezos, a minimal config.json looks like this:

{ "p2p": {"listen-addr": "[::]:9732" }  }

Here are three common options we can set in the config:

History Mode

Tezos supports 3 different history modes, these affect the amount of storage needed by your node and how much information is available in the RPC API.

These mores are:

• full stores all data since the beginning of the chain but removes archived data

• rolling most lightweight, only stores data since the last snapshot.

• archive stores everything, requires a lot of Storage space

You can set the mode in the config like this:

{ “shell”: {“history_mode”: “full”} }

Bootstrap Peers

Here you can specify the inital peers your node will connect to, specify them like this:

{ “p2p”: {“bootstrap-peers”: [ip1:port1, ip2:port2,…]} }

Private Mode

In private mode your node will not connect to nodes other than your bootstrap peers, Bakers often do this to hide their IP and only connect to one ”Frontend Node” that is hosted somewhere else, enable it with:

{ “p2p”: {“private-mode”: true } }

You can view all possible config options with this command:

$ docker run --rm -it tezos/tezos:mainnet tezos-node config --help

Docker Container Configuration

We will save our docker setup in a file so we can keep track of the configuration, so create a docker-compose.yml file with the following content:

version: "3"services:  
  mainnet:
    image: tezos/tezos:mainnet
    command: ["tezos-node"]
    hostname: node
    ports:
      - "8732:8732"
      - "9732:9732/udp"
    volumes: 
       - "/data/tezos:/var/run/tezos/node"
    deploy:   
      resources:
        limits:
          cpus: '1'
          memory: 4096M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 10

In this file we define:

• what image to use

• what the start command is

• what ports we want to have available ( RPC Port and P2P port )

• where to store the tezos data

• the maximum resource limits to 1 CPU and 4096 MB Ram

• and how to restart the node if it fails

Now we can deploy our setup with:

$ docker stack deploy -c docker-compose.yml tezos

and can check if the node is running with either docker ps or docker service ls, and we can see the node logs with

$ docker service logs tezos_mainnet -f

While we wait for our Node to start syncing Blocks, lets setup our Monitoring System.

Docker Monitoring

For this we will use the Grafana + Prometheus Stack from https://github.com/stefanprodan/swarmprom, so lets git clone this project…

$ git clone https://github.com/stefanprodan/swarmprom.git
$ cd swarmprom

…create a run.sh file with the following content…

ADMIN_USER=admin \
ADMIN_PASSWORD=admin \
docker stack deploy -c docker-compose.yml mon

..and start the monitoring setup:

$ chmod +x run.sh
$ ./run.sh

Wait a minute for everything to download and start, then open your browser and access your monitoring dashboard at http://localhost:3000, it should look like this:

Final Notes

We now have a running Tezos Node + Monitoring System, there is a lot more to get into that are beyond the scope of this Guide and depend on your Use-Case, for example, Grafana can be set up to send you Slack notifications in case your nodes throws an error, Or if you run this on a public server you should not expose your RPC port to the world like we did in this Guide, to do this change the port section in the docker-compose to:

ports:
      - mode: host
        target: 8732
        published: 8732

For more information on all RPC calls I recommend looking at the official documentation here:https://tezos.gitlab.io/tezos/api/rpc.html

And for all other questions I recommend you join us in our matrix/riot chat on https://tzchat.org/ :)

Introduction

Cette procédure est minutieusement testée sur Debian 9.4. Il fonctionnerait également sur Ubuntu 18.04 et 16.04. Cela fonctionne également sur MacOS 10.13.5 si vous passez directement à l'étape d'installation d'Opam.

Ces étapes fonctionneraient également sur Raspberry Pi 3B et 3B + exécutant Ubuntu 18.04. Un disque dur externe est requis.

Change Log

• 2020-01-13: Make Opam installation directions more general, allowing for Opam 2.0.5

• 2018-08-31: Added libhidapi-dev as a system package dependency.

Steps

Login to new Debian or Ubuntu system and update its base packages. (In the following, replace "192.155.xxx.xxx" with the actual IP address of your server).

ssh [email protected]
apt-get update
apt-get dist-upgrade -y

Create a user account for building and running tezos. The tezos is name is arbitrary; pick your favorite -- just don't build and run services as root. If you already have a user account you can use that instead. Note that the make build-deps step requires sudo rights when it first runs, to install some system packages via apt-get.

adduser tezos
adduser tezos sudo
reboot
ssh [email protected]

If you are on Ubuntu 16, do this to be able to install bubblewrap and latest version of git. Everyone else, ignore this.

sudo add-apt-repository ppa:ansible/bubblewrap
sudo add-apt-repository ppa:git-core/ppa
sudo apt-get update

Similarly, if you are on Debian 9, do this to upgrade git to version 2.18.0. You need the debian "stretch-backports" source enabled to do this. If the following command fails, see the "Add backports to your sources.list" section at https://backports.debian.org/Instructions/ and follow the steps there; then try this again.

sudo apt-get -t stretch-backports install git

If you are on Centos 7.5 some of the system package names are different. Use this instead of the apt-get just below:

sudo yum install epel-release
sudo yum install bzip2 screen wget rsync gcc m4 make unzip patch libev-devel libev hidapi-devel gmp-devel bubblewrap git

If you are on Arch Linux/Manjaro the above applies with pacman:

sudo pacman -Syu
sudo pacman -S patch unzip make gcc m4 git g++ aspcud bubblewrap curl bzip2 rsync libevdev gmp pkgconf hidapi

Install the system packages needed to start building tezos binaries. The actual build scripts will install more packages.

sudo apt-get install -y patch unzip make gcc m4 git g++ aspcud bubblewrap curl bzip2 rsync libev-dev libgmp-dev pkg-config libhidapi-dev

(If you're on MacOS, you can start here.)

Install OPAM utility needed to build the OCaml code. Version 2.0.0 or later of opam is required. See https://opam.ocaml.org/doc/Install.html for alternative installation steps.

Opam installation:

If asked, just accept the default of installing to /usr/local/bin. Installing there depends on the 'tezos' user having sudo rights as we arranged above.

sh <(curl -sL https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh)

Opam installation, alternative manual method for MacOS and other:

Visit https://github.com/ocaml/opam/releases/. Find the newest stable 2.0.x release (2.0.5 works at the time of writing, January 2020) and download the binary executable for your architecture. Move that executable file to /usr/local/bin/opam and use chmod a+x to make it executable.

Opam setup

Now that opam is installed, initialize it. (Allow it to update .profile, etc, at your own discretion).

opam init --bare
eval $(opam env)

If you are running in the Windows 10 Linux Subsystem you may need to add --disable-sandboxing to the call to opam init above. Otherwise you may be blocked by brwap errors as bubblewrap does not currently work in that environment.

Note that the make build-deps step below builds a local opam environment within the build directory, so we no longer need to set up a switch as we did before.

Get the mainnet source code.

git clone -b mainnet https://gitlab.com/tezos/tezos.git
cd tezos

Install OCaml dependencies (and some system package dependencies too). An error message about "No repository tezos found" is normal when running this step for the first time; you can ignore that error. If you see an error like "Could not update repository "tezos": Commit found, but unreachable: enable uploadpack.allowReachableSHA1InWant on server" then you need to start over and install a newer version of git. See above about upgrading git in Ubuntu 16 and Debian 9.

make build-deps

Compile the binaries. Since the build-deps step above created an _opam directory with an opam switch for tezos, update the environment again before compiling to be sure we've got the right opam configuration.

eval $(opam env)
make

Configure the node identity. In the mainnet the "difficulty" used in generating the node identity must be at least 26. That is the default now in the identity generate command.

./tezos-node identity generate 26.

Run the node. (I also like to run the node inside a screen(1) session (without nohup or &) so that the process persists in the foreground and I can detach and come back to it later in another ssh session.)\

nohup ./tezos-node run --rpc-addr 127.0.0.1:8732 &

The node will take a while to sync, bringing in the blockchain data from the peers. To see its progress you can run the following command which shows the head block known so far and will exit when the node is fully synced:

./tezos-client bootstrapped

Look for the timestamp value in the output from that. When that value gets to within a minute or so of the current date and time then your node is synced. The expected network/chain_id value is NetXdQprcVkpaWU.

Faster bootstrap

It's possible to start up your node with a copy of the chain data that is (typically) just a few days old. See the directions at https://tezosshots.com/.

To activate a donation account

./tezos-client add address my_account 
./tezos-client activate fundraiser account my_account with 

The my_account name/alias above is arbitrary, but conventional.

Note: you can also import your private key info, but that is not necessary in order to claim the donation account:

./tezos-client import fundraiser secret key my_account

Also: if your goal is only to activate your Tezos account and claim the tez from the fundraiser, it’s much easier to just use stephenandrews online utility at https://stephenandrews.github.io/activatez/ .

Baking on Mainnet

See the Tezos baking howto by @dakk.

Workarounds when things won't build or run

In the top code directory, ~/tezos, run eval $(opam env). Then try again.

After doing eval $(opam env), do opam update && opam upgrade. Then try again.

Sometimes it helps to remove the entire ~/.opam directory and start over again from the opam init step. Slow, but it gives a clean start for OPAM packages. Note that if you are building alphanet or other from the same user, this also wipes out the OPAM context for that work too.

rm -rf ~/.opam

The make build-deps step pins many packages to particular versions. If you want a clean start short of removing ~/.opam, you can remove all those pins:

opam pin list -s | xargs opam pin remove

If you get 0 connections, verify that your node identity was built with sufficient difficulty:

./tezos-node identity check

Fix issue in macOS

On macOS make build-deps sometimes fails since it cannot build OCaml compiler. You may get the following error

<><> Gathering sources ><><><><><><><><><><><><><><><><><><><><><><><><><><>  🐫
[ocaml-base-compiler.4.08.1] found in cache

<><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><>  🐫
[ERROR] The compilation of ocaml-base-compiler failed at
        "/Users/ameten/.opam/opam-init/hooks/sandbox.sh build ./configure
        --prefix=/Users/ameten/.opam/4.08.1 CC=cc ASPP=cc -c".
∗ installed base-bigarray.base
∗ installed base-threads.base
∗ installed base-unix.base

#=== ERROR while compiling ocaml-base-compiler.4.08.1 =========================#
# context     2.0.5 | macos/x86_64 |  | https://opam.ocaml.org#b679cc38
# path        ~/.opam/4.08.1/.opam-switch/build/ocaml-base-compiler.4.08.1
# command     ~/.opam/opam-init/hooks/sandbox.sh build ./configure --prefix=/Users/ameten/.opam/4.08.1 CC=cc ASPP=cc -c
# exit-code   65
# env-file    ~/.opam/log/ocaml-base-compiler-5420-ffb3fd.env
# output-file ~/.opam/log/ocaml-base-compiler-5420-ffb3fd.out
### output ###
# /Users/ameten/.opam/opam-init/hooks/sandbox.sh: line 9: cd: /Users/ameten/.ccache: No such file or directory
# sandbox-exec: empty subpath pattern



<><> Error report <><><><><><><><><><><><><><><><><><><><><><><><><><><><><>  🐫
┌─ The following actions failed
│ λ build ocaml-base-compiler 4.08.1
└─
┌─ The following changes have been performed (the rest was aborted)
│ ∗ install base-bigarray base
│ ∗ install base-threads  base
│ ∗ install base-unix     base
└─
# Run eval $(opam env) to update the current shell environment
Switch initialisation failed: clean up? ('n' will leave the switch partially
installed) [Y/n] Y

Sandbox executable complains that there is not place to store compiler cache. You don't have /Users/username/.ccache on your system. Install ccache using your favourite package manager. Command for Homebrew:

If ccache is installed, but you don't have /Users/username/.ccache, run the following command to create the directory:

When you have /Users/username/.ccache you should be able to install OCaml compiler using opam.

opam switch create 4.08.1

Once you have OCaml compiler in opam, you should be able to run make build-deps although it will install its own OCaml compiler.

Rebuilding

To rebuild with the latest Mainnet code you can move or remove the "tezos" directory and start again from the git clone step. As an alternative you can update in place as follows.

git fetch
git reset --hard origin/mainnet
git clean -dxf
eval $(opam env)
make build-deps
make

Details here:https://github.com/Blindripper/FAQ/blob/patch-1/Rebuilding_Mainnet.md

References

Baking info: https://gist.github.com/dakk/bdf6efe42ae920acc660b20080a506dd

Docker images: https://hub.docker.com/r/tezos/tezos/tags/

Docker script: https://gitlab.com/tezos/tezos/blob/mainnet/docs/introduction/howtoget.rst Copy to mainnet.sh and run as usual.

Korean version : https://blog.naver.com/justmustone/221310459511

Korean version : Raspberry Pi 3 https://blog.naver.com/justmustone/221310583691

About

Written by @fredcy with help from the tech chat room and others.

Obtenir des Super Pouvoirs

Devenir un super héros est un processus assez simple.

<script src="https://asciinema.org/a/14.js" id="asciicast-14" async></script>

$ teztool create <name> --network mainnet --rpc-port 8732 --history-mode archive
# you can also pass arguments and flags to the tezos-node run command, like:
$ teztool create <name> --network mainnet --rpc-port 8732 --history-mode archive --extra-flags "--singleproccess"

# or just run this and teztool will ask for all input:
$ teztool create

$ teztool <name> start 

sudo chown -R $USER:staff ~
$ teztool <name> snapshot import  <file>
$ teztool <name> start




# Building a Node w/teztool
    git clone https://gitlab.com/nomadic-labs/teztool.git
    cd ./teztool
    go build -o teztool *.go 
    mv teztool /usr/local/bin/teztool

# Past to .bash_profile
    echo >> export  > .bash_profile 
    #alias teztool='docker run -it --rm -v $PWD:/mnt/pwd --network host -e DIND_PWD=$PWD -v /var/run/docker.sock:/var/run/docker.sock registry.gitlab.com/nomadic-labs/teztool:latest'
    #alias teztool-update='docker pull registry.gitlab.com/nomadic-labs/teztool:latest'


asciinema rec --title="Build a Tezos Rolling Storage Node in < 2 min" --yes

Une fois que vous êtes assez fort, sauvez le monde:

# Ain't no code for that yet, sorry
echo 'You got to trust me on this, I saved the world'