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)

  • Common ways to obtain Contract
private void myMethod () {
 Contract c =
  • Codota Iconnew Contract()
  • Codota IconString fileName;Contract.fromDslFile(fileName)
  • Codota IconParcel parcel;parcel.getPaymentContract()
  • Smart code suggestions by Tabnine
}
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

  • Running tasks concurrently on multiple threads
  • getOriginalFilename (MultipartFile)
    Return the original filename in the client's filesystem.This may contain path information depending
  • getSharedPreferences (Context)
  • onCreateOptionsMenu (Activity)
  • Date (java.util)
    A specific moment in time, with millisecond precision. Values typically come from System#currentTime
  • Map (java.util)
    A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
  • Collectors (java.util.stream)
  • Stream (java.util.stream)
    A sequence of elements supporting sequential and parallel aggregate operations. The following exampl
  • ImageIO (javax.imageio)
  • Scheduler (org.quartz)
    This is the main interface of a Quartz Scheduler. A Scheduler maintains a registry of org.quartz.Job
Tabnine Logo

  • Products

    Search for Java codeSearch for JavaScript code

  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter

  • Company

    About UsContact UsCareers

  • Resources

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