Tabnine Logo
Contract.createTransactionalSection
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: UniversaBlockchain/universa

/**
 * Binder to hold any data client might want to keep per one transaction.
 * @return data {@link Binder} from transactional section
 */
public Binder getTransactionalData() {
  if (transactional == null)
    createTransactionalSection();
  return transactional.getData();
}
origin: UniversaBlockchain/universa

executor.addRequiredReference(executorRef, Role.RequiredMode.ALL_OF);
payment.createTransactionalSection();
payment.getTransactional().setId(HashId.createRandom().toBase64String());
origin: UniversaBlockchain/universa

consent.addPermission(new RevokePermission(ownerLink));
consent.addPermission(new ChangeOwnerPermission(ownerLink));
consent.createTransactionalSection();
consent.getTransactional().setId(HashId.createRandom().toBase64String());
consent.seal();
  source.createTransactionalSection();
origin: UniversaBlockchain/universa

twoSignContract.createTransactionalSection();
twoSignContract.getTransactional().setId(HashId.createRandom().toBase64String());
origin: UniversaBlockchain/universa

  nc = c;
nc.createTransactionalSection();
nc.getTransactional().setId(HashId.createRandom().toBase64String());
newContracts1.add(nc);
  nc = c;
nc.createTransactionalSection();
nc.getTransactional().setId(HashId.createRandom().toBase64String());
newContracts2.add(nc);
origin: UniversaBlockchain/universa

  /**
   * Creates special contract to set unlimited requests for the {@link PublicKey}.
   * The base limit is 30 per minute (excludes registration requests).
   * Unlimited requests for 5 minutes cost 5 U.
   * Register result contract by {@link com.icodici.universa.node2.network.Client#register(byte[])}.
   *
   * @param key is key for setting unlimited requests
   * @param payment is approved contract with "U" belongs to you
   * @param amount is number of "U" you want to spend to set unlimited requests for key; get by {@link Config#getRateLimitDisablingPayment()}
   * @param keys is own private keys, which are set as owner of payment contract
   * @return contract for setting unlimited requests to key
   */
  public synchronized static Contract createRateLimitDisablingContract(PublicKey key, Contract payment, int amount, Set<PrivateKey> keys) {

    Contract unlimitContract = payment.createRevision(keys);

    unlimitContract.createTransactionalSection();
    unlimitContract.getTransactional().setId(HashId.createRandom().toBase64String());
    unlimitContract.getTransactional().getData().set("unlimited_key", key.pack());

    unlimitContract.getStateData().set("transaction_units", payment.getStateData().getIntOrThrow("transaction_units") - amount);
    unlimitContract.seal();

    return unlimitContract;
  }
}
origin: UniversaBlockchain/universa

@Test(timeout = 90000)
public void transactionalValidUntil_good() throws Exception {
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  Set<PublicKey> stepaPublicKeys = new HashSet<>();
  stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey")));
  for (PrivateKey pk : stepaPrivateKeys) {
    stepaPublicKeys.add(pk.getPublicKey());
  }
  Contract stepaCoins = Contract.fromDslFile(ROOT_PATH + "stepaCoins.yml");
  if (stepaCoins.getTransactional() == null)
    stepaCoins.createTransactionalSection();
  stepaCoins.getTransactional().setValidUntil(ZonedDateTime.now().plusSeconds(Config.validUntilTailTime.getSeconds()*2).toEpochSecond());
  stepaCoins.addSignerKey(stepaPrivateKeys.iterator().next());
  stepaCoins.seal();
  stepaCoins.check();
  stepaCoins.traceErrors();
  Parcel parcel = createParcelWithFreshU(stepaCoins, stepaPrivateKeys);
  assertTrue(parcel.getPayloadContract().isOk());
  node.registerParcel(parcel);
  node.waitParcel(parcel.getId(), 8000);
  assertEquals(ItemState.APPROVED, node.waitItem(parcel.getPayment().getContract().getId(), 8000).state);
  assertEquals(ItemState.APPROVED, node.waitItem(parcel.getPayload().getContract().getId(), 8000).state);
}
origin: UniversaBlockchain/universa

