Wrap all errors with tracerr

eth/contracts/auction/HermezAuctionProtocol.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
+	"github.com/hermeznetwork/tracerr"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -36,12 +37,12 @@ var HermezAuctionProtocolBin = "0x608060405234801561001057600080fd5b50613d678061
 func DeployHermezAuctionProtocol(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *HermezAuctionProtocol, error) {
 	parsed, err := abi.JSON(strings.NewReader(HermezAuctionProtocolABI))
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 
 	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(HermezAuctionProtocolBin), backend)
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 	return address, tx, &HermezAuctionProtocol{HermezAuctionProtocolCaller: HermezAuctionProtocolCaller{contract: contract}, HermezAuctionProtocolTransactor: HermezAuctionProtocolTransactor{contract: contract}, HermezAuctionProtocolFilterer: HermezAuctionProtocolFilterer{contract: contract}}, nil
 }
@@ -109,7 +110,7 @@ type HermezAuctionProtocolTransactorRaw struct {
 func NewHermezAuctionProtocol(address common.Address, backend bind.ContractBackend) (*HermezAuctionProtocol, error) {
 	contract, err := bindHermezAuctionProtocol(address, backend, backend, backend)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocol{HermezAuctionProtocolCaller: HermezAuctionProtocolCaller{contract: contract}, HermezAuctionProtocolTransactor: HermezAuctionProtocolTransactor{contract: contract}, HermezAuctionProtocolFilterer: HermezAuctionProtocolFilterer{contract: contract}}, nil
 }
@@ -118,7 +119,7 @@ func NewHermezAuctionProtocol(address common.Address, backend bind.ContractBacke
 func NewHermezAuctionProtocolCaller(address common.Address, caller bind.ContractCaller) (*HermezAuctionProtocolCaller, error) {
 	contract, err := bindHermezAuctionProtocol(address, caller, nil, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolCaller{contract: contract}, nil
 }
@@ -127,7 +128,7 @@ func NewHermezAuctionProtocolCaller(address common.Address, caller bind.Contract
 func NewHermezAuctionProtocolTransactor(address common.Address, transactor bind.ContractTransactor) (*HermezAuctionProtocolTransactor, error) {
 	contract, err := bindHermezAuctionProtocol(address, nil, transactor, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolTransactor{contract: contract}, nil
 }
@@ -136,7 +137,7 @@ func NewHermezAuctionProtocolTransactor(address common.Address, transactor bind.
 func NewHermezAuctionProtocolFilterer(address common.Address, filterer bind.ContractFilterer) (*HermezAuctionProtocolFilterer, error) {
 	contract, err := bindHermezAuctionProtocol(address, nil, nil, filterer)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolFilterer{contract: contract}, nil
 }
@@ -145,7 +146,7 @@ func NewHermezAuctionProtocolFilterer(address common.Address, filterer bind.Cont
 func bindHermezAuctionProtocol(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 	parsed, err := abi.JSON(strings.NewReader(HermezAuctionProtocolABI))
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 }
@@ -197,7 +198,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) BLOCKSPERSLOT(opts *b
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "BLOCKS_PER_SLOT")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // BLOCKSPERSLOT is a free data retrieval call binding the contract method 0x2243de47.
@@ -223,7 +224,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) INITIALMINIMALBIDDING
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "INITIAL_MINIMAL_BIDDING")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // INITIALMINIMALBIDDING is a free data retrieval call binding the contract method 0xe6065914.
@@ -249,7 +250,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) CanForge(opts *bind.C
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "canForge", forger, blockNumber)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // CanForge is a free data retrieval call binding the contract method 0x83b1f6a0.
@@ -279,7 +280,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) Coordinators(opts *bi
 	})
 	out := ret
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "coordinators", arg0)
-	return *ret, err
+	return *ret, tracerr.Wrap(err)
 }
 
 // Coordinators is a free data retrieval call binding the contract method 0xa48af096.
