test

Author: leovct

cmd/ulxly/ulxly.go

@@ -10,7 +10,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/ethereum/go-ethereum"
 	"io"
 	"math/big"
 	"net/http"
@@ -19,6 +18,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/ethereum/go-ethereum"
+
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -1187,6 +1188,105 @@ var ulxlyClaimCmd = &cobra.Command{
 	Args:  cobra.NoArgs,
 }
 
+var bridgeAssetCmd = &cobra.Command{
+	Use:     "asset",
+	Short:   "Move ETH or an ERC20 between to chains",
+	Long:    bridgeAssetUsage,
+	PreRunE: prepInputs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return bridgeAsset(cmd)
+	},
+}
+
+var bridgeMessageCmd = &cobra.Command{
+	Use:     "message",
+	Short:   "Send some ETH along with data from one chain to another chain",
+	Long:    bridgeMessageUsage,
+	PreRunE: prepInputs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return bridgeMessage(cmd)
+	},
+}
+
+var bridgeMessageWETHCmd = &cobra.Command{
+	Use:     "weth",
+	Short:   "For L2's that use a gas token, use this to transfer WETH to another chain",
+	Long:    bridgeWETHMessageUsage,
+	PreRunE: prepInputs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return bridgeWETHMessage(cmd)
+	},
+}
+
+var claimAssetCmd = &cobra.Command{
+	Use:     "asset",
+	Short:   "Claim a deposit",
+	Long:    claimAssetUsage,
+	PreRunE: prepInputs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return claimAsset(cmd)
+	},
+}
+
+var claimMessageCmd = &cobra.Command{
+	Use:     "message",
+	Short:   "Claim a message",
+	Long:    claimMessageUsage,
+	PreRunE: prepInputs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return claimMessage(cmd)
+	},
+}
+var claimEverythingCmd = &cobra.Command{
+	Use:     "claim-everything",
+	Short:   "Attempt to claim as many deposits and messages as possible",
+	PreRunE: prepInputs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return claimEverything(cmd)
+	},
+}
+
+var emptyproofCmd = &cobra.Command{
+	Use:   "empty-proof",
+	Short: "create an empty proof",
+	Long:  "Use this command to print an empty proof response that's filled with zero-valued siblings like 0x0000000000000000000000000000000000000000000000000000000000000000. This can be useful when you need to submit a dummy proof.",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return emptyProof()
+	},
+}
+
+var zeroproofCmd = &cobra.Command{
+	Use:   "zero-proof",
+	Short: "create a proof that's filled with zeros",
+	Long: `Use this command to print a proof response that's filled with the zero
+hashes. This values are very helpful for debugging because it would
+tell you how populated the tree is and roughly which leaves and
+siblings are empty. It's also helpful for sanity checking a proof
+response to understand if the hashed value is part of the zero hashes
+or if it's actually an intermediate hash.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return zeroProof()
+	},
+}
+
+var proofCmd = &cobra.Command{
+	Use:   "proof",
+	Short: "Generate a proof for a given range of deposits",
+	Long:  proofUsage,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return proof(args)
+	},
+}
+
+var getDepositCmd = &cobra.Command{
+	Use:   "get-deposits",
+	Short: "Generate ndjson for each bridge deposit over a particular range of blocks",
+	Long:  depositGetUsage,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return readDeposit(cmd)
+	},
+}
+
 type ulxlyArgs struct {
 	gasLimit            *uint64
 	chainID             *string
@@ -1220,19 +1320,6 @@ type ulxlyArgs struct {
 
 var inputUlxlyArgs = ulxlyArgs{}
 
-var (
-	bridgeAssetCommand       *cobra.Command
-	bridgeMessageCommand     *cobra.Command
-	bridgeMessageWETHCommand *cobra.Command
-	claimAssetCommand        *cobra.Command
-	claimMessageCommand      *cobra.Command
-	claimEverythingCommand   *cobra.Command
-	emptyProofCommand        *cobra.Command
-	zeroProofCommand         *cobra.Command
-	proofCommand             *cobra.Command
-	getDepositCommand        *cobra.Command
-)
-
 const (
 	ArgGasLimit         = "gas-limit"
 	ArgChainID          = "chain-id"
@@ -1308,97 +1395,6 @@ func fatalIfError(err error) {
 }
 
 func init() {
-	bridgeAssetCommand = &cobra.Command{
-		Use:     "asset",
-		Short:   "Move ETH or an ERC20 between to chains",
-		Long:    bridgeAssetUsage,
-		PreRunE: prepInputs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return bridgeAsset(cmd)
-		},
-	}
-	bridgeMessageCommand = &cobra.Command{
-		Use:     "message",
-		Short:   "Send some ETH along with data from one chain to another chain",
-		Long:    bridgeMessageUsage,
-		PreRunE: prepInputs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return bridgeMessage(cmd)
-		},
-	}
-	bridgeMessageWETHCommand = &cobra.Command{
-		Use:     "weth",
-		Short:   "For L2's that use a gas token, use this to transfer WETH to another chain",
-		Long:    bridgeWETHMessageUsage,
-		PreRunE: prepInputs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return bridgeWETHMessage(cmd)
-		},
-	}
-	claimAssetCommand = &cobra.Command{
-		Use:     "asset",
-		Short:   "Claim a deposit",
-		Long:    claimAssetUsage,
-		PreRunE: prepInputs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return claimAsset(cmd)
-		},
-	}
-	claimMessageCommand = &cobra.Command{
-		Use:     "message",
-		Short:   "Claim a message",
-		Long:    claimMessageUsage,
-		PreRunE: prepInputs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return claimMessage(cmd)
-		},
-	}
-	claimEverythingCommand = &cobra.Command{
-		Use:     "claim-everything",
-		Short:   "Attempt to claim as many deposits and messages as possible",
-		PreRunE: prepInputs,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return claimEverything(cmd)
-		},
-	}
-	emptyProofCommand = &cobra.Command{
-		Use:   "empty-proof",
-		Short: "create an empty proof",
-		Long:  "Use this command to print an empty proof response that's filled with zero-valued siblings like 0x0000000000000000000000000000000000000000000000000000000000000000. This can be useful when you need to submit a dummy proof.",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return emptyProof()
-		},
-	}
-	zeroProofCommand = &cobra.Command{
-		Use:   "zero-proof",
-		Short: "create a proof that's filled with zeros",
-		Long: `Use this command to print a proof response that's filled with the zero
-hashes. This values are very helpful for debugging because it would
-tell you how populated the tree is and roughly which leaves and
-siblings are empty. It's also helpful for sanity checking a proof
-response to understand if the hashed value is part of the zero hashes
-or if it's actually an intermediate hash.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return zeroProof()
-		},
-	}
-	proofCommand = &cobra.Command{
-		Use:   "proof",
-		Short: "Generate a proof for a given range of deposits",
-		Long:  proofUsage,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return proof(args)
-		},
-	}
-	getDepositCommand = &cobra.Command{
-		Use:   "get-deposits",
-		Short: "Generate ndjson for each bridge deposit over a particular range of blocks",
-		Long:  depositGetUsage,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return readDeposit(cmd)
-		},
-	}
-
 	// Arguments for both bridge and claim
 	inputUlxlyArgs.rpcURL = ulxlyBridgeAndClaimCmd.PersistentFlags().String(ArgRPCURL, "", "the URL of the RPC to send the transaction")
 	inputUlxlyArgs.bridgeAddress = ulxlyBridgeAndClaimCmd.PersistentFlags().String(ArgBridgeAddress, "", "the address of the lxly bridge")
