feature/ archway module setup (#57)

* feat: archway app_module and codec

* feat: archway setup

* feat: scaffold methods for archway provider

* feat: scaffold archway_chain_processor

* feat: archway scaffold finalize

* feat: archway provider and processor added to strategies

* chore: fix failed test

cmd/config.go

@@ -31,6 +31,7 @@ import (
 	"time"
 
 	"github.com/icon-project/ibc-relayer/relayer"
+	archway "github.com/cosmos/relayer/v2/relayer/chains/archway"
 	"github.com/icon-project/ibc-relayer/relayer/chains/cosmos"
 	"github.com/icon-project/ibc-relayer/relayer/chains/icon"
 	"github.com/icon-project/ibc-relayer/relayer/chains/penumbra"
@@ -379,6 +380,7 @@ func (pcw *ProviderConfigWrapper) UnmarshalJSON(data []byte) error {
 		"icon":   reflect.TypeOf(icon.IconProviderConfig{}),
 		"cosmos":   reflect.TypeOf(cosmos.CosmosProviderConfig{}),
 		"penumbra": reflect.TypeOf(penumbra.PenumbraProviderConfig{}),
+		"archway": reflect.TypeOf(archway.ArchwayProviderConfig{}),
 	}
 	val, err := UnmarshalJSONProviderConfig(data, customTypes)
 	if err != nil {
@@ -439,6 +441,8 @@ func (iw *ProviderConfigYAMLWrapper) UnmarshalYAML(n *yaml.Node) error {
 		iw.Value = new(icon.IconProviderConfig)
 	case "penumbra":
 		iw.Value = new(penumbra.PenumbraProviderConfig)
+	case "archway":
+		iw.Value = new(archway.ArchwayProviderConfig)
 	default:
 		return fmt.Errorf("%s is an invalid chain type, check your config file", iw.Type)
 	}

relayer/chains/archway/archway_chain_processor.go

@@ -0,0 +1,75 @@
+package archway
+
+import (
+	"context"
+
+	"github.com/cosmos/relayer/v2/relayer/processor"
+	"github.com/cosmos/relayer/v2/relayer/provider"
+	"go.uber.org/zap"
+)
+
+type ArchwayChainProcessor struct {
+	log *zap.Logger
+
+	chainProvider *ArchwayProvider
+
+	pathProcessors processor.PathProcessors
+
+	// indicates whether queries are in sync with latest height of the chain
+	inSync bool
+
+	// highest block
+	latestBlock provider.LatestBlock
+
+	// holds highest consensus height and header for all clients
+	latestClientState
+
+	// holds open state for known connections
+	connectionStateCache processor.ConnectionStateCache
+
+	// holds open state for known channels
+	channelStateCache processor.ChannelStateCache
+
+	// map of connection ID to client ID
+	connectionClients map[string]string
+
+	// map of channel ID to connection ID
+	channelConnections map[string]string
+
+	// metrics to monitor lifetime of processor
+	metrics *processor.PrometheusMetrics
+}
+
+func NewArchwayChainProcessor(log *zap.Logger, provider *ArchwayProvider, metrics *processor.PrometheusMetrics) *ArchwayChainProcessor {
+	return &ArchwayChainProcessor{
+		log:                  log.With(zap.String("chain_name", provider.ChainName()), zap.String("chain_id", provider.ChainId())),
+		chainProvider:        provider,
+		latestClientState:    make(latestClientState),
+		connectionStateCache: make(processor.ConnectionStateCache),
+		channelStateCache:    make(processor.ChannelStateCache),
+		connectionClients:    make(map[string]string),
+		channelConnections:   make(map[string]string),
+		metrics:              metrics,
+	}
+}
+
+type latestClientState map[string]provider.ClientState
+
+func (l latestClientState) update(ctx context.Context, clientInfo clientInfo, ccp *ArchwayChainProcessor) {
+	// TODO:
+}
+
+// Provider returns the ChainProvider, which provides the methods for querying, assembling IBC messages, and sending transactions.
+func (ccp *ArchwayChainProcessor) Provider() provider.ChainProvider {
+	return ccp.chainProvider
+}
+
+// Set the PathProcessors that this ChainProcessor should publish relevant IBC events to.
+// ChainProcessors need reference to their PathProcessors and vice-versa, handled by EventProcessorBuilder.Build().
+func (ccp *ArchwayChainProcessor) SetPathProcessors(pathProcessors processor.PathProcessors) {
+	ccp.pathProcessors = pathProcessors
+}
+
+func (ccp *ArchwayChainProcessor) Run(ctx context.Context, initialBlockHistory uint64) error {
+	return nil
+}

relayer/chains/archway/codec.go

@@ -0,0 +1,37 @@
+package archway
+
+import (
+	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/types"
+	"github.com/cosmos/cosmos-sdk/std"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	ibc "github.com/cosmos/ibc-go/v7/modules/core"
+	archway_module "github.com/cosmos/relayer/v2/relayer/chains/archway/module"
+)
+
+var ModuleBasics = []module.AppModuleBasic{
+	ibc.AppModuleBasic{},
+	archway_module.AppModuleBasic{},
+}
+
+type Codec struct {
+	InterfaceRegistry types.InterfaceRegistry
+	Marshaler         codec.Codec
+}
+
+func MakeCodec(moduleBasics []module.AppModuleBasic, extraCodecs []string) Codec {
+	modBasic := module.NewBasicManager(moduleBasics...)
+	encodingConfig := MakeCodecConfig()
+	std.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	modBasic.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	return encodingConfig
+}
+
+func MakeCodecConfig() Codec {
+	interfaceRegistry := types.NewInterfaceRegistry()
+	marshaler := codec.NewProtoCodec(interfaceRegistry)
+	return Codec{
+		InterfaceRegistry: interfaceRegistry,
+		Marshaler:         marshaler,
+	}
+}

relayer/chains/archway/event_parser.go

@@ -0,0 +1,23 @@
+package archway
+
+import (
+	"time"
+
+	clienttypes "github.com/cosmos/ibc-go/v7/modules/core/02-client/types"
+	"github.com/cosmos/relayer/v2/relayer/provider"
+)
+
+type clientInfo struct {
+	clientID        string
+	consensusHeight clienttypes.Height
+	header          []byte
+}
+
+func (c clientInfo) ClientState(trustingPeriod time.Duration) provider.ClientState {
+	return provider.ClientState{
+		ClientID:        c.clientID,
+		ConsensusHeight: c.consensusHeight,
+		TrustingPeriod:  trustingPeriod,
+		Header:          c.header,
+	}
+}

relayer/chains/archway/keys.go

@@ -0,0 +1,201 @@
+package archway
+
+import (
+	// 	"errors"
+	// 	"os"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/relayer/v2/relayer/provider"
+	// "github.com/cosmos/go-bip39"
+	// "github.com/cosmos/relayer/v2/relayer/codecs/ethermint"
+	// "github.com/cosmos/relayer/v2/relayer/codecs/injective"
+	// "github.com/cosmos/relayer/v2/relayer/provider"
+)
+
+// const ethereumCoinType = uint32(60)
+
+// var (
+// 	// SupportedAlgorithms defines the list of signing algorithms used on Evmos:
+// 	//  - secp256k1     (Cosmos)
+// 	//  - eth_secp256k1 (Ethereum)
+// 	SupportedAlgorithms = keyring.SigningAlgoList{hd.Secp256k1, ethermint.EthSecp256k1, injective.EthSecp256k1}
+// 	// SupportedAlgorithmsLedger defines the list of signing algorithms used on Evmos for the Ledger device:
+// 	//  - secp256k1     (Cosmos)
+// 	//  - eth_secp256k1 (Ethereum)
+// 	SupportedAlgorithmsLedger = keyring.SigningAlgoList{hd.Secp256k1, ethermint.EthSecp256k1, injective.EthSecp256k1}
+// )
+
+// // KeyringAlgoOptions defines a function keys options for the ethereum Secp256k1 curve.
+// // It supports secp256k1 and eth_secp256k1 keys for accounts.
+// func KeyringAlgoOptions() keyring.Option {
+// 	return func(options *keyring.Options) {
+// 		options.SupportedAlgos = SupportedAlgorithms
+// 		options.SupportedAlgosLedger = SupportedAlgorithmsLedger
+// 	}
+// }
+
+// // CreateKeystore initializes a new instance of a keyring at the specified path in the local filesystem.
+func (cc *ArchwayProvider) CreateKeystore(path string) error {
+	// keybase, err := keyring.New(cc.PCfg.ChainID, cc.PCfg.KeyringBackend, cc.PCfg.KeyDirectory, cc.Input, cc.Cdc.Marshaler, KeyringAlgoOptions())
+	// if err != nil {
+	// 	return err
+	// }
+	// cc.Keybase = keybase
+	return nil
+}
+
+// // KeystoreCreated returns true if there is an existing keystore instance at the specified path, it returns false otherwise.
+func (cc *ArchwayProvider) KeystoreCreated(path string) bool {
+	// if _, err := os.Stat(cc.PCfg.KeyDirectory); errors.Is(err, os.ErrNotExist) {
+	// 	return false
+	// } else if cc.Keybase == nil {
+	// 	return false
+	// }
+	return true
+}
+
+// // AddKey generates a new mnemonic which is then converted to a private key and BIP-39 HD Path and persists it to the keystore.
+// // It fails if there is an existing key with the same address.
+func (cc *ArchwayProvider) AddKey(name string, coinType uint32) (output *provider.KeyOutput, err error) {
+	// ko, err := cc.KeyAddOrRestore(name, coinType)
+	// if err != nil {
+	// 	return nil, err
+	// }
+	return nil, nil
+}
+
+// // RestoreKey converts a mnemonic to a private key and BIP-39 HD Path and persists it to the keystore.
+// // It fails if there is an existing key with the same address.
+func (cc *ArchwayProvider) RestoreKey(name, mnemonic string, coinType uint32) (address string, err error) {
+	// ko, err := cc.KeyAddOrRestore(name, coinType, mnemonic)
+	// if err != nil {
+	// 	return "", err
+	// }
+	return "", nil
+}
+
+// // KeyAddOrRestore either generates a new mnemonic or uses the specified mnemonic and converts it to a private key
+// // and BIP-39 HD Path which is then persisted to the keystore. It fails if there is an existing key with the same address.
+// func (cc *ArchwayProvider) KeyAddOrRestore(keyName string, coinType uint32, mnemonic ...string) (*provider.KeyOutput, error) {
+// 	var mnemonicStr string
+// 	var err error
+// 	algo := keyring.SignatureAlgo(hd.Secp256k1)
+
+// 	if len(mnemonic) > 0 {
+// 		mnemonicStr = mnemonic[0]
+// 	} else {
+// 		mnemonicStr, err = CreateMnemonic()
+// 		if err != nil {
+// 			return nil, err
+// 		}
+// 	}
+
+// 	info, err := cc.Keybase.NewAccount(keyName, mnemonicStr, "", hd.CreateHDPath(coinType, 0, 0).String(), algo)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+
+// 	acc, err := info.GetAddress()
+// 	if err != nil {
+// 		return nil, err
+// 	}
+
+// 	out, err := cc.EncodeBech32AccAddr(acc)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	return &provider.KeyOutput{Mnemonic: mnemonicStr, Address: out}, nil
+// }
+
+// // ShowAddress retrieves a key by name from the keystore and returns the bech32 encoded string representation of that key.
+func (cc *ArchwayProvider) ShowAddress(name string) (address string, err error) {
+	// info, err := cc.Keybase.Key(name)
+	// if err != nil {
+	// 	return "", err
+	// }
+	// acc, err := info.GetAddress()
+	// if err != nil {
+	// 	return "", nil
+	// }
+	// out, err := cc.EncodeBech32AccAddr(acc)
+	// if err != nil {
+	// 	return "", err
+	// }
+	return "", nil
+}
+
+// // ListAddresses returns a map of bech32 encoded strings representing all keys currently in the keystore.
+func (cc *ArchwayProvider) ListAddresses() (map[string]string, error) {
+	out := map[string]string{}
+	// info, err := cc.Keybase.List()
+	// if err != nil {
+	// 	return nil, err
+	// }
+	// for _, k := range info {
+	// 	acc, err := k.GetAddress()
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	addr, err := cc.EncodeBech32AccAddr(acc)
+	// 	if err != nil {
+	// 		return nil, err
+	// 	}
+	// 	out[k.Name] = addr
+	// }
+	return out, nil
+}
+
+// // DeleteKey removes a key from the keystore for the specified name.
+func (cc *ArchwayProvider) DeleteKey(name string) error {
+	// 	if err := cc.Keybase.Delete(name); err != nil {
+	// 		return err
+	// 	}
+	return nil
+}
+
+// // KeyExists returns true if a key with the specified name exists in the keystore, it returns false otherwise.
+func (cc *ArchwayProvider) KeyExists(name string) bool {
+	// 	k, err := cc.Keybase.Key(name)
+	// 	if err != nil {
+	// 		return false
+	// 	}
+
+	// 	return k.Name == name
+	return false
+}
+
+// // ExportPrivKeyArmor returns a private key in ASCII armored format.
+// // It returns an error if the key does not exist or a wrong encryption passphrase is supplied.
+func (cc *ArchwayProvider) ExportPrivKeyArmor(keyName string) (armor string, err error) {
+	// return cc.Keybase.ExportPrivKeyArmor(keyName, ckeys.DefaultKeyPass)
+	return "", nil
+}
+
+// // GetKeyAddress returns the account address representation for the currently configured key.
+// func (cc *ArchwayProvider) GetKeyAddress() (sdk.AccAddress, error) {
+// 	info, err := cc.Keybase.Key(cc.PCfg.Key)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	return info.GetAddress()
+// }
+
+// // CreateMnemonic generates a new mnemonic.
+// func CreateMnemonic() (string, error) {
+// 	entropySeed, err := bip39.NewEntropy(256)
+// 	if err != nil {
+// 		return "", err
+// 	}
+// 	mnemonic, err := bip39.NewMnemonic(entropySeed)
+// 	if err != nil {
+// 		return "", err
+// 	}
+// 	return mnemonic, nil
+// }
+
+// EncodeBech32AccAddr returns the string bech32 representation for the specified account address.
+// It returns an empty sting if the byte slice is 0-length.
+// It returns an error if the bech32 conversion fails or the prefix is empty.
+func (cc *ArchwayProvider) EncodeBech32AccAddr(addr sdk.AccAddress) (string, error) {
+	return sdk.Bech32ifyAddressBytes(cc.PCfg.AccountPrefix, addr)
+}

relayer/chains/archway/message_handler.go

@@ -0,0 +1 @@
+package archway