bool CheckProofOfWork(uint256 hash, unsigned int nBits, ...);

// Conversion nBits vers target
Target.SetCompact(nBits, &fNegative, &fOverflow);

// La preuve est valide si hash <= target
bool isValid = hash <= target;

// Structure d'une transaction Bitcoin
class CTransaction {
public:
    std::vector vin;   // Inputs: références aux UTXO précédents
    std::vector vout; // Outputs: nouveaux UTXO créés
};

// Input référence un UTXO précédent
class CTxIn {
    COutPoint prevout;  // (txid, index)
    CScript scriptSig;  // Script de déverrouillage
};

// Point d'entrée de validation de script
bool VerifyScript(
    const CScript& scriptSig,
    const CScript& scriptPubKey,
    const CTxOut& txout,
    unsigned int nIn,
    unsigned int flags,
    ...);

// Exemple: P2PKH (Pay to Public Key Hash)
// ScriptPubKey: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
// ScriptSig: <signature> <pubKey>

// StateDB gère l'état Ethereum
type StateDB interface {
    // Lecture d'état
    GetBalance(addr common.Address) *big.Int
    GetCode(addr common.Address) []byte
    GetState(addr common.Address, key common.Hash) common.Hash
    
    // Écriture d'état
    SetBalance(addr common.Address, *big.Int)
    SetCode(addr common.Address, []byte)
    SetState(addr common.Address, key, value common.Hash)
    
    // Finalisation
    Commit(write bool) (root common.Hash, err error)
}

// Boucle d'exécution de l'EVM
func (evm *EVM) Run(pc *uint64, contract *Contract) ([]byte, error) {
    for {
        // Lecture de l'opcode à l'adresse PC
        op := OpCode(code[*pc])
        
        // Exécution de l'opcode
        operation := operations[op]
        if operation.execute == nil {
            return nil, fmt.Errorf("invalid opcode %v", op)
        }
        
        // Exécution avec coût gas
        evm.gas -= operation.gasCost(evm, args...)
        if evm.gas < 0 {
            return nil, ErrOutOfGas
        }
        
        // Exécution de l'opération
        operation.execute(&evm.stack, &evm.memory, &evm.storage)
        
        // Incrémentation du PC
        *pc++
    }
}

// Coûts de gas pour opérations courantes
const (
    GasQuickStep       uint64 = 2     // Opérations simples
    GasFastStep        uint64 = 3     // Opérations rapides
    GasMidStep         uint64 = 5     // Opérations moyennes
    GasExtStep         uint64 = 20    // Opérations extensives
    GasStorageSet      uint64 = 20000  // Écriture storage
    GasStorageUpdate   uint64 = 5000   // Mise à jour storage
    GasCall            uint64 = 700    // Appel de contrat
)

// Calcul du gas pour un appel de fonction
func gasCall(evm *EVM, contract *Contract, args ...interface{}) (uint64, error) {
    gas := GasCall
    if len(args) > 0 {
        // Ajouter gas pour la mémoire
        gas += memoryGasCost(args)
    }
    return gas, nil
}

// Concept de ring signature (pseudo-code)
class RingSignature {
    // Génération de la signature
    static bool generate(
        const std::vector<const crypto::public_key>& ringKeys,  // Ensemble de clés
        const crypto::secret_key& secretKey,                        // Clé réelle
        const crypto::hash& message,
        crypto::signature& sig
    ) {
        // 1. Sélectionner un indice aléatoire pour la vraie clé
        size_t realIndex = random(0, ringKeys.size());
        
        // 2. Générer des leurres (decoys) pour les autres indices
        for (size_t i = 0; i < ringKeys.size(); i++) {
            if (i != realIndex) {
                ringKeys[i] = generateDecoyKey();
            }
        }
        
        // 3. Créer la signature qui preuve possession de realIndex
        return createMLSAG(ringKeys, secretKey, message, sig);
    }
    
    // Vérification: peut être faite sans savoir quelle clé a signé
    static bool verify(
        const std::vector<const crypto::public_key>& ringKeys,
        const crypto::hash& message,
        const crypto::signature& sig
    ) {
        return checkMLSAG(ringKeys, message, sig);
    }
};

// Concept de RingCT (pseudo-code)
class RingCT {
    // Engagement de Pedersen: C = x*G + v*H
    // x = blinding factor (secret), v = montant, G,H = generators
    static commitment createCommitment(const uint64_t amount) {
        scalar x = randomScalar();  // Facteur aveuglant
        point C = x*G + amount*H;   // Engagement
        return {C, x};              // Retourne engagement + facteur secret
    }
    
