feat: bulk funding erc20 tokens

Signed-off-by: Ji Hwan <jkim@polygon.technology>

Author: jhkimqd

cmd/fund/cmd.go

@@ -35,6 +35,11 @@ type cmdFundParams struct {
 	Seed    string
 
 	FunderAddress string
+
+	// ERC20 specific parameters
+	TokenAddress           string
+	TokenAmount            *big.Int
+	ERC20BulkMinterAddress string
 }
 
 var (
@@ -80,6 +85,13 @@ func init() {
 
 	f.StringVarP(&params.OutputFile, "file", "f", "wallets.json", "output JSON file path for storing addresses and private keys of funded wallets")
 
+	// ERC20 parameters
+	f.StringVar(&params.TokenAddress, "token-address", "", "address of the ERC20 token contract to mint and fund (if provided, enables ERC20 mode)")
+	params.TokenAmount = new(big.Int)
+	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")
+
 	// Marking flags as mutually exclusive
 	FundCmd.MarkFlagsMutuallyExclusive("addresses", "number")
 	FundCmd.MarkFlagsMutuallyExclusive("addresses", "hd-derivation")
@@ -148,5 +160,14 @@ func checkFlags() error {
 		return errors.New("the output file is not specified")
 	}
 
+	// ERC20 specific validations
+	if params.TokenAddress != "" {
+		// ERC20 mode - validate token parameters
+		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")
+		}
+		// In ERC20 mode, ETH funding is still supported alongside token minting
+	}
+
 	return nil
 }

cmd/fund/fund.go

@@ -16,6 +16,7 @@ import (
 	"github.com/0xPolygon/polygon-cli/bindings/funder"
 	"github.com/0xPolygon/polygon-cli/hdwallet"
 	"github.com/0xPolygon/polygon-cli/util"
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -77,18 +78,27 @@ func runFunding(ctx context.Context) error {
 		}()
 	}
 
-	// Deploy or instantiate the Funder contract.
-	var contract *funder.Funder
-	contract, err = deployOrInstantiateFunderContract(ctx, c, tops, privateKey, len(addresses))
-	if err != nil {
-		return err
-	}
+	// 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 {
+			return err
+		}
+		log.Info().Msg("Wallet(s) funded with ERC20 tokens! 🪙")
+	} else {
+		// Deploy or instantiate the Funder contract.
+		var contract *funder.Funder
+		contract, err = deployOrInstantiateFunderContract(ctx, c, tops, privateKey, len(addresses))
+		if err != nil {
+			return err
+		}
 
-	// Fund wallets.
-	if err = fundWallets(ctx, c, tops, contract, addresses); err != nil {
-		return err
+		// Fund wallets with ETH.
+		if err = fundWallets(ctx, c, tops, contract, addresses); err != nil {
+			return err
+		}
+		log.Info().Msg("Wallet(s) funded with ETH! 💸")
 	}
-	log.Info().Msg("Wallet(s) funded! 💸")
 
 	log.Info().Msgf("Total execution time: %s", time.Since(startTime))
 	return nil
@@ -367,3 +377,40 @@ func getAddressesAndKeysFromSeed(seed string, numWallets int) ([]common.Address,
 	log.Info().Int("count", numWallets).Msg("Wallet(s) generated from seed")
 	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 {
+	if len(wallets) == 0 {
+		return errors.New("no wallet to fund with ERC20 tokens")
+	}
+
+	// Get the token contract instance
+	tokenAddress := common.HexToAddress(params.TokenAddress)
+
+	log.Info().Int("wallets", len(wallets)).Str("amountPerWallet", params.TokenAmount.String()).Msg("Minting tokens directly to each wallet")
+
+	// Create ABI for mint(address, uint256) function since the generated binding has wrong signature
+	mintABI, err := abi.JSON(strings.NewReader(`[{"type":"function","name":"mint","inputs":[{"name":"to","type":"address"},{"name":"amount","type":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}]`))
+	if err != nil {
+		log.Error().Err(err).Msg("Unable to parse mint ABI")
+		return err
+	}
+
+	// Create bound contract with the correct ABI
+	mintContract := bind.NewBoundContract(tokenAddress, mintABI, c, c, c)
+
+	// Mint tokens directly to each wallet
+	for i, wallet := range wallets {
+		log.Debug().Int("wallet", i+1).Int("total", len(wallets)).Str("address", wallet.String()).Str("amount", params.TokenAmount.String()).Msg("Minting tokens directly to wallet")
+
+		// Call mint(address, uint256) function directly
+		_, err = mintContract.Transact(tops, "mint", wallet, params.TokenAmount)
+		if err != nil {
+			log.Error().Err(err).Str("wallet", wallet.String()).Msg("Unable to mint ERC20 tokens directly to wallet")
+			return err
+		}
+	}
+
+	log.Info().Int("count", len(wallets)).Str("amount", params.TokenAmount.String()).Msg("Successfully funded all wallets with tokens")
+	return nil
+}