String longIdKey = toLongIdHexString(pgpSignature.getKeyID());
                if (ignoredKeys.contains(longIdKey)) {
                    result.ignored(longIdKey);
                    continue;
                }
                AtomicBoolean missing = new AtomicBoolean(true);
                keyService.findByLongId(pgpSignature.getKeyID(), new PublicKeyResultBuilder() {
                    @Override

    public PgpKeyId(long keyId) {
        asLong = keyId;
        asHex = toHex(keyId);
    }

    public PgpKeyId(PGPPublicKey keyId) {
        this(keyId.getKeyID());
    }

    public PgpKeyId(PGPSignature signature) {
        this(signature.getKeyID());
    }

    public PgpKeyId(String keyId) {
        asLong = toLong(keyId);
        asHex = toHex(asLong);
    }

    @Override

                            Fingerprint fingerprint = Fingerprint.of(key);
                            keyToKeyringBuilder.put(fingerprint, keyring);
                            longIdLongPGPPublicKeyBuilder.put(key.getKeyID(), keyring);
                        }
                    }
                    keys = new LoadedKeys(ImmutableMap.copyOf(keyToKeyringBuilder), longIdLongPGPPublicKeyBuilder.build());

    boolean checkAndMarkSatisfiedBy(DependencyVerificationConfiguration.TrustedKey trustedKey) {
        if (!trustedKeys.contains(trustedKey.getKeyId())) {
            return false;
        }
        boolean matches = trustedKey.matches(id);
        if (matches) {
            keyDeclaredGlobally(trustedKey.getKeyId());
        }
        return matches;
    }

        } catch (PGPException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    @Override
    public String getKeyId() {
        PgpKeyId id = new PgpKeyId(secretKey.getKeyID());
        return id.getAsHex();
    }

    private void feedGeneratorWith(InputStream toSign, PGPSignatureGenerator generator) throws IOException {
        byte[] buffer = new byte[1024];

    private final String reason;

    public IgnoredKey(String keyId, @Nullable String reason) {
        this.keyId = keyId.toUpperCase(Locale.ROOT);
        this.reason = reason;
    }

    public String getKeyId() {
        return keyId;
    }

    @Nullable
    public String getReason() {
        return reason;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

     */
    byte[] sign(InputStream toSign);

    /**
     * Returns the id of the key that will be used for signing.
     *
     * @return The key id
     */
    @Input
    @Optional
    String getKeyId();

                for (PGPSecretKeyRing keyring : new JcaPGPSecretKeyRingCollection(in)) {
                    for (PGPSecretKey key : keyring) {
                        if (expectedKeyId.equals(new PgpKeyId(key.getKeyID()))) {
                            return factory.createSignatory(name, key, password);
                        }
                    }
                }
            }
            return null;

            }
        }
        args.add("--no-tty");
        args.add("--batch");
        args.add("--detach-sign");
        return args;
    }

    @Override
    public String getKeyId() {
        return keyName;
    }

     */
    private void findMatchingKey(long id, PGPPublicKeyRing keyRing, PublicKeyResultBuilder builder) {
        for (PGPPublicKey publicKey : keyRing) {
            if (publicKey.getKeyID() == id) {
                builder.publicKey(publicKey);
                return;
            }
        }
    }

    /**
     * A response was sent from the server. This is a keyring, we need to find