@@ -311,7 +312,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GenesisBlock(opts *bi
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "genesisBlock")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GenesisBlock is a free data retrieval call binding the contract method 0x4cdc9c63.
@@ -337,7 +338,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetAllocationRatio(op
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getAllocationRatio")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetAllocationRatio is a free data retrieval call binding the contract method 0xec29159b.
@@ -363,7 +364,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetBootCoordinator(op
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getBootCoordinator")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetBootCoordinator is a free data retrieval call binding the contract method 0xb5f7f2f0.
@@ -389,7 +390,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetClaimableHEZ(opts
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getClaimableHEZ", bidder)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetClaimableHEZ is a free data retrieval call binding the contract method 0x5cca4903.
@@ -415,7 +416,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetClosedAuctionSlots
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getClosedAuctionSlots")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetClosedAuctionSlots is a free data retrieval call binding the contract method 0x4da9639d.
@@ -441,7 +442,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetCurrentSlotNumber(
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getCurrentSlotNumber")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetCurrentSlotNumber is a free data retrieval call binding the contract method 0x0c4da4f6.
@@ -467,7 +468,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetDefaultSlotSetBid(
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getDefaultSlotSetBid", slotSet)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetDefaultSlotSetBid is a free data retrieval call binding the contract method 0x564e6a71.
@@ -493,7 +494,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetDonationAddress(op
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getDonationAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetDonationAddress is a free data retrieval call binding the contract method 0x54c03ab7.
@@ -519,7 +520,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetMinBidBySlot(opts
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getMinBidBySlot", slot)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetMinBidBySlot is a free data retrieval call binding the contract method 0x37d1bd0b.
@@ -545,7 +546,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetOpenAuctionSlots(o
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getOpenAuctionSlots")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetOpenAuctionSlots is a free data retrieval call binding the contract method 0xac4b9012.
@@ -571,7 +572,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetOutbidding(opts *b
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getOutbidding")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetOutbidding is a free data retrieval call binding the contract method 0x55b442e6.
@@ -597,7 +598,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetSlotDeadline(opts
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getSlotDeadline")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetSlotDeadline is a free data retrieval call binding the contract method 0x13de9af2.
@@ -623,7 +624,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetSlotNumber(opts *b
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getSlotNumber", blockNumber)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetSlotNumber is a free data retrieval call binding the contract method 0xb3dc7bb1.
@@ -649,7 +650,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) GetSlotSet(opts *bind
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "getSlotSet", slot)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetSlotSet is a free data retrieval call binding the contract method 0xac5f658b.
@@ -675,7 +676,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) HermezRollup(opts *bi
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "hermezRollup")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // HermezRollup is a free data retrieval call binding the contract method 0xaebd6d98.
@@ -701,7 +702,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) PendingBalances(opts
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "pendingBalances", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // PendingBalances is a free data retrieval call binding the contract method 0xecdae41b.
@@ -735,7 +736,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) Slots(opts *bind.Call
 	})
 	out := ret
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "slots", arg0)
-	return *ret, err
+	return *ret, tracerr.Wrap(err)
 }
 
 // Slots is a free data retrieval call binding the contract method 0xbc415567.
@@ -771,7 +772,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolCaller) TokenHEZ(opts *bind.C
 	)
 	out := ret0
 	err := _HermezAuctionProtocol.contract.Call(opts, out, "tokenHEZ")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TokenHEZ is a free data retrieval call binding the contract method 0x79a135e3.
@@ -1168,7 +1169,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterHEZClaimed(op
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "HEZClaimed", ownerRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolHEZClaimedIterator{contract: _HermezAuctionProtocol.contract, event: "HEZClaimed", logs: logs, sub: sub}, nil
 }
@@ -1185,7 +1186,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchHEZClaimed(opt
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "HEZClaimed", ownerRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1195,19 +1196,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchHEZClaimed(opt
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolHEZClaimed)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "HEZClaimed", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1221,7 +1222,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchHEZClaimed(opt
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseHEZClaimed(log types.Log) (*HermezAuctionProtocolHEZClaimed, error) {
 	event := new(HermezAuctionProtocolHEZClaimed)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "HEZClaimed", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1306,7 +1307,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewAllocation
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewAllocationRatio")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewAllocationRatioIterator{contract: _HermezAuctionProtocol.contract, event: "NewAllocationRatio", logs: logs, sub: sub}, nil
 }
@@ -1318,7 +1319,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewAllocationR
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewAllocationRatio")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1328,19 +1329,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewAllocationR
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewAllocationRatio)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewAllocationRatio", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1354,7 +1355,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewAllocationR
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewAllocationRatio(log types.Log) (*HermezAuctionProtocolNewAllocationRatio, error) {
 	event := new(HermezAuctionProtocolNewAllocationRatio)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewAllocationRatio", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1451,7 +1452,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewBid(opts *
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewBid", slotRule, bidderRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewBidIterator{contract: _HermezAuctionProtocol.contract, event: "NewBid", logs: logs, sub: sub}, nil
 }
@@ -1473,7 +1474,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewBid(opts *b
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewBid", slotRule, bidderRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1483,19 +1484,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewBid(opts *b
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewBid)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewBid", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1509,7 +1510,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewBid(opts *b
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewBid(log types.Log) (*HermezAuctionProtocolNewBid, error) {
 	event := new(HermezAuctionProtocolNewBid)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewBid", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1599,7 +1600,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewBootCoordi
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewBootCoordinator", newBootCoordinatorRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewBootCoordinatorIterator{contract: _HermezAuctionProtocol.contract, event: "NewBootCoordinator", logs: logs, sub: sub}, nil
 }
@@ -1616,7 +1617,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewBootCoordin
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewBootCoordinator", newBootCoordinatorRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1626,19 +1627,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewBootCoordin
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewBootCoordinator)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewBootCoordinator", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1652,7 +1653,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewBootCoordin
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewBootCoordinator(log types.Log) (*HermezAuctionProtocolNewBootCoordinator, error) {
 	event := new(HermezAuctionProtocolNewBootCoordinator)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewBootCoordinator", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1737,7 +1738,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewClosedAuct
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewClosedAuctionSlots")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewClosedAuctionSlotsIterator{contract: _HermezAuctionProtocol.contract, event: "NewClosedAuctionSlots", logs: logs, sub: sub}, nil
 }
@@ -1749,7 +1750,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewClosedAucti
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewClosedAuctionSlots")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1759,19 +1760,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewClosedAucti
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewClosedAuctionSlots)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewClosedAuctionSlots", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1785,7 +1786,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewClosedAucti
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewClosedAuctionSlots(log types.Log) (*HermezAuctionProtocolNewClosedAuctionSlots, error) {
 	event := new(HermezAuctionProtocolNewClosedAuctionSlots)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewClosedAuctionSlots", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1871,7 +1872,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewDefaultSlo
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewDefaultSlotSetBid")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewDefaultSlotSetBidIterator{contract: _HermezAuctionProtocol.contract, event: "NewDefaultSlotSetBid", logs: logs, sub: sub}, nil
 }
@@ -1883,7 +1884,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewDefaultSlot
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewDefaultSlotSetBid")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1893,19 +1894,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewDefaultSlot
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewDefaultSlotSetBid)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewDefaultSlotSetBid", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1919,7 +1920,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewDefaultSlot
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewDefaultSlotSetBid(log types.Log) (*HermezAuctionProtocolNewDefaultSlotSetBid, error) {
 	event := new(HermezAuctionProtocolNewDefaultSlotSetBid)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewDefaultSlotSetBid", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2009,7 +2010,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewDonationAd
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewDonationAddress", newDonationAddressRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewDonationAddressIterator{contract: _HermezAuctionProtocol.contract, event: "NewDonationAddress", logs: logs, sub: sub}, nil
 }
@@ -2026,7 +2027,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewDonationAdd
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewDonationAddress", newDonationAddressRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2036,19 +2037,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewDonationAdd
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewDonationAddress)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewDonationAddress", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2062,7 +2063,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewDonationAdd
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewDonationAddress(log types.Log) (*HermezAuctionProtocolNewDonationAddress, error) {
 	event := new(HermezAuctionProtocolNewDonationAddress)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewDonationAddress", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2157,7 +2158,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewForge(opts
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewForge", forgerRule, slotToForgeRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewForgeIterator{contract: _HermezAuctionProtocol.contract, event: "NewForge", logs: logs, sub: sub}, nil
 }
@@ -2178,7 +2179,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewForge(opts
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewForge", forgerRule, slotToForgeRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2188,19 +2189,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewForge(opts
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewForge)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewForge", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2214,7 +2215,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewForge(opts
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewForge(log types.Log) (*HermezAuctionProtocolNewForge, error) {
 	event := new(HermezAuctionProtocolNewForge)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewForge", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2317,7 +2318,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewForgeAlloc
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewForgeAllocated", bidderRule, forgerRule, slotToForgeRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewForgeAllocatedIterator{contract: _HermezAuctionProtocol.contract, event: "NewForgeAllocated", logs: logs, sub: sub}, nil
 }
@@ -2342,7 +2343,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewForgeAlloca
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewForgeAllocated", bidderRule, forgerRule, slotToForgeRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2352,19 +2353,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewForgeAlloca
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewForgeAllocated)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewForgeAllocated", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2378,7 +2379,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewForgeAlloca
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewForgeAllocated(log types.Log) (*HermezAuctionProtocolNewForgeAllocated, error) {
 	event := new(HermezAuctionProtocolNewForgeAllocated)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewForgeAllocated", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2463,7 +2464,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewOpenAuctio
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewOpenAuctionSlots")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewOpenAuctionSlotsIterator{contract: _HermezAuctionProtocol.contract, event: "NewOpenAuctionSlots", logs: logs, sub: sub}, nil
 }
@@ -2475,7 +2476,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewOpenAuction
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewOpenAuctionSlots")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2485,19 +2486,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewOpenAuction
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewOpenAuctionSlots)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewOpenAuctionSlots", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2511,7 +2512,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewOpenAuction
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewOpenAuctionSlots(log types.Log) (*HermezAuctionProtocolNewOpenAuctionSlots, error) {
 	event := new(HermezAuctionProtocolNewOpenAuctionSlots)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewOpenAuctionSlots", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2596,7 +2597,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewOutbidding
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewOutbidding")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewOutbiddingIterator{contract: _HermezAuctionProtocol.contract, event: "NewOutbidding", logs: logs, sub: sub}, nil
 }
@@ -2608,7 +2609,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewOutbidding(
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewOutbidding")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2618,19 +2619,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewOutbidding(
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewOutbidding)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewOutbidding", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2644,7 +2645,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewOutbidding(
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewOutbidding(log types.Log) (*HermezAuctionProtocolNewOutbidding, error) {
 	event := new(HermezAuctionProtocolNewOutbidding)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewOutbidding", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2729,7 +2730,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterNewSlotDeadli
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "NewSlotDeadline")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolNewSlotDeadlineIterator{contract: _HermezAuctionProtocol.contract, event: "NewSlotDeadline", logs: logs, sub: sub}, nil
 }
@@ -2741,7 +2742,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewSlotDeadlin
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "NewSlotDeadline")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2751,19 +2752,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewSlotDeadlin
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolNewSlotDeadline)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewSlotDeadline", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2777,7 +2778,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchNewSlotDeadlin
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseNewSlotDeadline(log types.Log) (*HermezAuctionProtocolNewSlotDeadline, error) {
 	event := new(HermezAuctionProtocolNewSlotDeadline)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "NewSlotDeadline", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2873,7 +2874,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) FilterSetCoordinato
 
 	logs, sub, err := _HermezAuctionProtocol.contract.FilterLogs(opts, "SetCoordinator", bidderRule, forgerRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAuctionProtocolSetCoordinatorIterator{contract: _HermezAuctionProtocol.contract, event: "SetCoordinator", logs: logs, sub: sub}, nil
 }