@@ -1432,47 +1428,47 @@ or if it's actually an intermediate hash.`,
 	fatalIfError(ulxlyClaimCmd.MarkPersistentFlagRequired(ArgBridgeServiceURL))
 
 	// Claim Everything Helper Command
-	inputUlxlyArgs.bridgeServiceURLs = claimEverythingCommand.Flags().StringSlice(ArgBridgeMappings, nil, "Mappings between network ids and bridge service urls. E.g. '1=http://network-1-bridgeurl,7=http://network-2-bridgeurl'")
-	inputUlxlyArgs.bridgeLimit = claimEverythingCommand.Flags().Int(ArgBridgeLimit, 25, "Limit the number or responses returned by the bridge service when claiming")
-	inputUlxlyArgs.bridgeOffset = claimEverythingCommand.Flags().Int(ArgBridgeOffset, 0, "The offset to specify for pagination of the underlying bridge service deposits")
-	fatalIfError(claimEverythingCommand.MarkFlagRequired(ArgBridgeMappings))
+	inputUlxlyArgs.bridgeServiceURLs = claimEverythingCmd.Flags().StringSlice(ArgBridgeMappings, nil, "Mappings between network ids and bridge service urls. E.g. '1=http://network-1-bridgeurl,7=http://network-2-bridgeurl'")
+	inputUlxlyArgs.bridgeLimit = claimEverythingCmd.Flags().Int(ArgBridgeLimit, 25, "Limit the number or responses returned by the bridge service when claiming")
+	inputUlxlyArgs.bridgeOffset = claimEverythingCmd.Flags().Int(ArgBridgeOffset, 0, "The offset to specify for pagination of the underlying bridge service deposits")
+	fatalIfError(claimEverythingCmd.MarkFlagRequired(ArgBridgeMappings))
 
 	// Args that are just for the get deposit command
