chore(solver/app): approve outbox spend in fulfill

solver/app/app.go

@@ -229,7 +229,7 @@ func startEventStreams(
 		ShouldReject: newShouldRejector(network.ID),
 		Accept:       newAcceptor(inboxContracts, backends, solverAddr),
 		Reject:       newRejector(inboxContracts, backends, solverAddr),
-		Fulfill:      newFulfiller(network.ID, outboxContracts, backends, solverAddr),
+		Fulfill:      newFulfiller(network.ID, outboxContracts, backends, solverAddr, addrs.SolveOutbox),
 		Claim:        newClaimer(inboxContracts, backends, solverAddr),
 		SetCursor:    cursorSetter,
 	}

solver/app/deps.go

@@ -2,12 +2,15 @@ package app
 
 import (
 	"context"
+	"math"
+	"math/big"
 
 	"github.com/omni-network/omni/contracts/bindings"
 	"github.com/omni-network/omni/lib/errors"
 	"github.com/omni-network/omni/lib/ethclient/ethbackend"
 	"github.com/omni-network/omni/lib/log"
 	"github.com/omni-network/omni/lib/netconf"
+	"github.com/omni-network/omni/lib/umath"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -65,7 +68,7 @@ func newFulfiller(
 	network netconf.ID,
 	outboxContracts map[uint64]*bindings.SolveOutbox,
 	backends ethbackend.Backends,
-	solverAddr common.Address,
+	solverAddr, outboxAddr common.Address,
 ) func(ctx context.Context, chainID uint64, req bindings.SolveRequest) error {
 	return func(ctx context.Context, chainID uint64, req bindings.SolveRequest) error {
 		outbox, ok := outboxContracts[chainID]
@@ -78,12 +81,13 @@ func newFulfiller(
 			return err
 		}
 
+		callOpts := &bind.CallOpts{Context: ctx}
 		txOpts, err := backend.BindOpts(ctx, solverAddr)
 		if err != nil {
 			return err
 		}
 
-		if ok, err := outbox.DidFulfill(&bind.CallOpts{Context: ctx}, req.Id, chainID, req.Call); err != nil {
+		if ok, err := outbox.DidFulfill(callOpts, req.Id, chainID, req.Call); err != nil {
 			return errors.Wrap(err, "did fulfill")
 		} else if ok {
 			log.Info(ctx, "Skipping already fulfilled request", "req_id", req.Id)
@@ -100,6 +104,12 @@ func newFulfiller(
 			return errors.Wrap(err, "get token prereqs")
 		}
 
+		for _, prereq := range prereqs {
+			if err := approveOutboxSpend(ctx, prereq, backend, solverAddr, outboxAddr); err != nil {
+				return errors.Wrap(err, "approve outbox spend")
+			}
+		}
+
 		tx, err := outbox.Fulfill(txOpts, req.Id, chainID, req.Call, prereqs)
 		if err != nil {
 			return errors.Wrap(err, "fulfill request")
@@ -111,6 +121,37 @@ func newFulfiller(
 	}
 }
 
+func approveOutboxSpend(ctx context.Context, prereq bindings.SolveTokenPrereq, backend *ethbackend.Backend, solverAddr, outboxAddr common.Address) error {
+	token, err := bindings.NewMockToken(prereq.Token, backend)
+	if err != nil {
+		return errors.Wrap(err, "new token")
+	}
+
+	allowance, err := token.Allowance(&bind.CallOpts{Context: ctx}, solverAddr, outboxAddr)
+	if err != nil {
+		return errors.Wrap(err, "get allowance")
+	}
+
+	if new(big.Int).Sub(allowance, prereq.Amount).Sign() >= 0 {
+		return nil // Already approved
+	}
+
+	txOpts, err := backend.BindOpts(ctx, solverAddr)
+	if err != nil {
+		return err
+	}
+
+	var approveForever = umath.NewBigInt(math.MaxUint64)
+	tx, err := token.Approve(txOpts, outboxAddr, approveForever)
+	if err != nil {
+		return errors.Wrap(err, "approve token")
+	} else if _, err := backend.WaitMined(ctx, tx); err != nil {
+		return errors.Wrap(err, "wait mined")
+	}
+
+	return nil
+}
+
 func newRejector(
 	inboxContracts map[uint64]*bindings.SolveInbox,
 	backends ethbackend.Backends,