299 lines
8.8 KiB
Go
299 lines
8.8 KiB
Go
package commands
|
|
|
|
// import (
|
|
// "fmt"
|
|
// "io/ioutil"
|
|
// "strconv"
|
|
// "time"
|
|
|
|
// "github.com/pkg/errors"
|
|
// "github.com/spf13/cobra"
|
|
|
|
// // "github.com/spf13/viper"
|
|
// // "github.com/tendermint/tmlibs/cli"
|
|
// // "github.com/tendermint/tmlibs/log"
|
|
|
|
// "github.com/tendermint/go-wire"
|
|
// "github.com/tendermint/merkleeyes/iavl"
|
|
// cmn "github.com/tendermint/tmlibs/common"
|
|
|
|
// "github.com/tendermint/basecoin/plugins/ibc"
|
|
// "github.com/tendermint/basecoin/types"
|
|
// "github.com/tendermint/tendermint/rpc/client"
|
|
// tmtypes "github.com/tendermint/tendermint/types"
|
|
// )
|
|
|
|
// var RelayCmd = &cobra.Command{
|
|
// Use: "relay",
|
|
// Short: "Relay ibc packets between two chains",
|
|
// }
|
|
|
|
// var RelayStartCmd = &cobra.Command{
|
|
// Use: "start",
|
|
// Short: "Start basecoin relayer to relay IBC packets between chains",
|
|
// RunE: relayStartCmd,
|
|
// }
|
|
|
|
// var RelayInitCmd = &cobra.Command{
|
|
// Use: "init",
|
|
// Short: "Register both chains with each other, to prepare the relayer to run",
|
|
// RunE: relayInitCmd,
|
|
// }
|
|
|
|
// //flags
|
|
// var (
|
|
// chain1AddrFlag string
|
|
// chain2AddrFlag string
|
|
|
|
// chain1IDFlag string
|
|
// chain2IDFlag string
|
|
|
|
// fromFileFlag string
|
|
|
|
// genesisFile1Flag string
|
|
// genesisFile2Flag string
|
|
// )
|
|
|
|
// func init() {
|
|
// flags := []Flag2Register{
|
|
// {&chain1AddrFlag, "chain1-addr", "tcp://localhost:46657", "Node address for chain1"},
|
|
// {&chain2AddrFlag, "chain2-addr", "tcp://localhost:36657", "Node address for chain2"},
|
|
// {&chain1IDFlag, "chain1-id", "test_chain_1", "ChainID for chain1"},
|
|
// {&chain2IDFlag, "chain2-id", "test_chain_2", "ChainID for chain2"},
|
|
// {&fromFileFlag, "from", "key.json", "Path to a private key to sign the transaction"},
|
|
// }
|
|
// RegisterPersistentFlags(RelayCmd, flags)
|
|
|
|
// initFlags := []Flag2Register{
|
|
// {&genesisFile1Flag, "genesis1", "", "Path to genesis file for chain1"},
|
|
// {&genesisFile2Flag, "genesis2", "", "Path to genesis file for chain2"},
|
|
// }
|
|
// RegisterFlags(RelayInitCmd, initFlags)
|
|
|
|
// RelayCmd.AddCommand(RelayStartCmd)
|
|
// RelayCmd.AddCommand(RelayInitCmd)
|
|
// }
|
|
|
|
// func relayStartCmd(cmd *cobra.Command, args []string) error {
|
|
// go loop(chain1AddrFlag, chain2AddrFlag, chain1IDFlag, chain2IDFlag)
|
|
// go loop(chain2AddrFlag, chain1AddrFlag, chain2IDFlag, chain1IDFlag)
|
|
|
|
// cmn.TrapSignal(func() {
|
|
// // TODO: Cleanup
|
|
// })
|
|
// return nil
|
|
// }
|
|
|
|
// func relayInitCmd(cmd *cobra.Command, args []string) error {
|
|
// err := registerChain(chain1IDFlag, chain1AddrFlag, chain2IDFlag, genesisFile2Flag, fromFileFlag)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// err = registerChain(chain2IDFlag, chain2AddrFlag, chain1IDFlag, genesisFile1Flag, fromFileFlag)
|
|
// return err
|
|
// }
|
|
|
|
// func registerChain(chainID, node, registerChainID, registerGenesis, keyFile string) error {
|
|
// genesisBytes, err := ioutil.ReadFile(registerGenesis)
|
|
// if err != nil {
|
|
// return errors.Errorf("Error reading genesis file %v: %v\n", registerGenesis, err)
|
|
// }
|
|
|
|
// ibcTx := ibc.IBCRegisterChainTx{
|
|
// ibc.BlockchainGenesis{
|
|
// ChainID: registerChainID,
|
|
// Genesis: string(genesisBytes),
|
|
// },
|
|
// }
|
|
|
|
// privKey, err := LoadKey(keyFile)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// relay := newRelayer(privKey, chainID, node)
|
|
// return relay.appTx(ibcTx)
|
|
// }
|
|
|
|
// func loop(addr1, addr2, id1, id2 string) {
|
|
// nextSeq := 0
|
|
|
|
// // load the priv key
|
|
// privKey, err := LoadKey(fromFileFlag)
|
|
// if err != nil {
|
|
// logger.Error(err.Error())
|
|
// cmn.PanicCrisis(err.Error())
|
|
// }
|
|
|
|
// // relay from chain1 to chain2
|
|
// thisRelayer := newRelayer(privKey, id2, addr2)
|
|
|
|
// logger.Info(fmt.Sprintf("Relaying from chain %v on %v to chain %v on %v", id1, addr1, id2, addr2))
|
|
|
|
// httpClient := client.NewHTTP(addr1, "/websocket")
|
|
|
|
// OUTER:
|
|
// for {
|
|
|
|
// time.Sleep(time.Second)
|
|
|
|
// // get the latest ibc packet sequence number
|
|
// key := fmt.Sprintf("ibc,egress,%v,%v", id1, id2)
|
|
// query, err := queryWithClient(httpClient, []byte(key))
|
|
// if err != nil {
|
|
// logger.Error("Error querying for latest sequence", "key", key, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
// if len(query.Value) == 0 {
|
|
// // nothing yet
|
|
// continue OUTER
|
|
// }
|
|
|
|
// seq, err := strconv.ParseUint(string(query.Value), 10, 64)
|
|
// if err != nil {
|
|
// logger.Error("Error parsing sequence number from query", "query.Value", query.Value, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
// seq -= 1 // seq is the packet count. -1 because 0-indexed
|
|
|
|
// if nextSeq <= int(seq) {
|
|
// logger.Info("Got new packets", "last-sequence", nextSeq-1, "new-sequence", seq)
|
|
// }
|
|
|
|
// // get all packets since the last one we relayed
|
|
// for ; nextSeq <= int(seq); nextSeq++ {
|
|
// key := fmt.Sprintf("ibc,egress,%v,%v,%d", id1, id2, nextSeq)
|
|
// query, err := queryWithClient(httpClient, []byte(key))
|
|
// if err != nil {
|
|
// logger.Error("Error querying for packet", "seqeuence", nextSeq, "key", key, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
|
|
// var packet ibc.Packet
|
|
// err = wire.ReadBinaryBytes(query.Value, &packet)
|
|
// if err != nil {
|
|
// logger.Error("Error unmarshalling packet", "key", key, "query.Value", query.Value, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
|
|
// proof := new(iavl.IAVLProof)
|
|
// err = wire.ReadBinaryBytes(query.Proof, &proof)
|
|
// if err != nil {
|
|
// logger.Error("Error unmarshalling proof", "query.Proof", query.Proof, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
|
|
// // query.Height is actually for the next block,
|
|
// // so wait a block before we fetch the header & commit
|
|
// if err := waitForBlock(httpClient); err != nil {
|
|
// logger.Error("Error waiting for a block", "addr", addr1, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
|
|
// // get the header and commit from the height the query was done at
|
|
// res, err := httpClient.Commit(int(query.Height))
|
|
// if err != nil {
|
|
// logger.Error("Error fetching header and commits", "height", query.Height, "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
|
|
// // update the chain state on the other chain
|
|
// updateTx := ibc.IBCUpdateChainTx{
|
|
// Header: *res.Header,
|
|
// Commit: *res.Commit,
|
|
// }
|
|
// logger.Info("Updating chain", "src-chain", id1, "height", res.Header.Height, "appHash", res.Header.AppHash)
|
|
// if err := thisRelayer.appTx(updateTx); err != nil {
|
|
// logger.Error("Error creating/sending IBCUpdateChainTx", "error", err.Error())
|
|
// continue OUTER
|
|
// }
|
|
|
|
// // relay the packet and proof
|
|
// logger.Info("Relaying packet", "src-chain", id1, "height", query.Height, "sequence", nextSeq)
|
|
// postTx := ibc.IBCPacketPostTx{
|
|
// FromChainID: id1,
|
|
// FromChainHeight: query.Height,
|
|
// Packet: packet,
|
|
// Proof: proof,
|
|
// }
|
|
|
|
// if err := thisRelayer.appTx(postTx); err != nil {
|
|
// logger.Error("Error creating/sending IBCPacketPostTx", "error", err.Error())
|
|
// // dont `continue OUTER` here. the error might be eg. Already exists
|
|
// // TODO: catch this programmatically ?
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// type relayer struct {
|
|
// privKey *Key
|
|
// chainID string
|
|
// nodeAddr string
|
|
// client *client.HTTP
|
|
// }
|
|
|
|
// func newRelayer(privKey *Key, chainID, nodeAddr string) *relayer {
|
|
// httpClient := client.NewHTTP(nodeAddr, "/websocket")
|
|
// return &relayer{
|
|
// privKey: privKey,
|
|
// chainID: chainID,
|
|
// nodeAddr: nodeAddr,
|
|
// client: httpClient,
|
|
// }
|
|
// }
|
|
|
|
// func (r *relayer) appTx(ibcTx ibc.IBCTx) error {
|
|
// acc, err := getAccWithClient(r.client, r.privKey.Address[:])
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// sequence := acc.Sequence + 1
|
|
|
|
// data := []byte(wire.BinaryBytes(struct {
|
|
// ibc.IBCTx `json:"unwrap"`
|
|
// }{ibcTx}))
|
|
|
|
// smallCoins := coin.Coin{"mycoin", 1}
|
|
|
|
// input := types.NewTxInput(r.privKey.PubKey, coin.Coins{smallCoins}, sequence)
|
|
// tx := &types.AppTx{
|
|
// Gas: 0,
|
|
// Fee: smallCoins,
|
|
// Name: "IBC",
|
|
// Input: input,
|
|
// Data: data,
|
|
// }
|
|
|
|
// tx.Input.Signature = r.privKey.Sign(tx.SignBytes(r.chainID))
|
|
// txBytes := []byte(wire.BinaryBytes(struct {
|
|
// types.Tx `json:"unwrap"`
|
|
// }{tx}))
|
|
|
|
// data, log, err := broadcastTxWithClient(r.client, txBytes)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// _, _ = data, log
|
|
// return nil
|
|
// }
|
|
|
|
// // broadcast the transaction to tendermint
|
|
// func broadcastTxWithClient(httpClient *client.HTTP, tx tmtypes.Tx) ([]byte, string, error) {
|
|
// res, err := httpClient.BroadcastTxCommit(tx)
|
|
// if err != nil {
|
|
// return nil, "", errors.Errorf("Error on broadcast tx: %v", err)
|
|
// }
|
|
|
|
// if !res.CheckTx.Code.IsOK() {
|
|
// r := res.CheckTx
|
|
// return nil, "", errors.Errorf("BroadcastTxCommit got non-zero exit code: %v. %X; %s", r.Code, r.Data, r.Log)
|
|
// }
|
|
|
|
// if !res.DeliverTx.Code.IsOK() {
|
|
// r := res.DeliverTx
|
|
// return nil, "", errors.Errorf("BroadcastTxCommit got non-zero exit code: %v. %X; %s", r.Code, r.Data, r.Log)
|
|
// }
|
|
|
|
// return res.DeliverTx.Data, res.DeliverTx.Log, nil
|
|
// }
|