Piecestore proto change (#556)

* add action and storage node id to piecestore.proto. renamed payer and renter to satellite_id and uplink_id

examples/piecestore-client/main.go

@@ -13,10 +13,12 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/spf13/cobra"
 	"github.com/zeebo/errs"
 	"google.golang.org/grpc"
 
+	"storj.io/storj/pkg/node"
 	"storj.io/storj/pkg/pb"
 	"storj.io/storj/pkg/piecestore/rpc/client"
 	"storj.io/storj/pkg/provider"
@@ -49,7 +51,9 @@ func main() {
 	}
 	defer printError(conn.Close)
 
-	psClient, err := client.NewPSClient(conn, 1024*32, identity.Key.(*ecdsa.PrivateKey))
+	nodeID := node.IDFromString("test-node-id-1234567")
+
+	psClient, err := client.NewPSClient(conn, nodeID, 1024*32, identity.Key.(*ecdsa.PrivateKey))
 	if err != nil {
 		log.Fatalf("could not initialize PSClient: %s", err)
 	}
@@ -91,7 +95,20 @@ func main() {
 
 			id := client.NewPieceID()
 
-			if err := psClient.Put(context.Background(), id, dataSection, ttl, &pb.PayerBandwidthAllocation{}, nil); err != nil {
+			allocationData := &pb.PayerBandwidthAllocation_Data{
+				Action: pb.PayerBandwidthAllocation_PUT,
+			}
+		
+			serializedAllocation, err := proto.Marshal(allocationData)
+			if err != nil {
+				return err
+			}
+		
+			pba := &pb.PayerBandwidthAllocation{
+				Data: serializedAllocation,
+			}
+
+			if err := psClient.Put(context.Background(), id, dataSection, ttl, pba, nil); err != nil {
 				fmt.Printf("Failed to Store data of id: %s\n", id)
 				return err
 			}
@@ -140,7 +157,20 @@ func main() {
 				return err
 			}
 
-			rr, err := psClient.Get(ctx, client.PieceID(id), pieceInfo.Size, &pb.PayerBandwidthAllocation{}, nil)
+			allocationData := &pb.PayerBandwidthAllocation_Data{
+				Action: pb.PayerBandwidthAllocation_GET,
+			}
+		
+			serializedAllocation, err := proto.Marshal(allocationData)
+			if err != nil {
+				return err
+			}
+		
+			pba := &pb.PayerBandwidthAllocation{
+				Data: serializedAllocation,
+			}
+
+			rr, err := psClient.Get(ctx, client.PieceID(id), pieceInfo.Size, pba, nil)
 			if err != nil {
 				fmt.Printf("Failed to retrieve file of id: %s\n", id)
 				errRemove := os.Remove(outputDir)

pkg/audit/verifier.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"io"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/vivint/infectious"
 	monkit "gopkg.in/spacemonkeygo/monkit.v2"
 
@@ -17,7 +18,7 @@ import (
 	"storj.io/storj/pkg/pb"
 	"storj.io/storj/pkg/piecestore/rpc/client"
 	"storj.io/storj/pkg/provider"
-	proto "storj.io/storj/pkg/statdb/proto"
+	sdbproto "storj.io/storj/pkg/statdb/proto"
 	"storj.io/storj/pkg/transport"
 )
 
@@ -56,13 +57,13 @@ func NewVerifier(transport transport.Client, overlay overlay.Client, id provider
 	return &Verifier{downloader: newDefaultDownloader(transport, overlay, id)}
 }
 
-func (d *defaultDownloader) dial(ctx context.Context, node *pb.Node) (ps client.PSClient, err error) {
+func (d *defaultDownloader) dial(ctx context.Context, storageNode *pb.Node) (ps client.PSClient, err error) {
 	defer mon.Task()(&ctx)(&err)
-	c, err := d.transport.DialNode(ctx, node)
+	c, err := d.transport.DialNode(ctx, storageNode)
 	if err != nil {
 		return nil, err
 	}
-	return client.NewPSClient(c, 0, d.identity.Key)
+	return client.NewPSClient(c, node.IDFromString(storageNode.GetId()), 0, d.identity.Key)
 }
 
 // getShare use piece store clients to download shares from a given node
@@ -80,7 +81,20 @@ func (d *defaultDownloader) getShare(ctx context.Context, stripeIndex, shareSize
 		return s, err
 	}
 
-	rr, err := ps.Get(ctx, derivedPieceID, pieceSize, &pb.PayerBandwidthAllocation{}, authorization)
+	allocationData := &pb.PayerBandwidthAllocation_Data{
+		Action: pb.PayerBandwidthAllocation_GET,
+	}
+
+	serializedAllocation, err := proto.Marshal(allocationData)
+	if err != nil {
+		return s, err
+	}
+
+	pba := &pb.PayerBandwidthAllocation{
+		Data: serializedAllocation,
+	}
+
+	rr, err := ps.Get(ctx, derivedPieceID, pieceSize, pba, authorization)
 	if err != nil {
 		return s, err
 	}
@@ -197,7 +211,7 @@ func calcPadded(size int64, blockSize int) int64 {
 }
 
 // verify downloads shares then verifies the data correctness at the given stripe
-func (verifier *Verifier) verify(ctx context.Context, stripeIndex int, pointer *pb.Pointer, authorization *pb.SignedMessage) (verifiedNodes []*proto.Node, err error) {
+func (verifier *Verifier) verify(ctx context.Context, stripeIndex int, pointer *pb.Pointer, authorization *pb.SignedMessage) (verifiedNodes []*sdbproto.Node, err error) {
 	defer mon.Task()(&ctx)(&err)
 
 	shares, nodes, err := verifier.downloader.DownloadShares(ctx, pointer, stripeIndex, authorization)
@@ -249,7 +263,7 @@ func getSuccessNodes(ctx context.Context, nodes []*pb.Node, failedNodes, offline
 }
 
 // setVerifiedNodes creates a combined array of offline nodes, failed audit nodes, and success nodes with their stats set to the statdb proto Node type
-func setVerifiedNodes(ctx context.Context, nodes []*pb.Node, offlineNodes, failedNodes, successNodes []string) (verifiedNodes []*proto.Node) {
+func setVerifiedNodes(ctx context.Context, nodes []*pb.Node, offlineNodes, failedNodes, successNodes []string) (verifiedNodes []*sdbproto.Node) {
 	offlineStatusNodes := setOfflineStatus(ctx, offlineNodes)
 	failStatusNodes := setAuditFailStatus(ctx, failedNodes)
 	successStatusNodes := setSuccessStatus(ctx, successNodes)

pkg/pb/piecestore.pb.go

@@ -23,6 +23,29 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+type PayerBandwidthAllocation_Action int32
+
+const (
+	PayerBandwidthAllocation_PUT PayerBandwidthAllocation_Action = 0
+	PayerBandwidthAllocation_GET PayerBandwidthAllocation_Action = 1
+)
+
+var PayerBandwidthAllocation_Action_name = map[int32]string{
+	0: "PUT",
+	1: "GET",
+}
+var PayerBandwidthAllocation_Action_value = map[string]int32{
+	"PUT": 0,
+	"GET": 1,
+}
+
+func (x PayerBandwidthAllocation_Action) String() string {
+	return proto.EnumName(PayerBandwidthAllocation_Action_name, int32(x))
+}
+func (PayerBandwidthAllocation_Action) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{0, 0}
+}
+
 type PayerBandwidthAllocation struct {
 	Signature            []byte   `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
 	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
@@ -35,7 +58,7 @@ func (m *PayerBandwidthAllocation) Reset()         { *m = PayerBandwidthAllocati
 func (m *PayerBandwidthAllocation) String() string { return proto.CompactTextString(m) }
 func (*PayerBandwidthAllocation) ProtoMessage()    {}
 func (*PayerBandwidthAllocation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{0}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{0}
 }
 func (m *PayerBandwidthAllocation) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PayerBandwidthAllocation.Unmarshal(m, b)
@@ -70,11 +93,12 @@ func (m *PayerBandwidthAllocation) GetData() []byte {
 }
 
 type PayerBandwidthAllocation_Data struct {
-	Payer                []byte   `protobuf:"bytes,1,opt,name=payer,proto3" json:"payer,omitempty"`
-	Renter               []byte   `protobuf:"bytes,2,opt,name=renter,proto3" json:"renter,omitempty"`
+	SatelliteId          []byte                          `protobuf:"bytes,1,opt,name=satellite_id,json=satelliteId,proto3" json:"satellite_id,omitempty"`
+	UplinkId             []byte                          `protobuf:"bytes,2,opt,name=uplink_id,json=uplinkId,proto3" json:"uplink_id,omitempty"`
 	MaxSize              int64                           `protobuf:"varint,3,opt,name=max_size,json=maxSize,proto3" json:"max_size,omitempty"`
 	ExpirationUnixSec    int64                           `protobuf:"varint,4,opt,name=expiration_unix_sec,json=expirationUnixSec,proto3" json:"expiration_unix_sec,omitempty"`
 	SerialNumber         string                          `protobuf:"bytes,5,opt,name=serial_number,json=serialNumber,proto3" json:"serial_number,omitempty"`
+	Action               PayerBandwidthAllocation_Action `protobuf:"varint,6,opt,name=action,proto3,enum=piecestoreroutes.PayerBandwidthAllocation_Action" json:"action,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
 	XXX_unrecognized     []byte                          `json:"-"`
 	XXX_sizecache        int32                           `json:"-"`
@@ -84,7 +108,7 @@ func (m *PayerBandwidthAllocation_Data) Reset()         { *m = PayerBandwidthAll
 func (m *PayerBandwidthAllocation_Data) String() string { return proto.CompactTextString(m) }
 func (*PayerBandwidthAllocation_Data) ProtoMessage()    {}
 func (*PayerBandwidthAllocation_Data) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{0, 0}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{0, 0}
 }
 func (m *PayerBandwidthAllocation_Data) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PayerBandwidthAllocation_Data.Unmarshal(m, b)
@@ -104,16 +128,16 @@ func (m *PayerBandwidthAllocation_Data) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_PayerBandwidthAllocation_Data proto.InternalMessageInfo
 
-func (m *PayerBandwidthAllocation_Data) GetPayer() []byte {
+func (m *PayerBandwidthAllocation_Data) GetSatelliteId() []byte {
 	if m != nil {
-		return m.Payer
+		return m.SatelliteId
 	}
 	return nil
 }
 
-func (m *PayerBandwidthAllocation_Data) GetRenter() []byte {
+func (m *PayerBandwidthAllocation_Data) GetUplinkId() []byte {
 	if m != nil {
-		return m.Renter
+		return m.UplinkId
 	}
 	return nil
 }
@@ -139,6 +163,13 @@ func (m *PayerBandwidthAllocation_Data) GetSerialNumber() string {
 	return ""
 }
 
+func (m *PayerBandwidthAllocation_Data) GetAction() PayerBandwidthAllocation_Action {
+	if m != nil {
+		return m.Action
+	}
+	return PayerBandwidthAllocation_PUT
+}
+
 type RenterBandwidthAllocation struct {
 	Signature            []byte   `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
 	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
@@ -151,7 +182,7 @@ func (m *RenterBandwidthAllocation) Reset()         { *m = RenterBandwidthAlloca
 func (m *RenterBandwidthAllocation) String() string { return proto.CompactTextString(m) }
 func (*RenterBandwidthAllocation) ProtoMessage()    {}
 func (*RenterBandwidthAllocation) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{1}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{1}
 }
 func (m *RenterBandwidthAllocation) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RenterBandwidthAllocation.Unmarshal(m, b)
@@ -188,6 +219,7 @@ func (m *RenterBandwidthAllocation) GetData() []byte {
 type RenterBandwidthAllocation_Data struct {
 	PayerAllocation      *PayerBandwidthAllocation `protobuf:"bytes,1,opt,name=payer_allocation,json=payerAllocation,proto3" json:"payer_allocation,omitempty"`
 	Total                int64                     `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`
+	StorageNodeId        []byte                    `protobuf:"bytes,3,opt,name=storage_node_id,json=storageNodeId,proto3" json:"storage_node_id,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
 	XXX_unrecognized     []byte                    `json:"-"`
 	XXX_sizecache        int32                     `json:"-"`
@@ -197,7 +229,7 @@ func (m *RenterBandwidthAllocation_Data) Reset()         { *m = RenterBandwidthA
 func (m *RenterBandwidthAllocation_Data) String() string { return proto.CompactTextString(m) }
 func (*RenterBandwidthAllocation_Data) ProtoMessage()    {}
 func (*RenterBandwidthAllocation_Data) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{1, 0}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{1, 0}
 }
 func (m *RenterBandwidthAllocation_Data) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RenterBandwidthAllocation_Data.Unmarshal(m, b)
@@ -231,6 +263,13 @@ func (m *RenterBandwidthAllocation_Data) GetTotal() int64 {
 	return 0
 }
 
+func (m *RenterBandwidthAllocation_Data) GetStorageNodeId() []byte {
+	if m != nil {
+		return m.StorageNodeId
+	}
+	return nil
+}
+
 type PieceStore struct {
 	Bandwidthallocation  *RenterBandwidthAllocation `protobuf:"bytes,1,opt,name=bandwidthallocation,proto3" json:"bandwidthallocation,omitempty"`
 	Piecedata            *PieceStore_PieceData      `protobuf:"bytes,2,opt,name=piecedata,proto3" json:"piecedata,omitempty"`
@@ -244,7 +283,7 @@ func (m *PieceStore) Reset()         { *m = PieceStore{} }
 func (m *PieceStore) String() string { return proto.CompactTextString(m) }
 func (*PieceStore) ProtoMessage()    {}
 func (*PieceStore) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{2}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{2}
 }
 func (m *PieceStore) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceStore.Unmarshal(m, b)
@@ -298,7 +337,7 @@ func (m *PieceStore_PieceData) Reset()         { *m = PieceStore_PieceData{} }
 func (m *PieceStore_PieceData) String() string { return proto.CompactTextString(m) }
 func (*PieceStore_PieceData) ProtoMessage()    {}
 func (*PieceStore_PieceData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{2, 0}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{2, 0}
 }
 func (m *PieceStore_PieceData) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceStore_PieceData.Unmarshal(m, b)
@@ -351,7 +390,7 @@ func (m *PieceId) Reset()         { *m = PieceId{} }
 func (m *PieceId) String() string { return proto.CompactTextString(m) }
 func (*PieceId) ProtoMessage()    {}
 func (*PieceId) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{3}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{3}
 }
 func (m *PieceId) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceId.Unmarshal(m, b)
@@ -398,7 +437,7 @@ func (m *PieceSummary) Reset()         { *m = PieceSummary{} }
 func (m *PieceSummary) String() string { return proto.CompactTextString(m) }
 func (*PieceSummary) ProtoMessage()    {}
 func (*PieceSummary) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{4}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{4}
 }
 func (m *PieceSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceSummary.Unmarshal(m, b)
@@ -452,7 +491,7 @@ func (m *PieceRetrieval) Reset()         { *m = PieceRetrieval{} }
 func (m *PieceRetrieval) String() string { return proto.CompactTextString(m) }
 func (*PieceRetrieval) ProtoMessage()    {}
 func (*PieceRetrieval) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{5}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{5}
 }
 func (m *PieceRetrieval) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceRetrieval.Unmarshal(m, b)
@@ -506,7 +545,7 @@ func (m *PieceRetrieval_PieceData) Reset()         { *m = PieceRetrieval_PieceDa
 func (m *PieceRetrieval_PieceData) String() string { return proto.CompactTextString(m) }
 func (*PieceRetrieval_PieceData) ProtoMessage()    {}
 func (*PieceRetrieval_PieceData) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{5, 0}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{5, 0}
 }
 func (m *PieceRetrieval_PieceData) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceRetrieval_PieceData.Unmarshal(m, b)
@@ -559,7 +598,7 @@ func (m *PieceRetrievalStream) Reset()         { *m = PieceRetrievalStream{} }
 func (m *PieceRetrievalStream) String() string { return proto.CompactTextString(m) }
 func (*PieceRetrievalStream) ProtoMessage()    {}
 func (*PieceRetrievalStream) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{6}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{6}
 }
 func (m *PieceRetrievalStream) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceRetrievalStream.Unmarshal(m, b)
@@ -605,7 +644,7 @@ func (m *PieceDelete) Reset()         { *m = PieceDelete{} }
 func (m *PieceDelete) String() string { return proto.CompactTextString(m) }
 func (*PieceDelete) ProtoMessage()    {}
 func (*PieceDelete) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{7}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{7}
 }
 func (m *PieceDelete) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceDelete.Unmarshal(m, b)
@@ -650,7 +689,7 @@ func (m *PieceDeleteSummary) Reset()         { *m = PieceDeleteSummary{} }
 func (m *PieceDeleteSummary) String() string { return proto.CompactTextString(m) }
 func (*PieceDeleteSummary) ProtoMessage()    {}
 func (*PieceDeleteSummary) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{8}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{8}
 }
 func (m *PieceDeleteSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceDeleteSummary.Unmarshal(m, b)
@@ -689,7 +728,7 @@ func (m *PieceStoreSummary) Reset()         { *m = PieceStoreSummary{} }
 func (m *PieceStoreSummary) String() string { return proto.CompactTextString(m) }
 func (*PieceStoreSummary) ProtoMessage()    {}
 func (*PieceStoreSummary) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{9}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{9}
 }
 func (m *PieceStoreSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceStoreSummary.Unmarshal(m, b)
@@ -733,7 +772,7 @@ func (m *StatsReq) Reset()         { *m = StatsReq{} }
 func (m *StatsReq) String() string { return proto.CompactTextString(m) }
 func (*StatsReq) ProtoMessage()    {}
 func (*StatsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{10}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{10}
 }
 func (m *StatsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatsReq.Unmarshal(m, b)
@@ -767,7 +806,7 @@ func (m *StatSummary) Reset()         { *m = StatSummary{} }
 func (m *StatSummary) String() string { return proto.CompactTextString(m) }
 func (*StatSummary) ProtoMessage()    {}
 func (*StatSummary) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{11}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{11}
 }
 func (m *StatSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatSummary.Unmarshal(m, b)
@@ -828,7 +867,7 @@ func (m *SignedMessage) Reset()         { *m = SignedMessage{} }
 func (m *SignedMessage) String() string { return proto.CompactTextString(m) }
 func (*SignedMessage) ProtoMessage()    {}
 func (*SignedMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_13a9a597c2abd9cf, []int{12}
+	return fileDescriptor_piecestore_f59ad3d0b0de7e9d, []int{12}
 }
 func (m *SignedMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignedMessage.Unmarshal(m, b)
@@ -887,6 +926,7 @@ func init() {
 	proto.RegisterType((*StatsReq)(nil), "piecestoreroutes.StatsReq")
 	proto.RegisterType((*StatSummary)(nil), "piecestoreroutes.StatSummary")
 	proto.RegisterType((*SignedMessage)(nil), "piecestoreroutes.SignedMessage")
+	proto.RegisterEnum("piecestoreroutes.PayerBandwidthAllocation_Action", PayerBandwidthAllocation_Action_name, PayerBandwidthAllocation_Action_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1160,57 +1200,62 @@ var _PieceStoreRoutes_serviceDesc = grpc.ServiceDesc{
 	Metadata: "piecestore.proto",
 }
 
-func init() { proto.RegisterFile("piecestore.proto", fileDescriptor_piecestore_13a9a597c2abd9cf) }
+func init() { proto.RegisterFile("piecestore.proto", fileDescriptor_piecestore_f59ad3d0b0de7e9d) }
 
-var fileDescriptor_piecestore_13a9a597c2abd9cf = []byte{
-	// 782 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x5d, 0x4e, 0xe3, 0x48,
-	0x10, 0xc6, 0xce, 0x1f, 0xa9, 0x24, 0x2c, 0x34, 0x08, 0x19, 0x2b, 0xec, 0x46, 0x06, 0xa1, 0x88,
-	0x95, 0xa2, 0x15, 0x7b, 0x82, 0x45, 0x59, 0xed, 0xa2, 0xd5, 0x32, 0xa8, 0x2d, 0x5e, 0x90, 0x46,
-	0x99, 0x8e, 0x5d, 0x40, 0x4b, 0x8e, 0x9d, 0xb1, 0xdb, 0x4c, 0xe0, 0x2a, 0xf3, 0x3a, 0x2f, 0x73,
-	0x8d, 0x79, 0x9b, 0x53, 0xcc, 0x21, 0xe6, 0x02, 0x23, 0x77, 0x3b, 0x76, 0x42, 0xe2, 0x44, 0x42,
-	0xcc, 0x9b, 0xab, 0xaa, 0xeb, 0xab, 0xfa, 0x2a, 0x5f, 0x57, 0x07, 0xb6, 0xc7, 0x1c, 0x1d, 0x8c,
-	0x44, 0x10, 0x62, 0x6f, 0x1c, 0x06, 0x22, 0x20, 0x33, 0x9e, 0x30, 0x88, 0x05, 0x46, 0xd6, 0x77,
-	0x0d, 0x8c, 0x2b, 0xf6, 0x88, 0xe1, 0x39, 0xf3, 0xdd, 0x0f, 0xdc, 0x15, 0xf7, 0x7f, 0x79, 0x5e,
-	0xe0, 0x30, 0xc1, 0x03, 0x9f, 0xb4, 0xa1, 0x1e, 0xf1, 0x3b, 0x9f, 0x89, 0x38, 0x44, 0x43, 0xeb,
-	0x68, 0xdd, 0x26, 0xcd, 0x1d, 0x84, 0x40, 0xd9, 0x65, 0x82, 0x19, 0xba, 0x0c, 0xc8, 0x6f, 0xf3,
-	0x93, 0x06, 0xe5, 0x3e, 0x13, 0x8c, 0xec, 0x41, 0x65, 0x9c, 0xc0, 0xa6, 0x69, 0xca, 0x20, 0xfb,
-	0x50, 0x0d, 0xd1, 0x17, 0x18, 0xa6, 0x49, 0xa9, 0x45, 0x0e, 0x60, 0x73, 0xc4, 0x26, 0x83, 0x88,
-	0x3f, 0xa1, 0x51, 0xea, 0x68, 0xdd, 0x12, 0xad, 0x8d, 0xd8, 0xc4, 0xe6, 0x4f, 0x48, 0x7a, 0xb0,
-	0x8b, 0x93, 0x31, 0x0f, 0x65, 0x47, 0x83, 0xd8, 0xe7, 0x93, 0x41, 0x84, 0x8e, 0x51, 0x96, 0xa7,
-	0x76, 0xf2, 0xd0, 0xb5, 0xcf, 0x27, 0x36, 0x3a, 0xe4, 0x08, 0x5a, 0x11, 0x86, 0x9c, 0x79, 0x03,
-	0x3f, 0x1e, 0x0d, 0x31, 0x34, 0x2a, 0x1d, 0xad, 0x5b, 0xa7, 0x4d, 0xe5, 0xbc, 0x94, 0x3e, 0xeb,
-	0x8b, 0x06, 0x07, 0x54, 0x96, 0x7e, 0x1d, 0xda, 0x51, 0xca, 0xfa, 0x1a, 0xb6, 0x25, 0xd1, 0x01,
-	0xcb, 0xd0, 0x24, 0x40, 0xe3, 0xec, 0xb4, 0xf7, 0x7c, 0xf4, 0xbd, 0xa2, 0xb1, 0xd3, 0x5f, 0x24,
-	0xc6, 0x4c, 0x43, 0x7b, 0x50, 0x11, 0x81, 0x60, 0x9e, 0xac, 0x59, 0xa2, 0xca, 0xb0, 0xbe, 0xe9,
-	0x00, 0x57, 0x09, 0xa8, 0x9d, 0x80, 0x92, 0xb7, 0xb0, 0x3b, 0x9c, 0x82, 0x2d, 0x94, 0xff, 0x7d,
-	0xb1, 0x7c, 0x21, 0x7f, 0xba, 0x0c, 0x87, 0xf4, 0xa1, 0x2e, 0x21, 0x32, 0xee, 0x8d, 0xb3, 0x93,
-	0x25, 0x9c, 0xb2, 0x7e, 0xd4, 0x67, 0x32, 0x15, 0x9a, 0x27, 0x92, 0xbf, 0xa1, 0xc5, 0x62, 0x71,
-	0x1f, 0x84, 0xfc, 0x49, 0xb5, 0x57, 0x92, 0x48, 0xbf, 0x2d, 0x22, 0xd9, 0xfc, 0xce, 0x47, 0xf7,
-	0x7f, 0x8c, 0x22, 0x76, 0x87, 0x74, 0x3e, 0xcb, 0x44, 0xa8, 0x67, 0xf0, 0x64, 0x0b, 0x74, 0xee,
-	0x4a, 0x9e, 0x75, 0xaa, 0x73, 0xb7, 0x48, 0x31, 0x7a, 0x91, 0x62, 0x0c, 0xa8, 0x39, 0x81, 0x2f,
-	0xd0, 0x17, 0xb2, 0x9b, 0x26, 0x9d, 0x9a, 0xd6, 0x3b, 0xa8, 0xc9, 0x32, 0x17, 0xee, 0x42, 0x91,
-	0x05, 0x22, 0xfa, 0x4b, 0x88, 0x58, 0x43, 0x68, 0xaa, 0x91, 0xc5, 0xa3, 0x11, 0x0b, 0x1f, 0x17,
-	0xca, 0x10, 0x28, 0xcb, 0x4b, 0xa1, 0x9a, 0x97, 0xdf, 0x45, 0xfc, 0x4a, 0x05, 0xfc, 0xac, 0xaf,
-	0x3a, 0x6c, 0xc9, 0x22, 0x14, 0x45, 0xc8, 0xf1, 0x81, 0x79, 0x3f, 0x5b, 0x2b, 0xff, 0xa6, 0x5a,
-	0xe9, 0xe7, 0x5a, 0x39, 0x2d, 0xd0, 0x4a, 0xd6, 0xd3, 0x82, 0x5e, 0xfa, 0xaf, 0xa8, 0x97, 0x7f,
-	0x56, 0xe9, 0x65, 0xd9, 0x8c, 0xf7, 0xa1, 0x1a, 0xdc, 0xde, 0x46, 0x28, 0xd2, 0xb1, 0xa6, 0x96,
-	0xd5, 0x87, 0xbd, 0xf9, 0xb6, 0x6d, 0x11, 0x22, 0x1b, 0x65, 0x18, 0xda, 0x0c, 0xc6, 0x8c, 0xae,
-	0xf4, 0x79, 0x5d, 0xb9, 0xd0, 0x50, 0xed, 0xa0, 0x87, 0x02, 0xd7, 0x6b, 0xeb, 0x45, 0xa4, 0xad,
-	0x1e, 0x90, 0x99, 0x2a, 0x53, 0x85, 0x19, 0x50, 0x1b, 0xa9, 0xf3, 0x69, 0xc5, 0xa9, 0x69, 0xd9,
-	0xb0, 0x93, 0x5f, 0xdf, 0xb5, 0xc7, 0xc9, 0x31, 0xb4, 0xe4, 0x1e, 0xa2, 0xe8, 0x20, 0x7f, 0x40,
-	0x37, 0x9d, 0xdf, 0xbc, 0xd3, 0x02, 0xd8, 0xb4, 0x05, 0x13, 0x11, 0xc5, 0xf7, 0xd6, 0x67, 0x0d,
-	0x1a, 0x89, 0x31, 0xc5, 0x6e, 0x43, 0x3d, 0x8e, 0xd0, 0xb5, 0xc7, 0xcc, 0x99, 0x4e, 0x2e, 0x77,
-	0x90, 0x13, 0xd8, 0x62, 0x0f, 0x8c, 0x7b, 0x6c, 0xe8, 0xa1, 0x3a, 0xa2, 0x0a, 0x3c, 0xf3, 0x26,
-	0x7d, 0x24, 0x49, 0x99, 0x38, 0xd3, 0x5f, 0x6c, 0xde, 0x49, 0x7a, 0x40, 0xb2, 0xbc, 0xfc, 0xa8,
-	0x7a, 0x45, 0x96, 0x44, 0xac, 0x01, 0xb4, 0xe6, 0x86, 0x9b, 0xad, 0x7d, 0x2d, 0x5f, 0xfb, 0xf3,
-	0x0f, 0x85, 0xfe, 0xfc, 0xa1, 0x68, 0x43, 0x7d, 0x1c, 0x0f, 0x3d, 0xee, 0xfc, 0x87, 0x8f, 0xe9,
-	0x66, 0xc9, 0x1d, 0x67, 0x1f, 0x4b, 0xb0, 0x9d, 0x8f, 0x9b, 0xca, 0xdf, 0x93, 0xf4, 0xa1, 0x22,
-	0x7d, 0xe4, 0xa0, 0xe0, 0xba, 0x5c, 0xb8, 0xe6, 0xaf, 0x45, 0x5b, 0x57, 0x4d, 0xd5, 0xda, 0x20,
-	0x37, 0xb0, 0x99, 0xea, 0x13, 0x49, 0x67, 0xdd, 0xbd, 0x33, 0x4f, 0xd6, 0x9d, 0x50, 0x12, 0xb7,
-	0x36, 0xba, 0xda, 0x1f, 0x1a, 0xb9, 0x84, 0x8a, 0x7a, 0x6e, 0xda, 0xab, 0x96, 0xbf, 0x79, 0xb4,
-	0x2a, 0x9a, 0x75, 0xda, 0xd5, 0xc8, 0x1b, 0xa8, 0xa6, 0xb7, 0xe0, 0xb0, 0x20, 0x45, 0x85, 0xcd,
-	0xe3, 0x95, 0xe1, 0x9c, 0x7c, 0x3f, 0x69, 0x90, 0x89, 0x88, 0x98, 0x4b, 0xae, 0x4b, 0xaa, 0x44,
-	0xf3, 0x70, 0x79, 0x2c, 0x43, 0x39, 0x2f, 0xdf, 0xe8, 0xe3, 0xe1, 0xb0, 0x2a, 0xff, 0x35, 0xfd,
-	0xf9, 0x23, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x12, 0x90, 0xfa, 0x49, 0x09, 0x00, 0x00,
+var fileDescriptor_piecestore_f59ad3d0b0de7e9d = []byte{
+	// 862 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x51, 0x6e, 0xdb, 0x46,
+	0x10, 0x35, 0x29, 0x59, 0x32, 0x47, 0x96, 0xa3, 0x6c, 0x82, 0x82, 0x66, 0x9d, 0x56, 0x65, 0x02,
+	0x43, 0x48, 0x01, 0xa1, 0x75, 0x4f, 0x90, 0x40, 0x41, 0x2a, 0x14, 0x75, 0x0d, 0x32, 0xfe, 0x09,
+	0x50, 0xb0, 0x2b, 0xee, 0xc4, 0x59, 0x94, 0x22, 0x59, 0x72, 0xe9, 0xca, 0xfe, 0xeb, 0x39, 0x72,
+	0x82, 0x1e, 0xa5, 0xa7, 0xe8, 0x01, 0xda, 0x43, 0x14, 0xdc, 0x5d, 0x91, 0x92, 0x25, 0xda, 0x45,
+	0xe0, 0xfc, 0x71, 0x67, 0x76, 0xde, 0xbc, 0x79, 0x7a, 0xbb, 0x2b, 0x18, 0xa4, 0x1c, 0x43, 0xcc,
+	0x45, 0x92, 0xe1, 0x38, 0xcd, 0x12, 0x91, 0x90, 0x95, 0x48, 0x96, 0x14, 0x02, 0x73, 0xf7, 0x5f,
+	0x13, 0xec, 0x33, 0x7a, 0x85, 0xd9, 0x4b, 0x1a, 0xb3, 0xdf, 0x39, 0x13, 0xef, 0x5f, 0x44, 0x51,
+	0x12, 0x52, 0xc1, 0x93, 0x98, 0x1c, 0x81, 0x95, 0xf3, 0x8b, 0x98, 0x8a, 0x22, 0x43, 0xdb, 0x18,
+	0x1a, 0xa3, 0x7d, 0xaf, 0x0e, 0x10, 0x02, 0x6d, 0x46, 0x05, 0xb5, 0x4d, 0x99, 0x90, 0xdf, 0xce,
+	0x1f, 0x26, 0xb4, 0x27, 0x54, 0x50, 0xf2, 0x15, 0xec, 0xe7, 0x54, 0x60, 0x14, 0x71, 0x81, 0x01,
+	0x67, 0xba, 0xba, 0x57, 0xc5, 0xa6, 0x8c, 0x7c, 0x0e, 0x56, 0x91, 0x46, 0x3c, 0xfe, 0xb5, 0xcc,
+	0x2b, 0x90, 0x3d, 0x15, 0x98, 0x32, 0x72, 0x08, 0x7b, 0x73, 0xba, 0x08, 0x72, 0x7e, 0x8d, 0x76,
+	0x6b, 0x68, 0x8c, 0x5a, 0x5e, 0x77, 0x4e, 0x17, 0x3e, 0xbf, 0x46, 0x32, 0x86, 0x47, 0xb8, 0x48,
+	0x79, 0x26, 0x39, 0x06, 0x45, 0xcc, 0x17, 0x41, 0x8e, 0xa1, 0xdd, 0x96, 0xbb, 0x1e, 0xd6, 0xa9,
+	0xf3, 0x98, 0x2f, 0x7c, 0x0c, 0xc9, 0x53, 0xe8, 0xe7, 0x98, 0x71, 0x1a, 0x05, 0x71, 0x31, 0x9f,
+	0x61, 0x66, 0xef, 0x0e, 0x8d, 0x91, 0xe5, 0xed, 0xab, 0xe0, 0xa9, 0x8c, 0x91, 0x29, 0x74, 0x68,
+	0x58, 0x56, 0xd9, 0x9d, 0xa1, 0x31, 0x3a, 0x38, 0xf9, 0x76, 0x7c, 0x53, 0xaa, 0x71, 0x93, 0x4c,
+	0xe3, 0x17, 0xb2, 0xd0, 0xd3, 0x00, 0xae, 0x03, 0x1d, 0x15, 0x21, 0x5d, 0x68, 0x9d, 0x9d, 0xbf,
+	0x19, 0xec, 0x94, 0x1f, 0xaf, 0x5f, 0xbd, 0x19, 0x18, 0xee, 0x3f, 0x06, 0x1c, 0x7a, 0x18, 0x8b,
+	0xfb, 0xd2, 0xfb, 0x83, 0xa1, 0xf5, 0x3e, 0x87, 0x41, 0x5a, 0xf2, 0x0b, 0x68, 0x05, 0x27, 0x11,
+	0x7a, 0x27, 0xcf, 0xff, 0xff, 0x24, 0xde, 0x03, 0x89, 0xb1, 0xc2, 0xe8, 0x31, 0xec, 0x8a, 0x44,
+	0xd0, 0x48, 0x36, 0x6d, 0x79, 0x6a, 0x41, 0x8e, 0xe1, 0x41, 0x09, 0x47, 0x2f, 0x30, 0x88, 0x13,
+	0x26, 0x7f, 0xdf, 0x96, 0x24, 0xd5, 0xd7, 0xe1, 0xd3, 0x84, 0xe1, 0x94, 0xb9, 0x7f, 0x9b, 0x00,
+	0x67, 0x65, 0x73, 0xbf, 0x6c, 0x4e, 0x7e, 0x86, 0x47, 0xb3, 0x65, 0xd3, 0x0d, 0x9a, 0x5f, 0x6f,
+	0xd2, 0x6c, 0x14, 0xca, 0xdb, 0x86, 0x43, 0x26, 0x60, 0x49, 0x88, 0x4a, 0xa4, 0xde, 0xc9, 0xf1,
+	0x96, 0xd9, 0x2b, 0x3e, 0xea, 0xb3, 0x54, 0xcf, 0xab, 0x0b, 0xc9, 0x2b, 0xe8, 0xd3, 0x42, 0xbc,
+	0x4f, 0x32, 0x7e, 0xad, 0xe8, 0xb5, 0x24, 0xd2, 0x97, 0x9b, 0x48, 0x3e, 0xbf, 0x88, 0x91, 0xfd,
+	0x88, 0x79, 0x4e, 0x2f, 0xd0, 0x5b, 0xaf, 0x72, 0x10, 0xac, 0x0a, 0x9e, 0x1c, 0x80, 0xa9, 0x8f,
+	0x80, 0xe5, 0x99, 0x9c, 0x35, 0x39, 0xd8, 0x6c, 0x72, 0xb0, 0x0d, 0xdd, 0x30, 0x89, 0x05, 0xc6,
+	0x42, 0xeb, 0xbc, 0x5c, 0xba, 0xbf, 0x40, 0x57, 0xb6, 0x99, 0xb2, 0x8d, 0x26, 0x1b, 0x83, 0x98,
+	0x1f, 0x33, 0x88, 0x3b, 0x83, 0x7d, 0x25, 0x59, 0x31, 0x9f, 0xd3, 0xec, 0x6a, 0xa3, 0x0d, 0x81,
+	0xb6, 0x3c, 0xa4, 0x8a, 0xbc, 0xfc, 0x6e, 0x9a, 0xaf, 0xd5, 0x30, 0x9f, 0xfb, 0x97, 0x09, 0x07,
+	0xb2, 0x89, 0x87, 0x22, 0xe3, 0x78, 0x49, 0xa3, 0x4f, 0xed, 0x95, 0xef, 0xb5, 0x57, 0x26, 0xb5,
+	0x57, 0x9e, 0x37, 0x78, 0xa5, 0xe2, 0xb4, 0xe1, 0x97, 0xc9, 0x3d, 0xfa, 0xe5, 0xf5, 0x6d, 0x7e,
+	0xd9, 0xa6, 0xf1, 0x67, 0xd0, 0x49, 0xde, 0xbd, 0xcb, 0x51, 0x68, 0x59, 0xf5, 0xca, 0x9d, 0xc0,
+	0xe3, 0x75, 0xda, 0xbe, 0xc8, 0x90, 0xce, 0x2b, 0x0c, 0x63, 0x05, 0x63, 0xc5, 0x57, 0xe6, 0xba,
+	0xaf, 0x18, 0xf4, 0x14, 0x1d, 0x8c, 0x50, 0xe0, 0xdd, 0xde, 0xfa, 0xa8, 0xa1, 0xdd, 0x31, 0x90,
+	0x95, 0x2e, 0x4b, 0x87, 0xd9, 0xd0, 0x9d, 0xab, 0xfd, 0xba, 0xe3, 0x72, 0xe9, 0xfa, 0xf0, 0xb0,
+	0x3e, 0xbe, 0x77, 0x6e, 0x27, 0xcf, 0xa0, 0x2f, 0xef, 0x2b, 0x0f, 0x43, 0xe4, 0x97, 0xc8, 0xb4,
+	0x7e, 0xeb, 0x41, 0x17, 0x60, 0xcf, 0x17, 0x54, 0xe4, 0x1e, 0xfe, 0xe6, 0xfe, 0x69, 0x40, 0xaf,
+	0x5c, 0x2c, 0xb1, 0x8f, 0xc0, 0x2a, 0x72, 0x64, 0x7e, 0x4a, 0xc3, 0xa5, 0x72, 0x75, 0x80, 0x1c,
+	0xc3, 0x01, 0xbd, 0xa4, 0x3c, 0xa2, 0xb3, 0x08, 0xd5, 0x16, 0xd5, 0xe0, 0x46, 0xb4, 0xe4, 0x51,
+	0x16, 0x55, 0xe6, 0xd4, 0xbf, 0xd8, 0x7a, 0x90, 0x8c, 0x81, 0x54, 0x75, 0xf5, 0x56, 0xf5, 0xaa,
+	0x6d, 0xc9, 0xb8, 0x01, 0xf4, 0xd7, 0xc4, 0xad, 0xde, 0x07, 0xa3, 0x7e, 0x1f, 0xd6, 0x5f, 0x14,
+	0xf3, 0xe6, 0x8b, 0x72, 0x04, 0x56, 0x5a, 0xcc, 0x22, 0x1e, 0xfe, 0x80, 0x57, 0xfa, 0x66, 0xa9,
+	0x03, 0x27, 0x1f, 0x5a, 0x30, 0xa8, 0xe5, 0xf6, 0xe4, 0xef, 0x49, 0x26, 0xb0, 0x2b, 0x63, 0xe4,
+	0xb0, 0xe1, 0xb8, 0x4c, 0x99, 0xf3, 0x45, 0xd3, 0xad, 0xab, 0x54, 0x75, 0x77, 0xc8, 0x5b, 0xd8,
+	0xd3, 0xfe, 0x44, 0x32, 0xbc, 0xeb, 0xdc, 0x39, 0xc7, 0x77, 0xed, 0x50, 0x16, 0x77, 0x77, 0x46,
+	0xc6, 0x37, 0x06, 0x39, 0x85, 0x5d, 0xf5, 0xdc, 0x1c, 0xdd, 0x76, 0xf9, 0x3b, 0x4f, 0x6f, 0xcb,
+	0x56, 0x4c, 0x47, 0x06, 0xf9, 0x09, 0x3a, 0xfa, 0x14, 0x3c, 0x69, 0x28, 0x51, 0x69, 0xe7, 0xd9,
+	0xad, 0xe9, 0x7a, 0xf8, 0x49, 0x49, 0x90, 0x8a, 0x9c, 0x38, 0x5b, 0x8e, 0x8b, 0x76, 0xa2, 0xf3,
+	0x64, 0x7b, 0xae, 0x42, 0x79, 0xd9, 0x7e, 0x6b, 0xa6, 0xb3, 0x59, 0x47, 0xfe, 0xaf, 0xfb, 0xee,
+	0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x47, 0x43, 0x01, 0x53, 0xeb, 0x09, 0x00, 0x00,
 }

pkg/pb/piecestore.proto

@@ -18,25 +18,34 @@ service PieceStoreRoutes {
   rpc Stats(StatsReq) returns (StatSummary) {}
 }
 
-message PayerBandwidthAllocation {
-  message Data {
-    bytes payer = 1;
-    bytes renter = 2;
-    int64 max_size = 3;
-    int64 expiration_unix_sec = 4;
-    string serial_number = 5;
+message PayerBandwidthAllocation { // Payer refers to satellite
+
+  enum Action {
+    PUT = 0;
+    GET = 1;
   }
-  bytes signature = 1;
+
+  message Data {
+    bytes satellite_id = 1;        // Satellite Identity
+    bytes uplink_id = 2;           // Uplink Identity
+    int64 max_size = 3;            // Max amount of data the satellite will pay for in bytes
+    int64 expiration_unix_sec = 4; // Unix timestamp for when data is no longer being paid for
+    string serial_number = 5;      // Unique serial number
+    Action action = 6;             // GET or PUT
+  }
+
+  bytes signature = 1; // Seralized Data signed by Satellite
   bytes data = 2;      // Serialization of above Data Struct
 }
 
-message RenterBandwidthAllocation {
+message RenterBandwidthAllocation { // Renter refers to uplink
   message Data {
-    PayerBandwidthAllocation payer_allocation = 1;
-    int64 total = 2;
+    PayerBandwidthAllocation payer_allocation = 1; // Bandwidth Allocation from Satellite
+    int64 total = 2;                               // Total Bytes Stored
+    bytes storage_node_id = 3;                     // Storage Node Identity
   }
 
-  bytes signature = 1;
+  bytes signature = 1; // Seralized Data signed by Uplink
   bytes data = 2;      // Serialization of above Data Struct
 }
 

pkg/piecestore/rpc/client/client.go

@@ -19,6 +19,7 @@ import (
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 
+	"storj.io/storj/pkg/node"
 	"storj.io/storj/pkg/pb"
 	"storj.io/storj/pkg/ranger"
 )
@@ -29,10 +30,10 @@ var ClientError = errs.Class("PSClient error")
 var (
 	defaultBandwidthMsgSize = flag.Int(
 		"piecestore.rpc.client.default_bandwidth_msg_size", 32*1024,
-		"default bandwidth message size in kilobytes")
+		"default bandwidth message size in bytes")
 	maxBandwidthMsgSize = flag.Int(
 		"piecestore.rpc.client.max_bandwidth_msg_size", 64*1024,
-		"max bandwidth message size in kilobytes")
+		"max bandwidth message size in bytes")
 )
 
 // PSClient is an interface describing the functions for interacting with piecestore nodes
@@ -47,14 +48,15 @@ type PSClient interface {
 
 // Client -- Struct Info needed for protobuf api calls
 type Client struct {
-	route            pb.PieceStoreRoutesClient
-	conn             *grpc.ClientConn
-	prikey           crypto.PrivateKey
-	bandwidthMsgSize int
+	route            pb.PieceStoreRoutesClient // Client for interacting with Storage Node
+	conn             *grpc.ClientConn          // Connection to Storage Node
+	prikey           crypto.PrivateKey         // Uplink private key
+	bandwidthMsgSize int                       // max bandwidth message size in bytes
+	nodeID           *node.ID                  // Storage node being connected to
 }
 
 // NewPSClient initilizes a PSClient
-func NewPSClient(conn *grpc.ClientConn, bandwidthMsgSize int, prikey crypto.PrivateKey) (PSClient, error) {
+func NewPSClient(conn *grpc.ClientConn, nodeID *node.ID, bandwidthMsgSize int, prikey crypto.PrivateKey) (PSClient, error) {
 	if bandwidthMsgSize < 0 || bandwidthMsgSize > *maxBandwidthMsgSize {
 		return nil, ClientError.New(fmt.Sprintf("Invalid Bandwidth Message Size: %v", bandwidthMsgSize))
 	}
@@ -68,11 +70,12 @@ func NewPSClient(conn *grpc.ClientConn, bandwidthMsgSize int, prikey crypto.Priv
 		route:            pb.NewPieceStoreRoutesClient(conn),
 		bandwidthMsgSize: bandwidthMsgSize,
 		prikey:           prikey,
+		nodeID:           nodeID,
 	}, nil
 }
 
 // NewCustomRoute creates new Client with custom route interface
-func NewCustomRoute(route pb.PieceStoreRoutesClient, bandwidthMsgSize int, prikey crypto.PrivateKey) (*Client, error) {
+func NewCustomRoute(route pb.PieceStoreRoutesClient, nodeID *node.ID, bandwidthMsgSize int, prikey crypto.PrivateKey) (*Client, error) {
 	if bandwidthMsgSize < 0 || bandwidthMsgSize > *maxBandwidthMsgSize {
 		return nil, ClientError.New(fmt.Sprintf("Invalid Bandwidth Message Size: %v", bandwidthMsgSize))
 	}
@@ -85,6 +88,7 @@ func NewCustomRoute(route pb.PieceStoreRoutesClient, bandwidthMsgSize int, prike
 		route:            route,
 		bandwidthMsgSize: bandwidthMsgSize,
 		prikey:           prikey,
+		nodeID:           nodeID,
 	}, nil
 }
 

pkg/piecestore/rpc/client/pieceranger_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 
+	"storj.io/storj/pkg/node"
 	"storj.io/storj/pkg/pb"
 )
 
@@ -75,7 +76,7 @@ func TestPieceRanger(t *testing.T) {
 
 		ctx := context.Background()
 
-		c, err := NewCustomRoute(route, 32*1024, priv)
+		c, err := NewCustomRoute(route, node.IDFromString("test-node-id-1234567"), 32*1024, priv)
 		assert.NoError(t, err)
 		rr, err := PieceRanger(ctx, c, stream, pid, &pb.PayerBandwidthAllocation{}, nil)
 		if assert.NoError(t, err, errTag) {
@@ -146,7 +147,7 @@ func TestPieceRangerSize(t *testing.T) {
 
 		ctx := context.Background()
 
-		c, err := NewCustomRoute(route, 32*1024, priv)
+		c, err := NewCustomRoute(route, node.IDFromString("test-node-id-1234567"), 32*1024, priv)
 		assert.NoError(t, err)
 		rr := PieceRangerSize(c, stream, pid, tt.size, &pb.PayerBandwidthAllocation{}, nil)
 		assert.Equal(t, tt.size, rr.Size(), errTag)

pkg/piecestore/rpc/client/readerwriter.go

@@ -28,6 +28,7 @@ func (s *StreamWriter) Write(b []byte) (int, error) {
 	allocationData := &pb.RenterBandwidthAllocation_Data{
 		PayerAllocation: s.pba,
 		Total:           updatedAllocation,
+		StorageNodeId:   s.signer.nodeID.Bytes(),
 	}
 
 	serializedAllocation, err := proto.Marshal(allocationData)
@@ -108,6 +109,7 @@ func NewStreamReader(client *Client, stream pb.PieceStoreRoutes_RetrieveClient,
 			allocationData := &pb.RenterBandwidthAllocation_Data{
 				PayerAllocation: pba,
 				Total:           sr.allocated + allocate,
+				StorageNodeId:   sr.client.nodeID.Bytes(),
 			}
 
 			serializedAllocation, err := proto.Marshal(allocationData)

pkg/pointerdb/pointerdb.go

@@ -315,7 +315,11 @@ func (s *Server) getPayerBandwidthAllocation(ctx context.Context) (*pb.PayerBand
 	if err != nil {
 		return nil, err
 	}
-	pbad := &pb.PayerBandwidthAllocation_Data{Payer: payer, Renter: peerIdentity.ID.Bytes()}
+	pbad := &pb.PayerBandwidthAllocation_Data{
+		SatelliteId: payer,
+		UplinkId:    peerIdentity.ID.Bytes(),
+		// TODO: Action: pb.PayerBandwidthAllocation_GET, // Action should be a GET or a PUT
+	}
 
 	data, err := proto.Marshal(pbad)
 	if err != nil {

pkg/storage/ec/client.go

@@ -14,6 +14,7 @@ import (
 	monkit "gopkg.in/spacemonkeygo/monkit.v2"
 
 	"storj.io/storj/pkg/eestream"
+	"storj.io/storj/pkg/node"
 	"storj.io/storj/pkg/pb"
 	"storj.io/storj/pkg/piecestore/rpc/client"
 	"storj.io/storj/pkg/provider"
@@ -42,15 +43,15 @@ type defaultDialer struct {
 	identity  *provider.FullIdentity
 }
 
-func (dialer *defaultDialer) dial(ctx context.Context, node *pb.Node) (ps client.PSClient, err error) {
+func (dialer *defaultDialer) dial(ctx context.Context, storageNode *pb.Node) (ps client.PSClient, err error) {
 	defer mon.Task()(&ctx)(&err)
 
-	conn, err := dialer.transport.DialNode(ctx, node)
+	conn, err := dialer.transport.DialNode(ctx, storageNode)
 	if err != nil {
 		return nil, err
 	}
 
-	return client.NewPSClient(conn, 0, dialer.identity.Key)
+	return client.NewPSClient(conn, node.IDFromString(storageNode.GetId()), 0, dialer.identity.Key)
 }
 
 type ecClient struct {