-	inputUlxlyArgs.fromBlock = getDepositCommand.Flags().Uint64(ArgFromBlock, 0, "The start of the range of blocks to retrieve")
-	inputUlxlyArgs.toBlock = getDepositCommand.Flags().Uint64(ArgToBlock, 0, "The end of the range of blocks to retrieve")
-	inputUlxlyArgs.filterSize = getDepositCommand.Flags().Uint64(ArgFilterSize, 1000, "The batch size for individual filter queries")
-	getDepositCommand.Flags().String(ArgRPCURL, "", "The RPC URL to read deposit data")
-	getDepositCommand.Flags().String(ArgBridgeAddress, "", "The address of the ulxly bridge")
-	fatalIfError(getDepositCommand.MarkFlagRequired(ArgFromBlock))
-	fatalIfError(getDepositCommand.MarkFlagRequired(ArgToBlock))
-	fatalIfError(getDepositCommand.MarkFlagRequired(ArgRPCURL))
+	inputUlxlyArgs.fromBlock = getDepositCmd.Flags().Uint64(ArgFromBlock, 0, "The start of the range of blocks to retrieve")
+	inputUlxlyArgs.toBlock = getDepositCmd.Flags().Uint64(ArgToBlock, 0, "The end of the range of blocks to retrieve")
+	inputUlxlyArgs.filterSize = getDepositCmd.Flags().Uint64(ArgFilterSize, 1000, "The batch size for individual filter queries")
+	getDepositCmd.Flags().String(ArgRPCURL, "", "The RPC URL to read deposit data")
+	getDepositCmd.Flags().String(ArgBridgeAddress, "", "The address of the ulxly bridge")
+	fatalIfError(getDepositCmd.MarkFlagRequired(ArgFromBlock))
+	fatalIfError(getDepositCmd.MarkFlagRequired(ArgToBlock))
+	fatalIfError(getDepositCmd.MarkFlagRequired(ArgRPCURL))
 
 	// Args for the proof command
-	inputUlxlyArgs.inputFileName = proofCommand.Flags().String(ArgFileName, "", "An ndjson file with deposit data")
-	inputUlxlyArgs.depositNumber = proofCommand.Flags().Uint64(ArgDepositCount, 0, "The deposit number to generate a proof for")
+	inputUlxlyArgs.inputFileName = proofCmd.Flags().String(ArgFileName, "", "An ndjson file with deposit data")
+	inputUlxlyArgs.depositNumber = proofCmd.Flags().Uint64(ArgDepositCount, 0, "The deposit number to generate a proof for")
 
 	// Top Level
 	ULxLyCmd.AddCommand(ulxlyBridgeAndClaimCmd)
-	ULxLyCmd.AddCommand(emptyProofCommand)
-	ULxLyCmd.AddCommand(zeroProofCommand)
-	ULxLyCmd.AddCommand(proofCommand)
-	ULxLyCmd.AddCommand(getDepositCommand)
+	ULxLyCmd.AddCommand(emptyproofCmd)
+	ULxLyCmd.AddCommand(zeroproofCmd)
+	ULxLyCmd.AddCommand(proofCmd)
+	ULxLyCmd.AddCommand(getDepositCmd)
 
 	ULxLyCmd.AddCommand(ulxlyBridgeCmd)
 	ULxLyCmd.AddCommand(ulxlyClaimCmd)
-	ULxLyCmd.AddCommand(claimEverythingCommand)
+	ULxLyCmd.AddCommand(claimEverythingCmd)
 
 	// Bridge and Claim
 	ulxlyBridgeAndClaimCmd.AddCommand(ulxlyBridgeCmd)
 	ulxlyBridgeAndClaimCmd.AddCommand(ulxlyClaimCmd)
-	ulxlyBridgeAndClaimCmd.AddCommand(claimEverythingCommand)
+	ulxlyBridgeAndClaimCmd.AddCommand(claimEverythingCmd)
 
 	// Bridge
-	ulxlyBridgeCmd.AddCommand(bridgeAssetCommand)
-	ulxlyBridgeCmd.AddCommand(bridgeMessageCommand)
-	ulxlyBridgeCmd.AddCommand(bridgeMessageWETHCommand)
+	ulxlyBridgeCmd.AddCommand(bridgeAssetCmd)
+	ulxlyBridgeCmd.AddCommand(bridgeMessageCmd)
+	ulxlyBridgeCmd.AddCommand(bridgeMessageWETHCmd)
 
 	// Claim
-	ulxlyClaimCmd.AddCommand(claimAssetCommand)
-	ulxlyClaimCmd.AddCommand(claimMessageCommand)
+	ulxlyClaimCmd.AddCommand(claimAssetCmd)
+	ulxlyClaimCmd.AddCommand(claimMessageCmd)
 }