Examples with Base64String org.web3j.utils.Base64String used on opensource projects

Example 1 with Base64String

use of org.web3j.utils.Base64String in project besu by hyperledger.

the class FlexibleMultiTenancyAcceptanceTest method createFlexiblePrivacyGroup.

private String createFlexiblePrivacyGroup(final MultiTenancyPrivacyGroup group) {
    final List<MultiTenancyPrivacyNode> multiTenancyPrivacyNodes = group.getPrivacyNodes();
    final MultiTenancyPrivacyNode groupCreatorMultiTenancyPrivacyNode = multiTenancyPrivacyNodes.get(0);
    final PrivacyNode groupCreatorNode = group.getGroupCreatingPrivacyNode();
    final String groupCreatorTenant = group.getGroupCreatingTenant();
    final List<String> members = group.getTenants();
    final String token = groupCreatorMultiTenancyPrivacyNode.getTokenForTenant(groupCreatorTenant);
    final CreateFlexiblePrivacyGroupTransaction createTx = privacyTransactions.createFlexiblePrivacyGroup(groupCreatorNode, groupCreatorTenant, members, token);
    final PrivacyRequestFactory.PrivxCreatePrivacyGroupResponse createResponse = groupCreatorNode.execute(createTx);
    final String privacyGroupId = createResponse.getPrivacyGroupId();
    final List<Base64String> base64StringList = members.stream().map(Base64String::wrap).collect(Collectors.toList());
    for (final MultiTenancyPrivacyNode mtpn : multiTenancyPrivacyNodes) {
        final PrivacyNode privacyNode = mtpn.getPrivacyNode();
        for (final String tenant : mtpn.getTenants()) {
            if (members.contains(tenant)) {
                privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(mtpn.getTokenForTenant(tenant));
                privacyNode.verify(flexiblePrivacyGroupExists(privacyGroupId, base64StringList));
            }
        }
    }
    groupCreatorNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(token);
    final String commitmentHash = callGetParticipantsMethodAndReturnCommitmentHash(privacyGroupId, groupCreatorNode, groupCreatorTenant);
    final PrivateTransactionReceipt expectedReceipt = buildExpectedAddMemberTransactionReceipt(privacyGroupId, groupCreatorNode, groupCreatorTenant, members.toArray(new String[] {}));
    for (final MultiTenancyPrivacyNode mtpn : multiTenancyPrivacyNodes) {
        final PrivacyNode privacyNode = mtpn.getPrivacyNode();
        for (final String tenant : mtpn.getTenants()) {
            if (members.contains(tenant)) {
                privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(mtpn.getTokenForTenant(tenant));
                privacyNode.verify(privateTransactionVerifier.validPrivateTransactionReceipt(commitmentHash, expectedReceipt));
            }
        }
    }
    return privacyGroupId;
}

Example 2 with Base64String

use of org.web3j.utils.Base64String in project besu by hyperledger.

the class FlexibleMultiTenancyAcceptanceTest method noAccessWhenNotAMember.

