6589

pending completion

Build # 6589

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #2696 from trufflesuite/fix-phantoms

Add workaround to remove phantom stackframes

Run Details

2013 of 3116 branches covered (64.6%)

Branch coverage included in aggregate %.

54 of 54 new or added lines in 6 files covered. (100.0%)

5946 of 7870 relevant lines covered (75.55%)

109287.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.62

/packages/debugger/lib/evm/selectors/index.js

import debugModule from "debug";
const debug = debugModule("debugger:evm:selectors"); // eslint-disable-line no-unused-vars

import { createSelectorTree, createLeaf } from "reselect-tree";
import BN from "bn.js";

import trace from "lib/trace/selectors";

import * as Codec from "@truffle/codec";
import {
  isCallMnemonic,
  isCreateMnemonic,
  isShortCallMnemonic,
  isDelegateCallMnemonicBroad,
  isDelegateCallMnemonicStrict,
  isStaticCallMnemonic,
  isNormalHaltingMnemonic
} from "lib/helpers";

function determineFullContext(
  { address, binary },
  instances,
  search,
  contexts
) {
  let contextId;
  let isConstructor = Boolean(binary);
  if (address) {
    //if we're in a call to a deployed contract, we must have recorded
    //the context in the codex, so we don't need to do any further
    //searching
    ({ context: contextId, binary } = instances[address]);
  } else if (isConstructor) {
    //otherwise, if we're in a constructor, we'll need to actually do a
    //search
    contextId = search(binary);
  } else {
    //exceptional case: no transaction is loaded
    return null;
  }

  if (contextId != undefined) {
    //if we found the context, use it
    let context = contexts[contextId];
    return {
      ...context,
      binary
    };
  } else {
    //otherwise we'll construct something default
    return {
      binary,
      isConstructor
    };
  }
}

/**
 * create EVM-level selectors for a given trace step selector
 * may specify additional selectors to include
 */
