Introduce fixed gas for transfers

[herr-seppia]

Summary

Currently, when rusk is performing transactions, it calls the method execute of the transfer contract
execute methods does the following:

• Verify the tx is spendable
• Spend the inputs+fee and create the outputs
• Call the interContract method (if any)
• Refund the fee change (gas_left*gas_price)

Current implementation lead to some issues, due to the atomic logic of piecrust (a sort of "all or nothing).

• If a tx runs OOG while executing a contract call everything is reverted (no fee spent)
• If a tx runs OOG while refunding the change, the ICC is reverted
• If a tx runs OOG while spending, tx should be discarded completely (and we have no way to determine it, because now it looks like a OOG while executing)

Possible solution design or implementation

Introduce a fixed artificial gas limit for transfers (aka TX_GAS)

Split the execute into three different host calls:

1. spend: ensure that tx.gas_limit >= TX_GAS and set session to use GasLimit::MAX
2. call (if any): set session's gas limit to tx.gas_limit-TX_GAS
3. refund: pop crossover (if any) and refund tx.gas_limit - call.gas_spent - TX_GAS)

With this 3 host functions, rusk can handle all the actual use cases:

• If panics while spend then tx should be discarded
• If panic while call then tx return Err(_), otherwise it's considered successful
• refund should never fail

Additional context

N.B:

• refunding become free
• we still have to decide if we have to revert a panicked IIC, maybe it's up to the contract developer

[herr-seppia]

To keep it simpler, we can wrap those 3 fn in a new execute that return Result<TransactionResult, InvalidTx> where

enum TransactionResult {
  SUCCESS,
  FAIL(Piecrust::Error)
}

enum InvalidTx {
  UNSPENDABLE,
  OTHER
}