org.web3j.utils.Async Java Examples

@Test
@SuppressWarnings("unchecked")
public void testInvalidTransactionReceipt() throws Throwable {
    prepareNonceRequest();
    prepareTransactionRequest();

    EthGetTransactionReceipt ethGetTransactionReceipt = new EthGetTransactionReceipt();
    ethGetTransactionReceipt.setError(new Response.Error(1, "Invalid transaction receipt"));

    Request<?, EthGetTransactionReceipt> getTransactionReceiptRequest = mock(Request.class);
    when(getTransactionReceiptRequest.sendAsync())
            .thenReturn(Async.run(() -> ethGetTransactionReceipt));
    when(web3j.ethGetTransactionReceipt(TRANSACTION_HASH))
            .thenReturn((Request) getTransactionReceiptRequest);
    assertThrows(RuntimeException.class, this::testErrorScenario);
}
 

@Test(expected = RuntimeException.class)
@SuppressWarnings("unchecked")
public void testInvalidTransactionReceipt() throws Throwable {
    prepareNonceRequest();
    prepareTransactionRequest();

    EthGetTransactionReceipt ethGetTransactionReceipt = new EthGetTransactionReceipt();
    ethGetTransactionReceipt.setError(new Response.Error(1, "Invalid transaction receipt"));

    Request<?, EthGetTransactionReceipt> getTransactionReceiptRequest = mock(Request.class);
    when(getTransactionReceiptRequest.sendAsync())
            .thenReturn(Async.run(() -> ethGetTransactionReceipt));
    when(web3j.ethGetTransactionReceipt(TRANSACTION_HASH))
            .thenReturn((Request) getTransactionReceiptRequest);

    testErrorScenario();
}
 

@Test(expected = RuntimeException.class)
@SuppressWarnings("unchecked")
public void testInvalidTransactionReceipt() throws Throwable {
    prepareNonceRequest();
    prepareTransactionRequest();

    PlatonGetTransactionReceipt ethGetTransactionReceipt = new PlatonGetTransactionReceipt();
    ethGetTransactionReceipt.setError(new Response.Error(1, "Invalid transaction receipt"));

    Request<?, PlatonGetTransactionReceipt> getTransactionReceiptRequest = mock(Request.class);
    when(getTransactionReceiptRequest.sendAsync())
            .thenReturn(Async.run(() -> ethGetTransactionReceipt));
    when(web3j.platonGetTransactionReceipt(TRANSACTION_HASH))
            .thenReturn((Request) getTransactionReceiptRequest);

    testErrorScenario();
}
 

@Override
public void start() {
  LOG.info("Starting Besu Docker container: {}", besuContainerId);
  docker.startContainerCmd(besuContainerId).exec();

  LOG.info("Querying for the Docker dynamically allocated RPC port numbers");
  final InspectContainerResponse containerResponse =
      docker.inspectContainerCmd(besuContainerId).exec();
  final Ports ports = containerResponse.getNetworkSettings().getPorts();
  final int httpRpcPort = httpRpcPort(ports);
  final int wsRpcPort = wsRpcPort(ports);
  LOG.info("Http RPC port: {}, Web Socket RPC port: {}", httpRpcPort, wsRpcPort);

  final String httpRpcUrl = url(httpRpcPort);
  LOG.info("Besu Web3j service targeting: {} ", httpRpcUrl);

  final HttpService web3jHttpService = new HttpService(httpRpcUrl);
  this.jsonRpc =
      new JsonRpc2_0Web3j(web3jHttpService, pollingInterval, Async.defaultExecutorService());
  final RawJsonRpcRequestFactory requestFactory = new RawJsonRpcRequestFactory(web3jHttpService);
  final JsonRpc2_0Besu besuJsonRpc = new JsonRpc2_0Besu(web3jHttpService);
  final Eth eth = new Eth(jsonRpc);
  final Besu besu = new Besu(besuJsonRpc);
  final Eea eea = new Eea(requestFactory);
  this.accounts = new Accounts(eth);
  this.publicContracts = new PublicContracts(eth);
  this.privateContracts = new PrivateContracts(besu, eea);
  this.transactions = new Transactions(eth);
  this.ports = new NodePorts(httpRpcPort, wsRpcPort);
}
 

