congrats Icon
New! Announcing our next generation AI code completions
Read here
Tabnine Logo
Contract.getOwner
Code IndexAdd Tabnine to your IDE (free)

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

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

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
List l =
  • Codota Iconnew ArrayList()
  • Codota Iconnew LinkedList()
  • Smart code suggestions by Tabnine
}
origin: UniversaBlockchain/universa

public JSApiRole getOwner() {
  return JSApiRole.createJSApiRole(this.currentContract.getOwner());
}
origin: UniversaBlockchain/universa

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;
origin: UniversaBlockchain/universa

Role owner = contract.getOwner();
if (owner.isAllowedForKeys(getSealedByKeys()))
  return true;
origin: UniversaBlockchain/universa

boolean willBeMine = c.getOwner().isAllowedForKeys(keys);
origin: UniversaBlockchain/universa

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;
}
origin: UniversaBlockchain/universa

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));
origin: UniversaBlockchain/universa

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));
origin: UniversaBlockchain/universa

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));
}
origin: UniversaBlockchain/universa

@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;
}
origin: UniversaBlockchain/universa

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()));
origin: UniversaBlockchain/universa

boolean willBeMine = c.getOwner().isAllowedForKeys(publicKeys);
boolean willBeNotMine = (!c.getOwner().isAllowedForKeys(publicKeys));
origin: UniversaBlockchain/universa

@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()));
}
origin: UniversaBlockchain/universa

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));
origin: UniversaBlockchain/universa

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());
origin: UniversaBlockchain/universa

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));
origin: UniversaBlockchain/universa

@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));
}
origin: UniversaBlockchain/universa

@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());
}
origin: UniversaBlockchain/universa

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

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

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);
com.icodici.universa.contractContractgetOwner

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
  • createRevision,
  • fromDslFile,
  • fromPackedTransaction,
  • getCreatedAt,
  • getDefinition,
  • getErrors,
  • getKeysToSignWith,
  • getLastSealedBinary,
  • getNew,
  • getNewItems

Popular in Java

  • Updating database using SQL prepared statement
  • addToBackStack (FragmentTransaction)
  • onCreateOptionsMenu (Activity)
  • startActivity (Activity)
  • URI (java.net)
    A Uniform Resource Identifier that identifies an abstract or physical resource, as specified by RFC
  • MessageDigest (java.security)
    Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
  • DateFormat (java.text)
    Formats or parses dates and times.This class provides factories for obtaining instances configured f
  • DecimalFormat (java.text)
    A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features desig
  • Collections (java.util)
    This class consists exclusively of static methods that operate on or return collections. It contains
  • Reflections (org.reflections)
    Reflections one-stop-shop objectReflections scans your classpath, indexes the metadata, allows you t
  • Top 25 Plugins for Webstorm
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now