Auteur : Zen et l'art de la programmation informatique
1. Introduction
Cet article détaillera comment créer une crypto-monnaie hautement personnalisée via le langage de programmation Solidity. L'article convient aux lecteurs qui ont une certaine base en programmation et doivent avoir des connaissances en économie, en finance ou en monnaie numérique. Si vous ne disposez pas de telles réserves de connaissances, il est recommandé de lire d'abord des ouvrages professionnels pertinents.
L’essor de la technologie Crypto-Monnaie et Blockchain a sensibilisé de plus en plus de personnes aux changements qui s’opèrent dans le monde. En tant que pionnier de la nouvelle ère, je crois que chacun explore de nouvelles connaissances et méthodes pour créer son propre système de valeurs. Alors, quels projets ou organisations ont lancé avec succès de nouveaux projets de crypto-monnaie ou de blockchain au cours des dernières années ? Quels autres projets ou organisations ont échoué pour diverses raisons ? Quel est le sort de ces projets ?
Dans cet article, nous allons essayer de vous présenter comment créer votre propre système de crypto-monnaie via le langage de programmation Solidity dans la perspective de « créer une crypto-monnaie hautement personnalisée ». Nous apprendrons les concepts de base, la terminologie, les principes de l'algorithme, les étapes de fonctionnement spécifiques, les exemples de code et les orientations de développement futures impliquées dans la création d'un système de crypto-monnaie personnalisé. J'espère qu'en lisant cet article, les lecteurs pourront avoir une compréhension plus approfondie du langage de programmation Solidity et de la crypto-monnaie, et améliorer leurs compétences en développement de crypto-monnaie.
2. Explication des concepts et termes de base
2.1 Crypto-monnaie et Blockchain
Cryptomonnaie : La cryptomonnaie (anglais : Cryptocurrency), également appelée monnaie numérique, est un système de paiement électronique basé sur la technologie blockchain pour les transactions en ligne, communément appelé « Bitcoin ». Les crypto-monnaies sont généralement générées par les utilisateurs et hébergées sur un réseau distribué auquel tout le monde peut accéder, envoyer et recevoir des crypto-monnaies.
Blockchain : Blockchain (anglais : Blockchain) est une base de données distribuée qui enregistre l'historique de toutes les transactions en monnaie numérique. Il stocke les données de manière décentralisée et utilise des mécanismes de consensus cryptographique pour garantir la cohérence des données, c'est-à-dire que tous les participants suivent les mêmes règles. Chaque enregistrement de transaction est ajouté à la blockchain pour former une chaîne. De cette manière, la blockchain fournit un enregistrement fiable et immuable et permet de vérifier et de confirmer les transactions.
2.2 Bitcoin et jeton ERC-20
Bitcoin est un type de crypto-monnaie caractérisé par l’anonymat et n’est pas limité par les lois nationales. La principale caractéristique du Bitcoin est sa conception décentralisée, qui peut réaliser des fonctions telles que le paiement et la comptabilité. Cependant, ses frais de transaction sont relativement élevés. Lorsque le montant de chaque transaction atteint un certain seuil, elle sera confirmée et mise en chaîne.
Jeton ERC-20 : Le jeton ERC-20 d'Ethereum (également appelé jeton) est une norme de jeton décentralisée qui s'exécute sur la blockchain Ethereum. Il définit un ensemble d'interfaces communes qui permettent aux contrats intelligents de créer leurs propres tokens et de les échanger de manière standard. Le jeton ERC-20 est une norme de jeton qui peut être utilisée pour représenter une grande variété d'actifs, tels que l'ETH, le BTC ou les actions d'une entreprise. Vous pouvez créer votre propre jeton ERC-20 pour représenter votre entreprise, votre identité personnelle, etc., ou vous pouvez émettre ces jetons ERC-20 sur le marché pour des transactions.
2.3 Introduction au langage Solidity
Solidity : Un langage compilé statiquement de haut niveau basé sur la machine virtuelle EVM pour l'écriture d'applications décentralisées (DAPP). Solidity est un langage orienté objet pour rédiger des contrats intelligents. Il prend en charge une variété de types de données, tels que les entiers, les nombres à virgule flottante, les chaînes, les valeurs booléennes, les adresses, les tableaux, les structures, etc. ; il prend également en charge les pointeurs, l'héritage, les classes abstraites, les événements, etc.
2.4 Machine virtuelle EVM
EVM : Le nom complet est Ethereum Virtual Machine, qui est un composant clé de la plateforme Ethereum. Il s'agit d'un moteur informatique qui exécute des contrats intelligents, semblable à une machine virtuelle en Java ou dans d'autres langages de programmation.
2.5 DAPP
DAPP : L'abréviation de Decentralized Application signifie application décentralisée. Différent des applications Web traditionnelles, DAPP fonctionne entièrement sur des contrats intelligents sur la blockchain. Toutes les données des utilisateurs sont stockées en permanence. Il n'y a pas lieu de s'inquiéter des problèmes de sécurité des données. DAPP peut fournir un niveau de service ultra élevé. Par exemple, il existe un grand nombre d'applications décentralisées sur Ethereum, notamment des chaînes d'État, des plateformes de jeux en chaîne d'alliances, des plateformes de prêt, des jetons non fongibles, des organisations autonomes décentralisées DAO, etc.
2.6 DEX et contrats intelligents
DEX (Decentralized Exchange) : Échange décentralisé. Actuellement, l’échange décentralisé basé sur la blockchain le plus populaire est Uniswap. Uniswap est un échange entièrement décentralisé qui connecte les transactions entre plusieurs crypto-monnaies. Les utilisateurs doivent simplement spécifier ce qu'ils souhaitent acheter, plutôt que de soumettre d'abord une demande de commande à la bourse comme une bourse centralisée.
Contrat intelligent : Un contrat intelligent est un programme déployé sur la blockchain, qui contrôle le fonctionnement de la blockchain grâce au code présent dans le contrat. Leurs fonctions incluent les dépôts, les retraits, les transferts, les fonctions d'appel, etc. Les contrats intelligents sur la blockchain peuvent effectuer une gestion automatisée des actifs, comme les prêts hypothécaires automatisés, la gestion des jetons de contrat intelligents, etc.
2.7 DAO
DAO (Organisation Autonome Décentralisée) : Organisation autonome décentralisée. DAO est une forme organisationnelle dont les droits de propriété et de gouvernance sont détenus dans des contrats intelligents et sont strictement réglementés. DAO est composé d'un groupe de membres indépendants et ne nécessite aucun vote ou prise de décision de tiers. Il peut prendre directement des décisions via des contrats intelligents selon des règles internes prédéfinies.
3. Explication des principes de base de l'algorithme, des étapes de fonctionnement spécifiques et des formules mathématiques
3.1 Structure des données
3.1.1 Structure des données utilisateur
struct User { uint userId ; // Chaîne d'identification de l'utilisateur userName ; // Adresse du nom d'utilisateur userAddress ; // Adresse du compte utilisateur }
Cette structure représente la structure de données d'un utilisateur, où userId représente l'identifiant unique de l'utilisateur, userName représente le nom de l'utilisateur et userAddress représente l'adresse du compte de l'utilisateur.
3.1.2 Structure des données des actifs
struct Asset { uint AssetId ; // Identifiant de l'actif bytes32 nom ; // Symbole de chaîne du nom de l'actif ; // Symbole de l'actif uint totalSupply ; // Quantité totale d'approvisionnement bool isDivisible ; // S'il s'agit d' un mappage divisible (adresse => uint) soldes ; // Table de mappage de solde de détenteur mapping(address => mapping(address => uint)) autorisé ; // Table de mappage de jetons autorisée }
Cette structure représente la structure de données d'un actif, où AssetId représente l'identifiant unique de l'actif, name représente le nom de l'actif, symbol représente le symbole de l'actif, totalSupply représente l'offre totale de l'actif, isDivisible représente s'il est divisible et les soldes représentent la table de mappage des soldes du titulaire, autorisé représente la table de mappage des jetons autorisée.
3.1.3 Structure des données de transaction
struct Transaction { uint transactionId; // Adresse d'identifiant de transaction de; // Transférer l'adresse du compte vers; // Transférer l'adresse du compte uint montant; // Montant de la transaction en octets de données; // Données supplémentaires uint timestamp; // Horodatage de la transaction }
Cette structure représente la structure de données d'une transaction, où transactionId représente l'identifiant unique de la transaction, from représente l'adresse du compte du transfert, to représente l'adresse du compte du transfert, montant représente le montant de la transaction, data représente des données supplémentaires , et timestamp représente la transaction.
3.1.4 Introduction au livre blanc
« Au-delà du Bitcoin : Création de crypto-monnaies avancées avec un langage de programmation Solidity » mentionne quelques informations du livre blanc, et nous en citerons une partie comme suit :
- Cet article fournit une introduction à la motivation derrière le concept de système de paiement électronique P2P de Satoshi Nakamoto et à ses principales caractéristiques, notamment un réseau peer-to-peer distribué qui accepte les transactions sans autorité centrale ni tiers de confiance.
- Ce livre offre un aperçu complet du fonctionnement du Bitcoin et explique en détail tous ses détails techniques. Il comprend également un chapitre sur la création de votre propre monnaie numérique en utilisant Bitcoin comme base. Les exemples fournis sont écrits en Python mais vous pouvez facilement les traduire vers d'autres langages de programmation tels que JavaScript ou Java.
- Une présentation donnée par le professeur Woodbury de l'Université hébraïque de Jérusalem expliquant les bases des technologies blockchain. Il couvre des sujets tels que les algorithmes de consensus, la décentralisation, les blockchains sans autorisation et avec autorisation, etc.
- Cet article présente Ethereum, qui est l'une des crypto-monnaies les plus populaires basées sur la technologie blockchain. Il discute de ses avantages par rapport au Bitcoin, introduit certains concepts clés tels que les contrats intelligents, la décentralisation, les pools miniers et les échanges, et passe en revue plusieurs cas d'utilisation.
3.2 Algorithme de consensus
Algorithme de consensus : L'algorithme de consensus est un protocole utilisé dans les systèmes distribués pour garantir la cohérence des résultats de calcul des différents nœuds. Les algorithmes de consensus courants incluent Paxos, Raft, ZAB, etc. Lorsque plusieurs nœuds reçoivent différents messages en même temps et doivent sélectionner une valeur comme action suivante, un algorithme de consensus est nécessaire pour résoudre les conflits.
3.2.1 Algorithme PoW (algorithme de preuve de travail)
function mineBlock() public return (uint récompense){ require(!blockMined[msg.sender]); // Détermine si l'utilisateur actuel a miné if (!isValidProof()) return; // Si la puissance de calcul dépasse la valeur cible , then S'est avéré valide blockMined[msg.sender] = true; // Définit la récompense actuelle de l'utilisateur += calculateReward(); // Obtenez des récompenses en fonction du montant extrait par le mineur récompense = courantReward; // Renvoie la récompense au user addTransaction(" mining", "MINING", msg.sender, currentReward); // Ajouter une transaction minière currentReward = 0; // Effacer la récompense actuelle émet Mined(currentReward); // Déclencher un événement minier }
Ce code représente un exemple d'algorithme de preuve de charge de travail, dans lequel la fonction mineBlock() est la fonction d'entrée permettant aux utilisateurs de demander du minage. Elle détermine d'abord si l'utilisateur a déjà miné. S'il a déjà miné, il renverra un message d'erreur. . S'il n'a pas miné, il renverra un message d'erreur. , il est alors jugé si la puissance de calcul atteint la valeur cible. Si elle est atteinte, elle est prouvée valide et l'utilisateur qui a réussi à miner sera ajouté au liste minée. Ensuite, la récompense sera calculée et restituée à l'utilisateur. Enfin, la récompense minière sera écrite dans la liste des transactions. Et déclenchera l'événement minier.
3.2.2 Algorithme PoS (algorithme Proof of Stake)
function vote() public payable{ // Détermine si le compte courant a voté require(!voted[msg.sender]); voté[msg.sender] = true; // Définit le compte pour qu'il ait voté balanceOf[msg.sender] += msg.value; // Ajouter le montant du gage au compte courant totalSupply += msg.value; // Augmenter l'offre totale addTransaction("staking", "STAKING", msg.sender, msg.value); // Ajouter la transaction de gage émettre VoteCast (msg.sender, msg.value); // Déclencher l'événement de vote }
Ce code représente un exemple d'algorithme de preuve de participation. La fonction vote() est la fonction de saisie permettant aux utilisateurs de demander des engagements. Elle détermine d'abord si l'utilisateur a voté. Si l'utilisateur a voté, un message d'erreur sera renvoyé. S'il n'y a pas de vote, le compte sera créé. Voté, et ajouté le montant du gage au compte courant, et finalement écrit la transaction de gage dans la liste des transactions et déclenché l'événement de vote.
3.3 Logique métier
3.3.1 Créer des jetons
constructeur (nom_mémoire de chaîne, symbole de mémoire de chaîne, uint _initialSupply, bool _divisible) public { nom = _nom ; symbole = _symbole ; totalSupply = _initialSupply*(10**(uint(_decimals))); estDivisible = _divisible; propriétaire = msg.expéditeur ; soldes[propriétaire] = totalSupply ; émettre Transfer(address(0), propriétaire, totalSupply); }
Ce code représente un exemple de création d'un token. La fonction constructor() est la fonction d'entrée lors de l'initialisation du contrat. Elle crée les attributs de base du token, tels que le nom, le symbole, la fourniture initiale, s'il est divisible, etc.
3.3.2 Transfert
function transfer(address _to, uint _value) public return (bool success) { require(balanceOf[msg.sender] >= _value); require(balanceOf[_to]+_value > balanceOf[_to]); soldes[msg.sender]-= _value ; soldes[_to]+= _value ; addTransaction("transfer", "TRANSFER", msg.sender, _to, _value); émettre Transfer(msg.sender, _to, _value); succès = vrai ; }
Ce code représente un exemple de transfert, dans lequel la fonction transfer() est la fonction de saisie permettant aux utilisateurs de demander des transferts. Elle détermine d'abord si le solde de l'utilisateur est suffisant, puis met à jour le solde du compte, écrit la transaction de transfert dans la liste des transactions. et déclenche l'événement de transfert.
3.3.3 Opérations confiées
function approuver (adresse du dépensier, valeur uint) retours publics (succès booléen) { allocations[msg.sender][spender] = valeur ; addTransaction("approve", "APPROVE", msg.sender, dépenseur, valeur); émettre une approbation (msg.sender, dépensier, valeur) ; succès = vrai ; }
function transferFrom(adresse _from, adresse _to, uint _value) retours publics (succès bool) { require(balanceOf[_from]>=_value && allocations[_from][msg.sender]>=_value); require(balanceOf[_to]+_value > balanceOf[_to]); soldes[_from]-=_value ; soldes[_to]+=_value ; allocations[_from][msg.sender]-=_value; addTransaction("transferFrom", "TRANSFERFROM", _from, _to, _value); émettre Transfer(_from, _to, _value); succès = vrai ; }
Ce code représente un exemple de transaction commandée, dans laquelle la fonction approuve() est la fonction d'autorisation de l'utilisateur pour demander une transaction commandée. Elle délègue l'autorisation de l'utilisateur à d'autres comptes, écrit la transaction autorisée dans la liste des transactions et déclenche l'événement d'autorisation. ; transferFrom() La fonction est une fonction permettant aux utilisateurs de transférer de l'argent depuis d'autres comptes. Elle détermine d'abord si le solde du compte et l'autorisation sont suffisants, puis met à jour le solde du compte et l'autorisation, écrit la transaction de transfert dans la liste des transactions et déclenche le transfert événement.
3.3.4 Gel des avoirs
function freezeAsset (adresse du compte, statut booléen) public onlyOwner { geléAssets[compte] = statut ; addTransaction("freezeAsset", "FREEZEASSET", tx.origin, compte, uint(status)); émettre FreezeAsset (compte, statut); }
Ce code représente un exemple de gel des actifs, où la fonction freezeAsset() est une fonction permettant à l'administrateur de demander le gel des actifs du compte. Elle détermine d'abord si l'utilisateur est un administrateur, puis met à jour le statut de gel des actifs de l'utilisateur et écrit le gel des actifs. transaction d'actif dans la liste des transactions et déclencher l'événement d'actif gelé.
3.3.5 Retrait d'une transaction
function revokeTransaction(uint index) public onlyOwner { delete transactions[index]; }
Ce code représente un exemple d'annulation d'une transaction, dans lequel la fonction revokeTransaction() est une fonction utilisée par l'administrateur pour demander la révocation d'une transaction. Elle détermine d'abord si l'utilisateur est un administrateur, puis supprime la transaction et déclenche la révocation. événement de transaction.
3.4 Exemples de codes
pragma solidity ^0.4.24;
contract MyToken {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event FreezeAsset(address indexed _account, bool _status);
event VoteCast(address indexed _staker, uint256 _amount);
event Mined(uint256 _reward);
struct User {
uint userId;
string userName;
address userAddress;
}
struct Transaction {
uint transactionId;
address from;
address to;
uint amount;
bytes data;
uint timestamp;
}
struct Asset {
uint assetId;
bytes32 name;
string symbol;
uint totalSupply;
bool isDivisible;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
}
uint constant decimals = 18; // 精度
uint constant multiplier = 10**decimals; // 乘数
uint constant initialSupply = 10000*multiplier; // 初始总供应量
bytes32 constant name = 'MyToken'; // 名称
string constant symbol = 'MTKN'; // 符号
bool divisible = false; // 可否划分
address owner; // 所有者
mapping(address => bool) private blockMined; // 用户是否已经挖矿
mapping(address => bool) private voted; // 用户是否已经投票
mapping(address => bool) private frozenAssets; // 账户资产是否已被冻结
uint currentReward = 0; // 当前奖励
uint totalSupply; // 总供应量
mapping(address => uint) balances; // 持有者余额映射表
mapping(address => mapping(address => uint)) allowances; // 允许的代币映射表
mapping(uint => Transaction) transactions; // 交易列表
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
constructor () public {
owner = msg.sender;
totalSupply = initialSupply;
balances[owner] = totalSupply;
emit Transfer(address(0), owner, totalSupply);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(!frozenAssets[msg.sender], "The sender has been frozen");
require(_value <= balances[msg.sender],"Insufficient balance.");
balances[msg.sender] -= _value;
balances[_to] += _value;
addTransaction("transfer", "TRANSFER", msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value);
success = true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(!frozenAssets[msg.sender], "The sender has been frozen");
require(_value <= balances[_from],"Insufficient balance.");
require(_value <= allowances[_from][msg.sender],"Insufficient allowance.");
balances[_from] -= _value;
balances[_to] += _value;
allowances[_from][msg.sender] -= _value;
addTransaction("transferFrom", "TRANSFERFROM", _from, _to, _value);
emit Transfer(_from, _to, _value);
success = true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowances[msg.sender][_spender] = _value;
addTransaction("approve", "APPROVE", msg.sender, _spender, _value);
emit Approval(msg.sender, _spender, _value);
success = true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowances[_owner][_spender];
}
function freezeAsset(address account, bool status) public onlyOwner {
frozenAssets[account] = status;
addTransaction("freezeAsset", "FREEZEASSET", tx.origin, account, uint(status));
emit FreezeAsset(account, status);
}
function revokeTransaction(uint index) public onlyOwner {
delete transactions[index];
}
function withdrawEther() public onlyOwner {
require(address(this).balance > 0,"No ether left for withdrawal!");
msg.sender.transfer(address(this).balance);
}
function calculateReward() internal returns (uint) {
currentReward = block.number / 1000 + 1; // 挖矿获得的奖励等于区块高度除以1000加1
return currentReward * 1 ether; // 返回奖励金额
}
function isValidProof() internal pure returns (bool result) {
return true; // 为了演示方便，省略了算力校验环节
}
function addTransaction(bytes memory actionType, bytes memory actionName, address from, address to, uint amount) internal {
uint id = block.number - 1; // 每次交易自动分配一个ID
Transaction storage transact = transactions[id];
transact.transactionId = id;
transact.actionType = actionType;
transact.actionName = actionName;
transact.from = from;
transact.to = to;
transact.amount = amount;
transact.data = "";
transact.timestamp = now;
}
function mineBlock() public returns (uint reward) {
require(!blockMined[msg.sender]); // 判断当前用户是否已经挖矿
require(isValidProof()); // 判断算力是否符合要求
blockMined[msg.sender] = true; // 设置该用户已挖矿
currentReward += calculateReward(); // 根据矿工挖出来的量得到奖励
reward = currentReward; // 将奖励返回给用户
addTransaction("mining", "MINING", msg.sender, currentReward); // 添加挖矿交易
currentReward = 0; // 清空当前奖励
emit Mined(currentReward); // 触发挖矿事件
}
function vote() public payable {
// 判断当前账户是否已经投票
require(!voted[msg.sender]);
voted[msg.sender] = true; // 设置该账户已投票
balanceOf[msg.sender] += msg.value; // 给当前账户增加质押金额
totalSupply += msg.value; // 增加总供应
addTransaction("staking", "STAKING", msg.sender, msg.value); // 添加质押交易
emit VoteCast(msg.sender, msg.value); // 触发投票事件
}
}