@@ -2894,7 +2895,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchSetCoordinator
 
 	logs, sub, err := _HermezAuctionProtocol.contract.WatchLogs(opts, "SetCoordinator", bidderRule, forgerRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2904,19 +2905,19 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchSetCoordinator
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAuctionProtocolSetCoordinator)
 				if err := _HermezAuctionProtocol.contract.UnpackLog(event, "SetCoordinator", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2930,7 +2931,7 @@ func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) WatchSetCoordinator
 func (_HermezAuctionProtocol *HermezAuctionProtocolFilterer) ParseSetCoordinator(log types.Log) (*HermezAuctionProtocolSetCoordinator, error) {
 	event := new(HermezAuctionProtocolSetCoordinator)
 	if err := _HermezAuctionProtocol.contract.UnpackLog(event, "SetCoordinator", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }

eth/contracts/hermez/Hermez.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
+	"github.com/hermeznetwork/tracerr"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -36,12 +37,12 @@ var HermezBin = "0x608060405234801561001057600080fd5b506158f6806100206000396000f
 func DeployHermez(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Hermez, error) {
 	parsed, err := abi.JSON(strings.NewReader(HermezABI))
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 
 	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(HermezBin), backend)
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 	return address, tx, &Hermez{HermezCaller: HermezCaller{contract: contract}, HermezTransactor: HermezTransactor{contract: contract}, HermezFilterer: HermezFilterer{contract: contract}}, nil
 }
