From aaaf18ad71e2e2309f369d1d46a1f15cc4fd7f8a Mon Sep 17 00:00:00 2001 From: mossid Date: Fri, 16 Mar 2018 21:39:42 +0100 Subject: [PATCH] rm relay from basecli --- x/ibc/commands/ibctx.go | 9 ++++--- x/ibc/commands/relay.go | 58 ++++++++++++++++++++++++++++------------- x/ibc/types.go | 40 +++++++++++++++++++++++++++- 3 files changed, 85 insertions(+), 22 deletions(-) diff --git a/x/ibc/commands/ibctx.go b/x/ibc/commands/ibctx.go index aa51e81019..f49270966e 100644 --- a/x/ibc/commands/ibctx.go +++ b/x/ibc/commands/ibctx.go @@ -25,7 +25,7 @@ const ( func IBCTransferCmd(cdc *wire.Codec) *cobra.Command { cmdr := sendCommander{cdc} cmd := &cobra.Command{ - Use: "send", + Use: "transfer", RunE: cmdr.sendIBCTransfer, } cmd.Flags().String(flagTo, "", "Address to send coins") @@ -49,7 +49,10 @@ func (c sendCommander) sendIBCTransfer(cmd *cobra.Command, args []string) error return err } - res, err := builder.SignBuildBroadcast(msg, c.cdc) + fmt.Printf("%+v\n", msg) + + bz := sdk.StdSignBytes(viper.GetString(flagChain), []int64{viper.GetInt64(client.FlagSequence)}, msg) + res, err := builder.BroadcastTx(bz) if err != nil { return err } @@ -73,7 +76,7 @@ func buildMsg(from sdk.Address) (sdk.Msg, error) { to := sdk.Address(bz) - packet := ibc.NewIBCPacket(from, to, coins, viper.GetString(client.FlagNode), + packet := ibc.NewIBCPacket(from, to, coins, viper.GetString(flagChain), viper.GetString(flagChain)) msg := ibc.IBCTransferMsg{ diff --git a/x/ibc/commands/relay.go b/x/ibc/commands/relay.go index 865523067b..b2f116b5d2 100644 --- a/x/ibc/commands/relay.go +++ b/x/ibc/commands/relay.go @@ -17,8 +17,10 @@ import ( ) const ( - flagChain1 = "chain1" - flagChain2 = "chain2" + FlagFromChainID = "from-chain-id" + FlagFromChainNode = "from-chain-node" + FlagToChainID = "to-chain-id" + FlagToChainNode = "to-chain-node" ) func IBCRelayCmd(cdc *wire.Codec) *cobra.Command { @@ -31,8 +33,24 @@ func IBCRelayCmd(cdc *wire.Codec) *cobra.Command { Use: "relay", Run: cmdr.runIBCRelay, } - cmd.Flags().String(flagChain1, "", "Chain ID to relay IBC packets") - cmd.Flags().String(flagChain2, "", "Chain ID to relay IBC packets") + cmd.Flags().String(client.FlagName, "", "Name of private key with which to sign") + cmd.Flags().Bool(client.FlagTrustNode, true, "Don't verify proofs for responses") + cmd.Flags().String(FlagFromChainID, "", "Chain ID for ibc node to check outgoing packets") + cmd.Flags().String(FlagFromChainNode, "tcp://localhost:46657", ": to tendermint rpc interface for this chain") + cmd.Flags().String(FlagToChainID, "", "Chain ID for ibc node to broadcast incoming packets") + cmd.Flags().String(FlagToChainNode, "tcp://localhost:46658", ": to tendermint rpc interface for this chain") + cmd.MarkFlagRequired(client.FlagName) + cmd.MarkFlagRequired(FlagFromChainID) + cmd.MarkFlagRequired(FlagFromChainNode) + cmd.MarkFlagRequired(FlagToChainID) + cmd.MarkFlagRequired(FlagToChainNode) + viper.BindPFlag(client.FlagName, cmd.Flags().Lookup(client.FlagName)) + viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode)) + viper.BindPFlag(FlagFromChainID, cmd.Flags().Lookup(FlagFromChainID)) + viper.BindPFlag(FlagFromChainNode, cmd.Flags().Lookup(FlagFromChainNode)) + viper.BindPFlag(FlagToChainID, cmd.Flags().Lookup(FlagToChainID)) + viper.BindPFlag(FlagToChainNode, cmd.Flags().Lookup(FlagToChainNode)) + return cmd } @@ -43,17 +61,17 @@ type relayCommander struct { } func (c relayCommander) runIBCRelay(cmd *cobra.Command, args []string) { - chain1 := viper.GetString(flagChain1) - chain2 := viper.GetString(flagChain2) - + fromChainID := viper.GetString(FlagFromChainID) + fromChainNode := viper.GetString(FlagFromChainNode) + toChainID := viper.GetString(FlagToChainID) + toChainNode := viper.GetString(FlagToChainNode) address, err := builder.GetFromAddress() if err != nil { panic(err) } c.address = address - go c.loop(chain1, chain2) - go c.loop(chain2, chain1) + c.loop(fromChainID, fromChainNode, toChainID, toChainNode) } // https://github.com/cosmos/cosmos-sdk/blob/master/client/helpers.go using specified address @@ -92,16 +110,18 @@ func (c relayCommander) refine(bz []byte, sequence int64) []byte { return res } -func (c relayCommander) loop(fromID, toID string) { - ingressKey := ibc.IngressKey(fromID) +func (c relayCommander) loop(fromChainID, fromChainNode, toChainID, toChainNode string) { + ingressKey := ibc.IngressKey(fromChainID) - processedbz, err := query(toID, ingressKey, c.ibcStore) + processedbz, err := query(toChainNode, ingressKey, c.ibcStore) if err != nil { panic(err) } var processed int64 - if err = c.cdc.UnmarshalBinary(processedbz, &processed); err != nil { + if processedbz == nil { + processed = 0 + } else if err = c.cdc.UnmarshalBinary(processedbz, &processed); err != nil { panic(err) } @@ -109,25 +129,27 @@ OUTER: for { time.Sleep(time.Second) - lengthKey := ibc.EgressLengthKey(toID) - egressLengthbz, err := query(fromID, lengthKey, c.ibcStore) + lengthKey := ibc.EgressLengthKey(toChainID) + egressLengthbz, err := query(fromChainNode, lengthKey, c.ibcStore) if err != nil { fmt.Printf("Error querying outgoing packet list length: '%s'\n", err) continue OUTER } var egressLength int64 - if err = c.cdc.UnmarshalBinary(egressLengthbz, &egressLength); err != nil { + if egressLengthbz == nil { + egressLength = 0 + } else if err = c.cdc.UnmarshalBinary(egressLengthbz, &egressLength); err != nil { panic(err) } for i := processed; i < egressLength; i++ { - egressbz, err := query(fromID, ibc.EgressKey(toID, i), c.ibcStore) + egressbz, err := query(fromChainNode, ibc.EgressKey(toChainID, i), c.ibcStore) if err != nil { fmt.Printf("Error querying egress packet: '%s'\n", err) continue OUTER } - err = broadcastTx(toID, c.refine(egressbz, i)) + err = broadcastTx(toChainNode, c.refine(egressbz, i)) if err != nil { fmt.Printf("Error broadcasting ingress packet: '%s'\n", err) continue OUTER diff --git a/x/ibc/types.go b/x/ibc/types.go index 08cf1dfad7..d450bae096 100644 --- a/x/ibc/types.go +++ b/x/ibc/types.go @@ -4,6 +4,12 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" wire "github.com/cosmos/cosmos-sdk/wire" + + // temporal + "github.com/cosmos/cosmos-sdk/examples/basecoin/types" + "github.com/cosmos/cosmos-sdk/examples/basecoin/x/cool" + "github.com/cosmos/cosmos-sdk/x/bank" + oldwire "github.com/tendermint/go-wire" ) // ------------------------------ @@ -31,6 +37,38 @@ func NewIBCPacket(srcAddr sdk.Address, destAddr sdk.Address, coins sdk.Coins, } } +func makeCodec() *wire.Codec { // basecoin/app.MakeCodec() + const ( + msgTypeSend = 0x1 + msgTypeIssue = 0x2 + msgTypeQuiz = 0x3 + msgTypeSetTrend = 0x4 + msgTypeIBCTransfer = 0x5 + msgTypeIBCReceive = 0x6 + ) + + var _ = oldwire.RegisterInterface( + struct{ sdk.Msg }{}, + oldwire.ConcreteType{bank.SendMsg{}, msgTypeSend}, + oldwire.ConcreteType{bank.IssueMsg{}, msgTypeIssue}, + oldwire.ConcreteType{cool.QuizMsg{}, msgTypeQuiz}, + oldwire.ConcreteType{cool.SetTrendMsg{}, msgTypeSetTrend}, + oldwire.ConcreteType{IBCTransferMsg{}, msgTypeIBCTransfer}, + oldwire.ConcreteType{IBCReceiveMsg{}, msgTypeIBCReceive}, + ) + + const accTypeApp = 0x1 + var _ = oldwire.RegisterInterface( + struct{ sdk.Account }{}, + oldwire.ConcreteType{&types.AppAccount{}, accTypeApp}, + ) + + cdc := wire.NewCodec() + + return cdc + +} + // ---------------------------------- // IBCTransferMsg @@ -48,7 +86,7 @@ func (msg IBCTransferMsg) Get(key interface{}) interface{} { } func (msg IBCTransferMsg) GetSignBytes() []byte { - cdc := newCodec() + cdc := makeCodec() bz, err := cdc.MarshalBinary(msg.IBCPacket) if err != nil { panic(err)