Merge branch 'main' into minhd-vu/datastore-improvements

Author: minhd-vu

cmd/fixnoncegap/fixnoncegap.go

@@ -115,14 +115,12 @@ func fixNonceGap(cmd *cobra.Command, args []string) error {
 	var maxNonce uint64
 	if inputFixNonceGapArgs.maxNonce != 0 {
 		maxNonce = inputFixNonceGapArgs.maxNonce
+		log.Info().Uint64("maxNonce", maxNonce).Msg("maxNonce loaded from --max-nonce flag")
 	} else {
-		maxNonce, err = getMaxNonceFromTxPool(addr)
+		log.Info().Msg("--max-nonce flag not set")
+		maxNonce, err = getMaxNonce(addr)
 		if err != nil {
-			if strings.Contains(err.Error(), "the method txpool_content does not exist/is not available") {
-				log.Error().Err(err).Msg("The RPC doesn't provide access to txpool_content, please check --help for more information about --max-nonce")
-				return nil
-			}
-			log.Error().Err(err).Msg("Unable to get max nonce from txpool")
+			log.Error().Err(err).Msg("Unable to get max nonce, please check --help for more information about --max-nonce")
 			return err
 		}
 	}
@@ -132,7 +130,11 @@ func fixNonceGap(cmd *cobra.Command, args []string) error {
 		log.Info().Stringer("addr", addr).Msg("There is no nonce gap.")
 		return nil
 	}
-	log.Info().Stringer("addr", addr).Msgf("Nonce gap found. Max nonce: %d", maxNonce)
+	log.Info().
+		Stringer("addr", addr).
+		Uint64("currentNonce", currentNonce).
+		Uint64("maxNonce", maxNonce).
+		Msg("Nonce gap found")
 
 	gasPrice, err := rpcClient.SuggestGasPrice(cmd.Context())
 	if err != nil {
@@ -273,6 +275,26 @@ func WaitMineTransaction(ctx context.Context, client *ethclient.Client, tx *type
 	}
 }
 
+func getMaxNonce(addr common.Address) (uint64, error) {
+	log.Info().Msg("getting max nonce from txpool_content")
+	maxNonce, err := getMaxNonceFromTxPool(addr)
+	if err == nil {
+		log.Info().Uint64("maxNonce", maxNonce).Msg("maxNonce loaded from txpool_content")
+		return maxNonce, nil
+	}
+	log.Warn().Err(err).Msg("unable to get max nonce from txpool_content")
+
+	log.Info().Msg("getting max nonce from pending nonce")
+	// if the error is not about txpool_content, falls back to PendingNonceAt
+	maxNonce, err = rpcClient.PendingNonceAt(context.Background(), addr)
+	if err != nil {
+		return 0, err
+	}
+
+	log.Info().Uint64("maxNonce", maxNonce).Msg("maxNonce loaded from pending nonce")
+	return maxNonce, nil
+}
+
 func getMaxNonceFromTxPool(addr common.Address) (uint64, error) {
 	var result PoolContent
 	err := rpcClient.Client().Call(&result, "txpool_content")
@@ -299,6 +321,7 @@ func getMaxNonceFromTxPool(addr common.Address) (uint64, error) {
 			nonceInt, ok := new(big.Int).SetString(nonce, 10)
 			if !ok {
 				err = fmt.Errorf("invalid nonce found: %s", nonce)
+				log.Warn().Err(err).Msg("unable to get txpool_content")
 				return 0, err
 			}
 

cmd/fund/cmd.go

@@ -35,6 +35,13 @@ type cmdFundParams struct {
 	Seed    string
 
 	FunderAddress string
+
+	// ERC20 specific parameters
+	TokenAddress           string
+	TokenAmount            *big.Int
+	ERC20BulkMinterAddress string
+	ApproveSpender         string
+	ApproveAmount          *big.Int
 }
 
 var (
@@ -80,6 +87,17 @@ 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")
+	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")
 	FundCmd.MarkFlagsMutuallyExclusive("addresses", "hd-derivation")
@@ -148,5 +166,20 @@ 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")
+		}
+		// 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
+	}
+
 	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, privateKeys); 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,90 @@ 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 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")
+	}
+
+	// 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 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
+}

cmd/ulxly/bridge_service/aggkit/service.go

@@ -57,32 +57,43 @@ func (s *BridgeService) GetDeposits(destinationAddress string, offset, limit int
 	return nil, 0, fmt.Errorf("GetDeposits is not supported by aggkit bridge service yet")
 }
 
