v0.41.3 sr25519 algo

build.sh → .build.sh

@@ -11,7 +11,7 @@ set -ue
 # - DEBUG
 
 # Source builder's functions library
-. /usr/local/share/cosmos-sdk/buildlib.sh
+. /usr/local/share/tendermint/buildlib.sh
 
 # These variables are now available
 # - BASEDIR

.github/workflows/proto-docker.yml

@@ -0,0 +1,44 @@
+name: Build & Push SDK Proto Builder
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - "contrib/devtools/dockerfile"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - name: Prepare
+        id: prep
+        run: |
+          DOCKER_IMAGE=tendermintdev/sdk-proto-gen
+          VERSION=noop
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          elif [[ $GITHUB_REF == refs/heads/* ]]; then
+            VERSION=$(echo ${GITHUB_REF#refs/heads/} | sed -r 's#/+#-#g')
+            if [ "${{ github.event.repository.default_branch }}" = "$VERSION" ]; then
+              VERSION=latest
+            fi
+          fi
+          TAGS="${DOCKER_IMAGE}:${VERSION}"
+          echo ::set-output name=tags::${TAGS}
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUBTM_USERNAME }}
+          password: ${{ secrets.DOCKERHUBTM_TOKEN }}
+
+      - name: Publish to Docker Hub
+        uses: docker/build-push-action@v2
+        with:
+          context: ./docker-build-sdk-proto
+          file: ./docker-build-sdk-proto/Dockerfile
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.prep.outputs.tags }}

.github/workflows/test.yml

@@ -31,6 +31,26 @@ jobs:
           path: ~/go/bin
           key: ${{ runner.os }}-go-tparse-binary
 
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-arch: ["amd64", "arm", "arm64"]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2.1.3
+        with:
+          go-version: 1.15
+      - uses: technote-space/get-diff-action@v4
+        id: git_diff
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - name: Build
+        run: GOARCH=${{ matrix.go-arch }} LEDGER_ENABLED=false make build
+
   test-cosmovisor:
     runs-on: ubuntu-latest
     steps:

RELEASE_NOTES.md

@@ -0,0 +1,5 @@
+# Cosmos SDK v0.41.3 "Stargate" Release Notes
+
+This release fixes a build failure caused by a small API breakage introduced in Tendermint v0.34.7. It is **highly recommended** that all applications using v0.41.2 upgrade to v0.41.3 as soon as possible.
+
+See the [Cosmos SDK v0.41.3 milestone](https://github.com/cosmos/cosmos-sdk/milestone/39?closed=1) on our issue tracker for details.

baseapp/grpcrouter.go

@@ -2,6 +2,7 @@ package baseapp
 
 import (
 	"fmt"
+	"reflect"
 
 	gogogrpc "github.com/gogo/protobuf/grpc"
 	abci "github.com/tendermint/tendermint/abci/types"
@@ -12,13 +13,19 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/grpc/reflection"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 var protoCodec = encoding.GetCodec(proto.Name)
 
 // GRPCQueryRouter routes ABCI Query requests to GRPC handlers
 type GRPCQueryRouter struct {
-	routes            map[string]GRPCQueryHandler
+	routes map[string]GRPCQueryHandler
+	// returnTypes is a map of FQ method name => its return type. It is used
+	// for cache purposes: the first time a method handler is run, we save its
+	// return type in this map. Then, on subsequent method handler calls, we
+	// decode the ABCI response bytes using the cached return type.
+	returnTypes       map[string]reflect.Type
 	interfaceRegistry codectypes.InterfaceRegistry
 	serviceData       []serviceData
 }
@@ -34,7 +41,8 @@ var _ gogogrpc.Server = &GRPCQueryRouter{}
 // NewGRPCQueryRouter creates a new GRPCQueryRouter
 func NewGRPCQueryRouter() *GRPCQueryRouter {
 	return &GRPCQueryRouter{
-		routes: map[string]GRPCQueryHandler{},
+		returnTypes: map[string]reflect.Type{},
+		routes:      map[string]GRPCQueryHandler{},
 	}
 }
 
@@ -89,8 +97,17 @@ func (qrt *GRPCQueryRouter) RegisterService(sd *grpc.ServiceDesc, handler interf
 				if qrt.interfaceRegistry != nil {
 					return codectypes.UnpackInterfaces(i, qrt.interfaceRegistry)
 				}
+
 				return nil
 			}, nil)
+
+			// If it's the first time we call this handler, then we save
+			// the return type of the handler in the `returnTypes` map.
+			// The return type will be used for decoding subsequent requests.
+			if _, found := qrt.returnTypes[fqName]; !found {
+				qrt.returnTypes[fqName] = reflect.TypeOf(res)
+			}
+
 			if err != nil {
 				return abci.ResponseQuery{}, err
 			}
@@ -127,3 +144,16 @@ func (qrt *GRPCQueryRouter) SetInterfaceRegistry(interfaceRegistry codectypes.In
 		reflection.NewReflectionServiceServer(interfaceRegistry),
 	)
 }
+
+// returnTypeOf returns the return type of a gRPC method handler. With the way the
+// `returnTypes` cache map is set up, the return type of a method handler is
+// guaranteed to be found if it's retrieved **after** the method handler ran at
+// least once. If not, then a logic error is return.
+func (qrt *GRPCQueryRouter) returnTypeOf(method string) (reflect.Type, error) {
+	returnType, found := qrt.returnTypes[method]
+	if !found {
+		return nil, sdkerrors.Wrapf(sdkerrors.ErrLogic, "cannot find %s return type", method)
+	}
+
+	return returnType, nil
+}

baseapp/grpcserver.go

@@ -2,67 +2,78 @@ package baseapp
 
 import (
 	"context"
-	"strconv"
+	"reflect"
 
 	gogogrpc "github.com/gogo/protobuf/grpc"
 	grpcmiddleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	grpcrecovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
 
-	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/client"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-	grpctypes "github.com/cosmos/cosmos-sdk/types/grpc"
+	"github.com/cosmos/cosmos-sdk/types/tx"
 )
 
 // GRPCQueryRouter returns the GRPCQueryRouter of a BaseApp.
 func (app *BaseApp) GRPCQueryRouter() *GRPCQueryRouter { return app.grpcQueryRouter }
 
 // RegisterGRPCServer registers gRPC services directly with the gRPC server.
-func (app *BaseApp) RegisterGRPCServer(server gogogrpc.Server) {
-	// Define an interceptor for all gRPC queries: this interceptor will create
-	// a new sdk.Context, and pass it into the query handler.
-	interceptor := func(grpcCtx context.Context, req interface{}, _ *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
-		// If there's some metadata in the context, retrieve it.
-		md, ok := metadata.FromIncomingContext(grpcCtx)
-		if !ok {
-			return nil, status.Error(codes.Internal, "unable to retrieve metadata")
-		}
+func (app *BaseApp) RegisterGRPCServer(clientCtx client.Context, server gogogrpc.Server) {
+	// Define an interceptor for all gRPC queries: this interceptor will route
+	// the query through the `clientCtx`, which itself queries Tendermint.
+	interceptor := func(grpcCtx context.Context, req interface{}, info *grpc.UnaryServerInfo, _ grpc.UnaryHandler) (interface{}, error) {
+		// Two things can happen here:
+		// 1. either we're broadcasting a Tx, in which case we call Tendermint's broadcast endpoint directly,
+		// 2. or we are querying for state, in which case we call ABCI's Query.
 
-		// Get height header from the request context, if present.
-		var height int64
-		if heightHeaders := md.Get(grpctypes.GRPCBlockHeightHeader); len(heightHeaders) > 0 {
-			height, err = strconv.ParseInt(heightHeaders[0], 10, 64)
-			if err != nil {
-				return nil, sdkerrors.Wrapf(
-					sdkerrors.ErrInvalidRequest,
-					"Baseapp.RegisterGRPCServer: invalid height header %q: %v", grpctypes.GRPCBlockHeightHeader, err)
-			}
-			if err := checkNegativeHeight(height); err != nil {
-				return nil, err
+		// Case 1. Broadcasting a Tx.
+		if reqProto, ok := req.(*tx.BroadcastTxRequest); ok {
+			if !ok {
+				return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxRequest)(nil), req)
 			}
+
+			return client.TxServiceBroadcast(grpcCtx, clientCtx, reqProto)
+		}
+
+		// Case 2. Querying state.
+		inMd, _ := metadata.FromIncomingContext(grpcCtx)
+		abciRes, outMd, err := client.RunGRPCQuery(clientCtx, grpcCtx, info.FullMethod, req, inMd)
+		if err != nil {
+			return nil, err
 		}
 
-		// Create the sdk.Context. Passing false as 2nd arg, as we can't
-		// actually support proofs with gRPC right now.
-		sdkCtx, err := app.createQueryContext(height, false)
+		// We need to know the return type of the grpc method for
+		// unmarshalling abciRes.Value.
+		//
+		// When we call each method handler for the first time, we save its
+		// return type in the `returnTypes` map (see the method handler in
+		// `grpcrouter.go`). By this time, the method handler has already run
+		// at least once (in the RunGRPCQuery call), so we're sure the
+		// returnType maps is populated for this method. We're retrieving it
+		// for decoding.
+		returnType, err := app.GRPCQueryRouter().returnTypeOf(info.FullMethod)
 		if err != nil {
 			return nil, err
 		}
 
-		// Attach the sdk.Context into the gRPC's context.Context.
-		grpcCtx = context.WithValue(grpcCtx, sdk.SdkContextKey, sdkCtx)
+		// returnType is a pointer to a struct. Here, we're creating res which
+		// is a new pointer to the underlying struct.
+		res := reflect.New(returnType.Elem()).Interface()
 
-		// Add relevant gRPC headers
-		if height == 0 {
-			height = sdkCtx.BlockHeight() // If height was not set in the request, set it to the latest
+		err = protoCodec.Unmarshal(abciRes.Value, res)
+		if err != nil {
+			return nil, err
+		}
+
+		// Send the metadata header back. The metadata currently includes:
+		// - block height.
+		err = grpc.SendHeader(grpcCtx, outMd)
+		if err != nil {
+			return nil, err
 		}
-		md = metadata.Pairs(grpctypes.GRPCBlockHeightHeader, strconv.FormatInt(height, 10))
-		grpc.SetHeader(grpcCtx, md)
 
-		return handler(grpcCtx, req)
+		return res, nil
 	}
 
 	// Loop through all services and methods, add the interceptor, and register

buf.yaml

@@ -1,3 +1,5 @@
+version: v1beta1
+
 build:
   roots:
     - proto