@Test
@SuppressWarnings("unchecked")
public void testInvalidTransactionResponse() throws IOException {
    prepareNonceRequest();

    EthSendTransaction ethSendTransaction = new EthSendTransaction();
    ethSendTransaction.setError(new Response.Error(1, "Invalid transaction"));

    Request<?, EthSendTransaction> rawTransactionRequest = mock(Request.class);
    when(rawTransactionRequest.sendAsync()).thenReturn(Async.run(() -> ethSendTransaction));
    when(web3j.ethSendRawTransaction(any(String.class)))
            .thenReturn((Request) rawTransactionRequest);
    assertThrows(RuntimeException.class, this::testErrorScenario);
}
 

public QueuingTransactionReceiptProcessor(
        Web3j web3j, Callback callback, int pollingAttemptsPerTxHash, long pollingFrequency) {
    super(web3j);
    this.scheduledExecutorService = Async.defaultExecutorService();
    this.callback = callback;
    this.pendingTransactions = new LinkedBlockingQueue<>();
    this.pollingAttemptsPerTxHash = pollingAttemptsPerTxHash;

    scheduledExecutorService.scheduleAtFixedRate(
            this::sendTransactionReceiptRequests,
            pollingFrequency,
            pollingFrequency,
            TimeUnit.MILLISECONDS);
}
 

@Test(expected = RuntimeException.class)
@SuppressWarnings("unchecked")
public void testInvalidTransactionResponse() throws Throwable {
    prepareNonceRequest();

    EthSendTransaction ethSendTransaction = new EthSendTransaction();
    ethSendTransaction.setError(new Response.Error(1, "Invalid transaction"));

    Request<?, EthSendTransaction> rawTransactionRequest = mock(Request.class);
    when(rawTransactionRequest.sendAsync()).thenReturn(Async.run(() -> ethSendTransaction));
    when(web3j.ethSendRawTransaction(any(String.class)))
            .thenReturn((Request) rawTransactionRequest);

    testErrorScenario();
}
 

public QueuingTransactionReceiptProcessor(
        Web3j web3j, Callback callback,
        int pollingAttemptsPerTxHash, long pollingFrequency) {
    super(web3j);
    this.scheduledExecutorService = Async.defaultExecutorService();
    this.callback = callback;
    this.pendingTransactions = new LinkedBlockingQueue<>();
    this.pollingAttemptsPerTxHash = pollingAttemptsPerTxHash;

    scheduledExecutorService.scheduleAtFixedRate(
            this::sendTransactionReceiptRequests,
            pollingFrequency, pollingFrequency, TimeUnit.MILLISECONDS);
}
 

public void start() {
  LOG.info("Starting EthSigner");
  runner.start(PROCESS_NAME);

  final String httpJsonRpcUrl = getUrl();

  LOG.info("Http requests being submitted to : {} ", httpJsonRpcUrl);

  final OkHttpClient httpClient = OkHttpClientHelpers.createOkHttpClient(clientTlsConfig);

  final HttpService web3jHttpService = new HttpService(httpJsonRpcUrl, httpClient);
  this.jsonRpc =
      new JsonRpc2_0Web3j(
          web3jHttpService, pollingInterval.toMillis(), Async.defaultExecutorService());
  final JsonRpc2_0Besu besuJsonRpc = new JsonRpc2_0Besu(web3jHttpService);

  final Eth eth = new Eth(jsonRpc);
  final RawJsonRpcRequestFactory requestFactory = new RawJsonRpcRequestFactory(web3jHttpService);
  this.transactions = new Transactions(eth);
  final Besu besu = new Besu(besuJsonRpc);
  final Eea eea = new Eea(requestFactory);
  this.publicContracts = new PublicContracts(eth);
  this.privateContracts = new PrivateContracts(besu, eea);
  this.accounts = new Accounts(eth);
  this.rawJsonRpcRequests = new RawJsonRpcRequests(web3jHttpService, requestFactory);
  this.rawHttpRequests = new HttpRequest(httpJsonRpcUrl, httpClient);
}
 

