Function decodeLiteral has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

export function* decodeLiteral(
  dataType: Format.Types.Type,
  pointer: Pointer.StackLiteralPointer,
  info: Evm.EvmInfo
): Generator<DecoderRequest, Format.Values.Result, Uint8Array | null> {

• Read up
  Read up

Function deriveConfigEnvironment has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

const deriveConfigEnvironment = function (detectedConfig, network, url) {
  let configuredNetwork;

  const configDefinesProvider =
    detectedConfig.networks[network] &&

Function exports has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

module.exports = async function (options) {
  const Config = require("@truffle/config");
  const ConfigurationError = require("../../errors/configurationerror");
  const create = require("./helpers");

Function exports has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

module.exports = async options => {
  const TruffleError = require("@truffle/error");
  const { Plugins } = require("@truffle/plugins");
  const { getConfig, constructRecipes } = require("./plugins");
  const { preserve, ConsoleReporter } = require("@truffle/preserve");

Function readStorage has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function* readStorage(
  pointer: Pointer.StoragePointer,
  state: Evm.EvmState
): Generator<DecoderRequest, Uint8Array, Uint8Array | null> {
  const { storage } = state;

Function process has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function* process(options: {
  relationship: "ancestor" | "descendant";
  network: IdObject<"networks">;
  alreadyTried: string[];
  disableIndex?: boolean;

Function forAttachAndSchema has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export const forAttachAndSchema = <C extends Collections>(options: {
  attach: (options: Pouch.Adapters.AttachOptions) => Workspace<C>;
  schema: GraphQLSchema;
}) => {
  const { attach, schema } = options;

Function decodeDispatch has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function* decodeDispatch(
  dataType: Format.Types.Type,
  pointer: Pointer.DataPointer,
  info: Evm.EvmInfo,
  options: DecoderOptions = {}

Function forContract has 43 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export function forContract(contract: any): CompiledContract {
  const {
    contractName,
    contract_name,
    sourcePath,

Function _ has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        (scopes, scope, pointer, sourceId, language) => {
          let variables = {};
          if (scope !== undefined) {
            let cur =
              scope.id !== undefined ? scope.id : makePath(sourceId, pointer);

Function exports has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

module.exports = async function (options) {
  const TruffleError = require("@truffle/error");
  const WorkflowCompile = require("@truffle/workflow-compile").default;
  const Config = require("@truffle/config");
  const config = Config.detect(options);

Function execVyper has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function execVyper(options, sourcePath, version, callback) {
  const formats = ["abi", "bytecode", "bytecode_runtime"];
  debug("version: %s", version);
  if (
    semver.satisfies(version, ">=0.1.0-beta.7", {

Function exports has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

module.exports = async function (selectedCommand, subCommand, options) {
  const commands = require("../index");
  const globalCommandOptions = require("../../global-command-options");
  const TruffleError = require("@truffle/error");

Function decodeReturnValueWithAdditionalContexts has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  public async decodeReturnValueWithAdditionalContexts(
    abi: Abi.FunctionEntry,
    data: string,
    options: DecoderTypes.ReturnOptions = {},
    additionalContexts: Contexts.Contexts = {}

Function constructor has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  constructor(info: Types.EncoderInfoInternal) {
    //first, set up the basic info that we need to run
    if (info.userDefinedTypes && info.allocations) {
      debug("internal route!");
      this.userDefinedTypes = info.userDefinedTypes;

Function decodeMessage has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export async function decodeMessage(
  lifecycle: ReceivedMessageLifecycle<DashboardProviderMessage>,
  decoder: ProjectDecoder
) {
  const method = lifecycle.message.payload.method as DecodableRpcMethod;

Function handleCompilations has 42 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async (compilations: Compilation[], hashes?: string[]) => {
      if (compilations.length === 0 || !stateRef.current.decoder) return;

      let decoderNeedsUpdate = false;
      const decoderCompilations = [...stateRef.current.decoderCompilations!];

Consider simplifying this complex logical expression.

Open

        if (
          isContextChange ||
          !node ||
          node.id === undefined ||
          !next ||

Consider simplifying this complex logical expression.

Open

    if (
      decoding.kind === "function" &&
      (decoding.abi.name === "aggregate" ||
        decoding.abi.name === "blockAndAggregate") &&
      decoding.abi.inputs.length === 1 &&

Consider simplifying this complex logical expression.

Open

    } else if (
      decoding.kind === "function" &&
      decoding.abi.name === "aggregate3" &&
      decoding.abi.inputs.length === 1 &&
      decoding.abi.inputs[0].type === "tuple[]" &&