    // Vérification de conservation de valeur
    static bool verifyBalance(
        const std::vector<commitment>& inputCommits,
        const std::vector<commitment>& outputCommits,
        const std::vector<bulletproof>& proofs
    ) {
        // Σ(inputs) - Σ(outputs) = 0 (en commitment)
        point sumInputs = sum(inputCommits);
        point sumOutputs = sum(outputCommits);
        
        // Vérifier que la différence est zéro
        // en utilisant les preuves bulletproof
        for (const auto& proof : proofs) {
            if (!verifyBulletproof(proof, sumInputs - sumOutputs)) {
                return false;
            }
        }
        return true;
    }
};

// Concept de Stealth Address (pseudo-code)
class StealthAddress {
    // Génération d'adresse stealth à partir de la clé publique du destinataire
    static address generateStealth(
        const public_key& destPublicViewKey,   // Clé de vue publique
        const public_key& destPublicSpendKey,  // Clé de dépense publique
        const scalar& randomEntropy            // Random
    ) {
        // Calcul: P = Hs(r*A)*G + B
        // r = randomEntropy, A = clé de vue, B = clé de dépense
        scalar r = randomEntropy;
        point R = r * G;                              // Publication
        scalar Hs_rA = hashToScalar(r * destPublicViewKey);  // H(r*A)
        point P = Hs_rA * G + destPublicSpendKey;    // Adresse stealth
        
        return {P, R};  // R publié, P utilisé comme adresse
    }
    
    // Dépense: le destinataire calcule la clé privée correspondante
    static scalar derivePrivateKey(
        const scalar& r,                              // Secret utilisé
        const scalar& privateViewKey,                 // Clé de vue privée
        const scalar& privateSpendKey                 // Clé de dépense privée
    ) {
        scalar Hs_rA = hashToScalar(r * (privateViewKey * G));
        return Hs_rA + privateSpendKey;  // Clé privée de l'adresse stealth
    }
};

// Flux: Solidity -> Compilateur (solc) -> Bytecode -> EVM

// Exemple de code Solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public storedData;
    
    function set(uint256 x) public {
        storedData = x;
    }
}

// Bytecode compilé (conceptuel):
// PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x04 PUSH1 0x00 ...

// Structure minimale d'un smart contract
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Compteur {
    // State variable: stockage on-chain
    uint256 public count;
    address public owner;
    
    // Constructeur: appelé au déploiement
    constructor() {
        owner = msg.sender;
    }
    
    // Fonction: logique métier
    function increment() public {
        count += 1;
    }
    
    function decrement() public {
        require(count > 0, "Cannot go below zero");
        count -= 1;
    }
}

// Différence storage / memory / calldata
pragma solidity ^0.8.0;

contract StorageExample {
    // Storage: données persistantes on-chain
    uint256[] public numbers;
    
    function addNumber(uint256 _value) public {
        // _value est en calldata (immuable, pas de copy)
        // On copie en memory pour manipulation
        uint256 temp = _value;
        
        // push ajoute au storage (persistant, coûteux)
        numbers.push(temp);
    }
    
    function getSum() public view returns (uint256) {
        // Memory: calcul temporaire
        uint256 sum = 0;
        for (uint256 i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        return sum;
    }
}

// Types et visibilité en Solidity
pragma solidity ^0.8.0;

contract TypesExample {
    // Types de base
    bool public paused = false;
    address public owner;
    uint256 public count = 0;
    
    // Mapping: table associative
    mapping(address => uint256) public balances;
    mapping(address => bool) public isWhitelisted;
    
    // Struct: structure de données personnalisée
    struct Proposal {
        string description;
        uint256 votesFor;
        uint256 votesAgainst;
        bool executed;
        address proposer;
    }
    
    // Tableau de structs
    Proposal[] public proposals;
    
    // Visibilité: 
    // public: accessible partout (externally + internally)
    // private: seulement dans ce contrat
    // internal: dans ce contrat et ses héritiers
    // external: seulement depuis l'extérieur

// Modifiers et contrôle d'accès
pragma solidity ^0.8.0;

contract AccessControl {
    address public owner;
    
    // Modifier: condition avant exécution de la fonction
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _; // Continue l'exécution de la fonction
    }
    
    modifier whenNotPaused() {
        require(!paused, "Contract is paused");
        _;
    }
    
    bool public paused = false;
    
    constructor() {
        owner = msg.sender;
    }
    
    // Utilisation des modifiers
    function pause() public onlyOwner {
        paused = true;
    }
    
    function unpause() public onlyOwner {
        paused = false;
    }
    
    // Fonction protégée par plusieurs modifiers
    function sensitiveOperation() 
        public 
        onlyOwner 
        whenNotPaused 
    {
        // Logique sensibles
    }
}

// Events et interaction
pragma solidity ^0.8.0;

contract EventExample {
    // Déclaration d'un event
    // indexed: permet de filtrer par cette valeur
    event ValueChanged(
        address indexed user, 
        uint256 oldValue, 
        uint256 newValue
    );
    
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 amount
    );
    
    uint256 public value;
    
    function setValue(uint256 _newValue) public {
        uint256 oldValue = value;
        value = _newValue;
        
        // Émission de l'event
        emit ValueChanged(msg.sender, oldValue, _newValue);
    }
    
    // Event avec adress: plus courant
    mapping(address => uint256) public balances;
    
    function transfer(address to, uint256 amount) public {
        require(balances[msg.sender] >= amount);
        balances[msg.sender] -= amount;
        balances[to] += amount;
        
        emit Transfer(msg.sender, to, amount);
    }
}