-func (s *BridgeService) GetProof(depositNetwork, depositCount uint32, ger *common.Hash) (*bridge_service.Proof, error) {
-	var l1InfoTreeIndex uint32
+func (s *BridgeService) GetProof(depositNetwork, depositCount uint32) (*bridge_service.Proof, error) {
+	return s.getProof(depositNetwork, depositCount, nil)
+}
 
-	if ger != nil {
-		return nil, errors.New("getting proof by ger is not supported yet by Aggkit bridge service")
-	}
+func (s *BridgeService) GetProofByGer(depositNetwork, depositCount uint32, ger common.Hash) (*bridge_service.Proof, error) {
+	return nil, errors.New("getting proof by ger is not supported yet by Aggkit bridge service")
+}
 
-	timeout := time.After(time.Minute)
-out:
-	for {
-		idx, err := s.getL1InfoTreeIndex(depositNetwork, depositCount)
-		if err != nil && !errors.Is(err, bridge_service.ErrNotFound) {
-			return nil, err
-		} else if err == nil {
-			l1InfoTreeIndex = *idx
-			break out
-		}
-		select {
-		case <-timeout:
-			return nil, fmt.Errorf("timeout waiting for l1 info tree index")
-		default:
-			time.Sleep(time.Second)
+func (s *BridgeService) GetProofByL1InfoTreeIndex(depositNetwork, depositCount uint32, l1InfoTreeIndex uint32) (*bridge_service.Proof, error) {
+	return s.getProof(depositNetwork, depositCount, &l1InfoTreeIndex)
+}
+
+func (s *BridgeService) getProof(depositNetwork, depositCount uint32, l1InfoTreeIndex *uint32) (*bridge_service.Proof, error) {
+	var l1InfoTreeIndexValue uint32
+	if l1InfoTreeIndex != nil {
+		l1InfoTreeIndexValue = *l1InfoTreeIndex
+	} else {
+
+		timeout := time.After(time.Minute)
+	out:
+		for {
+			idx, err := s.getL1InfoTreeIndex(depositNetwork, depositCount)
+			if err != nil && !errors.Is(err, bridge_service.ErrNotFound) {
+				return nil, err
+			} else if err == nil {
+				l1InfoTreeIndexValue = *idx
+				break out
+			}
+			select {
+			case <-timeout:
+				return nil, fmt.Errorf("timeout waiting for l1 info tree index")
+			default:
+				time.Sleep(time.Second)
+			}
 		}
 	}
-
-	endpoint := fmt.Sprintf("%s/%s/claim-proof?network_id=%d&leaf_index=%d&deposit_count=%d", s.BridgeServiceBase.Url(), urlPath, depositNetwork, l1InfoTreeIndex, depositCount)
+	endpoint := fmt.Sprintf("%s/%s/claim-proof?network_id=%d&leaf_index=%d&deposit_count=%d", s.BridgeServiceBase.Url(), urlPath, depositNetwork, l1InfoTreeIndexValue, depositCount)
 	resp, respError, statusCode, err := httpjson.HTTPGetWithError[getClaimProofResponse, errorResponse](s.httpClient, endpoint)
 	if err != nil {
 		return nil, err

cmd/ulxly/bridge_service/interface.go

@@ -15,7 +15,9 @@ var (
 type BridgeService interface {
 	GetDeposit(depositNetwork, depositCount uint32) (*Deposit, error)
 	GetDeposits(destinationAddress string, offset, limit int) (deposits []Deposit, total int, err error)
-	GetProof(depositNetwork, depositCount uint32, ger *common.Hash) (*Proof, error)
+	GetProof(depositNetwork, depositCount uint32) (*Proof, error)
+	GetProofByGer(depositNetwork, depositCount uint32, ger common.Hash) (*Proof, error)
+	GetProofByL1InfoTreeIndex(depositNetwork, depositCount uint32, l1InfoTreeIndex uint32) (*Proof, error)
 	Url() string
 }
 

cmd/ulxly/bridge_service/legacy/service.go

@@ -66,12 +66,21 @@ func (s *BridgeService) GetDeposits(destinationAddress string, offset, limit int
 
 }
 
-func (s *BridgeService) GetProof(depositNetwork, depositCount uint32, ger *common.Hash) (*bridge_service.Proof, error) {
+func (s *BridgeService) GetProof(depositNetwork, depositCount uint32) (*bridge_service.Proof, error) {
 	endpoint := fmt.Sprintf("%s/merkle-proof?net_id=%d&deposit_cnt=%d", s.BridgeServiceBase.Url(), depositNetwork, depositCount)
-	if ger != nil {
-		endpoint = fmt.Sprintf("%s/merkle-proof-by-ger?net_id=%d&deposit_cnt=%d&ger=%s", s.BridgeServiceBase.Url(), depositNetwork, depositCount, ger.String())
+
+	resp, _, err := httpjson.HTTPGet[GetProofResponse](s.httpClient, endpoint)
+	if err != nil {
+		return nil, err
 	}
 
+	proof := resp.Proof.ToProof()
+	return proof, nil
+}
+
+func (s *BridgeService) GetProofByGer(depositNetwork, depositCount uint32, ger common.Hash) (*bridge_service.Proof, error) {
+	endpoint := fmt.Sprintf("%s/merkle-proof-by-ger?net_id=%d&deposit_cnt=%d&ger=%s", s.BridgeServiceBase.Url(), depositNetwork, depositCount, ger.String())
+
 	resp, _, err := httpjson.HTTPGet[GetProofResponse](s.httpClient, endpoint)
 	if err != nil {
 		return nil, err
@@ -80,3 +89,7 @@ func (s *BridgeService) GetProof(depositNetwork, depositCount uint32, ger *commo
 	proof := resp.Proof.ToProof()
 	return proof, nil
 }
+
+func (s *BridgeService) GetProofByL1InfoTreeIndex(depositNetwork, depositCount uint32, l1InfoTreeIndex uint32) (*bridge_service.Proof, error) {
+	return nil, fmt.Errorf("GetProofByL1InfoTreeIndex is not supported in the legacy bridge service")
+}