protocol

type Acceptance struct {
	Accepted bool `protobuf:"varint,1,opt,name=accepted,proto3" json:"accepted,omitempty"`
	// contains filtered or unexported fields
}

type AstrisV1Client interface {
	// this is for announcing and managing peers.
	PeerExchange(ctx context.Context, in *Peer, opts ...grpc.CallOption) (AstrisV1_PeerExchangeClient, error)
	// this is the connection we open to receive blocks
	// we only have a receive function. If other peers
	// want blocks from us, they must call RecieveBlocks
	// to open the channel
	// the client should immediately send it's current "HEAD"
	// block header, from which the client can decide whether
	// to ask for more blocks, or ignore this peer
	RecvBlocks(ctx context.Context, in *Empty, opts ...grpc.CallOption) (AstrisV1_RecvBlocksClient, error)
	// recieve a specific block from the peer, if they have it
	// this can be used to populate your chain
	// addressed.
	GetBlock(ctx context.Context, in *BlockID, opts ...grpc.CallOption) (*FullBlock, error)
	// this can be used to fetch a stream of blocks starting at the given one
	// if the peer doesn't recognise the starting block, it should bail.
	// if the client doesn't recieve a valid ordered sequence of blocks,
	// it should bail. This is used to "fast-forward" a client.
	FromBlock(ctx context.Context, in *BlockID, opts ...grpc.CallOption) (AstrisV1_FromBlockClient, error)
	// This method is used to find the largest depth common block
	// between two divergent chains
	AtDepth(ctx context.Context, in *Depth, opts ...grpc.CallOption) (*BlockID, error)
	// Publish a block onto the chain, to allow us to "push" blocks to a node we have connected to
	// If they have connected to us, we can just use their RecvBlocks to deliver. This is designed
	// for the clients that wish to connect and publish rather than participate in the full mesh
	PublishBlock(ctx context.Context, in *FullBlock, opts ...grpc.CallOption) (*Acceptance, error)
}

type AstrisV1Server interface {
	// this is for announcing and managing peers.
	PeerExchange(*Peer, AstrisV1_PeerExchangeServer) error
	// this is the connection we open to receive blocks
	// we only have a receive function. If other peers
	// want blocks from us, they must call RecieveBlocks
	// to open the channel
	// the client should immediately send it's current "HEAD"
	// block header, from which the client can decide whether
	// to ask for more blocks, or ignore this peer
	RecvBlocks(*Empty, AstrisV1_RecvBlocksServer) error
	// recieve a specific block from the peer, if they have it
	// this can be used to populate your chain
	// addressed.
	GetBlock(context.Context, *BlockID) (*FullBlock, error)
	// this can be used to fetch a stream of blocks starting at the given one
	// if the peer doesn't recognise the starting block, it should bail.
	// if the client doesn't recieve a valid ordered sequence of blocks,
	// it should bail. This is used to "fast-forward" a client.
	FromBlock(*BlockID, AstrisV1_FromBlockServer) error
	// This method is used to find the largest depth common block
	// between two divergent chains
	AtDepth(context.Context, *Depth) (*BlockID, error)
	// Publish a block onto the chain, to allow us to "push" blocks to a node we have connected to
	// If they have connected to us, we can just use their RecvBlocks to deliver. This is designed
	// for the clients that wish to connect and publish rather than participate in the full mesh
	PublishBlock(context.Context, *FullBlock) (*Acceptance, error)
	// contains filtered or unexported methods
}

type AstrisV1_FromBlockClient interface {
	Recv() (*FullBlock, error)
	grpc.ClientStream
}

type AstrisV1_FromBlockServer interface {
	Send(*FullBlock) error
	grpc.ServerStream
}

type AstrisV1_PeerExchangeClient interface {
	Recv() (*Peer, error)
	grpc.ClientStream
}

type AstrisV1_PeerExchangeServer interface {
	Send(*Peer) error
	grpc.ServerStream
}

type AstrisV1_RecvBlocksClient interface {
	Recv() (*BlockHeader, error)
	grpc.ClientStream
}

type AstrisV1_RecvBlocksServer interface {
	Send(*BlockHeader) error
	grpc.ServerStream
}

type BlockHeader struct {
	PrevId      []byte `protobuf:"bytes,1,opt,name=prev_id,json=prevId,proto3" json:"prev_id,omitempty"`
	PayloadHash []byte `protobuf:"bytes,2,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"` // this should match the payload
	Timestamp   uint32 `protobuf:"fixed32,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`                      // unix timestamp of block creation
	Proof       uint32 `protobuf:"fixed32,4,opt,name=proof,proto3" json:"proof,omitempty"`                              // proof of work
	Depth       uint64 `protobuf:"varint,5,opt,name=depth,proto3" json:"depth,omitempty"`                               // block height or chain depth
	Kind        uint32 `protobuf:"varint,6,opt,name=kind,proto3" json:"kind,omitempty"`
	// contains filtered or unexported fields
}

type BlockID struct {

	// our block hashes are SHA256 which means 32bytes or 4x64bit values.
	// using the "bytes" value is rubbish as it can be 2^32 long.
	// there is no fixed length possible. We will have to do the validation
	// outside the protobuf code.
	// fortunately the GRPC code has a MaxMessageSize so we can limit the damage.
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// contains filtered or unexported fields
}

type Depth struct {
	Depth uint64 `protobuf:"fixed64,1,opt,name=depth,proto3" json:"depth,omitempty"`
	// contains filtered or unexported fields
}

type Empty struct {
	// contains filtered or unexported fields
}

type FullBlock struct {
	Header  *BlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	Payload []byte       `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	// contains filtered or unexported fields
}

type Peer struct {
	Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// contains filtered or unexported fields
}

type Server struct {
	UnimplementedAstrisV1Server
	// contains filtered or unexported fields
}

type UnimplementedAstrisV1Server struct {
}

type UnsafeAstrisV1Server interface {
	// contains filtered or unexported methods
}