Examples with Errors com.icodici.universa.Errors used on opensource projects

Example 1 with Errors

use of com.icodici.universa.Errors in project universa by UniversaBlockchain.

the class Contract method addError.

/**
 * Add error to contract
 * @param code error code
 * @param field path to contract field error found in
 * @param text error message
 */
@Override
public void addError(Errors code, String field, String text) {
    Errors code1 = code;
    String field1 = field;
    String text1 = text;
    errors.add(new ErrorRecord(code1, field1, text1));
}

Example 2 with Errors

use of com.icodici.universa.Errors in project universa by UniversaBlockchain.

the class Contract method verifySealedKeys.

/**
 * Verify signatures in sealed contract (if needed) and forms a map of sealed keys.
 * Errors found can be accessed with {@link #getErrors()}
 *
 * @param isQuantise if needed quantisation verifying signatures
 * @throws Quantiser.QuantiserException when quantas limit was reached during check
 */
public void verifySealedKeys(boolean isQuantise) throws Quantiser.QuantiserException {
    if (sealedBinary == null)
        return;
    if (!isNeedVerifySealedKeys) {
        if (isQuantise)
            // Add key verify quanta again (we just reset quantiser)
            for (PublicKey key : sealedByKeys.keySet()) if (key != null)
                verifySignatureQuantized(key);
        return;
    }
    Binder data = Boss.unpack(sealedBinary);
    if (!data.getStringOrThrow("type").equals("unicapsule"))
        throw new IllegalArgumentException("wrong object type, unicapsule required");
    List signatures = (List) data.getOrThrow("signatures");
    if (signatures.size() == 0)
        return;
    byte[] contractBytes = data.getBinaryOrThrow("data");
    // fill sealedByKeys from signatures matching with roles
    HashMap<Bytes, PublicKey> keys = new HashMap<Bytes, PublicKey>();
    Consumer<Role> extractKeys = role -> {
        RoleExtractor.extractKeys(role).forEach(key -> keys.put(ExtendedSignature.keyId(key), key));
        RoleExtractor.extractAnonymousIds(role).forEach(anonId -> {
            getTransactionPack().getKeysForPack().forEach(key -> {
                try {
                    if (key.matchAnonymousId(anonId.getBytes())) {
                        keys.put(ExtendedSignature.keyId(key), key);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        });
        RoleExtractor.extractKeyAddresses(role).forEach(keyAddr -> {
            getTransactionPack().getKeysForPack().forEach(key -> {
                try {
                    if (key.isMatchingKeyAddress(keyAddr)) {
                        keys.put(ExtendedSignature.keyId(key), key);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        });
    };
    roles.values().forEach(extractKeys);
    state.roles.values().forEach(extractKeys);
    // verify signatures
    for (Object signature : 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) {
            if (isQuantise)
                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");
        }
    }
    isNeedVerifySealedKeys = false;
}