Check pcall and contract.pcall

[kroggen]

This is written in the documentation about contract.pcall:

The difference is that with contract.pcall when an error occurs the state and balance modified by the called function rolls back to the state before the call. This does not happen when using just pcall.

The example used there is also not good

I am not sure if there is indeed any difference between contract.pcall and pcall currently

And if it should have any difference

What do you think should be the behavior of the 2 functions above?

(also do not forget that there is a xpcall function as well)

[kroggen]

I was checking the behavior with an invalid test.

It was showing that the state from the current contract is not being reverted on all 3 functions.

Check updated test below

[kroggen]

If the behavior of both functions are the same, I suggest to remove the mention of contract.pcall from documentation and let users use only pcall

So later we can change the behavior of contract.pcall (if needed). This can only be done if there are no deployed contracts that use it

[kroggen]

I removed the reference to contract.pcall from the docs. The changes are here

[kroggen]

We can check the behavior with this test:

This is test-pcall.lua:

state.var {
  v = state.value()
}

function constructor()
  v:set(0)
end

local function error_handler(err_msg)
  return "error_handler: " .. err_msg
end

function test_pcall()
  v:set(111)
  contract.event("before pcall")
  local success, ret = pcall(do_work, "pcall")
  contract.event("after pcall", success, ret)
  return v:get()
end

function test_contract_pcall()
  v:set(111)
  contract.event("before contract.pcall")
  local success, ret = contract.pcall(do_work, "contract.pcall")
  contract.event("after contract.pcall", success, ret)
  return v:get()
end

function test_xpcall()
  v:set(111)
  contract.event("before xpcall")
  local success, ret = xpcall(do_work, error_handler, "xpcall")
  contract.event("after xpcall", success, ret)
  return v:get()
end

function do_work(caller)
  contract.event("inside do_work: before")
  v:set(123)
  assert(1 == 0, "failed")
  contract.event("inside do_work: after")
end

abi.register(test_pcall, test_contract_pcall, test_xpcall)

And this is test.brick:

inject me 10000000000000000

deploy me 0 ct ./test-pcall.lua

hardfork 2

call me 0 ct test_pcall `[]` `` `111`
call me 0 ct test_xpcall `[]` `` `111`
call me 0 ct test_contract_pcall `[]` `` `111`

hardfork 3

call me 0 ct test_pcall `[]` `` `111`
call me 0 ct test_xpcall `[]` `` `111`
call me 0 ct test_contract_pcall `[]` `` `111`

hardfork 4

call me 0 ct test_pcall `[]` `` `111`
call me 0 ct test_xpcall `[]` `` `111`
call me 0 ct test_contract_pcall `[]` `` `111`

To run:

brick -V test.brick

Currently the state from the current contract is only being reverted on contract.pcall

pcall and xpcall do not revert the state

This is the behavior that was on the docs, but it can be changed on V4 to make all 3 of them to rollback the contract state