Fixed multi-tx functions

Author: jclapis

src/rocketpool-cli/commands/node/stake-rpl.go

@@ -97,7 +97,7 @@ func nodeStakeRpl(c *cli.Context) error {
 	}
 
 	// Handle boosting the allowance
-	if stakeResponse.Data.Allowance.Cmp(amountWei) < 0 {
+	if stakeResponse.Data.ApproveTxInfo != nil {
 		fmt.Println("Before staking RPL, you must first give the staking contract approval to interact with your RPL.")
 		fmt.Println("This only needs to be done once for your node.")
 
@@ -106,7 +106,7 @@ func nodeStakeRpl(c *cli.Context) error {
 			utils.PrintMultiTransactionNonceWarning()
 		}
 
-		// Run the approve TX
+		// Run the Approve TX
 		validated, err := tx.HandleTx(c, rp, stakeResponse.Data.ApproveTxInfo,
 			"Do you want to let the staking contract interact with your RPL?",
 			"approving RPL for staking",
@@ -119,6 +119,11 @@ func nodeStakeRpl(c *cli.Context) error {
 			fmt.Println("Successfully approved staking access to RPL.")
 		}
 
+		// Build the stake TX once approval is done
+		stakeResponse, err = rp.Api.Node.StakeRpl(amountWei)
+		if err != nil {
+			return err
+		}
 	}
 
 	// Run the stake TX

src/rocketpool-cli/commands/node/utils.go

@@ -414,7 +414,7 @@ func SwapRpl(c *cli.Context, rp *client.Client, amountWei *big.Int) error {
 	}
 
 	// Handle boosting the allowance
-	if response.Data.Allowance.Cmp(amountWei) < 0 {
+	if response.Data.ApproveTxInfo != nil {
 		fmt.Println("Before swapping legacy RPL for new RPL, you must first give the new RPL contract approval to interact with your legacy RPL.")
 		fmt.Println("This only needs to be done once for your node.")
 
@@ -436,6 +436,11 @@ func SwapRpl(c *cli.Context, rp *client.Client, amountWei *big.Int) error {
 			fmt.Println("Successfully approved access to legacy RPL.")
 		}
 
+		// Get the TX once approval is done
+		response, err = rp.Api.Node.SwapRpl(amountWei)
+		if err != nil {
+			return err
+		}
 	}
 
 	// Run the swap TX

src/rocketpool-cli/commands/odao/join.go

@@ -54,35 +54,44 @@ func join(c *cli.Context) error {
 	if !response.Data.CanJoin {
 		fmt.Println("Cannot join the oracle DAO:")
 		if response.Data.ProposalExpired {
-			fmt.Println("The proposal for you to join the oracle DAO does not exist or has expired.")
+			fmt.Println("The proposal for you to join the Oracle DAO does not exist or has expired.")
 		}
 		if response.Data.AlreadyMember {
-			fmt.Println("The node is already a member of the oracle DAO.")
+			fmt.Println("The node is already a member of the Oracle DAO.")
 		}
 		if response.Data.InsufficientRplBalance {
 			fmt.Println("The node does not have enough RPL to pay the RPL bond.")
 		}
 		return nil
 	}
 
-	// Run the Approve TX
-	validated, err := tx.HandleTx(c, rp, response.Data.ApproveTxInfo,
-		"Do you want to let the Oracle DAO manager interact with your RPL? This is required to post your bond in order to join it.",
-		"approving RPL for bond",
-		"Approving RPL for joining the Oracle DAO...",
-	)
-	if err != nil {
-		return err
-	}
-	if validated {
-		fmt.Println("Successfully approved bond access to RPL.")
+	// Check if approval is required first
+	if response.Data.ApproveTxInfo != nil {
+		// Run the Approve TX
+		validated, err := tx.HandleTx(c, rp, response.Data.ApproveTxInfo,
+			"Do you want to let the Oracle DAO manager interact with your RPL? This is required to post your bond in order to join it.",
+			"approving RPL for bond",
+			"Approving RPL for joining the Oracle DAO...",
+		)
+		if err != nil {
+			return err
+		}
+		if validated {
+			fmt.Println("Successfully approved bond access to RPL.")
+		}
+
+		// Build the Join TX once approval is done
+		response, err = rp.Api.ODao.Join()
+		if err != nil {
+			return err
+		}
 	}
 
 	// Run the Join TX
-	validated, err = tx.HandleTx(c, rp, response.Data.JoinTxInfo,
+	validated, err := tx.HandleTx(c, rp, response.Data.JoinTxInfo,
 		"Are you sure you want to join the oracle DAO? Your RPL bond will be locked until you leave.",
 		"joining Oracle DAO",
-		"Joining the ODAO...",
+		"Joining the Oracle DAO...",
 	)
 	if err != nil {
 		return err
@@ -92,6 +101,6 @@ func join(c *cli.Context) error {
 	}
 
 	// Log & return
-	fmt.Println("Successfully joined the oracle DAO.")
+	fmt.Println("Successfully joined the Oracle DAO.")
 	return nil
 }

src/rocketpool-daemon/api/node/stake-rpl.go

@@ -100,21 +100,22 @@ func (c *nodeStakeRplContext) PrepareData(data *api.NodeStakeRplData, opts *bind
 	data.CanStake = !(data.InsufficientBalance)
 
 	if data.CanStake {
-		// Check allowance
-		if c.amount.Cmp(c.allowance) > 0 {
-			approvalAmount := big.NewInt(0).Sub(c.amount, c.allowance)
+		if c.allowance.Cmp(c.amount) < 0 {
+			// Do the approve TX if needed
+			approvalAmount := getMaxApproval()
 			txInfo, err := c.rpl.Approve(c.nsAddress, approvalAmount, opts)
 			if err != nil {
 				return types.ResponseStatus_Error, fmt.Errorf("error getting TX info to approve increasing RPL's allowance: %w", err)
 			}
 			data.ApproveTxInfo = txInfo
+		} else {
+			// Just do the stake
+			txInfo, err := c.node.StakeRpl(c.amount, opts)
+			if err != nil {
+				return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for StakeRpl: %w", err)
+			}
+			data.StakeTxInfo = txInfo
 		}
-
-		txInfo, err := c.node.StakeRpl(c.amount, opts)
-		if err != nil {
-			return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for StakeRpl: %w", err)
-		}
-		data.StakeTxInfo = txInfo
 	}
 	return types.ResponseStatus_Success, nil
 }

src/rocketpool-daemon/api/node/swap-rpl.go

@@ -99,24 +99,22 @@ func (c *nodeSwapRplContext) PrepareData(data *api.NodeSwapRplData, opts *bind.T
 	data.CanSwap = !(data.InsufficientBalance)
 
 	if data.CanSwap {
-		// Check allowance
-		if c.amount.Cmp(c.allowance) > 0 {
-			// Calculate max uint256 value
-			approvalAmount := big.NewInt(2)
-			approvalAmount = approvalAmount.Exp(approvalAmount, big.NewInt(256), nil)
-			approvalAmount = approvalAmount.Sub(approvalAmount, big.NewInt(1))
+		if c.allowance.Cmp(c.amount) < 0 {
+			// Do the approve TX if needed
+			approvalAmount := getMaxApproval()
 			txInfo, err := c.fsrpl.Approve(c.rplAddress, approvalAmount, opts)
 			if err != nil {
 				return types.ResponseStatus_Error, fmt.Errorf("error getting TX info to approve increasing legacy RPL's allowance: %w", err)
 			}
 			data.ApproveTxInfo = txInfo
+		} else {
+			// Just do the swap
+			txInfo, err := c.rpl.SwapFixedSupplyRplForRpl(c.amount, opts)
+			if err != nil {
+				return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for SwapFixedSupplyRPLForRPL: %w", err)
+			}
+			data.SwapTxInfo = txInfo
 		}
-
-		txInfo, err := c.rpl.SwapFixedSupplyRplForRpl(c.amount, opts)
-		if err != nil {
-			return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for SwapFixedSupplyRPLForRPL: %w", err)
-		}
-		data.SwapTxInfo = txInfo
 	}
 	return types.ResponseStatus_Success, nil
 }

src/rocketpool-daemon/api/node/utils.go

@@ -0,0 +1,11 @@
+package node
+
+import "math/big"
+
+func getMaxApproval() *big.Int {
+	// Calculate max uint256 value
+	maxApproval := big.NewInt(2)
+	maxApproval = maxApproval.Exp(maxApproval, big.NewInt(256), nil)
+	maxApproval = maxApproval.Sub(maxApproval, big.NewInt(1))
+	return maxApproval
+}

src/rocketpool-daemon/api/odao/join.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gorilla/mux"
 	batch "github.com/rocket-pool/batch-query"
 	"github.com/rocket-pool/node-manager-core/eth"
+	"github.com/rocket-pool/rocketpool-go/core"
 	"github.com/rocket-pool/rocketpool-go/dao/oracle"
 	"github.com/rocket-pool/rocketpool-go/rocketpool"
 	"github.com/rocket-pool/rocketpool-go/tokens"
@@ -49,12 +50,14 @@ type oracleDaoJoinContext struct {
 	handler     *OracleDaoHandler
 	rp          *rocketpool.RocketPool
 	nodeAddress common.Address
-
-	odaoMember *oracle.OracleDaoMember
-	odaoMgr    *oracle.OracleDaoManager
-	oSettings  *oracle.OracleDaoSettings
-	rpl        *tokens.TokenRpl
-	rplBalance *big.Int
+	dnta        *core.Contract
+
+	odaoMember   *oracle.OracleDaoMember
+	odaoMgr      *oracle.OracleDaoManager
+	oSettings    *oracle.OracleDaoSettings
+	rpl          *tokens.TokenRpl
+	rplBalance   *big.Int
+	rplAllowance *big.Int
 }
 
 func (c *oracleDaoJoinContext) Initialize() (types.ResponseStatus, error) {
@@ -82,6 +85,10 @@ func (c *oracleDaoJoinContext) Initialize() (types.ResponseStatus, error) {
 		return types.ResponseStatus_Error, fmt.Errorf("error creating Oracle DAO manager binding: %w", err)
 	}
 	c.oSettings = c.odaoMgr.Settings
+	c.dnta, err = c.rp.GetContract(rocketpool.ContractName_RocketDAONodeTrustedActions)
+	if err != nil {
+		return types.ResponseStatus_Error, fmt.Errorf("error getting RPL token contract: %w", err)
+	}
 	return types.ResponseStatus_Success, nil
 }
 
@@ -92,6 +99,7 @@ func (c *oracleDaoJoinContext) GetState(mc *batch.MultiCaller) {
 		c.odaoMember.Exists,
 		c.oSettings.Member.RplBond,
 	)
+	c.rpl.GetAllowance(mc, &c.rplAllowance, c.nodeAddress, c.dnta.Address)
 	c.rpl.BalanceOf(mc, &c.rplBalance, c.nodeAddress)
 }
 
@@ -113,23 +121,23 @@ func (c *oracleDaoJoinContext) PrepareData(data *api.OracleDaoJoinData, opts *bi
 	data.CanJoin = !(data.ProposalExpired || data.AlreadyMember || data.InsufficientRplBalance)
 
 	// Get the tx
-	if data.CanJoin && opts != nil {
-		dnta, err := c.rp.GetContract(rocketpool.ContractName_RocketDAONodeTrustedActions)
-		if err != nil {
-			return types.ResponseStatus_Error, fmt.Errorf("error getting RPL token contract: %w", err)
-		}
-
-		approveTxInfo, err := c.rpl.Approve(dnta.Address, rplBond, opts)
-		if err != nil {
-			return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for RPL approval: %w", err)
-		}
-		data.ApproveTxInfo = approveTxInfo
-
-		joinTxInfo, err := c.odaoMgr.Join(opts)
-		if err != nil {
-			return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for Join: %w", err)
+	if data.CanJoin {
+		if c.rplAllowance.Cmp(rplBond) < 0 {
+			// Do the approve TX if needed
+			diff := big.NewInt(0).Sub(rplBond, c.rplAllowance)
+			approveTxInfo, err := c.rpl.Approve(c.dnta.Address, diff, opts)
+			if err != nil {
+				return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for RPL approval: %w", err)
+			}
+			data.ApproveTxInfo = approveTxInfo
+		} else {
+			// Just do the join
+			joinTxInfo, err := c.odaoMgr.Join(opts)
+			if err != nil {
+				return types.ResponseStatus_Error, fmt.Errorf("error getting TX info for Join: %w", err)
+			}
+			data.JoinTxInfo = joinTxInfo
 		}
-		data.JoinTxInfo = joinTxInfo
 	}
 	return types.ResponseStatus_Success, nil
 }