trufflesuite/truffle

Identical blocks of code found in 2 locations. Consider refactoring.

Open

    try {
      return {
        compile: options =>
          String(execSync(command, { input: options, maxBuffer })),
        version: () => versionString

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export type Mutation<
  C extends Collections,
  M extends MutationName<C> = MutationName<C>
> = {
  [K in M]: K extends keyof CollectionMutation<C>

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

export type Query<
  C extends Collections,
  Q extends QueryName<C> = QueryName<C>
> = {
  [K in Q]: K extends keyof CollectionQuery<C> ? CollectionQuery<C>[K] : never;

• Read up
  Read up

File adapter.ts has 258 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import debugModule from "debug";
const debug = debugModule("decoder:adapter");
import type { BlockSpecifier } from "@truffle/codec";
import type BN from "bn.js";
import type {

File VersionRange.ts has 257 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import debugModule from "debug";
const debug = debugModule("compile:compilerSupplier");

import requireFromString from "require-from-string";

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

Open

              ...Object.entries(scopes).map(([id, scope]) => {
                let definition = inlined[id].definition;
                if (definition.nodeType === "ContractDefinition") {
                  //contract definition case: process inheritance
                  debug("contract id %d", id);

Function start has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  start: async function (context, web3Error) {
    const constructor = this;
    let currentBlock = override.defaultMaxBlocks;

    // Reject after attempting to get reason string if we shouldn't be waiting.

Function link has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  link: async function (library, destinations, deployer) {
    let eventArgs;
    let libraryName = library.contractName;
    if (libraryName == null && library.constructor) {
      //allow for the possibility that library is an instance rather

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

Open

module.exports = async options => {
  const { Develop } = require("@truffle/environment");
  const Config = require("@truffle/config");

  const config = Config.detect(options);

Function decodeVariable has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  private async decodeVariable(
    variable: Storage.Allocate.StateVariableAllocation,
    block: RegularizedBlockSpecifier
  ): Promise<DecoderTypes.StateVariable> {
    const info: Codec.Evm.EvmInfo = {

Identical blocks of code found in 3 locations. Consider refactoring.

Open

        <C.Container
          prefix={<mark style={{ backgroundColor: "cyan" }}>prefix</mark>}
          suffix={<mark style={{ backgroundColor: "magenta" }}>suffix</mark>}
          empty={false}
        >

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

        <C.Container
          prefix={<mark style={{ backgroundColor: "cyan" }}>prefix</mark>}
          suffix={<mark style={{ backgroundColor: "magenta" }}>suffix</mark>}
          empty={false}
        >

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

        <C.Container
          prefix={<mark style={{ backgroundColor: "cyan" }}>prefix</mark>}
          suffix={<mark style={{ backgroundColor: "magenta" }}>suffix</mark>}
          empty={false}
        >

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public async wrap(
    dataType: Codec.Format.Types.Type,
    input: unknown
  ): Promise<Codec.Format.Values.Value> {
    return await this.projectEncoder.wrap(dataType, input);

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public async wrapElementaryValue(
    dataType: Codec.Format.Types.ElementaryType,
    input: unknown
  ): Promise<Codec.Format.Values.ElementaryValue> {
    return await this.contractEncoder.wrapElementaryValue(dataType, input);

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public async wrapElementaryValue(
    dataType: Codec.Format.Types.ElementaryType,
    input: unknown
  ): Promise<Codec.Format.Values.ElementaryValue> {
    return await this.projectEncoder.wrapElementaryValue(dataType, input);

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

  public async wrap(
    dataType: Codec.Format.Types.Type,
    input: unknown
  ): Promise<Codec.Format.Values.Value> {
    return await this.contractEncoder.wrap(dataType, input);

• Read up
  Read up

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

Open

export function* process(options: {
  networks: (Pick<Resource<"networks">, "id" | "historicBlock"> | undefined)[];
  settings?: {
    disableIndex?: boolean;
  };

Identical blocks of code found in 5 locations. Consider refactoring.

Open

  private async interpretAggregate(
    decoding: Codec.CalldataDecoding,
    transaction: DecoderTypes.Transaction,
    additionalContexts: Contexts.Contexts = {},
    additionalAllocations?: {

• Read up
  Read up

Identical blocks of code found in 5 locations. Consider refactoring.

Open

  private async interpretMulticall(
    decoding: Codec.CalldataDecoding,
    transaction: DecoderTypes.Transaction,
    additionalContexts: Contexts.Contexts = {},
    additionalAllocations?: {

• Read up
  Read up