trufflesuite/truffle

import debugModule from "debug";
const debug = debugModule("debugger:data:reducers");

import { combineReducers } from "redux";

import * as actions from "./actions";

import * as Codec from "@truffle/codec";
import { makeAssignment, makePath } from "lib/helpers";

const DEFAULT_SCOPES = {
  bySourceId: {}
};

function scopes(state = DEFAULT_SCOPES, action) {
  switch (action.type) {
    case actions.SCOPE: {
      const { sourceId, id, sourceIndex, parentId, pointer } = action;
      const astRef = id !== undefined ? id : makePath(sourceIndex, pointer);
      //astRef is used throughout the data saga.
      //it identifies an AST node within a given compilation either by:
      //1. its ast ID, if it has one, or
      //2. a combination of its source index and its JSON pointer if not

      return {
        bySourceId: {
          ...state.bySourceId,
          [sourceId]: {
            byAstRef: {
              ...(state.bySourceId[sourceId] || {}).byAstRef,
              [astRef]: {
                ...(state.bySourceId[sourceId] || { byAstRef: {} }).byAstRef[
                  astRef
                ],
                id,
                parentId,
                sourceIndex,
                pointer,
                sourceId
              }
            }
          }
        }
      };
    }

    case actions.DECLARE: {
      let { sourceId, name, astRef, scopeAstRef } = action;

      //note: we can assume the scope already exists!
      let scope = state.bySourceId[sourceId].byAstRef[scopeAstRef];
      let variables = scope.variables || [];

      return {
        bySourceId: {
          ...state.bySourceId,
          [sourceId]: {
            byAstRef: {
              ...state.bySourceId[sourceId].byAstRef,
              [scopeAstRef]: {
                ...scope,
                variables: [...variables, { name, astRef, sourceId }]
              }
            }
          }
        }
      };
    }

    default:
      return state;
  }
}

//yes, this is just a flat array as that's what's convenient
function userDefinedTypes(state = [], action) {
  switch (action.type) {
    case actions.DEFINE_TYPE:
      debug("action: %O", action);
      return [...state, { id: action.node.id, sourceId: action.sourceId }];
    default:
      return state;
  }
}

//just going to treat this like userDefinedTypes
function taggedOutputs(state = [], action) {
  switch (action.type) {
    case actions.DEFINE_TAGGED_OUTPUT:
      return [...state, { id: action.node.id, sourceId: action.sourceId }];
    default:
      return state;
  }
}

const DEFAULT_ALLOCATIONS = {
  storage: {},
  memory: {},
  abi: {},
  calldata: {},
  returndata: {},
  event: {},
  state: {}
};

function allocations(state = DEFAULT_ALLOCATIONS, action) {
  if (action.type === actions.ALLOCATE) {
    debug("action: %O", action);
    return {
      storage: action.storage,
      memory: action.memory,
      abi: action.abi,
      calldata: action.calldata,
      returndata: action.returndata,
      event: action.event,
      state: action.state
    };
  } else {
    return state; //not to be confused with action.state!
  }
}

const DEFAULT_CONTRACTS = {
  byCompilationId: {}
};

function contracts(state = DEFAULT_CONTRACTS, action) {
  if (action.type === actions.ADD_CONTRACTS) {
    //NOTE: this code assumes that we are only ever adding compilations
    //wholesale, and never adding to existing ones!
    return {
      byCompilationId: {
        ...state.byCompilationId,
        ...Object.assign(
          {},
          ...Object.entries(action.contracts).map(
            ([compilationId, compilation]) => ({
              [compilationId]: {
                byAstId: compilation
              }
            })
          )
        )
      }
    };
  } else {
    return state;
  }
}

const info = combineReducers({
  scopes,
  contracts,
  userDefinedTypes,
  taggedOutputs,
  allocations
});

const GLOBAL_ASSIGNMENTS = [
  [{ builtin: "msg" }, { location: "special", special: "msg" }],
  [{ builtin: "tx" }, { location: "special", special: "tx" }],
  [{ builtin: "block" }, { location: "special", special: "block" }],
  [{ builtin: "this" }, { location: "special", special: "this" }],
  [{ builtin: "now" }, { location: "special", special: "timestamp" }] //we don't have an alias "now"
].map(([idObj, ref]) => makeAssignment(idObj, ref));

const DEFAULT_ASSIGNMENTS = {
  byId: Object.assign(
    {}, //we start out with all globals assigned
    ...GLOBAL_ASSIGNMENTS.map(assignment => ({ [assignment.id]: assignment }))
  )
};