@Test
public void noAccessWhenNotAMember() {
    final MultiTenancyPrivacyGroup twoTenantsFromAlice = new MultiTenancyPrivacyGroup();
    final List<String> tenants = aliceMultiTenancyPrivacyNode.getTenants();
    final String removedTenant = tenants.remove(tenants.size() - 1);
    twoTenantsFromAlice.addNodeWithTenants(aliceMultiTenancyPrivacyNode, tenants);
    final String privacyGroupId = createFlexiblePrivacyGroup(twoTenantsFromAlice);
    final MultiTenancyPrivacyNode multiTenancyPrivacyNode = twoTenantsFromAlice.getPrivacyNodes().get(0);
    final String tenant = tenants.get(0);
    final PrivacyNode privacyNode = multiTenancyPrivacyNode.getPrivacyNode();
    final BesuNode privacyNodeBesu = privacyNode.getBesu();
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    final EventEmitter eventEmitter = privacyNode.execute(privateContractTransactions.createSmartContractWithPrivacyGroupId(EventEmitter.class, privacyNode.getTransactionSigningKey(), tenant, privacyGroupId));
    final String transactionHash = getContractDeploymentCommitmentHash(eventEmitter);
    // check that a member can get the transaction receipt
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    privacyNode.verify(privateTransactionVerifier.validPrivateTransactionReceipt(transactionHash, (PrivateTransactionReceipt) eventEmitter.getTransactionReceipt().get()));
    final String actual = privacyNode.execute(privacyTransactions.privGetCode(privacyGroupId, Address.fromHexString(eventEmitter.getContractAddress()), "latest")).toHexString();
    assertThat(EventEmitter.BINARY).contains(actual.substring(2));
    // check that getting the transaction receipt does not work if you are not a member
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    privacyNode.verify(privateTransactionVerifier.noPrivateTransactionReceipt(// returning null because the RPC is using the enclave key
    transactionHash));
    // check that getting the code of the event emitter does not work when you are not a member
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.privGetCode(privacyGroupId, Address.fromHexString(eventEmitter.getContractAddress()), "latest"))).hasMessageContaining("Unauthorized");
    final LogFilterJsonParameter filterParameter = new LogFilterJsonParameter("earliest", "latest", List.of(eventEmitter.getContractAddress()), Collections.emptyList(), null);
    // create a valid filter
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    final String filterId = privacyNode.execute(privacyTransactions.newFilter(privacyGroupId, filterParameter));
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    final CallPrivateSmartContractFunction storeTransaction = privateContractTransactions.callSmartContractWithPrivacyGroupId(eventEmitter.getContractAddress(), eventEmitter.store(BigInteger.valueOf(VALUE_SET)).encodeFunctionCall(), privacyNode.getTransactionSigningKey(), Restriction.RESTRICTED, tenant, privacyGroupId);
    final String storeTransactionHash = privacyNode.execute(storeTransaction);
    privacyNode.execute(privacyTransactions.getPrivateTransactionReceipt(storeTransactionHash));
    // check that getting the filter changes works for a member
    assertThat(privacyNode.execute(privacyTransactions.getFilterChanges(privacyGroupId, filterId))).hasSize(1);
    // check that getting the filter changes does not work if you are not a member
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.getFilterChanges(privacyGroupId, filterId))).hasMessageContaining("Unauthorized");
    // check that getting the filter logs works for a member
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    assertThat(privacyNode.execute(privacyTransactions.getFilterLogs(privacyGroupId, filterId))).hasSize(// create privacy group, deploy event emitter, store on event emitter
    3);
    // check that getting the filter logs does not work if you are not a member
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.getFilterLogs(privacyGroupId, filterId))).hasMessageContaining("Unauthorized");
    // check that getting the logs works for a member
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    assertThat(privacyNode.execute(privacyTransactions.privGetLogs(privacyGroupId, filterParameter))).hasSize(// create privacy group, deploy event emitter, store on event emitter
    3);
    // check that getting the logs does not work if you are not a member
    privacyNodeBesu.useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.privGetLogs(privacyGroupId, filterParameter))).hasMessageContaining("Unauthorized");
    final List<Base64String> base64StringList = tenants.stream().map(Base64String::wrap).collect(Collectors.toList());
    // check that a member can find the on-chain privacy group
    privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    final List<PrivacyRequestFactory.FlexiblePrivacyGroup> group = privacyNode.execute(privacyTransactions.findFlexiblePrivacyGroup(Base64String.unwrapList(base64StringList)));
    assertThat(group.size()).isEqualTo(1);
    assertThat(group.get(0).getMembers()).containsAll(base64StringList).hasSize(2);
    // check that when you are not a member you cannot find the privacy group
    privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.findFlexiblePrivacyGroup(Base64String.unwrapList(base64StringList)))).hasMessageContaining("Error finding flexible privacy group");
    // check that a member can do a priv_call
    privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    final EthCall readValue = privacyNode.execute(privacyTransactions.privCall(privacyGroupId, eventEmitter, eventEmitter.value().encodeFunctionCall()));
    assertThat(new BigInteger(readValue.getValue().substring(2), 16)).isEqualByComparingTo(BigInteger.valueOf(VALUE_SET));
    // check that when you are not a member you cannot do a priv_call
    privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.privCall(privacyGroupId, eventEmitter, eventEmitter.value().encodeFunctionCall()))).hasMessageContaining("Unauthorized");
    // check that a member can do a priv_getTransaction
    privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(tenant));
    final PrivacyRequestFactory.GetPrivateTransactionResponse privTransaction = privacyNode.execute(privacyTransactions.privGetTransaction(storeTransactionHash));
    assertThat(privTransaction.getResult().getPrivacyGroupId()).isEqualTo(privacyGroupId);
    // check that when you are not a member you cannot do a priv_getTransaction
    privacyNode.getBesu().useAuthenticationTokenInHeaderForJsonRpc(multiTenancyPrivacyNode.getTokenForTenant(removedTenant));
    assertThatThrownBy(() -> privacyNode.execute(privacyTransactions.privGetTransaction(storeTransactionHash))).hasMessageContaining(// TODO: returning null because the RPC is using the
    "Expecting actual not to be null");
// enclave key
}

Example 3 with Base64String

use of org.web3j.utils.Base64String in project besu by hyperledger.

the class FlexiblePrivacyAcceptanceTestBase method createFlexiblePrivacyGroup.

/**
 * Create an flexible privacy group. The privacy group id will be randomly generated.
 *
 * <p>This method also checks that each node member has successfully processed the transaction and
 * has the expected list of member for the group.
 *
 * @param members the list of members of the privacy group. The first member of the list will be
 *     the creator of the group.
 * @return the id of the privacy group
 */
