Teleporter CLI

.gitignore

@@ -4,8 +4,9 @@ cache/
 target/
 Cargo.lock
 
-# Example binary
+# Binaries
 blst_example
+cli/teleporter-cli
 
 # File generated by tests
 relayerConfig.json

abi-bindings/go/Teleporter/TeleporterMessenger/event.go

@@ -0,0 +1,101 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package teleportermessenger
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+// Event is a Teleporter log event
+type Event uint8
+
+const (
+	Unknown Event = iota
+	SendCrossChainMessage
+	ReceiveCrossChainMessage
+	AddFeeAmount
+	MessageExecutionFailed
+	MessageExecuted
+	RelayerRewardsRedeemed
+
+	sendCrossChainMessageStr    = "SendCrossChainMessage"
+	receiveCrossChainMessageStr = "ReceiveCrossChainMessage"
+	addFeeAmountStr             = "AddFeeAmount"
+	messageExecutionFailedStr   = "MessageExecutionFailed"
+	messageExecutedStr          = "MessageExecuted"
+	relayerRewardsRedeemedStr   = "RelayerRewardsRedeemed"
+	unknownStr                  = "Unknown"
+)
+
+// String returns the string representation of an Event
+func (e Event) String() string {
+	switch e {
+	case SendCrossChainMessage:
+		return sendCrossChainMessageStr
+	case ReceiveCrossChainMessage:
+		return receiveCrossChainMessageStr
+	case AddFeeAmount:
+		return addFeeAmountStr
+	case MessageExecutionFailed:
+		return messageExecutionFailedStr
+	case MessageExecuted:
+		return messageExecutedStr
+	case RelayerRewardsRedeemed:
+		return relayerRewardsRedeemedStr
+	default:
+		return unknownStr
+	}
+}
+
+// ToEvent converts a string to an Event
+func ToEvent(e string) (Event, error) {
+	switch strings.ToLower(e) {
+	case strings.ToLower(sendCrossChainMessageStr):
+		return SendCrossChainMessage, nil
+	case strings.ToLower(receiveCrossChainMessageStr):
+		return ReceiveCrossChainMessage, nil
+	case strings.ToLower(addFeeAmountStr):
+		return AddFeeAmount, nil
+	case strings.ToLower(messageExecutionFailedStr):
+		return MessageExecutionFailed, nil
+	case strings.ToLower(messageExecutedStr):
+		return MessageExecuted, nil
+	case strings.ToLower(relayerRewardsRedeemedStr):
+		return RelayerRewardsRedeemed, nil
+	default:
+		return Unknown, fmt.Errorf("unknown event %s", e)
+	}
+}
+
+// FilterTeleporterEvents parses the topics and data of a Teleporter log into the corresponding Teleporter event
+func FilterTeleporterEvents(topics []common.Hash, data []byte, event string) (interface{}, error) {
+	e, err := ToEvent(event)
+	if err != nil {
+		return nil, err
+	}
+	var out interface{}
+	switch e {
+	case SendCrossChainMessage:
+		out = new(TeleporterMessengerSendCrossChainMessage)
+	case ReceiveCrossChainMessage:
+		out = new(TeleporterMessengerReceiveCrossChainMessage)
+	case AddFeeAmount:
+		out = new(TeleporterMessengerAddFeeAmount)
+	case MessageExecutionFailed:
+		out = new(TeleporterMessengerMessageExecutionFailed)
+	case MessageExecuted:
+		out = new(TeleporterMessengerMessageExecuted)
+	case RelayerRewardsRedeemed:
+		out = new(TeleporterMessengerRelayerRewardsRedeemed)
+	default:
+		return nil, fmt.Errorf("unknown event %s", event)
+	}
+	if err := UnpackEvent(out, event, topics, data); err != nil {
+		return nil, err
+	}
+	return out, nil
+}

abi-bindings/go/Teleporter/TeleporterMessenger/packing.go

@@ -115,3 +115,24 @@ func PackMessageReceivedOutput(success bool) ([]byte, error) {
 
 	return abi.PackOutput("messageReceived", success)
 }
+
+// UnpackEvent unpacks the event data and topics into the provided interface
+func UnpackEvent(out interface{}, event string, topics []common.Hash, data []byte) error {
+	teleporterABI, err := TeleporterMessengerMetaData.GetAbi()
+	if err != nil {
+		return fmt.Errorf("failed to get abi: %v", err)
+	}
+	if len(data) > 0 {
+		if err := teleporterABI.UnpackIntoInterface(out, event, data); err != nil {
+			return err
+		}
+	}
+
+	var indexed abi.Arguments
+	for _, arg := range teleporterABI.Events[event].Inputs {
+		if arg.Indexed {
+			indexed = append(indexed, arg)
+		}
+	}
+	return abi.ParseTopics(out, indexed, topics[1:])
+}

