How to use

getIssuer

method

in

com.icodici.universa.contract.Contract

public JSApiRole getIssuer() {
  return JSApiRole.createJSApiRole(this.currentContract.getIssuer());
}

@Override
public boolean isU(Set<KeyAddress> issuerKeys, String issuerName) {
  Role issuer = getIssuer();
  if(!(issuer instanceof SimpleRole))
    return false;
  Set<KeyAddress> thisIssuerAddresses = new HashSet<>(((SimpleRole)issuer).getSimpleKeyAddresses());
  for (PublicKey publicKey : ((SimpleRole)issuer).getSimpleKeys())
    thisIssuerAddresses.add(publicKey.getShortAddress());
  if (Collections.disjoint(issuerKeys, thisIssuerAddresses))
    return false;
  if ( !issuerName.equals(getDefinition().getData().get("issuerName")))
    return false;
  return true;
}

@SuppressWarnings("deprecation") //outdated method. will be replaced with new one soon
private void checkForNetConfig(Contract contract) {
  if (contract.getIssuer().getKeys().stream().anyMatch(key -> config.getNetworkReconfigKeyAddress().isMatchingKey(key))) {
    if(contract.getParent() == null)
      return;
    if(contract.getRevoking().size() == 0 || !contract.getRevoking().get(0).getId().equals(contract.getParent()))
      return;
    Contract parent = contract.getRevoking().get(0);
    if(!checkContractCorrespondsToConfig(parent,network.allNodes())) {
      return;
    }
    if(!checkIfContractContainsNetConfig(contract)) {
      return;
    }
    List<NodeInfo> networkNodes = network.allNodes();
    List contractNodes = (List)DefaultBiMapper.getInstance().deserializeObject(contract.getStateData().get("net_config"));
    contractNodes.stream().forEach(nodeInfo -> {
      if(!networkNodes.contains(nodeInfo)) {
        addNode((NodeInfo) nodeInfo);
      }
      networkNodes.remove(nodeInfo);
    });
    networkNodes.stream().forEach( nodeInfo -> removeNode(nodeInfo));
  }
}

public Binder serializeWith(BiSerializer serializer) {
  List<Permission> pp = permissions.values();
  Binder pb = new Binder();
  int lastId = 0;
  // serialize permissions with a valid id
  permissions.values().forEach(perm -> {
    String pid = perm.getId();
    if (pid == null)
      throw new IllegalStateException("permission without id: " + perm);
    if (pb.containsKey(pid))
      throw new IllegalStateException("permission: duplicate permission id found: " + perm);
    pb.put(pid, perm);
  });
  Collections.sort(pp);
  Binder of = Binder.of(
      "issuer", getIssuer(),
      "created_at", createdAt,
      "data", data,
      "permissions", pb
  );
  if (expiresAt != null)
    of.set("expires_at", expiresAt);
  if (references != null)
    of.set("references", references);
  if (extendedType != null)
    of.set("extended_type", extendedType);
  return serializer.serialize(of);
}

