diff --git a/Gopkg.lock b/Gopkg.lock
index ac4f2f285d14ed8b28b9331e02b41f7106c6ba3d..fb5c586a4249ae7666a6417bb8d71f131b348b1f 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -31,7 +31,7 @@
   name = "github.com/btcsuite/btcd"
   packages = ["btcec"]
   pruneopts = "NUT"
-  revision = "f673a4b563b57b9a95832545c878669a7fa801d9"
+  revision = "9a2f9524024889e129a5422aca2cff73cb3eabf6"
 
 [[projects]]
   branch = "master"
@@ -436,7 +436,7 @@
     "ssh/terminal",
   ]
   pruneopts = "NUT"
-  revision = "a2144134853fc9a27a7b1e3eb4f19f1a76df13c9"
+  revision = "c126467f60eb25f8f27e5a981f32a87e3965053f"
 
 [[projects]]
   digest = "1:15dbe437d38eb2103f6b55348758958a6f85a400ecc16fcb53b3f271d38cd8ea"
@@ -495,7 +495,7 @@
   name = "google.golang.org/genproto"
   packages = ["googleapis/rpc/status"]
   pruneopts = "NUT"
-  revision = "fedd2861243fd1a8152376292b921b394c7bef7e"
+  revision = "02b4e95473316948020af0b7a4f0f22c73929b0e"
 
 [[projects]]
   digest = "1:f778941d5c2e46da5e0f5d553d3e80bf70eb40d2e80bb4c649b625b9133f3d5f"
@@ -552,7 +552,9 @@
     "github.com/go-kit/kit/log/term",
     "github.com/gogo/protobuf/gogoproto",
     "github.com/gogo/protobuf/proto",
+    "github.com/gogo/protobuf/types",
     "github.com/golang/protobuf/proto",
+    "github.com/golang/protobuf/ptypes/timestamp",
     "github.com/gorilla/websocket",
     "github.com/howeyc/gopass",
     "github.com/imdario/mergo",
diff --git a/Makefile b/Makefile
index fcc9956dd5a37a02ae95ffb288d57712202355ef..3db456789da99d0d0a401b9074d08210c8db3833 100644
--- a/Makefile
+++ b/Makefile
@@ -78,7 +78,7 @@ protobuf_deps:
 # Implicit compile rule for GRPC/proto files (note since pb.go files no longer generated
 # in same directory as proto file this just regenerates everything
 %.pb.go: %.proto
-	protoc -I vendor -I protobuf $< --gogo_out=plugins=grpc:${GOPATH}/src
+	protoc -I protobuf -I vendor $< --gogo_out=plugins=grpc:${GOPATH}/src
 
 .PHONY: protobuf
 protobuf: $(PROTO_GO_FILES)
diff --git a/acm/validator/validator.pb.go b/acm/validator/validator.pb.go
index 93c8b77d7b476877c6709de87971b03a0694bc96..b15639c0ed8a7b9be73832fa24e37d9f7180b06a 100644
--- a/acm/validator/validator.pb.go
+++ b/acm/validator/validator.pb.go
@@ -17,7 +17,6 @@ import golang_proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
 import _ "github.com/gogo/protobuf/gogoproto"
-import _ "github.com/hyperledger/burrow/permission"
 import crypto "github.com/hyperledger/burrow/crypto"
 
 import github_com_hyperledger_burrow_crypto "github.com/hyperledger/burrow/crypto"
@@ -385,21 +384,21 @@ func init() { proto.RegisterFile("validator.proto", fileDescriptorValidator) }
 func init() { golang_proto.RegisterFile("validator.proto", fileDescriptorValidator) }
 
 var fileDescriptorValidator = []byte{
-	// 255 bytes of a gzipped FileDescriptorProto
+	// 242 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2f, 0x4b, 0xcc, 0xc9,
 	0x4c, 0x49, 0x2c, 0xc9, 0x2f, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x84, 0x0b, 0x48,
 	0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7,
-	0xeb, 0x83, 0x55, 0x24, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0x29, 0x25, 0x50,
-	0x90, 0x5a, 0x94, 0x9b, 0x59, 0x5c, 0x9c, 0x99, 0x9f, 0x07, 0x15, 0xe1, 0x49, 0x2e, 0xaa, 0x2c,
-	0x28, 0x81, 0xca, 0x2b, 0xad, 0x62, 0xe4, 0xe2, 0x0c, 0x83, 0x19, 0x2e, 0xe4, 0xc5, 0xc5, 0xee,
-	0x98, 0x92, 0x52, 0x94, 0x5a, 0x5c, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xe3, 0x64, 0x70, 0xeb,
-	0x9e, 0xbc, 0x0e, 0x92, 0x8d, 0x19, 0x95, 0x05, 0xa9, 0x45, 0x39, 0xa9, 0x29, 0xe9, 0xa9, 0x45,
-	0xfa, 0x49, 0xa5, 0x45, 0x45, 0xf9, 0xe5, 0xfa, 0x50, 0xe3, 0xa0, 0xfa, 0x82, 0x60, 0x06, 0x08,
-	0x99, 0x72, 0x71, 0x06, 0x94, 0x26, 0xe5, 0x64, 0x26, 0x7b, 0xa7, 0x56, 0x4a, 0x30, 0x29, 0x30,
-	0x6a, 0x70, 0x1b, 0x09, 0xea, 0x41, 0x15, 0xc3, 0x25, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08,
-	0x42, 0xa8, 0x14, 0x12, 0xe1, 0x62, 0x0d, 0xc8, 0x2f, 0x4f, 0x2d, 0x92, 0x60, 0x56, 0x60, 0xd4,
-	0x60, 0x09, 0x82, 0x70, 0xac, 0x58, 0x66, 0x2c, 0x90, 0x67, 0x70, 0x72, 0x3c, 0xf1, 0x48, 0x8e,
-	0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x0f, 0x3c, 0x96, 0x63, 0x3c, 0xf1, 0x58,
-	0x8e, 0x31, 0x4a, 0x1b, 0xbf, 0xfb, 0x12, 0x93, 0x73, 0xf5, 0xe1, 0xc1, 0x97, 0xc4, 0x06, 0xf6,
-	0xb6, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x1c, 0xca, 0xd9, 0x6f, 0x63, 0x01, 0x00, 0x00,
+	0xeb, 0x83, 0x55, 0x24, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0xd1, 0x29, 0xc5, 0x93,
+	0x5c, 0x54, 0x59, 0x50, 0x02, 0xe5, 0x29, 0xad, 0x62, 0xe4, 0xe2, 0x0c, 0x83, 0x19, 0x25, 0xe4,
+	0xc5, 0xc5, 0xee, 0x98, 0x92, 0x52, 0x94, 0x5a, 0x5c, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xe3,
+	0x64, 0x70, 0xeb, 0x9e, 0xbc, 0x0e, 0x92, 0xf9, 0x19, 0x95, 0x05, 0xa9, 0x45, 0x39, 0xa9, 0x29,
+	0xe9, 0xa9, 0x45, 0xfa, 0x49, 0xa5, 0x45, 0x45, 0xf9, 0xe5, 0xfa, 0x50, 0xe3, 0xa0, 0xfa, 0x82,
+	0x60, 0x06, 0x08, 0x99, 0x72, 0x71, 0x06, 0x94, 0x26, 0xe5, 0x64, 0x26, 0x7b, 0xa7, 0x56, 0x4a,
+	0x30, 0x29, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xea, 0x41, 0x15, 0xc3, 0x25, 0x9c, 0x58, 0x4e, 0xdc,
+	0x93, 0x67, 0x08, 0x42, 0xa8, 0x14, 0x12, 0xe1, 0x62, 0x0d, 0xc8, 0x2f, 0x4f, 0x2d, 0x92, 0x60,
+	0x56, 0x60, 0xd4, 0x60, 0x09, 0x82, 0x70, 0xac, 0x58, 0x66, 0x2c, 0x90, 0x67, 0x70, 0x72, 0x3c,
+	0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x0f, 0x3c, 0x96, 0x63,
+	0x3c, 0xf1, 0x58, 0x8e, 0x31, 0x4a, 0x1b, 0xbf, 0xfb, 0x12, 0x93, 0x73, 0xf5, 0xe1, 0x81, 0x95,
+	0xc4, 0x06, 0xf6, 0xb6, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x5d, 0xe5, 0x4a, 0x65, 0x51, 0x01,
+	0x00, 0x00,
 }
