feat: polycli fund support for bulk token approval

Signed-off-by: Ji Hwan <[email protected]>

Author: jhkimqd

cmd/fund/cmd.go

@@ -40,6 +40,8 @@ type cmdFundParams struct {
 	TokenAddress           string
 	TokenAmount            *big.Int
 	ERC20BulkMinterAddress string
+	ApproveSpender         string
+	ApproveAmount          *big.Int
 }
 
 var (
@@ -91,6 +93,10 @@ func init() {
 	params.TokenAmount.SetString("1000000000000000000", 10) // 1 token
 	f.Var(&flag_loader.BigIntValue{Val: params.TokenAmount}, "token-amount", "amount of ERC20 tokens to mint and transfer to each wallet")
 	f.StringVar(&params.ERC20BulkMinterAddress, "erc20-bulk-funder-address", "", "address of pre-deployed ERC20BulkFunder contract")
+	f.StringVar(&params.ApproveSpender, "approve-spender", "", "address to approve for spending tokens from each funded wallet")
+	params.ApproveAmount = new(big.Int)
+	params.ApproveAmount.SetString("1000000000000000000000", 10) // 1000 tokens default
+	f.Var(&flag_loader.BigIntValue{Val: params.ApproveAmount}, "approve-amount", "amount of ERC20 tokens to approve for the spender")
 
 	// Marking flags as mutually exclusive
 	FundCmd.MarkFlagsMutuallyExclusive("addresses", "number")
@@ -166,6 +172,12 @@ func checkFlags() error {
 		if params.TokenAmount == nil || params.TokenAmount.Cmp(big.NewInt(0)) <= 0 {
 			return errors.New("token amount must be greater than 0 when using ERC20 mode")
 		}
+		// Validate approve parameters if provided
+		if params.ApproveSpender != "" {
+			if params.ApproveAmount == nil || params.ApproveAmount.Cmp(big.NewInt(0)) <= 0 {
+				return errors.New("approve amount must be greater than 0 when approve spender is specified")
+			}
+		}
 		// In ERC20 mode, ETH funding is still supported alongside token minting
 	}
 

cmd/fund/fund.go

@@ -81,7 +81,7 @@ func runFunding(ctx context.Context) error {
 	// If ERC20 mode is enabled, fund with tokens instead of ETH
 	if params.TokenAddress != "" {
 		log.Info().Str("tokenAddress", params.TokenAddress).Msg("Starting ERC20 token funding (ETH funding disabled)")
-		if err = fundWalletsWithERC20(ctx, c, tops, privateKey, addresses); err != nil {
+		if err = fundWalletsWithERC20(ctx, c, tops, privateKey, addresses, privateKeys); err != nil {
 			return err
 		}
 		log.Info().Msg("Wallet(s) funded with ERC20 tokens! 🪙")
@@ -378,8 +378,8 @@ func getAddressesAndKeysFromSeed(seed string, numWallets int) ([]common.Address,
 	return addresses, privateKeys, nil
 }
 
-// fundWalletsWithERC20 funds multiple wallets with ERC20 tokens by minting to the funding account and transferring.
-func fundWalletsWithERC20(ctx context.Context, c *ethclient.Client, tops *bind.TransactOpts, privateKey *ecdsa.PrivateKey, wallets []common.Address) error {
+// fundWalletsWithERC20 funds multiple wallets with ERC20 tokens by minting directly to each wallet and optionally approving a spender.
+func fundWalletsWithERC20(ctx context.Context, c *ethclient.Client, tops *bind.TransactOpts, privateKey *ecdsa.PrivateKey, wallets []common.Address, walletsPrivateKeys []*ecdsa.PrivateKey) error {
 	if len(wallets) == 0 {
 		return errors.New("no wallet to fund with ERC20 tokens")
 	}
@@ -411,6 +411,56 @@ func fundWalletsWithERC20(ctx context.Context, c *ethclient.Client, tops *bind.T
 		}
 	}
 
-	log.Info().Int("count", len(wallets)).Str("amount", params.TokenAmount.String()).Msg("Successfully funded all wallets with tokens")
+	log.Info().Int("count", len(wallets)).Str("amount", params.TokenAmount.String()).Msg("Successfully minted tokens to all wallets")
+
+	// If approve spender is specified, approve tokens from each wallet
+	if params.ApproveSpender != "" && len(walletsPrivateKeys) > 0 {
+		spenderAddress := common.HexToAddress(params.ApproveSpender)
+		log.Info().Str("spender", spenderAddress.String()).Str("amount", params.ApproveAmount.String()).Msg("Starting bulk approve for all wallets")
+
+		// Create ABI for approve(address, uint256) function
+		approveABI, err := abi.JSON(strings.NewReader(`[{"type":"function","name":"approve","inputs":[{"name":"spender","type":"address"},{"name":"amount","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"stateMutability":"nonpayable"}]`))
+		if err != nil {
+			log.Error().Err(err).Msg("Unable to parse approve ABI")
+			return err
+		}
+
+		// Get chain ID for signing transactions
+		chainID, err := c.ChainID(ctx)
+		if err != nil {
+			log.Error().Err(err).Msg("Unable to get chain ID for approve transactions")
+			return err
+		}
+
+		// Approve from each wallet
+		for i, walletPrivateKey := range walletsPrivateKeys {
+			if i >= len(wallets) {
+				break // Safety check
+			}
+
+			wallet := wallets[i]
+			log.Debug().Int("wallet", i+1).Int("total", len(wallets)).Str("address", wallet.String()).Str("spender", spenderAddress.String()).Str("amount", params.ApproveAmount.String()).Msg("Approving spender from wallet")
+
+			// Create transaction options for this wallet
+			walletTops, err := bind.NewKeyedTransactorWithChainID(walletPrivateKey, chainID)
+			if err != nil {
+				log.Error().Err(err).Str("wallet", wallet.String()).Msg("Unable to create transaction signer for wallet")
+				return err
+			}
+
+			// Create bound contract for approve call
+			approveContract := bind.NewBoundContract(tokenAddress, approveABI, c, c, c)
+
+			// Call approve(address, uint256) function from this wallet
+			_, err = approveContract.Transact(walletTops, "approve", spenderAddress, params.ApproveAmount)
+			if err != nil {
+				log.Error().Err(err).Str("wallet", wallet.String()).Str("spender", spenderAddress.String()).Msg("Unable to approve spender from wallet")
+				return err
+			}
+		}
+
+		log.Info().Int("count", len(wallets)).Str("spender", spenderAddress.String()).Str("amount", params.ApproveAmount.String()).Msg("Successfully approved spender for all wallets")
+	}
+
 	return nil
 }