@Test
public void anonymizeRole() throws Exception {
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  assertTrue (new File(basePath + "forRoleAnonymizing.unicon").exists());
  callMain("-anonymize", basePath + "forRoleAnonymizing.unicon",
      "-role", "issuer");
  assertTrue (new File(basePath + "forRoleAnonymizing_anonymized.unicon").exists());
  System.out.println(output);
  PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey"));
  Contract contract = CLIMain.loadContract(basePath + "forRoleAnonymizing_anonymized.unicon", true);
  assertFalse(contract.getIssuer().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract = new Contract(contract.getLastSealedBinary());
  assertFalse(anonPublishedContract.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract.getSealedByKeys().contains(key.getPublicKey()));
}

@Test
public void anonymizeRoleAndSaveWithName() throws Exception {
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  assertTrue (new File(basePath + "forRoleAnonymizing.unicon").exists());
  callMain("-anonymize", basePath + "forRoleAnonymizing.unicon",
      "-role", "issuer",
      "--output", basePath + "myAnon.unicon");
  assertTrue (new File(basePath + "myAnon.unicon").exists());
  System.out.println(output);
  PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey"));
  Contract contract = CLIMain.loadContract(basePath + "myAnon.unicon", true);
  assertFalse(contract.getIssuer().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract = new Contract(contract.getLastSealedBinary());
  assertFalse(anonPublishedContract.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract.getSealedByKeys().contains(key.getPublicKey()));
}

@Test
public void anonymizeRoleForTwoContracts() throws Exception {
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing1.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing2.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  assertTrue (new File(basePath + "forRoleAnonymizing1.unicon").exists());
  assertTrue (new File(basePath + "forRoleAnonymizing2.unicon").exists());
  callMain("-anonymize", basePath + "forRoleAnonymizing1.unicon", basePath + "forRoleAnonymizing2.unicon",
      "-role", "issuer");
  assertTrue (new File(basePath + "forRoleAnonymizing1_anonymized.unicon").exists());
  assertTrue (new File(basePath + "forRoleAnonymizing2_anonymized.unicon").exists());
  System.out.println(output);
  PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey"));
  Contract contract1 = CLIMain.loadContract(basePath + "forRoleAnonymizing1_anonymized.unicon", true);
  assertFalse(contract1.getIssuer().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract1 = new Contract(contract1.getLastSealedBinary());
  assertFalse(anonPublishedContract1.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract1.getSealedByKeys().contains(key.getPublicKey()));
  Contract contract2 = CLIMain.loadContract(basePath + "forRoleAnonymizing2_anonymized.unicon", true);
  assertFalse(contract2.getIssuer().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract2 = new Contract(contract2.getLastSealedBinary());
  assertFalse(anonPublishedContract2.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract2.getSealedByKeys().contains(key.getPublicKey()));
}

@Test
public void anonymizeRoleForTwoContractsWithNames() throws Exception {
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing1.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing2.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  assertTrue (new File(basePath + "forRoleAnonymizing1.unicon").exists());
  assertTrue (new File(basePath + "forRoleAnonymizing2.unicon").exists());
  callMain("-anonymize", basePath + "forRoleAnonymizing1.unicon", basePath + "forRoleAnonymizing2.unicon",
      "-role", "issuer",
      "--output", basePath + "myAnon1.unicon", "--output", basePath + "myAnon2.unicon");
  assertTrue (new File(basePath + "myAnon1.unicon").exists());
  assertTrue (new File(basePath + "myAnon2.unicon").exists());
  System.out.println(output);
  PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey"));
  Contract contract1 = CLIMain.loadContract(basePath + "myAnon1.unicon", true);
  assertFalse(contract1.getIssuer().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract1 = new Contract(contract1.getLastSealedBinary());
  assertFalse(anonPublishedContract1.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract1.getSealedByKeys().contains(key.getPublicKey()));
  Contract contract2 = CLIMain.loadContract(basePath + "myAnon2.unicon", true);
  assertFalse(contract2.getIssuer().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract2 = new Contract(contract2.getLastSealedBinary());
  assertFalse(anonPublishedContract2.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract2.getSealedByKeys().contains(key.getPublicKey()));
}

  @Test
  public void checkAnonymizingRole() throws Exception {

    PrivateKey key = new PrivateKey(Do.read(PRIVATE_KEY_PATH));
    Contract contract = createCoin100apiv3();
    contract.addSignerKey(key);
    sealCheckTrace(contract, true);

    assertTrue(contract.getIssuer().getKeys().contains(key.getPublicKey()));

    contract.anonymizeRole("issuer");
    contract.anonymizeRole("owner");
    contract.seal();

    assertFalse(contract.getIssuer().getKeys().contains(key.getPublicKey()));

    Contract anonPublishedContract = new Contract(contract.getLastSealedBinary());

    assertFalse(anonPublishedContract.getIssuer().getKeys().contains(key.getPublicKey()));
//        assertFalse(anonPublishedContract.getSealedByKeys().contains(key.getPublicKey()));
  }

@Test
public void anonymizeAllRoles() throws Exception {
  callMain2("-create", rootPath + "TokenDSLTemplate.yml", "--output", basePath + "forRoleAnonymizing.unicon",
      "-k", rootPath + "_xer0yfe2nn1xthc.private.unikey");
  assertTrue (new File(basePath + "forRoleAnonymizing.unicon").exists());
  callMain("-anonymize", basePath + "forRoleAnonymizing.unicon");
  assertTrue (new File(basePath + "forRoleAnonymizing_anonymized.unicon").exists());
  System.out.println(output);
  PrivateKey key = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey"));
  PrivateKey ownerKey = new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey"));
  Contract contract = CLIMain.loadContract(basePath + "forRoleAnonymizing_anonymized.unicon", true);
  assertFalse(contract.getOwner().getKeys().contains(ownerKey.getPublicKey()));
  assertFalse(contract.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(contract.getCreator().getKeys().contains(key.getPublicKey()));
  Contract anonPublishedContract = new Contract(contract.getLastSealedBinary());
  assertFalse(anonPublishedContract.getOwner().getKeys().contains(ownerKey.getPublicKey()));
  assertFalse(anonPublishedContract.getIssuer().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract.getCreator().getKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract.getSealedByKeys().contains(key.getPublicKey()));
  assertFalse(anonPublishedContract.getSealedByKeys().contains(ownerKey.getPublicKey()));
}

assertFalse(contract1.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(contract1.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract1.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract1.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract1.getSealedByKeys().contains(key.getPublicKey()));
assertFalse(contract2.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(contract2.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract2.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract2.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract2.getSealedByKeys().contains(key.getPublicKey()));

reference.type = Reference.TYPE_TRANSACTIONAL;
reference.transactional_id = consent.getTransactional().getId();
reference.signed_by.add(consent.getIssuer());

assertTrue(notaryContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(notaryContract.getCreator().isAllowedForKeys(issuerPrivateKeys));
assertFalse(notaryContract.getIssuer().isAllowedForKeys(ownerPublicKeys));
assertFalse(notaryContract.getCreator().isAllowedForKeys(ownerPublicKeys));

@Test
public void goodNotary() throws Exception {
  Set<PrivateKey> martyPrivateKeys = new HashSet<>();
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  Set<PublicKey> martyPublicKeys = new HashSet<>();
  Set<PublicKey> stepaPublicKeys = new HashSet<>();
  martyPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/marty_mcfly.private.unikey")));
  stepaPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")));
  for (PrivateKey pk : stepaPrivateKeys)
    stepaPublicKeys.add(pk.getPublicKey());
  for (PrivateKey pk : martyPrivateKeys)
    martyPublicKeys.add(pk.getPublicKey());
  Contract notaryContract = ContractsService.createNotaryContract(martyPrivateKeys, stepaPublicKeys);
  notaryContract.check();
  notaryContract.traceErrors();
  assertTrue(notaryContract.isOk());
  assertTrue(notaryContract.getOwner().isAllowedForKeys(stepaPublicKeys));
  assertTrue(notaryContract.getIssuer().isAllowedForKeys(martyPrivateKeys));
  assertTrue(notaryContract.getCreator().isAllowedForKeys(martyPrivateKeys));
  assertFalse(notaryContract.getOwner().isAllowedForKeys(martyPrivateKeys));
  assertFalse(notaryContract.getIssuer().isAllowedForKeys(stepaPublicKeys));
  assertFalse(notaryContract.getCreator().isAllowedForKeys(stepaPublicKeys));
  assertTrue(notaryContract.getExpiresAt().isAfter(ZonedDateTime.now().plusMonths(3)));
  assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now()));
  assertTrue(notaryContract.isPermitted("revoke", stepaPublicKeys));
  assertTrue(notaryContract.isPermitted("revoke", martyPublicKeys));
  assertTrue(notaryContract.isPermitted("change_owner", stepaPublicKeys));
  assertFalse(notaryContract.isPermitted("change_owner", martyPublicKeys));
}

assertTrue(shareContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(shareContract.getCreator().isAllowedForKeys(issuerPrivateKeys));
assertFalse(shareContract.getIssuer().isAllowedForKeys(ownerPublicKeys));
assertFalse(shareContract.getCreator().isAllowedForKeys(ownerPublicKeys));

assertTrue(tokenContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(tokenContract.getCreator().isAllowedForKeys(issuerPrivateKeys));
assertFalse(tokenContract.getIssuer().isAllowedForKeys(ownerPublicKeys));
assertFalse(tokenContract.getCreator().isAllowedForKeys(ownerPublicKeys));

contract2.getIssuer().addRequiredReference(reference, Role.RequiredMode.ALL_OF);

newContractRef.setConditions(Binder.of("all_of",revokeCondtitions));
newContract.addReference(newContractRef);
newContract.getIssuer().addRequiredReference("ref1", Role.RequiredMode.ALL_OF);
newContract.seal();
rootReference.setConditions(Binder.of("all_of",rootConditions));
transactionRoot.addReference(rootReference);
transactionRoot.getIssuer().addRequiredReference("ref1", Role.RequiredMode.ALL_OF);
transactionRoot.seal();
transactionRoot.getTransactionPack().addReferencedItem(referencedContract2);

newReference.setConditions(Binder.of("all_of",newConditions));
newContract.addReference(newReference);
newContract.getIssuer().addRequiredReference(newReference.getName(), Role.RequiredMode.ALL_OF);
newContract.seal();

rootReference.setConditions(Binder.of("all_of",rootConditions));
transactionRoot.addReference(rootReference);
transactionRoot.getIssuer().addRequiredReference("ref1", Role.RequiredMode.ALL_OF);
transactionRoot.seal();
transactionRoot.getTransactionPack().addReferencedItem(referencedContract2);