function createStepSelectors(step, state = null) {
  let base = {
    /**
     * .trace
     *
     * trace step info related to operation
     */
    trace: createLeaf([step], step => {
      if (!step) {
        return null;
      }
      let { gasCost, op, pc } = step;
      return { gasCost, op, pc };
    }),

    /**
     * .programCounter
     */
    programCounter: createLeaf(["./trace"], step => (step ? step.pc : null)),

    /**
     * .isJump
     */
    isJump: createLeaf(
      ["./trace"],
      step => step.op != "JUMPDEST" && step.op.indexOf("JUMP") == 0
    ),

    /**
     * .isCall
     *
     * whether the opcode will switch to another calling context
     */
    isCall: createLeaf(["./trace"], step => isCallMnemonic(step.op)),

    /**
     * .isShortCall
     *
     * for calls that only take 6 arguments instead of 7
     */
    isShortCall: createLeaf(["./trace"], step => isShortCallMnemonic(step.op)),

    /**
     * .isDelegateCallBroad
     *
     * for calls that delegate storage
     */
    isDelegateCallBroad: createLeaf(["./trace"], step =>
      isDelegateCallMnemonicBroad(step.op)
    ),

    /**
     * .isDelegateCallStrict
     *
     * for calls that additionally delegate sender and value
     */
    isDelegateCallStrict: createLeaf(["./trace"], step =>
      isDelegateCallMnemonicStrict(step.op)
    ),

    /**
     * .isStaticCall
     */
    isStaticCall: createLeaf(["./trace"], step =>
      isStaticCallMnemonic(step.op)
    ),

    /**
     * .isCreate
     */
    isCreate: createLeaf(["./trace"], step => isCreateMnemonic(step.op)),

    /**
     * .isHalting
     *
     * whether the instruction halts or returns from a calling context
     * NOTE: this covers only ordinary halts, not exceptional halts;
     * but it doesn't check the return status, so any normal halting
     * instruction will qualify here
     */
    isHalting: createLeaf(["./trace"], step =>
      isNormalHaltingMnemonic(step.op)
    ),

    /*
     * .isStore
     */
    isStore: createLeaf(["./trace"], step => step.op == "SSTORE"),

    /*
     * .isLoad
     */
    isLoad: createLeaf(["./trace"], step => step.op == "SLOAD"),

    /*
     * .touchesStorage
     *
     * whether the instruction involves storage
     */
    touchesStorage: createLeaf(
      ["./isStore", "isLoad"],
      (stores, loads) => stores || loads
    )
  };

  if (state) {
    const isRelative = path =>
      typeof path == "string" &&
      (path.startsWith("./") || path.startsWith("../"));

    if (isRelative(state)) {
      state = `../${state}`;
    }

    Object.assign(base, {
      /**
       * .callAddress
       *
       * address transferred to by call operation
       */
      callAddress: createLeaf(
        ["./isCall", state],

        (isCall, { stack }) => {
          if (!isCall) {
            return null;
          }

          let address = stack[stack.length - 2];
          return Codec.Evm.Utils.toAddress(address);
        }
      ),

      /**
       * .createBinary
       *
       * binary code to execute via create operation
       */
      createBinary: createLeaf(
        ["./isCreate", state],

        (isCreate, { stack, memory }) => {
          if (!isCreate) {
            return null;
          }

          // Get the code that's going to be created from memory.
          // Note we multiply by 2 because these offsets are in bytes.
          const offset = parseInt(stack[stack.length - 2], 16) * 2;
          const length = parseInt(stack[stack.length - 3], 16) * 2;

          return "0x" + memory.join("").substring(offset, offset + length);
        }
      ),

      /**
       * .callData
       *
       * data passed to EVM call
       */
      callData: createLeaf(
        ["./isCall", "./isShortCall", state],
        (isCall, short, { stack, memory }) => {
          if (!isCall) {
            return null;
          }

          //if it's 6-argument call, the data start and offset will be one spot
          //higher in the stack than they would be for a 7-argument call, so
          //let's introduce an offset to handle this
          let argOffset = short ? 1 : 0;

          // Get the data from memory.
          // Note we multiply by 2 because these offsets are in bytes.
          const offset = parseInt(stack[stack.length - 4 + argOffset], 16) * 2;
          const length = parseInt(stack[stack.length - 5 + argOffset], 16) * 2;

          return "0x" + memory.join("").substring(offset, offset + length);
        }
      ),

      /**
       * .callValue
       *
       * value for the call (not create); returns null for DELEGATECALL
       */
      callValue: createLeaf(
        ["./isCall", "./isDelegateCallStrict", "./isStaticCall", state],
        (calls, delegates, isStatic, { stack }) => {
          if (!calls || delegates) {
            return null;
          }

          if (isStatic) {
            return new BN(0);
          }

          //otherwise, for CALL and CALLCODE, it's the 3rd argument
          let value = stack[stack.length - 3];
          return Codec.Conversion.toBN(value);
        }
      ),

      /**
       * .createValue
       *
       * value for the create
       */
      createValue: createLeaf(["./isCreate", state], (isCreate, { stack }) => {
        if (!isCreate) {
          return null;
        }

        //creates have the value as the first argument
        let value = stack[stack.length - 1];
        return Codec.Conversion.toBN(value);
      }),

      /**
       * .storageAffected
       *
       * storage slot being stored to or loaded from
       * we do NOT prepend "0x"
       */
      storageAffected: createLeaf(
        ["./touchesStorage", state],

        (touchesStorage, { stack }) => {
          if (!touchesStorage) {
            return null;
          }

          return stack[stack.length - 1];
        }
      ),

      /**
       * .callContext
       *
       * context of what this step is calling/creating (if applicable)
       */
      callContext: createLeaf(
        [
          "./callAddress",
          "./createBinary",
          "/current/codex/instances",
          "/info/binaries/search",
          "/info/contexts"
        ],
        (address, binary, instances, search, contexts) =>
          determineFullContext({ address, binary }, instances, search, contexts)
      )
    });
  }

  return base;
}

