headlong

Le contrat ABI et le préfixe de longueur récursif ont facilité la JVM.

ABI Spec: https://solidity.readthedocs.io/en/latest/abi-spe.html

RLP Spec: https://ethereum.org/en/developers/docs/data-structures-and-coding/rlp

SHA-256 (Headlong-13.3.3

Usage

Paquet ABI

Codage des appels de fonction

 Function baz = function.parse ("baz (uint32, bool)"); // canonicalise et analyse toute signature // orfonction f2 = Function.fromjson ("{" type ":" fonction "," name ":" foo "," entrées ": [{" name ":" complex_nums "," type ":" tuple [] "," com ponents ": [{" name ":" réel "," type ":" fixe168x10 "}, {" name ":" imaginaire "," type ":" fixe168x10 "}]}]}"); paire <long, Boolean> bazargs = tuple.of (69l, true); tuple complexnums = single.of (new tuple [] {tuple.of (new BigDecimal ("0,0090000000"), new BigDecimal ("1.9500000000"))}); // Deux styles équivalents: ByteBuffer Bazcall = baz.encodecall (bazargs); bytebuffer bazcall2 = baz.encodecallwithargs (69l, true); System.out.println ("baz appelez hex: n" + strings.encode (bazcall) + "n"); // codage hexadécimal (sans préfixe 0x) Tuple Recomedargs = baz.decodecall (bazcall2); // décodait l'encodage à l'argssystem.out.out.println d'origine ("baz args: n" + rétablirgs + "n"); // toString () System.out.println ("égal: n" + rétabli.equals (bazargs) + "n"); // Tester pour EqualitySystem.out.println ("BAZ Call Debug: N" + BAZ.AnnotateCall (Bazcall.array ()) + "N"); // lisible par l'homme, pour les appels de fonction de débogage (s'attend à ce que l'entrée commence par le sélecteur de 4 octets) System.out.println ("Baz Args Debug: n" + baz.getInputs (). Annotate (bazargs) + "n") ; // lisible par l'homme, pour les encodages de débogage sans sélecteursystem.out.println ("f2 Call Debug: n" + f2.annotatecall (complexnums) + "n"); System.out.println ("f2 args debug: n" + f2.getInputs (). Annotate (complexnums));

Décodage des valeurs de retour

 Function foo = function.parse ("foo ((fixe [], int8) [1] [] [5])", "(int, string)"); // Decode return type (int256, string) tuple décodé = foo.decodereturn (fasthex.decode ("000000000000000000000000000000000000000000000000000000000000002A" + "00000000000000000000000000000000000000000000000000000000000000000040" + "00000000000000000000000000000000000000000000000000000000000E" + "59616F62616E67456967687479390000000000000000000000000000000000")
); System.out.println (Decoded.equals (tuple.of (bigInteger.Valueof (42L), "YaObangeighty9")));

 Fonction Footwo = function.Parse ("Footwo ()", "(uint8)"); int retourné = Footwo.decodesingletOnreturn (fasthex.decode ("0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ff")); // uint8 correspond à IntSystem.out.println (retourné);

Utilisation de tupletype

 Tupletype <tuple> tt = tupletype.parse ("(bool, adresse, int72 [] [])"); bytebuffer b0 = tt.encode (tuple.of (false, adresse.wrap ("0x52908400098527886e0f7030069857D2E4169EE7"),, new) BigInteger [0] [])); // Tuple t = tt.decode (b0); // décode le tuple (a l'effet secondaire de faire avancer la position de l'octette) // ou ... l'adresse a = tt.decode (b0, 1); // Decode uniquement index 1System.out.println (a); tuple t2 = tt.decode (b0, 0, 2); // Décode uniquement les indices 0 et 2System.out.println (t2); byteBuffer b1 = tt. <abitype <bigInteger [] [] >> get (2) .encode (new BigInteger [] [] {}); // Encode uniquement int72 [] []

Mission

 Event <?> Event = event.fromjson ("{" type ":" event "," name ":" an_event "," entrées ": [{" name ":" a "," type ":" octets ", "indexé": true}, {"name": "b", "type": "uint256", "indexé": false}], "anonymous": true} "); tuple args = event.decodeargs (new octet [] [] {new octet [32]}, nouveau octet [32]); System.out.println (événement); System.out.println (args); // créer n'importe quel type directement (avancé) ArrayType <abitype <objet> ,?, objet> at = Typefactory.create ("(adresse, int) []"); arraytype <tupletype <tuple>, tuple, tuple []> at2 = typefactory.create ("(adresse, int) []"); arraytype <tupletype <paire <Adresse, bigInteger >>, paire <adresse, bigInteger>, paire <adresse, bigInteger> []> at3 = Typefactory.create ("(adresse, int) []"); abitype <objet> inconnu = typefactory.create (at.getCanonicalType ());

Package RLP

 // Pour un exemple de classe, mettant en œuvre un exemple d'étudiant interfacePublic (byte [] rlp) {iterator <rlpitem> iter = rlpdecoder.rlp_strict.senceiterator (rlp);    this.name = iter.next (). asstring (Strings.Utf_8); this.gpa = iter.next (). asfloat (false); this.publickey = iter.next (). Asbytes (); this.balance = Nouveau BigDecimal (iter.Next (). Asbigint (), iter.Next (). ASInt ());
} @OverRidePublic Object [] toObjectArray () {return nouvel objet [] {// Instances de byte [] strings.decode (name, strings.utf_8), floatingpoint.toBytes (gpa), publicKey, bancal.unscaledValue (). (), Entiers.tobytes (Balance.Scale ()) // Inclure un Objet [] ou itérable et ses éléments seront codés sous forme de liste RLP (qui peut inclure d'autres listes)};
} @OverridePublic Byte [] torlp () {return rlPencoder.Sequence (toObjectArray ());
}

Construire

Maintenant disponible dans le référentiel Maven Central.

Ou construire localement:

Clone le projet et installez-vous sur votre référentiel Maven local à l'aide gradle publishToMavenLocal ou mvn install , puis déclarez-le comme une dépendance:

 Implémentation ("com.esaulpaugh: tête baignante: 12.3.4-snapshot")

 <dépendance>
    <GroupId> com.esaulpaugh </rom grouped>
    <ArtefactId> tête baissée </titefactive>
    <version> 12.3.4-snapshot </DERNIER>
</Dependance>

Alternativement:

• Exécutez gradle build ou gradle jar qui sortira à build/libs

• Utilisez mvn package qui s'approche pour target

• Exécutez ant all build-jar qui sortent pour build/lib

• Ajouter la tête baissée comme dépendance au projet

Repères

Graalvm 20.0.2 sur x86-64

Interface de ligne de commande

https://github.com/esaulpaugh/headlong-cli

Exemple d'application Android

https://github.com/esaulpaugh/headlong-android

Mission

Comprend également des implémentations optimisées de:

• EIP-778 Records de nœuds Ethereum

• Encodage d'adresses de somme de contrôle de la somme de cas mixtes EIP-55

• Keccak

• hexadécimal

Headlong dépend de GSON V2.10.1 pour le package ABI. La suite de test doit prendre moins d'une minute pour courir. Les packages de test nécessitent JUnit. La taille du pot est de ~ 128 kib. Java 8+.

Voir le wiki pour plus, comme le codage (et le décodage) et la notation d'objet RLP: https://github.com/esaulpaugh/headlong/wiki

Sous licence des termes Apache 2.0