*/
    public File getOriginalFile(long contextId, InstrumentationArtifactMetadata metadata) {
        String hash = metadata.getArtifactHash();
        String artifactName = metadata.getArtifactName();
        return checkNotNull(getResolutionData(contextId).getOriginalFile(metadata.getArtifactHash()),
            "Original file for artifact with name '%s' and hash '%s' does not exist! " +

            Set<String> artifactConfigurations = depArtifact.getConfigurations();
            if (include(artifactConfigurations, includedConfigurations)) {
                IvyArtifactName ivyArtifactName = depArtifact.getArtifactName();
                artifacts.add(ivyArtifactName);
            }
        }
        return artifacts.build();
    }

            consumerBuildPath,
            consumerProjectPath,
            componentId,
            sourceAttributes,
            targetAttributes,
            capabilities,
            artifact.getArtifactName().getDisplayName(),
            upstreamDependencies.getConfigurationIdentity(),
            transformStepNodeId
        );
    }

            return ComponentToOperationConverter.convertComponentIdentifier(componentIdentifier);
        }

        @Override
        public String getArtifactName() {
            return inputArtifact.getName();
        }

        @Override
        public Class<?> getTransformActionClass() {
            return transform.getImplementationClass();
        }

        encoder.writeSmallInt(artifacts.size());
        for (Artifact artifact : artifacts) {
            IvyArtifactNameSerializer.INSTANCE.write(encoder, artifact.getArtifactName());
            writeStringSet(encoder, artifact.getConfigurations());
        }
    }

    private SetMultimap<String, String> readDependencyConfigurationMapping(Decoder decoder) throws IOException {

                                    return true;
                                }

                                @Override
                                public IvyArtifactName getArtifactName() {
                                    return DefaultIvyArtifactName.forFile(file, null);
                                }

                                @Override

            writeArtifactVerification(verification);
        }
    }

    private void writeArtifactVerification(ArtifactVerificationMetadata verification) throws IOException {
        String artifact = verification.getArtifactName();
        writer.startElement(ARTIFACT);
        writeAttribute(NAME, artifact);
        writeTrustedKeys(verification.getTrustedPgpKeys());
        writeIgnoredKeys(verification.getIgnoredPgpKeys());

            for (ArtifactVerificationMetadata verification : verifications) {
                String verifiedArtifact = verification.getArtifactName();
                if (verifiedArtifact.equals(foundArtifactFileName)) {
                    if (signature == null) {
                        // There is no signature file or verify-signature=false

                        .stream()
                        .map(ComponentVerificationsBuilder::toArtifactVerification)
                        .sorted(Comparator.comparing(ArtifactVerificationMetadata::getArtifactName))
                        .collect(Collectors.toList())
                );
            } catch (InvalidGpgKeyIdsException ex) {
                throw new ComponentVerificationException(component, ex::formatMessage);

            writeCount(artifacts.size());
            for (Artifact artifact : artifacts) {
                IvyArtifactNameSerializer.INSTANCE.write(encoder, artifact.getArtifactName());
                writeStringSet(artifact.getConfigurations());
            }
        }

        private void writeIvyDependencies(List<IvyDependencyDescriptor> dependencies) throws IOException {