Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Misc ibc fixes #5357

Merged
merged 6 commits into from
Dec 10, 2019
Merged

Misc ibc fixes #5357

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
0eff598
fix cli ExactArgs
fedekunze Dec 3, 2019
0cd34d5
merge ibc-alpha
fedekunze Dec 3, 2019
231e7ba
remove full handshakes
fedekunze Dec 3, 2019
bc729be
rm dup flag
fedekunze Dec 4, 2019
116f406
fix error handling
fedekunze Dec 6, 2019
495e276
Merge branch 'ibc-alpha' of https://github.com/cosmos/cosmos-sdk into…
fedekunze Dec 10, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
282 changes: 10 additions & 272 deletions x/ibc/03-connection/client/cli/tx.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,18 +36,18 @@ const (
// chain A with a given counterparty chain B
func GetCmdConnectionOpenInit(storeKey string, cdc *codec.Codec) *cobra.Command {
cmd := &cobra.Command{
Use: strings.TrimSpace(`open-init [connection-id] [client-id] [counterparty-connection-id]
[counterparty-client-id] [path/to/counterparty_prefix.json]`),
Use: strings.TrimSpace(`open-init [connection-id] [client-id] [counterparty-connection-id] [counterparty-client-id] [path/to/counterparty_prefix.json]`),
Short: "initialize connection on chain A",
Long: strings.TrimSpace(
fmt.Sprintf(`initialize a connection on chain A with a given counterparty chain B:

Example:
$ %s tx ibc connection open-init [connection-id] [client-id] [counterparty-connection-id]
[counterparty-client-id] [path/to/counterparty_prefix.json]
$ %s tx ibc connection open-init [connection-id] [client-id] \
[counterparty-connection-id] [counterparty-client-id] \
[path/to/counterparty_prefix.json]
`, version.ClientName),
),
Args: cobra.ExactArgs(6),
Args: cobra.ExactArgs(5),
RunE: func(cmd *cobra.Command, args []string) error {
inBuf := bufio.NewReader(cmd.InOrStdin())
txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
Expand Down Expand Up @@ -87,20 +87,20 @@ $ %s tx ibc connection open-init [connection-id] [client-id] [counterparty-conne
// chain B
func GetCmdConnectionOpenTry(storeKey string, cdc *codec.Codec) *cobra.Command {
cmd := &cobra.Command{
Use: strings.TrimSpace(`open-try [connection-id] [client-id]
Use: strings.TrimSpace(`open-try [connection-id] [client-id]
[counterparty-connection-id] [counterparty-client-id] [path/to/counterparty_prefix.json]
[counterparty-versions] [path/to/proof_init.json]`),
Short: "initiate connection handshake between two chains",
Long: strings.TrimSpace(
fmt.Sprintf(`initialize a connection on chain A with a given counterparty chain B:

Example:
$ %s tx ibc connection open-try connection-id] [client-id]
[counterparty-connection-id] [counterparty-client-id] [path/to/counterparty_prefix.json]
$ %s tx ibc connection open-try connection-id] [client-id] \
[counterparty-connection-id] [counterparty-client-id] [path/to/counterparty_prefix.json] \
[counterparty-versions] [path/to/proof_init.json]
`, version.ClientName),
),
Args: cobra.ExactArgs(6),
Args: cobra.ExactArgs(7),
RunE: func(cmd *cobra.Command, args []string) error {
inBuf := bufio.NewReader(cmd.InOrStdin())
txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
Expand Down Expand Up @@ -224,7 +224,7 @@ Example:
$ %s tx ibc connection open-confirm [connection-id] [path/to/proof_ack.json]
`, version.ClientName),
),
Args: cobra.ExactArgs(3),
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
inBuf := bufio.NewReader(cmd.InOrStdin())
txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
Expand Down Expand Up @@ -289,265 +289,3 @@ func parsePath(cdc *codec.Codec, arg string) (commitment.Prefix, error) {
}
return path, nil
}

// func GetCmdHandshakeState(storeKey string, cdc *codec.Codec) *cobra.Command {
// cmd := &cobra.Command{
// Use: "handshake [conn-id-chain-1] [client-id-chain-1] [path-chain-1] [conn-id-chain-2] [client-id-chain-2] [path-chain-2] ",
// Short: "initiate connection handshake between two chains",
// Args: cobra.ExactArgs(6),
// RunE: func(cmd *cobra.Command, args []string) error {
// inBuf := bufio.NewReader(cmd.InOrStdin())
// prove := true

// // --chain-id values for each chain
// cid1 := viper.GetString(flags.FlagChainID)
// cid2 := viper.GetString(FlagChainID2)

// // --from values for each wallet
// from1 := viper.GetString(FlagFrom1)
// from2 := viper.GetString(FlagFrom2)

// // --node values for each RPC
// rpc1 := viper.GetString(FlagNode1)
// rpc2 := viper.GetString(FlagNode2)

// // ibc connection-id for each chain
// connID1 := args[0]
// connID2 := args[3]

// // ibc client-id for each chain
// clientID1 := args[1]
// clientID2 := args[4]

// // Get default version
// version := types.GetCompatibleVersions()[0]

// // Create txbldr, clictx, querier for cid1
// viper.Set(flags.FlagChainID, cid1)
// txBldr1 := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
// ctx1 := context.NewCLIContextIBC(inBuf, from1, cid1, rpc1).WithCodec(cdc).
// WithBroadcastMode(flags.BroadcastBlock)

// // Create txbldr, clictx, querier for cid1
// viper.Set(flags.FlagChainID, cid2)
// txBldr2 := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
// ctx2 := context.NewCLIContextIBC(inBuf, from2, cid2, rpc2).WithCodec(cdc).
// WithBroadcastMode(flags.BroadcastBlock)

// // read in path for cid1
// path1, err := parsePath(ctx1.Codec, args[2])
// if err != nil {
// return err
// }

// // read in path for cid2
// path2, err := parsePath(ctx1.Codec, args[5])
// if err != nil {
// return err
// }

// // get passphrase for key from1
// passphrase1, err := keys.GetPassphrase(from1)
// if err != nil {
// return err
// }

// // get passphrase for key from2
// passphrase2, err := keys.GetPassphrase(from2)
// if err != nil {
// return err
// }

// viper.Set(flags.FlagChainID, cid1)
// msgOpenInit := types.NewMsgConnectionOpenInit(
// connID1, clientID1, connID2, clientID2,
// path2, ctx1.GetFromAddress(),
// )

// if err := msgOpenInit.ValidateBasic(); err != nil {
// return err
// }

// fmt.Printf("%v <- %-14v", cid1, msgOpenInit.Type())
// res, err := utils.CompleteAndBroadcastTx(txBldr1, ctx1, []sdk.Msg{msgOpenInit}, passphrase1)
// if err != nil || !res.IsOK() {
// return err
// }

// fmt.Printf(" [OK] txid(%v) client(%v) conn(%v)\n", res.TxHash, clientID1, connID1)

// // Another block has to be passed after msgOpenInit is committed
// // to retrieve the correct proofs
// // TODO: Modify this to actually check two blocks being processed, and
// // remove hardcoding this to 8 seconds.
// time.Sleep(8 * time.Second)

// header, _, err := clientutils.QueryTendermintHeader(ctx1)
// if err != nil {
// return err
// }

// // Create and send msgUpdateClient
// viper.Set(flags.FlagChainID, cid2)
// msgUpdateClient := clienttypes.NewMsgUpdateClient(clientID2, header, ctx2.GetFromAddress())

// if err := msgUpdateClient.ValidateBasic(); err != nil {
// return err
// }

// fmt.Printf("%v <- %-14v", cid2, msgUpdateClient.Type())
// res, err = utils.CompleteAndBroadcastTx(txBldr2, ctx2, []sdk.Msg{msgUpdateClient}, passphrase2)
// if err != nil || !res.IsOK() {
// return err
// }
// fmt.Printf(" [OK] txid(%v) client(%v)\n", res.TxHash, clientID1)

// // Fetch proofs from cid1
// viper.Set(flags.FlagChainID, cid1)
// proofs, err := queryProofs(ctx1.WithHeight(header.Height-1), connID1, storeKey)
// if err != nil {
// return err
// }

// csProof, err := clientutils.QueryConsensusStateProof(ctx1.WithHeight(header.Height-1), clientID1, prove)
// if err != nil {
// return err
// }

// // Create and send msgOpenTry
// viper.Set(flags.FlagChainID, cid2)
// msgOpenTry := types.NewMsgConnectionOpenTry(connID2, clientID2, connID1, clientID1, path1, []string{version}, proofs.Proof, csProof.Proof, uint64(header.Height), uint64(header.Height), ctx2.GetFromAddress())

// if err := msgOpenTry.ValidateBasic(); err != nil {
// return err
// }

// fmt.Printf("%v <- %-14v", cid2, msgOpenTry.Type())

// res, err = utils.CompleteAndBroadcastTx(txBldr2, ctx2, []sdk.Msg{msgOpenTry}, passphrase2)
// if err != nil || !res.IsOK() {
// return err
// }

// fmt.Printf(" [OK] txid(%v) client(%v) connection(%v)\n", res.TxHash, clientID2, connID2)

// // Another block has to be passed after msgOpenInit is committed
// // to retrieve the correct proofs
// // TODO: Modify this to actually check two blocks being processed, and
// // remove hardcoding this to 8 seconds.
// time.Sleep(8 * time.Second)

// header, _, err = clientutils.QueryTendermintHeader(ctx2)
// if err != nil {
// return err
// }

// // Update the client for cid2 on cid1
// viper.Set(flags.FlagChainID, cid1)
// msgUpdateClient = clienttypes.NewMsgUpdateClient(clientID1, header, ctx1.GetFromAddress())

// if err := msgUpdateClient.ValidateBasic(); err != nil {
// return err
// }

// res, err = utils.CompleteAndBroadcastTx(txBldr1, ctx1, []sdk.Msg{msgUpdateClient}, passphrase1)
// if err != nil || !res.IsOK() {
// return err
// }
// fmt.Printf(" [OK] txid(%v) client(%v)\n", res.TxHash, clientID2)

// // Fetch proofs from cid2
// viper.Set(flags.FlagChainID, cid2)
// proofs, err = queryProofs(ctx2.WithHeight(header.Height-1), connID2, storeKey)
// if err != nil {
// return err
// }

// csProof, err = clientutils.QueryConsensusStateProof(ctx2.WithHeight(header.Height-1), clientID2, prove)
// if err != nil {
// return err
// }

// // Create and send msgOpenAck
// viper.Set(flags.FlagChainID, cid1)
// msgOpenAck := types.NewMsgConnectionOpenAck(connID1, proofs.Proof, csProof.Proof, uint64(header.Height), uint64(header.Height), version, ctx1.GetFromAddress())

// if err := msgOpenAck.ValidateBasic(); err != nil {
// return err
// }

// fmt.Printf("%v <- %-14v", cid1, msgOpenAck.Type())

// res, err = utils.CompleteAndBroadcastTx(txBldr1, ctx1, []sdk.Msg{msgOpenAck}, passphrase1)
// if err != nil || !res.IsOK() {
// return err
// }
// fmt.Printf(" [OK] txid(%v) connection(%v)\n", res.TxHash, connID1)

// // Another block has to be passed after msgOpenInit is committed
// // to retrieve the correct proofs
// // TODO: Modify this to actually check two blocks being processed, and
// // remove hardcoding this to 8 seconds.
// time.Sleep(8 * time.Second)

// header, _, err = clientutils.QueryTendermintHeader(ctx1)
// if err != nil {
// return err
// }

// // Update client for cid1 on cid2
// viper.Set(flags.FlagChainID, cid2)
// msgUpdateClient = clienttypes.NewMsgUpdateClient(clientID2, header, ctx2.GetFromAddress())

// if err := msgUpdateClient.ValidateBasic(); err != nil {
// return err
// }

// fmt.Printf("%v <- %-14v", cid2, msgUpdateClient.Type())

// res, err = utils.CompleteAndBroadcastTx(txBldr2, ctx2, []sdk.Msg{msgUpdateClient}, passphrase2)
// if err != nil || !res.IsOK() {
// return err
// }
// fmt.Printf(" [OK] txid(%v) client(%v)\n", res.TxHash, clientID1)

// viper.Set(flags.FlagChainID, cid1)
// proofs, err = queryProofs(ctx1.WithHeight(header.Height-1), connID1, storeKey)
// if err != nil {
// return err
// }

// // Create and send msgOpenConfirm
// viper.Set(flags.FlagChainID, cid2)
// msgOpenConfirm := types.NewMsgConnectionOpenConfirm(connID2, proofs.Proof, uint64(header.Height), ctx2.GetFromAddress())

// if err := msgOpenConfirm.ValidateBasic(); err != nil {
// return err
// }

// fmt.Printf("%v <- %-14v", cid1, msgOpenConfirm.Type())

// res, err = utils.CompleteAndBroadcastTx(txBldr2, ctx2, []sdk.Msg{msgOpenConfirm}, passphrase2)
// if err != nil || !res.IsOK() {
// return err
// }
// fmt.Printf(" [OK] txid(%v) connection(%v)\n", res.TxHash, connID2)

// return nil
// },
// }

// cmd.Flags().String(FlagNode1, "tcp://localhost:26657", "RPC port for the first chain")
// cmd.Flags().String(FlagNode2, "tcp://localhost:26657", "RPC port for the second chain")
// cmd.Flags().String(FlagFrom1, "", "key in local keystore for first chain")
// cmd.Flags().String(FlagFrom2, "", "key in local keystore for second chain")
// cmd.Flags().String(FlagChainID2, "", "chain-id for the second chain")

// cmd.MarkFlagRequired(FlagNode1)
// cmd.MarkFlagRequired(FlagNode2)
// cmd.MarkFlagRequired(FlagFrom1)
// cmd.MarkFlagRequired(FlagFrom2)
// cmd.MarkFlagRequired(FlagChainID2)

// return cmd
// }
2 changes: 1 addition & 1 deletion x/ibc/03-connection/keeper/handshake.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,7 +31,7 @@ func (k Keeper) ConnOpenInit(

err := k.addConnectionToClient(ctx, clientID, connectionID)
if err != nil {
sdkerrors.Wrap(err, "cannot initialize connection")
return sdkerrors.Wrap(err, "cannot initialize connection")
}

k.Logger(ctx).Info(fmt.Sprintf("connection %s state updated: NONE -> INIT", connectionID))
Expand Down
Loading