headlong

Vertrag ABI und rekursives Präfix für die JVM leicht gemacht.

ABI Spec: https://solidid.readthedocs.io/en/latest/abi-spec.html

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

SHA-256 (Headlong-122.3.3.Jar): 9B577AF538D30FFC05133425C8B0BFF3A79BCBA99955B3222DD2D825B27150CC

Verwendung

ABI -Paket

Codierungsfunktionsaufrufe

 Funktion BAZ = Funktion.Parse ("Baz (uint32, bool)"); // kanonisch und analysiert jede Signatur // Orfunktion f2 = Function.fromjson ("{" Typ ":" Funktion "," Name ":" Foo "," Inputs ": [{" Name ":" Complex_nums "," Typ ":" Tuple [] "," com Ponents ": [{" Name ":" Real "," Typ ":" Fixed168x10 "}, {" Name ":" imaginär "," Typ ":" Fixed168x10 "}]}]}"); Paar <lang, <lang, Boolean> bazargs = tuple.of (69l, true); tuple complexnums = Single.of (neuer Tuple [] {tuple.of (neuer BigDecimal ("0,0090000000"), neuer Bigdecimal ("1,950000000000")}); //// Zwei äquivalente Stile: ByteBuffer Bazcall = baz.encodecall (bazargs); bytebuffer bazcall2 = baz.encodecallwithargs (69l, true); // hexadezimale Codierung (ohne 0x Präfix) Tuple RecrecsEdargs = baz.decodecall (Bazcall2); // Dekodieren Sie die Codierung auf das ursprüngliche argssystem.out.println ("Baz args: n" + RecordErgs + "n"); // toString () system.out.println ("Equal: n" + Recoveredargs.equals (Bazargs) + "n"); // Test für EqualitySystem.out.println ("Baz Call Debug: n" + baz.annotateCall (Bazcall.Array ()) + "n"); // Human-Readable, für Debugging-Funktionsaufrufe (erwartet, dass die Eingabe mit 4-Byte-Selektor) system.out.println ("Baz Args Debug: n" + baz.getInputs (). Annotate (Bazargs) + "N"). ; // Human-Readable, zum Debuggen von Codierungen ohne selektorsystem.out.println ("F2 Call Debug: N" + F2.AnnotateCall (ComplexNums) + "n"); System.out.println ("F2 Args Debug: n" + f2.getInputs (). Annotate (Komplexnums));

Rückgabewerte decodieren

 Funktion foo = function.parse ("foo ((fixe [], int8) [1] [] [5])", "(int, String)"); // Rückgabetyp (int256, String) tuple decoded = foo.decodereturn (fasthex.decode ("00000000000000000000000000000000000000000000000000002A"+ "000000000000000000000000000000000000000000000000000000000040"+ "0000000000000000000000000000000000000000000000000E"++ "59616f62616e6745696768747939000000000000000000000000000000")))))
);

 Funktion footwo = function.parse ("footwo ()", "(uint8)"); int zurückgegeben = footwo.decodesingletonReturn (fasthex.decode ("0000000000000000000000000000000000000000000000000000000000000000FF"))))) // uint8 entspricht intsystem.out.println (zurückgegeben);

Mit Tupletyp

 Tupletyp <tuple> tt = tupletype.parse ("(bool, adresse, int72 [] [] [])"); BigInteger [0] [])); // tuple t = tt.decode (b0); // Dekodieren Sie das Tupel (hat den Nebeneffekt, die Position des ByteBuffer voranzutreiben) // oder ... Adresse a = tt.decode (b0, 1); // Nur index 1System.out.println (a); tuple t2 = tt.decode (B0, 0, 2); // Nur Indizes 0 und 2System.out.println (t2); bytebuffer b1 = tt. // Codieren Sie nur Int72 [] [] []

Miser

 Ereignis <?> Event = event.fromjson ("{" Typ ":" Ereignis "," Name ":" An_Event "," Inputs ": [{" Name ":" A "," Typ ":" Bytes ", "Indexed": True}, {"Name": "B", "Typ": "Uint256", "Indexed": false}], "Anonymous": true} ") args = event.decodeargs (neues byte [] [] {new byte [32]}, neues Byte [32]); System.out.println (Ereignis); System.out.println (args); // Erstellen einer beliebigen Art erstellen Direkt (erweitert) ArrayType <Abitype <Object>,?, Object> at = Victefactory.create ("(Adresse, int) []"); ArrayType <Tupletype <Tuple>, Tuple, Tuple []> at2 = victefactory.create ("(Adresse, int) []"); <adresse, BigInteger >>, Paar <Adresse, BigInteger>, Paar <Adresse, BigInteger> []> AT3 = Victefactory.create ("(Adresse, int) []"); Abitype <Object> unbekannt = victefactory.create (at.getCanonicalType ());

RLP -Paket

 // Beispiel für einen Beispiel -Schüler, der einige Beispiele interfacepublic Student (Byte [] rlp) {Iterator <rlpItem> iter = rlpDecoder.rlp_strict.sequenceIterator (RLP);    this.name = iter.Next (). Asstring (Strings.utf_8); this.gpa = iter.next (). Asfloat (false); this.publickey = iter.next (). AsBytes (); this.balance = new BigDecimal (iter.Next (). AsBigint (), iter.next (). ASINT ());
} @Overridepublic Object [] toobjectArray () {neu ein neues Objekt [] {// Instanzen von Byte [] Strings.decode (Name, Strings.utf_8), FloatingPoint.Tobytes (GPA), PublicKey, Balance.unscaledValue (). TobytearrayrayrayrayrayrayrayRay (). Tobytearrays (), Intageds.tobytes (balance.scale ()) // ein Objekt einschließen [] oder iterable und seine Elemente werden als RLP -Liste (die andere Listen enthalten) codiert};
} @Overridepublic byte [] torlp () {return rlpenCoder.sequence (toobjectArray ());
}

Bauen

Jetzt im Maven Central Repository erhältlich.

Oder lokal bauen:

Klonen Sie das Projekt und installieren Sie in Ihrem lokalen Maven -Repository mit gradle publishToMavenLocal oder mvn install und deklarieren Sie es als Abhängigkeit:

 Implementierung ("com.esaulpaugh: Headlong: 12.3.4-Snapshot")

 <De vorangehen>
    <GruppeId> com.esaulpaugh </Groupid>
    <artifactId> Kopfhörer </artifactid>
    <version> 12.3.4-Snapshot </Version>
</abhängig>

Alternativ:

• Führen Sie gradle build oder gradle jar aus, die ausgibt, um build/libs

• Verwenden Sie mvn package , das zum target ausgibt

• Führen Sie ant all build-jar build/lib

• Fügen Sie als Projektabhängigkeit angezogen

Benchmarks

Graalvm 20.0.2 auf x86-64

Befehlszeilenschnittstelle

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

Beispiel Android App

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

Miser

Enthält auch optimierte Implementierungen von:

• EIP-778 Ethereum-Knotendatensätze

• EIP-55 Mixed-Case-Prüfsummenadresscodierung

• Keccak

• hexadezimal

Anfang ist auf GSON v2.10.1 für das ABI -Paket abhängig. Die Testsuite sollte weniger als eine Minute dauern. Testpakete erfordern jungit. Die Glasgröße beträgt ~ 128 kib. Java 8+.

Weitere Informationen finden Sie im Wiki, wie z.

Lizenziert unter Apache 2.0 Begriffen