cli/README.md

@@ -0,0 +1,17 @@
+# Teleporter CLI
+
+This directory contains the source code for the Teleporter CLI. The CLI is a command line interface for interacting with the Teleporter contracts. It is written with [cobra](https://github.com/spf13/cobra) commands as a Go application.
+
+## Build
+
+To build the CLI, run `go build -o teleporter-cli` from this directory. This will create a binary called `teleporter-cli` in the current directory.
+
+## Usage
+
+The CLI has a number of subcommands. To see the list of subcommands, run `./teleporter-cli help`. To see the help for a specific subcommand, run `./teleporter-cli help <subcommand>`.
+
+The supported subcommands include:
+
+- `event`: given a log event's topics and data, attempts to decode into a Teleporter event in more readable format.
+- `message`: given a Teleporter message bytes hex encoded, attempts to decode into a Teleporter message in more readable format.
+- `transaction`: given a transaction hash, attempts to decode all relevant Teleporter and Warp log events in more readable format.

cli/cmd/event.go

@@ -0,0 +1,47 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package cmd
+
+import (
+	teleportermessenger "github.com/ava-labs/teleporter/abi-bindings/go/Teleporter/TeleporterMessenger"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+)
+
+var (
+	topicArgs []string
+	data      []byte
+)
+
+var eventCmd = &cobra.Command{
+	Use:   "event --topics topic1, topic2",
+	Short: "Parses a Teleporter log's topics and data",
+	Long: `Given the topics and data of a Teleporter log, parses the log into
+the corresponding Teleporter event. Topics are represented by a hash,
+and data is the hex encoding of the bytes.`,
+	Args: cobra.NoArgs,
+	Run: func(cmd *cobra.Command, args []string) {
+		var topics []common.Hash
+		for _, topic := range topicArgs {
+			topics = append(topics, common.HexToHash(topic))
+		}
+
+		event, err := teleporterABI.EventByID(topics[0])
+		cobra.CheckErr(err)
+
+		out, err := teleportermessenger.FilterTeleporterEvents(topics, data, event.Name)
+		cobra.CheckErr(err)
+		logger.Info("Parsed Teleporter event", zap.String("name", event.Name), zap.Any("event", out))
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(eventCmd)
+	eventCmd.PersistentFlags().StringSliceVar(&topicArgs, "topics", []string{}, "Topic hashes of the event")
+	eventCmd.Flags().BytesHexVar(&data, "data", []byte{}, "Hex encoded data of the event")
+
+	err := eventCmd.MarkPersistentFlagRequired("topics")
+	cobra.CheckErr(err)
+}

cli/cmd/message.go

@@ -0,0 +1,33 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package cmd
+
+import (
+	"encoding/hex"
+
+	teleportermessenger "github.com/ava-labs/teleporter/abi-bindings/go/Teleporter/TeleporterMessenger"
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+)
+
+var messageCmd = &cobra.Command{
+	Use:   "message MESSAGE_BYTES",
+	Short: "Decodes hex encoded Teleporter message bytes into a TeleporterMessage struct",
+	Long: `Given the hex encoded bytes of a Teleporter message, this command will decode
+the bytes into a TeleporterMessage struct and print the struct fields.`,
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		encodedMsg := args[0]
+		b, err := hex.DecodeString(encodedMsg)
+		cobra.CheckErr(err)
+
+		msg, err := teleportermessenger.UnpackTeleporterMessage(b)
+		cobra.CheckErr(err)
+		logger.Info("Teleporter Message unpacked", zap.Any("message", msg))
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(messageCmd)
+}

cli/cmd/root.go

@@ -0,0 +1,64 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package cmd
+
+import (
+	"os"
+
+	"github.com/ava-labs/avalanchego/utils/logging"
+	"github.com/ava-labs/subnet-evm/accounts/abi"
+	teleportermessenger "github.com/ava-labs/teleporter/abi-bindings/go/Teleporter/TeleporterMessenger"
+	"github.com/spf13/cobra"
+)
+
+var (
+	logger        logging.Logger
+	teleporterABI *abi.ABI
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "teleporter-cli",
+	Short: "A CLI that integrates with the Teleporter protocol",
+	Long: `A CLI that integrates with the Teleporter protocol, and allows you
+to debug Teleporter on chain activity. The CLI can help decode
+Teleporter and Warp events, as well as parsing Teleporter messages.`,
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	err := rootCmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.CompletionOptions.DisableDefaultCmd = true
+	logLevelArg := rootCmd.PersistentFlags().StringP("log", "l", "", "Log level i.e. debug, info...")
+	rootCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
+		if *logLevelArg == "" {
+			*logLevelArg = logging.Info.LowerString()
+		}
+
+		logLevel, err := logging.ToLevel(*logLevelArg)
+		if err != nil {
+			return err
+		}
+		logger = logging.NewLogger(
+			"teleporter-cli",
+			logging.NewWrappedCore(
+				logLevel,
+				os.Stdout,
+				logging.Plain.ConsoleEncoder(),
+			),
+		)
+		abi, err := teleportermessenger.TeleporterMessengerMetaData.GetAbi()
+		if err != nil {
+			return err
+		}
+		teleporterABI = abi
+		return nil
+	}
+}

cli/cmd/transaction.go

@@ -0,0 +1,94 @@
+// (c) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package cmd
+
+import (
+	"context"
+
+	warpPayload "github.com/ava-labs/avalanchego/vms/platformvm/warp/payload"
+	"github.com/ava-labs/subnet-evm/ethclient"
+	"github.com/ava-labs/subnet-evm/x/warp"
+	teleportermessenger "github.com/ava-labs/teleporter/abi-bindings/go/Teleporter/TeleporterMessenger"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
+)
+
+const (
+	warpPrecompileAddress = "0x0200000000000000000000000000000000000005"
+)
+
+var (
+	rpcEndpoint     string
+	contractAddress common.Address
+	client          ethclient.Client
+)
+
+var transactionCmd = &cobra.Command{
+	Use:   "transaction --rpc RPC_URL --contract-address CONTRACT_ADDRESS TRANSACTION_HASH",
+	Short: "Parses relevant Teleporter logs from a transaction",
+	Long: `Given a transaction this command looks through the transaction's receipt
+for Teleporter and Warp log events. When corresponding log events are found,
+the command parses to log event fields to a more human readable format.`,
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		receipt, err := client.TransactionReceipt(context.Background(),
+			common.HexToHash(args[0]))
+		cobra.CheckErr(err)
+		for _, log := range receipt.Logs {
+			if log.Address == contractAddress {
+				logger.Debug("Processing Teleporter log", zap.Any("log", log))
+
+				event, err := teleporterABI.EventByID(log.Topics[0])
+				cobra.CheckErr(err)
+
+				out, err := teleportermessenger.FilterTeleporterEvents(log.Topics, log.Data, event.Name)
+				cobra.CheckErr(err)
+				logger.Info("Parsed Teleporter event", zap.String("name", event.Name), zap.Any("event", out))
+			}
+
+			if log.Address == common.HexToAddress(warpPrecompileAddress) {
+				logger.Debug("Processing Warp log", zap.Any("log", log))
+
+				unsignedMsg, err := warp.UnpackSendWarpEventDataToMessage(log.Data)
+				cobra.CheckErr(err)
+
+				warpPayload, err := warpPayload.ParseAddressedCall(unsignedMsg.Payload)
+				cobra.CheckErr(err)
+
+				teleporterMessage, err := teleportermessenger.UnpackTeleporterMessage(warpPayload.Payload)
+				cobra.CheckErr(err)
+				logger.Info("Parsed Teleporter message", zap.String("warpMessageID", unsignedMsg.ID().Hex()), zap.String("teleporterMessageID", teleporterMessage.MessageID.String()), zap.Any("message", teleporterMessage))
+			}
+
+		}
+
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(transactionCmd)
+	transactionCmd.PersistentFlags().StringVar(&rpcEndpoint, "rpc", "", "RPC endpoint to connect to the node")
+	address := transactionCmd.PersistentFlags().StringP("contract-address", "c", "", "Teleporter contract address")
+	err := transactionCmd.MarkPersistentFlagRequired("rpc")
+	cobra.CheckErr(err)
+	err = transactionCmd.MarkPersistentFlagRequired("contract-address")
+	cobra.CheckErr(err)
+	transactionCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
+		// Run the persistent pre-run function of the root command if it exists.
+		if rootCmd.PersistentPreRunE != nil {
+			if err := rootCmd.PersistentPreRunE(cmd, args); err != nil {
+				return err
+			}
+		}
+		contractAddress = common.HexToAddress(*address)
+		c, err := ethclient.Dial(rpcEndpoint)
+		if err != nil {
+			return err
+		}
+
+		client = c
+		return err
+	}
+}