324 lines
9.4 KiB
JavaScript
324 lines
9.4 KiB
JavaScript
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;
|