125 lines
4.1 KiB
Go
125 lines
4.1 KiB
Go
package utils
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client/context"
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
|
|
commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types"
|
|
ibctypes "github.com/cosmos/cosmos-sdk/x/ibc/types"
|
|
)
|
|
|
|
// QueryAllConnections returns all the connections. It _does not_ return
|
|
// any merkle proof.
|
|
func QueryAllConnections(cliCtx context.CLIContext, page, limit int) ([]types.ConnectionEnd, int64, error) {
|
|
params := types.NewQueryAllConnectionsParams(page, limit)
|
|
bz, err := cliCtx.Codec.MarshalJSON(params)
|
|
if err != nil {
|
|
return nil, 0, fmt.Errorf("failed to marshal query params: %w", err)
|
|
}
|
|
|
|
route := fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryAllConnections)
|
|
res, height, err := cliCtx.QueryWithData(route, bz)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
var connections []types.ConnectionEnd
|
|
err = cliCtx.Codec.UnmarshalJSON(res, &connections)
|
|
if err != nil {
|
|
return nil, 0, fmt.Errorf("failed to unmarshal connections: %w", err)
|
|
}
|
|
return connections, height, nil
|
|
}
|
|
|
|
// QueryConnection queries the store to get a connection end and a merkle
|
|
// proof.
|
|
func QueryConnection(
|
|
cliCtx context.CLIContext, connectionID string, prove bool,
|
|
) (types.ConnectionResponse, error) {
|
|
req := abci.RequestQuery{
|
|
Path: "store/ibc/key",
|
|
Data: ibctypes.KeyConnection(connectionID),
|
|
Prove: prove,
|
|
}
|
|
|
|
res, err := cliCtx.QueryABCI(req)
|
|
if err != nil {
|
|
return types.ConnectionResponse{}, err
|
|
}
|
|
|
|
var connection types.ConnectionEnd
|
|
if err := cliCtx.Codec.UnmarshalBinaryBare(res.Value, &connection); err != nil {
|
|
return types.ConnectionResponse{}, err
|
|
}
|
|
|
|
connRes := types.NewConnectionResponse(connectionID, connection, res.Proof, res.Height)
|
|
|
|
return connRes, nil
|
|
}
|
|
|
|
// QueryClientConnections queries the store to get the registered connection paths
|
|
// registered for a particular client and a merkle proof.
|
|
func QueryClientConnections(
|
|
cliCtx context.CLIContext, clientID string, prove bool,
|
|
) (types.ClientConnectionsResponse, error) {
|
|
req := abci.RequestQuery{
|
|
Path: "store/ibc/key",
|
|
Data: ibctypes.KeyClientConnections(clientID),
|
|
Prove: prove,
|
|
}
|
|
|
|
res, err := cliCtx.QueryABCI(req)
|
|
if err != nil {
|
|
return types.ClientConnectionsResponse{}, err
|
|
}
|
|
|
|
var paths []string
|
|
if err := cliCtx.Codec.UnmarshalBinaryBare(res.Value, &paths); err != nil {
|
|
return types.ClientConnectionsResponse{}, err
|
|
}
|
|
|
|
connPathsRes := types.NewClientConnectionsResponse(clientID, paths, res.Proof, res.Height)
|
|
return connPathsRes, nil
|
|
}
|
|
|
|
// ParsePrefix unmarshals an cmd input argument from a JSON string to a commitment
|
|
// Prefix. If the input is not a JSON, it looks for a path to the JSON file.
|
|
func ParsePrefix(cdc *codec.Codec, arg string) (commitmenttypes.MerklePrefix, error) {
|
|
var prefix commitmenttypes.MerklePrefix
|
|
if err := cdc.UnmarshalJSON([]byte(arg), &prefix); err != nil {
|
|
// check for file path if JSON input is not provided
|
|
contents, err := ioutil.ReadFile(arg)
|
|
if err != nil {
|
|
return commitmenttypes.MerklePrefix{}, errors.New("neither JSON input nor path to .json file were provided")
|
|
}
|
|
if err := cdc.UnmarshalJSON(contents, &prefix); err != nil {
|
|
return commitmenttypes.MerklePrefix{}, errors.Wrap(err, "error unmarshalling commitment prefix")
|
|
}
|
|
}
|
|
return prefix, nil
|
|
}
|
|
|
|
// ParseProof unmarshals an cmd input argument from a JSON string to a commitment
|
|
// Proof. If the input is not a JSON, it looks for a path to the JSON file.
|
|
func ParseProof(cdc *codec.Codec, arg string) (commitmenttypes.MerkleProof, error) {
|
|
var proof commitmenttypes.MerkleProof
|
|
if err := cdc.UnmarshalJSON([]byte(arg), &proof); err != nil {
|
|
// check for file path if JSON input is not provided
|
|
contents, err := ioutil.ReadFile(arg)
|
|
if err != nil {
|
|
return commitmenttypes.MerkleProof{}, errors.New("neither JSON input nor path to .json file were provided")
|
|
}
|
|
if err := cdc.UnmarshalJSON(contents, &proof); err != nil {
|
|
return commitmenttypes.MerkleProof{}, errors.Wrap(err, "error unmarshalling commitment proof")
|
|
}
|
|
}
|
|
return proof, nil
|
|
}
|