@Test(expected = RuntimeException.class)
@SuppressWarnings("unchecked")
public void testInvalidTransactionResponse() throws Throwable {
    prepareNonceRequest();

    PlatonSendTransaction ethSendTransaction = new PlatonSendTransaction();
    ethSendTransaction.setError(new Response.Error(1, "Invalid transaction"));

    Request<?, PlatonSendTransaction> rawTransactionRequest = mock(Request.class);
    when(rawTransactionRequest.sendAsync()).thenReturn(Async.run(() -> ethSendTransaction));
    when(web3j.platonSendRawTransaction(any(String.class)))
            .thenReturn((Request) rawTransactionRequest);

    testErrorScenario();
}
 

public QueuingTransactionReceiptProcessor(
        Web3j web3j, Callback callback,
        int pollingAttemptsPerTxHash, long pollingFrequency) {
    super(web3j);
    this.scheduledExecutorService = Async.defaultExecutorService();
    this.callback = callback;
    this.pendingTransactions = new LinkedBlockingQueue<>();
    this.pollingAttemptsPerTxHash = pollingAttemptsPerTxHash;

    scheduledExecutorService.scheduleAtFixedRate(
            this::sendTransactionReceiptRequests,
            pollingFrequency, pollingFrequency, TimeUnit.MILLISECONDS);
}
 

@Test(expected = ExecutionException.class)
public void testRunException() throws Exception {
    Async.run(() -> {
        throw new RuntimeException("");
    }).get();
}
 

public JsonRpc2_0Web3j(Web3jService web3jService) {
    this(web3jService, DEFAULT_BLOCK_TIME, Async.defaultExecutorService());
}
 

@Override
public CompletableFuture<BatchResponse> sendBatchAsync(BatchRequest batchRequest) {
    return Async.run(() -> sendBatch(batchRequest));
}
 

@Override
public <T extends Response> CompletableFuture<T> sendAsync(
        Request jsonRpc20Request, Class<T> responseType) {
    return Async.run(() -> send(jsonRpc20Request, responseType));
}
 

@Override
public <T extends Response> CompletableFuture<T> sendAsync(
        Request jsonRpc20Request, Class<T> responseType) {
    return Async.run(() -> send(jsonRpc20Request, responseType));
}
 

public JsonRpc2_0Besu(final Web3jService web3jService) {
    this(web3jService, DEFAULT_BLOCK_TIME, Async.defaultExecutorService());
}
 

@Test
public void testRun() throws Exception {
    assertThat(Async.run(() -> "").get(), is(""));
}
 

@Test
public void testRun() throws Exception {
    assertThat(Async.run(() -> "").get(), is(""));
}
 

public JsonRpc2_0Web3j(Web3jService web3jService) {
    this(web3jService, DEFAULT_BLOCK_TIME, Async.defaultExecutorService());
}
 

public JsonRpc2_0Web3j(Web3jService web3jService) {
    this(web3jService, DEFAULT_BLOCK_TIME, Async.defaultExecutorService());
}
 

@Override
public <T extends Response> CompletableFuture<T> sendAsync(
        Request jsonRpc20Request, Class<T> responseType) {
    return Async.run(() -> send(jsonRpc20Request, responseType));
}
 

@Test(expected = ExecutionException.class)
public void testRunException() throws Exception {
    Async.run(() -> {
        throw new RuntimeException("");
    }).get();
}
 

private Web3j buildWeb3j(Node node, Web3jService web3jService) {

        return Web3j.build(web3jService, node.getPollingInterval(), Async.defaultExecutorService());
    }
 

/**
 * Perform request asynchronously with a future.
 *
 * @return a future containing our function
 */
public CompletableFuture<T> sendAsync() {
    return Async.run(this::send);
}
 

/**
 * Perform request asynchronously with a future.
 *
 * @return a future containing our function
 */
public CompletableFuture<T> sendAsync() {
    return Async.run(this::send);
}
 

/**
 * Perform request asynchronously with a future.
 *
 * @return a future containing our function
 */
public CompletableFuture<T> sendAsync() {
    return Async.run(this::send);
}