protected String createFlexiblePrivacyGroup(final String privateFrom, final List<String> addresses, final PrivacyNode... members) {
    final PrivacyNode groupCreator = members[0];
    final CreateFlexiblePrivacyGroupTransaction createTx = privacyTransactions.createFlexiblePrivacyGroup(groupCreator, privateFrom, addresses);
    final PrivacyRequestFactory.PrivxCreatePrivacyGroupResponse createResponse = groupCreator.execute(createTx);
    final String privacyGroupId = createResponse.getPrivacyGroupId();
    final List<Base64String> membersEnclaveKeys = Arrays.stream(members).map(m -> Base64String.wrap(m.getEnclaveKey())).collect(Collectors.toList());
    for (final PrivacyNode member : members) {
        member.verify(flexiblePrivacyGroupExists(privacyGroupId, membersEnclaveKeys));
    }
    final String commitmentHash = callGetParticipantsMethodAndReturnCommitmentHash(privacyGroupId, groupCreator, privateFrom);
    final PrivateTransactionReceipt expectedReceipt = buildExpectedAddMemberTransactionReceipt(privacyGroupId, groupCreator, addresses.toArray(new String[] {}));
    for (final PrivacyNode member : members) {
        member.verify(privateTransactionVerifier.validPrivateTransactionReceipt(commitmentHash, expectedReceipt));
    }
    return privacyGroupId;
}

Example 4 with Base64String

use of org.web3j.utils.Base64String in project web3j by web3j.

the class BesuOnChainPrivacyIntegrationTest method testCreateAddRemoveOnChainPrivacyGroup.

@Test
public void testCreateAddRemoveOnChainPrivacyGroup() throws Exception {
    Base64String privacyGroupId = Base64String.wrap(generateRandomBytes(32));
    final String createTxHash = besu.privOnChainCreatePrivacyGroup(privacyGroupId, ALICE, ENCLAVE_KEY_ALICE, Collections.singletonList(ENCLAVE_KEY_BOB)).send().getTransactionHash();
    TransactionReceipt createReceipt = processor.waitForTransactionReceipt(createTxHash);
    assertTrue(createReceipt.isStatusOK());
    final String addTxHash = besu.privOnChainAddToPrivacyGroup(privacyGroupId, ALICE, ENCLAVE_KEY_ALICE, Collections.singletonList(ENCLAVE_KEY_CHARLIE)).send().getTransactionHash();
    TransactionReceipt addReceipt = processor.waitForTransactionReceipt(addTxHash);
    assertTrue(addReceipt.isStatusOK());
    List<PrivacyGroup> groups = besu.privOnChainFindPrivacyGroup(Arrays.asList(ENCLAVE_KEY_ALICE, ENCLAVE_KEY_BOB, ENCLAVE_KEY_CHARLIE)).send().getGroups();
    assertTrue(groups.stream().anyMatch(g -> g.getPrivacyGroupId().equals(privacyGroupId) && g.getMembers().size() == 3));
    final String removeTxHash = besu.privOnChainRemoveFromPrivacyGroup(privacyGroupId, ALICE, ENCLAVE_KEY_ALICE, ENCLAVE_KEY_CHARLIE).send().getTransactionHash();
    TransactionReceipt removeReceipt = processor.waitForTransactionReceipt(removeTxHash);
    assertTrue(removeReceipt.isStatusOK());
    List<PrivacyGroup> removedGroups = besu.privOnChainFindPrivacyGroup(Arrays.asList(ENCLAVE_KEY_ALICE, ENCLAVE_KEY_BOB)).send().getGroups();
    assertTrue(removedGroups.stream().anyMatch(g -> g.getPrivacyGroupId().equals(privacyGroupId) && g.getMembers().size() == 2));
}

Example 5 with Base64String

use of org.web3j.utils.Base64String in project web3j by web3j.

the class BesuOnChainPrivacyIntegrationTest method testCreateAndFindOnChainPrivacyGroup.

@Test
public void testCreateAndFindOnChainPrivacyGroup() throws Exception {
    Base64String privacyGroupId = Base64String.wrap(generateRandomBytes(32));
    final String txHash = besu.privOnChainCreatePrivacyGroup(privacyGroupId, ALICE, ENCLAVE_KEY_ALICE, Collections.singletonList(ENCLAVE_KEY_BOB)).send().getTransactionHash();
    TransactionReceipt receipt = processor.waitForTransactionReceipt(txHash);
    assertTrue(receipt.isStatusOK());
    List<PrivacyGroup> groups = besu.privOnChainFindPrivacyGroup(Arrays.asList(ENCLAVE_KEY_ALICE, ENCLAVE_KEY_BOB)).send().getGroups();
    assertTrue(groups.stream().anyMatch(x -> x.getPrivacyGroupId().equals(privacyGroupId)));
}