00-Foundations - Origines Cypherpunk et Environnement

Navigation : Sommaire de la série | SC-3 Solidity Basics >>

La sous-série d’ouverture des SmartContracts (SC-0 a SC-2b) pose les deux socles sur lesquels toute la série reposera : le pourquoi (les primitives cryptographiques qui font qu’une blockchain tient) et le comment (l’environnement de développement). On commence par remonter aux origines cypherpunk – hachage, arbres de Merkle, preuve de travail, signatures, tables de hachage distribuées – pour comprendre pourquoi une chaîne est immuable et résistante à la falsification. On installe ensuite Foundry (forge, cast, anvil), la trousse à outils de référence, puis on connecte web3.py + py-solc-x a anvil pour compiler, déployer et appeler un premier contrat Solidity entièrement depuis Python. Le compagnon SC-2b retourne ensuite le point de vue : au lieu d’un compte unique qui joue tous les rôles, trois acteurs à clé délibèrent par contrat – et l’on voit une institution produire un résultat litigieux sans violer aucune règle.

A l’issue de cette phase (~2h50), l’environnement est opérationnel et le pattern de compilation/déploiement depuis Python – réutilise dans tous les notebooks suivants – est en place. Les notebooks suivants supposent cet environnement installé : Foundry sur le PATH, web3/py-solc-x disponibles, anvil capable de lancer une blockchain locale.

Notebooks

# Notebook Durée Contenu
0 SC-00-Cypherpunk-Origins-Python ~60 min Mouvement cypherpunk, primitives cryptographiques (hash, signatures, PoW), mini-blockchain Python, arbre de Merkle, DHT/Kademlia
1 SC-01-Setup-Foundry-Python ~30 min Installation Foundry (forge/cast/anvil), vérification Solidity, premier projet, compilation + test d’un contrat simple
2 SC-02-Setup-Web3py-Python ~40 min web3.py + py-solc-x, connexion a anvil, compiler/déployer/appeler un contrat depuis Python, pattern réutilisable
2b SC-02b-Bac-ASable-Institutionnel-Python ~40 min Bac a sable institutionnel : acteurs a cles BIP44, contrat Deliberation (quorum, anti-double-vote, cloture en blocs), journal d’evenements pandas, rejouabilite par mnemonic, echec institutionnel licite

Objectifs d’apprentissage

A l’issue de cette sous-série, vous serez capable de :

  1. Expliquer les primitives cryptographiques fondatrices (hachage, Merkle, PoW, signatures) et leur rôle dans l’immutabilité d’une blockchain
  2. Installer l’environnement de développement complet (Foundry + web3.py + py-solc-x)
  3. Compiler, déployer et appeler un contrat Solidity depuis Python via anvil
  4. Établir le pattern de déploiement réutilisable pour les notebooks suivants
  5. Simuler une délibération multi-acteurs rejouable (SC-2b) : journal d’événements pandas, empreinte SHA-256, échec institutionnel licite

Prérequis

Notebook Prérequis
SC-0 Cypherpunk Origins Python 3.10+ (hashlib stdlib), pycryptodome pour les signatures ; aucune connaissance blockchain préalable
SC-1 Setup Foundry Python 3.10+, curl ou PowerShell, Git
SC-2 Setup Web3py SC-1 complète (anvil installé), Python 3.10+, pip install web3 py-solc-x
SC-2b Bac a sable institutionnel SC-2 complète (pattern compile-deploy-call), pip install web3 py-solc-x pandas

Remarques pédagogiques

  • SC-0 travaille les primitives from scratch en Python : aucune blockchain externe n’est requise. La mini-blockchain et l’arbre de Merkle sont construits a la main pour rendre la théorie tangible.
  • SC-1 / SC-2 sont des notebooks de setup : ils installent et verifient l’environnement. Les outputs committes documentent honnêtement ce qui s’exécute (Foundry installé, anvil lance, contrat compile+déployé) – ils ne contiennent pas d’erreurs volontaires et s’exécutent de bout en bout une fois les dépendances présentes.
  • Le pattern compile -> deploy -> call établi en SC-2 est celui repris dans toute la série (01-Solidity-Foundation et au-delà) : c’est la fondation technique autant que conceptuelle.

Ponts inter-séries

Série Lien Relation
SmartContracts (parent) Vue d’ensemble Contexte et parcours global de la série
01-Solidity-Foundation Suite immédiate SC-3 Solidity Basics démarre après SC-2

Conclusion / Prochaines étapes

Ce que vous avez appris

Cette sous-série d’ouverture vous a posé les deux socles sur lesquels toute la série SmartContracts reposera. L’arc pédagogique procède du pourquoi au comment :

  • Le socle conceptuel — les primitives cypherpunk (SC-0) — vous êtes remonté aux origines de la blockchain en reconstruisant les briques cryptographiques from scratch en Python : le hachage (ancrage immuable), l’arbre de Merkle (preuve d’inclusion logarithmique), la preuve de travail (résistance à la falsification par le coût computationnel), les signatures numériques (authentification non-répudiable), et la table de hachage distribuée / Kademlia (coordination sans serveur central). Comprendre ces primitives, c’est comprendre pourquoi une chaîne est immuable : non par décret, mais parce que chaque brique rend la falsification exponentiellement plus coûteuse que la vérification.
  • Le socle technique — l’environnement Foundry + web3.py (SC-1, SC-2) — vous avez installé la trousse à outils de référence (forge, cast, anvil) puis connecté web3.py + py-solc-x à une blockchain locale anvil. Le résultat n’est pas anecdotique : le pattern compile -> deploy -> call établi en SC-2 est celui repris dans tous les notebooks suivants. C’est la fondation opérationnelle autant que conceptuelle de la série.
  • La posture honnête — les notebooks de setup documentent ce qui s’exécute réellement (Foundry installé, anvil lancé, contrat compilé et déployé), sans erreurs volontaires. La rigueur commence ici : un environnement reproductible est la condition de toute expérimentation sérieuse sur les smart contracts.

Prochaines étapes

  • Solidity par la pratique : la suite immédiate est 01-Solidity-Foundation (SC-3 Solidity Basics et au-delà), qui exploite l’environnement désormais opérationnel pour écrire de vrais contrats — variables, fonctions, modifiers, événements, héritage.
  • Approfondir les primitives : SC-00-Cypherpunk-Origins-Python mérite d’être repris après avoir écrit des contrats en Solidity — la théorie du hachage et de Merkle prend tout son sens quand on manipule keccak256 et le stockage d’un contrat.
  • La série dans son ensemble : le sommaire SmartContracts cartographie les sept sous-séries (Foundations, Solidity Fondements, Solidity Avancé, Foundry-Testing, Privacy/Cryptography, Alternative-Chains, Real-World) — cette sous-série n’est que le seuil.

Le fil rouge

L’ouverture propose un changement de regard sur les smart contracts : ne plus les voir comme du « code sur une blockchain » magique, mais comme la composition de primitives cryptographiques dont l’immutabilité est mathématiquement fondée, manipulées via un environnement d’outils reproductible. Cette sous-série vous a donné le pourquoi (les primitives cypherpunk) et le comment (Foundry + web3.py), en gardant à l’esprit que le pattern compile -> deploy -> call établi ici est le squelette de toute la suite — et que la rigueur de l’environnement est la condition non-négociable de toute expérimentation honnête.

Retour au sommet