@@ -109,7 +110,7 @@ type HermezTransactorRaw struct {
 func NewHermez(address common.Address, backend bind.ContractBackend) (*Hermez, error) {
 	contract, err := bindHermez(address, backend, backend, backend)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &Hermez{HermezCaller: HermezCaller{contract: contract}, HermezTransactor: HermezTransactor{contract: contract}, HermezFilterer: HermezFilterer{contract: contract}}, nil
 }
@@ -118,7 +119,7 @@ func NewHermez(address common.Address, backend bind.ContractBackend) (*Hermez, e
 func NewHermezCaller(address common.Address, caller bind.ContractCaller) (*HermezCaller, error) {
 	contract, err := bindHermez(address, caller, nil, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezCaller{contract: contract}, nil
 }
@@ -127,7 +128,7 @@ func NewHermezCaller(address common.Address, caller bind.ContractCaller) (*Herme
 func NewHermezTransactor(address common.Address, transactor bind.ContractTransactor) (*HermezTransactor, error) {
 	contract, err := bindHermez(address, nil, transactor, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezTransactor{contract: contract}, nil
 }
@@ -136,7 +137,7 @@ func NewHermezTransactor(address common.Address, transactor bind.ContractTransac
 func NewHermezFilterer(address common.Address, filterer bind.ContractFilterer) (*HermezFilterer, error) {
 	contract, err := bindHermez(address, nil, nil, filterer)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezFilterer{contract: contract}, nil
 }
@@ -145,7 +146,7 @@ func NewHermezFilterer(address common.Address, filterer bind.ContractFilterer) (
 func bindHermez(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 	parsed, err := abi.JSON(strings.NewReader(HermezABI))
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 }
@@ -197,7 +198,7 @@ func (_Hermez *HermezCaller) ABSOLUTEMAXL1L2BATCHTIMEOUT(opts *bind.CallOpts) (u
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "ABSOLUTE_MAX_L1L2BATCHTIMEOUT")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // ABSOLUTEMAXL1L2BATCHTIMEOUT is a free data retrieval call binding the contract method 0x95a09f2a.
@@ -233,7 +234,7 @@ func (_Hermez *HermezCaller) Buckets(opts *bind.CallOpts, arg0 *big.Int) (struct
 	})
 	out := ret
 	err := _Hermez.contract.Call(opts, out, "buckets", arg0)
-	return *ret, err
+	return *ret, tracerr.Wrap(err)
 }
 
 // Buckets is a free data retrieval call binding the contract method 0x9b51fb0d.
@@ -271,7 +272,7 @@ func (_Hermez *HermezCaller) ExitNullifierMap(opts *bind.CallOpts, arg0 uint64,
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "exitNullifierMap", arg0, arg1)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // ExitNullifierMap is a free data retrieval call binding the contract method 0xe9b5269c.
@@ -297,7 +298,7 @@ func (_Hermez *HermezCaller) ExitRootsMap(opts *bind.CallOpts, arg0 uint64) (*bi
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "exitRootsMap", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // ExitRootsMap is a free data retrieval call binding the contract method 0x506d5463.
@@ -323,7 +324,7 @@ func (_Hermez *HermezCaller) FeeAddToken(opts *bind.CallOpts) (*big.Int, error)
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "feeAddToken")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // FeeAddToken is a free data retrieval call binding the contract method 0xbded9bb8.
@@ -349,7 +350,7 @@ func (_Hermez *HermezCaller) ForgeL1L2BatchTimeout(opts *bind.CallOpts) (uint8,
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "forgeL1L2BatchTimeout")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // ForgeL1L2BatchTimeout is a free data retrieval call binding the contract method 0xa3275838.
@@ -375,7 +376,7 @@ func (_Hermez *HermezCaller) HermezAuctionContract(opts *bind.CallOpts) (common.
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "hermezAuctionContract")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // HermezAuctionContract is a free data retrieval call binding the contract method 0x2bd83626.
@@ -401,7 +402,7 @@ func (_Hermez *HermezCaller) HermezGovernanceDAOAddress(opts *bind.CallOpts) (co
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "hermezGovernanceDAOAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // HermezGovernanceDAOAddress is a free data retrieval call binding the contract method 0xdd46bf84.
@@ -427,7 +428,7 @@ func (_Hermez *HermezCaller) InstantWithdrawalViewer(opts *bind.CallOpts, tokenA
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "instantWithdrawalViewer", tokenAddress, amount)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // InstantWithdrawalViewer is a free data retrieval call binding the contract method 0x375110aa.
@@ -453,7 +454,7 @@ func (_Hermez *HermezCaller) LastForgedBatch(opts *bind.CallOpts) (uint64, error
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "lastForgedBatch")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // LastForgedBatch is a free data retrieval call binding the contract method 0x44e0b2ce.
@@ -479,7 +480,7 @@ func (_Hermez *HermezCaller) LastIdx(opts *bind.CallOpts) (*big.Int, error) {
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "lastIdx")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // LastIdx is a free data retrieval call binding the contract method 0xd486645c.
@@ -505,7 +506,7 @@ func (_Hermez *HermezCaller) LastL1L2Batch(opts *bind.CallOpts) (uint64, error)
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "lastL1L2Batch")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // LastL1L2Batch is a free data retrieval call binding the contract method 0x84ef9ed4.
@@ -531,7 +532,7 @@ func (_Hermez *HermezCaller) MapL1TxQueue(opts *bind.CallOpts, arg0 uint64) ([]b
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "mapL1TxQueue", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // MapL1TxQueue is a free data retrieval call binding the contract method 0xe796fcf3.
@@ -557,7 +558,7 @@ func (_Hermez *HermezCaller) NextL1FillingQueue(opts *bind.CallOpts) (uint64, er
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "nextL1FillingQueue")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // NextL1FillingQueue is a free data retrieval call binding the contract method 0x0ee8e52b.
@@ -583,7 +584,7 @@ func (_Hermez *HermezCaller) NextL1ToForgeQueue(opts *bind.CallOpts) (uint64, er
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "nextL1ToForgeQueue")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // NextL1ToForgeQueue is a free data retrieval call binding the contract method 0xd0f32e67.
@@ -609,7 +610,7 @@ func (_Hermez *HermezCaller) RegisterTokensCount(opts *bind.CallOpts) (*big.Int,
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "registerTokensCount")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // RegisterTokensCount is a free data retrieval call binding the contract method 0x9f34e9a3.
@@ -641,7 +642,7 @@ func (_Hermez *HermezCaller) RollupVerifiers(opts *bind.CallOpts, arg0 *big.Int)
 	})
 	out := ret
 	err := _Hermez.contract.Call(opts, out, "rollupVerifiers", arg0)
-	return *ret, err
+	return *ret, tracerr.Wrap(err)
 }
 
 // RollupVerifiers is a free data retrieval call binding the contract method 0x38330200.
@@ -675,7 +676,7 @@ func (_Hermez *HermezCaller) SafetyAddress(opts *bind.CallOpts) (common.Address,
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "safetyAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // SafetyAddress is a free data retrieval call binding the contract method 0xe56e27ae.
@@ -701,7 +702,7 @@ func (_Hermez *HermezCaller) StateRootMap(opts *bind.CallOpts, arg0 uint64) (*bi
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "stateRootMap", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // StateRootMap is a free data retrieval call binding the contract method 0x86c6acc1.
@@ -727,7 +728,7 @@ func (_Hermez *HermezCaller) TokenExchange(opts *bind.CallOpts, arg0 common.Addr
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "tokenExchange", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TokenExchange is a free data retrieval call binding the contract method 0x0dd94b96.
@@ -753,7 +754,7 @@ func (_Hermez *HermezCaller) TokenHEZ(opts *bind.CallOpts) (common.Address, erro
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "tokenHEZ")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TokenHEZ is a free data retrieval call binding the contract method 0x79a135e3.
@@ -779,7 +780,7 @@ func (_Hermez *HermezCaller) TokenList(opts *bind.CallOpts, arg0 *big.Int) (comm
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "tokenList", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TokenList is a free data retrieval call binding the contract method 0x9ead7222.
@@ -805,7 +806,7 @@ func (_Hermez *HermezCaller) TokenMap(opts *bind.CallOpts, arg0 common.Address)
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "tokenMap", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TokenMap is a free data retrieval call binding the contract method 0x004aca6e.
@@ -831,7 +832,7 @@ func (_Hermez *HermezCaller) WithdrawDelayerContract(opts *bind.CallOpts) (commo
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "withdrawDelayerContract")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // WithdrawDelayerContract is a free data retrieval call binding the contract method 0x1b0a8223.
@@ -857,7 +858,7 @@ func (_Hermez *HermezCaller) WithdrawVerifier(opts *bind.CallOpts) (common.Addre
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "withdrawVerifier")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // WithdrawVerifier is a free data retrieval call binding the contract method 0x864eb164.
@@ -883,7 +884,7 @@ func (_Hermez *HermezCaller) WithdrawalDelay(opts *bind.CallOpts) (uint64, error
 	)
 	out := ret0
 	err := _Hermez.contract.Call(opts, out, "withdrawalDelay")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // WithdrawalDelay is a free data retrieval call binding the contract method 0xa7ab6961.
@@ -1238,7 +1239,7 @@ func (_Hermez *HermezFilterer) FilterAddToken(opts *bind.FilterOpts, tokenAddres
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "AddToken", tokenAddressRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezAddTokenIterator{contract: _Hermez.contract, event: "AddToken", logs: logs, sub: sub}, nil
 }
@@ -1255,7 +1256,7 @@ func (_Hermez *HermezFilterer) WatchAddToken(opts *bind.WatchOpts, sink chan<- *
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "AddToken", tokenAddressRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1265,19 +1266,19 @@ func (_Hermez *HermezFilterer) WatchAddToken(opts *bind.WatchOpts, sink chan<- *
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezAddToken)
 				if err := _Hermez.contract.UnpackLog(event, "AddToken", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1291,7 +1292,7 @@ func (_Hermez *HermezFilterer) WatchAddToken(opts *bind.WatchOpts, sink chan<- *
 func (_Hermez *HermezFilterer) ParseAddToken(log types.Log) (*HermezAddToken, error) {
 	event := new(HermezAddToken)
 	if err := _Hermez.contract.UnpackLog(event, "AddToken", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1381,7 +1382,7 @@ func (_Hermez *HermezFilterer) FilterForgeBatch(opts *bind.FilterOpts, batchNum
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "ForgeBatch", batchNumRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezForgeBatchIterator{contract: _Hermez.contract, event: "ForgeBatch", logs: logs, sub: sub}, nil
 }
@@ -1398,7 +1399,7 @@ func (_Hermez *HermezFilterer) WatchForgeBatch(opts *bind.WatchOpts, sink chan<-
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "ForgeBatch", batchNumRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1408,19 +1409,19 @@ func (_Hermez *HermezFilterer) WatchForgeBatch(opts *bind.WatchOpts, sink chan<-
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezForgeBatch)
 				if err := _Hermez.contract.UnpackLog(event, "ForgeBatch", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1434,7 +1435,7 @@ func (_Hermez *HermezFilterer) WatchForgeBatch(opts *bind.WatchOpts, sink chan<-
 func (_Hermez *HermezFilterer) ParseForgeBatch(log types.Log) (*HermezForgeBatch, error) {
 	event := new(HermezForgeBatch)
 	if err := _Hermez.contract.UnpackLog(event, "ForgeBatch", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1530,7 +1531,7 @@ func (_Hermez *HermezFilterer) FilterL1UserTxEvent(opts *bind.FilterOpts, queueI
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "L1UserTxEvent", queueIndexRule, positionRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezL1UserTxEventIterator{contract: _Hermez.contract, event: "L1UserTxEvent", logs: logs, sub: sub}, nil
 }
@@ -1551,7 +1552,7 @@ func (_Hermez *HermezFilterer) WatchL1UserTxEvent(opts *bind.WatchOpts, sink cha
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "L1UserTxEvent", queueIndexRule, positionRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1561,19 +1562,19 @@ func (_Hermez *HermezFilterer) WatchL1UserTxEvent(opts *bind.WatchOpts, sink cha
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezL1UserTxEvent)
 				if err := _Hermez.contract.UnpackLog(event, "L1UserTxEvent", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1587,7 +1588,7 @@ func (_Hermez *HermezFilterer) WatchL1UserTxEvent(opts *bind.WatchOpts, sink cha
 func (_Hermez *HermezFilterer) ParseL1UserTxEvent(log types.Log) (*HermezL1UserTxEvent, error) {
 	event := new(HermezL1UserTxEvent)
 	if err := _Hermez.contract.UnpackLog(event, "L1UserTxEvent", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1671,7 +1672,7 @@ func (_Hermez *HermezFilterer) FilterSafeMode(opts *bind.FilterOpts) (*HermezSaf
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "SafeMode")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezSafeModeIterator{contract: _Hermez.contract, event: "SafeMode", logs: logs, sub: sub}, nil
 }
@@ -1683,7 +1684,7 @@ func (_Hermez *HermezFilterer) WatchSafeMode(opts *bind.WatchOpts, sink chan<- *
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "SafeMode")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1693,19 +1694,19 @@ func (_Hermez *HermezFilterer) WatchSafeMode(opts *bind.WatchOpts, sink chan<- *
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezSafeMode)
 				if err := _Hermez.contract.UnpackLog(event, "SafeMode", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1719,7 +1720,7 @@ func (_Hermez *HermezFilterer) WatchSafeMode(opts *bind.WatchOpts, sink chan<- *
 func (_Hermez *HermezFilterer) ParseSafeMode(log types.Log) (*HermezSafeMode, error) {
 	event := new(HermezSafeMode)
 	if err := _Hermez.contract.UnpackLog(event, "SafeMode", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1815,7 +1816,7 @@ func (_Hermez *HermezFilterer) FilterUpdateBucketWithdraw(opts *bind.FilterOpts,
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "UpdateBucketWithdraw", numBucketRule, blockStampRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezUpdateBucketWithdrawIterator{contract: _Hermez.contract, event: "UpdateBucketWithdraw", logs: logs, sub: sub}, nil
 }
@@ -1836,7 +1837,7 @@ func (_Hermez *HermezFilterer) WatchUpdateBucketWithdraw(opts *bind.WatchOpts, s
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "UpdateBucketWithdraw", numBucketRule, blockStampRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1846,19 +1847,19 @@ func (_Hermez *HermezFilterer) WatchUpdateBucketWithdraw(opts *bind.WatchOpts, s
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezUpdateBucketWithdraw)
 				if err := _Hermez.contract.UnpackLog(event, "UpdateBucketWithdraw", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1872,7 +1873,7 @@ func (_Hermez *HermezFilterer) WatchUpdateBucketWithdraw(opts *bind.WatchOpts, s
 func (_Hermez *HermezFilterer) ParseUpdateBucketWithdraw(log types.Log) (*HermezUpdateBucketWithdraw, error) {
 	event := new(HermezUpdateBucketWithdraw)
 	if err := _Hermez.contract.UnpackLog(event, "UpdateBucketWithdraw", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1957,7 +1958,7 @@ func (_Hermez *HermezFilterer) FilterUpdateBucketsParameters(opts *bind.FilterOp
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "UpdateBucketsParameters")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezUpdateBucketsParametersIterator{contract: _Hermez.contract, event: "UpdateBucketsParameters", logs: logs, sub: sub}, nil
 }
@@ -1969,7 +1970,7 @@ func (_Hermez *HermezFilterer) WatchUpdateBucketsParameters(opts *bind.WatchOpts
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "UpdateBucketsParameters")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1979,19 +1980,19 @@ func (_Hermez *HermezFilterer) WatchUpdateBucketsParameters(opts *bind.WatchOpts
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezUpdateBucketsParameters)
 				if err := _Hermez.contract.UnpackLog(event, "UpdateBucketsParameters", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2005,7 +2006,7 @@ func (_Hermez *HermezFilterer) WatchUpdateBucketsParameters(opts *bind.WatchOpts
 func (_Hermez *HermezFilterer) ParseUpdateBucketsParameters(log types.Log) (*HermezUpdateBucketsParameters, error) {
 	event := new(HermezUpdateBucketsParameters)
 	if err := _Hermez.contract.UnpackLog(event, "UpdateBucketsParameters", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2090,7 +2091,7 @@ func (_Hermez *HermezFilterer) FilterUpdateFeeAddToken(opts *bind.FilterOpts) (*
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "UpdateFeeAddToken")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezUpdateFeeAddTokenIterator{contract: _Hermez.contract, event: "UpdateFeeAddToken", logs: logs, sub: sub}, nil
 }
@@ -2102,7 +2103,7 @@ func (_Hermez *HermezFilterer) WatchUpdateFeeAddToken(opts *bind.WatchOpts, sink
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "UpdateFeeAddToken")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2112,19 +2113,19 @@ func (_Hermez *HermezFilterer) WatchUpdateFeeAddToken(opts *bind.WatchOpts, sink
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezUpdateFeeAddToken)
 				if err := _Hermez.contract.UnpackLog(event, "UpdateFeeAddToken", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2138,7 +2139,7 @@ func (_Hermez *HermezFilterer) WatchUpdateFeeAddToken(opts *bind.WatchOpts, sink
 func (_Hermez *HermezFilterer) ParseUpdateFeeAddToken(log types.Log) (*HermezUpdateFeeAddToken, error) {
 	event := new(HermezUpdateFeeAddToken)
 	if err := _Hermez.contract.UnpackLog(event, "UpdateFeeAddToken", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2223,7 +2224,7 @@ func (_Hermez *HermezFilterer) FilterUpdateForgeL1L2BatchTimeout(opts *bind.Filt
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "UpdateForgeL1L2BatchTimeout")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezUpdateForgeL1L2BatchTimeoutIterator{contract: _Hermez.contract, event: "UpdateForgeL1L2BatchTimeout", logs: logs, sub: sub}, nil
 }
@@ -2235,7 +2236,7 @@ func (_Hermez *HermezFilterer) WatchUpdateForgeL1L2BatchTimeout(opts *bind.Watch
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "UpdateForgeL1L2BatchTimeout")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2245,19 +2246,19 @@ func (_Hermez *HermezFilterer) WatchUpdateForgeL1L2BatchTimeout(opts *bind.Watch
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezUpdateForgeL1L2BatchTimeout)
 				if err := _Hermez.contract.UnpackLog(event, "UpdateForgeL1L2BatchTimeout", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2271,7 +2272,7 @@ func (_Hermez *HermezFilterer) WatchUpdateForgeL1L2BatchTimeout(opts *bind.Watch
 func (_Hermez *HermezFilterer) ParseUpdateForgeL1L2BatchTimeout(log types.Log) (*HermezUpdateForgeL1L2BatchTimeout, error) {
 	event := new(HermezUpdateForgeL1L2BatchTimeout)
 	if err := _Hermez.contract.UnpackLog(event, "UpdateForgeL1L2BatchTimeout", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2357,7 +2358,7 @@ func (_Hermez *HermezFilterer) FilterUpdateTokenExchange(opts *bind.FilterOpts)
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "UpdateTokenExchange")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezUpdateTokenExchangeIterator{contract: _Hermez.contract, event: "UpdateTokenExchange", logs: logs, sub: sub}, nil
 }
@@ -2369,7 +2370,7 @@ func (_Hermez *HermezFilterer) WatchUpdateTokenExchange(opts *bind.WatchOpts, si
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "UpdateTokenExchange")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2379,19 +2380,19 @@ func (_Hermez *HermezFilterer) WatchUpdateTokenExchange(opts *bind.WatchOpts, si
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezUpdateTokenExchange)
 				if err := _Hermez.contract.UnpackLog(event, "UpdateTokenExchange", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2405,7 +2406,7 @@ func (_Hermez *HermezFilterer) WatchUpdateTokenExchange(opts *bind.WatchOpts, si
 func (_Hermez *HermezFilterer) ParseUpdateTokenExchange(log types.Log) (*HermezUpdateTokenExchange, error) {
 	event := new(HermezUpdateTokenExchange)
 	if err := _Hermez.contract.UnpackLog(event, "UpdateTokenExchange", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2490,7 +2491,7 @@ func (_Hermez *HermezFilterer) FilterUpdateWithdrawalDelay(opts *bind.FilterOpts
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "UpdateWithdrawalDelay")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezUpdateWithdrawalDelayIterator{contract: _Hermez.contract, event: "UpdateWithdrawalDelay", logs: logs, sub: sub}, nil
 }
@@ -2502,7 +2503,7 @@ func (_Hermez *HermezFilterer) WatchUpdateWithdrawalDelay(opts *bind.WatchOpts,
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "UpdateWithdrawalDelay")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2512,19 +2513,19 @@ func (_Hermez *HermezFilterer) WatchUpdateWithdrawalDelay(opts *bind.WatchOpts,
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezUpdateWithdrawalDelay)
 				if err := _Hermez.contract.UnpackLog(event, "UpdateWithdrawalDelay", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2538,7 +2539,7 @@ func (_Hermez *HermezFilterer) WatchUpdateWithdrawalDelay(opts *bind.WatchOpts,
 func (_Hermez *HermezFilterer) ParseUpdateWithdrawalDelay(log types.Log) (*HermezUpdateWithdrawalDelay, error) {
 	event := new(HermezUpdateWithdrawalDelay)
 	if err := _Hermez.contract.UnpackLog(event, "UpdateWithdrawalDelay", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -2638,7 +2639,7 @@ func (_Hermez *HermezFilterer) FilterWithdrawEvent(opts *bind.FilterOpts, idx []
 
 	logs, sub, err := _Hermez.contract.FilterLogs(opts, "WithdrawEvent", idxRule, numExitRootRule, instantWithdrawRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HermezWithdrawEventIterator{contract: _Hermez.contract, event: "WithdrawEvent", logs: logs, sub: sub}, nil
 }
@@ -2663,7 +2664,7 @@ func (_Hermez *HermezFilterer) WatchWithdrawEvent(opts *bind.WatchOpts, sink cha
 
 	logs, sub, err := _Hermez.contract.WatchLogs(opts, "WithdrawEvent", idxRule, numExitRootRule, instantWithdrawRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -2673,19 +2674,19 @@ func (_Hermez *HermezFilterer) WatchWithdrawEvent(opts *bind.WatchOpts, sink cha
 				// New log arrived, parse the event and forward to the user
 				event := new(HermezWithdrawEvent)
 				if err := _Hermez.contract.UnpackLog(event, "WithdrawEvent", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -2699,7 +2700,7 @@ func (_Hermez *HermezFilterer) WatchWithdrawEvent(opts *bind.WatchOpts, sink cha
 func (_Hermez *HermezFilterer) ParseWithdrawEvent(log types.Log) (*HermezWithdrawEvent, error) {
 	event := new(HermezWithdrawEvent)
 	if err := _Hermez.contract.UnpackLog(event, "WithdrawEvent", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }

eth/contracts/tokenHEZ/HEZ.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
+	"github.com/hermeznetwork/tracerr"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -36,12 +37,12 @@ var HEZBin = "0x608060405234801561001057600080fd5b506040516111153803806111158339
 func DeployHEZ(auth *bind.TransactOpts, backend bind.ContractBackend, initialHolder common.Address) (common.Address, *types.Transaction, *HEZ, error) {
 	parsed, err := abi.JSON(strings.NewReader(HEZABI))
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 
 	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(HEZBin), backend, initialHolder)
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 	return address, tx, &HEZ{HEZCaller: HEZCaller{contract: contract}, HEZTransactor: HEZTransactor{contract: contract}, HEZFilterer: HEZFilterer{contract: contract}}, nil
 }
@@ -109,7 +110,7 @@ type HEZTransactorRaw struct {
 func NewHEZ(address common.Address, backend bind.ContractBackend) (*HEZ, error) {
 	contract, err := bindHEZ(address, backend, backend, backend)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZ{HEZCaller: HEZCaller{contract: contract}, HEZTransactor: HEZTransactor{contract: contract}, HEZFilterer: HEZFilterer{contract: contract}}, nil
 }
@@ -118,7 +119,7 @@ func NewHEZ(address common.Address, backend bind.ContractBackend) (*HEZ, error)
 func NewHEZCaller(address common.Address, caller bind.ContractCaller) (*HEZCaller, error) {
 	contract, err := bindHEZ(address, caller, nil, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZCaller{contract: contract}, nil
 }
@@ -127,7 +128,7 @@ func NewHEZCaller(address common.Address, caller bind.ContractCaller) (*HEZCalle
 func NewHEZTransactor(address common.Address, transactor bind.ContractTransactor) (*HEZTransactor, error) {
 	contract, err := bindHEZ(address, nil, transactor, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZTransactor{contract: contract}, nil
 }
@@ -136,7 +137,7 @@ func NewHEZTransactor(address common.Address, transactor bind.ContractTransactor
 func NewHEZFilterer(address common.Address, filterer bind.ContractFilterer) (*HEZFilterer, error) {
 	contract, err := bindHEZ(address, nil, nil, filterer)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZFilterer{contract: contract}, nil
 }
@@ -145,7 +146,7 @@ func NewHEZFilterer(address common.Address, filterer bind.ContractFilterer) (*HE
 func bindHEZ(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 	parsed, err := abi.JSON(strings.NewReader(HEZABI))
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 }
@@ -197,7 +198,7 @@ func (_HEZ *HEZCaller) EIP712DOMAINHASH(opts *bind.CallOpts) ([32]byte, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "EIP712DOMAIN_HASH")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // EIP712DOMAINHASH is a free data retrieval call binding the contract method 0xc473af33.
@@ -223,7 +224,7 @@ func (_HEZ *HEZCaller) NAMEHASH(opts *bind.CallOpts) ([32]byte, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "NAME_HASH")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // NAMEHASH is a free data retrieval call binding the contract method 0x04622c2e.
@@ -249,7 +250,7 @@ func (_HEZ *HEZCaller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "PERMIT_TYPEHASH")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f.
@@ -275,7 +276,7 @@ func (_HEZ *HEZCaller) TRANSFERWITHAUTHORIZATIONTYPEHASH(opts *bind.CallOpts) ([
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "TRANSFER_WITH_AUTHORIZATION_TYPEHASH")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TRANSFERWITHAUTHORIZATIONTYPEHASH is a free data retrieval call binding the contract method 0xa0cc6a68.
@@ -301,7 +302,7 @@ func (_HEZ *HEZCaller) VERSIONHASH(opts *bind.CallOpts) ([32]byte, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "VERSION_HASH")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // VERSIONHASH is a free data retrieval call binding the contract method 0x9e4e7318.
@@ -327,7 +328,7 @@ func (_HEZ *HEZCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "allowance", arg0, arg1)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
@@ -353,7 +354,7 @@ func (_HEZ *HEZCaller) AuthorizationState(opts *bind.CallOpts, arg0 common.Addre
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "authorizationState", arg0, arg1)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // AuthorizationState is a free data retrieval call binding the contract method 0xe94a0102.
@@ -379,7 +380,7 @@ func (_HEZ *HEZCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "balanceOf", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
@@ -405,7 +406,7 @@ func (_HEZ *HEZCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "decimals")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // Decimals is a free data retrieval call binding the contract method 0x313ce567.
@@ -431,7 +432,7 @@ func (_HEZ *HEZCaller) GetChainId(opts *bind.CallOpts) (*big.Int, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "getChainId")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetChainId is a free data retrieval call binding the contract method 0x3408e470.
@@ -457,7 +458,7 @@ func (_HEZ *HEZCaller) InitialBalance(opts *bind.CallOpts) (*big.Int, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "initialBalance")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // InitialBalance is a free data retrieval call binding the contract method 0x18369a2a.
@@ -483,7 +484,7 @@ func (_HEZ *HEZCaller) Name(opts *bind.CallOpts) (string, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "name")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // Name is a free data retrieval call binding the contract method 0x06fdde03.
@@ -509,7 +510,7 @@ func (_HEZ *HEZCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.In
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "nonces", arg0)
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // Nonces is a free data retrieval call binding the contract method 0x7ecebe00.
@@ -535,7 +536,7 @@ func (_HEZ *HEZCaller) Symbol(opts *bind.CallOpts) (string, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "symbol")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
@@ -561,7 +562,7 @@ func (_HEZ *HEZCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
 	)
 	out := ret0
 	err := _HEZ.contract.Call(opts, out, "totalSupply")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
@@ -795,7 +796,7 @@ func (_HEZ *HEZFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Ad
 
 	logs, sub, err := _HEZ.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZApprovalIterator{contract: _HEZ.contract, event: "Approval", logs: logs, sub: sub}, nil
 }
@@ -816,7 +817,7 @@ func (_HEZ *HEZFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *HEZApp
 
 	logs, sub, err := _HEZ.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -826,19 +827,19 @@ func (_HEZ *HEZFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *HEZApp
 				// New log arrived, parse the event and forward to the user
 				event := new(HEZApproval)
 				if err := _HEZ.contract.UnpackLog(event, "Approval", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -852,7 +853,7 @@ func (_HEZ *HEZFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *HEZApp
 func (_HEZ *HEZFilterer) ParseApproval(log types.Log) (*HEZApproval, error) {
 	event := new(HEZApproval)
 	if err := _HEZ.contract.UnpackLog(event, "Approval", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -947,7 +948,7 @@ func (_HEZ *HEZFilterer) FilterAuthorizationUsed(opts *bind.FilterOpts, authoriz
 
 	logs, sub, err := _HEZ.contract.FilterLogs(opts, "AuthorizationUsed", authorizerRule, nonceRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZAuthorizationUsedIterator{contract: _HEZ.contract, event: "AuthorizationUsed", logs: logs, sub: sub}, nil
 }
@@ -968,7 +969,7 @@ func (_HEZ *HEZFilterer) WatchAuthorizationUsed(opts *bind.WatchOpts, sink chan<
 
 	logs, sub, err := _HEZ.contract.WatchLogs(opts, "AuthorizationUsed", authorizerRule, nonceRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -978,19 +979,19 @@ func (_HEZ *HEZFilterer) WatchAuthorizationUsed(opts *bind.WatchOpts, sink chan<
 				// New log arrived, parse the event and forward to the user
 				event := new(HEZAuthorizationUsed)
 				if err := _HEZ.contract.UnpackLog(event, "AuthorizationUsed", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1004,7 +1005,7 @@ func (_HEZ *HEZFilterer) WatchAuthorizationUsed(opts *bind.WatchOpts, sink chan<
 func (_HEZ *HEZFilterer) ParseAuthorizationUsed(log types.Log) (*HEZAuthorizationUsed, error) {
 	event := new(HEZAuthorizationUsed)
 	if err := _HEZ.contract.UnpackLog(event, "AuthorizationUsed", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1100,7 +1101,7 @@ func (_HEZ *HEZFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Add
 
 	logs, sub, err := _HEZ.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &HEZTransferIterator{contract: _HEZ.contract, event: "Transfer", logs: logs, sub: sub}, nil
 }
@@ -1121,7 +1122,7 @@ func (_HEZ *HEZFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *HEZTra
 
 	logs, sub, err := _HEZ.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1131,19 +1132,19 @@ func (_HEZ *HEZFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *HEZTra
 				// New log arrived, parse the event and forward to the user
 				event := new(HEZTransfer)
 				if err := _HEZ.contract.UnpackLog(event, "Transfer", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1157,7 +1158,7 @@ func (_HEZ *HEZFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *HEZTra
 func (_HEZ *HEZFilterer) ParseTransfer(log types.Log) (*HEZTransfer, error) {
 	event := new(HEZTransfer)
 	if err := _HEZ.contract.UnpackLog(event, "Transfer", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }

eth/contracts/withdrawdelayer/WithdrawalDelayer.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
+	"github.com/hermeznetwork/tracerr"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -36,12 +37,12 @@ var WithdrawalDelayerBin = "0x608060405234801561001057600080fd5b50611be680610020
 func DeployWithdrawalDelayer(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *WithdrawalDelayer, error) {
 	parsed, err := abi.JSON(strings.NewReader(WithdrawalDelayerABI))
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 
 	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(WithdrawalDelayerBin), backend)
 	if err != nil {
-		return common.Address{}, nil, nil, err
+		return common.Address{}, nil, nil, tracerr.Wrap(err)
 	}
 	return address, tx, &WithdrawalDelayer{WithdrawalDelayerCaller: WithdrawalDelayerCaller{contract: contract}, WithdrawalDelayerTransactor: WithdrawalDelayerTransactor{contract: contract}, WithdrawalDelayerFilterer: WithdrawalDelayerFilterer{contract: contract}}, nil
 }
@@ -109,7 +110,7 @@ type WithdrawalDelayerTransactorRaw struct {
 func NewWithdrawalDelayer(address common.Address, backend bind.ContractBackend) (*WithdrawalDelayer, error) {
 	contract, err := bindWithdrawalDelayer(address, backend, backend, backend)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayer{WithdrawalDelayerCaller: WithdrawalDelayerCaller{contract: contract}, WithdrawalDelayerTransactor: WithdrawalDelayerTransactor{contract: contract}, WithdrawalDelayerFilterer: WithdrawalDelayerFilterer{contract: contract}}, nil
 }
@@ -118,7 +119,7 @@ func NewWithdrawalDelayer(address common.Address, backend bind.ContractBackend)
 func NewWithdrawalDelayerCaller(address common.Address, caller bind.ContractCaller) (*WithdrawalDelayerCaller, error) {
 	contract, err := bindWithdrawalDelayer(address, caller, nil, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerCaller{contract: contract}, nil
 }
@@ -127,7 +128,7 @@ func NewWithdrawalDelayerCaller(address common.Address, caller bind.ContractCall
 func NewWithdrawalDelayerTransactor(address common.Address, transactor bind.ContractTransactor) (*WithdrawalDelayerTransactor, error) {
 	contract, err := bindWithdrawalDelayer(address, nil, transactor, nil)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerTransactor{contract: contract}, nil
 }
@@ -136,7 +137,7 @@ func NewWithdrawalDelayerTransactor(address common.Address, transactor bind.Cont
 func NewWithdrawalDelayerFilterer(address common.Address, filterer bind.ContractFilterer) (*WithdrawalDelayerFilterer, error) {
 	contract, err := bindWithdrawalDelayer(address, nil, nil, filterer)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerFilterer{contract: contract}, nil
 }
@@ -145,7 +146,7 @@ func NewWithdrawalDelayerFilterer(address common.Address, filterer bind.Contract
 func bindWithdrawalDelayer(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 	parsed, err := abi.JSON(strings.NewReader(WithdrawalDelayerABI))
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 }
@@ -197,7 +198,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) MAXEMERGENCYMODETIME(opts *bi
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "MAX_EMERGENCY_MODE_TIME")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // MAXEMERGENCYMODETIME is a free data retrieval call binding the contract method 0xb4b8e39d.
@@ -223,7 +224,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) MAXWITHDRAWALDELAY(opts *bind
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "MAX_WITHDRAWAL_DELAY")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // MAXWITHDRAWALDELAY is a free data retrieval call binding the contract method 0xa238f9df.
@@ -253,7 +254,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) DepositInfo(opts *bind.CallOp
 		ret1,
 	}
 	err := _WithdrawalDelayer.contract.Call(opts, out, "depositInfo", _owner, _token)
-	return *ret0, *ret1, err
+	return *ret0, *ret1, tracerr.Wrap(err)
 }
 
 // DepositInfo is a free data retrieval call binding the contract method 0x493b0170.
@@ -283,7 +284,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) Deposits(opts *bind.CallOpts,
 	})
 	out := ret
 	err := _WithdrawalDelayer.contract.Call(opts, out, "deposits", arg0)
-	return *ret, err
+	return *ret, tracerr.Wrap(err)
 }
 
 // Deposits is a free data retrieval call binding the contract method 0x3d4dff7b.
@@ -315,7 +316,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) GetEmergencyModeStartingTime(
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "getEmergencyModeStartingTime")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetEmergencyModeStartingTime is a free data retrieval call binding the contract method 0x668cdd67.
@@ -341,7 +342,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) GetHermezGovernanceDAOAddress
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "getHermezGovernanceDAOAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetHermezGovernanceDAOAddress is a free data retrieval call binding the contract method 0x580fc611.
@@ -367,7 +368,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) GetHermezKeeperAddress(opts *
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "getHermezKeeperAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetHermezKeeperAddress is a free data retrieval call binding the contract method 0x305887f9.
@@ -393,7 +394,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) GetWhiteHackGroupAddress(opts
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "getWhiteHackGroupAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetWhiteHackGroupAddress is a free data retrieval call binding the contract method 0xae7efbbd.
@@ -419,7 +420,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) GetWithdrawalDelay(opts *bind
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "getWithdrawalDelay")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // GetWithdrawalDelay is a free data retrieval call binding the contract method 0x03160940.
@@ -445,7 +446,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) HermezRollupAddress(opts *bin
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "hermezRollupAddress")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // HermezRollupAddress is a free data retrieval call binding the contract method 0x0fd266d7.
@@ -471,7 +472,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerCaller) IsEmergencyMode(opts *bind.Ca
 	)
 	out := ret0
 	err := _WithdrawalDelayer.contract.Call(opts, out, "isEmergencyMode")
-	return *ret0, err
+	return *ret0, tracerr.Wrap(err)
 }
 
 // IsEmergencyMode is a free data retrieval call binding the contract method 0x20a194b8.
@@ -769,7 +770,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterDeposit(opts *bind.Fi
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "Deposit", ownerRule, tokenRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerDepositIterator{contract: _WithdrawalDelayer.contract, event: "Deposit", logs: logs, sub: sub}, nil
 }
@@ -790,7 +791,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchDeposit(opts *bind.Wat
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "Deposit", ownerRule, tokenRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -800,19 +801,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchDeposit(opts *bind.Wat
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerDeposit)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "Deposit", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -826,7 +827,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchDeposit(opts *bind.Wat
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseDeposit(log types.Log) (*WithdrawalDelayerDeposit, error) {
 	event := new(WithdrawalDelayerDeposit)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "Deposit", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -910,7 +911,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterEmergencyModeEnabled(
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "EmergencyModeEnabled")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerEmergencyModeEnabledIterator{contract: _WithdrawalDelayer.contract, event: "EmergencyModeEnabled", logs: logs, sub: sub}, nil
 }
@@ -922,7 +923,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchEmergencyModeEnabled(o
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "EmergencyModeEnabled")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -932,19 +933,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchEmergencyModeEnabled(o
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerEmergencyModeEnabled)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "EmergencyModeEnabled", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -958,7 +959,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchEmergencyModeEnabled(o
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseEmergencyModeEnabled(log types.Log) (*WithdrawalDelayerEmergencyModeEnabled, error) {
 	event := new(WithdrawalDelayerEmergencyModeEnabled)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "EmergencyModeEnabled", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1059,7 +1060,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterEscapeHatchWithdrawal
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "EscapeHatchWithdrawal", whoRule, toRule, tokenRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerEscapeHatchWithdrawalIterator{contract: _WithdrawalDelayer.contract, event: "EscapeHatchWithdrawal", logs: logs, sub: sub}, nil
 }
@@ -1084,7 +1085,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchEscapeHatchWithdrawal(
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "EscapeHatchWithdrawal", whoRule, toRule, tokenRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1094,19 +1095,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchEscapeHatchWithdrawal(
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerEscapeHatchWithdrawal)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "EscapeHatchWithdrawal", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1120,7 +1121,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchEscapeHatchWithdrawal(
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseEscapeHatchWithdrawal(log types.Log) (*WithdrawalDelayerEscapeHatchWithdrawal, error) {
 	event := new(WithdrawalDelayerEscapeHatchWithdrawal)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "EscapeHatchWithdrawal", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1205,7 +1206,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterNewHermezGovernanceDA
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "NewHermezGovernanceDAOAddress")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerNewHermezGovernanceDAOAddressIterator{contract: _WithdrawalDelayer.contract, event: "NewHermezGovernanceDAOAddress", logs: logs, sub: sub}, nil
 }
@@ -1217,7 +1218,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewHermezGovernanceDAO
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "NewHermezGovernanceDAOAddress")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1227,19 +1228,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewHermezGovernanceDAO
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerNewHermezGovernanceDAOAddress)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewHermezGovernanceDAOAddress", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1253,7 +1254,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewHermezGovernanceDAO
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseNewHermezGovernanceDAOAddress(log types.Log) (*WithdrawalDelayerNewHermezGovernanceDAOAddress, error) {
 	event := new(WithdrawalDelayerNewHermezGovernanceDAOAddress)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewHermezGovernanceDAOAddress", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1338,7 +1339,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterNewHermezKeeperAddres
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "NewHermezKeeperAddress")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerNewHermezKeeperAddressIterator{contract: _WithdrawalDelayer.contract, event: "NewHermezKeeperAddress", logs: logs, sub: sub}, nil
 }
@@ -1350,7 +1351,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewHermezKeeperAddress
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "NewHermezKeeperAddress")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1360,19 +1361,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewHermezKeeperAddress
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerNewHermezKeeperAddress)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewHermezKeeperAddress", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1386,7 +1387,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewHermezKeeperAddress
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseNewHermezKeeperAddress(log types.Log) (*WithdrawalDelayerNewHermezKeeperAddress, error) {
 	event := new(WithdrawalDelayerNewHermezKeeperAddress)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewHermezKeeperAddress", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1471,7 +1472,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterNewWhiteHackGroupAddr
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "NewWhiteHackGroupAddress")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerNewWhiteHackGroupAddressIterator{contract: _WithdrawalDelayer.contract, event: "NewWhiteHackGroupAddress", logs: logs, sub: sub}, nil
 }
@@ -1483,7 +1484,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewWhiteHackGroupAddre
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "NewWhiteHackGroupAddress")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1493,19 +1494,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewWhiteHackGroupAddre
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerNewWhiteHackGroupAddress)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewWhiteHackGroupAddress", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1519,7 +1520,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewWhiteHackGroupAddre
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseNewWhiteHackGroupAddress(log types.Log) (*WithdrawalDelayerNewWhiteHackGroupAddress, error) {
 	event := new(WithdrawalDelayerNewWhiteHackGroupAddress)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewWhiteHackGroupAddress", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1604,7 +1605,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterNewWithdrawalDelay(op
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "NewWithdrawalDelay")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerNewWithdrawalDelayIterator{contract: _WithdrawalDelayer.contract, event: "NewWithdrawalDelay", logs: logs, sub: sub}, nil
 }
@@ -1616,7 +1617,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewWithdrawalDelay(opt
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "NewWithdrawalDelay")
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1626,19 +1627,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewWithdrawalDelay(opt
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerNewWithdrawalDelay)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewWithdrawalDelay", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1652,7 +1653,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchNewWithdrawalDelay(opt
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseNewWithdrawalDelay(log types.Log) (*WithdrawalDelayerNewWithdrawalDelay, error) {
 	event := new(WithdrawalDelayerNewWithdrawalDelay)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "NewWithdrawalDelay", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }
@@ -1748,7 +1749,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) FilterWithdraw(opts *bind.F
 
 	logs, sub, err := _WithdrawalDelayer.contract.FilterLogs(opts, "Withdraw", tokenRule, ownerRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &WithdrawalDelayerWithdrawIterator{contract: _WithdrawalDelayer.contract, event: "Withdraw", logs: logs, sub: sub}, nil
 }
@@ -1769,7 +1770,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchWithdraw(opts *bind.Wa
 
 	logs, sub, err := _WithdrawalDelayer.contract.WatchLogs(opts, "Withdraw", tokenRule, ownerRule)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		defer sub.Unsubscribe()
@@ -1779,19 +1780,19 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchWithdraw(opts *bind.Wa
 				// New log arrived, parse the event and forward to the user
 				event := new(WithdrawalDelayerWithdraw)
 				if err := _WithdrawalDelayer.contract.UnpackLog(event, "Withdraw", log); err != nil {
-					return err
+					return tracerr.Wrap(err)
 				}
 				event.Raw = log
 
 				select {
 				case sink <- event:
 				case err := <-sub.Err():
-					return err
+					return tracerr.Wrap(err)
 				case <-quit:
 					return nil
 				}
 			case err := <-sub.Err():
-				return err
+				return tracerr.Wrap(err)
 			case <-quit:
 				return nil
 			}
@@ -1805,7 +1806,7 @@ func (_WithdrawalDelayer *WithdrawalDelayerFilterer) WatchWithdraw(opts *bind.Wa
 func (_WithdrawalDelayer *WithdrawalDelayerFilterer) ParseWithdraw(log types.Log) (*WithdrawalDelayerWithdraw, error) {
 	event := new(WithdrawalDelayerWithdraw)
 	if err := _WithdrawalDelayer.contract.UnpackLog(event, "Withdraw", log); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return event, nil
 }