// Version 1: Vote simple - Compteur de votes on-chain
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Vote {
    // State variables: stockage on-chain
    uint256 public yes;
    uint256 public no;
    
    // everyone can vote yes
    function voteYes() public {
        yes += 1;
    }
    
    // everyone can vote no
    function voteNo() public {
        no += 1;
    }
    
    // Obtenir le résultat
    function getResult() public view returns (string memory) {
        if (yes > no) {
            return "Approved";
        } else if (no > yes) {
            return "Rejected";
        } else {
            return "Tied";
        }
    }
}

// Version 2: Anti double vote avec mapping
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VoteWithPrevention {
    uint256 public yes;
    uint256 public no;
    
    // Mapping: enregistrement des votants
    // address => bool: a déjà voted?
    mapping(address => bool) public hasVoted;
    
    // Enums: type personnalisé
    enum VoteOption { None, Yes, No }
    mapping(address => VoteOption) public userVote;
    
    function voteYes() public {
        // Vérification: pas encore voted
        require(!hasVoted[msg.sender], "Already voted");
        
        // Enregistrement
        hasVoted[msg.sender] = true;
        userVote[msg.sender] = VoteOption.Yes;
        
        yes += 1;
    }
    
    function voteNo() public {
        require(!hasVoted[msg.sender], "Already voted");
        
        hasVoted[msg.sender] = true;
        userVote[msg.sender] = VoteOption.No;
        
        no += 1;
    }
}

// Version 3: Mini DAO structurée
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MiniDAO {
    // Struct: proposition avec état complet
    struct Proposal {
        string description;
        uint256 yesVotes;
        uint256 noVotes;
        bool executed;
        uint256 createdAt;
        address proposer;
    }
    
    // Storage
    Proposal[] public proposals;
    mapping(uint256 => mapping(address => bool)) public hasVoted;
    address public owner;
    
    // Événements
    event ProposalCreated(uint256 indexed id, string description);
    event VoteCast(uint256 indexed id, address voter, bool support);
    event ProposalExecuted(uint256 indexed id, bool approved);
    
    constructor() {
        owner = msg.sender;
    }
    
    // Créer une proposition
    function createProposal(string memory _description) public {
        proposals.push(Proposal({
            description: _description,
            yesVotes: 0,
            noVotes: 0,
            executed: false,
            createdAt: block.timestamp,
            proposer: msg.sender
        }));
        emit ProposalCreated(proposals.length - 1, _description);
    }
    
    // Voter sur une proposition
    function vote(uint256 _proposalId, bool _support) public {
        Proposal storage proposal = proposals[_proposalId];
        
        require(!proposal.executed, "Already executed");
        require(!hasVoted[_proposalId][msg.sender], "Already voted");
        
        hasVoted[_proposalId][msg.sender] = true;
        
        if (_support) {
            proposal.yesVotes++;
        } else {
            proposal.noVotes++;
        }
        
        emit VoteCast(_proposalId, msg.sender, _support);
    }
    
    // Exécuter une proposition (si majorité)
    function executeProposal(uint256 _proposalId) public {
        Proposal storage proposal = proposals[_proposalId];
        
        require(!proposal.executed, "Already executed");
        
        // Règle de gouvernance: > 50% et au moins 3 votes
        uint256 total = proposal.yesVotes + proposal.noVotes;
        require(total >= 3, "Quorum not reached");
        require(proposal.yesVotes > proposal.noVotes, "Not approved");
        
        proposal.executed = true;
        
        emit ProposalExecuted(_proposalId, true);
        // Logique d'exécution ici (transfert, etc.)
    }
}