Public

Extract old, deprecated v2 self-contained binary partially unpacked by the
TransactionPack, and fill

<init>

Add one or more siblings to the contract. Note that those must be sealed before
calling #seal() or #

addNewItems

Add private key to keys contract binary to be signed with when sealed next time.
It is called before

addSignerKey

getExpiresAt

getId

Pack the contract to the most modern .unicon format, same as
TransactionPack#pack(). Uses bounded Tr

getPackedTransaction

Register new role. Name must be unique otherwise existing role will be
overwritten

registerRole

Seal contract to binary. This call adds signatures from #getKeysToSignWith()

seal

Add signature to sealed (before) contract. Do not deserializing or changing
contract bytes, but will

addSignatureToSeal

check

Create new revision to be changed, signed sealed and then ready to approve.
Created "revision" contr

createRevision

Create contract importing its parameters with passed .yaml file. No signatures
are added automatical

fromDslFile

Main .unicon read routine. Load any .unicon version and construct a linked
Contract with counterpart

fromPackedTransaction

getCreatedAt

getDefinition

Get list of errors found during contract check

getErrors

Get private keys contract binary to be signed with when sealed next time. It is
called before seal()

getKeysToSignWith

Get last sealed binary or create it if there is not

getLastSealedBinary

Get contracts current contract creates upon registration

getNew

Get contracts to be registered within current contract registration.

getNewItems

Contract

Making http requests using okhttp

java.awt.Menu

Prints formatted representations of objects to a text-output stream. This class
implements all of th

java.io.PrintWriter

This class generates cryptographically secure pseudo-random numbers. It is best
to invoke SecureRand

java.security.SecureRandom

A connection represents a link from a Java application to a database. All SQL
statements and results

java.sql.Connection

A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each
#acquire blocks if 

java.util.concurrent.Semaphore

A filter is an object that performs filtering tasks on either the request to a
resource (a servlet o

javax.servlet.Filter

getSystemService

Return the contained value, if present, otherwise throw an exception to be
created by the provided s

orElseThrow

setContentView

/**
     * Import contract from specified yaml, xml or json file.
     *
     * @param sourceName
     *
     * @return loaded and from loaded data created Contract.
     */

//            usage("Path " + sourceName + " does not exist");

/**
     * Extract old, deprecated v2 self-contained binary partially unpacked by the {@link TransactionPack}, and fill the
     * transaction pack with its contents. This contsructor also fills transaction pack instance with the new and
     * revoking items included in its body in v2.
     *
     * @param sealed binary sealed contract
     * @param data   unpacked sealed data (it is ready by the time of calling it)
     * @param pack is {@link TransactionPack} for contract was sent with
     *
     * @throws IOException on the various format errors
     */

// debug const. need to get quantaLimit from TransactionPack here

"This constructor requires version 2, got version "

// This must be explained. By default, Boss.load will apply contract transformation in place

// as it is registered BiSerializable type, and we want to avoid it. Therefore, we decode boss

// data without BiSerializer and then do it by hand calling deserialize:

// if exist siblings for contract (more then itself)

// fill references with contracts from TransactionPack

/*if (transactional != null && transactional.references != null) {
            for(Reference ref : transactional.references) {
                ref.setContract(this);
                references.put(ref.name, ref);
            }
        }
        if (definition != null && definition.references != null) {
            for(Reference ref : definition.references) {
                ref.setContract(this);
                references.put(ref.name, ref);
            }
        }
        if (state != null && state.references != null){
            for(Reference ref : state.references) {
                ref.setContract(this);
                references.put(ref.name, ref);
            }
        }

        for(Reference ref : getReferences().values()) {

            Set<Contract> referencedContracts = new HashSet<>(pack.getReferencedItems().values());
            for(Approvable a : getNewItems()) {
                if (a instanceof Contract) {
                    referencedContracts.add((Contract) a);
                }
            }

            for(Contract c : pack.getReferencedItems().values()) {
                if(ref.isMatchingWith(c, referencedContracts)) {
                    ref.addMatchingItem(c);
                }
            }

            for(Approvable a : getNewItems()) {
                if(a instanceof Contract) {
                    Contract c = (Contract) a;
                    if (ref.isMatchingWith(c, referencedContracts)) {
                        ref.addMatchingItem(c);
                    }
                }
            }
        }

        // fill sealedByKeys from signatures matching with roles

        HashMap<Bytes, PublicKey> keys = new HashMap<Bytes, PublicKey>();

        roles.values().forEach(role -> {
            role.getKeys().forEach(key -> keys.put(ExtendedSignature.keyId(key), key));
            role.getAnonymousIds().forEach(anonId -> {
                transactionPack.getKeysForPack().forEach(
                        key -> {
                            try {
                                if(key.matchAnonymousId(anonId.getBytes())) {
                                    keys.put(ExtendedSignature.keyId(key), key);
                                }
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                );
            });
            role.getKeyAddresses().forEach(keyAddr -> {
                transactionPack.getKeysForPack().forEach(
                        key -> {
                            try {
                                if(key.isMatchingKeyAddress(keyAddr)) {
                                    keys.put(ExtendedSignature.keyId(key), key);
                                }
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                );
            });
        });

        for (Object signature : (List) data.getOrThrow("signatures")) {
            byte[] s = ((Bytes) signature).toArray();
            PublicKey key = ExtendedSignature.extractPublicKey(s);
            if (key == null) {
                Bytes keyId = ExtendedSignature.extractKeyId(s);
                key = keys.get(keyId);
            }
            if (key != null) {
                verifySignatureQuantized(key);
                ExtendedSignature es = ExtendedSignature.verify(key, s, contractBytes);
                if (es != null) {
                    sealedByKeys.put(key, es);
                } else
                    addError(Errors.BAD_SIGNATURE, "keytag:" + key.info().getBase64Tag(), "the signature is broken");
            }
        }*/

/**
     * Extract contract from v2 or v3 sealed form, getting revoking and new items from sealed unicapsule and referenced items from
     * the transaction pack supplied.
     * <p>
     * It is recommended to call {@link #check()} after construction to see the errors.
     *
     * @param sealed binary sealed contract.
     * @param pack   the transaction pack to resolve dependeincise agains.
     *
     * @throws IOException on the various format errors
     */

// Legacy format: revoking and new items are included (so the contract pack grows)

// new format: only references are included

//                    System.out.println("Revoking item was not found in the transaction pack");

"Revoking item was not found in the transaction pack"

//                    System.out.println("New item was not found in the transaction pack");

"New item was not found in the transaction pack"

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

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

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