Calldata with predicates

[josojo]

Background
The Gnosis MockContract is a smart contract enabling developers to quickly mock contract interactions for unit tests.
It enables developers to

• Make dependent contracts return predefined values for different methods and arguments
• Simulate exceptions such as revert and outOfGas
• Assert on how often a dependency is called

The MockContract facilitates these features without requiring any separate test contracts. Check out the repo: https://github.com/gnosis/mock-contract

Task
Extend the functionality of the MockContract to mock contract interaction on calldata with predicate

s

Acceptance criteria:

• Develop a framework allowing developers to define predicates on calldata for specific methods. 
The predicates should include GREATER_THAN with a definition similar to:

const calldata = contract.methods.foo(
GREATER_THAN(10)
).encodeABI()

and the predicate SMALL_THAN

const calldata = contract.methods.foo(
SMALLER_THAN(10)
).encodeABI()

• Write the logic for the MockContract to expose predefined returns to calldata with predicates. 
Hence, it is expected that the following functions are provided for calldata with predicates:

	function givenPredicateCalldataReturn(bytes calldata call, bytes calldata response) external;
	function givenPredicateCalldataReturnBool(bytes calldata call, bool response) external;
	function givenPredicateCalldataReturnUint(bytes calldata call, uint response) external;
	function givenPredicateCalldataReturnAddress(bytes calldata call, address response) external;

	function givenPredicateCalldataRevert(bytes calldata call) external;
	function givenPredicateCalldataRevertWithMessage(bytes calldata call, string calldata message) external;
	function givenPredicateCalldataRunOutOfGas(bytes calldata call) external;

They should enable the same functionality on calldata with predicates as the current respective
functions with the same function names, but without the word "Predicate".

• Make sure the invocation count functions are still returning the right numbers
:

       function invocationCount() external returns (uint);
       function invocationCountForMethod(bytes calldata method) external returns (uint);
       function invocationCountForCalldata(bytes calldata call) external returns (uint);

• Current naming conventions need to be preserved
• All functionality must have 100 % line and branch coverage
• The solidity style guide must be considered and code must be linted

Payout:
0.75 ETH
Additional GNO can be tipped according to the level of technical implementation

[fleupold]

This one is a little more tricky than the previous one. I was thinking that we could actually allow people to write the predicate as a boolean expression in solidity (with a somehow defined naming scheme for variables).

E.g. GREATER_THAN(10) could be implemented as

contract.method.givenConditionReturn("arg0 > 10", true)

which under the hood (in js) could be implemented by deploying a new contract instance (using something like this) which inherits MockContract, and implements the method something like:

function method(arg0, arg1, ...) returns (bool) {
  if ($condition) {
    return $returnValue
  } else {
    super.method(arg0, arg1, ...)
  }
}

Of course there is still some more fine technical detail which has to be ironed out, which is why this task is definitely more involved than #14

But I'm also happy leaving it open like this to see if someone comes up with a better idea.

[bh2smith]

Don't forget to update this!

The MockContract allows for all of that without having to write a separate test contract each time.

with

The MockContract facilitates these features without requiring any separate test contracts.

[bh2smith]

Are these exercises to be given out for prizes at the trufflecon?

[josojo]

@bh2smith Yeah, they are exercises, which will be posted in gitcoin. It is not specifically for trufflecon

[gitcoinbot]

Issue Status: 1. Open 2. Started 3. Submitted 4. Done

---

This issue now has a funding of 0.75 ETH (159.1 USD @ $212.14/ETH) attached to it as part of the Gnosis fund.

• If you would like to work on this issue you can 'start work' on the Gitcoin Issue Details page.
• Want to chip in? Add your own contribution here.
• Questions? Checkout Gitcoin Help or the Gitcoin Slack
• $142,366.64 more funded OSS Work available on the Gitcoin Issue Explorer

[fvictorio]

My two cents in case anyone cares: I feel like solidity needs some extra features before something like this can be implemented, unless you do something like deploying ad-hoc contracts, like @fleupold suggested.

More specifically, I think for doing this you should need to store information about how to decode a given calldata, but AFAIK you can't store a tuple of types, which is the type of the second parameter of abi.decode:

abi.decode(someBytes, (uint, string))

I mean, someone calling a givenPredicateCalldata* method should also provide info about how to decode this. If this is possible, I think #14 becomes much easier too.

[fleupold]

One cool hack that was presented at EthLondon last weekend is Lurch, which allows evaluating arbitrary bytecode given some calldata.

We could implement the predicate as bytecode and pass it in to the MockContract. Then when the mock contract matches the method-name it could evaluate the bytecode given the calldata in lurch and if it returns true execute the given expectation.

I'm not sure how practical it will be to compile predicates into bytecode and if it could be done nicely in JS.

[gitcoinbot]

Issue Status: 1. Open 2. Cancelled

---

The funding of 0.75 ETH (100.64 USD @ $134.18/ETH) attached to this issue has been cancelled by the bounty submitter

• Questions? Checkout Gitcoin Help or the Gitcoin Slack
• $80,006.89 more funded OSS Work available on the Gitcoin Issue Explorer