@Test(timeout = 90000)
public void transactionalValidUntil_timeEnds() throws Exception {
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  Set<PublicKey> stepaPublicKeys = new HashSet<>();
  stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey")));
  for (PrivateKey pk : stepaPrivateKeys) {
    stepaPublicKeys.add(pk.getPublicKey());
  }
  Contract stepaCoins = Contract.fromDslFile(ROOT_PATH + "stepaCoins.yml");
  if (stepaCoins.getTransactional() == null)
    stepaCoins.createTransactionalSection();
  stepaCoins.getTransactional().setValidUntil(ZonedDateTime.now().plusSeconds(Config.validUntilTailTime.getSeconds()/2).toEpochSecond());
  stepaCoins.addSignerKey(stepaPrivateKeys.iterator().next());
  stepaCoins.seal();
  stepaCoins.check();
  stepaCoins.traceErrors();
  Parcel parcel = createParcelWithFreshU(stepaCoins, stepaPrivateKeys);
  assertFalse(parcel.getPayloadContract().isOk());
  node.registerParcel(parcel);
  node.waitParcel(parcel.getId(), 8000);
  assertEquals(ItemState.APPROVED, node.waitItem(parcel.getPayment().getContract().getId(), 8000).state);
  assertEquals(ItemState.DECLINED, node.waitItem(parcel.getPayload().getContract().getId(), 8000).state);
}
origin: UniversaBlockchain/universa

@Test(timeout = 90000)
public void transactionalValidUntil_timeIsOver() throws Exception {
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  Set<PublicKey> stepaPublicKeys = new HashSet<>();
  stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey")));
  for (PrivateKey pk : stepaPrivateKeys) {
    stepaPublicKeys.add(pk.getPublicKey());
  }
  Contract stepaCoins = Contract.fromDslFile(ROOT_PATH + "stepaCoins.yml");
  if (stepaCoins.getTransactional() == null)
    stepaCoins.createTransactionalSection();
  stepaCoins.getTransactional().setValidUntil(ZonedDateTime.now().plusMonths(-1).toEpochSecond());
  stepaCoins.addSignerKey(stepaPrivateKeys.iterator().next());
  stepaCoins.seal();
  stepaCoins.check();
  stepaCoins.traceErrors();
  Parcel parcel = createParcelWithFreshU(stepaCoins, stepaPrivateKeys);
  assertFalse(parcel.getPayloadContract().isOk());
  node.registerParcel(parcel);
  node.waitParcel(parcel.getId(), 8000);
  assertEquals(ItemState.APPROVED, node.waitItem(parcel.getPayment().getContract().getId(), 8000).state);
  assertEquals(ItemState.DECLINED, node.waitItem(parcel.getPayload().getContract().getId(), 8000).state);
}
origin: UniversaBlockchain/universa

  @Test
  public void checkTransactional() throws Exception {

    PrivateKey manufacturePrivateKey = new PrivateKey(Do.read(rootPath + "_xer0yfe2nn1xthc.private.unikey"));

    Contract delorean = Contract.fromDslFile(rootPath + "DeLoreanOwnership.yml");
    delorean.addSignerKey(manufacturePrivateKey);
    delorean.seal();
    delorean.traceErrors();

    Contract.Transactional transactional = delorean.createTransactionalSection();
    Reference reference = new Reference();
//        reference.setName("transactional_example");
    transactional.addReference(reference);
    Contract deloreanTransactional = delorean.createRevision(transactional);
    deloreanTransactional.addSignerKey(manufacturePrivateKey);
    deloreanTransactional.seal();
    deloreanTransactional.traceErrors();

  }

origin: UniversaBlockchain/universa

Contract.Transactional transactional1 = newContract1.createTransactionalSection();
transactional1.setId(HashId.createRandom().toBase64String());
Contract.Transactional transactional2 = newContract2.createTransactionalSection();
transactional2.setId(HashId.createRandom().toBase64String());
origin: UniversaBlockchain/universa

parcel.getPaymentContract().createTransactionalSection();
parcel.getPaymentContract().getTransactional().setId(HashId.createRandom().toBase64String());
parcel.getPaymentContract().getTransactional().getData().set("var", 1);
origin: UniversaBlockchain/universa

contract.addSignerKey(key);
contract.createTransactionalSection();
contract.getTransactional().setId(HashId.createRandom().toBase64String());
com.icodici.universa.contractContractcreateTransactionalSection

Javadoc

Create new transactional section for 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
  • setContentView (Activity)
  • getExternalFilesDir (Context)
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • ResultSet (java.sql)
    An interface for an object which represents a database table entry, returned as the result of the qu
  • Date (java.util)
    A specific moment in time, with millisecond precision. Values typically come from System#currentTime
  • Iterator (java.util)
    An iterator over a sequence of objects, such as a collection.If a collection has been changed since
  • 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
  • SortedMap (java.util)
    A map that has its keys ordered. The sorting is according to either the natural ordering of its keys
  • Semaphore (java.util.concurrent)
    A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if
  • From CI to AI: The AI layer in your organization
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