Merge branch 'master' into feature/pie-2284-add-trace-transaction-api

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/condition/eth/EthConditions.java

@@ -18,6 +18,9 @@
 import org.hyperledger.besu.tests.acceptance.dsl.condition.miner.MiningStatusCondition;
 import org.hyperledger.besu.tests.acceptance.dsl.transaction.eth.EthTransactions;
 
+import java.math.BigInteger;
+import java.util.List;
+
 public class EthConditions {
 
  private final EthTransactions transactions;
@@ -68,4 +71,10 @@ public Condition expectSuccessfulTransactionReceiptWithoutReason(final String tr
  public Condition miningStatus(final boolean isMining) {
  return new MiningStatusCondition(transactions.mining(), isMining);
  }
+
+ public Condition expectNewPendingTransactions(
+ final BigInteger filterId, final List<String> transactionHashes) {
+ return new NewPendingTransactionFilterChangesCondition(
+ transactions.filterChanges(filterId), transactionHashes);
+ }
 }

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/condition/eth/NewPendingTransactionFilterChangesCondition.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.tests.acceptance.dsl.condition.eth;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hyperledger.besu.tests.acceptance.dsl.WaitUtils;
+import org.hyperledger.besu.tests.acceptance.dsl.condition.Condition;
+import org.hyperledger.besu.tests.acceptance.dsl.node.Node;
+import org.hyperledger.besu.tests.acceptance.dsl.transaction.eth.EthFilterChangesTransaction;
+
+import java.util.List;
+
+import org.web3j.protocol.core.methods.response.EthLog;
+
+public class NewPendingTransactionFilterChangesCondition implements Condition {
+
+ private final EthFilterChangesTransaction filterChanges;
+ private final List<String> transactionHashes;
+
+ public NewPendingTransactionFilterChangesCondition(
+ final EthFilterChangesTransaction filterChanges, final List<String> transactionHashes) {
+
+ this.filterChanges = filterChanges;
+ this.transactionHashes = transactionHashes;
+ }
+
+ @Override
+ public void verify(final Node node) {
+ WaitUtils.waitFor(
+ () -> {
+ final EthLog response = node.execute(filterChanges);
+ assertThat(response).isNotNull();
+ assertThat(response.getResult().size()).isEqualTo(transactionHashes.size());
+ for (int i = 0; i < transactionHashes.size(); ++i) {
+ assertThat(response.getLogs().get(0).get()).isEqualTo(transactionHashes.get(0));
+ }
+ });
+ }
+}

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/node/configuration/privacy/PrivacyNodeConfiguration.java

@@ -19,15 +19,23 @@
 
 public class PrivacyNodeConfiguration {
 
+ private final int privacyAddress;
  private final BesuNodeConfiguration besuConfig;
  private final OrionKeyConfiguration orionConfig;
 
  PrivacyNodeConfiguration(
- final BesuNodeConfiguration besuConfig, final OrionKeyConfiguration orionConfig) {
+ final int privacyAddress,
+ final BesuNodeConfiguration besuConfig,
+ final OrionKeyConfiguration orionConfig) {
+ this.privacyAddress = privacyAddress;
  this.besuConfig = besuConfig;
  this.orionConfig = orionConfig;
  }
 
+ public int getPrivacyAddress() {
+ return privacyAddress;
+ }
+
  public BesuNodeConfiguration getBesuConfig() {
  return besuConfig;
  }

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/node/configuration/privacy/PrivacyNodeFactory.java

@@ -14,6 +14,7 @@
  */
 package org.hyperledger.besu.tests.acceptance.dsl.node.configuration.privacy;
 
+import org.hyperledger.besu.ethereum.core.Address;
 import org.hyperledger.besu.tests.acceptance.dsl.node.configuration.BesuNodeConfigurationBuilder;
 import org.hyperledger.besu.tests.acceptance.dsl.node.configuration.NodeConfigurationFactory;
 import org.hyperledger.besu.tests.acceptance.dsl.node.configuration.genesis.GenesisConfigurationFactory;
@@ -41,8 +42,15 @@ private PrivacyNode create(final PrivacyNodeConfiguration privacyNodeConfig) thr
 
  public PrivacyNode createPrivateTransactionEnabledMinerNode(
  final String name, final PrivacyAccount privacyAccount) throws IOException {
+ return createPrivateTransactionEnabledMinerNode(name, privacyAccount, Address.PRIVACY);
+ }
+
+ public PrivacyNode createPrivateTransactionEnabledMinerNode(
+ final String name, final PrivacyAccount privacyAccount, final int privacyAddress)
+ throws IOException {
  return create(
  new PrivacyNodeConfiguration(
+ privacyAddress,
  new BesuNodeConfigurationBuilder()
  .name(name)
  .miningEnabled()
@@ -57,8 +65,15 @@ public PrivacyNode createPrivateTransactionEnabledMinerNode(
 
  public PrivacyNode createPrivateTransactionEnabledNode(
  final String name, final PrivacyAccount privacyAccount) throws IOException {
+ return createPrivateTransactionEnabledNode(name, privacyAccount, Address.PRIVACY);
+ }
+
+ public PrivacyNode createPrivateTransactionEnabledNode(
+ final String name, final PrivacyAccount privacyAccount, final int privacyAddress)
+ throws IOException {
  return create(
  new PrivacyNodeConfiguration(
+ privacyAddress,
  new BesuNodeConfigurationBuilder()
  .name(name)
  .jsonRpcEnabled()
@@ -72,8 +87,15 @@ public PrivacyNode createPrivateTransactionEnabledNode(
 
  public PrivacyNode createIbft2NodePrivacyEnabled(
  final String name, final PrivacyAccount privacyAccount) throws IOException {
+ return createIbft2NodePrivacyEnabled(name, privacyAccount, Address.PRIVACY);
+ }
+
+ public PrivacyNode createIbft2NodePrivacyEnabled(
+ final String name, final PrivacyAccount privacyAccount, final int privacyAddress)
+ throws IOException {
  return create(
  new PrivacyNodeConfiguration(
+ privacyAddress,
  new BesuNodeConfigurationBuilder()
  .name(name)
  .miningEnabled()

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/PrivacyNode.java

@@ -69,6 +69,7 @@ public class PrivacyNode implements AutoCloseable {
  private final OrionTestHarness orion;
  private final BesuNode besu;
  private final Vertx vertx;
+ private final Integer privacyAddress;
 
  public PrivacyNode(final PrivacyNodeConfiguration privacyConfiguration, final Vertx vertx)
  throws IOException {
@@ -78,6 +79,8 @@ public PrivacyNode(final PrivacyNodeConfiguration privacyConfiguration, final Ve
 
  final BesuNodeConfiguration besuConfig = privacyConfiguration.getBesuConfig();
 
+ privacyAddress = privacyConfiguration.getPrivacyAddress();
+
  this.besu =
  new BesuNode(
  besuConfig.getName(),
@@ -167,6 +170,7 @@ public void start(final BesuNodeRunner runner) {
  .setStorageProvider(createKeyValueStorageProvider(dataDir, dbDir))
  .setPrivateKeyPath(KeyPairUtil.getDefaultKeyFile(besu.homeDirectory()).toPath())
  .setEnclaveFactory(new EnclaveFactory(vertx))
+ .setPrivacyAddress(privacyAddress)
  .build();
  } catch (IOException e) {
  throw new RuntimeException();

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/condition/ExpectExistingPrivateTransactionReceipt.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.tests.acceptance.dsl.privacy.condition;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.PrivacyNode;
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.transaction.PrivacyTransactions;
+
+import org.web3j.protocol.besu.response.privacy.PrivateTransactionReceipt;
+
+public class ExpectExistingPrivateTransactionReceipt implements PrivateCondition {
+ private final PrivacyTransactions transactions;
+ private final String transactionHash;
+
+ public ExpectExistingPrivateTransactionReceipt(
+ final PrivacyTransactions transactions, final String transactionHash) {
+
+ this.transactions = transactions;
+ this.transactionHash = transactionHash;
+ }
+
+ @Override
+ public void verify(final PrivacyNode node) {
+ final PrivateTransactionReceipt privateTransactionReceipt =
+ node.execute(transactions.getPrivateTransactionReceipt(transactionHash));
+ assertThat(privateTransactionReceipt).isNotNull();
+ }
+}

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/condition/ExpectValidOnChainPrivacyGroupCreated.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.tests.acceptance.dsl.privacy.condition;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.PrivacyNode;
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.transaction.PrivacyTransactions;
+import org.hyperledger.besu.tests.acceptance.dsl.transaction.privacy.PrivacyRequestFactory;
+
+import java.util.List;
+
+import org.awaitility.Awaitility;
+import org.web3j.utils.Base64String;
+
+public class ExpectValidOnChainPrivacyGroupCreated implements PrivateCondition {
+
+ private final PrivacyTransactions transactions;
+ private final PrivacyRequestFactory.OnChainPrivacyGroup expected;
+
+ public ExpectValidOnChainPrivacyGroupCreated(
+ final PrivacyTransactions transactions,
+ final PrivacyRequestFactory.OnChainPrivacyGroup expected) {
+ this.transactions = transactions;
+ this.expected = expected;
+ }
+
+ @Override
+ public void verify(final PrivacyNode node) {
+ Awaitility.await()
+ .untilAsserted(
+ () -> {
+ final List<PrivacyRequestFactory.OnChainPrivacyGroup> groups =
+ node.execute(
+ transactions.findOnChainPrivacyGroup(
+ Base64String.unwrapList(expected.getMembers())));
+ assertThat(groups).contains(expected);
+ });
+ }
+}

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/condition/ExpectValidPrivateContractDeployedReceipt.java

@@ -43,6 +43,8 @@ public void verify(final Contract contract) {
  assertThat(receipt.isPresent()).isTrue();
  final TransactionReceipt transactionReceipt = receipt.get();
 
+ assertThat(transactionReceipt.isStatusOK()).isTrue();
+
  // Contract transaction has no 'to' address or contract address
  assertThat(transactionReceipt.getTo()).isNull();
 

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/condition/ExpectValidPrivateTransactionReceipt.java

@@ -24,21 +24,34 @@
 public class ExpectValidPrivateTransactionReceipt implements PrivateCondition {
  private final PrivacyTransactions transactions;
  private final String transactionHash;
- private final PrivateTransactionReceipt receipt;
+ private final PrivateTransactionReceipt expectedReceipt;
 
  public ExpectValidPrivateTransactionReceipt(
  final PrivacyTransactions transactions,
  final String transactionHash,
- final PrivateTransactionReceipt receipt) {
+ final PrivateTransactionReceipt expectedReceipt) {
 
  this.transactions = transactions;
  this.transactionHash = transactionHash;
- this.receipt = receipt;
+ this.expectedReceipt = expectedReceipt;
  }
 
  @Override
  public void verify(final PrivacyNode node) {
- assertThat(node.execute(transactions.getPrivateTransactionReceipt(transactionHash)))
- .isEqualToIgnoringGivenFields(receipt, "commitmentHash");
+ final PrivateTransactionReceipt actualReceipt =
+ node.execute(transactions.getPrivateTransactionReceipt(transactionHash));
+ assertThat(actualReceipt)
+ .usingRecursiveComparison()
+ .ignoringFields("commitmentHash", "logs")
+ .isEqualTo(expectedReceipt);
+
+ assertThat(actualReceipt.getLogs().size()).isEqualTo(expectedReceipt.getLogs().size());
+
+ for (int i = 0; i < expectedReceipt.getLogs().size(); i++) {
+ assertThat(actualReceipt.getLogs().get(i))
+ .usingRecursiveComparison()
+ .ignoringFields("blockHash", "blockNumber")
+ .isEqualTo(expectedReceipt.getLogs().get(i));
+ }
  }
 }

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/condition/PrivGetTransactionReceiptTransaction.java

@@ -39,7 +39,7 @@ public PrivGetTransactionReceiptTransaction(final String transactionHash) {
  public PrivateTransactionReceipt execute(final NodeRequests node) {
  final Besu besu = node.privacy().getBesuClient();
  final PollingPrivateTransactionReceiptProcessor receiptProcessor =
- new PollingPrivateTransactionReceiptProcessor(besu, 15000, 3);
+ new PollingPrivateTransactionReceiptProcessor(besu, 1000, 15);
  try {
  final PrivateTransactionReceipt result =
  receiptProcessor.waitForTransactionReceipt(transactionHash);

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/condition/PrivateTransactionVerifier.java

@@ -14,10 +14,17 @@
  */
 package org.hyperledger.besu.tests.acceptance.dsl.privacy.condition;
 
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.PrivacyNode;
 import org.hyperledger.besu.tests.acceptance.dsl.privacy.transaction.PrivacyTransactions;
+import org.hyperledger.besu.tests.acceptance.dsl.transaction.privacy.PrivacyRequestFactory.OnChainPrivacyGroup;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 
 import org.web3j.protocol.besu.response.privacy.PrivacyGroup;
 import org.web3j.protocol.besu.response.privacy.PrivateTransactionReceipt;
+import org.web3j.utils.Base64String;
 
 public class PrivateTransactionVerifier {
 
@@ -32,6 +39,11 @@ public ExpectValidPrivateTransactionReceipt validPrivateTransactionReceipt(
  return new ExpectValidPrivateTransactionReceipt(transactions, transactionHash, receipt);
  }
 
+ public ExpectExistingPrivateTransactionReceipt existingPrivateTransactionReceipt(
+ final String transactionHash) {
+ return new ExpectExistingPrivateTransactionReceipt(transactions, transactionHash);
+ }
+
  public ExpectNoPrivateTransactionReceipt noPrivateTransactionReceipt(
  final String transactionHash) {
  return new ExpectNoPrivateTransactionReceipt(transactions, transactionHash);
@@ -41,6 +53,21 @@ public ExpectValidPrivacyGroupCreated validPrivacyGroupCreated(final PrivacyGrou
  return new ExpectValidPrivacyGroupCreated(transactions, expected);
  }
 
+ public ExpectValidOnChainPrivacyGroupCreated onChainPrivacyGroupExists(
+ final String privacyGroupId, final PrivacyNode... members) {
+
+ List<Base64String> membersEnclaveKeys =
+ Arrays.stream(members)
+ .map(PrivacyNode::getEnclaveKey)
+ .map(Base64String::wrap)
+ .collect(Collectors.toList());
+
+ final OnChainPrivacyGroup expectedGroup =
+ new OnChainPrivacyGroup(privacyGroupId, membersEnclaveKeys);
+
+ return new ExpectValidOnChainPrivacyGroupCreated(transactions, expectedGroup);
+ }
+
  public ExpectInternalErrorPrivateTransactionReceipt internalErrorPrivateTransactionReceipt(
  final String transactionHash) {
  return new ExpectInternalErrorPrivateTransactionReceipt(transactions, transactionHash);