headlong

Contrato ABI y el prefijo de longitud recursiva facilitada para el JVM.

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

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

SHA-256 (Headlong-2.3.3.Jar): 9B577AF538D30FFC05133425C8B0BFF3A79BCBA99955B3222DD2D825B27150CCC

Uso

Paquete ABI

Llamadas a la función de codificación

 Función baz = function.parse ("baz (uint32, bool)"); // Canonicalizs y analiza cualquier firma // Orfunction f2 = Function.FromJson ("{" tipo ":" función "," nombre ":" foo "," entradas ": [{" nombre ":" complej_nums "," type ":" tuple [], "com ponientes ": [{" nombre ":" real "," tipo ":" fijo168x10 "}, {" nombre ":" imaginario "," tipo ":" fijo168x10 "}]}]}"); par <largo, Booleano> bazargs = tuple.of (69l, true); tuple complejnums = single.of (new tuple [] {tuple.of (new BigDecimal ("0.0090000000"), new BigDecimal ("1.95000000000000")}); // Dos estilos equivalentes: bytebuffer bazcall = Baz.EncodeCall (Bazargs); bytebuffer bazcall2 = baz.encodeCallwithargs (69l, true); system.out.println ("baz call hex: n" + strings.encode (bazcall) + "n"); // codificación hexadecimal (sin 0x prefijo) Tuple Recoveredargs = baz.DecodeCall (bazcall2); // decodificar la codificación al original argssystem.out.println ("baz args: n" + recuperadogargs + "n"); // toString () system.out.println ("igual: n" + recuperadoRegs.equals (bazargs) + "n"); // Prueba de IgualitySystem.out.println ("Baz Call Debug: N" + Baz.annotateCall (bazcall.array ()) + "n"); // legible por humanos, para las llamadas a la función de depuración (espera que la entrada comience con el selector de 4 byte) System.out.println ("Baz args Debug: N" + baz.getInputs (). Annotate (Bazargs) + "N") ; // legible por humanos, para la depuración de codificaciones sin un selectorsystem.out.println ("F2 Call Debug: N" + F2.annotateCall (ComplexNums) + "n"); System.Println ("F2 args Debug: n" + f2.getInputs (). Annotate (ComplexNums));

Decodificación de valores de retorno

 Function foo = function.Parse ("foo ((fijo [], int8) [1] [] [5])", "(int, string)"); // Decode Tipo de retorno (int256, string) Tuple decoded = foo.Decodereturn (fasthex.decode ("000000000000000000000000000000000000000000000000000000000000002A"+ "00000000000000000000000000000000000000000000000000000000000000000040"+ "000000000000000000000000000000000000000000000000000000000ESE"+ "59616f62616e674569676874793900000000000000000000000000000000000000")
); System.out.println (decoded.equals (tuple.of (bigInteger.ValueOf (42L), "YaObangeighty9")));

 Función footwo = function.parse ("footwo ()", "(uint8)"); int returned = footwo.decodesingletonreturn (fasthex.decode ("0000000000000000000000000000000000000000000000000000000000FF")); // uint8 corresponde a intsystem.out.println (devuelto);

Usando TupleType

 TupleType <Tuple> tt = tupleType.Parse ("(bool, dirección, int72 [] [])"); byteBuffer b0 = tt.encode (tuple.of (false, dirección.wrap ("0x52908400098527886e0f7030069857d2e4169ee7"), neto BigInteger [0] [])); // tuple t = tt.decode (b0); // decodificar la tupla (tiene el efecto secundario de avanzar en la posición del bytebuffer) // o ... dirección a = tt.decode (b0, 1); // Decode solo índice 1System.out.println (a); tuple t2 = tt.decode (b0, 0, 2); // indicados solo de decodificación 0 y 2system.out.println (t2); bytebuffer b1 = tt. <abitype <bigInteger [] [] >> get (2) .Encode (nuevo biginteger [] [] {}); // codificar solo int72 [] []

Maga

 Event <?> Event = Event.FromJson ("{" Tipo ":" Event "," Nombre ":" An_event "," Entradas ": [{" Nombre ":" A "," Tipo ":" Bytes ", "indexado": true}, {"nombre": "b", "tipo": "uint256", "indexado": falso}], "anónimo": true} "); Tuple args = event.decodeargs (new byte [] [] {new Byte [32]}, new Byte [32]); System.out.println (event); System.out.println (args); // Crear cualquier tipo directamente (avanzado) ArrayType <Abitype <pectus>,?, Object> at = TypeFactory.Create ("(Dirección, int) []"); ArrayType <TupleType <Tuple>, Tuple, Tuple []> AT2 = TypeFactory.Create ("(dirección, int) []"); ArrayType <TupleType <Par de <Dirección, biginteger >>, par <dirección, biginteger>, par <dirección, biginteger> []> at3 = TypeFactory.Create ("(Dirección, int) []"); AbityPe <ject> desconocido = typefactory.create (at.getCanonicalType ());

Paquete RLP

 // Para un estudiante de clase de ejemplo que implementa algunos ejemplos de estudiante interfacePublic (byte [] rlp) {iterator <rlpitem> iter = rlpdecoder.rlp_strict.sequenceIterator (rlp);    this.name = iter.next (). astring (strings.utf_8); this.gpa = iter.next (). asfloat (falso); this.publickey = iter.next (). asbytes (); this.balance = new BigDecimal (iter.next (). asBigint (), iter.next (). asint ());
} @OverridePublic Object [] toObyCegetArray () {return nuevo objeto [] {// instancias de byte [] strings.Decode (nombre, strings.utf_8), flotingpoint.tobytes (GPA), publickey, balance.unscaledValue (). (), Integers.tobytes (balance.scale ()) // incluye un objeto [] o ITerable y sus elementos se codificarán como una lista RLP (que puede incluir otras listas)};
} @OverridePublic byte [] torlp () {return rlpencoder.Sequence (toObjectArray ());
}

Construir

Ahora disponible en el repositorio central de Maven.

O construir localmente:

Clone el proyecto e instale en su repositorio de Maven local utilizando gradle publishToMavenLocal o mvn install , luego declara como una dependencia:

 Implementación ("com.esaulpaugh: encabezado: 12.3.4-snapshot")

 <pendencia>
    <MoupRoD> com.esaulpaugh </groupid>
    <ArFactId> Headlong </artifactId>
    <Versión> 12.3.4-Snapshot </versión>
</pendency>

Alternativamente:

• Ejecute gradle build o gradle jar que salga a build/libs

• Use mvn package que sale a target

• Ejecutar ant all build-jar que sale a build/lib

• Agregue la cabeza como dependencia del proyecto

Puntos de referencia

Graalvm 20.0.2 en x86-64

Interfaz de línea de comando

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

Ejemplo de la aplicación Android

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

Maga

También incluye implementaciones optimizadas de:

• EIP-778 Registros de nodo Ethereum

• EIP-55 Codificación de la dirección de la suma de verificación

• Kecca

• hexadecimal

La cabeza depende de GSON V2.10.1 para el paquete ABI. La suite de prueba debe tardar menos de un minuto en correr. Los paquetes de prueba requieren Junit. El tamaño del frasco es ~ 128 kib. Java 8+.

Vea el wiki para obtener más información, como codificación empaquetada (y decodificación) y notación del objeto RLP: https://github.com/esaulpaugh/headlong/wiki

Licenciado bajo los términos de Apache 2.0