const evm = createSelectorTree({
  /**
   * evm.state
   */
  state: state => state.evm,

  /**
   * evm.info
   */
  info: {
    /**
     * evm.info.contexts
     */
    contexts: createLeaf(["/state"], state => state.info.contexts.byContext),

    /**
     * evm.info.binaries
     */
    binaries: {
      /**
       * evm.info.binaries.search
       *
       * returns function (binary) => context (returns the *ID* of the context)
       * (returns null on no match)
       */
      search: createLeaf(["/info/contexts"], contexts => binary =>
        Codec.Contexts.Utils.findDebuggerContext(contexts, binary)
      )
    }
  },

  /**
   * evm.transaction
   */
  transaction: {
    /*
     * evm.transaction.globals
     */
    globals: {
      /*
       * evm.transaction.globals.tx
       */
      tx: createLeaf(["/state"], state => state.transaction.globals.tx),
      /*
       * evm.transaction.globals.block
       */
      block: createLeaf(["/state"], state => state.transaction.globals.block)
    },

    /*
     * evm.transaction.status
     */
    status: createLeaf(["/state"], state => state.transaction.status),

    /*
     * evm.transaction.initialCall
     */
    initialCall: createLeaf(["/state"], state => state.transaction.initialCall),

    /*
     * evm.transaction.startingContext
     */
    startingContext: createLeaf(
      [
        "/current/callstack", //we're just getting bottom stackframe, so this is in fact tx-level
        "/current/codex/instances", //this should also be fine?
        "/info/binaries/search",
        "/info/contexts"
      ],
      (stack, instances, search, contexts) =>
        stack.length > 0
          ? determineFullContext(stack[0], instances, search, contexts)
          : null
    )
  },

  /**
   * evm.current
   */
  current: {
    /**
     * evm.current.callstack
     */
    callstack: state => state.evm.proc.callstack,

    /**
     * evm.current.call
     */
    call: createLeaf(
      ["./callstack"],

      stack => (stack.length ? stack[stack.length - 1] : {})
    ),

    /**
     * evm.current.context
     */
    context: createLeaf(
      [
        "./call",
        "./codex/instances",
        "/info/binaries/search",
        "/info/contexts"
      ],
      determineFullContext
    ),

    /**
     * evm.current.state
     *
     * evm state info: as of last operation, before op defined in step
     */
    state: Object.assign(
      {},
      ...["depth", "error", "gas", "memory", "stack", "storage"].map(param => ({
        [param]: createLeaf([trace.step], step => step[param])
      }))
    ),

    /**
     * evm.current.step
     */
    step: {
      ...createStepSelectors(trace.step, "./state"),

      //the following step selectors only exist for current, not next or any
      //other step

      /*
       * evm.current.step.createdAddress
       *
       * address created by the current create step
       */
      createdAddress: createLeaf(
        ["./isCreate", "/nextOfSameDepth/state/stack"],
        (isCreate, stack) => {
          if (!isCreate) {
            return null;
          }
          let address = stack[stack.length - 1];
          return Codec.Evm.Utils.toAddress(address);
        }
      ),

      /**
       * evm.current.step.isInstantCallOrReturn
       *
       * are we doing a call or create for which there are no trace steps?
       * This can happen if:
       * 1. we call a precompile
       * 2. we call an externally-owned account
       * 3. we do a call or create but the call stack is exhausted
       * 4. we attempt to transfer more ether than we have
       */
      isInstantCallOrCreate: createLeaf(
        ["./isCall", "./isCreate", "/current/state/depth", "/next/state/depth"],
        (calls, creates, currentDepth, nextDepth) =>
          (calls || creates) && currentDepth === nextDepth
      ),

      /**
       * evm.current.step.isContextChange
       * groups together calls, creates, halts, and exceptional halts
       */
      isContextChange: createLeaf(
        ["/current/state/depth", "/next/state/depth"],
        (currentDepth, nextDepth) => currentDepth !== nextDepth
      ),

      /**
       * evm.current.step.isExceptionalHalting
       */
      isExceptionalHalting: createLeaf(
        [
          "./isHalting",
          "/current/state/depth",
          "/next/state/depth",
          "./returnStatus"
        ],
        (halting, currentDepth, nextDepth, status) =>
          halting
            ? !status //if deliberately halting, check the return status
            : nextDepth < currentDepth //if not on a deliberate halt, any halt
        //is an exceptional halt
      ),

      /**
       * evm.current.step.returnStatus
       * checks the return status of the *current* halting instruction (for
       * normal halts only)
       * (returns a boolean -- true for success, false for failure)
       */
      returnStatus: createLeaf(
        [
          "./isHalting",
          "/next/state",
          trace.stepsRemaining,
          "/transaction/status"
        ],
        (isHalting, { stack }, remaining, finalStatus) => {
          if (!isHalting) {
            return null; //not clear this'll do much good since this may get
            //read as false, but, oh well, may as well
          }
          if (remaining <= 1) {
            return finalStatus;
          } else {
            const ZERO_WORD = "00".repeat(Codec.Evm.Utils.WORD_SIZE);
            return stack[stack.length - 1] !== ZERO_WORD;
          }
        }
      ),

      /*
       * evm.current.step.returnValue
       *
       * for a [successful] RETURN or REVERT instruction, the value returned;
       * we DO prepend "0x"
       * for everything else, including unsuccessful RETURN, just returns "0x"
       * (which is what the return value would be if the instruction were to
       * fail) (or succeed in the case of STOP or SELFDESTRUCT)
       * NOTE: technically this will be wrong if a REVERT fails, but that case
       * is hard to detect and it barely matters
       */
      returnValue: createLeaf(
        ["./trace", "./isExceptionalHalting", "../state"],

        (step, isExceptionalHalting, { stack, memory }) => {
          if (step.op !== "RETURN" && step.op !== "REVERT") {
            return "0x";
          }
          if (isExceptionalHalting && step.op !== "REVERT") {
            return "0x";
          }
          // Get the data from memory.
          // Note we multiply by 2 because these offsets are in bytes.
          const offset = parseInt(stack[stack.length - 1], 16) * 2;
          const length = parseInt(stack[stack.length - 2], 16) * 2;

          return "0x" + memory.join("").substring(offset, offset + length);
        }
      )
    },

    /**
     * evm.current.codex (namespace)
     */
    codex: {
      /**
       * evm.current.codex (selector)
       * the whole codex! not that that's very much at the moment
       */
      _: createLeaf(["/state"], state => state.proc.codex),

      /**
       * evm.current.codex.storage
       * the current storage, as fetched from the codex... unless we're in a
       * failed creation call, then we just fall back on the state (which will
       * work, since nothing else can interfere with the storage of a failed
       * creation call!)
       */
      storage: createLeaf(
        ["./_", "../state/storage", "../call"],
        (codex, rawStorage, { storageAddress }) =>
          storageAddress === Codec.Evm.Utils.ZERO_ADDRESS
            ? rawStorage //HACK -- if zero address ignore the codex
            : codex[codex.length - 1].accounts[storageAddress].storage
      ),

      /*
       * evm.current.codex.instances
       */
      instances: createLeaf(["./_"], codex =>
        Object.assign(
          {},
          ...Object.entries(codex[codex.length - 1].accounts).map(
            ([address, { code, context }]) => ({
              [address]: { address, binary: code, context }
            })
          )
        )
      )
    }
  },

  /**
   * evm.next
   */
  next: {
    /**
     * evm.next.state
     *
     * evm state as a result of next step operation
     */
    state: Object.assign(
      {},
      ...["depth", "error", "gas", "memory", "stack", "storage"].map(param => ({
        [param]: createLeaf([trace.next], step => step[param])
      }))
    ),

    /*
     * evm.next.step
     */
    step: createStepSelectors(trace.next, "./state")
  },

  /**
   * evm.nextOfSameDepth
   */
  nextOfSameDepth: {
    /**
     * evm.nextOfSameDepth.state
     *
     * evm state at the next step of same depth
     */
    state: Object.assign(
      {},
      ...["depth", "error", "gas", "memory", "stack", "storage"].map(param => ({
        [param]: createLeaf([trace.nextOfSameDepth], step => step[param])
      }))
    )
  }
});