function assignments(state = DEFAULT_ASSIGNMENTS, action) {
  switch (action.type) {
    case actions.ASSIGN:
    case actions.MAP_PATH_AND_ASSIGN:
      debug("action.type %O", action.type);
      debug("action.assignments %O", action.assignments);
      return {
        byId: {
          ...state.byId,
          ...action.assignments
        }
      };

    case actions.RESET:
      return DEFAULT_ASSIGNMENTS;

    default:
      return state;
  }
}

const DEFAULT_PATHS = {
  byAddress: {}
};

//WARNING: do *not* rely on mappedPaths to keep track of paths that do not
//involve mapping keys!  Yes, many will get mapped, but there is no guarantee.
//Only when mapping keys are involved does it necessarily work reliably --
//which is fine, as that's all we need it for.
function mappedPaths(state = DEFAULT_PATHS, action) {
  switch (action.type) {
    case actions.MAP_PATH_AND_ASSIGN:
      let { address, slot, typeIdentifier, parentType } = action;
      //how this case works: first, we find the spot in our table (based on
      //address, type identifier, and slot address) where the new entry should
      //be added; if needed we set up all the objects needed along the way.  If
      //there's already something there, we do nothing.  If there's nothing
      //there, we record our given slot in that spot in that table -- however,
      //we alter it in one key way.  Before entry, we check if the slot's
      //*parent* has a spot in the table, based on address (same for both child
      //and parent), parentType, and the parent's slot address (which can be
      //found as the slotAddress of the slot's path object, if it exists -- if
      //it doesn't then we conclude that no the parent does not have a spot in
      //the table).  If the parent has a slot in the table already, then we
      //alter the child slot by replacing its path with the parent slot.  This
      //will keep the slotAddress the same, but since the versions kept in the
      //table here are supposed to preserve path information, we'll be
      //replacing a fairly bare-bones Slot object with one with a full path.

      //we do NOT want to distinguish between types with and without "_ptr" on
      //the end here! (or _slice)
      debug("typeIdentifier %s", typeIdentifier);
      typeIdentifier = Codec.Ast.Utils.regularizeTypeIdentifier(typeIdentifier);
      parentType = Codec.Ast.Utils.regularizeTypeIdentifier(parentType);

      debug("slot %o", slot);
      let hexSlotAddress = Codec.Conversion.toHexString(
        Codec.Storage.Utils.slotAddress(slot),
        Codec.Evm.Utils.WORD_SIZE
      );
      let parentAddress = slot.path
        ? Codec.Conversion.toHexString(
            Codec.Storage.Utils.slotAddress(slot.path),
            Codec.Evm.Utils.WORD_SIZE
          )
        : undefined;

      //this is going to be messy and procedural, sorry.  but let's start with
      //the easy stuff: create the new address if needed, clone if not
      let newState = {
        ...state,
        byAddress: {
          ...state.byAddress,
          [address]: {
            byType: {
              ...(state.byAddress[address] || { byType: {} }).byType
            }
          }
        }
      };

      //now, let's add in the new type, if needed
      newState.byAddress[address].byType = {
        ...newState.byAddress[address].byType,
        [typeIdentifier]: {
          bySlotAddress: {
            ...(
              newState.byAddress[address].byType[typeIdentifier] || {
                bySlotAddress: {}
              }
            ).bySlotAddress
          }
        }
      };

      let oldSlot =
        newState.byAddress[address].byType[typeIdentifier].bySlotAddress[
          hexSlotAddress
        ];
      //yes, this looks strange, but we haven't changed it yet except to
      //clone or create empty (and we don't want undefined!)
      //now: is there something already there or no?  if no, we must add
      if (oldSlot === undefined) {
        let newSlot;
        debug("parentAddress %o", parentAddress);
        if (
          parentAddress !== undefined &&
          newState.byAddress[address].byType[parentType] &&
          newState.byAddress[address].byType[parentType].bySlotAddress[
            parentAddress
          ]
        ) {
          //if the parent is already present, use that instead of the given
          //parent!
          newSlot = {
            ...slot,
            path: newState.byAddress[address].byType[parentType].bySlotAddress[
              parentAddress
            ]
          };
        } else {
          newSlot = slot;
        }
        newState.byAddress[address].byType[typeIdentifier].bySlotAddress[
          hexSlotAddress
        ] = newSlot;
      }
      //if there's already something there, we don't need to do anything

      return newState;

    case actions.RESET:
      return DEFAULT_PATHS;

    default:
      return state;
  }
}

const proc = combineReducers({
  assignments,
  mappedPaths
});

const reducer = combineReducers({
  info,
  proc
});

export default reducer;