com.icodici.universa.contract.Contract.getOwner java code examples

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

if(!(contract.getOwner() instanceof ListRole)) {
  return false;
ListRole owner = (ListRole) contract.getOwner();
if(owner.getQuorum() == 0 || owner.getQuorum() < owner.getRoles().size()-1) {
  return false;
Set<PublicKey> ownerKeys = contract.getOwner().getKeys();
if(contractNodes.size() != ownerKeys.size() || !contractNodes.stream().allMatch(nodeInfo -> nodeInfo instanceof NodeInfo && ownerKeys.contains(((NodeInfo)nodeInfo).getPublicKey()))) {
  return false;
    if(!(permission.getRole() instanceof RoleLink) || ((RoleLink)permission.getRole()).getRole() != contract.getOwner())
      return false;
      if(!(permission.getRole() instanceof RoleLink) || ((RoleLink)permission.getRole()).getRole() != contract.getOwner())
        return false;

Role owner = contract.getOwner();
if (owner.isAllowedForKeys(getSealedByKeys()))
  return true;

boolean willBeMine = c.getOwner().isAllowedForKeys(keys);

public synchronized Contract finishSwap_wrongKey(Contract swapContract, Set<PrivateKey> keys, PrivateKey wrongKey) {
  List<Contract> swappingContracts = (List<Contract>) swapContract.getNew();
  // looking for contract that will be own
  for (Contract c : swappingContracts) {
    boolean willBeMine = c.getOwner().isAllowedForKeys(keys);
    System.out.println("willBeMine: " + willBeMine + " " + c.getSealedByKeys().size());
    if(willBeMine) {
      c.addSignatureToSeal(wrongKey);
    }
  }
  swapContract.seal();
  return swapContract;
}

System.out.println("DeLorean revoked ownership was belongs to Marty: " + delorean.getOwner().isAllowedForKeys(martyPublicKeys));
assertEquals(ItemState.REVOKED, deloreanResult.state);
System.out.println("Lamborghini revoked ownership was belongs to Stepa: " + lamborghini.getOwner().isAllowedForKeys(stepaPublicKeys));
assertEquals(ItemState.REVOKED, lamborghiniResult.state);
System.out.println("DeLorean ownership is now belongs to Stepa: " + newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys));
assertEquals(ItemState.APPROVED, deloreanResult.state);
assertTrue(newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys));
System.out.println("Lamborghini ownership is now belongs to Marty: " + newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys));
assertEquals(ItemState.APPROVED, lamborghiniResult.state);
assertTrue(newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys));

System.out.println("DeLorean revoked ownership still belongs to Marty: " + delorean.getOwner().isAllowedForKeys(martyPublicKeys));
assertEquals(ItemState.APPROVED, deloreanResult.state);
System.out.println("Lamborghini revoked ownership still belongs to Stepa: " + lamborghini.getOwner().isAllowedForKeys(stepaPublicKeys));
assertEquals(ItemState.APPROVED, lamborghiniResult.state);
System.out.println("DeLorean ownership should belongs to Stepa: " + newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys));
assertEquals(ItemState.UNDEFINED, deloreanResult.state);
assertTrue(newDelorean.getOwner().isAllowedForKeys(stepaPublicKeys));
System.out.println("Lamborghini ownership should belongs to Marty: " + newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys));
assertEquals(ItemState.UNDEFINED, lamborghiniResult.state);
assertTrue(newLamborghini.getOwner().isAllowedForKeys(martyPublicKeys));

