a
a
Weather:
city not found
HomeBitcoingo-ethereum / accounts.go sur master ethereum / go-ethereum GitHub

go-ethereum / accounts.go sur master ethereum / go-ethereum GitHub

// Copyright 2017 Les auteurs de go-ethereum // Ce fichier fait partie de la bibliothèque go-ethereum. // // La bibliothèque go-ethereum est un logiciel libre: vous pouvez la redistribuer et / ou la modifier // fr sous les termes de la GNU Lesser General Public License telle que publiée par // la Free Software Foundation, version 3 de la licence, ou // (votre choix) toute version ultérieure. // // La bibliothèque go-ethereum est distribuée dans l’espoir qu’elle sera utile, // mais SANS AUCUNE GARANTIE; sans même la garantie implicite de // QUALITÉ MARCHANDE ou ADAPTATION À UN USAGE PARTICULIER. Voir le // Licence publique générale moindre GNU pour plus de détails. // // Vous devriez avoir reçu une copie de la licence publique générale limitée GNU // avec la bibliothèque go-ethereum. Sinon, voir . // Les packages de compte implémentent la gestion des comptes Ethereum de haut niveau. paquet comptes importer ( « fmt » « maths / gros » « github.com/ethereum/go-ethereum » « github.com/ethereum/go-ethereum/common » « github.com/ethereum/go-ethereum/core/types » « github.com/ethereum/go-ethereum/event » « golang.org/x/crypto/sha3 » ) // Le compte représente un compte Ethereum situé dans un emplacement défini spécifique // à partir du champ URL facultatif. gentil Compte struct { Adresse Commun.Adresse « json: » adresse «  » // Adresse du compte Ethereum dérivée de la clé URL URL « json: » url « ` // Localisateur de ressources facultatif dans un backend } const ( MimetypeDataWithValidator = « données / validateur » MimetypeTypedData = « données / saisies » MimetypeClique = « application / x-clique-header » MimetypeTextPlain = « texte / simple » ) // Wallet représente un portefeuille logiciel ou matériel pouvant contenir un ou plusieurs // comptes (dérivés de la même graine). gentil Portefeuille interface { // URL récupère le chemin canonique sous lequel ce portefeuille est accessible. EST // utilisateur des couches supérieures pour définir un ordre de tri sur tous les portefeuilles à partir de plusieurs // backend. URL() URL // Statut renvoie un statut textuel pour aider l’utilisateur dans l’état actuel de // portefeuille. Il renvoie également une erreur indiquant les erreurs que le portefeuille pourrait avoir // rencontré. L’état() (corde, erreur) // Open initialise l’accès à une instance de portefeuille. Il n’est pas non plus destiné à déverrouiller // décrypter les clés de compte, plutôt simplement pour établir une connexion au matériel // portefeuille et / ou pour accéder aux graines de dérivation. // // Le paramètre de phrase de passe peut ou non être utilisé par une implémentation de fichier // instance particulière du portefeuille. La raison pour laquelle il n’y a pas de méthode ouverte sans mot de passe // est de tendre vers une gestion uniforme du portefeuille, ignorant les différents // fournisseurs de backend. // // Notez que si vous ouvrez un portefeuille, vous devez le fermer pour libérer les // ressources (particulièrement importantes lorsque vous travaillez avec des portefeuilles matériels). Ouvert(phrase secrète corde) erreur // Close libère toutes les ressources détenues par une instance de portefeuille ouverte. Voisin() erreur // Comptes récupère la liste des comptes signés dont le portefeuille a actuellement connaissance // sur. Pour les portefeuilles déterministes hiérarchiques, la liste ne sera pas exhaustive, // il ne contient plutôt que les comptes qui sont explicitement bloqués lors de la dérivation du compte. Comptes() []Compte // Contient des retours indépendamment du fait qu’un compte fasse ou non partie de ce portefeuille particulier. Contient(Compte Compte) booléen // Derive essaie de dériver explicitement un compte déterministe hiérarchique dans // le chemin de dérivation spécifié. Si nécessaire, le compte dérivé sera ajouté // à la liste des comptes suivis par portefeuille. Dériver(sentier DerivationPath, épingle booléen) (Compte, erreur) // SelfDerive définit un chemin de dérivation de compte de base à partir duquel le portefeuille tente // pour découvrir les comptes non nuls et les ajouter automatiquement à la liste des pistes // Compte. // // Remarque, la dérivation automatique incrémentera le dernier composant du chemin spécifié // en face de passer dans un chemin enfant pour permettre à la découverte de compte de démarrer // à partir de composants non nuls. // // Certains portefeuilles matériels ont changé leurs chemins de dérivation au cours de leur évolution, donc // cette méthode prend en charge la fourniture de plusieurs bases pour détecter les anciens comptes d’utilisateurs // purée. Seule la dernière base sera utilisée pour dériver le prochain compte vide. // // Vous pouvez désactiver la détection automatique des comptes en appelant SelfDerive avec zéro // lecteur d’état de la chaîne. SelfDerive(les bases []DerivationPath, chaîne ethereum.ChainStateReader) // SignData nécessite que le portefeuille signe le hachage des données fournies // Recherche le compte spécifié exclusivement par son adresse contenue dans, // ou éventuellement à l’aide de n’importe quelle métadonnée d’emplacement du champ URL intégré. // // Si le portefeuille nécessite une authentification supplémentaire pour signer la demande (ex // un mot de passe pour décrypter le compte ou un code PIN pour vérifier la transaction), // une instance AuthNeededError sera retournée, contenant des informations pour l’utilisateur // sur quels champs ou actions sont nécessaires. L’utilisateur peut réessayer en fournissant // les détails nécessaires via SignDataWithPassphrase ou par d’autres moyens (par exemple // le compte dans un keystore). SignData(Compte Compte, mimeType corde, Les données []octet) ([]octet, erreur) // SignDataWithPassphrase est identique à SignData, mais accepte également un mot de passe // NOTE: il y a une possibilité qu’un mauvais appel puisse permuter les deux chaînes, et // fournissez le mot de passe dans le champ MIME, ou vice versa. Donc, une implémentation // ne doit jamais faire écho au type MIME ou renvoyer le type MIME dans la réponse d’erreur SignDataWithPassphrase(Compte Compte, phrase secrète, mimeType corde, Les données []octet) ([]octet, erreur) // SignText nécessite que le portefeuille signe le hachage d’une donnée prédéterminée donnée // du schéma de préfixe Ethereum // Recherche le compte spécifié exclusivement par son adresse contenue dans, // ou éventuellement à l’aide de n’importe quelle métadonnée d’emplacement du champ URL intégré. // // Si le portefeuille nécessite une authentification supplémentaire pour signer la demande (ex // un mot de passe pour décrypter le compte ou un code PIN pour vérifier la transaction), // une instance AuthNeededError sera retournée, contenant des informations pour l’utilisateur // sur quels champs ou actions sont nécessaires. L’utilisateur peut réessayer en fournissant // les détails nécessaires via SignHashWithPassphrase ou d’autres moyens (par exemple // le compte dans un keystore). // // Cette méthode doit renvoyer la signature au format « canonique », avec v 0 ou 1 SignText(Compte Compte, texte []octet) ([]octet, erreur) // SignTextWithPassphrase est identique à Signtext, mais accepte également un mot de passe SignTextWithPassphrase(Compte Compte, phrase secrète corde, hacher []octet) ([]octet, erreur) // SignTx nécessite que le portefeuille signe la transaction donnée. // // Recherche le compte spécifié exclusivement par son adresse contenue dans, // ou éventuellement à l’aide de n’importe quelle métadonnée d’emplacement du champ URL intégré. // // Si le portefeuille nécessite une authentification supplémentaire pour signer la demande (ex // un mot de passe pour décrypter le compte ou un code PIN pour vérifier la transaction), // une instance AuthNeededError sera retournée, contenant des informations pour l’utilisateur // sur quels champs ou actions sont nécessaires. L’utilisateur peut réessayer en fournissant // les détails nécessaires via SignTxWithPassphrase ou par d’autres moyens (par ex. // le compte dans un keystore). SignTx(Compte Compte, tx *les types.Transaction, chainID *génial.Int) (*les types.Transaction, erreur) // SignTxWithPassphrase est identique à SignTx, mais accepte également un mot de passe SignTxWithPassphrase(Compte Compte, phrase secrète corde, tx *les types.Transaction, chainID *génial.Int) (*les types.Transaction, erreur) } // Backend est un « fournisseur de portefeuille » qui peut contenir un groupe de comptes pouvant // signez les transactions avec et sur demande, faites-le. gentil Backend interface { // Wallets récupère la liste des portefeuilles dont le backend a actuellement connaissance. // // Les portefeuilles retournés ne sont pas ouverts par défaut. Pour les portefeuilles de logiciels HD, // signifie qu’aucune graine de base n’est déchiffrée et pour les portefeuilles matériels qui ne sont pas efficaces // la connexion est établie. // // La liste résultante des portefeuilles sera triée par ordre alphabétique en fonction de celle-ci // URL attribuée par le backend. Étant donné que les portefeuilles (en particulier le matériel) peuvent venir et // allez, le même portefeuille peut apparaître à différentes positions dans la liste pendant // récupérations ultérieures. Portefeuilles() []Portefeuille // S’abonner crée un abonnement asynchrone pour recevoir des notifications lorsque le // backend détecte l’arrivée ou le départ d’un portefeuille. souscrire(Évier chan<- WalletEvent) un événement.Abonnement } // TextHash est une fonction d’assistance qui calcule un hachage pour le message donné qu’il peut être // utilisé en toute sécurité pour calculer une signature à partir de. // // Le hachage est calculé comme // keccak256 ( » x19Ethereum Signed Message: n » $ {longueur du message} $ {message}). // // Cela fournit un contexte au message signé et empêche la signature de la transaction. func TextHash(Les données []octet) []octet { hacher, _ : = TextAndHash(Les données) revenir hacher } // TextAndHash est une fonction d’assistance qui calcule un hachage pour le message donné qui peut être // utilisé en toute sécurité pour calculer une signature à partir de. // // Le hachage est calculé comme // keccak256 ( » x19Ethereum Signed Message: n » $ {longueur du message} $ {message}). // // Cela fournit un contexte au message signé et empêche la signature de la transaction. func TextAndHash(Les données []octet) ([]octet, corde) { msg : = fmt.Sprintf(«  x19Message signé par Ethereum: n% d% s « , len(Les données), corde(Les données)) hasher : = sha3.NouveauLegacyKeccak256() hasher.écrire([]octet(msg)) revenir hasher.Somme(zéro), msg } // WalletEventType représente les différents types d’événements qui peuvent être déclenchés // le sous-système de souscription du portefeuille. gentil WalletEventType int const ( // WalletArrived est déclenché lorsqu’un nouveau portefeuille est détecté via USB ou via // un événement du système de fichiers dans le keystore. WalletArrivé WalletEventType = iota // WalletOpened est déclenché lorsqu’un portefeuille est ouvert avec succès dans le but // démarrage des processus d’arrière-plan tels que la dérivation automatique de clé. PortefeuilleOuvert // WalletDropped WalletDropped ) // WalletEvent est un événement déclenché par le backend d’un compte lorsqu’un portefeuille ou // le départ est détecté. gentil WalletEvent struct { Portefeuille Portefeuille // L’instance Wallet est arrivée ou est partie Gentil WalletEventType // Type d’événement survenu sur le système }

https://github.com/ethereum/go-ethereum/blob/master/accounts/accounts.go

No comments

leave a comment