Package com.kryptokrauts.sophia.compiler.generated.api.rxjava

Class DefaultApi

java.lang.Object
com.kryptokrauts.sophia.compiler.generated.api.rxjava.DefaultApi
@Generated(value="org.openapitools.codegen.languages.JavaClientCodegen",
           date="2022-01-10T23:40:13.294772960Z[Etc/UTC]")
public class DefaultApi
extends java.lang.Object

  • Constructor Details

    • DefaultApi

      public DefaultApi​(DefaultApi delegate)

  • Method Details

    • getDelegate

      public DefaultApi getDelegate()

    • aPIVersion

      public void aPIVersion​(io.vertx.core.Handler<io.vertx.core.AsyncResult<APIVersion>> resultHandler)
      Get the version of the API
      Parameters:
      resultHandler - Asynchronous result handler

    • rxAPIVersion

      public io.reactivex.Single<APIVersion> rxAPIVersion()
      Get the version of the API
      Returns:
      Asynchronous result handler (RxJava Single)

    • api

      public void api​(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Object>> resultHandler)
      Get the Api description
      Parameters:
      resultHandler - Asynchronous result handler

    • rxApi

      public io.reactivex.Single<java.lang.Object> rxApi()
      Get the Api description
      Returns:
      Asynchronous result handler (RxJava Single)

    • compileContract

      public void compileContract​(Contract body, io.vertx.core.Handler<io.vertx.core.AsyncResult<ByteCode>> resultHandler)
      Compile a sophia contract from source and return byte code
      Parameters:
      body - contract code (required)
      resultHandler - Asynchronous result handler

    • rxCompileContract

      public io.reactivex.Single<ByteCode> rxCompileContract​(Contract body)
      Compile a sophia contract from source and return byte code
      Parameters:
      body - contract code (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • decodeCallResult

      public void decodeCallResult​(SophiaCallResultInput body, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Object>> resultHandler)
      Decode the result of contract call
      Parameters:
      body - Binary data in Sophia ABI format (required)
      resultHandler - Asynchronous result handler

    • rxDecodeCallResult

      public io.reactivex.Single<java.lang.Object> rxDecodeCallResult​(SophiaCallResultInput body)
      Decode the result of contract call
      Parameters:
      body - Binary data in Sophia ABI format (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • decodeCallResultBytecode

      public void decodeCallResultBytecode​(BytecodeCallResultInput body, io.vertx.core.Handler<io.vertx.core.AsyncResult<DecodedCallresult>> resultHandler)
      Decode the result of contract call from Bytecode
      Parameters:
      body - Call result + compiled contract (required)
      resultHandler - Asynchronous result handler

    • rxDecodeCallResultBytecode

      public io.reactivex.Single<DecodedCallresult> rxDecodeCallResultBytecode​(BytecodeCallResultInput body)
      Decode the result of contract call from Bytecode
      Parameters:
      body - Call result + compiled contract (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • decodeCalldataBytecode

      public void decodeCalldataBytecode​(DecodeCalldataBytecode body, io.vertx.core.Handler<io.vertx.core.AsyncResult<DecodedCalldata>> resultHandler)
      Identify function name and arguments in Calldata for a compiled contract
      Parameters:
      body - Calldata + compiled contract (required)
      resultHandler - Asynchronous result handler

    • rxDecodeCalldataBytecode

      public io.reactivex.Single<DecodedCalldata> rxDecodeCalldataBytecode​(DecodeCalldataBytecode body)
      Identify function name and arguments in Calldata for a compiled contract
      Parameters:
      body - Calldata + compiled contract (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • decodeCalldataSource

      public void decodeCalldataSource​(DecodeCalldataSource body, io.vertx.core.Handler<io.vertx.core.AsyncResult<DecodedCalldata>> resultHandler)
      Identify function name and arguments in Calldata for a (partial) contract
      Parameters:
      body - Calldata + contract (stub) code (required)
      resultHandler - Asynchronous result handler

    • rxDecodeCalldataSource

      public io.reactivex.Single<DecodedCalldata> rxDecodeCalldataSource​(DecodeCalldataSource body)
      Identify function name and arguments in Calldata for a (partial) contract
      Parameters:
      body - Calldata + contract (stub) code (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • decodeData

      public void decodeData​(SophiaBinaryData body, io.vertx.core.Handler<io.vertx.core.AsyncResult<SophiaJsonData>> resultHandler)
      Decode data as retuned by a contract call. - Legacy decoding
      Parameters:
      body - Binary data in Sophia ABI format (required)
      resultHandler - Asynchronous result handler

    • rxDecodeData

      public io.reactivex.Single<SophiaJsonData> rxDecodeData​(SophiaBinaryData body)
      Decode data as retuned by a contract call. - Legacy decoding
      Parameters:
      body - Binary data in Sophia ABI format (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • encodeCalldata

      public void encodeCalldata​(FunctionCallInput body, io.vertx.core.Handler<io.vertx.core.AsyncResult<Calldata>> resultHandler)
      Encode Sophia function call according to sophia ABI.
      Parameters:
      body - Sophia function call - contract code + function name + arguments (required)
      resultHandler - Asynchronous result handler

    • rxEncodeCalldata

      public io.reactivex.Single<Calldata> rxEncodeCalldata​(FunctionCallInput body)
      Encode Sophia function call according to sophia ABI.
      Parameters:
      body - Sophia function call - contract code + function name + arguments (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • generateACI

      public void generateACI​(Contract body, io.vertx.core.Handler<io.vertx.core.AsyncResult<ACI>> resultHandler)
      Generate an Aeternity Contract Interface (ACI) for contract
      Parameters:
      body - contract code (required)
      resultHandler - Asynchronous result handler

    • rxGenerateACI

      public io.reactivex.Single<ACI> rxGenerateACI​(Contract body)
      Generate an Aeternity Contract Interface (ACI) for contract
      Parameters:
      body - contract code (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • getCompilerVersion

      public void getCompilerVersion​(ByteCodeInput body, io.vertx.core.Handler<io.vertx.core.AsyncResult<CompilerVersion>> resultHandler)
      Extract compiler version from bytecode
      Parameters:
      body - contract byte array (required)
      resultHandler - Asynchronous result handler

    • rxGetCompilerVersion

      public io.reactivex.Single<CompilerVersion> rxGetCompilerVersion​(ByteCodeInput body)
      Extract compiler version from bytecode
      Parameters:
      body - contract byte array (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • getFateAssemblerCode

      public void getFateAssemblerCode​(ByteCodeInput body, io.vertx.core.Handler<io.vertx.core.AsyncResult<FateAssembler>> resultHandler)
      Get FATE assembler code from bytecode
      Parameters:
      body - contract byte array (required)
      resultHandler - Asynchronous result handler

    • rxGetFateAssemblerCode

      public io.reactivex.Single<FateAssembler> rxGetFateAssemblerCode​(ByteCodeInput body)
      Get FATE assembler code from bytecode
      Parameters:
      body - contract byte array (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • validateByteCode

      public void validateByteCode​(ValidateByteCodeInput body, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>> resultHandler)
      Verify that an encoded byte array is the result of compiling a given contract
      Parameters:
      body - contract byte array and source code (required)
      resultHandler - Asynchronous result handler

    • rxValidateByteCode

      public io.reactivex.Single<java.lang.Void> rxValidateByteCode​(ValidateByteCodeInput body)
      Verify that an encoded byte array is the result of compiling a given contract
      Parameters:
      body - contract byte array and source code (required)
      Returns:
      Asynchronous result handler (RxJava Single)

    • version

      public void version​(io.vertx.core.Handler<io.vertx.core.AsyncResult<CompilerVersion>> resultHandler)
      Get the version of the underlying Sophia compiler version
      Parameters:
      resultHandler - Asynchronous result handler

    • rxVersion

      public io.reactivex.Single<CompilerVersion> rxVersion()
      Get the version of the underlying Sophia compiler version
      Returns:
      Asynchronous result handler (RxJava Single)

    • newInstance

      public static DefaultApi newInstance​(DefaultApi arg)