public void prepareContractsForSwap(
    Set<PrivateKey> martyPrivateKeys,
    Set<PublicKey> martyPublicKeys,
    Set<PrivateKey> stepaPrivateKeys,
    Set<PublicKey> stepaPublicKeys,
    Contract delorean,
    Contract lamborghini) throws Exception {
  martyPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/marty_mcfly.private.unikey")));
  for (PrivateKey pk : martyPrivateKeys) {
    martyPublicKeys.add(pk.getPublicKey());
  }
  stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey")));
  for (PrivateKey pk : stepaPrivateKeys) {
    stepaPublicKeys.add(pk.getPublicKey());
  }
  PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(ROOT_PATH + "_xer0yfe2nn1xthc.private.unikey"));
  delorean.addSignerKey(manufacturePrivateKey);
  delorean.seal();
  System.out.println("DeLorean ownership contract is valid: " + delorean.check());
  delorean.traceErrors();
  registerAndCheckApproved(delorean);
  System.out.println("DeLorean ownership is belongs to Marty: " + delorean.getOwner().isAllowedForKeys(martyPublicKeys));
  lamborghini.addSignerKey(manufacturePrivateKey);
  lamborghini.seal();
  System.out.println("Lamborghini ownership contract is valid: " + lamborghini.check());
  lamborghini.traceErrors();
  registerAndCheckApproved(lamborghini);
  System.out.println("Lamborghini ownership is belongs to Stepa: " + lamborghini.getOwner().isAllowedForKeys(stepaPublicKeys));
}

@Override
public boolean beforeUpdate(ImmutableEnvironment c) {
  boolean checkResult = false;
  // recalculate storing info without saving to state to get valid storing data
  calculatePrepaidKilobytesForDays(false);
  // check that payment was not hacked
  checkResult = prepaidKilobytesForDays == getStateData().getInt(PREPAID_KD_FIELD_NAME, 0);
  if(!checkResult) {
    addError(Errors.FAILED_CHECK, "Wrong [state.data." + PREPAID_KD_FIELD_NAME + "] value. " +
        "Should be sum of early paid U and paid U by current revision.");
    return checkResult;
  }
  if(getTrackingContract() != null) {
    // check for that last revision of tracking contract has same owner as creator of slot
    checkResult = getTrackingContract().getOwner().isAllowedForKeys(getEffectiveKeys());
    if (!checkResult) {
      addError(Errors.FAILED_CHECK, "Slot-contract signing keys must has allowed keys for owner of tracking contract");
      return checkResult;
    }
  }
  // and call common slot check
  checkResult = additionallySlotCheck(c);
  return checkResult;
}

Contract contract1 = CLIMain.loadContract(basePath + "forRoleAnonymizing1_anonymized.unicon", true);
assertFalse(contract1.getOwner().getKeys().contains(ownerKey.getPublicKey()));
assertFalse(contract1.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(contract1.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract1.getOwner().getKeys().contains(ownerKey.getPublicKey()));
assertFalse(anonPublishedContract1.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract1.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(contract2.getOwner().getKeys().contains(ownerKey.getPublicKey()));
assertFalse(contract2.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(contract2.getCreator().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract2.getOwner().getKeys().contains(ownerKey.getPublicKey()));
assertFalse(anonPublishedContract2.getIssuer().getKeys().contains(key.getPublicKey()));
assertFalse(anonPublishedContract2.getCreator().getKeys().contains(key.getPublicKey()));

boolean willBeMine = c.getOwner().isAllowedForKeys(publicKeys);
boolean willBeNotMine = (!c.getOwner().isAllowedForKeys(publicKeys));

@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()));
}

assertTrue(anonAfterSend.getOwner().getKeyAddresses().iterator().next().equals(stepaAddress));
assertEquals(0, anonAfterSend.getOwner().getKeys().size());
assertEquals(0, afterSend.getOwner().getKeyAddresses().size());
assertTrue(afterSend.getOwner().isAllowedForKeys(martyPublicKeys));

assertTrue(c.check());
assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract());
Role cOwner = c.getOwner();
assertTrue (cOwner.isAllowedForKeys(new HashSet<>(Do.listOf(ownerKey1))));
assertTrue (!cOwner.isAllowedForKeys(new HashSet<>(Do.listOf(ownerKey2))));
assertNotEquals(c.getOwner(), c1.getOwner());
c1.seal();
c1.check();
assertEquals(c.getOwner(), ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getRole());
assertEquals(c2, ((RoleLink) c2.getPermissions().getFirst("change_owner").getRole()).getContract());
assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract());
c2.setOwnerKey(ownerKey3);
assertNotEquals(c.getOwner(), c2.getOwner());
assertEquals(c.getOwner(), ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getRole());

