Wie kann ich überprüfen, ob eine Ethereum-Adresse gültig ist?

Verwenden einer Bibliothek

Bibliotheken wie web3.js und Ether haben isAddress().

Beispiele:

• ethers.utils.isAddress('0x8ba1f109551bd432803012645ac136ddd64dba72');// Stimmt

• web3.utils.isAddress('blah');// FALSCH

Das Folgende ist eine Antwort aus dem Jahr 2016.

Normale Adresse

EIP 55 fügte eine „Großbuchstaben-basierte Prüfsumme“ hinzu , die von Geth bis Mai 2016 implementiert wurde. Hier ist Javascript-Code von Geth:

/**
 * Checks if the given string is an address
 *
 * @method isAddress
 * @param {String} address the given HEX adress
 * @return {Boolean}
*/
var isAddress = function (address) {
    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
        // check if it has the basic requirements of an address
        return false;
    } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
        // If it's all small caps or all all caps, return true
        return true;
    } else {
        // Otherwise check each case
        return isChecksumAddress(address);
    }
};

/**
 * Checks if the given string is a checksummed address
 *
 * @method isChecksumAddress
 * @param {String} address the given HEX adress
 * @return {Boolean}
*/
var isChecksumAddress = function (address) {
    // Check each case
    address = address.replace('0x','');
    var addressHash = sha3(address.toLowerCase());
    for (var i = 0; i < 40; i++ ) {
        // the nth letter should be uppercase if the nth digit of casemap is 1
        if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) || (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) {
            return false;
        }
    }
    return true;
};

ICAP-Adresse

ICAP hat eine Prüfsumme, die verifiziert werden kann. Sie können Geths icap.go überprüfen und hier ist ein Ausschnitt daraus:

// https://en.wikipedia.org/wiki/International_Bank_Account_Number#Validating_the_IBAN
func validCheckSum(s string) error {
    s = join(s[4:], s[:4])
    expanded, err := iso13616Expand(s)
    if err != nil {
        return err
    }
    checkSumNum, _ := new(big.Int).SetString(expanded, 10)
    if checkSumNum.Mod(checkSumNum, Big97).Cmp(Big1) != 0 {
        return ICAPChecksumError
    }
    return nil
}

Es geht jetzt einfacher mit web3:

Naiv:
https://web3js.readthedocs.io/en/v1.2.0/web3-utils.html#isaddress

web3.utils.isAddress('0xc1912fee45d61c87cc5ea59dae31190fffff232d');
> true

ODER
Bessere Version
https://web3js.readthedocs.io/en/v1.2.0/web3-utils.html#tochecksumaddress

try {
  const address = web3.utils.toChecksumAddress(rawInput)
} catch(e) { 
  console.error('invalid ethereum address', e.message) 
}

Die Verwendung der checkSum-Methode ist besser, da Sie immer mit Daten umgehen und niemals Kleinbuchstaben verwenden müssen.

Die standardmäßigen 40-stelligen Hex-Adressen haben jetzt eine Prüfsumme in Form von Großschreibung. Wenn die Adresse mindestens einen Großbuchstaben enthält, wird eine Prüfsumme erstellt, und wenn sie auf einer Website eingegeben wird, die die Summe prüft, wird sie falsch zurückgegeben, wenn es sich nicht um eine gültige Adresse handelt.

Das Schema ist wie folgt:

Konvertieren Sie die Adresse in Hex, aber wenn die i-te Ziffer ein Buchstabe ist (dh es ist eine von abcdef), geben Sie sie in Großbuchstaben aus, wenn das i-te Bit des Hashs der Adresse (in binärer Form) 1 ist, andernfalls in Kleinbuchstaben

Sie können die vollständige Beschreibung von VB hier lesen: https://github.com/ethereum/EIPs/issues/55

function validateInputAddresses(address) {
        return (/^(0x){1}[0-9a-fA-F]{40}$/i.test(address));
}

Das Python-Paket ‚ethereum‘ hat eine Funktion namens ‚check_checksum‘ im utils-Modul:

from ethereum.utils import check_checksum
check_checksum('0xc1912fee45d61c87cc5ea59dae31190fffff232d')
> True

Ich baue dafür ein kleines Projekt, das ich programmatisch in meinen Apps verwende. Es hat eine 'Mikro'-API:

https://balidator.io/api/ethereum/0xea0258D0E745620e77B0A389e3A656EFdb7Cf821

Es hat auch eine Adressvalidierung für Bitcoin, Monero und Ripple.

Die Dokumentation finden Sie hier: balidator.io/api-documentation

Bisher haben Etheradressen keine Prüfsumme und sind einfach die HEX-Kodierung der Adressbytes. Es gibt jedoch einen Vorschlag für Kodierung und Prüfsumme, siehe: ICAP: Inter exchange Client Address Protocol .

ICAP hat vorläufige Unterstützung in einigen Ethereum-Clients integriert.

Prüfsummen sind Mechanismen, um zu verhindern, dass Gelder an falsche Adressen gesendet werden (versehentlich oder von einer böswilligen Partei gesetzt).

Programmatisch

Sie können die web3erstaunlichen Dienstprogramme von verwenden:

web3.utils.toChecksumAddress(Wert)

Die obige Funktion funktioniert nur, wenn Sie Version 1.0.0oder höher haben.

Netz

Ich habe ein Online-Tool erstellt, schau es dir hier an: EthSum .

Eine andere Möglichkeit zu überprüfen ist, ob Sie auch den öffentlichen Schlüssel der Ethereum-Adresse haben. Die offizielle eth-keysPython-Bibliothek der Ethereum Foundation kann verwendet werden und ist jetzt Teil ihres Github-Repos und kann hier eingesehen werden. Sie enthält eine Reihe von Tools, die Möglichkeiten zur Überprüfung der Adressgültigkeit enthalten, z. B. die Verwendung der PublicKey().checksum_address()Methode (siehe Beispiel unten).

Die folgende Methode erfordert den unkomprimierten öffentlichen Schlüssel im Byte-Format, was bedeutet, dass es nur für Konten gelten müsste, für die Sie die Daten des öffentlichen Schlüssels haben:

 >>>from eth_keys import keys
 
 >>>keys.PublicKey(b'\x98\xbb\xfa\xdd\xbc\xc7\xab\x14\xa3\x9c\xb4\x84\xbf\x94MO\xf5\x91^G\xc1\xc2\x0b\xe77t\xc3\xd0\x05\x12|Z\xf5\x17PZ\x97\xe2\\`IR\xc1\xbd\x10\xa3\xa3\xdf\xbf0\xaf;7\xc0z\xbc\xc7\x0b\x9c\xbd<FY\x98').to_checksum_address()
        
        '0x28f4961F8b06F7361A1efD5E700DE717b1db5292'

Oder in Python (mit Web3py )

from web3 import Web3

print(Web3.isAddress("0xBB9923E927F0bC33C901396F4C589B43DB991705"))