diff --git a/consensus/tendermint/node_view.go b/consensus/tendermint/node_view.go
index 62a50085d82dd9d3b80eed78c5c0f90cb1c845c4..023533e141121bc049872d6529f6d4e38f8a3a22 100644
--- a/consensus/tendermint/node_view.go
+++ b/consensus/tendermint/node_view.go
@@ -7,32 +7,35 @@ import (
 	"github.com/hyperledger/burrow/txs"
 	"github.com/tendermint/tendermint/consensus"
 	ctypes "github.com/tendermint/tendermint/consensus/types"
-	tmCrypto "github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 )
 
 type NodeView struct {
-	tmNode    *Node
-	txDecoder txs.Decoder
+	tmNode             *Node
+	validatorPublicKey crypto.PublicKey
+	txDecoder          txs.Decoder
 }
 
-func NewNodeView(tmNode *Node, txDecoder txs.Decoder) *NodeView {
-	return &NodeView{
-		tmNode:    tmNode,
-		txDecoder: txDecoder,
+func NewNodeView(tmNode *Node, txDecoder txs.Decoder) (*NodeView, error) {
+	publicKey, err := crypto.PublicKeyFromTendermintPubKey(tmNode.PrivValidator().GetPubKey())
+	if err != nil {
+		return nil, err
 	}
+	return &NodeView{
+		validatorPublicKey: publicKey,
+		tmNode:             tmNode,
+		txDecoder:          txDecoder,
+	}, nil
 }
 
-func (nv *NodeView) PrivValidatorPublicKey() (crypto.PublicKey, error) {
-	pub := nv.tmNode.PrivValidator().GetPubKey().(tmCrypto.PubKeyEd25519)
-
-	return crypto.PublicKeyFromBytes(pub[:], crypto.CurveTypeEd25519)
+func (nv *NodeView) ValidatorPublicKey() crypto.PublicKey {
+	return nv.validatorPublicKey
 }
 
-func (nv *NodeView) NodeInfo() p2p.NodeInfo {
-	return nv.tmNode.NodeInfo()
+func (nv *NodeView) NodeInfo() *NodeInfo {
+	return NewNodeInfo(nv.tmNode.NodeInfo())
 }
 
 func (nv *NodeView) IsListening() bool {
diff --git a/consensus/tendermint/tendermint.go b/consensus/tendermint/tendermint.go
index 0122f580eea7f9b3d70ab7c5f0cb355abcdcca08..573265ee6e48c2329f3f2ab516a9f6e051c52f76 100644
--- a/consensus/tendermint/tendermint.go
+++ b/consensus/tendermint/tendermint.go
@@ -4,7 +4,9 @@ import (
 	"os"
 	"path"
 
+	"github.com/hyperledger/burrow/binary"
 	"github.com/hyperledger/burrow/consensus/tendermint/abci"
+	"github.com/hyperledger/burrow/crypto"
 	"github.com/hyperledger/burrow/genesis"
 	"github.com/hyperledger/burrow/logging"
 	"github.com/hyperledger/burrow/logging/structure"
@@ -12,6 +14,7 @@ import (
 	tmCrypto "github.com/tendermint/tendermint/crypto"
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/node"
+	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/proxy"
 	tmTypes "github.com/tendermint/tendermint/types"
 )
@@ -90,13 +93,15 @@ func DeriveGenesisDoc(burrowGenesisDoc *genesis.GenesisDoc) *tmTypes.GenesisDoc
 	}
 }
 
-func NewBlockEvent(message interface{}) *tmTypes.EventDataNewBlock {
-	tmEventData, ok := message.(tmTypes.TMEventData)
-	if ok {
-		eventDataNewBlock, ok := tmEventData.(tmTypes.EventDataNewBlock)
-		if ok {
-			return &eventDataNewBlock
-		}
+func NewNodeInfo(ni p2p.NodeInfo) *NodeInfo {
+	address, _ := crypto.AddressFromHexString(string(ni.ID))
+	return &NodeInfo{
+		ID:            address,
+		Moniker:       ni.Moniker,
+		ListenAddress: ni.ListenAddr,
+		Version:       ni.Version,
+		Channels:      binary.HexBytes(ni.Channels),
+		Network:       ni.Network,
+		Other:         ni.Other,
 	}
-	return nil
 }
diff --git a/consensus/tendermint/tendermint.pb.go b/consensus/tendermint/tendermint.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..47f2bd55b011d81e52774504cadb521c3817ca2b
--- /dev/null
+++ b/consensus/tendermint/tendermint.pb.go
@@ -0,0 +1,607 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: tendermint.proto
+
+/*
+	Package tendermint is a generated protocol buffer package.
+
+	It is generated from these files:
+		tendermint.proto
+
+	It has these top-level messages:
+		NodeInfo
+*/
+package tendermint
+
+import proto "github.com/gogo/protobuf/proto"
+import golang_proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "github.com/gogo/protobuf/gogoproto"
+
+import github_com_hyperledger_burrow_crypto "github.com/hyperledger/burrow/crypto"
+import github_com_hyperledger_burrow_binary "github.com/hyperledger/burrow/binary"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = golang_proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+type NodeInfo struct {
+	ID            github_com_hyperledger_burrow_crypto.Address  `protobuf:"bytes,1,opt,name=ID,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"ID"`
+	ListenAddress string                                        `protobuf:"bytes,2,opt,name=ListenAddress,proto3" json:"ListenAddress,omitempty"`
+	Network       string                                        `protobuf:"bytes,3,opt,name=Network,proto3" json:"Network,omitempty"`
+	Version       string                                        `protobuf:"bytes,4,opt,name=Version,proto3" json:"Version,omitempty"`
+	Channels      github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,5,opt,name=Channels,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"Channels"`
+	Moniker       string                                        `protobuf:"bytes,6,opt,name=Moniker,proto3" json:"Moniker,omitempty"`
+	Other         []string                                      `protobuf:"bytes,7,rep,name=Other" json:"Other,omitempty"`
+}
+
+func (m *NodeInfo) Reset()                    { *m = NodeInfo{} }
+func (m *NodeInfo) String() string            { return proto.CompactTextString(m) }
+func (*NodeInfo) ProtoMessage()               {}
+func (*NodeInfo) Descriptor() ([]byte, []int) { return fileDescriptorTendermint, []int{0} }
+
+func (m *NodeInfo) GetListenAddress() string {
+	if m != nil {
+		return m.ListenAddress
+	}
+	return ""
+}
+
+func (m *NodeInfo) GetNetwork() string {
+	if m != nil {
+		return m.Network
+	}
+	return ""
+}
+
+func (m *NodeInfo) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
+func (m *NodeInfo) GetMoniker() string {
+	if m != nil {
+		return m.Moniker
+	}
+	return ""
+}
+
+func (m *NodeInfo) GetOther() []string {
+	if m != nil {
+		return m.Other
+	}
+	return nil
+}
+
+func (*NodeInfo) XXX_MessageName() string {
+	return "tendermint.NodeInfo"
+}
+func init() {
+	proto.RegisterType((*NodeInfo)(nil), "tendermint.NodeInfo")
+	golang_proto.RegisterType((*NodeInfo)(nil), "tendermint.NodeInfo")
+}
+func (m *NodeInfo) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *NodeInfo) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	dAtA[i] = 0xa
+	i++
+	i = encodeVarintTendermint(dAtA, i, uint64(m.ID.Size()))
+	n1, err := m.ID.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n1
+	if len(m.ListenAddress) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintTendermint(dAtA, i, uint64(len(m.ListenAddress)))
+		i += copy(dAtA[i:], m.ListenAddress)
+	}
+	if len(m.Network) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintTendermint(dAtA, i, uint64(len(m.Network)))
+		i += copy(dAtA[i:], m.Network)
+	}
+	if len(m.Version) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintTendermint(dAtA, i, uint64(len(m.Version)))
+		i += copy(dAtA[i:], m.Version)
+	}
+	dAtA[i] = 0x2a
+	i++
+	i = encodeVarintTendermint(dAtA, i, uint64(m.Channels.Size()))
+	n2, err := m.Channels.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n2
+	if len(m.Moniker) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintTendermint(dAtA, i, uint64(len(m.Moniker)))
+		i += copy(dAtA[i:], m.Moniker)
+	}
+	if len(m.Other) > 0 {
+		for _, s := range m.Other {
+			dAtA[i] = 0x3a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func encodeVarintTendermint(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *NodeInfo) Size() (n int) {
+	var l int
+	_ = l
+	l = m.ID.Size()
+	n += 1 + l + sovTendermint(uint64(l))
+	l = len(m.ListenAddress)
+	if l > 0 {
+		n += 1 + l + sovTendermint(uint64(l))
+	}
+	l = len(m.Network)
+	if l > 0 {
+		n += 1 + l + sovTendermint(uint64(l))
+	}
+	l = len(m.Version)
+	if l > 0 {
+		n += 1 + l + sovTendermint(uint64(l))
+	}
+	l = m.Channels.Size()
+	n += 1 + l + sovTendermint(uint64(l))
+	l = len(m.Moniker)
+	if l > 0 {
+		n += 1 + l + sovTendermint(uint64(l))
+	}
+	if len(m.Other) > 0 {
+		for _, s := range m.Other {
+			l = len(s)
+			n += 1 + l + sovTendermint(uint64(l))
+		}
+	}
+	return n
+}
+
+func sovTendermint(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozTendermint(x uint64) (n int) {
+	return sovTendermint(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *NodeInfo) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTendermint
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: NodeInfo: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: NodeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ListenAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ListenAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Network = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Version = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Channels", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Channels.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Moniker", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Moniker = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Other", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Other = append(m.Other, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTendermint(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTendermint
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipTendermint(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTendermint
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTendermint
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthTendermint
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowTendermint
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipTendermint(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthTendermint = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTendermint   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("tendermint.proto", fileDescriptorTendermint) }
+func init() { golang_proto.RegisterFile("tendermint.proto", fileDescriptorTendermint) }
+
+var fileDescriptorTendermint = []byte{
+	// 318 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xcd, 0x4e, 0xfa, 0x40,
+	0x14, 0xc5, 0xff, 0x53, 0xfe, 0x7c, 0x4d, 0x34, 0x31, 0x8d, 0x8b, 0x89, 0x8b, 0x42, 0x8c, 0x0b,
+	0x16, 0xd2, 0x26, 0x7e, 0x3c, 0x80, 0xc8, 0x02, 0x12, 0xc5, 0xd8, 0x85, 0x0b, 0x77, 0x94, 0x5e,
+	0xda, 0x06, 0x98, 0x4b, 0xee, 0x4c, 0x83, 0x7d, 0x28, 0xdf, 0xc1, 0x25, 0x4b, 0xd7, 0x2e, 0x88,
+	0x81, 0x17, 0x31, 0x4c, 0xab, 0xe8, 0x46, 0x77, 0xf3, 0x3b, 0x67, 0xe6, 0xde, 0x93, 0x39, 0xfc,
+	0x40, 0x83, 0x0c, 0x81, 0x66, 0x89, 0xd4, 0xee, 0x9c, 0x50, 0xa3, 0xcd, 0x77, 0xca, 0x51, 0x3b,
+	0x4a, 0x74, 0x9c, 0x06, 0xee, 0x08, 0x67, 0x5e, 0x84, 0x11, 0x7a, 0xe6, 0x4a, 0x90, 0x8e, 0x0d,
+	0x19, 0x30, 0xa7, 0xfc, 0xe9, 0xf1, 0xb3, 0xc5, 0x6b, 0x03, 0x0c, 0xa1, 0x2f, 0xc7, 0x68, 0x77,
+	0xb9, 0xd5, 0xef, 0x0a, 0xd6, 0x64, 0xad, 0xbd, 0xce, 0xc5, 0x72, 0xd5, 0xf8, 0xf7, 0xb6, 0x6a,
+	0x9c, 0x7e, 0x9b, 0x17, 0x67, 0x73, 0xa0, 0x29, 0x84, 0x11, 0x90, 0x17, 0xa4, 0x44, 0xb8, 0xf0,
+	0x46, 0x94, 0xcd, 0x35, 0xba, 0x57, 0x61, 0x48, 0xa0, 0x94, 0x6f, 0xf5, 0xbb, 0xf6, 0x09, 0xdf,
+	0xbf, 0x49, 0x94, 0x06, 0x59, 0x88, 0xc2, 0x6a, 0xb2, 0x56, 0xdd, 0xff, 0x29, 0xda, 0x82, 0x57,
+	0x07, 0xa0, 0x17, 0x48, 0x13, 0x51, 0x32, 0xfe, 0x27, 0x6e, 0x9d, 0x07, 0x20, 0x95, 0xa0, 0x14,
+	0xff, 0x73, 0xa7, 0x40, 0xfb, 0x9e, 0xd7, 0xae, 0xe3, 0xa1, 0x94, 0x30, 0x55, 0xa2, 0x6c, 0x52,
+	0x5e, 0x16, 0x29, 0xdb, 0xbf, 0xa7, 0x0c, 0x12, 0x39, 0xa4, 0xcc, 0xed, 0xc1, 0x53, 0x27, 0xd3,
+	0xa0, 0xfc, 0xaf, 0x31, 0xdb, 0x65, 0xb7, 0x28, 0x93, 0x09, 0x90, 0xa8, 0xe4, 0xcb, 0x0a, 0xb4,
+	0x0f, 0x79, 0xf9, 0x4e, 0xc7, 0x40, 0xa2, 0xda, 0x2c, 0xb5, 0xea, 0x7e, 0x0e, 0x9d, 0xde, 0x72,
+	0xed, 0xb0, 0xd7, 0xb5, 0xc3, 0xde, 0xd7, 0x0e, 0x7b, 0xd9, 0x38, 0x6c, 0xb9, 0x71, 0xd8, 0xe3,
+	0xd9, 0x1f, 0x9f, 0x84, 0x52, 0x81, 0x54, 0xa9, 0xf2, 0x76, 0x45, 0x05, 0x15, 0x53, 0xc0, 0xf9,
+	0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd1, 0x1c, 0x4c, 0x76, 0xcf, 0x01, 0x00, 0x00,
+}
diff --git a/core/kernel.go b/core/kernel.go
index 46854844acfc90d1d9214deccb44c5cc8444abcb..28ff55a7271f663b3a6f4c5e145f8fb5ae41251f 100644
--- a/core/kernel.go
+++ b/core/kernel.go
@@ -126,7 +126,10 @@ func NewKernel(ctx context.Context, keyClient keys.KeyClient, privValidator tmTy
 
 	nameRegState := kern.State
 	accountState := kern.State
-	nodeView := tendermint.NewNodeView(kern.Node, txCodec)
+	nodeView, err := tendermint.NewNodeView(kern.Node, txCodec)
+	if err != nil {
+		return nil, err
+	}
 	kern.Service = rpc.NewService(accountState, nameRegState, kern.Blockchain, nodeView, kern.Logger)
 
 	kern.Launchers = []process.Launcher{
diff --git a/execution/contexts/call_context.go b/execution/contexts/call_context.go
index fcf7e146c0dd5269311ef64497d3b9c4b038633f..385d05e1882961a310fe3d7e255578deee68dc80 100644
--- a/execution/contexts/call_context.go
+++ b/execution/contexts/call_context.go
@@ -213,6 +213,7 @@ func (ctx *CallContext) Deliver(inAcc, outAcc acm.Account, value uint64) error {
 		// Failure. Charge the gas fee. The 'value' was otherwise not transferred.
 		ctx.Logger.InfoMsg("Error on execution",
 			structure.ErrorKey, exception)
+		ctx.txe.SetException(exception)
 	} else {
 		ctx.Logger.TraceMsg("Successful execution")
 		if createContract {
diff --git a/execution/contexts/permissions_context.go b/execution/contexts/permissions_context.go
index 00cbd1a5589823ba72a7d59f55e361a59238c197..ac4c450b3adf904ba0d85f776aac597e62804a2e 100644
--- a/execution/contexts/permissions_context.go
+++ b/execution/contexts/permissions_context.go
@@ -44,7 +44,7 @@ func (ctx *PermissionsContext) Execute(txe *exec.TxExecution) error {
 		return fmt.Errorf("PermsTx received containing invalid PermArgs: %v", err)
 	}
 
-	permFlag := ctx.tx.PermArgs.PermFlag
+	permFlag := ctx.tx.PermArgs.Action
 	// check permission
 	if !HasPermission(ctx.StateWriter, inAcc, permFlag, ctx.Logger) {
 		return fmt.Errorf("account %s does not have moderator permission %s (%b)", ctx.tx.Input.Address,
@@ -65,17 +65,17 @@ func (ctx *PermissionsContext) Execute(txe *exec.TxExecution) error {
 		"perm_args", ctx.tx.PermArgs.String())
 
 	var permAcc acm.Account
-	switch ctx.tx.PermArgs.PermFlag {
+	switch ctx.tx.PermArgs.Action {
 	case permission.HasBase:
 		// this one doesn't make sense from txs
 		return fmt.Errorf("HasBase is for contracts, not humans. Just look at the blockchain")
 	case permission.SetBase:
-		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Address,
+		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Target,
 			func(perms *permission.AccountPermissions) error {
 				return perms.Base.Set(*ctx.tx.PermArgs.Permission, *ctx.tx.PermArgs.Value)
 			})
 	case permission.UnsetBase:
-		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Address,
+		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Target,
 			func(perms *permission.AccountPermissions) error {
 				return perms.Base.Unset(*ctx.tx.PermArgs.Permission)
 			})
@@ -87,20 +87,20 @@ func (ctx *PermissionsContext) Execute(txe *exec.TxExecution) error {
 	case permission.HasRole:
 		return fmt.Errorf("HasRole is for contracts, not humans. Just look at the blockchain")
 	case permission.AddRole:
-		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Address,
+		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Target,
 			func(perms *permission.AccountPermissions) error {
 				if !perms.AddRole(*ctx.tx.PermArgs.Role) {
 					return fmt.Errorf("role (%s) already exists for account %s",
-						*ctx.tx.PermArgs.Role, *ctx.tx.PermArgs.Address)
+						*ctx.tx.PermArgs.Role, *ctx.tx.PermArgs.Target)
 				}
 				return nil
 			})
 	case permission.RemoveRole:
-		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Address,
+		permAcc, err = mutatePermissions(ctx.StateWriter, *ctx.tx.PermArgs.Target,
 			func(perms *permission.AccountPermissions) error {
 				if !perms.RmRole(*ctx.tx.PermArgs.Role) {
 					return fmt.Errorf("role (%s) does not exist for account %s",
-						*ctx.tx.PermArgs.Role, *ctx.tx.PermArgs.Address)
+						*ctx.tx.PermArgs.Role, *ctx.tx.PermArgs.Target)
 				}
 				return nil
 			})
diff --git a/execution/errors/errors.go b/execution/errors/errors.go
index 00e49c47bcb3074ce038ed7ae3dc85b1322679fe..69f9f89c1468672ce2473c54755830d1e03d0d1d 100644
--- a/execution/errors/errors.go
+++ b/execution/errors/errors.go
@@ -173,5 +173,5 @@ func (e *Exception) Error() string {
 	if e == nil {
 		return ""
 	}
-	return fmt.Sprintf("Error %v: %s", e.Code, e.Exception)
+	return fmt.Sprintf("Error %d: %s", e.Code, e.Exception)
 }
diff --git a/execution/exec/tx_execution.go b/execution/exec/tx_execution.go
index 9de377ffea91255ce67c5ecab96228ca8547b4c4..98886d049fc1208b20ccec94bd033cecc4556827 100644
--- a/execution/exec/tx_execution.go
+++ b/execution/exec/tx_execution.go
@@ -97,6 +97,10 @@ func (txe *TxExecution) GovernAccount(governAccount *GovernAccountEvent, excepti
 	})
 }
 
+func (txe *TxExecution) SetException(err error) {
+	txe.Exception = errors.AsException(err)
+}
+
 // Set result
 func (txe *TxExecution) Return(returnValue []byte, gasUsed uint64) {
 	if txe.Result == nil {
diff --git a/execution/execution.go b/execution/execution.go
index 63328d29163886dbb956159aa78c4b6af367a56c..d14b40a883934ca7e11a2679a6bee0d667eea3c3 100644
--- a/execution/execution.go
+++ b/execution/execution.go
@@ -197,7 +197,7 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (txe *exec.TxExecution, err er
 			return nil, err
 		}
 		// Return execution for this tx
-		return txe, err
+		return txe, nil
 	}
 	return nil, fmt.Errorf("unknown transaction type: %v", txEnv.Tx.Type())
 }
diff --git a/execution/simulated_call.go b/execution/simulated_call.go
index 0274a7393396017dc99c9d553dc9899acdb17ba1..813937d40dfdf6f0aa588f849d3210dfcdac0fc6 100644
--- a/execution/simulated_call.go
+++ b/execution/simulated_call.go
@@ -57,6 +57,7 @@ func CallCodeSim(reader state.Reader, tip bcm.BlockchainInfo, fromAddress, addre
 			err = fmt.Errorf("panic from VM in simulated call: %v\n%s", r, debug.Stack())
 		}
 	}()
+
 	ret, err := vmach.Call(txCache, caller, callee, code, data, 0, &gas)
 	if err != nil {
 		return nil, err
diff --git a/execution/transactor.go b/execution/transactor.go
index c1a12edc33179e7e73d7d3f1e69593e2d0e2f737..8cf042111b2cd3d5a2e4db1ca99f5afe40a71176 100644
--- a/execution/transactor.go
+++ b/execution/transactor.go
@@ -106,7 +106,11 @@ func (trans *Transactor) BroadcastTxSync(ctx context.Context, txEnv *txs.Envelop
 		return nil, fmt.Errorf("timed out waiting for transaction with hash %v timed out after %v",
 			checkTxReceipt.TxHash, BlockingTimeout)
 	case msg := <-out:
-		return msg.(*exec.TxExecution), nil
+		txe := msg.(*exec.TxExecution)
+		if txe.Exception != nil && txe.Exception.ErrorCode() != errors.ErrorCodeExecutionReverted {
+			return nil, errors.Wrap(txe.Exception, "exception during transaction execution")
+		}
+		return txe, nil
 	}
 }
 
diff --git a/integration/rpcquery/query_server_test.go b/integration/rpcquery/query_server_test.go
index 05bb7e858e712a2868d6da4f24a89a3b3e4a620c..adef77c72001e4c67308c40bd31ae1afc08fa3f0 100644
--- a/integration/rpcquery/query_server_test.go
+++ b/integration/rpcquery/query_server_test.go
@@ -18,6 +18,25 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestStatus(t *testing.T) {
+	cli := rpctest.NewQueryClient(t, testConfig.RPC.GRPC.ListenAddress)
+	stat, err := cli.Status(context.Background(), &rpcquery.StatusParam{})
+	require.NoError(t, err)
+	assert.Equal(t, rpctest.PrivateAccounts[0].PublicKey(), stat.PublicKey)
+	assert.Equal(t, rpctest.GenesisDoc.ChainID(), stat.ChainID)
+	for i := 0; i < 3; i++ {
+		// Unless we get lucky this is an error
+		_, err = cli.Status(context.Background(), &rpcquery.StatusParam{
+			BlockWithin: "1ns",
+		})
+		if err != nil {
+			break
+		}
+	}
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "no block committed within")
+}
+
 func TestGetAccount(t *testing.T) {
 	cli := rpctest.NewQueryClient(t, testConfig.RPC.GRPC.ListenAddress)
 	ca, err := cli.GetAccount(context.Background(), &rpcquery.GetAccountParam{
diff --git a/permission/permission.pb.go b/permission/permission.pb.go
index b72986011d0be70e3ed447ac9745961bd7388b3e..da42a596ccca8986f5ed7f27f39077291efab47e 100644
--- a/permission/permission.pb.go
+++ b/permission/permission.pb.go
@@ -94,20 +94,23 @@ func (*BasePermissions) XXX_MessageName() string {
 }
 
 type PermArgs struct {
-	PermFlag   PermFlag                                      `protobuf:"varint,1,opt,name=PermFlag,casttype=PermFlag" json:"PermFlag"`
-	Address    *github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,2,opt,name=Address,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address,omitempty"`
-	Permission *PermFlag                                     `protobuf:"varint,3,opt,name=Permission,casttype=PermFlag" json:"Permission,omitempty"`
-	Role       *string                                       `protobuf:"bytes,4,opt,name=Role" json:"Role,omitempty"`
-	Value      *bool                                         `protobuf:"varint,5,opt,name=Value" json:"Value,omitempty"`
+	// The permission function
+	Action PermFlag `protobuf:"varint,1,opt,name=Action,casttype=PermFlag" json:"Action"`
+	// The target of the action
+	Target *github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,2,opt,name=Target,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Target,omitempty"`
+	// Possible arguments
+	Permission *PermFlag `protobuf:"varint,3,opt,name=Permission,casttype=PermFlag" json:"Permission,omitempty"`
+	Role       *string   `protobuf:"bytes,4,opt,name=Role" json:"Role,omitempty"`
+	Value      *bool     `protobuf:"varint,5,opt,name=Value" json:"Value,omitempty"`
 }
 
 func (m *PermArgs) Reset()                    { *m = PermArgs{} }
 func (*PermArgs) ProtoMessage()               {}
 func (*PermArgs) Descriptor() ([]byte, []int) { return fileDescriptorPermission, []int{2} }
 
-func (m *PermArgs) GetPermFlag() PermFlag {
+func (m *PermArgs) GetAction() PermFlag {
 	if m != nil {
-		return m.PermFlag
+		return m.Action
 	}
 	return 0
 }
@@ -232,12 +235,12 @@ func (m *PermArgs) MarshalTo(dAtA []byte) (int, error) {
 	_ = l
 	dAtA[i] = 0x8
 	i++
-	i = encodeVarintPermission(dAtA, i, uint64(m.PermFlag))
-	if m.Address != nil {
+	i = encodeVarintPermission(dAtA, i, uint64(m.Action))
+	if m.Target != nil {
 		dAtA[i] = 0x12
 		i++
-		i = encodeVarintPermission(dAtA, i, uint64(m.Address.Size()))
-		n2, err := m.Address.MarshalTo(dAtA[i:])
+		i = encodeVarintPermission(dAtA, i, uint64(m.Target.Size()))
+		n2, err := m.Target.MarshalTo(dAtA[i:])
 		if err != nil {
 			return 0, err
 		}
@@ -307,9 +310,9 @@ func (m *BasePermissions) Size() (n int) {
 func (m *PermArgs) Size() (n int) {
 	var l int
 	_ = l
-	n += 1 + sovPermission(uint64(m.PermFlag))
-	if m.Address != nil {
-		l = m.Address.Size()
+	n += 1 + sovPermission(uint64(m.Action))
+	if m.Target != nil {
+		l = m.Target.Size()
 		n += 1 + l + sovPermission(uint64(l))
 	}
 	if m.Permission != nil {
@@ -568,9 +571,9 @@ func (m *PermArgs) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field PermFlag", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
 			}
-			m.PermFlag = 0
+			m.Action = 0
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowPermission
@@ -580,14 +583,14 @@ func (m *PermArgs) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				m.PermFlag |= (PermFlag(b) & 0x7F) << shift
+				m.Action |= (PermFlag(b) & 0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
 		case 2:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
 			}
 			var byteLen int
 			for shift := uint(0); ; shift += 7 {
@@ -612,8 +615,8 @@ func (m *PermArgs) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			var v github_com_hyperledger_burrow_crypto.Address
-			m.Address = &v
-			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			m.Target = &v
+			if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -818,27 +821,28 @@ func init() { proto.RegisterFile("permission.proto", fileDescriptorPermission) }
 func init() { golang_proto.RegisterFile("permission.proto", fileDescriptorPermission) }
 
 var fileDescriptorPermission = []byte{
-	// 351 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0x31, 0x4b, 0xc3, 0x40,
-	0x14, 0xee, 0xb5, 0xa9, 0xb6, 0xcf, 0x82, 0xe5, 0x70, 0x08, 0x0a, 0x49, 0xe8, 0x20, 0x19, 0x6a,
-	0x22, 0x82, 0x4b, 0x07, 0xa1, 0x19, 0x1c, 0x9c, 0xe4, 0x04, 0x07, 0xb7, 0x34, 0x3d, 0xd3, 0x40,
-	0xda, 0x0b, 0x77, 0x17, 0xa4, 0xff, 0xc4, 0x51, 0xff, 0x89, 0x63, 0xc7, 0xce, 0x0e, 0x45, 0x5a,
-	0xf0, 0x47, 0x38, 0xc9, 0x5d, 0x6a, 0x1b, 0x85, 0xba, 0xbd, 0xef, 0x7d, 0xdf, 0x7b, 0xdf, 0xbd,
-	0xef, 0xa0, 0x9d, 0x51, 0x3e, 0x4e, 0x84, 0x48, 0xd8, 0xc4, 0xcb, 0x38, 0x93, 0x0c, 0xc3, 0xb6,
-	0x73, 0x7c, 0x16, 0x27, 0x72, 0x94, 0x0f, 0xbc, 0x88, 0x8d, 0xfd, 0x98, 0xc5, 0xcc, 0xd7, 0x92,
-	0x41, 0xfe, 0xa8, 0x91, 0x06, 0xba, 0x2a, 0x46, 0x3b, 0x21, 0xe0, 0x7e, 0x14, 0xb1, 0x7c, 0x22,
-	0x6f, 0x37, 0x3b, 0x04, 0xbe, 0x04, 0x23, 0x08, 0x05, 0x35, 0x91, 0x83, 0xdc, 0x83, 0x8b, 0x13,
-	0xaf, 0xe4, 0xa8, 0xfa, 0x25, 0x69, 0x60, 0xcc, 0x16, 0x76, 0x85, 0x68, 0x39, 0x3e, 0x82, 0x3a,
-	0x61, 0x29, 0x15, 0x66, 0xd5, 0xa9, 0xb9, 0x4d, 0x52, 0x80, 0x4e, 0x02, 0x87, 0x7f, 0x86, 0xf0,
-	0x29, 0xd4, 0x15, 0x14, 0xda, 0xc0, 0x08, 0xda, 0x6a, 0xc7, 0xd7, 0xc2, 0x6e, 0xa8, 0xe6, 0x75,
-	0x1a, 0xc6, 0xa4, 0xa0, 0xb1, 0x0b, 0x7b, 0x77, 0x54, 0x06, 0x89, 0x34, 0xab, 0x3b, 0x84, 0x6b,
-	0xbe, 0x67, 0x3c, 0xbf, 0xd8, 0x95, 0xce, 0x27, 0x02, 0x4d, 0xf5, 0x79, 0x2c, 0x70, 0x17, 0x36,
-	0xb2, 0x9d, 0x3e, 0x9b, 0x0a, 0xdf, 0xc0, 0x7e, 0x7f, 0x38, 0xe4, 0x54, 0x08, 0xed, 0xd5, 0x0a,
-	0xce, 0xdf, 0x17, 0x76, 0xb7, 0x14, 0xe6, 0x68, 0x9a, 0x51, 0x9e, 0xd2, 0x61, 0x4c, 0xb9, 0x3f,
-	0xc8, 0x39, 0x67, 0x4f, 0x7e, 0xc4, 0xa7, 0x99, 0x64, 0xde, 0x7a, 0x8e, 0xfc, 0x2c, 0xc0, 0x5d,
-	0x80, 0xed, 0xb5, 0x66, 0x4d, 0x7b, 0xb7, 0x7e, 0xf9, 0x96, 0x78, 0x8c, 0xc1, 0x50, 0x41, 0x99,
-	0x86, 0x83, 0xdc, 0x26, 0xd1, 0xb5, 0x4a, 0xf2, 0x3e, 0x4c, 0x73, 0x6a, 0xd6, 0x1d, 0xe4, 0x36,
-	0x48, 0x01, 0x7a, 0x0d, 0x75, 0xe4, 0xfc, 0xd5, 0xae, 0x04, 0x57, 0xb3, 0xa5, 0x85, 0xe6, 0x4b,
-	0x0b, 0x7d, 0x2c, 0x2d, 0xf4, 0xb6, 0xb2, 0xd0, 0x6c, 0x65, 0xa1, 0x07, 0xf7, 0xff, 0xe7, 0x6e,
-	0x7f, 0xf1, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x75, 0xf4, 0x5f, 0xe9, 0x44, 0x02, 0x00, 0x00,
+	// 355 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0xb1, 0x4b, 0xfb, 0x40,
+	0x14, 0xee, 0xb5, 0x69, 0x69, 0xdf, 0xaf, 0xf0, 0x2b, 0x87, 0x43, 0x50, 0x48, 0x42, 0x07, 0xc9,
+	0x50, 0x13, 0x11, 0x5c, 0x3a, 0x08, 0xc9, 0x20, 0x8e, 0x12, 0xc5, 0xc1, 0x2d, 0x4d, 0xcf, 0x6b,
+	0x20, 0xed, 0x85, 0xbb, 0x0b, 0xd2, 0xff, 0xc4, 0x51, 0xff, 0x13, 0xc7, 0x8e, 0x9d, 0x1d, 0x4a,
+	0x69, 0xff, 0x0b, 0x27, 0xb9, 0x4b, 0xb1, 0x51, 0xa8, 0xdb, 0xfb, 0xde, 0xf7, 0x7d, 0xef, 0xbb,
+	0xf7, 0x0e, 0x7a, 0x39, 0xe1, 0xd3, 0x54, 0x88, 0x94, 0xcd, 0xbc, 0x9c, 0x33, 0xc9, 0x30, 0xec,
+	0x3b, 0xc7, 0x67, 0x34, 0x95, 0x93, 0x62, 0xe4, 0x25, 0x6c, 0xea, 0x53, 0x46, 0x99, 0xaf, 0x25,
+	0xa3, 0xe2, 0x49, 0x23, 0x0d, 0x74, 0x55, 0x5a, 0xfb, 0x31, 0xe0, 0x20, 0x49, 0x58, 0x31, 0x93,
+	0xb7, 0xdf, 0x33, 0x04, 0xbe, 0x04, 0x23, 0x8c, 0x05, 0x31, 0x91, 0x83, 0xdc, 0x7f, 0x17, 0x27,
+	0x5e, 0x25, 0x51, 0xf5, 0x2b, 0xd2, 0xd0, 0x58, 0xac, 0xec, 0x5a, 0xa4, 0xe5, 0xf8, 0x08, 0x9a,
+	0x11, 0xcb, 0x88, 0x30, 0xeb, 0x4e, 0xc3, 0xed, 0x44, 0x25, 0xe8, 0xa7, 0xf0, 0xff, 0x97, 0x09,
+	0x9f, 0x42, 0x53, 0x41, 0xa1, 0x03, 0x8c, 0xb0, 0xa7, 0x66, 0x7c, 0xae, 0xec, 0xb6, 0x6a, 0x5e,
+	0x67, 0x31, 0x8d, 0x4a, 0x1a, 0xbb, 0xd0, 0xba, 0x23, 0x32, 0x4c, 0xa5, 0x59, 0x3f, 0x20, 0xdc,
+	0xf1, 0x43, 0xe3, 0xe5, 0xd5, 0xae, 0xf5, 0xd7, 0x08, 0x34, 0x15, 0x70, 0xaa, 0xcd, 0x41, 0x22,
+	0x53, 0x36, 0x3b, 0x98, 0xb2, 0xe3, 0xf1, 0x0d, 0xb4, 0xee, 0x63, 0x4e, 0x49, 0x19, 0xd3, 0x0d,
+	0xcf, 0x3f, 0x56, 0xf6, 0xa0, 0x72, 0xc7, 0xc9, 0x3c, 0x27, 0x3c, 0x23, 0x63, 0x4a, 0xb8, 0x3f,
+	0x2a, 0x38, 0x67, 0xcf, 0x7e, 0xc2, 0xe7, 0xb9, 0x64, 0x5e, 0x30, 0x1e, 0x73, 0x22, 0x44, 0xb4,
+	0xf3, 0xe3, 0x01, 0xc0, 0x7e, 0x4f, 0xb3, 0xa1, 0x73, 0xbb, 0x3f, 0x32, 0x2b, 0x3c, 0xc6, 0x60,
+	0xa8, 0x13, 0x99, 0x86, 0x83, 0xdc, 0x4e, 0xa4, 0x6b, 0x75, 0xc3, 0x87, 0x38, 0x2b, 0x88, 0xd9,
+	0x74, 0x90, 0xdb, 0x8e, 0x4a, 0x30, 0x6c, 0xab, 0xf5, 0x96, 0x6f, 0x76, 0x2d, 0xbc, 0x5a, 0x6c,
+	0x2c, 0xb4, 0xdc, 0x58, 0x68, 0xbd, 0xb1, 0xd0, 0xfb, 0xd6, 0x42, 0x8b, 0xad, 0x85, 0x1e, 0xdd,
+	0xbf, 0x5f, 0xbb, 0xff, 0xbf, 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x70, 0x53, 0xf2, 0x3e,
+	0x02, 0x00, 0x00,
 }
diff --git a/permission/snatives.go b/permission/snatives.go
index 6f3df0a1ec184c07c3f0975a1e3c7693cdb3287a..649fcc111f0084f25c0b0c51c689ad5d18347c3a 100644
--- a/permission/snatives.go
+++ b/permission/snatives.go
@@ -26,9 +26,9 @@ import (
 
 func (pa PermArgs) String() string {
 	body := make([]string, 0, 5)
-	body = append(body, fmt.Sprintf("PermFlag: %v", String(pa.PermFlag)))
-	if pa.Address != nil {
-		body = append(body, fmt.Sprintf("Address: %s", *pa.Address))
+	body = append(body, fmt.Sprintf("PermFlag: %v", String(pa.Action)))
+	if pa.Target != nil {
+		body = append(body, fmt.Sprintf("Address: %s", *pa.Target))
 	}
 	if pa.Permission != nil {
 		body = append(body, fmt.Sprintf("Permission: %v", String(*pa.Permission)))
@@ -43,9 +43,9 @@ func (pa PermArgs) String() string {
 }
 
 func (pa PermArgs) EnsureValid() error {
-	pf := pa.PermFlag
+	pf := pa.Action
 	// Address
-	if pa.Address == nil && pf != SetGlobal {
+	if pa.Target == nil && pf != SetGlobal {
 		return fmt.Errorf("PermArgs for PermFlag %v requires Address to be provided but was nil", pf)
 	}
 	if pf == HasRole || pf == AddRole || pf == RemoveRole {
@@ -65,16 +65,16 @@ func (pa PermArgs) EnsureValid() error {
 
 func HasBaseArgs(address crypto.Address, permFlag PermFlag) PermArgs {
 	return PermArgs{
-		PermFlag:   HasBase,
-		Address:    &address,
+		Action:     HasBase,
+		Target:     &address,
 		Permission: &permFlag,
 	}
 }
 
 func SetBaseArgs(address crypto.Address, permFlag PermFlag, value bool) PermArgs {
 	return PermArgs{
-		PermFlag:   SetBase,
-		Address:    &address,
+		Action:     SetBase,
+		Target:     &address,
 		Permission: &permFlag,
 		Value:      &value,
 	}
@@ -82,15 +82,15 @@ func SetBaseArgs(address crypto.Address, permFlag PermFlag, value bool) PermArgs
 
 func UnsetBaseArgs(address crypto.Address, permFlag PermFlag) PermArgs {
 	return PermArgs{
-		PermFlag:   UnsetBase,
-		Address:    &address,
+		Action:     UnsetBase,
+		Target:     &address,
 		Permission: &permFlag,
 	}
 }
 
 func SetGlobalArgs(permFlag PermFlag, value bool) PermArgs {
 	return PermArgs{
-		PermFlag:   SetGlobal,
+		Action:     SetGlobal,
 		Permission: &permFlag,
 		Value:      &value,
 	}
@@ -98,24 +98,24 @@ func SetGlobalArgs(permFlag PermFlag, value bool) PermArgs {
 
 func HasRoleArgs(address crypto.Address, role string) PermArgs {
 	return PermArgs{
-		PermFlag: HasRole,
-		Address:  &address,
-		Role:     &role,
+		Action: HasRole,
+		Target: &address,
+		Role:   &role,
 	}
 }
 
 func AddRoleArgs(address crypto.Address, role string) PermArgs {
 	return PermArgs{
-		PermFlag: AddRole,
-		Address:  &address,
-		Role:     &role,
+		Action: AddRole,
+		Target: &address,
+		Role:   &role,
 	}
 }
 
 func RemoveRoleArgs(address crypto.Address, role string) PermArgs {
 	return PermArgs{
-		PermFlag: RemoveRole,
-		Address:  &address,
-		Role:     &role,
+		Action: RemoveRole,
+		Target: &address,
+		Role:   &role,
 	}
 }
diff --git a/protobuf/github.com/gogo/protobuf/gogoproto/gogo.proto b/protobuf/github.com/gogo/protobuf/gogoproto/gogo.proto
new file mode 100644
index 0000000000000000000000000000000000000000..bc8d889f161a321d207c944dc4ed19bef34abff8
--- /dev/null
+++ b/protobuf/github.com/gogo/protobuf/gogoproto/gogo.proto
@@ -0,0 +1,136 @@
+// Protocol Buffers for Go with Gadgets
+//
+// Copyright (c) 2013, The GoGo Authors. All rights reserved.
+// http://github.com/gogo/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto2";
+package gogoproto;
+
+import "google/protobuf/descriptor.proto";
+
+option java_package = "com.google.protobuf";
+option java_outer_classname = "GoGoProtos";
+option go_package = "github.com/gogo/protobuf/gogoproto";
+
+extend google.protobuf.EnumOptions {
+	optional bool goproto_enum_prefix = 62001;
+	optional bool goproto_enum_stringer = 62021;
+	optional bool enum_stringer = 62022;
+	optional string enum_customname = 62023;
+	optional bool enumdecl = 62024;
+}
+
+extend google.protobuf.EnumValueOptions {
+	optional string enumvalue_customname = 66001;
+}
+
+extend google.protobuf.FileOptions {
+	optional bool goproto_getters_all = 63001;
+	optional bool goproto_enum_prefix_all = 63002;
+	optional bool goproto_stringer_all = 63003;
+	optional bool verbose_equal_all = 63004;
+	optional bool face_all = 63005;
+	optional bool gostring_all = 63006;
+	optional bool populate_all = 63007;
+	optional bool stringer_all = 63008;
+	optional bool onlyone_all = 63009;
+
+	optional bool equal_all = 63013;
+	optional bool description_all = 63014;
+	optional bool testgen_all = 63015;
+	optional bool benchgen_all = 63016;
+	optional bool marshaler_all = 63017;
+	optional bool unmarshaler_all = 63018;
+	optional bool stable_marshaler_all = 63019;
+
+	optional bool sizer_all = 63020;
+
+	optional bool goproto_enum_stringer_all = 63021;
+	optional bool enum_stringer_all = 63022;
+
+	optional bool unsafe_marshaler_all = 63023;
+	optional bool unsafe_unmarshaler_all = 63024;
+
+	optional bool goproto_extensions_map_all = 63025;
+	optional bool goproto_unrecognized_all = 63026;
+	optional bool gogoproto_import = 63027;
+	optional bool protosizer_all = 63028;
+	optional bool compare_all = 63029;
+    optional bool typedecl_all = 63030;
+    optional bool enumdecl_all = 63031;
+
+	optional bool goproto_registration = 63032;
+	optional bool messagename_all = 63033;
+}
+
+extend google.protobuf.MessageOptions {
+	optional bool goproto_getters = 64001;
+	optional bool goproto_stringer = 64003;
+	optional bool verbose_equal = 64004;
+	optional bool face = 64005;
+	optional bool gostring = 64006;
+	optional bool populate = 64007;
+	optional bool stringer = 67008;
+	optional bool onlyone = 64009;
+
+	optional bool equal = 64013;
+	optional bool description = 64014;
+	optional bool testgen = 64015;
+	optional bool benchgen = 64016;
+	optional bool marshaler = 64017;
+	optional bool unmarshaler = 64018;
+	optional bool stable_marshaler = 64019;
+
+	optional bool sizer = 64020;
+
+	optional bool unsafe_marshaler = 64023;
+	optional bool unsafe_unmarshaler = 64024;
+
+	optional bool goproto_extensions_map = 64025;
+	optional bool goproto_unrecognized = 64026;
+
+	optional bool protosizer = 64028;
+	optional bool compare = 64029;
+
+	optional bool typedecl = 64030;
+
+	optional bool messagename = 64033;
+}
+
+extend google.protobuf.FieldOptions {
+	optional bool nullable = 65001;
+	optional bool embed = 65002;
+	optional string customtype = 65003;
+	optional string customname = 65004;
+	optional string jsontag = 65005;
+	optional string moretags = 65006;
+	optional string casttype = 65007;
+	optional string castkey = 65008;
+	optional string castvalue = 65009;
+
+	optional bool stdtime = 65010;
+	optional bool stdduration = 65011;
+}
diff --git a/protobuf/permission.proto b/protobuf/permission.proto
index d7ba52af5dd3ace0ffcb79596c26a819a263ceb6..b1709bffea4c90d68336dfdc585942842cb3de64 100644
--- a/protobuf/permission.proto
+++ b/protobuf/permission.proto
@@ -31,8 +31,11 @@ message BasePermissions {
 message PermArgs {
     option (gogoproto.goproto_unrecognized) = false;
     option (gogoproto.goproto_stringer) = false;
-    optional uint64 PermFlag = 1 [(gogoproto.casttype) = "PermFlag", (gogoproto.nullable) = false];
-    optional bytes Address = 2 [(gogoproto.customtype) = "github.com/hyperledger/burrow/crypto.Address"];
+    // The permission function
+    optional uint64 Action = 1 [(gogoproto.casttype) = "PermFlag", (gogoproto.nullable) = false];
+    // The target of the action
+    optional bytes Target = 2 [(gogoproto.customtype) = "github.com/hyperledger/burrow/crypto.Address"];
+    // Possible arguments
     optional uint64 Permission = 3 [(gogoproto.casttype) = "PermFlag"];
     optional string Role = 4;
     optional bool Value = 5;
diff --git a/protobuf/rpc.proto b/protobuf/rpc.proto
new file mode 100644
index 0000000000000000000000000000000000000000..4270702ee341c9e7e33de054dd16531b1e990b1d
--- /dev/null
+++ b/protobuf/rpc.proto
@@ -0,0 +1,31 @@
+// Needed to proto2 rather than proto3 to get pointer field for PermArg
+syntax = 'proto3';
+
+option go_package = "github.com/hyperledger/burrow/rpc";
+
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+import "crypto.proto";
+import "tendermint.proto";
+import "google/protobuf/timestamp.proto";
+
+package rpc;
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+option (gogoproto.goproto_registration) = true;
+option (gogoproto.messagename_all) = true;
+
+message ResultStatus {
+    string ChainID = 1;
+    bytes GenesisHash = 4 [(gogoproto.customtype) = "github.com/hyperledger/burrow/binary.HexBytes", (gogoproto.nullable) = false];
+    tendermint.NodeInfo NodeInfo = 2;
+    string NodeVersion = 3;
+    crypto.PublicKey PublicKey = 5 [(gogoproto.nullable) = false];
+    bytes LatestBlockHash = 6 [(gogoproto.customtype) = "github.com/hyperledger/burrow/binary.HexBytes", (gogoproto.nullable) = false];
+    uint64 LatestBlockHeight = 7 [(gogoproto.jsontag) = ""];
+    // Unix
+
+    google.protobuf.Timestamp LatestBlockTime = 8 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+}
+
diff --git a/protobuf/rpcquery.proto b/protobuf/rpcquery.proto
index fc8b66262e5fe309df5e52657782c93f87365473..8981b7b7fb11f3dddb344c7965c982cdd851ec19 100644
--- a/protobuf/rpcquery.proto
+++ b/protobuf/rpcquery.proto
@@ -9,6 +9,7 @@ import "github.com/gogo/protobuf/gogoproto/gogo.proto";
 import "names.proto";
 import "acm.proto";
 import "validator.proto";
+import "rpc.proto";
 
 option (gogoproto.marshaler_all) = true;
 option (gogoproto.unmarshaler_all) = true;
@@ -17,13 +18,20 @@ option (gogoproto.goproto_registration) = true;
 option (gogoproto.messagename_all) = true;
 
 service Query {
+    rpc Status (StatusParam) returns (rpc.ResultStatus);
     rpc GetAccount (GetAccountParam) returns (acm.ConcreteAccount);
     rpc ListAccounts (ListAccountsParam) returns (stream acm.ConcreteAccount);
+
     rpc GetName (GetNameParam) returns (names.Entry);
     rpc ListNames (ListNamesParam) returns (stream names.Entry);
+
     rpc GetValidatorSet (GetValidatorSetParam) returns (ValidatorSet);
 }
 
+message StatusParam {
+    string BlockWithin = 1;
+}
+
 message GetAccountParam {
     bytes Address = 1 [(gogoproto.customtype) = "github.com/hyperledger/burrow/crypto.Address", (gogoproto.nullable) = false];
 }
diff --git a/protobuf/tendermint.proto b/protobuf/tendermint.proto
new file mode 100644
index 0000000000000000000000000000000000000000..a4a06319f2434538f5dbb8770515d285edf89950
--- /dev/null
+++ b/protobuf/tendermint.proto
@@ -0,0 +1,24 @@
+// Needed to proto2 rather than proto3 to get pointer field for PermArg
+syntax = 'proto3';
+
+option go_package = "github.com/hyperledger/burrow/consensus/tendermint";
+
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+package tendermint;
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+option (gogoproto.goproto_registration) = true;
+option (gogoproto.messagename_all) = true;
+
+message NodeInfo {
+    bytes ID = 1 [(gogoproto.customtype) = "github.com/hyperledger/burrow/crypto.Address", (gogoproto.nullable) = false];
+    string ListenAddress = 2;
+    string Network = 3;
+    string Version = 4;
+    bytes Channels = 5 [(gogoproto.customtype) = "github.com/hyperledger/burrow/binary.HexBytes", (gogoproto.nullable) = false];
+    string Moniker = 6;
+    repeated string Other = 7;
+}
diff --git a/rpc/metrics/export.go b/rpc/metrics/export.go
index 51e105c96c21f5f4090a3123ba2a9bf39d6aefce..d64a8577ee3ffd883c170de6e98b9c1aa04040a4 100644
--- a/rpc/metrics/export.go
+++ b/rpc/metrics/export.go
@@ -53,7 +53,7 @@ func (e *Exporter) gatherData() error {
 
 // Get status
 func (e *Exporter) getStatus() error {
-	res, err := e.service.Status()
+	res, err := e.service.Status("")
 	if err != nil {
 		return err
 	}
diff --git a/rpc/metrics/server.go b/rpc/metrics/server.go
index 5eab0754c58a243ebb9c6c1bda12515c3ebcc71f..273996dddc4e9240a562554b2fab6a71870e59a5 100644
--- a/rpc/metrics/server.go
+++ b/rpc/metrics/server.go
@@ -55,7 +55,7 @@ func StartServer(service *rpc.Service, pattern, listenAddress string, blockSampl
 	logger *logging.Logger) (*http.Server, error) {
 
 	// instantiate metrics and variables we do not expect to change during runtime
-	chainStatus, _ := service.Status()
+	chainStatus, _ := service.Status("")
 	exporter := Exporter{
 		burrowMetrics:    AddMetrics(),
 		datum:            &Datum{},
diff --git a/rpc/result.go b/rpc/result.go
index 35d21892f7d912c622a8cacc710a56ecdf66763e..a7ca72edb6408f5afbb3ef5cc2da5df2f844622b 100644
--- a/rpc/result.go
+++ b/rpc/result.go
@@ -15,18 +15,16 @@
 package rpc
 
 import (
-	"time"
-
 	"github.com/hyperledger/burrow/acm"
 	"github.com/hyperledger/burrow/acm/validator"
 	"github.com/hyperledger/burrow/binary"
+	"github.com/hyperledger/burrow/consensus/tendermint"
 	"github.com/hyperledger/burrow/crypto"
 	"github.com/hyperledger/burrow/execution/names"
 	"github.com/hyperledger/burrow/genesis"
 	"github.com/hyperledger/burrow/txs"
 	"github.com/tendermint/go-amino"
 	consensusTypes "github.com/tendermint/tendermint/consensus/types"
-	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/rpc/core/types"
 	tmTypes "github.com/tendermint/tendermint/types"
 )
@@ -94,22 +92,6 @@ func (b *Block) UnmarshalJSON(data []byte) (err error) {
 	return aminoCodec.UnmarshalJSON(data, &b.Block)
 }
 
-type ResultStatus struct {
-	NodeInfo          p2p.NodeInfo
-	GenesisHash       binary.HexBytes
-	PublicKey         crypto.PublicKey
-	LatestBlockHash   binary.HexBytes
-	LatestBlockHeight uint64
-	LatestBlockTime   int64
-	NodeVersion       string
-}
-
-type ResultLastBlockInfo struct {
-	LastBlockHeight uint64
-	LastBlockTime   time.Time
-	LastBlockHash   binary.HexBytes
-}
-
 type ResultChainId struct {
 	ChainName   string
 	ChainId     string
@@ -126,12 +108,12 @@ type ResultUnsubscribe struct {
 }
 
 type Peer struct {
-	NodeInfo   p2p.NodeInfo
+	NodeInfo   *tendermint.NodeInfo
 	IsOutbound bool
 }
 
 type ResultNetInfo struct {
-	ThisNode  p2p.NodeInfo
+	ThisNode  *tendermint.NodeInfo
 	Listening bool
 	Listeners []string
 	Peers     []*Peer
diff --git a/rpc/result_test.go b/rpc/result_test.go
index 9c66f47ad838dd8aaab94e017f7c7da4e23749e5..78af66633d1ed0cfbcab6dc14232e8b2dafe144f 100644
--- a/rpc/result_test.go
+++ b/rpc/result_test.go
@@ -18,12 +18,7 @@ import (
 	"encoding/json"
 	"testing"
 
-	"time"
-
-	"fmt"
-
 	"github.com/hyperledger/burrow/acm"
-	"github.com/hyperledger/burrow/binary"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/tendermint/tendermint/consensus/types"
@@ -87,15 +82,3 @@ func TestResultDumpConsensusState(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, string(bs), string(bsOut))
 }
-
-func TestResultLastBlockInfo(t *testing.T) {
-	res := &ResultLastBlockInfo{
-		LastBlockTime:   time.Now(),
-		LastBlockHash:   binary.HexBytes{3, 4, 5, 6},
-		LastBlockHeight: 2343,
-	}
-	bs, err := json.Marshal(res)
-	require.NoError(t, err)
-	fmt.Println(string(bs))
-
-}
diff --git a/rpc/rpc.pb.go b/rpc/rpc.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..1815a6200f11c7cf6a49245d4e5d63cc528c9204
--- /dev/null
+++ b/rpc/rpc.pb.go
@@ -0,0 +1,653 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: rpc.proto
+
+/*
+	Package rpc is a generated protocol buffer package.
+
+	It is generated from these files:
+		rpc.proto
+
+	It has these top-level messages:
+		ResultStatus
+*/
+package rpc
+
+import proto "github.com/gogo/protobuf/proto"
+import golang_proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import _ "github.com/gogo/protobuf/gogoproto"
+import crypto "github.com/hyperledger/burrow/crypto"
+import tendermint "github.com/hyperledger/burrow/consensus/tendermint"
+import _ "github.com/golang/protobuf/ptypes/timestamp"
+
+import github_com_hyperledger_burrow_binary "github.com/hyperledger/burrow/binary"
+import time "time"
+
+import types "github.com/gogo/protobuf/types"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = golang_proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+var _ = time.Kitchen
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+
+type ResultStatus struct {
+	ChainID           string                                        `protobuf:"bytes,1,opt,name=ChainID,proto3" json:"ChainID,omitempty"`
+	GenesisHash       github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,4,opt,name=GenesisHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"GenesisHash"`
+	NodeInfo          *tendermint.NodeInfo                          `protobuf:"bytes,2,opt,name=NodeInfo" json:"NodeInfo,omitempty"`
+	NodeVersion       string                                        `protobuf:"bytes,3,opt,name=NodeVersion,proto3" json:"NodeVersion,omitempty"`
+	PublicKey         crypto.PublicKey                              `protobuf:"bytes,5,opt,name=PublicKey" json:"PublicKey"`
+	LatestBlockHash   github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,6,opt,name=LatestBlockHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"LatestBlockHash"`
+	LatestBlockHeight uint64                                        `protobuf:"varint,7,opt,name=LatestBlockHeight,proto3" json:""`
+	LatestBlockTime   time.Time                                     `protobuf:"bytes,8,opt,name=LatestBlockTime,stdtime" json:"LatestBlockTime"`
+}
+
+func (m *ResultStatus) Reset()                    { *m = ResultStatus{} }
+func (m *ResultStatus) String() string            { return proto.CompactTextString(m) }
+func (*ResultStatus) ProtoMessage()               {}
+func (*ResultStatus) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} }
+
+func (m *ResultStatus) GetChainID() string {
+	if m != nil {
+		return m.ChainID
+	}
+	return ""
+}
+
+func (m *ResultStatus) GetNodeInfo() *tendermint.NodeInfo {
+	if m != nil {
+		return m.NodeInfo
+	}
+	return nil
+}
+
+func (m *ResultStatus) GetNodeVersion() string {
+	if m != nil {
+		return m.NodeVersion
+	}
+	return ""
+}
+
+func (m *ResultStatus) GetPublicKey() crypto.PublicKey {
+	if m != nil {
+		return m.PublicKey
+	}
+	return crypto.PublicKey{}
+}
+
+func (m *ResultStatus) GetLatestBlockHeight() uint64 {
+	if m != nil {
+		return m.LatestBlockHeight
+	}
+	return 0
+}
+
+func (m *ResultStatus) GetLatestBlockTime() time.Time {
+	if m != nil {
+		return m.LatestBlockTime
+	}
+	return time.Time{}
+}
+
+func (*ResultStatus) XXX_MessageName() string {
+	return "rpc.ResultStatus"
+}
+func init() {
+	proto.RegisterType((*ResultStatus)(nil), "rpc.ResultStatus")
+	golang_proto.RegisterType((*ResultStatus)(nil), "rpc.ResultStatus")
+}
+func (m *ResultStatus) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ResultStatus) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.ChainID) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.ChainID)))
+		i += copy(dAtA[i:], m.ChainID)
+	}
+	if m.NodeInfo != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.NodeInfo.Size()))
+		n1, err := m.NodeInfo.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n1
+	}
+	if len(m.NodeVersion) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.NodeVersion)))
+		i += copy(dAtA[i:], m.NodeVersion)
+	}
+	dAtA[i] = 0x22
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.GenesisHash.Size()))
+	n2, err := m.GenesisHash.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n2
+	dAtA[i] = 0x2a
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.PublicKey.Size()))
+	n3, err := m.PublicKey.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n3
+	dAtA[i] = 0x32
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.LatestBlockHash.Size()))
+	n4, err := m.LatestBlockHash.MarshalTo(dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n4
+	if m.LatestBlockHeight != 0 {
+		dAtA[i] = 0x38
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.LatestBlockHeight))
+	}
+	dAtA[i] = 0x42
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(types.SizeOfStdTime(m.LatestBlockTime)))
+	n5, err := types.StdTimeMarshalTo(m.LatestBlockTime, dAtA[i:])
+	if err != nil {
+		return 0, err
+	}
+	i += n5
+	return i, nil
+}
+
+func encodeVarintRpc(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *ResultStatus) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.ChainID)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.NodeInfo != nil {
+		l = m.NodeInfo.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.NodeVersion)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = m.GenesisHash.Size()
+	n += 1 + l + sovRpc(uint64(l))
+	l = m.PublicKey.Size()
+	n += 1 + l + sovRpc(uint64(l))
+	l = m.LatestBlockHash.Size()
+	n += 1 + l + sovRpc(uint64(l))
+	if m.LatestBlockHeight != 0 {
+		n += 1 + sovRpc(uint64(m.LatestBlockHeight))
+	}
+	l = types.SizeOfStdTime(m.LatestBlockTime)
+	n += 1 + l + sovRpc(uint64(l))
+	return n
+}
+
+func sovRpc(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozRpc(x uint64) (n int) {
+	return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *ResultStatus) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ResultStatus: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ResultStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ChainID = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodeInfo", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.NodeInfo == nil {
+				m.NodeInfo = &tendermint.NodeInfo{}
+			}
+			if err := m.NodeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodeVersion", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.NodeVersion = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GenesisHash", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.GenesisHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHash", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.LatestBlockHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockHeight", wireType)
+			}
+			m.LatestBlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.LatestBlockHeight |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LatestBlockTime", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := types.StdTimeUnmarshal(&m.LatestBlockTime, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipRpc(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthRpc
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowRpc
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipRpc(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthRpc = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowRpc   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("rpc.proto", fileDescriptorRpc) }
+func init() { golang_proto.RegisterFile("rpc.proto", fileDescriptorRpc) }
+
+var fileDescriptorRpc = []byte{
+	// 403 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x51, 0xb1, 0x8e, 0xd3, 0x40,
+	0x10, 0x65, 0x89, 0xb9, 0x4b, 0x36, 0x91, 0xe0, 0x56, 0x14, 0xab, 0x14, 0xb6, 0xa1, 0x72, 0xc3,
+	0x1a, 0x1d, 0x3a, 0xd1, 0x1b, 0x24, 0xee, 0x04, 0x3a, 0x21, 0x13, 0x81, 0x44, 0x83, 0x6c, 0x67,
+	0x62, 0xaf, 0xb0, 0xbd, 0xd6, 0xee, 0x5a, 0xe0, 0xbf, 0xe0, 0x93, 0x28, 0x53, 0x52, 0x53, 0x04,
+	0x94, 0x74, 0x74, 0xfc, 0x01, 0xf2, 0x26, 0x4e, 0x4c, 0x90, 0x68, 0xae, 0x9b, 0x37, 0x6f, 0xe6,
+	0xcd, 0x9b, 0x19, 0x3c, 0x92, 0x55, 0xc2, 0x2a, 0x29, 0xb4, 0x20, 0x03, 0x59, 0x25, 0xd3, 0x47,
+	0x29, 0xd7, 0x59, 0x1d, 0xb3, 0x44, 0x14, 0x7e, 0x2a, 0x52, 0xe1, 0x1b, 0x2e, 0xae, 0x17, 0x06,
+	0x19, 0x60, 0xa2, 0x6d, 0xcf, 0x74, 0x92, 0xc8, 0xa6, 0xd2, 0x1d, 0xba, 0xa7, 0xa1, 0x9c, 0x83,
+	0x2c, 0x78, 0xa9, 0x77, 0x19, 0x27, 0x15, 0x22, 0xcd, 0xe1, 0xa0, 0xa2, 0x79, 0x01, 0x4a, 0x47,
+	0x45, 0xb5, 0x2d, 0x78, 0xf8, 0x7b, 0x80, 0x27, 0x21, 0xa8, 0x3a, 0xd7, 0x6f, 0x74, 0xa4, 0x6b,
+	0x45, 0x28, 0x3e, 0x7d, 0x96, 0x45, 0xbc, 0xbc, 0x7a, 0x4e, 0x91, 0x8b, 0xbc, 0x51, 0xd8, 0x41,
+	0xf2, 0x18, 0x0f, 0xaf, 0xc5, 0x1c, 0xae, 0xca, 0x85, 0xa0, 0xb7, 0x5d, 0xe4, 0x8d, 0xcf, 0xef,
+	0xb3, 0xde, 0xc0, 0x8e, 0x0b, 0xf7, 0x55, 0xc4, 0xc5, 0xe3, 0x36, 0x7e, 0x0b, 0x52, 0x71, 0x51,
+	0xd2, 0x81, 0xd1, 0xeb, 0xa7, 0xc8, 0x3b, 0x3c, 0x7e, 0x01, 0x25, 0x28, 0xae, 0x2e, 0x23, 0x95,
+	0x51, 0xcb, 0x45, 0xde, 0x24, 0xb8, 0x58, 0xae, 0x9c, 0x5b, 0xdf, 0x57, 0x4e, 0xff, 0x16, 0x59,
+	0x53, 0x81, 0xcc, 0x61, 0x9e, 0x82, 0xf4, 0xe3, 0x5a, 0x4a, 0xf1, 0xc9, 0x8f, 0x79, 0x19, 0xc9,
+	0x86, 0x5d, 0xc2, 0xe7, 0xa0, 0xd1, 0xa0, 0xc2, 0xbe, 0x12, 0xb9, 0xc0, 0xa3, 0xd7, 0x75, 0x9c,
+	0xf3, 0xe4, 0x25, 0x34, 0xf4, 0x8e, 0x71, 0x7b, 0xc6, 0x76, 0xc7, 0xda, 0x13, 0x81, 0xd5, 0x4e,
+	0x0a, 0x0f, 0x95, 0xe4, 0x03, 0xbe, 0xfb, 0x2a, 0xd2, 0xa0, 0x74, 0x90, 0x8b, 0xe4, 0xa3, 0xf1,
+	0x74, 0x72, 0x13, 0x4f, 0xc7, 0x6a, 0xe4, 0x1c, 0x9f, 0xf5, 0x53, 0xc0, 0xd3, 0x4c, 0xd3, 0x53,
+	0x17, 0x79, 0x56, 0x60, 0xfd, 0x6a, 0xcd, 0xfc, 0x4b, 0x93, 0xeb, 0xbf, 0x4c, 0xcd, 0x78, 0x01,
+	0x74, 0x68, 0x36, 0x9a, 0xb2, 0xed, 0x7b, 0x59, 0xf7, 0x5e, 0x36, 0xeb, 0xde, 0x1b, 0x0c, 0x5b,
+	0xc3, 0x5f, 0x7e, 0x38, 0x28, 0x3c, 0x6e, 0x0e, 0x9e, 0x2e, 0xd7, 0x36, 0xfa, 0xb6, 0xb6, 0xd1,
+	0xcf, 0xb5, 0x8d, 0xbe, 0x6e, 0x6c, 0xb4, 0xdc, 0xd8, 0xe8, 0xfd, 0x83, 0xff, 0x6f, 0x26, 0xab,
+	0x24, 0x3e, 0x31, 0x73, 0x9e, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff, 0xee, 0x3a, 0x76, 0xc2, 0xb5,
+	0x02, 0x00, 0x00,
+}
diff --git a/rpc/rpcquery/query_server.go b/rpc/rpcquery/query_server.go
index debdc05b53f06473b252cff097b76e1512b56e62..45f2a54e2d5bbcee88f4e67be7b0eafa8db7b0eb 100644
--- a/rpc/rpcquery/query_server.go
+++ b/rpc/rpcquery/query_server.go
@@ -10,6 +10,7 @@ import (
 	"github.com/hyperledger/burrow/event/query"
 	"github.com/hyperledger/burrow/execution/names"
 	"github.com/hyperledger/burrow/logging"
+	"github.com/hyperledger/burrow/rpc"
 )
 
 type queryServer struct {
@@ -33,6 +34,10 @@ func NewQueryServer(state state.IterableReader, nameReg names.IterableReader, bl
 	}
 }
 
+func (qs *queryServer) Status(ctx context.Context, param *StatusParam) (*rpc.ResultStatus, error) {
+	return rpc.Status(qs.blockchain, qs.nodeView, param.BlockWithin)
+}
+
 // Account state
 
 func (qs *queryServer) GetAccount(ctx context.Context, param *GetAccountParam) (*acm.ConcreteAccount, error) {
diff --git a/rpc/rpcquery/rpcquery.pb.go b/rpc/rpcquery/rpcquery.pb.go
index ec9b81710c9f6a760e4d693965d95b4f70cbf1f0..120b2df0b75ecc09eea894cd791d286ae31814a4 100644
--- a/rpc/rpcquery/rpcquery.pb.go
+++ b/rpc/rpcquery/rpcquery.pb.go
@@ -8,6 +8,7 @@
 		rpcquery.proto
 
 	It has these top-level messages:
+		StatusParam
 		GetAccountParam
 		ListAccountsParam
 		GetNameParam
@@ -26,6 +27,7 @@ import _ "github.com/gogo/protobuf/gogoproto"
 import names "github.com/hyperledger/burrow/execution/names"
 import acm "github.com/hyperledger/burrow/acm"
 import validator "github.com/hyperledger/burrow/acm/validator"
+import rpc "github.com/hyperledger/burrow/rpc"
 
 import github_com_hyperledger_burrow_crypto "github.com/hyperledger/burrow/crypto"
 
@@ -46,6 +48,26 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
 
+type StatusParam struct {
+	BlockWithin string `protobuf:"bytes,1,opt,name=BlockWithin,proto3" json:"BlockWithin,omitempty"`
+}
+
+func (m *StatusParam) Reset()                    { *m = StatusParam{} }
+func (m *StatusParam) String() string            { return proto.CompactTextString(m) }
+func (*StatusParam) ProtoMessage()               {}
+func (*StatusParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{0} }
+
+func (m *StatusParam) GetBlockWithin() string {
+	if m != nil {
+		return m.BlockWithin
+	}
+	return ""
+}
+
+func (*StatusParam) XXX_MessageName() string {
+	return "rpcquery.StatusParam"
+}
+
 type GetAccountParam struct {
 	Address github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,1,opt,name=Address,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address"`
 }
@@ -53,7 +75,7 @@ type GetAccountParam struct {
 func (m *GetAccountParam) Reset()                    { *m = GetAccountParam{} }
 func (m *GetAccountParam) String() string            { return proto.CompactTextString(m) }
 func (*GetAccountParam) ProtoMessage()               {}
-func (*GetAccountParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{0} }
+func (*GetAccountParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{1} }
 
 func (*GetAccountParam) XXX_MessageName() string {
 	return "rpcquery.GetAccountParam"
@@ -66,7 +88,7 @@ type ListAccountsParam struct {
 func (m *ListAccountsParam) Reset()                    { *m = ListAccountsParam{} }
 func (m *ListAccountsParam) String() string            { return proto.CompactTextString(m) }
 func (*ListAccountsParam) ProtoMessage()               {}
-func (*ListAccountsParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{1} }
+func (*ListAccountsParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{2} }
 
 func (m *ListAccountsParam) GetQuery() string {
 	if m != nil {
@@ -86,7 +108,7 @@ type GetNameParam struct {
 func (m *GetNameParam) Reset()                    { *m = GetNameParam{} }
 func (m *GetNameParam) String() string            { return proto.CompactTextString(m) }
 func (*GetNameParam) ProtoMessage()               {}
-func (*GetNameParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{2} }
+func (*GetNameParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{3} }
 
 func (m *GetNameParam) GetName() string {
 	if m != nil {
@@ -106,7 +128,7 @@ type ListNamesParam struct {
 func (m *ListNamesParam) Reset()                    { *m = ListNamesParam{} }
 func (m *ListNamesParam) String() string            { return proto.CompactTextString(m) }
 func (*ListNamesParam) ProtoMessage()               {}
-func (*ListNamesParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{3} }
+func (*ListNamesParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{4} }
 
 func (m *ListNamesParam) GetQuery() string {
 	if m != nil {
@@ -126,7 +148,7 @@ type GetValidatorSetParam struct {
 func (m *GetValidatorSetParam) Reset()                    { *m = GetValidatorSetParam{} }
 func (m *GetValidatorSetParam) String() string            { return proto.CompactTextString(m) }
 func (*GetValidatorSetParam) ProtoMessage()               {}
-func (*GetValidatorSetParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{4} }
+func (*GetValidatorSetParam) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{5} }
 
 func (m *GetValidatorSetParam) GetIncludeHistory() bool {
 	if m != nil {
@@ -148,7 +170,7 @@ type ValidatorSet struct {
 func (m *ValidatorSet) Reset()                    { *m = ValidatorSet{} }
 func (m *ValidatorSet) String() string            { return proto.CompactTextString(m) }
 func (*ValidatorSet) ProtoMessage()               {}
-func (*ValidatorSet) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{5} }
+func (*ValidatorSet) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{6} }
 
 func (m *ValidatorSet) GetHeight() uint64 {
 	if m != nil {
@@ -182,7 +204,7 @@ type ValidatorSetDeltas struct {
 func (m *ValidatorSetDeltas) Reset()                    { *m = ValidatorSetDeltas{} }
 func (m *ValidatorSetDeltas) String() string            { return proto.CompactTextString(m) }
 func (*ValidatorSetDeltas) ProtoMessage()               {}
-func (*ValidatorSetDeltas) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{6} }
+func (*ValidatorSetDeltas) Descriptor() ([]byte, []int) { return fileDescriptorRpcquery, []int{7} }
 
 func (m *ValidatorSetDeltas) GetValidators() []*validator.Validator {
 	if m != nil {
@@ -195,6 +217,8 @@ func (*ValidatorSetDeltas) XXX_MessageName() string {
 	return "rpcquery.ValidatorSetDeltas"
 }
 func init() {
+	proto.RegisterType((*StatusParam)(nil), "rpcquery.StatusParam")
+	golang_proto.RegisterType((*StatusParam)(nil), "rpcquery.StatusParam")
 	proto.RegisterType((*GetAccountParam)(nil), "rpcquery.GetAccountParam")
 	golang_proto.RegisterType((*GetAccountParam)(nil), "rpcquery.GetAccountParam")
 	proto.RegisterType((*ListAccountsParam)(nil), "rpcquery.ListAccountsParam")
@@ -222,6 +246,7 @@ const _ = grpc.SupportPackageIsVersion4
 // Client API for Query service
 
 type QueryClient interface {
+	Status(ctx context.Context, in *StatusParam, opts ...grpc.CallOption) (*rpc.ResultStatus, error)
 	GetAccount(ctx context.Context, in *GetAccountParam, opts ...grpc.CallOption) (*acm.ConcreteAccount, error)
 	ListAccounts(ctx context.Context, in *ListAccountsParam, opts ...grpc.CallOption) (Query_ListAccountsClient, error)
 	GetName(ctx context.Context, in *GetNameParam, opts ...grpc.CallOption) (*names.Entry, error)
@@ -237,6 +262,15 @@ func NewQueryClient(cc *grpc.ClientConn) QueryClient {
 	return &queryClient{cc}
 }
 
+func (c *queryClient) Status(ctx context.Context, in *StatusParam, opts ...grpc.CallOption) (*rpc.ResultStatus, error) {
+	out := new(rpc.ResultStatus)
+	err := grpc.Invoke(ctx, "/rpcquery.Query/Status", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) GetAccount(ctx context.Context, in *GetAccountParam, opts ...grpc.CallOption) (*acm.ConcreteAccount, error) {
 	out := new(acm.ConcreteAccount)
 	err := grpc.Invoke(ctx, "/rpcquery.Query/GetAccount", in, out, c.cc, opts...)
@@ -331,6 +365,7 @@ func (c *queryClient) GetValidatorSet(ctx context.Context, in *GetValidatorSetPa
 // Server API for Query service
 
 type QueryServer interface {
+	Status(context.Context, *StatusParam) (*rpc.ResultStatus, error)
 	GetAccount(context.Context, *GetAccountParam) (*acm.ConcreteAccount, error)
 	ListAccounts(*ListAccountsParam, Query_ListAccountsServer) error
 	GetName(context.Context, *GetNameParam) (*names.Entry, error)
@@ -342,6 +377,24 @@ func RegisterQueryServer(s *grpc.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
 }
 
+func _Query_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StatusParam)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).Status(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/rpcquery.Query/Status",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).Status(ctx, req.(*StatusParam))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_GetAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(GetAccountParam)
 	if err := dec(in); err != nil {
@@ -442,6 +495,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "rpcquery.Query",
 	HandlerType: (*QueryServer)(nil),
 	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Status",
+			Handler:    _Query_Status_Handler,
+		},
 		{
 			MethodName: "GetAccount",
 			Handler:    _Query_GetAccount_Handler,
@@ -470,6 +527,30 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 	Metadata: "rpcquery.proto",
 }
 
+func (m *StatusParam) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *StatusParam) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.BlockWithin) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpcquery(dAtA, i, uint64(len(m.BlockWithin)))
+		i += copy(dAtA[i:], m.BlockWithin)
+	}
+	return i, nil
+}
+
 func (m *GetAccountParam) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -682,6 +763,16 @@ func encodeVarintRpcquery(dAtA []byte, offset int, v uint64) int {
 	dAtA[offset] = uint8(v)
 	return offset + 1
 }
+func (m *StatusParam) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.BlockWithin)
+	if l > 0 {
+		n += 1 + l + sovRpcquery(uint64(l))
+	}
+	return n
+}
+
 func (m *GetAccountParam) Size() (n int) {
 	var l int
 	_ = l
@@ -775,6 +866,85 @@ func sovRpcquery(x uint64) (n int) {
 func sozRpcquery(x uint64) (n int) {
 	return sovRpcquery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
+func (m *StatusParam) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpcquery
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: StatusParam: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StatusParam: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockWithin", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpcquery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpcquery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.BlockWithin = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpcquery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpcquery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *GetAccountParam) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -1483,36 +1653,39 @@ func init() { proto.RegisterFile("rpcquery.proto", fileDescriptorRpcquery) }
 func init() { golang_proto.RegisterFile("rpcquery.proto", fileDescriptorRpcquery) }
 
 var fileDescriptorRpcquery = []byte{
-	// 487 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x4f, 0x6f, 0xd3, 0x30,
-	0x1c, 0xc5, 0xeb, 0x58, 0xd7, 0xdf, 0xaa, 0x4e, 0x58, 0x55, 0x55, 0x02, 0xca, 0xa6, 0x1c, 0xaa,
-	0x81, 0x20, 0x99, 0xc6, 0xe0, 0x06, 0x62, 0x1b, 0xa8, 0x0c, 0xa1, 0x09, 0x32, 0x89, 0x03, 0x37,
-	0xd7, 0x31, 0x69, 0xa4, 0x26, 0x0e, 0x8e, 0x03, 0xea, 0x17, 0xe0, 0x63, 0x21, 0x8e, 0x3d, 0x72,
-	0xe6, 0x30, 0xa1, 0xee, 0x8b, 0xa0, 0x38, 0xce, 0xbf, 0x75, 0xea, 0xcd, 0xcf, 0x79, 0xef, 0xf7,
-	0xec, 0xbc, 0x67, 0xe8, 0x89, 0x98, 0x7e, 0x4b, 0x99, 0x98, 0xdb, 0xb1, 0xe0, 0x92, 0xe3, 0xed,
-	0x02, 0x1b, 0x4f, 0xfd, 0x40, 0x4e, 0xd3, 0x89, 0x4d, 0x79, 0xe8, 0xf8, 0xdc, 0xe7, 0x8e, 0x22,
-	0x4c, 0xd2, 0xaf, 0x0a, 0x29, 0xa0, 0x56, 0xb9, 0xd0, 0xd8, 0x89, 0x48, 0xc8, 0x12, 0x0d, 0x3a,
-	0x84, 0x86, 0x7a, 0xb9, 0xfb, 0x9d, 0xcc, 0x02, 0x8f, 0x48, 0x2e, 0xf2, 0x0d, 0x8b, 0xc0, 0xee,
-	0x98, 0xc9, 0x13, 0x4a, 0x79, 0x1a, 0xc9, 0x8f, 0x44, 0x90, 0x10, 0x5f, 0x40, 0xfb, 0xc4, 0xf3,
-	0x04, 0x4b, 0x92, 0x21, 0xda, 0x47, 0x07, 0xdd, 0xd3, 0xe3, 0xc5, 0xd5, 0xde, 0x9d, 0xbf, 0x57,
-	0x7b, 0x4f, 0x6a, 0x67, 0x98, 0xce, 0x63, 0x26, 0x66, 0xcc, 0xf3, 0x99, 0x70, 0x26, 0xa9, 0x10,
-	0xfc, 0x87, 0x43, 0xc5, 0x3c, 0x96, 0xdc, 0xd6, 0x5a, 0xb7, 0x18, 0x62, 0x3d, 0x82, 0x7b, 0x1f,
-	0x82, 0xa4, 0xf0, 0x48, 0x72, 0x93, 0x3e, 0xdc, 0xfd, 0x94, 0x5d, 0x4c, 0x59, 0x74, 0xdc, 0x1c,
-	0x58, 0x16, 0x74, 0xc7, 0x4c, 0x5e, 0x90, 0x90, 0xe5, 0x2c, 0x0c, 0x9b, 0x19, 0xd0, 0x24, 0xb5,
-	0xb6, 0x46, 0xd0, 0xcb, 0xc6, 0x65, 0xeb, 0xb5, 0xb3, 0x5e, 0x41, 0x7f, 0xcc, 0xe4, 0xe7, 0xe2,
-	0xbe, 0x97, 0x4c, 0x5f, 0x6f, 0x04, 0xbd, 0xf3, 0x88, 0xce, 0x52, 0x8f, 0xbd, 0x0b, 0x12, 0xc9,
-	0xb5, 0x6c, 0xdb, 0xbd, 0xb1, 0x6b, 0xfd, 0x44, 0xd0, 0xad, 0xab, 0xf1, 0x00, 0xb6, 0xa6, 0x2c,
-	0xf0, 0xa7, 0x52, 0x09, 0x36, 0x5d, 0x8d, 0xf0, 0x08, 0x5a, 0x97, 0x4c, 0x0e, 0x37, 0xf6, 0x5b,
-	0x07, 0x3b, 0x47, 0x7d, 0xbb, 0xfa, 0xc3, 0xa5, 0xda, 0xcd, 0x08, 0xf8, 0x05, 0xb4, 0x0b, 0xc7,
-	0x96, 0xe2, 0x3e, 0xb4, 0xcb, 0xb8, 0xeb, 0x46, 0x6f, 0xd8, 0x4c, 0x92, 0xc4, 0x2d, 0xc8, 0xd6,
-	0x7b, 0xc0, 0xab, 0x9f, 0xf1, 0x31, 0x40, 0xb9, 0x9b, 0xac, 0x35, 0xaf, 0xf1, 0x8e, 0x7e, 0x6d,
-	0xe8, 0x7f, 0x85, 0x5f, 0x02, 0x54, 0xc1, 0xe3, 0xfb, 0xd5, 0x51, 0x6e, 0xd4, 0xc1, 0xe8, 0xdb,
-	0x59, 0x7d, 0xce, 0x78, 0x44, 0x05, 0x93, 0xac, 0x10, 0x9c, 0x41, 0xb7, 0x1e, 0x2a, 0x7e, 0x50,
-	0x0d, 0x58, 0x09, 0xfb, 0xf6, 0x11, 0x87, 0x08, 0x3b, 0xd0, 0xd6, 0x71, 0xe3, 0x41, 0xe3, 0x00,
-	0x65, 0x03, 0x8c, 0xae, 0x9d, 0x37, 0xf9, 0x6d, 0x24, 0xc5, 0x1c, 0x3f, 0x87, 0x4e, 0x99, 0x3d,
-	0x1e, 0x36, 0x2d, 0xab, 0x42, 0x34, 0x45, 0x87, 0x08, 0x9f, 0xab, 0x92, 0x37, 0xc2, 0x34, 0x1b,
-	0x7e, 0x2b, 0x2d, 0x31, 0x06, 0xb7, 0x67, 0x73, 0xfa, 0x7a, 0xb1, 0x34, 0xd1, 0x9f, 0xa5, 0x89,
-	0xfe, 0x2d, 0x4d, 0xf4, 0xfb, 0xda, 0x44, 0x8b, 0x6b, 0x13, 0x7d, 0x79, 0xbc, 0xfe, 0x65, 0x88,
-	0x98, 0x3a, 0xc5, 0xb8, 0xc9, 0x96, 0x7a, 0x78, 0xcf, 0xfe, 0x07, 0x00, 0x00, 0xff, 0xff, 0xfd,
-	0xa4, 0xb6, 0xf9, 0xec, 0x03, 0x00, 0x00,
+	// 538 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xc1, 0x6e, 0xd3, 0x40,
+	0x10, 0x86, 0xd9, 0xa6, 0x24, 0xcd, 0x24, 0x4a, 0xd5, 0x55, 0x88, 0x82, 0x41, 0x6e, 0xe4, 0x43,
+	0x54, 0x10, 0xd8, 0x55, 0x28, 0xdc, 0x40, 0x34, 0x05, 0x85, 0x22, 0x54, 0x81, 0x23, 0x81, 0xc4,
+	0x6d, 0xb3, 0x59, 0x12, 0x0b, 0xc7, 0x6b, 0xd6, 0x6b, 0x50, 0x5e, 0x80, 0xe7, 0xe2, 0x98, 0x23,
+	0x67, 0x0e, 0x15, 0x4a, 0xdf, 0x80, 0x27, 0x40, 0x5e, 0xaf, 0x63, 0xa7, 0xa9, 0x72, 0x9b, 0x59,
+	0xff, 0xff, 0xcc, 0x78, 0xf7, 0x1b, 0x68, 0x88, 0x90, 0x7e, 0x8b, 0x99, 0x98, 0xdb, 0xa1, 0xe0,
+	0x92, 0xe3, 0xbd, 0x2c, 0x37, 0x1e, 0x4f, 0x3c, 0x39, 0x8d, 0x47, 0x36, 0xe5, 0x33, 0x67, 0xc2,
+	0x27, 0xdc, 0x51, 0x82, 0x51, 0xfc, 0x45, 0x65, 0x2a, 0x51, 0x51, 0x6a, 0x34, 0x6a, 0x01, 0x99,
+	0xb1, 0x48, 0x27, 0x55, 0x42, 0x67, 0x3a, 0xdc, 0xff, 0x4e, 0x7c, 0x6f, 0x4c, 0x24, 0x17, 0xd9,
+	0x37, 0x11, 0xd2, 0x34, 0xb4, 0x1c, 0xa8, 0x0d, 0x25, 0x91, 0x71, 0xf4, 0x9e, 0x08, 0x32, 0xc3,
+	0x1d, 0xa8, 0xf5, 0x7d, 0x4e, 0xbf, 0x7e, 0xf2, 0xe4, 0xd4, 0x0b, 0xda, 0xa8, 0x83, 0x8e, 0xaa,
+	0x6e, 0xf1, 0xc8, 0x22, 0xb0, 0x3f, 0x60, 0xf2, 0x94, 0x52, 0x1e, 0x07, 0x32, 0x35, 0x5d, 0x40,
+	0xe5, 0x74, 0x3c, 0x16, 0x2c, 0x8a, 0x94, 0xa1, 0xde, 0x3f, 0x59, 0x5c, 0x1e, 0xde, 0xfa, 0x73,
+	0x79, 0xf8, 0xa8, 0x30, 0xff, 0x74, 0x1e, 0x32, 0xe1, 0xb3, 0xf1, 0x84, 0x09, 0x67, 0x14, 0x0b,
+	0xc1, 0x7f, 0x38, 0x54, 0xcc, 0x43, 0xc9, 0x6d, 0xed, 0x75, 0xb3, 0x22, 0xd6, 0x03, 0x38, 0x78,
+	0xe7, 0x45, 0x59, 0x0f, 0x3d, 0x59, 0x13, 0x6e, 0x7f, 0x48, 0x2e, 0x45, 0xcf, 0x94, 0x26, 0x96,
+	0x05, 0xf5, 0x01, 0x93, 0x17, 0x64, 0xc6, 0x52, 0x15, 0x86, 0xdd, 0x24, 0xd1, 0x22, 0x15, 0x5b,
+	0x5d, 0x68, 0x24, 0xe5, 0x92, 0x78, 0x6b, 0xad, 0x17, 0xd0, 0x1c, 0x30, 0xf9, 0x31, 0xbb, 0xab,
+	0x21, 0xd3, 0xbf, 0xd7, 0x85, 0xc6, 0x79, 0x40, 0xfd, 0x78, 0xcc, 0xde, 0x78, 0x91, 0xe4, 0xda,
+	0xb6, 0xe7, 0x5e, 0x3b, 0xb5, 0x7e, 0x22, 0xa8, 0x17, 0xdd, 0xb8, 0x05, 0xe5, 0x29, 0xf3, 0x26,
+	0x53, 0xa9, 0x0c, 0xbb, 0xae, 0xce, 0x70, 0x17, 0x4a, 0x43, 0x26, 0xdb, 0x3b, 0x9d, 0xd2, 0x51,
+	0xad, 0xd7, 0xb4, 0xf3, 0xd7, 0x59, 0xb9, 0xdd, 0x44, 0x80, 0x9f, 0x41, 0x25, 0xeb, 0x58, 0x52,
+	0xda, 0xfb, 0xf6, 0x0a, 0x95, 0x62, 0xa3, 0x57, 0xcc, 0x97, 0x24, 0x72, 0x33, 0xb1, 0xf5, 0x16,
+	0xf0, 0xe6, 0x67, 0x7c, 0x02, 0xb0, 0x3a, 0x8d, 0xb6, 0x36, 0x2f, 0xe8, 0x7a, 0xff, 0x76, 0xf4,
+	0x5d, 0xe1, 0x1e, 0x94, 0x53, 0x52, 0xf0, 0x9d, 0x7c, 0x8c, 0x02, 0x3b, 0xc6, 0x41, 0x72, 0x6c,
+	0xbb, 0x2c, 0x8a, 0x7d, 0xa9, 0x95, 0xcf, 0x01, 0x72, 0x58, 0xf0, 0xdd, 0xdc, 0x77, 0x0d, 0x21,
+	0xa3, 0x69, 0x27, 0xb8, 0x9e, 0xf1, 0x80, 0x0a, 0x26, 0x59, 0x66, 0x38, 0x83, 0x7a, 0x11, 0x04,
+	0x7c, 0x2f, 0x2f, 0xb0, 0x01, 0xc8, 0xcd, 0x25, 0x8e, 0x11, 0x76, 0xa0, 0xa2, 0x11, 0xc1, 0xad,
+	0xb5, 0x01, 0x56, 0xd4, 0x18, 0x75, 0x3b, 0xdd, 0x9c, 0xd7, 0x81, 0x14, 0x73, 0xfc, 0x14, 0xaa,
+	0x2b, 0x5e, 0x70, 0x7b, 0xbd, 0x65, 0x0e, 0xd1, 0xba, 0xe9, 0x18, 0xe1, 0x73, 0xb5, 0x18, 0x6b,
+	0x00, 0x98, 0x6b, 0xfd, 0x36, 0xc8, 0x32, 0x5a, 0x37, 0xbf, 0x67, 0xff, 0xe5, 0x62, 0x69, 0xa2,
+	0xdf, 0x4b, 0x13, 0xfd, 0x5d, 0x9a, 0xe8, 0xd7, 0x95, 0x89, 0x16, 0x57, 0x26, 0xfa, 0xfc, 0x70,
+	0xfb, 0x36, 0x89, 0x90, 0x3a, 0x59, 0xb9, 0x51, 0x59, 0x6d, 0xf7, 0x93, 0xff, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0xb5, 0xb5, 0x70, 0xe2, 0x5c, 0x04, 0x00, 0x00,
 }
diff --git a/rpc/service.go b/rpc/service.go
index 3c266ad257c5576ff0136dfe80c673e2feec43c5..031a5f33ab076dfc31f543ca9b10d16995e75004 100644
--- a/rpc/service.go
+++ b/rpc/service.go
@@ -91,31 +91,8 @@ func (s *Service) ListUnconfirmedTxs(maxTxs int) (*ResultListUnconfirmedTxs, err
 	}, nil
 }
 
-func (s *Service) Status() (*ResultStatus, error) {
-	latestHeight := s.blockchain.LastBlockHeight()
-	var (
-		latestBlockMeta *tmTypes.BlockMeta
-		latestBlockHash []byte
-		latestBlockTime int64
-	)
-	if latestHeight != 0 {
-		latestBlockMeta = s.nodeView.BlockStore().LoadBlockMeta(int64(latestHeight))
-		latestBlockHash = latestBlockMeta.Header.Hash()
-		latestBlockTime = latestBlockMeta.Header.Time.UnixNano()
-	}
-	publicKey, err := s.nodeView.PrivValidatorPublicKey()
-	if err != nil {
-		return nil, err
-	}
-	return &ResultStatus{
-		NodeInfo:          s.nodeView.NodeInfo(),
-		GenesisHash:       s.blockchain.GenesisHash(),
-		PublicKey:         publicKey,
-		LatestBlockHash:   latestBlockHash,
-		LatestBlockHeight: latestHeight,
-		LatestBlockTime:   latestBlockTime,
-		NodeVersion:       project.History.CurrentVersion().String(),
-	}, nil
+func (s *Service) Status(blockWithin string) (*ResultStatus, error) {
+	return Status(s.BlockchainInfo(), s.nodeView, blockWithin)
 }
 
 func (s *Service) ChainIdentifiers() (*ResultChainId, error) {
@@ -130,7 +107,7 @@ func (s *Service) Peers() (*ResultPeers, error) {
 	peers := make([]*Peer, s.nodeView.Peers().Size())
 	for i, peer := range s.nodeView.Peers().List() {
 		peers[i] = &Peer{
-			NodeInfo:   peer.NodeInfo(),
+			NodeInfo:   tendermint.NewNodeInfo(peer.NodeInfo()),
 			IsOutbound: peer.IsOutbound(),
 		}
 	}
@@ -355,11 +332,16 @@ func (s *Service) GeneratePrivateAccount() (*ResultGeneratePrivateAccount, error
 	}, nil
 }
 
-func (s *Service) LastBlockInfo(blockWithin string) (*ResultLastBlockInfo, error) {
-	res := &ResultLastBlockInfo{
-		LastBlockHeight: s.blockchain.LastBlockHeight(),
-		LastBlockHash:   s.blockchain.LastBlockHash(),
-		LastBlockTime:   s.blockchain.LastBlockTime(),
+func Status(blockchain bcm.BlockchainInfo, nodeView *tendermint.NodeView, blockWithin string) (*ResultStatus, error) {
+	res := &ResultStatus{
+		ChainID:           blockchain.ChainID(),
+		NodeInfo:          nodeView.NodeInfo(),
+		NodeVersion:       project.History.CurrentVersion().String(),
+		GenesisHash:       blockchain.GenesisHash(),
+		PublicKey:         nodeView.ValidatorPublicKey(),
+		LatestBlockHash:   blockchain.LastBlockHash(),
+		LatestBlockHeight: blockchain.LastBlockHeight(),
+		LatestBlockTime:   blockchain.LastBlockTime(),
 	}
 	if blockWithin == "" {
 		return res, nil
@@ -368,12 +350,12 @@ func (s *Service) LastBlockInfo(blockWithin string) (*ResultLastBlockInfo, error
 	if err != nil {
 		return nil, fmt.Errorf("could not parse blockWithin duration to determine whether to throw error: %v", err)
 	}
-	// Take neg abs in case caller is counting backwards (not we add later)
+	// Take neg abs in case caller is counting backwards (note we later add the time since we normalise the duration to negative)
 	if duration > 0 {
 		duration = -duration
 	}
 	blockTimeThreshold := time.Now().Add(duration)
-	if res.LastBlockTime.After(blockTimeThreshold) {
+	if res.LatestBlockTime.After(blockTimeThreshold) {
 		// We've created blocks recently enough
 		return res, nil
 	}
@@ -381,6 +363,6 @@ func (s *Service) LastBlockInfo(blockWithin string) (*ResultLastBlockInfo, error
 	if err != nil {
 		resJSON = []byte("<error: could not marshal last block info>")
 	}
-	return nil, fmt.Errorf("no block committed within the last %s (cutoff: %s), last block info: %s",
+	return nil, fmt.Errorf("no block committed within the last %s (cutoff: %s), current status: %s",
 		blockWithin, blockTimeThreshold.Format(time.RFC3339), string(resJSON))
 }
diff --git a/rpc/tm/methods.go b/rpc/tm/methods.go
index e28e7d8626ad45c307e8fdd57fa3823eb857e2ad..6732aa66b4c15e7b8d1650dd231a0fb300970d8d 100644
--- a/rpc/tm/methods.go
+++ b/rpc/tm/methods.go
@@ -11,7 +11,7 @@ import (
 
 // Method names
 const (
-	// Status
+	// Status and healthcheck
 	Status  = "status"
 	NetInfo = "net_info"
 
@@ -44,16 +44,13 @@ const (
 	// Private keys and signing
 	GeneratePrivateAccount = "unsafe/gen_priv_account"
 	SignTx                 = "unsafe/sign_tx"
-
-	// Health check
-	LastBlockInfo = "last_block_info"
 )
 
 func GetRoutes(service *rpc.Service, logger *logging.Logger) map[string]*server.RPCFunc {
 	logger = logger.WithScope("GetRoutes")
 	return map[string]*server.RPCFunc{
 		// Status
-		Status:  server.NewRPCFunc(service.Status, ""),
+		Status:  server.NewRPCFunc(service.Status, "block_within"),
 		NetInfo: server.NewRPCFunc(service.NetInfo, ""),
 
 		// Accounts
@@ -85,7 +82,6 @@ func GetRoutes(service *rpc.Service, logger *logging.Logger) map[string]*server.
 
 		// Private account
 		GeneratePrivateAccount: server.NewRPCFunc(service.GeneratePrivateAccount, ""),
-		LastBlockInfo:          server.NewRPCFunc(service.LastBlockInfo, "block_within"),
 	}
 }