notaryContract.traceErrors();
assertTrue(notaryContract.getOwner().isAllowedForKeys(ownerPublicKeys));
assertTrue(notaryContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(notaryContract.getCreator().isAllowedForKeys(issuerPrivateKeys));
assertFalse(notaryContract.getOwner().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));
}

@Test
public void getStateWithNoLedgerCache() throws Exception {
  TestSpace testSpace = prepareTestSpace(TestKeys.privateKey(0));
  testSpace.nodes.forEach(m -> m.config.setIsFreeRegistrationsAllowedFromYaml(true));
  testSpace.nodes.forEach(m -> ((PostgresLedger)m.node.getLedger()).enableCache(false));
  //SHUTDOWN LAST NODE
  testSpace.nodes.remove(testSpace.nodes.size()-1).shutdown();
  Thread.sleep(4000);
  Contract rev1 = new Contract(TestKeys.privateKey(0));
  rev1.getStateData().set("field1", 33);
  Permission permission = new ChangeNumberPermission(rev1.getOwner(), Binder.of("field_name", "field1"));
  rev1.addPermission(permission);
  rev1.seal();
  ItemResult ir1 = testSpace.client.register(rev1.getPackedTransaction(), 5000);
  assertEquals(ItemState.APPROVED, ir1.state);
  Contract rev2 = rev1.createRevision();
  rev2.getStateData().set("field1", 34);
  rev2.addSignerKey(TestKeys.privateKey(0));
  rev2.seal();
  ItemResult ir2 = testSpace.client.register(rev2.getPackedTransaction(), 5000);
  assertEquals(ItemState.APPROVED, ir2.state);
  ir1 = testSpace.client.register(rev1.getPackedTransaction(), 5000);
  assertEquals(ItemState.REVOKED, ir1.state);
  testSpace.nodes.forEach(m -> m.shutdown());
}

checkResult = getTrackingContract().getOwner().isAllowedForKeys(getEffectiveKeys());
if (!checkResult) {
  addError(Errors.FAILED_CHECK, "Slot-contract signing keys must has allowed keys for owner of tracking contract");

ModifyDataPermission perm = new ModifyDataPermission(contract.getOwner(), new Binder());
perm.addField("test_value", Arrays.asList("0", "1"));
contract.addPermission(perm);

permParams.set("max_step", 1);
permParams.set("field_name", "test_value");
ChangeNumberPermission perm = new ChangeNumberPermission(contract.getOwner(), permParams);
contract.addPermission(perm);
contract.getStateData().set("test_value", 11);

Javadoc

Get owner role

Popular methods of Contract

<init>
Extract old, deprecated v2 self-contained binary partially unpacked by the TransactionPack, and fill
addNewItems
Add one or more siblings to the contract. Note that those must be sealed before calling #seal() or #
addSignerKey
Add private key to keys contract binary to be signed with when sealed next time. It is called before
getExpiresAt
Get contract expiration time
getId
Get the id sealing self if need
getPackedTransaction
Pack the contract to the most modern .unicon format, same as TransactionPack#pack(). Uses bounded Tr
registerRole
Register new role. Name must be unique otherwise existing role will be overwritten
seal
Seal contract to binary. This call adds signatures from #getKeysToSignWith()
addSignatureToSeal
Add signature to sealed (before) contract. Do not deserializing or changing contract bytes, but will
check
createRevision
Create new revision to be changed, signed sealed and then ready to approve. Created "revision" contr
fromDslFile
Create contract importing its parameters with passed .yaml file. No signatures are added automatical

Popular in Java

Making http post requests using okhttp
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
getSharedPreferences (Context)
startActivity (Activity)
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
Callable (java.util.concurrent)
A task that returns a result and may throw an exception. Implementors define a single method with no
Notification (javax.management)
IOUtils (org.apache.commons.io)
General IO stream manipulation utilities. This class provides static utility methods for input/outpu
Project (org.apache.tools.ant)
Central representation of an Ant project. This class defines an Ant project with all of its targets,
Top plugins for WebStorm

How to use getOwnermethodin com.icodici.universa.contract.Contract

Best Java code snippets using com.icodici.universa.contract.Contract.getOwner (Showing top 20 results out of 315)

How to use
getOwner
method
in
com.icodici.universa.contract.Contract