export default evm;

1	import debugModule from "debug";	2✔
2	const debug = debugModule("debugger:evm:selectors"); // eslint-disable-line no-unused-vars	2✔
3
4	import { createSelectorTree, createLeaf } from "reselect-tree";	2✔
5	import BN from "bn.js";	2✔
6
7	import trace from "lib/trace/selectors";	2✔
8
9	import * as Codec from "@truffle/codec";	2✔
10	import {	2✔
11	isCallMnemonic,
12	isCreateMnemonic,
13	isShortCallMnemonic,
14	isDelegateCallMnemonicBroad,
15	isDelegateCallMnemonicStrict,
16	isStaticCallMnemonic,
17	isNormalHaltingMnemonic
18	} from "lib/helpers";
19
20	function determineFullContext(
21	{ address, binary },
22	instances,
23	search,
24	contexts
25	) {
26	let contextId;
27	let isConstructor = Boolean(binary);	554✔
28	if (address) {	554✔
29	//if we're in a call to a deployed contract, we must have recorded
30	//the context in the codex, so we don't need to do any further
31	//searching
32	({ context: contextId, binary } = instances[address]);	544✔
33	} else if (isConstructor) {	10✔
34	//otherwise, if we're in a constructor, we'll need to actually do a
35	//search
36	contextId = search(binary);	8✔
37	} else {
38	//exceptional case: no transaction is loaded
39	return null;	2✔
40	}
41
42	if (contextId != undefined) {	552!
43	//if we found the context, use it
44	let context = contexts[contextId];	552✔
45	return {	552✔
46	...context,
47	binary
48	};
49	} else {
50	//otherwise we'll construct something default
51	return {	×
52	binary,
53	isConstructor
54	};
55	}
56	}
57
58	/**
59	* create EVM-level selectors for a given trace step selector
60	* may specify additional selectors to include
61	*/
62	function createStepSelectors(step, state = null) {	×
63	let base = {	4✔
64	/**
65	* .trace
66	*
67	* trace step info related to operation
68	*/
69	trace: createLeaf([step], step => {
70	if (!step) {	45,166✔
71	return null;	2✔
72	}
73	let { gasCost, op, pc } = step;	45,164✔
74	return { gasCost, op, pc };	45,164✔
75	}),
76
77	/**
78	* .programCounter
79	*/
80	programCounter: createLeaf(["./trace"], step => (step ? step.pc : null)),	45,166✔
81
82	/**
83	* .isJump
84	*/
85	isJump: createLeaf(
86	["./trace"],
87	step => step.op != "JUMPDEST" && step.op.indexOf("JUMP") == 0	24,188✔
88	),
89
90	/**
91	* .isCall
92	*
93	* whether the opcode will switch to another calling context
94	*/
95	isCall: createLeaf(["./trace"], step => isCallMnemonic(step.op)),	24,194✔
96
97	/**
98	* .isShortCall
99	*
100	* for calls that only take 6 arguments instead of 7
101	*/
102	isShortCall: createLeaf(["./trace"], step => isShortCallMnemonic(step.op)),	20✔
103
104	/**
105	* .isDelegateCallBroad
106	*
107	* for calls that delegate storage
108	*/
109	isDelegateCallBroad: createLeaf(["./trace"], step =>
110	isDelegateCallMnemonicBroad(step.op)	14✔
111	),
112
113	/**
114	* .isDelegateCallStrict
115	*
116	* for calls that additionally delegate sender and value
117	*/
118	isDelegateCallStrict: createLeaf(["./trace"], step =>
119	isDelegateCallMnemonicStrict(step.op)	20✔
120	),
121
122	/**
123	* .isStaticCall
124	*/
125	isStaticCall: createLeaf(["./trace"], step =>
126	isStaticCallMnemonic(step.op)	14✔
127	),
128
129	/**
130	* .isCreate
131	*/
132	isCreate: createLeaf(["./trace"], step => isCreateMnemonic(step.op)),	24,194✔
133
134	/**
135	* .isHalting
136	*
137	* whether the instruction halts or returns from a calling context
138	* NOTE: this covers only ordinary halts, not exceptional halts;
139	* but it doesn't check the return status, so any normal halting
140	* instruction will qualify here
141	*/
142	isHalting: createLeaf(["./trace"], step =>
143	isNormalHaltingMnemonic(step.op)	24,202✔
144	),
145
146	/*
147	* .isStore
148	*/
149	isStore: createLeaf(["./trace"], step => step.op == "SSTORE"),	24,118✔
150
151	/*
152	* .isLoad
153	*/
154	isLoad: createLeaf(["./trace"], step => step.op == "SLOAD"),	24,118✔
155
156	/*
157	* .touchesStorage
158	*
159	* whether the instruction involves storage
160	*/
161	touchesStorage: createLeaf(
162	["./isStore", "isLoad"],
163	(stores, loads) => stores \|\| loads	810✔
164	)
165	};
166
167	if (state) {	4!
168	const isRelative = path =>	4✔
169	typeof path == "string" &&	4!
170	(path.startsWith("./") \|\| path.startsWith("../"));
171
172	if (isRelative(state)) {	4!
173	state = `../${state}`;	4✔
174	}
175
176	Object.assign(base, {	4✔
177	/**
178	* .callAddress
179	*
180	* address transferred to by call operation
181	*/
182	callAddress: createLeaf(
183	["./isCall", state],
184
185	(isCall, { stack }) => {
186	if (!isCall) {	20!
187	return null;	×
188	}
189
190	let address = stack[stack.length - 2];	20✔
191	return Codec.Evm.Utils.toAddress(address);	20✔
192	}
193	),
194
195	/**
196	* .createBinary
197	*
198	* binary code to execute via create operation
199	*/
200	createBinary: createLeaf(
201	["./isCreate", state],
202
203	(isCreate, { stack, memory }) => {
204	if (!isCreate) {	×
205	return null;	×
206	}
207
208	// Get the code that's going to be created from memory.
209	// Note we multiply by 2 because these offsets are in bytes.
210	const offset = parseInt(stack[stack.length - 2], 16) * 2;	×
211	const length = parseInt(stack[stack.length - 3], 16) * 2;	×
212
213	return "0x" + memory.join("").substring(offset, offset + length);	×
214	}
215	),
216
217	/**
218	* .callData
219	*
220	* data passed to EVM call
221	*/
222	callData: createLeaf(
223	["./isCall", "./isShortCall", state],
224	(isCall, short, { stack, memory }) => {
225	if (!isCall) {	20!
226	return null;	×
227	}
228
229	//if it's 6-argument call, the data start and offset will be one spot
230	//higher in the stack than they would be for a 7-argument call, so
231	//let's introduce an offset to handle this
232	let argOffset = short ? 1 : 0;	20✔
233
234	// Get the data from memory.
235	// Note we multiply by 2 because these offsets are in bytes.
236	const offset = parseInt(stack[stack.length - 4 + argOffset], 16) * 2;	20✔
237	const length = parseInt(stack[stack.length - 5 + argOffset], 16) * 2;	20✔
238
239	return "0x" + memory.join("").substring(offset, offset + length);	20✔
240	}
241	),
242
243	/**
244	* .callValue
245	*
246	* value for the call (not create); returns null for DELEGATECALL
247	*/
248	callValue: createLeaf(
249	["./isCall", "./isDelegateCallStrict", "./isStaticCall", state],
250	(calls, delegates, isStatic, { stack }) => {
251	if (!calls \|\| delegates) {	14!
252	return null;	×
253	}
254
255	if (isStatic) {	14✔
256	return new BN(0);	2✔
257	}
258
259	//otherwise, for CALL and CALLCODE, it's the 3rd argument
260	let value = stack[stack.length - 3];	12✔
261	return Codec.Conversion.toBN(value);	12✔
262	}
263	),
264
265	/**
266	* .createValue
267	*
268	* value for the create
269	*/
270	createValue: createLeaf(["./isCreate", state], (isCreate, { stack }) => {
271	if (!isCreate) {	×
272	return null;	×
273	}
274
275	//creates have the value as the first argument
276	let value = stack[stack.length - 1];	×
277	return Codec.Conversion.toBN(value);	×
278	}),
279
280	/**
281	* .storageAffected
282	*
283	* storage slot being stored to or loaded from
284	* we do NOT prepend "0x"
285	*/
286	storageAffected: createLeaf(
287	["./touchesStorage", state],
288
289	(touchesStorage, { stack }) => {
290	if (!touchesStorage) {	404!
291	return null;	×
292	}
293
294	return stack[stack.length - 1];	404✔
295	}
296	),
297
298	/**
299	* .callContext
300	*
301	* context of what this step is calling/creating (if applicable)
302	*/
303	callContext: createLeaf(
304	[
305	"./callAddress",
306	"./createBinary",
307	"/current/codex/instances",
308	"/info/binaries/search",
309	"/info/contexts"
310	],
311	(address, binary, instances, search, contexts) =>
312	determineFullContext({ address, binary }, instances, search, contexts)	×
313	)
314	});
315	}
316
317	return base;	4✔
318	}
319
320	const evm = createSelectorTree({	2✔
321	/**
322	* evm.state
323	*/
324	state: state => state.evm,	26,851✔
325
326	/**
327	* evm.info
328	*/
329	info: {
330	/**
331	* evm.info.contexts
332	*/
333	contexts: createLeaf(["/state"], state => state.info.contexts.byContext),	556✔
334
335	/**
336	* evm.info.binaries
337	*/
338	binaries: {
339	/**
340	* evm.info.binaries.search
341	*
342	* returns function (binary) => context (returns the ID of the context)
343	* (returns null on no match)
344	*/
345	search: createLeaf(["/info/contexts"], contexts => binary =>	90✔
346	Codec.Contexts.Utils.findDebuggerContext(contexts, binary)	116✔
347	)
348	}
349	},
350
351	/**
352	* evm.transaction
353	*/
354	transaction: {
355	/*
356	* evm.transaction.globals
357	*/
358	globals: {
359	/*
360	* evm.transaction.globals.tx
361	*/
362	tx: createLeaf(["/state"], state => state.transaction.globals.tx),	162✔
363	/*
364	* evm.transaction.globals.block
365	*/
366	block: createLeaf(["/state"], state => state.transaction.globals.block)	162✔
367	},
368
369	/*
370	* evm.transaction.status
371	*/
372	status: createLeaf(["/state"], state => state.transaction.status),	458✔
373
374	/*
375	* evm.transaction.initialCall
376	*/
377	initialCall: createLeaf(["/state"], state => state.transaction.initialCall),	2✔
378
379	/*
380	* evm.transaction.startingContext
381	*/
382	startingContext: createLeaf(
383	[
384	"/current/callstack", //we're just getting bottom stackframe, so this is in fact tx-level
385	"/current/codex/instances", //this should also be fine?
386	"/info/binaries/search",
387	"/info/contexts"
388	],
389	(stack, instances, search, contexts) =>
390	stack.length > 0	92✔
391	? determineFullContext(stack[0], instances, search, contexts)	92!
392	: null
393	)
394	},
395
396	/**
397	* evm.current
398	*/
399	current: {
400	/**
401	* evm.current.callstack
402	*/
403	callstack: state => state.evm.proc.callstack,	26,687✔
404
405	/**
406	* evm.current.call
407	*/
408	call: createLeaf(
409	["./callstack"],
410
411	stack => (stack.length ? stack[stack.length - 1] : {})	124✔
412	),
413
414	/**
415	* evm.current.context
416	*/
417	context: createLeaf(
418	[
419	"./call",
420	"./codex/instances",
421	"/info/binaries/search",
422	"/info/contexts"
423	],
424	determineFullContext
425	),
426
427	/**
428	* evm.current.state
429	*
430	* evm state info: as of last operation, before op defined in step
431	*/
432	state: Object.assign(
433	{},
434	...["depth", "error", "gas", "memory", "stack", "storage"].map(param => ({	12✔
435	[param]: createLeaf([trace.step], step => step[param])	26,940✔
436	}))
437	),
438
439	/**
440	* evm.current.step
441	*/
442	step: {
443	...createStepSelectors(trace.step, "./state"),
444
445	//the following step selectors only exist for current, not next or any
446	//other step
447
448	/*
449	* evm.current.step.createdAddress
450	*
451	* address created by the current create step
452	*/
453	createdAddress: createLeaf(
454	["./isCreate", "/nextOfSameDepth/state/stack"],
455	(isCreate, stack) => {
456	if (!isCreate) {	×
457	return null;	×
458	}
459	let address = stack[stack.length - 1];	×
460	return Codec.Evm.Utils.toAddress(address);	×
461	}
462	),
463
464	/**
465	* evm.current.step.isInstantCallOrReturn
466	*
467	* are we doing a call or create for which there are no trace steps?
468	* This can happen if:
469	* 1. we call a precompile
470	* 2. we call an externally-owned account
471	* 3. we do a call or create but the call stack is exhausted
472	* 4. we attempt to transfer more ether than we have
473	*/
474	isInstantCallOrCreate: createLeaf(
475	["./isCall", "./isCreate", "/current/state/depth", "/next/state/depth"],
476	(calls, creates, currentDepth, nextDepth) =>
477	(calls \|\| creates) && currentDepth === nextDepth	166✔
478	),
479
480	/**
481	* evm.current.step.isContextChange
482	* groups together calls, creates, halts, and exceptional halts
483	*/
484	isContextChange: createLeaf(
485	["/current/state/depth", "/next/state/depth"],
486	(currentDepth, nextDepth) => currentDepth !== nextDepth	160✔
487	),
488
489	/**
490	* evm.current.step.isExceptionalHalting
491	*/
492	isExceptionalHalting: createLeaf(
493	[
494	"./isHalting",
495	"/current/state/depth",
496	"/next/state/depth",
497	"./returnStatus"
498	],
499	(halting, currentDepth, nextDepth, status) =>
500	halting	164✔
501	? !status //if deliberately halting, check the return status	164✔
502	: nextDepth < currentDepth //if not on a deliberate halt, any halt
503	//is an exceptional halt
504	),
505
506	/**
507	* evm.current.step.returnStatus
508	* checks the return status of the current halting instruction (for
509	* normal halts only)
510	* (returns a boolean -- true for success, false for failure)
511	*/
512	returnStatus: createLeaf(
513	[
514	"./isHalting",
515	"/next/state",
516	trace.stepsRemaining,
517	"/transaction/status"
518	],
519	(isHalting, { stack }, remaining, finalStatus) => {
520	if (!isHalting) {	24,202✔
521	return null; //not clear this'll do much good since this may get	24,152✔
522	//read as false, but, oh well, may as well
523	}
524	if (remaining <= 1) {	50✔
525	return finalStatus;	42✔
526	} else {
527	const ZERO_WORD = "00".repeat(Codec.Evm.Utils.WORD_SIZE);	8✔
528	return stack[stack.length - 1] !== ZERO_WORD;	8✔
529	}
530	}
531	),
532
533	/*
534	* evm.current.step.returnValue
535	*
536	* for a [successful] RETURN or REVERT instruction, the value returned;
537	* we DO prepend "0x"
538	* for everything else, including unsuccessful RETURN, just returns "0x"
539	* (which is what the return value would be if the instruction were to
540	* fail) (or succeed in the case of STOP or SELFDESTRUCT)
541	* NOTE: technically this will be wrong if a REVERT fails, but that case
542	* is hard to detect and it barely matters
543	*/
544	returnValue: createLeaf(
545	["./trace", "./isExceptionalHalting", "../state"],
546
547	(step, isExceptionalHalting, { stack, memory }) => {
548	if (step.op !== "RETURN" && step.op !== "REVERT") {	×
549	return "0x";	×
550	}
551	if (isExceptionalHalting && step.op !== "REVERT") {	×
552	return "0x";	×
553	}
554	// Get the data from memory.
555	// Note we multiply by 2 because these offsets are in bytes.
556	const offset = parseInt(stack[stack.length - 1], 16) * 2;	×
557	const length = parseInt(stack[stack.length - 2], 16) * 2;	×
558
559	return "0x" + memory.join("").substring(offset, offset + length);	×
560	}
561	)
562	},
563
564	/**
565	* evm.current.codex (namespace)
566	*/
567	codex: {
568	/**
569	* evm.current.codex (selector)
570	* the whole codex! not that that's very much at the moment
571	*/
572	_: createLeaf(["/state"], state => state.proc.codex),	556✔
573
574	/**
575	* evm.current.codex.storage
576	* the current storage, as fetched from the codex... unless we're in a
577	* failed creation call, then we just fall back on the state (which will
578	* work, since nothing else can interfere with the storage of a failed
579	* creation call!)
580	*/
581	storage: createLeaf(
582	["./_", "../state/storage", "../call"],
583	(codex, rawStorage, { storageAddress }) =>
584	storageAddress === Codec.Evm.Utils.ZERO_ADDRESS	208✔
585	? rawStorage //HACK -- if zero address ignore the codex	208!
586	: codex[codex.length - 1].accounts[storageAddress].storage
587	),
588
589	/*
590	* evm.current.codex.instances
591	*/
592	instances: createLeaf(["./_"], codex =>
593	Object.assign(	466✔
594	{},
595	...Object.entries(codex[codex.length - 1].accounts).map(
596	([address, { code, context }]) => ({	510✔
597	[address]: { address, binary: code, context }
598	})
599	)
600	)
601	)
602	}
603	},
604
605	/**
606	* evm.next
607	*/
608	next: {
609	/**
610	* evm.next.state
611	*
612	* evm state as a result of next step operation
613	*/
614	state: Object.assign(
615	{},
616	...["depth", "error", "gas", "memory", "stack", "storage"].map(param => ({	12✔
617	[param]: createLeaf([trace.next], step => step[param])	145,212✔
618	}))
619	),
620
621	/*
622	* evm.next.step
623	*/
624	step: createStepSelectors(trace.next, "./state")
625	},
626
627	/**
628	* evm.nextOfSameDepth
629	*/
630	nextOfSameDepth: {
631	/**
632	* evm.nextOfSameDepth.state
633	*
634	* evm state at the next step of same depth
635	*/
636	state: Object.assign(
637	{},
638	...["depth", "error", "gas", "memory", "stack", "storage"].map(param => ({	12✔
639	[param]: createLeaf([trace.nextOfSameDepth], step => step[param])	×
640	}))
641	)
642	}
643	});
644
645	export default evm;

trufflesuite / truffle / 6589

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous