congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
Contract.getIssuer
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: UniversaBlockchain/universa

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

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

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

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

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

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

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

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

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

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

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

reference.type = Reference.TYPE_TRANSACTIONAL;
reference.transactional_id = consent.getTransactional().getId();
reference.signed_by.add(consent.getIssuer());
origin: UniversaBlockchain/universa

assertTrue(notaryContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(notaryContract.getCreator().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

assertTrue(shareContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(shareContract.getCreator().isAllowedForKeys(issuerPrivateKeys));
assertFalse(shareContract.getIssuer().isAllowedForKeys(ownerPublicKeys));
assertFalse(shareContract.getCreator().isAllowedForKeys(ownerPublicKeys));
origin: UniversaBlockchain/universa

assertTrue(tokenContract.getIssuer().isAllowedForKeys(issuerPrivateKeys));
assertTrue(tokenContract.getCreator().isAllowedForKeys(issuerPrivateKeys));
assertFalse(tokenContract.getIssuer().isAllowedForKeys(ownerPublicKeys));
assertFalse(tokenContract.getCreator().isAllowedForKeys(ownerPublicKeys));
origin: UniversaBlockchain/universa

contract2.getIssuer().addRequiredReference(reference, Role.RequiredMode.ALL_OF);
origin: UniversaBlockchain/universa

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

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

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

Javadoc

Get issuer of the contract

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

  • Parsing JSON documents to java classes using gson
  • getExternalFilesDir (Context)
  • getSupportFragmentManager (FragmentActivity)
  • runOnUiThread (Activity)
  • Table (com.google.common.collect)
    A collection that associates an ordered pair of keys, called a row key and a column key, with a sing
  • IOException (java.io)
    Signals a general, I/O-related error. Error details may be specified when calling the constructor, a
  • KeyStore (java.security)
    KeyStore is responsible for maintaining cryptographic keys and their owners. The type of the syste
  • HashMap (java.util)
    HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
  • Notification (javax.management)
  • DataSource (javax.sql)
    An interface for the creation of Connection objects which represent a connection to a database. This
  • Best IntelliJ plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

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