service/state: Provide simple scaffold for StateService and implement CoreAccess

cmd/celestia/light.go

@@ -17,12 +17,18 @@ func init() {
 			cmdnode.P2PFlags(),
 			cmdnode.HeadersFlags(),
 			cmdnode.MiscFlags(),
+			// NOTE: for now, state-related queries can only be accessed
+			// over an RPC connection with a celestia-core node.
+			cmdnode.CoreFlags(),
 		),
 		cmdnode.Start(
 			cmdnode.NodeFlags(node.Light),
 			cmdnode.P2PFlags(),
 			cmdnode.HeadersFlags(),
 			cmdnode.MiscFlags(),
+			// NOTE: for now, state-related queries can only be accessed
+			// over an RPC connection with a celestia-core node.
+			cmdnode.CoreFlags(),
 		),
 	)
 }
@@ -58,6 +64,11 @@ var lightCmd = &cobra.Command{
 			return err
 		}
 
+		err = cmdnode.ParseCoreFlags(cmd, env)
+		if err != nil {
+			return err
+		}
+
 		return nil
 	},
 }

core/testing.go

@@ -53,20 +53,21 @@ func MockEmbeddedClient() Client {
 // mock Core Client.
 func StartRemoteClient() (*node.Node, Client, error) {
 	remote := StartMockNode(CreateKvStore(defaultRetainBlocks))
-	protocol, ip := getRemoteEndpoint(remote)
+	protocol, ip := GetRemoteEndpoint(remote)
 	client, err := NewRemote(protocol, ip)
 	return remote, client, err
 }
 
-// StartRemoteCore starts a remote core and returns it's protocol and address
+// StartRemoteCore starts a remote core and returns its protocol and address
 func StartRemoteCore() (*node.Node, string, string) {
-	remote := StartMockNode(CreateKvStore(defaultRetainBlocks))
-	protocol, ip := getRemoteEndpoint(remote)
+	app := CreateKvStore(defaultRetainBlocks)
+	remote := StartMockNode(app)
+	protocol, ip := GetRemoteEndpoint(remote)
 	return remote, protocol, ip
 }
 
-// getRemoteEndpoint returns the protocol and ip of the remote node.
-func getRemoteEndpoint(remote *node.Node) (string, string) {
+// GetRemoteEndpoint returns the protocol and ip of the remote node.
+func GetRemoteEndpoint(remote *node.Node) (string, string) {
 	endpoint := remote.Config().RPC.ListenAddress
 	// protocol = "tcp"
 	protocol, ip := endpoint[:3], endpoint[6:]

docs/adr/adr-004-state-interaction.md

@@ -9,6 +9,7 @@
 ## Changelog
 
 * 2022-01-14: initial draft
+* 2022-02-11: update to interface and `CoreAccess` implementation details
 
 <hr style="border:2px solid gray"> </hr>
 
@@ -19,95 +20,112 @@ and public state of others.
 
 ## Decision
 
-Both celestia **light** and **full** nodes will run `StateService`. 
+Both celestia **light** and **full** nodes will run `StateService`.
 `StateService` will be responsible for managing the RPC endpoints provided by `StateAccessor`.
 
 `StateAccessor` will be an interface for interacting with celestia-core in order to retrieve account-related information
 as well as submit transactions.
 
 ### `StateService`
 
-`StateService` will expose several higher-level RPC endpoints for users to access the methods provided by the 
+`StateService` will expose several higher-level RPC endpoints for users to access the methods provided by the
 `StateAccessor`.
 
 ```go
 type StateService struct {
-    accessor StateAccessor
+accessor StateAccessor
 }
 ``` 
 
 ### `StateAccessor`
 
-`StateAccessor` is defined by the two methods listed below and may be expanded in the future to include more methods 
+`StateAccessor` is defined by the two methods listed below and may be expanded in the future to include more methods
 related to accounts and transactions in later iterations.
 
 ```go
 type StateAccessor interface {
-    // AccountBalance returns the Celestia Balance for the given Account
-    func AccountBalance(context.Context, Account) (Balance, error)
-	// SubmitTx submits the given Tx, where Tx implements sdk.Msg
-    func SubmitTx(context.Context, Tx) error
+   // Balance retrieves the Celestia coin balance
+   // for the node's account/signer.
+   Balance(ctx context.Context) (*Balance, error)
+   // BalanceForAddress retrieves the Celestia coin balance
+   // for the given address (given as `types.AccAddress` from cosmos-SDK).
+   BalanceForAddress(ctx context.Context, addr types.AccAddress) (*Balance, error)
+   // SubmitTx submits the given transaction/message to the
+   // Celestia network and blocks until the tx is included in
+   // a block.
+   SubmitTx(ctx context.Context, tx Tx) (*TxResponse, error)
 }
 ```
 
-`StateAccessor` will have 3 separate implementations under the hood, the first of which will be outlined in this ADR: 
+`StateAccessor` will have 3 separate implementations under the hood, the first of which will be outlined in this ADR:
+
 1. **CORE**: RPC connection with a celestia-core endpoint handed to the node upon initialisation
-(*required for this iteration*) 
-2. **P2P**: discovery of a **bridge** node or other node that is able to provide state (*nice-to-have for this iteration*)
-3. **LOCAL**: eventually, **full** nodes will be able to provide state to the network, and can therefore execute and 
-respond to the queries without relaying queries to celestia-core (*to be scoped out and implemented in later iterations*)
+   (*required for this iteration*)
+2. **P2P**: discovery of a **bridge** node or other node that is able to provide state (*nice-to-have for this
+   iteration*)
+3. **LOCAL**: eventually, **full** nodes will be able to provide state to the network, and can therefore execute and
+   respond to the queries without relaying queries to celestia-core (*to be scoped out and implemented in later
+   iterations*)
 
 ### 1. Core Implementation of `StateAccessor`: `CoreAccess`
 
-`CoreAccess` will be the direct RPC connection implementation of `StateAccessor`. It will use the [lens implementation of ChainClient](https://github.com/strangelove-ventures/lens/blob/main/client/chain_client.go#L23)
-under the hood. `lens.ChainClient` provides a nice wrapper around the Cosmos-SDK APIs. 
+`CoreAccess` will be the direct RPC connection implementation of `StateAccessor`. It will maintain a gRPC connection
+with a celestia-core node under the hood.
 
-Upon node initialisation, the node will receive the endpoint of a trusted celestia-core node. The constructor for 
-`CoreAccess` will construct a new instance of `CoreAccess` with the `lens.ChainClient` pointing at the given 
-celestia-core endpoint.
+Upon node initialisation, the node will receive the endpoint of a trusted celestia-core node. The constructor for
+`CoreAccess` will create a new instance of `CoreAccess`, and the given celestia-core endpoint will only be dialed upon
+start.
 
 ```go
 type CoreAccess struct {
-    cc *lens.ChainClient
+    signer *apptypes.KeyringSigner
+    encCfg cosmoscmd.EncodingConfig
+
+    coreEndpoint string
+    coreConn     *grpc.ClientConn
 }
 
-func NewCoreAccess(cc *lens.ChainClient) (*CoreAccess, error) {
-	return &CoreAccess{
-        cc: cc,		
-    }, nil   
+func (ca *CoreAccessor) BalanceForAddress(ctx context.Context, addr string) (*Balance, error) {
+    queryCli := banktypes.NewQueryClient(ca.coreConn)
+
+    balReq := &banktypes.QueryBalanceRequest{
+        Address: addr,
+        Denom:   app.DisplayDenom,
+    }
+
+    balResp, err := queryCli.Balance(ctx, balReq)
+    if err != nil {
+        return nil, err
+    }
+
+    return balResp.Balance, nil
 }
 
-// where Account wraps account information and Balance 
-func (ca *CoreAccess) AccountBalance(ctx context.Context, acct Account) (Balance, error) {
-	coins, err := da.cc.QueryBalanceWithAddress(acct.Address)
-	if err != nil {
-		return err
-    }   
-    // returning first index as we only care for account's balance on celestia chain	
-	return coins[0], nil 
+func (ca *CoreAccessor) SubmitTx(ctx context.Context, tx Tx) (*TxResponse, error) {
+    txResp, err := apptypes.BroadcastTx(ctx, ca.coreConn, sdk_tx.BroadcastMode_BROADCAST_MODE_SYNC, tx)
+    if err != nil {
+        return nil, err
+    }
+    return txResp.TxResponse, nil
 }
 
-// where Tx implements sdk.Msg
-func (ca *CoreAccess) SubmitTx(ctx context.Context, tx Tx) (TxResponse, error) {
-	return da.cc.SendMsg(ctx, tx)
-}
 ```
 
 ### 2. P2P Implementation of `StateAccessor`: `P2PAccess`
 
-While it is not necessary to detail how `P2PAccess` will be implemented in this ADR, it will still conform to the 
-`StateAccessor` interface, but instead of being provided a core endpoint to connect to via RPC and using `lens.ChainClient`
-for state-related queries, `P2PAccess` will perform service discovery of state-providing nodes in the network and perform
-the state queries via libp2p streams. More details of the p2p implementation will be described in a separate dedicated ADR.
+While it is not necessary to detail how `P2PAccess` will be implemented in this ADR, it will still conform to the
+`StateAccessor` interface, but instead of being provided a core endpoint to connect to via RPC, `P2PAccess` will perform
+service discovery of state-providing nodes in the network and perform the state queries via libp2p streams. More details 
+of the p2p implementation will be described in a separate dedicated ADR.
 
 ```go
 type P2PAccess struct {
-    // for discovery and communication
-    // with state-providing nodes
-    host host.Host
-    // for managing keys
-    keybase        keyring.Keyring
-    keyringOptions []keyring.Option
+   // for discovery and communication
+   // with state-providing nodes
+   host host.Host
+   // for managing keys
+   keybase        keyring.Keyring
+   keyringOptions []keyring.Option
 }
 ```
 
@@ -116,6 +134,5 @@ type P2PAccess struct {
 A **bridge** node will run a `StateProvider` (server-side of `P2PAccessor`). The `StateProvider` will be responsible for
 relaying the state-related queries through to its trusted celestia-core node.
 
-The `StateProvider` will be initialised with a `lens.ChainClient` that will be used under the hood for communication 
-with its already-configured celestia-core RPC connection. It will listen for inbound state-related queries from its 
-peers and relay the received payloads to celestia-core.
+The `StateProvider` will be initialised with a celestia-core RPC connection. It will listen for inbound state-related 
+queries from its peers and relay the received payloads to celestia-core.