2024-10-17 21:31:23 +03:00

834 lines
22 KiB
JavaScript

import debugModule from "debug";
const debug = debugModule("debugger:test:data:more-decoding");
import { assert } from "chai";
import Web3 from "web3"; //just using for utils
import Ganache from "ganache";
import { prepareContracts, lineOf, testBlockGasLimit } from "../helpers";
import Debugger from "lib/debugger";
import sourcemapping from "lib/sourcemapping/selectors";
import data from "lib/data/selectors";
import evm from "lib/evm/selectors";
import * as Codec from "@truffle/codec";
const __CONTAINERS = `
pragma solidity ^0.8.0;
contract ContainersTest {
//provides a nice ending point
event Done();
//declare needed structs
struct Wrapper {
uint x;
}
//declare storage variables to be tested
Wrapper[] storageStructArray;
uint128[2][] storageArrayArray;
mapping(string => Wrapper) structMapping;
mapping(string => uint128[2]) arrayMapping;
mapping(string => int128) signedMapping;
//this one is not tested directly
uint[2] pointedAt;
function run() public {
//declare local variables to be tested
uint[1] memory memoryStaticArray;
uint[2] storage localStorage = pointedAt;
//set up variables with values
storageStructArray.push();
storageStructArray[0].x = 107;
storageArrayArray.push();
storageArrayArray[0][0] = 2;
storageArrayArray[0][1] = 3;
structMapping["hello"].x = 107;
arrayMapping["hello"][0] = 2;
arrayMapping["hello"][1] = 3;
signedMapping["hello"] = -1;
memoryStaticArray[0] = 107;
//for this one, let's mix how we access it
localStorage[0] = 107;
pointedAt[1] = 214;
//everything's set up, time to decode!
emit Done(); //break here
}
}
`;
const __KEYSANDBYTES = `
pragma solidity ^0.8.8;
contract ElementaryTest {
event Done(); //makes a useful breakpoint
enum Ternary { Red, Green, Blue }
type MyInt is int8;
//storage variables to be tested
mapping(bool => bool) boolMap;
mapping(bytes1 => bytes1) byteMap;
mapping(bytes => bytes) bytesMap;
mapping(bytes4 => bytes4) selectorMap;
mapping(uint => uint) uintMap;
mapping(int => int) intMap;
mapping(string => string) stringMap;
mapping(address => address) addressMap;
mapping(ElementaryTest => ElementaryTest) contractMap;
mapping(Ternary => Ternary) enumMap;
mapping(MyInt => MyInt) wrapMap;
//constant state variables to try as mapping keys
//(and for testing on their own)
uint constant two = 2;
string constant hello = "hello";
bytes4 constant hexConst = 0xdeadbeef;
bytes4 constant short = hex"ff";
function run() public {
//local variables to be tested
bytes1 oneByte;
bytes1[] memory severalBytes;
//set up variables for testing
oneByte = 0xff;
severalBytes = new bytes1[](1);
severalBytes[0] = 0xff;
boolMap[true] = true;
byteMap[0x01] = 0x01;
bytesMap[hex"01"] = hex"01";
uintMap[1] = 1;
uintMap[two] = two;
intMap[-1] = -1;
addressMap[address(this)] = address(this);
stringMap["0xdeadbeef"] = "0xdeadbeef";
stringMap["12345"] = "12345";
stringMap[hello] = hello;
contractMap[this] = this;
enumMap[Ternary.Blue] = Ternary.Blue;
wrapMap[MyInt.wrap(-2)] = MyInt.wrap(-2);
selectorMap[hexConst] = hexConst;
selectorMap[short] = short;
selectorMap[hex"f00f"] = hex"f00f";
emit Done(); //break here
}
}
`;
const __SPLICING = `
pragma solidity ^0.8.0;
contract SpliceTest {
//splicing is (nontrivially) used in two contexts right now:
//1. decoding nested memory structures
//2. decoding mapping keys pointed to by a memory variable
//we'll also test some trivial splicing, I guess
event Done();
mapping(string => string) map;
struct ArrayStruct {
uint[1] x;
}
string pointedAt = "key2";
function run() public {
uint[1][1] memory arrayArray;
ArrayStruct memory arrayStruct;
arrayArray[0][0] = 82;
arrayStruct.x[0] = 82;
string memory key1 = "key1";
string storage key2 = pointedAt;
map[key1] = "value1";
map[key2] = "value2";
emit Done(); //break here
}
}
`;
const __INNERMAPS = `
pragma solidity ^0.8.0;
contract ComplexMappingTest {
struct MappingStruct {
mapping(string => string) map;
}
mapping(string => string)[1] mapArrayStatic;
mapping(string => mapping(string => string)) mapMap;
MappingStruct mapStruct0;
MappingStruct mapStruct1;
function run() public {
mapArrayStatic[0]["a"] = "0a";
mapMap["a"]["c"] = "ac";
mapStruct0.map["a"] = "00a";
mapStruct1.map["e"] = "10e";
}
}
`;
const __OVERFLOW = `
pragma solidity ^0.8.0;
contract OverflowTest {
event Unsigned(uint8);
event Raw(bytes1);
event Signed(int8);
function unsignedTest() public {
unchecked {
uint8[1] memory memoryByte;
uint8 byte1 = 255;
uint8 byte2 = 255;
uint8 sum = byte1 + byte2;
emit Unsigned(sum); //BREAK UNSIGNED
}
}
function rawTest() public {
bytes1 full = 0xff;
bytes1 right = full >> 1;
emit Raw(right); //BREAK RAW
}
function signedTest() public {
unchecked {
int8 byte1 = -128;
int8 byte2 = -128;
int8 sum = byte1 + byte2;
emit Signed(sum); //BREAK SIGNED
}
}
}
`;
const __BADBOOL = `
pragma solidity ^0.8.0;
pragma abicoder v1;
contract BadBoolTest {
mapping(bool => uint) boolMap;
function run(bool key) public {
boolMap[key] = 1;
}
}
`;
const __CIRCULAR = `
pragma solidity ^0.8.0;
contract CircularTest {
struct Tree {
uint x;
Tree[] children;
}
event Done();
function run() public {
Tree memory circular;
circular.x = 3;
circular.children = new Tree[](1);
circular.children[0] = circular;
emit Done(); //BREAK HERE
}
}
`;
const __GLOBALDECLS = `
pragma solidity ^0.8.0;
struct GlobalStruct {
uint x;
uint y;
}
enum GlobalEnum {
No, Yes
}
contract GlobalDeclarationTest {
GlobalStruct globalStruct;
GlobalEnum globalEnum;
function run() public {
globalStruct.x = 2;
globalStruct.y = 3;
globalEnum = GlobalEnum.Yes;
}
}
`;
const __UNKNOWN = `
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract UnknownTest {
struct Pair {
uint x;
uint y;
}
uint known;
uint unknown;
Pair partialPair;
uint[2] partialArray;
uint[] partialDynamic;
mapping(uint => uint) theMap;
event Num(uint);
constructor() {
known = 1;
unknown = 2;
partialPair.x = 3;
partialPair.y = 4;
partialArray[0] = 5;
partialArray[1] = 6;
partialDynamic.push(7);
partialDynamic.push(8);
theMap[9] = 9;
}
function run() public { //BREAK
emit Num(known);
emit Num(partialPair.x);
emit Num(partialArray[0]);
emit Num(partialDynamic[0]);
emit Num(theMap[9]);
}
}
`;
const sources = {
"ContainersTest.sol": __CONTAINERS,
"ElementaryTest.sol": __KEYSANDBYTES,
"SpliceTest.sol": __SPLICING,
"ComplexMappingsTest.sol": __INNERMAPS,
"OverflowTest.sol": __OVERFLOW,
"BadBoolTest.sol": __BADBOOL,
"Circular.sol": __CIRCULAR,
"GlobalDeclarations.sol": __GLOBALDECLS,
"UnknownTest.sol": __UNKNOWN
};
describe("Further Decoding", function () {
var provider;
var abstractions;
var compilations;
before("Create Provider", async function () {
provider = Ganache.provider({
seed: "debugger",
miner: {
instamine: "strict",
blockGasLimit: testBlockGasLimit
},
logging: {
quiet: true
}
});
});
before("Prepare contracts and artifacts", async function () {
this.timeout(30000);
let prepared = await prepareContracts(provider, sources);
abstractions = prepared.abstractions;
compilations = prepared.compilations;
});
it("Decodes various reference types correctly", async function () {
this.timeout(12000);
let instance = await abstractions.ContainersTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("break here", source)
});
await bugger.continueUntilBreakpoint();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
const expectedResult = {
memoryStaticArray: [107],
localStorage: [107, 214],
storageStructArray: [{ x: 107 }],
storageArrayArray: [[2, 3]],
structMapping: { hello: { x: 107 } },
arrayMapping: { hello: [2, 3] },
signedMapping: { hello: -1 },
pointedAt: [107, 214]
};
assert.deepInclude(variables, expectedResult);
});
it("Decodes elementary types and mappings correctly", async function () {
this.timeout(12000);
let instance = await abstractions.ElementaryTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let address = instance.address;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("break here", source)
});
await bugger.continueUntilBreakpoint();
const rawVariables = await bugger.variables();
const variables =
Codec.Format.Utils.Inspect.unsafeNativizeVariables(rawVariables);
debug("variables %O", variables);
const expectedResult = {
boolMap: { true: true },
byteMap: { "0x01": "0x01" },
bytesMap: { "0x01": "0x01" },
uintMap: { 1: 1, 2: 2 },
intMap: { "-1": -1 },
stringMap: {
"0xdeadbeef": "0xdeadbeef",
"12345": "12345",
"hello": "hello"
},
addressMap: { [address]: address },
contractMap: { [address]: address },
enumMap: { "ElementaryTest.Ternary.Blue": "ElementaryTest.Ternary.Blue" },
wrapMap: { "-2": -2 },
oneByte: "0xff",
severalBytes: ["0xff"],
two: 2,
hexConst: "0xdeadbeef",
short: "0xff000000",
hello: "hello",
selectorMap: {
"0xdeadbeef": "0xdeadbeef",
"0xff000000": "0xff000000",
"0xf00f0000": "0xf00f0000"
}
};
assert.deepInclude(variables, expectedResult);
//while we're at it, let's also test the interpretation on addressMap[address]
const value = rawVariables.addressMap.value[0].value;
assert.equal(value.kind, "value");
assert.equal(value.type.typeClass, "address");
assert.isDefined(value.interpretations.contractClass);
assert.equal(
value.interpretations.contractClass.typeName,
"ElementaryTest"
);
});
it("Splices locations correctly", async function () {
this.timeout(12000);
let instance = await abstractions.SpliceTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("break here", source)
});
await bugger.continueUntilBreakpoint();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
const expectedResult = {
map: { key1: "value1", key2: "value2" },
pointedAt: "key2",
arrayArray: [[82]],
arrayStruct: { x: [82] },
key1: "key1",
key2: "key2",
pointedAt: "key2"
};
assert.deepInclude(variables, expectedResult);
});
it("Decodes inner mappings correctly and keeps path info", async function () {
this.timeout(12000);
let instance = await abstractions.ComplexMappingTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
//we're only testing storage so run till end
await bugger.runToEnd();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
const expectedResult = {
mapArrayStatic: [{ a: "0a" }],
mapMap: { a: { c: "ac" } },
mapStruct0: {
map: { a: "00a" }
},
mapStruct1: {
map: { e: "10e" }
}
};
debug("variables %O", variables);
debug("expectedResult %O", expectedResult);
assert.deepInclude(variables, expectedResult);
//let's get the ID of the current contract to use as an index
let contractId = bugger.view(evm.current.context).contractId;
//get offsets of top-level variables for this contract
//converting to numbers for convenience
const startingOffsets = Object.values(
bugger.view(data.current.allocations.state)[contractId].members
).map(({ pointer }) => pointer.range.from.slot.offset);
const mappingKeys = bugger.view(data.views.mappingKeys);
for (let slot of mappingKeys) {
while (slot.path !== undefined) {
slot = slot.path;
}
//check that each path in the mapping keys can be traced back to one of
//the top-level variables
assert.deepInclude(startingOffsets, slot.offset);
}
});
it("Cleans badly-encoded booleans used as mapping keys", async function () {
this.timeout(12000);
let instance = await abstractions.BadBoolTest.deployed();
let signature = "run(bool)";
//manually set up the selector; 10 is for initial 0x + 8 more hex digits
let selector = Web3.utils
.soliditySha3({ type: "string", value: signature })
.slice(0, 10);
let argument =
"0000000000000000000000000000000000000000000000000000000000000002";
let receipt = await instance.sendTransaction({ data: selector + argument });
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
await bugger.runToEnd();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
debug("variables %O", variables);
const expectedResult = {
boolMap: { true: 1 }
};
assert.deepInclude(variables, expectedResult);
});
it("Handles globally-declared structs and enums", async function () {
this.timeout(12000);
let instance = await abstractions.GlobalDeclarationTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
await bugger.runToEnd();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
debug("variables %O", variables);
const expectedResult = {
globalStruct: { x: 2, y: 3 },
globalEnum: "GlobalEnum.Yes"
};
assert.deepInclude(variables, expectedResult);
});
it("Decodes circular structures", async function () {
this.timeout(12000);
let instance = await abstractions.CircularTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("BREAK HERE", source)
});
await bugger.continueUntilBreakpoint();
const circular = Codec.Format.Utils.Inspect.unsafeNativize(
await bugger.variable("circular")
);
assert.strictEqual(circular.x, 3);
assert.isArray(circular.children);
assert.lengthOf(circular.children, 1);
assert.strictEqual(circular.children[0], circular);
});
it("Distinguishes known and unknown storage", async function () {
this.timeout(12000);
let instance = await abstractions.UnknownTest.deployed();
let receipt = await instance.run();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("BREAK", source)
});
const assertIsUnknown = variable => {
assert.equal(variable.kind, "error");
assert.equal(variable.error.kind, "StorageNotSuppliedError");
};
await bugger.continueUntilBreakpoint();
let variables = await bugger.variables({ indicateUnknown: true });
assertIsUnknown(variables.known); //it's not known yet
assert.isTrue(Codec.Export.containsDeliberateReadError(variables.known));
assertIsUnknown(variables.unknown);
assert.isTrue(Codec.Export.containsDeliberateReadError(variables.unknown));
assert.equal(variables.partialPair.kind, "value"); //it's known but individual entries are not
assertIsUnknown(variables.partialPair.value[0].value);
assertIsUnknown(variables.partialPair.value[1].value);
assert.isTrue(
Codec.Export.containsDeliberateReadError(variables.partialPair)
);
assert.equal(variables.partialArray.kind, "value"); //again, it's known but individual entries are not
assertIsUnknown(variables.partialArray.value[0]);
assertIsUnknown(variables.partialArray.value[1]);
assert.isTrue(
Codec.Export.containsDeliberateReadError(variables.partialArray)
);
assertIsUnknown(variables.partialDynamic); //this OTOH is wholly unknown since we don't know its length
assert.isTrue(
Codec.Export.containsDeliberateReadError(variables.partialDynamic)
);
assert.equal(variables.theMap.kind, "value"); //maps should never turn up unknown
assert.lengthOf(variables.theMap.value, 0); //no keys recorded
assert.isFalse(Codec.Export.containsDeliberateReadError(variables.theMap));
await bugger.runToEnd();
variables = await bugger.variables({ indicateUnknown: true });
assert.equal(variables.known.kind, "value"); //known now
assert.isFalse(Codec.Export.containsDeliberateReadError(variables.known));
assertIsUnknown(variables.unknown); //still unknown
assert.isTrue(Codec.Export.containsDeliberateReadError(variables.unknown));
assert.equal(variables.partialPair.kind, "value"); //first entry now known, second still unknown
assert.equal(variables.partialPair.value[0].value.kind, "value");
assertIsUnknown(variables.partialPair.value[1].value);
assert.isTrue(
Codec.Export.containsDeliberateReadError(variables.partialPair)
);
assert.equal(variables.partialArray.kind, "value"); //similar
assert.equal(variables.partialArray.value[0].kind, "value");
assertIsUnknown(variables.partialArray.value[1]);
assert.isTrue(
Codec.Export.containsDeliberateReadError(variables.partialArray)
);
assert.equal(variables.partialDynamic.kind, "value"); //length & first entry now known
assert.equal(variables.partialDynamic.value[0].kind, "value");
assertIsUnknown(variables.partialDynamic.value[1]);
assert.isTrue(
Codec.Export.containsDeliberateReadError(variables.partialDynamic)
);
assert.equal(variables.theMap.kind, "value"); //maps should never turn up unknown
assert.lengthOf(variables.theMap.value, 1); //1 key recorded
assert.isFalse(Codec.Export.containsDeliberateReadError(variables.theMap));
});
describe("Overflow", function () {
it("Discards padding on unsigned integers", async function () {
this.timeout(6000);
let instance = await abstractions.OverflowTest.deployed();
let receipt = await instance.unsignedTest();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("BREAK UNSIGNED", source)
});
await bugger.continueUntilBreakpoint();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
debug("variables %O", variables);
const expectedResult = {
byte1: 255,
byte2: 255,
sum: 254
};
assert.include(variables, expectedResult);
});
it("Discards padding on signed integers", async function () {
this.timeout(6000);
let instance = await abstractions.OverflowTest.deployed();
let receipt = await instance.signedTest();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("BREAK SIGNED", source)
});
await bugger.continueUntilBreakpoint();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
debug("variables %O", variables);
const expectedResult = {
byte1: -128,
byte2: -128,
sum: 0
};
assert.include(variables, expectedResult);
});
it("Discards padding on static bytestrings", async function () {
this.timeout(6000);
let instance = await abstractions.OverflowTest.deployed();
let receipt = await instance.rawTest();
let txHash = receipt.tx;
let bugger = await Debugger.forTx(txHash, { provider, compilations });
let sourceId = bugger.view(sourcemapping.current.source).id;
let source = bugger.view(sourcemapping.current.source).source;
await bugger.addBreakpoint({
sourceId,
line: lineOf("BREAK RAW", source)
});
await bugger.continueUntilBreakpoint();
const variables = Codec.Format.Utils.Inspect.unsafeNativizeVariables(
await bugger.variables()
);
debug("variables %O", variables);
const expectedResult = {
full: "0xff",
right: "0x7f"
};
assert.include(variables, expectedResult);
});
});
});