diff --git a/internal/testplanet/planet_test.go b/internal/testplanet/planet_test.go
index 16c6e9d01..1f6095950 100644
--- a/internal/testplanet/planet_test.go
+++ b/internal/testplanet/planet_test.go
@@ -36,12 +36,9 @@ func TestBasic(t *testing.T) {
 	}
 
 	// Example of using pointer db
-	client, err := planet.Uplinks[0].DialPointerDB(planet.Satellites[0], "apikey")
+	_, err = planet.Uplinks[0].DialPointerDB(planet.Satellites[0], "apikey")
 	require.NoError(t, err)
 
-	message := client.SignedMessage()
-	t.Log(message)
-
 	// ping a satellite
 	_, err = planet.StorageNodes[0].Kademlia.Service.Ping(ctx, planet.Satellites[0].Local())
 	require.NoError(t, err)
diff --git a/pkg/audit/cursor.go b/pkg/audit/cursor.go
index cc16139a9..cca2590ae 100644
--- a/pkg/audit/cursor.go
+++ b/pkg/audit/cursor.go
@@ -11,7 +11,6 @@ import (
 
 	"github.com/vivint/infectious"
 
-	"storj.io/storj/pkg/auth"
 	"storj.io/storj/pkg/eestream"
 	"storj.io/storj/pkg/identity"
 	"storj.io/storj/pkg/pb"
@@ -22,10 +21,9 @@ import (
 
 // Stripe keeps track of a stripe's index and its parent segment
 type Stripe struct {
-	Index         int
-	Segment       *pb.Pointer
-	PBA           *pb.PayerBandwidthAllocation
-	Authorization *pb.SignedMessage
+	Index   int
+	Segment *pb.Pointer
+	PBA     *pb.PayerBandwidthAllocation
 }
 
 // Cursor keeps track of audit location in pointer db
@@ -85,16 +83,6 @@ func (cursor *Cursor) NextStripe(ctx context.Context) (stripe *Stripe, err error
 		return nil, err
 	}
 
-	signature, err := auth.GenerateSignature(cursor.identity.ID.Bytes(), cursor.identity)
-	if err != nil {
-		return nil, err
-	}
-
-	authorization, err := auth.NewSignedMessage(signature, cursor.identity)
-	if err != nil {
-		return nil, err
-	}
-
 	if pointer.GetType() != pb.Pointer_REMOTE {
 		return nil, nil
 	}
@@ -115,10 +103,9 @@ func (cursor *Cursor) NextStripe(ctx context.Context) (stripe *Stripe, err error
 	}
 
 	return &Stripe{
-		Index:         index,
-		Segment:       pointer,
-		PBA:           pba,
-		Authorization: authorization,
+		Index:   index,
+		Segment: pointer,
+		PBA:     pba,
 	}, nil
 }
 
diff --git a/pkg/audit/verifier.go b/pkg/audit/verifier.go
index e57ceb54c..4c1a646ae 100644
--- a/pkg/audit/verifier.go
+++ b/pkg/audit/verifier.go
@@ -35,7 +35,7 @@ type Verifier struct {
 }
 
 type downloader interface {
-	DownloadShares(ctx context.Context, pointer *pb.Pointer, stripeIndex int, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (shares map[int]Share, nodes map[int]storj.NodeID, err error)
+	DownloadShares(ctx context.Context, pointer *pb.Pointer, stripeIndex int, pba *pb.PayerBandwidthAllocation) (shares map[int]Share, nodes map[int]storj.NodeID, err error)
 }
 
 // defaultDownloader downloads shares from networked storage nodes
@@ -58,7 +58,7 @@ func NewVerifier(transport transport.Client, overlay *overlay.Cache, id *identit
 
 // getShare use piece store clients to download shares from a given node
 func (d *defaultDownloader) getShare(ctx context.Context, stripeIndex, shareSize, pieceNumber int,
-	id psclient.PieceID, pieceSize int64, fromNode *pb.Node, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (s Share, err error) {
+	id psclient.PieceID, pieceSize int64, fromNode *pb.Node, pba *pb.PayerBandwidthAllocation) (s Share, err error) {
 	// TODO: too many arguments use a struct
 	defer mon.Task()(&ctx)(&err)
 
@@ -77,7 +77,7 @@ func (d *defaultDownloader) getShare(ctx context.Context, stripeIndex, shareSize
 		return s, err
 	}
 
-	rr, err := ps.Get(ctx, derivedPieceID, pieceSize, pba, authorization)
+	rr, err := ps.Get(ctx, derivedPieceID, pieceSize, pba)
 	if err != nil {
 		return s, err
 	}
@@ -106,7 +106,7 @@ func (d *defaultDownloader) getShare(ctx context.Context, stripeIndex, shareSize
 
 // Download Shares downloads shares from the nodes where remote pieces are located
 func (d *defaultDownloader) DownloadShares(ctx context.Context, pointer *pb.Pointer,
-	stripeIndex int, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (shares map[int]Share, nodes map[int]storj.NodeID, err error) {
+	stripeIndex int, pba *pb.PayerBandwidthAllocation) (shares map[int]Share, nodes map[int]storj.NodeID, err error) {
 	defer mon.Task()(&ctx)(&err)
 
 	var nodeIds storj.NodeIDList
@@ -133,7 +133,7 @@ func (d *defaultDownloader) DownloadShares(ctx context.Context, pointer *pb.Poin
 		paddedSize := calcPadded(pointer.GetSegmentSize(), shareSize)
 		pieceSize := paddedSize / int64(pointer.Remote.Redundancy.GetMinReq())
 
-		s, err := d.getShare(ctx, stripeIndex, shareSize, int(pieces[i].PieceNum), pieceID, pieceSize, node, pba, authorization)
+		s, err := d.getShare(ctx, stripeIndex, shareSize, int(pieces[i].PieceNum), pieceID, pieceSize, node, pba)
 		if err != nil {
 			s = Share{
 				Error:       err,
@@ -201,7 +201,7 @@ func calcPadded(size int64, blockSize int) int64 {
 func (verifier *Verifier) verify(ctx context.Context, stripe *Stripe) (verifiedNodes *RecordAuditsInfo, err error) {
 	defer mon.Task()(&ctx)(&err)
 
-	shares, nodes, err := verifier.downloader.DownloadShares(ctx, stripe.Segment, stripe.Index, stripe.PBA, stripe.Authorization)
+	shares, nodes, err := verifier.downloader.DownloadShares(ctx, stripe.Segment, stripe.Index, stripe.PBA)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/audit/verifier_test.go b/pkg/audit/verifier_test.go
index 6b755be2f..480179bcf 100644
--- a/pkg/audit/verifier_test.go
+++ b/pkg/audit/verifier_test.go
@@ -48,7 +48,7 @@ func TestPassingAudit(t *testing.T) {
 		md := mockDownloader{shares: mockShares}
 		verifier := &audit.Verifier{downloader: &md}
 		pointer := makePointer(tt.nodeAmt)
-		verifiedNodes, err := verifier.Verify(ctx, &audit.Stripe{Index: 6, Segment: pointer, PBA: nil, Authorization: nil})
+		verifiedNodes, err := verifier.Verify(ctx, &audit.Stripe{Index: 6, Segment: pointer, PBA: nil})
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -92,7 +92,7 @@ func TestSomeNodesPassAudit(t *testing.T) {
 		md := mockDownloader{shares: mockShares}
 		verifier := &audit.Verifier{downloader: &md}
 		pointer := makePointer(tt.nodeAmt)
-		verifiedNodes, err := verifier.verify(ctx, &audit.Stripe{Index: 6, Segment: pointer, PBA: nil, Authorization: nil})
+		verifiedNodes, err := verifier.verify(ctx, &audit.Stripe{Index: 6, Segment: pointer, PBA: nil})
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -205,7 +205,7 @@ func TestCalcPadded(t *testing.T) {
 }
 
 func (m *mockDownloader) DownloadShares(ctx context.Context, pointer *pb.Pointer, stripeIndex int,
-	pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (shares map[int]share, nodes map[int]storj.NodeID, err error) {
+	pba *pb.PayerBandwidthAllocation) (shares map[int]share, nodes map[int]storj.NodeID, err error) {
 
 	nodes = make(map[int]*pb.Node, 30)
 
diff --git a/pkg/auth/signature.go b/pkg/auth/signature.go
index 5208a17a2..28b416d8d 100644
--- a/pkg/auth/signature.go
+++ b/pkg/auth/signature.go
@@ -5,7 +5,6 @@ package auth
 
 import (
 	"storj.io/storj/pkg/identity"
-	"storj.io/storj/pkg/pb"
 	"storj.io/storj/pkg/pkcrypto"
 )
 
@@ -13,43 +12,3 @@ import (
 func GenerateSignature(data []byte, identity *identity.FullIdentity) ([]byte, error) {
 	return pkcrypto.HashAndSign(identity.Key, data)
 }
-
-// NewSignedMessage creates instance of signed message
-func NewSignedMessage(signature []byte, identity *identity.FullIdentity) (*pb.SignedMessage, error) {
-	encodedKey, err := pkcrypto.PublicKeyToPKIX(identity.Leaf.PublicKey)
-	if err != nil {
-		return nil, err
-	}
-	return &pb.SignedMessage{
-		Data:      identity.ID.Bytes(),
-		Signature: signature,
-		PublicKey: encodedKey,
-	}, nil
-}
-
-// SignedMessageVerifier checks if provided signed message can be verified
-type SignedMessageVerifier func(signature *pb.SignedMessage) error
-
-// NewSignedMessageVerifier creates default implementation of SignedMessageVerifier
-func NewSignedMessageVerifier() SignedMessageVerifier {
-	return func(signedMessage *pb.SignedMessage) error {
-		if signedMessage == nil {
-			return Error.New("no message to verify")
-		}
-		if signedMessage.Signature == nil {
-			return Error.New("missing signature for verification")
-		}
-		if signedMessage.Data == nil {
-			return Error.New("missing data for verification")
-		}
-		if signedMessage.PublicKey == nil {
-			return Error.New("missing public key for verification")
-		}
-
-		k, err := pkcrypto.PublicKeyFromPKIX(signedMessage.GetPublicKey())
-		if err != nil {
-			return Error.Wrap(err)
-		}
-		return pkcrypto.HashAndVerifySignature(k, signedMessage.GetData(), signedMessage.GetSignature())
-	}
-}
diff --git a/pkg/auth/signature_test.go b/pkg/auth/signature_test.go
index 8cfc7347d..96c3883f5 100644
--- a/pkg/auth/signature_test.go
+++ b/pkg/auth/signature_test.go
@@ -38,42 +38,3 @@ func TestGenerateSignature(t *testing.T) {
 		}
 	}
 }
-
-func TestSignedMessageVerifier(t *testing.T) {
-	ctx := context.Background()
-	ca, err := testidentity.NewTestCA(ctx)
-	assert.NoError(t, err)
-	identity, err := ca.NewIdentity()
-	assert.NoError(t, err)
-
-	signature, err := GenerateSignature(identity.ID.Bytes(), identity)
-	assert.NoError(t, err)
-
-	signedMessage, err := NewSignedMessage(signature, identity)
-	assert.NoError(t, err)
-
-	for _, tt := range []struct {
-		signature []byte
-		data      []byte
-		publicKey []byte
-		errString string
-	}{
-		{signedMessage.Signature, signedMessage.Data, signedMessage.PublicKey, ""},
-		{nil, signedMessage.Data, signedMessage.PublicKey, "auth error: missing signature for verification"},
-		{signedMessage.Signature, nil, signedMessage.PublicKey, "auth error: missing data for verification"},
-		{signedMessage.Signature, signedMessage.Data, nil, "auth error: missing public key for verification"},
-
-		{signedMessage.Signature, []byte("malformed data"), signedMessage.PublicKey, "signature verification error: signature is not valid"},
-	} {
-		signedMessage.Signature = tt.signature
-		signedMessage.Data = tt.data
-		signedMessage.PublicKey = tt.publicKey
-
-		err := NewSignedMessageVerifier()(signedMessage)
-		if tt.errString != "" {
-			assert.EqualError(t, err, tt.errString)
-		} else {
-			assert.NoError(t, err)
-		}
-	}
-}
diff --git a/pkg/pb/bandwidth_utils.go b/pkg/pb/bandwidth_utils.go
index 7fd1c7027..c1bcdf247 100644
--- a/pkg/pb/bandwidth_utils.go
+++ b/pkg/pb/bandwidth_utils.go
@@ -58,3 +58,22 @@ func (m *RenterBandwidthAllocation) SetCerts(certs [][]byte) {
 func (m *RenterBandwidthAllocation) SetSignature(signature []byte) {
 	m.Signature = signature
 }
+
+// Clone creates a deep copy of PayerBandwidthAllocation
+func (m *PayerBandwidthAllocation) Clone() (pba PayerBandwidthAllocation) {
+	pba = PayerBandwidthAllocation{
+		SatelliteId:       m.SatelliteId,
+		UplinkId:          m.UplinkId,
+		MaxSize:           m.MaxSize,
+		ExpirationUnixSec: m.ExpirationUnixSec,
+		SerialNumber:      m.SerialNumber,
+		Action:            m.Action,
+		CreatedUnixSec:    m.CreatedUnixSec,
+	}
+	pba.Certs = make([][]byte, len(m.Certs))
+	copy(pba.Certs, m.Certs)
+	pba.Signature = make([]byte, len(m.Signature))
+	copy(pba.Signature, m.Signature)
+
+	return pba
+}
diff --git a/pkg/pb/piecestore.pb.go b/pkg/pb/piecestore.pb.go
index 499fbebbd..3bf2328d8 100644
--- a/pkg/pb/piecestore.pb.go
+++ b/pkg/pb/piecestore.pb.go
@@ -54,7 +54,7 @@ func (x BandwidthAction) String() string {
 	return proto.EnumName(BandwidthAction_name, int32(x))
 }
 func (BandwidthAction) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_ef88e5b6fd61ab5b, []int{0}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{0}
 }
 
 type PayerBandwidthAllocation struct {
@@ -76,7 +76,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_ef88e5b6fd61ab5b, []int{0}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{0}
 }
 func (m *PayerBandwidthAllocation) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PayerBandwidthAllocation.Unmarshal(m, b)
@@ -160,7 +160,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_ef88e5b6fd61ab5b, []int{1}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{1}
 }
 func (m *RenterBandwidthAllocation) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RenterBandwidthAllocation.Unmarshal(m, b)
@@ -221,7 +221,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_ef88e5b6fd61ab5b, []int{2}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{2}
 }
 func (m *PieceStore) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceStore.Unmarshal(m, b)
@@ -276,7 +276,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_ef88e5b6fd61ab5b, []int{2, 0}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{2, 0}
 }
 func (m *PieceStore_PieceData) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceStore_PieceData.Unmarshal(m, b)
@@ -321,6 +321,7 @@ type PieceId struct {
 	// TODO: may want to use customtype and fixed-length byte slice
 	Id                   string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
 	Authorization        *SignedMessage `protobuf:"bytes,2,opt,name=authorization,proto3" json:"authorization,omitempty"`
+	SatelliteId          NodeID         `protobuf:"bytes,3,opt,name=satellite_id,json=satelliteId,proto3,customtype=NodeID" json:"satellite_id"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -330,7 +331,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_ef88e5b6fd61ab5b, []int{3}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{3}
 }
 func (m *PieceId) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceId.Unmarshal(m, b)
@@ -377,7 +378,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_ef88e5b6fd61ab5b, []int{4}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{4}
 }
 func (m *PieceSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceSummary.Unmarshal(m, b)
@@ -431,7 +432,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_ef88e5b6fd61ab5b, []int{5}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{5}
 }
 func (m *PieceRetrieval) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceRetrieval.Unmarshal(m, b)
@@ -486,7 +487,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_ef88e5b6fd61ab5b, []int{5, 0}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{5, 0}
 }
 func (m *PieceRetrieval_PieceData) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceRetrieval_PieceData.Unmarshal(m, b)
@@ -539,7 +540,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_ef88e5b6fd61ab5b, []int{6}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{6}
 }
 func (m *PieceRetrievalStream) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceRetrievalStream.Unmarshal(m, b)
@@ -577,6 +578,7 @@ type PieceDelete struct {
 	// TODO: may want to use customtype and fixed-length byte slice
 	Id                   string         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
 	Authorization        *SignedMessage `protobuf:"bytes,3,opt,name=authorization,proto3" json:"authorization,omitempty"`
+	SatelliteId          NodeID         `protobuf:"bytes,4,opt,name=satellite_id,json=satelliteId,proto3,customtype=NodeID" json:"satellite_id"`
 	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
 	XXX_unrecognized     []byte         `json:"-"`
 	XXX_sizecache        int32          `json:"-"`
@@ -586,7 +588,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_ef88e5b6fd61ab5b, []int{7}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{7}
 }
 func (m *PieceDelete) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceDelete.Unmarshal(m, b)
@@ -631,7 +633,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_ef88e5b6fd61ab5b, []int{8}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{8}
 }
 func (m *PieceDeleteSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceDeleteSummary.Unmarshal(m, b)
@@ -670,7 +672,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_ef88e5b6fd61ab5b, []int{9}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{9}
 }
 func (m *PieceStoreSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_PieceStoreSummary.Unmarshal(m, b)
@@ -714,7 +716,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_ef88e5b6fd61ab5b, []int{10}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{10}
 }
 func (m *StatsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatsReq.Unmarshal(m, b)
@@ -748,7 +750,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_ef88e5b6fd61ab5b, []int{11}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{11}
 }
 func (m *StatSummary) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StatSummary.Unmarshal(m, b)
@@ -809,7 +811,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_ef88e5b6fd61ab5b, []int{12}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{12}
 }
 func (m *SignedMessage) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SignedMessage.Unmarshal(m, b)
@@ -860,7 +862,7 @@ func (m *DashboardReq) Reset()         { *m = DashboardReq{} }
 func (m *DashboardReq) String() string { return proto.CompactTextString(m) }
 func (*DashboardReq) ProtoMessage()    {}
 func (*DashboardReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_ef88e5b6fd61ab5b, []int{13}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{13}
 }
 func (m *DashboardReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DashboardReq.Unmarshal(m, b)
@@ -898,7 +900,7 @@ func (m *DashboardStats) Reset()         { *m = DashboardStats{} }
 func (m *DashboardStats) String() string { return proto.CompactTextString(m) }
 func (*DashboardStats) ProtoMessage()    {}
 func (*DashboardStats) Descriptor() ([]byte, []int) {
-	return fileDescriptor_piecestore_ef88e5b6fd61ab5b, []int{14}
+	return fileDescriptor_piecestore_c26ae6b59e2ee94d, []int{14}
 }
 func (m *DashboardStats) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DashboardStats.Unmarshal(m, b)
@@ -1326,81 +1328,82 @@ var _PieceStoreRoutes_serviceDesc = grpc.ServiceDesc{
 	Metadata: "piecestore.proto",
 }
 
-func init() { proto.RegisterFile("piecestore.proto", fileDescriptor_piecestore_ef88e5b6fd61ab5b) }
+func init() { proto.RegisterFile("piecestore.proto", fileDescriptor_piecestore_c26ae6b59e2ee94d) }
 
-var fileDescriptor_piecestore_ef88e5b6fd61ab5b = []byte{
-	// 1159 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcd, 0x6e, 0xdb, 0x46,
-	0x10, 0x16, 0xa9, 0xff, 0xd1, 0x6f, 0x36, 0x46, 0x2b, 0x0b, 0xb1, 0xad, 0x32, 0x4d, 0xaa, 0xda,
-	0x80, 0x9c, 0x38, 0x40, 0x81, 0x1e, 0xed, 0xca, 0x08, 0x84, 0xa2, 0x8e, 0xbb, 0xb2, 0x2f, 0x29,
-	0x50, 0x66, 0x45, 0x8e, 0x65, 0x22, 0x14, 0xa9, 0x92, 0x4b, 0x57, 0xf6, 0xb5, 0xcf, 0xd3, 0xf7,
-	0xe8, 0x13, 0xf4, 0xd0, 0x43, 0x8a, 0xbe, 0x40, 0x1f, 0xa0, 0xa7, 0x82, 0xbb, 0xfc, 0x91, 0xf5,
-	0x67, 0x20, 0x40, 0x6e, 0x9c, 0x6f, 0x3f, 0xce, 0xce, 0x7c, 0x33, 0x3b, 0xbb, 0xd0, 0x9c, 0x5a,
-	0x68, 0xa0, 0xcf, 0x5d, 0x0f, 0x7b, 0x53, 0xcf, 0xe5, 0x2e, 0x99, 0x43, 0x3c, 0x37, 0xe0, 0xe8,
-	0xb7, 0x61, 0xec, 0x8e, 0x5d, 0xb9, 0xda, 0xde, 0x1d, 0xbb, 0xee, 0xd8, 0xc6, 0x43, 0x61, 0x8d,
-	0x82, 0xab, 0x43, 0x33, 0xf0, 0x18, 0xb7, 0x5c, 0x47, 0xae, 0x6b, 0xbf, 0x65, 0xa1, 0x75, 0xce,
-	0x6e, 0xd1, 0x3b, 0x61, 0x8e, 0xf9, 0xab, 0x65, 0xf2, 0xeb, 0x63, 0xdb, 0x76, 0x0d, 0x41, 0x21,
-	0x2f, 0xa1, 0xea, 0x33, 0x8e, 0xb6, 0x6d, 0x71, 0xd4, 0x2d, 0xb3, 0xa5, 0x74, 0x94, 0x6e, 0xf5,
-	0xa4, 0xfe, 0xc7, 0x87, 0xbd, 0xcc, 0x5f, 0x1f, 0xf6, 0x0a, 0x67, 0xae, 0x89, 0x83, 0x3e, 0xad,
-	0x24, 0x9c, 0x81, 0x49, 0x0e, 0xa0, 0x1c, 0x4c, 0x6d, 0xcb, 0x79, 0x1f, 0xf2, 0xd5, 0x95, 0xfc,
-	0x92, 0x24, 0x0c, 0x4c, 0xb2, 0x0d, 0xa5, 0x09, 0x9b, 0xe9, 0xbe, 0x75, 0x87, 0xad, 0x6c, 0x47,
-	0xe9, 0x66, 0x69, 0x71, 0xc2, 0x66, 0x43, 0xeb, 0x0e, 0x49, 0x0f, 0x1e, 0xe3, 0x6c, 0x6a, 0xc9,
-	0x58, 0xf5, 0xc0, 0xb1, 0x66, 0xba, 0x8f, 0x46, 0x2b, 0x27, 0x58, 0x8f, 0xd2, 0xa5, 0x4b, 0xc7,
-	0x9a, 0x0d, 0xd1, 0x20, 0x4f, 0xa1, 0xe6, 0xa3, 0x67, 0x31, 0x5b, 0x77, 0x82, 0xc9, 0x08, 0xbd,
-	0x56, 0xbe, 0xa3, 0x74, 0xcb, 0xb4, 0x2a, 0xc1, 0x33, 0x81, 0x91, 0x6f, 0xa1, 0xc0, 0x8c, 0xf0,
-	0xaf, 0x56, 0xa1, 0xa3, 0x74, 0xeb, 0x47, 0x5f, 0xf4, 0x16, 0xb5, 0xeb, 0xa5, 0x32, 0x08, 0x22,
-	0x8d, 0x7e, 0x20, 0x5d, 0x68, 0x1a, 0x1e, 0x32, 0x8e, 0x66, 0x1a, 0x4c, 0x51, 0x04, 0x53, 0x8f,
-	0xf0, 0x38, 0x92, 0x2d, 0xc8, 0x1b, 0xe8, 0x71, 0xbf, 0x55, 0xea, 0x64, 0xbb, 0x55, 0x2a, 0x0d,
-	0xf2, 0x04, 0xca, 0xbe, 0x35, 0x76, 0x18, 0x0f, 0x3c, 0x6c, 0x95, 0x43, 0x5d, 0x68, 0x0a, 0x68,
-	0xff, 0x29, 0xb0, 0x4d, 0xd1, 0xe1, 0xab, 0xcb, 0xf0, 0x13, 0x34, 0xa7, 0x61, 0x89, 0x74, 0x96,
-	0x60, 0xa2, 0x14, 0x95, 0xa3, 0xfd, 0xe5, 0x04, 0xd6, 0x15, 0xf3, 0x24, 0x17, 0x96, 0x81, 0x36,
-	0x84, 0xa7, 0x39, 0xe7, 0x5b, 0x90, 0xe7, 0x2e, 0x67, 0xb6, 0x28, 0x56, 0x96, 0x4a, 0x83, 0x7c,
-	0x03, 0x8d, 0xd0, 0x29, 0x1b, 0xa3, 0xee, 0xb8, 0xa6, 0x28, 0x7e, 0x76, 0x65, 0x31, 0x6b, 0x11,
-	0x4d, 0x98, 0x66, 0x9a, 0x7c, 0x6e, 0x6d, 0xf2, 0xf9, 0xc5, 0xe4, 0xff, 0x51, 0x01, 0xce, 0xc3,
-	0x34, 0x86, 0x61, 0x1a, 0xe4, 0x67, 0xd8, 0x1a, 0xc5, 0xe1, 0x2f, 0x67, 0x7c, 0xb0, 0x9c, 0xf1,
-	0x5a, 0xe1, 0xe8, 0xe3, 0xd1, 0x0a, 0x35, 0x4f, 0x01, 0x84, 0x0b, 0xdd, 0x64, 0x9c, 0x89, 0xac,
-	0x2b, 0x47, 0xcf, 0x57, 0xe8, 0x98, 0x44, 0x24, 0x3f, 0xfb, 0x8c, 0x33, 0x5a, 0x9e, 0xc6, 0x9f,
-	0xe4, 0x14, 0x6a, 0x2c, 0xe0, 0xd7, 0xae, 0x67, 0xdd, 0xc9, 0xf8, 0xb2, 0xc2, 0xd3, 0xde, 0xb2,
-	0xa7, 0xa1, 0x35, 0x76, 0xd0, 0xfc, 0x01, 0x7d, 0x9f, 0x8d, 0x91, 0xde, 0xff, 0xab, 0x8d, 0x50,
-	0x4e, 0xdc, 0x93, 0x3a, 0xa8, 0xd1, 0x29, 0x2b, 0x53, 0xd5, 0x32, 0xd7, 0x1d, 0x02, 0x75, 0xdd,
-	0x21, 0x68, 0x41, 0xd1, 0x70, 0x1d, 0x8e, 0x0e, 0x97, 0xd5, 0xa2, 0xb1, 0xa9, 0xbd, 0x83, 0xa2,
-	0xd8, 0x66, 0x60, 0x2e, 0x6d, 0xb2, 0x94, 0x88, 0xfa, 0x31, 0x89, 0x68, 0x13, 0xa8, 0x4a, 0xc9,
-	0x82, 0xc9, 0x84, 0x79, 0xb7, 0x4b, 0xdb, 0xec, 0xc4, 0xb2, 0x8b, 0xd3, 0x2e, 0x53, 0x90, 0x72,
-	0x6e, 0x3a, 0xef, 0xd9, 0x35, 0xa9, 0x6a, 0x7f, 0xaa, 0x50, 0x17, 0xfb, 0x51, 0xe4, 0x9e, 0x85,
-	0x37, 0xcc, 0xfe, 0xe4, 0x8d, 0x33, 0x58, 0xd1, 0x38, 0xfb, 0x6b, 0x1a, 0x27, 0x89, 0xea, 0x93,
-	0x36, 0x0f, 0xdd, 0xd4, 0x3c, 0x0f, 0x08, 0xfe, 0x19, 0x14, 0xdc, 0xab, 0x2b, 0x1f, 0x79, 0xa4,
-	0x71, 0x64, 0x69, 0x6f, 0x60, 0xeb, 0x7e, 0x06, 0x43, 0xee, 0x21, 0x9b, 0x2c, 0xb8, 0x53, 0x16,
-	0xdd, 0xcd, 0xb5, 0x9e, 0x7a, 0xbf, 0xf5, 0x4c, 0xa8, 0xc8, 0x20, 0xd1, 0x46, 0x8e, 0x0f, 0xb7,
-	0xdf, 0x47, 0x49, 0xa1, 0xf5, 0x80, 0xcc, 0xed, 0x12, 0x37, 0x61, 0x0b, 0x8a, 0x13, 0xc9, 0x8f,
-	0x76, 0x8c, 0x4d, 0xed, 0x02, 0x1e, 0xa5, 0x27, 0xfc, 0x41, 0x3a, 0x79, 0x06, 0x75, 0x31, 0x18,
-	0x75, 0x0f, 0x0d, 0xb4, 0x6e, 0xd0, 0x8c, 0x04, 0xad, 0x09, 0x94, 0x46, 0xa0, 0x06, 0x50, 0x1a,
-	0x72, 0xc6, 0x7d, 0x8a, 0xbf, 0x68, 0xbf, 0x2b, 0x50, 0x09, 0x8d, 0xd8, 0xf9, 0x0e, 0x40, 0xe0,
-	0xa3, 0xa9, 0xfb, 0x53, 0x66, 0x24, 0x02, 0x86, 0xc8, 0x30, 0x04, 0xc8, 0x57, 0xd0, 0x60, 0x37,
-	0xcc, 0xb2, 0xd9, 0xc8, 0xc6, 0x88, 0x23, 0xb7, 0xa8, 0x27, 0xb0, 0x24, 0x3e, 0x83, 0xba, 0xf0,
-	0x93, 0xb4, 0x68, 0x54, 0xc0, 0x5a, 0x88, 0x26, 0xcd, 0x4c, 0x0e, 0xe1, 0x71, 0xea, 0x2f, 0xe5,
-	0xca, 0x0b, 0x94, 0x24, 0x4b, 0xc9, 0x0f, 0xda, 0x3b, 0xa8, 0xdd, 0x53, 0x98, 0x10, 0xc8, 0x89,
-	0x4e, 0x17, 0xb7, 0x3e, 0x15, 0xdf, 0xf7, 0x27, 0xb9, 0xba, 0x30, 0xc9, 0x45, 0x8f, 0x04, 0x23,
-	0xdb, 0x32, 0xf4, 0xf7, 0x78, 0x1b, 0x8d, 0xa0, 0xb2, 0x44, 0xbe, 0xc7, 0x5b, 0xad, 0x0e, 0xd5,
-	0x3e, 0xf3, 0xaf, 0x47, 0x2e, 0xf3, 0xcc, 0x50, 0xa1, 0xbf, 0x55, 0xa8, 0x27, 0x80, 0xd0, 0x8d,
-	0x7c, 0x0e, 0xc5, 0xf8, 0xbe, 0x91, 0x15, 0x28, 0x38, 0xf2, 0x62, 0xf9, 0x1a, 0x9a, 0x62, 0xc1,
-	0x70, 0x1d, 0x07, 0xc5, 0x95, 0xec, 0x47, 0xfa, 0x34, 0x42, 0xfc, 0xbb, 0x14, 0x26, 0x07, 0xf0,
-	0x68, 0xe4, 0xba, 0xdc, 0xe7, 0x1e, 0x9b, 0xea, 0xcc, 0x34, 0x3d, 0xf4, 0x7d, 0x11, 0x4c, 0x99,
-	0x36, 0x93, 0x85, 0x63, 0x89, 0x87, 0x7e, 0xad, 0x70, 0x0a, 0x38, 0xcc, 0x4e, 0xb8, 0x39, 0xc1,
-	0x6d, 0xc4, 0xf8, 0x1c, 0x15, 0x67, 0x0b, 0x54, 0xf9, 0xca, 0x68, 0xc4, 0x78, 0x4c, 0x7d, 0x05,
-	0x79, 0x3f, 0xcc, 0x47, 0xbc, 0x33, 0x2a, 0x47, 0x3b, 0x2b, 0x9a, 0x39, 0xed, 0x0c, 0x2a, 0xb9,
-	0x64, 0x17, 0x20, 0xcd, 0x4e, 0x3c, 0x2e, 0x4a, 0x74, 0x0e, 0x21, 0x2f, 0xa1, 0x10, 0x4c, 0xb9,
-	0x35, 0xc1, 0x56, 0x49, 0x78, 0xdd, 0xee, 0xc9, 0xb7, 0x5d, 0x2f, 0x7e, 0xdb, 0xf5, 0xfa, 0xd1,
-	0xdb, 0x8e, 0x46, 0xc4, 0x7d, 0x0a, 0x8d, 0x85, 0x07, 0x0d, 0x29, 0x42, 0xf6, 0xfc, 0xf2, 0xa2,
-	0x99, 0x09, 0x3f, 0x5e, 0x9f, 0x5e, 0x34, 0x15, 0x52, 0x83, 0xf2, 0xeb, 0xd3, 0x0b, 0xfd, 0xf8,
-	0xb2, 0x3f, 0xb8, 0x68, 0xaa, 0xa4, 0x0e, 0x10, 0x9a, 0xf4, 0xf4, 0xfc, 0x78, 0x40, 0x9b, 0xd9,
-	0xd0, 0x3e, 0xbf, 0x4c, 0xec, 0xdc, 0xd1, 0xbf, 0x59, 0x68, 0xa6, 0x47, 0x87, 0x8a, 0x74, 0x48,
-	0x1f, 0xf2, 0x02, 0x23, 0xdb, 0x6b, 0x06, 0xe2, 0xc0, 0x6c, 0xef, 0xae, 0xbb, 0x64, 0xa5, 0x0c,
-	0x5a, 0x86, 0xbc, 0x85, 0x52, 0x34, 0x76, 0x90, 0x74, 0x1e, 0x9a, 0xac, 0xed, 0xe7, 0x0f, 0x31,
-	0xe4, 0xe4, 0xd2, 0x32, 0x5d, 0xe5, 0x85, 0x42, 0xce, 0x20, 0x2f, 0xdf, 0x17, 0x4f, 0x36, 0xdd,
-	0xf5, 0xed, 0xa7, 0x9b, 0x56, 0x93, 0x48, 0xbb, 0x0a, 0x79, 0x03, 0x85, 0x68, 0xa2, 0xed, 0xac,
-	0xf9, 0x45, 0x2e, 0xb7, 0xbf, 0xdc, 0xb8, 0x9c, 0x26, 0xdf, 0x0f, 0x03, 0x0c, 0xfb, 0xa0, 0xbd,
-	0xba, 0x5b, 0xc2, 0xa1, 0xd2, 0xde, 0xdc, 0x49, 0x5a, 0x86, 0xfc, 0x08, 0xe5, 0xe4, 0x48, 0x91,
-	0x15, 0x8a, 0xcf, 0x1f, 0xc0, 0x76, 0x67, 0xc3, 0xba, 0xd8, 0x52, 0xcb, 0xbc, 0x50, 0x4e, 0x72,
-	0x6f, 0xd5, 0xe9, 0x68, 0x54, 0x10, 0x5d, 0xf6, 0xea, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f,
-	0x14, 0x59, 0xb7, 0x81, 0x0c, 0x00, 0x00,
+var fileDescriptor_piecestore_c26ae6b59e2ee94d = []byte{
+	// 1176 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcb, 0x6e, 0xdb, 0x46,
+	0x17, 0x16, 0x49, 0x5d, 0x8f, 0xae, 0x99, 0x18, 0xff, 0x2f, 0x0b, 0x71, 0xa2, 0x32, 0x4d, 0xaa,
+	0x26, 0x80, 0x92, 0x38, 0x40, 0x81, 0x2e, 0xed, 0xca, 0x08, 0x84, 0xa2, 0x89, 0x3b, 0xb2, 0x37,
+	0x29, 0x50, 0x76, 0x44, 0x1e, 0xcb, 0x44, 0x28, 0x52, 0x25, 0x87, 0xae, 0xec, 0x6d, 0x1f, 0xa1,
+	0x8b, 0x3e, 0x45, 0xdf, 0xa3, 0x4f, 0xd0, 0x45, 0x17, 0x29, 0xfa, 0x02, 0x7d, 0x80, 0xae, 0x0a,
+	0xce, 0xf0, 0x22, 0xeb, 0x0a, 0x14, 0xcd, 0x8e, 0xe7, 0x3b, 0x1f, 0xcf, 0x9c, 0xdb, 0x9c, 0x39,
+	0xd0, 0x9a, 0xd9, 0x68, 0x62, 0xc0, 0x3d, 0x1f, 0xfb, 0x33, 0xdf, 0xe3, 0x1e, 0x59, 0x40, 0x7c,
+	0x2f, 0xe4, 0x18, 0x74, 0x60, 0xe2, 0x4d, 0x3c, 0xa9, 0xed, 0xdc, 0x9f, 0x78, 0xde, 0xc4, 0xc1,
+	0x67, 0x42, 0x1a, 0x87, 0x17, 0xcf, 0xac, 0xd0, 0x67, 0xdc, 0xf6, 0x5c, 0xa9, 0xd7, 0x7f, 0xd4,
+	0xa0, 0x7d, 0xca, 0xae, 0xd1, 0x3f, 0x66, 0xae, 0xf5, 0x83, 0x6d, 0xf1, 0xcb, 0x23, 0xc7, 0xf1,
+	0x4c, 0x41, 0x21, 0x2f, 0xa0, 0x16, 0x30, 0x8e, 0x8e, 0x63, 0x73, 0x34, 0x6c, 0xab, 0xad, 0x74,
+	0x95, 0x5e, 0xed, 0xb8, 0xf1, 0xeb, 0xfb, 0x07, 0xb9, 0xdf, 0xdf, 0x3f, 0x28, 0xbe, 0xf6, 0x2c,
+	0x1c, 0x0e, 0x68, 0x35, 0xe5, 0x0c, 0x2d, 0xf2, 0x14, 0x2a, 0xe1, 0xcc, 0xb1, 0xdd, 0x77, 0x11,
+	0x5f, 0x5d, 0xcb, 0x2f, 0x4b, 0xc2, 0xd0, 0x22, 0xfb, 0x50, 0x9e, 0xb2, 0xb9, 0x11, 0xd8, 0x37,
+	0xd8, 0xd6, 0xba, 0x4a, 0x4f, 0xa3, 0xa5, 0x29, 0x9b, 0x8f, 0xec, 0x1b, 0x24, 0x7d, 0xb8, 0x8b,
+	0xf3, 0x99, 0x2d, 0x7d, 0x35, 0x42, 0xd7, 0x9e, 0x1b, 0x01, 0x9a, 0xed, 0xbc, 0x60, 0xdd, 0xc9,
+	0x54, 0xe7, 0xae, 0x3d, 0x1f, 0xa1, 0x49, 0x1e, 0x42, 0x3d, 0x40, 0xdf, 0x66, 0x8e, 0xe1, 0x86,
+	0xd3, 0x31, 0xfa, 0xed, 0x42, 0x57, 0xe9, 0x55, 0x68, 0x4d, 0x82, 0xaf, 0x05, 0x46, 0x3e, 0x87,
+	0x22, 0x33, 0xa3, 0xbf, 0xda, 0xc5, 0xae, 0xd2, 0x6b, 0x1c, 0x7e, 0xd4, 0x5f, 0xce, 0x5d, 0x3f,
+	0x4b, 0x83, 0x20, 0xd2, 0xf8, 0x07, 0xd2, 0x83, 0x96, 0xe9, 0x23, 0xe3, 0x68, 0x65, 0xce, 0x94,
+	0x84, 0x33, 0x8d, 0x18, 0x4f, 0x3c, 0xd9, 0x83, 0x82, 0x89, 0x3e, 0x0f, 0xda, 0xe5, 0xae, 0xd6,
+	0xab, 0x51, 0x29, 0x90, 0x7b, 0x50, 0x09, 0xec, 0x89, 0xcb, 0x78, 0xe8, 0x63, 0xbb, 0x12, 0xe5,
+	0x85, 0x66, 0x80, 0xfe, 0xb7, 0x02, 0xfb, 0x14, 0x5d, 0xbe, 0xbe, 0x0c, 0xdf, 0x40, 0x6b, 0x16,
+	0x95, 0xc8, 0x60, 0x29, 0x26, 0x4a, 0x51, 0x3d, 0x7c, 0xb2, 0x1a, 0xc0, 0xa6, 0x62, 0x1e, 0xe7,
+	0xa3, 0x32, 0xd0, 0xa6, 0xb0, 0xb4, 0x60, 0x7c, 0x0f, 0x0a, 0xdc, 0xe3, 0xcc, 0x11, 0xc5, 0xd2,
+	0xa8, 0x14, 0xc8, 0x67, 0xd0, 0x8c, 0x8c, 0xb2, 0x09, 0x1a, 0xae, 0x67, 0x89, 0xe2, 0x6b, 0x6b,
+	0x8b, 0x59, 0x8f, 0x69, 0x42, 0xb4, 0xb2, 0xe0, 0xf3, 0x1b, 0x83, 0x2f, 0x2c, 0x07, 0xff, 0xa7,
+	0x0a, 0x70, 0x1a, 0x85, 0x31, 0x8a, 0xc2, 0x20, 0xdf, 0xc2, 0xde, 0x38, 0x71, 0x7f, 0x35, 0xe2,
+	0xa7, 0xab, 0x11, 0x6f, 0x4c, 0x1c, 0xbd, 0x3b, 0x5e, 0x93, 0xcd, 0x13, 0x00, 0x61, 0xc2, 0xb0,
+	0x18, 0x67, 0x22, 0xea, 0xea, 0xe1, 0xe3, 0x35, 0x79, 0x4c, 0x3d, 0x92, 0x9f, 0x03, 0xc6, 0x19,
+	0xad, 0xcc, 0x92, 0x4f, 0x72, 0x02, 0x75, 0x16, 0xf2, 0x4b, 0xcf, 0xb7, 0x6f, 0xa4, 0x7f, 0x9a,
+	0xb0, 0xf4, 0x60, 0xd5, 0xd2, 0xc8, 0x9e, 0xb8, 0x68, 0x7d, 0x85, 0x41, 0xc0, 0x26, 0x48, 0x6f,
+	0xff, 0xd5, 0x41, 0xa8, 0xa4, 0xe6, 0x49, 0x03, 0xd4, 0xf8, 0x96, 0x55, 0xa8, 0x6a, 0x5b, 0x9b,
+	0x2e, 0x81, 0xba, 0xe9, 0x12, 0xb4, 0xa1, 0x64, 0x7a, 0x2e, 0x47, 0x97, 0xcb, 0x6a, 0xd1, 0x44,
+	0xd4, 0x7f, 0x52, 0xa0, 0x24, 0xce, 0x19, 0x5a, 0x2b, 0xa7, 0xac, 0x44, 0xa2, 0xfe, 0x9b, 0x48,
+	0x56, 0x86, 0x85, 0xb6, 0x73, 0x58, 0xe8, 0x53, 0xa8, 0xc9, 0x34, 0x87, 0xd3, 0x29, 0xf3, 0xaf,
+	0x57, 0x3c, 0x3b, 0x48, 0x4a, 0x25, 0x26, 0x84, 0x0c, 0x5b, 0x96, 0x60, 0xdb, 0x8c, 0xd0, 0x36,
+	0xa4, 0x47, 0xff, 0x4d, 0x85, 0x86, 0x38, 0x8f, 0x22, 0xf7, 0x6d, 0xbc, 0x62, 0xce, 0x07, 0x6f,
+	0xb6, 0xe1, 0x9a, 0x66, 0x7b, 0xb2, 0xa1, 0xd9, 0x52, 0xaf, 0x3e, 0x68, 0xc3, 0xd1, 0x6d, 0x0d,
+	0xb7, 0x23, 0xe1, 0xff, 0x83, 0xa2, 0x77, 0x71, 0x11, 0x20, 0x8f, 0x73, 0x1c, 0x4b, 0xfa, 0x1b,
+	0xd8, 0xbb, 0x1d, 0xc1, 0x88, 0xfb, 0xc8, 0xa6, 0x4b, 0xe6, 0x94, 0x65, 0x73, 0x0b, 0xed, 0xaa,
+	0xde, 0x6e, 0xd7, 0x9f, 0x15, 0xa8, 0x4a, 0x2f, 0xd1, 0x41, 0x8e, 0xbb, 0x5b, 0x56, 0xfb, 0x4f,
+	0x5a, 0x36, 0xbf, 0xbb, 0x65, 0xfb, 0x40, 0x16, 0x1c, 0x4b, 0x1a, 0xb7, 0x0d, 0xa5, 0xa9, 0x3c,
+	0x22, 0x76, 0x32, 0x11, 0xf5, 0x33, 0xb8, 0x93, 0x4d, 0x92, 0x9d, 0x74, 0xf2, 0x08, 0x1a, 0x62,
+	0x00, 0x1b, 0x3e, 0x9a, 0x68, 0x5f, 0xa1, 0x15, 0x17, 0xa1, 0x2e, 0x50, 0x1a, 0x83, 0x3a, 0x40,
+	0x79, 0xc4, 0x19, 0x0f, 0x28, 0x7e, 0xaf, 0xff, 0xa2, 0x40, 0x35, 0x12, 0x12, 0xe3, 0x07, 0x00,
+	0x61, 0x80, 0x96, 0x11, 0xcc, 0x98, 0x99, 0x26, 0x3d, 0x42, 0x46, 0x11, 0x40, 0x3e, 0x81, 0x26,
+	0xbb, 0x62, 0xb6, 0xc3, 0xc6, 0x0e, 0xc6, 0x1c, 0x79, 0x44, 0x23, 0x85, 0x25, 0xf1, 0x11, 0x34,
+	0x84, 0x9d, 0xb4, 0xad, 0xe3, 0xa2, 0xd7, 0x23, 0x34, 0xbd, 0x00, 0xe4, 0x19, 0xdc, 0xcd, 0xec,
+	0x65, 0x5c, 0xf9, 0x50, 0x93, 0x54, 0x95, 0xfe, 0xa0, 0x7f, 0x07, 0xf5, 0x5b, 0x45, 0x21, 0x04,
+	0xf2, 0xe2, 0x76, 0x88, 0xed, 0x82, 0x8a, 0xef, 0xdb, 0x2f, 0x86, 0xba, 0xf4, 0x62, 0x88, 0xbe,
+	0x0a, 0xc7, 0x8e, 0x6d, 0x1a, 0xef, 0xf0, 0x3a, 0x1e, 0x75, 0x15, 0x89, 0x7c, 0x89, 0xd7, 0x7a,
+	0x03, 0x6a, 0x03, 0x16, 0x5c, 0x8e, 0x3d, 0xe6, 0x5b, 0x51, 0x86, 0xfe, 0x50, 0xa1, 0x91, 0x02,
+	0x22, 0x6f, 0xe4, 0xff, 0x50, 0x4a, 0xde, 0x35, 0x59, 0x81, 0xa2, 0x2b, 0x1f, 0xb0, 0x4f, 0xa1,
+	0x25, 0x14, 0xa6, 0xe7, 0xba, 0x28, 0x9e, 0xfe, 0x20, 0xce, 0x4f, 0x33, 0xc2, 0xbf, 0xc8, 0x60,
+	0xf2, 0x14, 0xee, 0x8c, 0x3d, 0x8f, 0x07, 0xdc, 0x67, 0x33, 0x83, 0x59, 0x96, 0x8f, 0x41, 0x20,
+	0x9c, 0xa9, 0xd0, 0x56, 0xaa, 0x38, 0x92, 0x78, 0x64, 0xd7, 0x8e, 0x26, 0x87, 0xcb, 0x9c, 0x94,
+	0x9b, 0x17, 0xdc, 0x66, 0x82, 0x2f, 0x50, 0x71, 0xbe, 0x44, 0x95, 0xdb, 0x4c, 0x33, 0xc1, 0x13,
+	0xea, 0x4b, 0x28, 0x04, 0x51, 0x3c, 0x62, 0x9f, 0xa9, 0x1e, 0x1e, 0xac, 0xe9, 0xff, 0xac, 0x33,
+	0xa8, 0xe4, 0x92, 0xfb, 0x00, 0x59, 0x74, 0x62, 0x89, 0x29, 0xd3, 0x05, 0x84, 0xbc, 0x80, 0x62,
+	0x38, 0xe3, 0xf6, 0x14, 0xdb, 0x65, 0x61, 0x75, 0xbf, 0x2f, 0x77, 0xc8, 0x7e, 0xb2, 0x43, 0xf6,
+	0x07, 0xf1, 0x0e, 0x49, 0x63, 0xe2, 0x13, 0x0a, 0xcd, 0xa5, 0xc5, 0x89, 0x94, 0x40, 0x3b, 0x3d,
+	0x3f, 0x6b, 0xe5, 0xa2, 0x8f, 0x57, 0x27, 0x67, 0x2d, 0x85, 0xd4, 0xa1, 0xf2, 0xea, 0xe4, 0xcc,
+	0x38, 0x3a, 0x1f, 0x0c, 0xcf, 0x5a, 0x2a, 0x69, 0x00, 0x44, 0x22, 0x3d, 0x39, 0x3d, 0x1a, 0xd2,
+	0x96, 0x16, 0xc9, 0xa7, 0xe7, 0xa9, 0x9c, 0x3f, 0xfc, 0x4b, 0x83, 0x56, 0x76, 0x75, 0xa8, 0x08,
+	0x87, 0x0c, 0xa0, 0x20, 0x30, 0xb2, 0xbf, 0x61, 0x88, 0x0e, 0xad, 0xce, 0xfd, 0x4d, 0x8f, 0xb9,
+	0x4c, 0x83, 0x9e, 0x23, 0x6f, 0xa1, 0x1c, 0x8f, 0x2a, 0x24, 0xdd, 0x5d, 0xd3, 0xb8, 0xf3, 0x78,
+	0x17, 0x43, 0x4e, 0x3b, 0x3d, 0xd7, 0x53, 0x9e, 0x2b, 0xe4, 0x35, 0x14, 0xe4, 0x1e, 0x73, 0x6f,
+	0xdb, 0x4e, 0xd1, 0x79, 0xb8, 0x4d, 0x9b, 0x7a, 0xda, 0x53, 0xc8, 0x1b, 0x28, 0xc6, 0x43, 0xf0,
+	0x60, 0xc3, 0x2f, 0x52, 0xdd, 0xf9, 0x78, 0xab, 0x3a, 0x0b, 0x7e, 0x10, 0x39, 0x18, 0xf5, 0x41,
+	0x67, 0x7d, 0xb7, 0x44, 0x43, 0xa5, 0xb3, 0xbd, 0x93, 0xf4, 0x1c, 0xf9, 0x1a, 0x2a, 0xe9, 0x95,
+	0x22, 0x6b, 0x32, 0xbe, 0x78, 0x01, 0x3b, 0xdd, 0x2d, 0x7a, 0x71, 0xa4, 0x9e, 0x7b, 0xae, 0x1c,
+	0xe7, 0xdf, 0xaa, 0xb3, 0xf1, 0xb8, 0x28, 0xba, 0xec, 0xe5, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff,
+	0xda, 0xcb, 0x89, 0xc5, 0xe9, 0x0c, 0x00, 0x00,
 }
diff --git a/pkg/pb/piecestore.proto b/pkg/pb/piecestore.proto
index 131a0694a..416aa1a86 100644
--- a/pkg/pb/piecestore.proto
+++ b/pkg/pb/piecestore.proto
@@ -66,6 +66,7 @@ message PieceId {
   string id = 1;
 
   SignedMessage authorization = 2;
+  bytes satellite_id = 3 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
 }
 
 message PieceSummary {
@@ -96,6 +97,7 @@ message PieceDelete {
   // TODO: may want to use customtype and fixed-length byte slice
   string id = 1;
   SignedMessage authorization = 3;
+  bytes satellite_id = 4 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
 }
 
 message PieceDeleteSummary {
@@ -133,4 +135,4 @@ message DashboardStats {
   StatSummary stats = 6;
   bool connection = 7;
   google.protobuf.Duration uptime = 8;
-}
+}
\ No newline at end of file
diff --git a/pkg/piecestore/psclient/client.go b/pkg/piecestore/psclient/client.go
index 77d72ade7..d91865748 100644
--- a/pkg/piecestore/psclient/client.go
+++ b/pkg/piecestore/psclient/client.go
@@ -43,9 +43,9 @@ func init() {
 // Client is an interface describing the functions for interacting with piecestore nodes
 type Client interface {
 	Meta(ctx context.Context, id PieceID) (*pb.PieceSummary, error)
-	Put(ctx context.Context, id PieceID, data io.Reader, ttl time.Time, ba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) error
-	Get(ctx context.Context, id PieceID, size int64, ba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (ranger.Ranger, error)
-	Delete(ctx context.Context, pieceID PieceID, authorization *pb.SignedMessage) error
+	Put(ctx context.Context, id PieceID, data io.Reader, ttl time.Time, ba *pb.PayerBandwidthAllocation) error
+	Get(ctx context.Context, id PieceID, size int64, ba *pb.PayerBandwidthAllocation) (ranger.Ranger, error)
+	Delete(ctx context.Context, pieceID PieceID, satelliteID storj.NodeID) error
 	io.Closer
 }
 
@@ -117,15 +117,25 @@ func (ps *PieceStore) Meta(ctx context.Context, id PieceID) (*pb.PieceSummary, e
 }
 
 // Put uploads a Piece to a piece store Server
-func (ps *PieceStore) Put(ctx context.Context, id PieceID, data io.Reader, ttl time.Time, ba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) error {
+func (ps *PieceStore) Put(ctx context.Context, id PieceID, data io.Reader, ttl time.Time, pba *pb.PayerBandwidthAllocation) error {
 	stream, err := ps.client.Store(ctx)
 	if err != nil {
 		return err
 	}
 
+	// Making a clone, otherwise there will be a data race
+	// when another goroutine tries to write the cached size
+	// of this instance at the same time.
+	pbaClone := pba.Clone()
+
+	rba := &pb.RenterBandwidthAllocation{
+		PayerAllocation: pbaClone,
+		StorageNodeId:   ps.remoteID,
+	}
+
 	msg := &pb.PieceStore{
-		PieceData:     &pb.PieceStore_PieceData{Id: id.String(), ExpirationUnixSec: ttl.Unix()},
-		Authorization: authorization,
+		PieceData:           &pb.PieceStore_PieceData{Id: id.String(), ExpirationUnixSec: ttl.Unix()},
+		BandwidthAllocation: rba,
 	}
 	if err = stream.Send(msg); err != nil {
 		if _, closeErr := stream.CloseAndRecv(); closeErr != nil {
@@ -135,7 +145,7 @@ func (ps *PieceStore) Put(ctx context.Context, id PieceID, data io.Reader, ttl t
 		return fmt.Errorf("%v.Send() = %v", stream, err)
 	}
 
-	writer := &StreamWriter{signer: ps, stream: stream, pba: ba}
+	writer := &StreamWriter{signer: ps, stream: stream, rba: rba}
 
 	defer func() {
 		if err := writer.Close(); err != nil && err != io.EOF {
@@ -154,18 +164,18 @@ func (ps *PieceStore) Put(ctx context.Context, id PieceID, data io.Reader, ttl t
 }
 
 // Get begins downloading a Piece from a piece store Server
-func (ps *PieceStore) Get(ctx context.Context, id PieceID, size int64, ba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (ranger.Ranger, error) {
+func (ps *PieceStore) Get(ctx context.Context, id PieceID, size int64, ba *pb.PayerBandwidthAllocation) (ranger.Ranger, error) {
 	stream, err := ps.client.Retrieve(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	return PieceRangerSize(ps, stream, id, size, ba, authorization), nil
+	return PieceRangerSize(ps, stream, id, size, ba), nil
 }
 
 // Delete a Piece from a piece store Server
-func (ps *PieceStore) Delete(ctx context.Context, id PieceID, authorization *pb.SignedMessage) error {
-	reply, err := ps.client.Delete(ctx, &pb.PieceDelete{Id: id.String(), Authorization: authorization})
+func (ps *PieceStore) Delete(ctx context.Context, id PieceID, satelliteID storj.NodeID) error {
+	reply, err := ps.client.Delete(ctx, &pb.PieceDelete{Id: id.String(), SatelliteId: satelliteID})
 	if err != nil {
 		return err
 	}
diff --git a/pkg/piecestore/psclient/pieceranger.go b/pkg/piecestore/psclient/pieceranger.go
index cf1b01fcc..d365e19c2 100644
--- a/pkg/piecestore/psclient/pieceranger.go
+++ b/pkg/piecestore/psclient/pieceranger.go
@@ -19,28 +19,27 @@ import (
 var Error = errs.Class("pieceRanger error")
 
 type pieceRanger struct {
-	c             *PieceStore
-	id            PieceID
-	size          int64
-	stream        pb.PieceStoreRoutes_RetrieveClient
-	pba           *pb.PayerBandwidthAllocation
-	authorization *pb.SignedMessage
+	c      *PieceStore
+	id     PieceID
+	size   int64
+	stream pb.PieceStoreRoutes_RetrieveClient
+	pba    *pb.PayerBandwidthAllocation
 }
 
 // PieceRanger PieceRanger returns a Ranger from a PieceID.
-func PieceRanger(ctx context.Context, c *PieceStore, stream pb.PieceStoreRoutes_RetrieveClient, id PieceID, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (ranger.Ranger, error) {
+func PieceRanger(ctx context.Context, c *PieceStore, stream pb.PieceStoreRoutes_RetrieveClient, id PieceID, pba *pb.PayerBandwidthAllocation) (ranger.Ranger, error) {
 	piece, err := c.Meta(ctx, id)
 	if err != nil {
 		return nil, err
 	}
-	return &pieceRanger{c: c, id: id, size: piece.PieceSize, stream: stream, pba: pba, authorization: authorization}, nil
+	return &pieceRanger{c: c, id: id, size: piece.PieceSize, stream: stream, pba: pba}, nil
 }
 
 // PieceRangerSize creates a PieceRanger with known size.
 // Use it if you know the piece size. This will safe the extra request for
 // retrieving the piece size from the piece storage.
-func PieceRangerSize(c *PieceStore, stream pb.PieceStoreRoutes_RetrieveClient, id PieceID, size int64, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) ranger.Ranger {
-	return &pieceRanger{c: c, id: id, size: size, stream: stream, pba: pba, authorization: authorization}
+func PieceRangerSize(c *PieceStore, stream pb.PieceStoreRoutes_RetrieveClient, id PieceID, size int64, pba *pb.PayerBandwidthAllocation) ranger.Ranger {
+	return &pieceRanger{c: c, id: id, size: size, stream: stream, pba: pba}
 }
 
 // Size implements Ranger.Size
@@ -63,10 +62,23 @@ func (r *pieceRanger) Range(ctx context.Context, offset, length int64) (io.ReadC
 		return ioutil.NopCloser(bytes.NewReader([]byte{})), nil
 	}
 
+	// Making a copy, otherwise there will be a data race
+	// when another goroutine tries to write the cached size
+	// of this instance at the same time.
+	pbaClone := r.pba.Clone()
+
+	rba := &pb.RenterBandwidthAllocation{
+		PayerAllocation: pbaClone,
+		StorageNodeId:   r.c.remoteID,
+	}
+
 	// send piece data
-	if err := r.stream.Send(&pb.PieceRetrieval{PieceData: &pb.PieceRetrieval_PieceData{Id: r.id.String(), PieceSize: length, Offset: offset}, Authorization: r.authorization}); err != nil {
+	if err := r.stream.Send(&pb.PieceRetrieval{
+		PieceData:           &pb.PieceRetrieval_PieceData{Id: r.id.String(), PieceSize: length, Offset: offset},
+		BandwidthAllocation: rba,
+	}); err != nil {
 		return nil, err
 	}
 
-	return NewStreamReader(r.c, r.stream, r.pba, r.size), nil
+	return NewStreamReader(r.c, r.stream, rba, r.size), nil
 }
diff --git a/pkg/piecestore/psclient/pieceranger_test.go b/pkg/piecestore/psclient/pieceranger_test.go
index c756f6925..1db2ce4c2 100644
--- a/pkg/piecestore/psclient/pieceranger_test.go
+++ b/pkg/piecestore/psclient/pieceranger_test.go
@@ -59,13 +59,7 @@ func TestPieceRanger(t *testing.T) {
 		pid := NewPieceID()
 
 		if tt.offset >= 0 && tt.length > 0 && tt.offset+tt.length <= tt.size {
-			msg1 := &pb.PieceRetrieval{
-				PieceData: &pb.PieceRetrieval_PieceData{
-					Id: pid.String(), PieceSize: tt.length, Offset: tt.offset,
-				},
-			}
-
-			stream.EXPECT().Send(msg1).Return(nil)
+			stream.EXPECT().Send(gomock.Any()).Return(nil)
 			stream.EXPECT().Send(gomock.Any()).Return(nil).MinTimes(0).MaxTimes(1)
 			stream.EXPECT().Recv().Return(
 				&pb.PieceRetrievalStream{
@@ -86,7 +80,7 @@ func TestPieceRanger(t *testing.T) {
 		target.Type.DPanicOnInvalid("pr test")
 		c, err := NewCustomRoute(route, target, 32*1024, id)
 		assert.NoError(t, err)
-		rr, err := PieceRanger(ctx, c, stream, pid, &pb.PayerBandwidthAllocation{}, nil)
+		rr, err := PieceRanger(ctx, c, stream, pid, &pb.PayerBandwidthAllocation{})
 		if assert.NoError(t, err, errTag) {
 			assert.Equal(t, tt.size, rr.Size(), errTag)
 		}
@@ -139,13 +133,7 @@ func TestPieceRangerSize(t *testing.T) {
 		stream := pb.NewMockPieceStoreRoutes_RetrieveClient(ctrl)
 
 		if tt.offset >= 0 && tt.length > 0 && tt.offset+tt.length <= tt.size {
-			msg1 := &pb.PieceRetrieval{
-				PieceData: &pb.PieceRetrieval_PieceData{
-					Id: pid.String(), PieceSize: tt.length, Offset: tt.offset,
-				},
-			}
-
-			stream.EXPECT().Send(msg1).Return(nil)
+			stream.EXPECT().Send(gomock.Any()).Return(nil)
 			stream.EXPECT().Send(gomock.Any()).Return(nil).MinTimes(0).MaxTimes(1)
 			stream.EXPECT().Recv().Return(
 				&pb.PieceRetrievalStream{
@@ -168,7 +156,7 @@ func TestPieceRangerSize(t *testing.T) {
 		target.Type.DPanicOnInvalid("pr test 2")
 		c, err := NewCustomRoute(route, target, 32*1024, id)
 		assert.NoError(t, err)
-		rr := PieceRangerSize(c, stream, pid, tt.size, &pb.PayerBandwidthAllocation{}, nil)
+		rr := PieceRangerSize(c, stream, pid, tt.size, &pb.PayerBandwidthAllocation{})
 		assert.Equal(t, tt.size, rr.Size(), errTag)
 		r, err := rr.Range(ctx, tt.offset, tt.length)
 		if tt.errString != "" {
diff --git a/pkg/piecestore/psclient/readerwriter.go b/pkg/piecestore/psclient/readerwriter.go
index d74a6482b..d7a8206a0 100644
--- a/pkg/piecestore/psclient/readerwriter.go
+++ b/pkg/piecestore/psclient/readerwriter.go
@@ -19,24 +19,22 @@ type StreamWriter struct {
 	stream       pb.PieceStoreRoutes_StoreClient
 	signer       *PieceStore // We need this for signing
 	totalWritten int64
-	pba          *pb.PayerBandwidthAllocation
+	rba          *pb.RenterBandwidthAllocation
 }
 
 // Write Piece data to a piece store server upload stream
 func (s *StreamWriter) Write(b []byte) (int, error) {
 	updatedAllocation := s.totalWritten + int64(len(b))
-	rba := &pb.RenterBandwidthAllocation{
-		PayerAllocation: *s.pba,
-		Total:           updatedAllocation,
-		StorageNodeId:   s.signer.remoteID,
-	}
-	err := auth.SignMessage(rba, *s.signer.selfID)
+
+	s.rba.Total = updatedAllocation
+	err := auth.SignMessage(s.rba, *s.signer.selfID)
 	if err != nil {
 		return 0, err
 	}
+
 	msg := &pb.PieceStore{
 		PieceData:           &pb.PieceStore_PieceData{Content: b},
-		BandwidthAllocation: rba,
+		BandwidthAllocation: s.rba,
 	}
 	s.totalWritten = updatedAllocation
 	// Second we send the actual content
@@ -70,7 +68,7 @@ type StreamReader struct {
 }
 
 // NewStreamReader creates a StreamReader for reading data from the piece store server
-func NewStreamReader(client *PieceStore, stream pb.PieceStoreRoutes_RetrieveClient, pba *pb.PayerBandwidthAllocation, size int64) *StreamReader {
+func NewStreamReader(client *PieceStore, stream pb.PieceStoreRoutes_RetrieveClient, rba *pb.RenterBandwidthAllocation, size int64) *StreamReader {
 	sr := &StreamReader{
 		pendingAllocs: sync2.NewThrottle(),
 		client:        client,
@@ -92,11 +90,9 @@ func NewStreamReader(client *PieceStore, stream pb.PieceStoreRoutes_RetrieveClie
 			if sr.allocated+trustedSize > size {
 				allocate = size - sr.allocated
 			}
-			rba := &pb.RenterBandwidthAllocation{
-				PayerAllocation: *pba,
-				Total:           sr.allocated + allocate,
-				StorageNodeId:   sr.client.remoteID,
-			}
+
+			rba.Total = sr.allocated + allocate
+
 			err := auth.SignMessage(rba, *client.selfID)
 			if err != nil {
 				sr.pendingAllocs.Fail(err)
diff --git a/pkg/piecestore/psserver/retrieve.go b/pkg/piecestore/psserver/retrieve.go
index 850ba2564..c1c57c4a8 100644
--- a/pkg/piecestore/psserver/retrieve.go
+++ b/pkg/piecestore/psserver/retrieve.go
@@ -35,17 +35,22 @@ func (s *Server) Retrieve(stream pb.PieceStoreRoutes_RetrieveServer) (err error)
 		return RetrieveError.New("error receiving piece data")
 	}
 
-	authorization := recv.GetAuthorization()
-	if err := s.verifier(authorization); err != nil {
-		return ServerError.Wrap(err)
-	}
-
 	pd := recv.GetPieceData()
 	if pd == nil {
 		return RetrieveError.New("PieceStore message is nil")
 	}
 
-	id, err := getNamespacedPieceID([]byte(pd.GetId()), getNamespace(authorization))
+	rba := recv.GetBandwidthAllocation()
+	if rba == nil {
+		return RetrieveError.New("RenterBandwidthAllocation message is nil")
+	}
+
+	pba := rba.PayerAllocation
+	if pb.Equal(&pba, &pb.PayerBandwidthAllocation{}) {
+		return RetrieveError.New("PayerBandwidthAllocation message is empty")
+	}
+
+	id, err := getNamespacedPieceID([]byte(pd.GetId()), pba.SatelliteId.Bytes())
 	if err != nil {
 		return err
 	}
diff --git a/pkg/piecestore/psserver/server.go b/pkg/piecestore/psserver/server.go
index d0e43ce23..14a4faf5f 100644
--- a/pkg/piecestore/psserver/server.go
+++ b/pkg/piecestore/psserver/server.go
@@ -12,7 +12,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"regexp"
 	"strings"
 	"time"
 
@@ -64,7 +63,6 @@ type Server struct {
 	totalAllocated   int64 // TODO: use memory.Size
 	totalBwAllocated int64 // TODO: use memory.Size
 	whitelist        map[storj.NodeID]crypto.PublicKey
-	verifier         auth.SignedMessageVerifier
 	kad              *kademlia.Kademlia
 }
 
@@ -143,7 +141,6 @@ func NewEndpoint(log *zap.Logger, config Config, storage *pstore.Storage, db *ps
 		totalAllocated:   allocatedDiskSpace,
 		totalBwAllocated: allocatedBandwidth,
 		whitelist:        whitelist,
-		verifier:         auth.NewSignedMessageVerifier(),
 		kad:              k,
 	}, nil
 }
@@ -163,12 +160,7 @@ func (s *Server) Stop(ctx context.Context) error {
 func (s *Server) Piece(ctx context.Context, in *pb.PieceId) (*pb.PieceSummary, error) {
 	s.log.Debug("Getting Meta", zap.String("Piece ID", in.GetId()))
 
-	authorization := in.GetAuthorization()
-	if err := s.verifier(authorization); err != nil {
-		return nil, ServerError.Wrap(err)
-	}
-
-	id, err := getNamespacedPieceID([]byte(in.GetId()), getNamespace(authorization))
+	id, err := getNamespacedPieceID([]byte(in.GetId()), in.SatelliteId.Bytes())
 	if err != nil {
 		return nil, err
 	}
@@ -178,15 +170,6 @@ func (s *Server) Piece(ctx context.Context, in *pb.PieceId) (*pb.PieceSummary, e
 		return nil, err
 	}
 
-	match, err := regexp.MatchString("^[A-Za-z0-9]{20,64}$", id)
-	if err != nil {
-		return nil, err
-	}
-
-	if !match {
-		return nil, ServerError.New("invalid ID")
-	}
-
 	fileInfo, err := os.Stat(path)
 	if err != nil {
 		return nil, err
@@ -261,11 +244,8 @@ func (s *Server) Dashboard(in *pb.DashboardReq, stream pb.PieceStoreRoutes_Dashb
 // Delete -- Delete data by Id from piecestore
 func (s *Server) Delete(ctx context.Context, in *pb.PieceDelete) (*pb.PieceDeleteSummary, error) {
 	s.log.Debug("Deleting", zap.String("Piece ID", fmt.Sprint(in.GetId())))
-	authorization := in.GetAuthorization()
-	if err := s.verifier(authorization); err != nil {
-		return nil, ServerError.Wrap(err)
-	}
-	id, err := getNamespacedPieceID([]byte(in.GetId()), getNamespace(authorization))
+
+	id, err := getNamespacedPieceID([]byte(in.GetId()), in.SatelliteId.Bytes())
 	if err != nil {
 		return nil, err
 	}
@@ -373,10 +353,6 @@ func getNamespacedPieceID(pieceID, namespace []byte) (string, error) {
 	return base58.Encode(h), nil
 }
 
-func getNamespace(signedMessage *pb.SignedMessage) []byte {
-	return signedMessage.GetData()
-}
-
 func (s *Server) getDashboardData(ctx context.Context) (*pb.DashboardStats, error) {
 	statsSummary, err := s.retrieveStats()
 	if err != nil {
diff --git a/pkg/piecestore/psserver/server_test.go b/pkg/piecestore/psserver/server_test.go
index 44a0547db..b0dca2a0f 100644
--- a/pkg/piecestore/psserver/server_test.go
+++ b/pkg/piecestore/psserver/server_test.go
@@ -47,12 +47,15 @@ func TestPiece(t *testing.T) {
 	s, c, cleanup := NewTest(ctx, t, snID, upID, []storj.NodeID{})
 	defer cleanup()
 
-	if err := writeFile(s, "11111111111111111111"); err != nil {
+	namespacedID, err := getNamespacedPieceID([]byte("11111111111111111111"), snID.ID.Bytes())
+	require.NoError(t, err)
+
+	if err := writeFile(s, namespacedID); err != nil {
 		t.Errorf("Error: %v\nCould not create test piece", err)
 		return
 	}
 
-	defer func() { _ = s.storage.Delete("11111111111111111111") }()
+	defer func() { _ = s.storage.Delete(namespacedID) }()
 
 	// set up test cases
 	tests := []struct {
@@ -67,41 +70,35 @@ func TestPiece(t *testing.T) {
 			expiration: 9999999999,
 			err:        "",
 		},
-		{ // server should err with invalid id
-			id:         "123",
-			size:       5,
-			expiration: 9999999999,
-			err:        "rpc error: code = Unknown desc = piecestore error: invalid id length",
-		},
 		{ // server should err with nonexistent file
 			id:         "22222222222222222222",
 			size:       5,
 			expiration: 9999999999,
 			err: fmt.Sprintf("rpc error: code = Unknown desc = stat %s: no such file or directory", func() string {
-				path, _ := s.storage.PiecePath("22222222222222222222")
+				namespacedID, err := getNamespacedPieceID([]byte("22222222222222222222"), snID.ID.Bytes())
+				require.NoError(t, err)
+				path, _ := s.storage.PiecePath(namespacedID)
 				return path
 			}()),
 		},
-		{ // server should err with invalid TTL
-			id:         "22222222222222222222;DELETE*FROM TTL;;;;",
-			size:       5,
-			expiration: 9999999999,
-			err:        "rpc error: code = Unknown desc = PSServer error: invalid ID",
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run("", func(t *testing.T) {
+
+			namespacedID, err := getNamespacedPieceID([]byte(tt.id), snID.ID.Bytes())
+			require.NoError(t, err)
+
 			// simulate piece TTL entry
-			_, err := s.DB.DB.Exec(fmt.Sprintf(`INSERT INTO ttl (id, created, expires) VALUES ("%s", "%d", "%d")`, tt.id, 1234567890, tt.expiration))
+			_, err = s.DB.DB.Exec(fmt.Sprintf(`INSERT INTO ttl (id, created, expires) VALUES ("%s", "%d", "%d")`, namespacedID, 1234567890, tt.expiration))
 			require.NoError(t, err)
 
 			defer func() {
-				_, err := s.DB.DB.Exec(fmt.Sprintf(`DELETE FROM ttl WHERE id="%s"`, tt.id))
+				_, err := s.DB.DB.Exec(fmt.Sprintf(`DELETE FROM ttl WHERE id="%s"`, namespacedID))
 				require.NoError(t, err)
 			}()
 
-			req := &pb.PieceId{Id: tt.id}
+			req := &pb.PieceId{Id: tt.id, SatelliteId: snID.ID}
 			resp, err := c.Piece(ctx, req)
 
 			if tt.err != "" {
@@ -305,16 +302,6 @@ func TestStore(t *testing.T) {
 			totalReceived: 5,
 			err:           "",
 		},
-		{ // should err with invalid id length
-			id:            "butts",
-			satelliteID:   satID.ID,
-			whitelist:     []storj.NodeID{satID.ID},
-			ttl:           9999999999,
-			content:       []byte("xyzwq"),
-			message:       "",
-			totalReceived: 0,
-			err:           "rpc error: code = Unknown desc = piecestore error: invalid id length",
-		},
 		{ // should err with piece ID not specified
 			id:            "",
 			satelliteID:   satID.ID,
@@ -337,14 +324,19 @@ func TestStore(t *testing.T) {
 			stream, err := c.Store(ctx)
 			require.NoError(t, err)
 
-			// Write the buffer to the stream we opened earlier
-			err = stream.Send(&pb.PieceStore{PieceData: &pb.PieceStore_PieceData{Id: tt.id, ExpirationUnixSec: tt.ttl}})
-			require.NoError(t, err)
-			// Send Bandwidth Allocation Data
+			// Create Bandwidth Allocation Data
 			pba, err := testbwagreement.GeneratePayerBandwidthAllocation(pb.BandwidthAction_PUT, snID, upID, time.Hour)
 			require.NoError(t, err)
 			rba, err := testbwagreement.GenerateRenterBandwidthAllocation(pba, snID.ID, upID, tt.totalReceived)
 			require.NoError(t, err)
+
+			// Write the buffer to the stream we opened earlier
+			err = stream.Send(&pb.PieceStore{
+				PieceData:           &pb.PieceStore_PieceData{Id: tt.id, ExpirationUnixSec: tt.ttl},
+				BandwidthAllocation: rba,
+			})
+			require.NoError(t, err)
+
 			msg := &pb.PieceStore{
 				PieceData:           &pb.PieceStore_PieceData{Content: tt.content},
 				BandwidthAllocation: rba,
@@ -443,12 +435,7 @@ func TestPbaValidation(t *testing.T) {
 			stream, err := c.Store(ctx)
 			require.NoError(t, err)
 
-			//cleanup incase tests previously paniced
-			_ = s.storage.Delete("99999999999999999999")
-			// Write the buffer to the stream we opened earlier
-			err = stream.Send(&pb.PieceStore{PieceData: &pb.PieceStore_PieceData{Id: "99999999999999999999", ExpirationUnixSec: 9999999999}})
-			require.NoError(t, err)
-			// Send Bandwidth Allocation Data
+			// Create Bandwidth Allocation Data
 			content := []byte("content")
 			pba, err := testbwagreement.GeneratePayerBandwidthAllocation(tt.action, satID1, upID, time.Hour)
 			require.NoError(t, err)
@@ -459,6 +446,15 @@ func TestPbaValidation(t *testing.T) {
 				BandwidthAllocation: rba,
 			}
 
+			//cleanup incase tests previously paniced
+			_ = s.storage.Delete("99999999999999999999")
+			// Write the buffer to the stream we opened earlier
+			err = stream.Send(&pb.PieceStore{
+				PieceData:           &pb.PieceStore_PieceData{Id: "99999999999999999999", ExpirationUnixSec: 9999999999},
+				BandwidthAllocation: rba,
+			})
+			require.NoError(t, err)
+
 			// Write the buffer to the stream we opened earlier
 			err = stream.Send(msg)
 			if err != io.EOF && err != nil {
@@ -498,11 +494,6 @@ func TestDelete(t *testing.T) {
 			message: "OK",
 			err:     "",
 		},
-		{ // should err with invalid id length
-			id:      "123",
-			message: "rpc error: code = Unknown desc = piecestore error: invalid id length",
-			err:     "rpc error: code = Unknown desc = piecestore error: invalid id length",
-		},
 		{ // should return OK with nonexistent file
 			id:      "22222222222222222223",
 			message: "OK",
@@ -565,9 +556,6 @@ func NewTest(ctx context.Context, t *testing.T, snID, upID *identity.FullIdentit
 	require.NoError(t, err)
 	err = psDB.Migration().Run(zap.NewNop(), psDB)
 	require.NoError(t, err)
-	verifier := func(authorization *pb.SignedMessage) error {
-		return nil
-	}
 	whitelist := make(map[storj.NodeID]crypto.PublicKey)
 	for _, id := range ids {
 		whitelist[id] = nil
@@ -576,7 +564,6 @@ func NewTest(ctx context.Context, t *testing.T, snID, upID *identity.FullIdentit
 		log:              zaptest.NewLogger(t),
 		storage:          storage,
 		DB:               psDB,
-		verifier:         verifier,
 		totalAllocated:   math.MaxInt64,
 		totalBwAllocated: math.MaxInt64,
 		whitelist:        whitelist,
diff --git a/pkg/piecestore/psserver/store.go b/pkg/piecestore/psserver/store.go
index 6f2cfd3b5..4aa0b78cf 100644
--- a/pkg/piecestore/psserver/store.go
+++ b/pkg/piecestore/psserver/store.go
@@ -35,11 +35,6 @@ func (s *Server) Store(reqStream pb.PieceStoreRoutes_StoreServer) (err error) {
 		return StoreError.New("error receiving Piece metadata")
 	}
 
-	authorization := recv.GetAuthorization()
-	if err := s.verifier(authorization); err != nil {
-		return ServerError.Wrap(err)
-	}
-
 	pd := recv.GetPieceData()
 	if pd == nil {
 		return StoreError.New("PieceStore message is nil")
@@ -51,7 +46,17 @@ func (s *Server) Store(reqStream pb.PieceStoreRoutes_StoreServer) (err error) {
 		return StoreError.New("piece ID not specified")
 	}
 
-	id, err := getNamespacedPieceID([]byte(pd.GetId()), getNamespace(authorization))
+	rba := recv.GetBandwidthAllocation()
+	if rba == nil {
+		return StoreError.New("RenterBandwidthAllocation message is nil")
+	}
+
+	pba := rba.PayerAllocation
+	if pb.Equal(&pba, &pb.PayerBandwidthAllocation{}) {
+		return StoreError.New("PayerBandwidthAllocation message is empty")
+	}
+
+	id, err := getNamespacedPieceID([]byte(pd.GetId()), pba.SatelliteId.Bytes())
 	if err != nil {
 		return err
 	}
diff --git a/pkg/pointerdb/allocation.go b/pkg/pointerdb/allocation.go
index d74c21e06..5e4a923cb 100644
--- a/pkg/pointerdb/allocation.go
+++ b/pkg/pointerdb/allocation.go
@@ -65,10 +65,8 @@ func (allocation *AllocationSigner) PayerBandwidthAllocation(ctx context.Context
 		Action:            action,
 		SerialNumber:      serialNum.String(),
 	}
-	if err := auth.SignMessage(pba, *allocation.satelliteIdentity); err != nil {
-		return nil, err
-	}
-	return pba, nil
+	err = auth.SignMessage(pba, *allocation.satelliteIdentity)
+	return pba, err
 }
 
 func (allocation *AllocationSigner) restrictActions(peerID storj.NodeID, action pb.BandwidthAction) error {
diff --git a/pkg/pointerdb/pdbclient/client.go b/pkg/pointerdb/pdbclient/client.go
index 460eaa33a..35a13118e 100644
--- a/pkg/pointerdb/pdbclient/client.go
+++ b/pkg/pointerdb/pdbclient/client.go
@@ -5,8 +5,6 @@ package pdbclient
 
 import (
 	"context"
-	"sync/atomic"
-	"unsafe"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
@@ -26,8 +24,7 @@ var (
 
 // PointerDB creates a grpcClient
 type PointerDB struct {
-	client        pb.PointerDBClient
-	authorization unsafe.Pointer // *pb.SignedMessage
+	client pb.PointerDBClient
 }
 
 // New Used as a public function
@@ -52,7 +49,6 @@ type Client interface {
 	List(ctx context.Context, prefix, startAfter, endBefore storj.Path, recursive bool, limit int, metaFlags uint32) (items []ListItem, more bool, err error)
 	Delete(ctx context.Context, path storj.Path) error
 
-	SignedMessage() *pb.SignedMessage
 	PayerBandwidthAllocation(context.Context, pb.BandwidthAction) (*pb.PayerBandwidthAllocation, error)
 
 	// Disconnect() error // TODO: implement
@@ -102,8 +98,6 @@ func (pdb *PointerDB) Get(ctx context.Context, path storj.Path) (pointer *pb.Poi
 		return nil, nil, nil, Error.Wrap(err)
 	}
 
-	atomic.StorePointer(&pdb.authorization, unsafe.Pointer(res.GetAuthorization()))
-
 	if res.GetPointer().GetType() == pb.Pointer_INLINE {
 		return res.GetPointer(), nodes, res.GetPba(), nil
 	}
@@ -174,8 +168,3 @@ func (pdb *PointerDB) PayerBandwidthAllocation(ctx context.Context, action pb.Ba
 	}
 	return response.GetPba(), nil
 }
-
-// SignedMessage gets signed message from last request
-func (pdb *PointerDB) SignedMessage() *pb.SignedMessage {
-	return (*pb.SignedMessage)(atomic.LoadPointer(&pdb.authorization))
-}
diff --git a/pkg/pointerdb/pdbclient/mocks/mock_client.go b/pkg/pointerdb/pdbclient/mocks/mock_client.go
index d11c9f67b..ba66f0daa 100644
--- a/pkg/pointerdb/pdbclient/mocks/mock_client.go
+++ b/pkg/pointerdb/pdbclient/mocks/mock_client.go
@@ -6,10 +6,8 @@ package mock_pointerdb
 
 import (
 	context "context"
-	reflect "reflect"
-
 	gomock "github.com/golang/mock/gomock"
-
+	reflect "reflect"
 	pb "storj.io/storj/pkg/pb"
 	pdbclient "storj.io/storj/pkg/pointerdb/pdbclient"
 )
@@ -39,6 +37,7 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder {
 
 // Delete mocks base method
 func (m *MockClient) Delete(arg0 context.Context, arg1 string) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Delete", arg0, arg1)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -46,11 +45,13 @@ func (m *MockClient) Delete(arg0 context.Context, arg1 string) error {
 
 // Delete indicates an expected call of Delete
 func (mr *MockClientMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClient)(nil).Delete), arg0, arg1)
 }
 
 // Get mocks base method
 func (m *MockClient) Get(arg0 context.Context, arg1 string) (*pb.Pointer, []*pb.Node, *pb.PayerBandwidthAllocation, error) {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get", arg0, arg1)
 	ret0, _ := ret[0].(*pb.Pointer)
 	ret1, _ := ret[1].([]*pb.Node)
@@ -61,11 +62,13 @@ func (m *MockClient) Get(arg0 context.Context, arg1 string) (*pb.Pointer, []*pb.
 
 // Get indicates an expected call of Get
 func (mr *MockClientMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0, arg1)
 }
 
 // List mocks base method
 func (m *MockClient) List(arg0 context.Context, arg1, arg2, arg3 string, arg4 bool, arg5 int, arg6 uint32) ([]pdbclient.ListItem, bool, error) {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
 	ret0, _ := ret[0].([]pdbclient.ListItem)
 	ret1, _ := ret[1].(bool)
@@ -75,11 +78,13 @@ func (m *MockClient) List(arg0 context.Context, arg1, arg2, arg3 string, arg4 bo
 
 // List indicates an expected call of List
 func (mr *MockClientMockRecorder) List(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
 }
 
 // PayerBandwidthAllocation mocks base method
 func (m *MockClient) PayerBandwidthAllocation(arg0 context.Context, arg1 pb.BandwidthAction) (*pb.PayerBandwidthAllocation, error) {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PayerBandwidthAllocation", arg0, arg1)
 	ret0, _ := ret[0].(*pb.PayerBandwidthAllocation)
 	ret1, _ := ret[1].(error)
@@ -88,11 +93,13 @@ func (m *MockClient) PayerBandwidthAllocation(arg0 context.Context, arg1 pb.Band
 
 // PayerBandwidthAllocation indicates an expected call of PayerBandwidthAllocation
 func (mr *MockClientMockRecorder) PayerBandwidthAllocation(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PayerBandwidthAllocation", reflect.TypeOf((*MockClient)(nil).PayerBandwidthAllocation), arg0, arg1)
 }
 
 // Put mocks base method
 func (m *MockClient) Put(arg0 context.Context, arg1 string, arg2 *pb.Pointer) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -100,17 +107,6 @@ func (m *MockClient) Put(arg0 context.Context, arg1 string, arg2 *pb.Pointer) er
 
 // Put indicates an expected call of Put
 func (mr *MockClientMockRecorder) Put(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), arg0, arg1, arg2)
 }
-
-// SignedMessage mocks base method
-func (m *MockClient) SignedMessage() *pb.SignedMessage {
-	ret := m.ctrl.Call(m, "SignedMessage")
-	ret0, _ := ret[0].(*pb.SignedMessage)
-	return ret0
-}
-
-// SignedMessage indicates an expected call of SignedMessage
-func (mr *MockClientMockRecorder) SignedMessage() *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignedMessage", reflect.TypeOf((*MockClient)(nil).SignedMessage))
-}
diff --git a/pkg/pointerdb/pointerdb.go b/pkg/pointerdb/pointerdb.go
index c60360972..335e0b72b 100644
--- a/pkg/pointerdb/pointerdb.go
+++ b/pkg/pointerdb/pointerdb.go
@@ -148,19 +148,12 @@ func (s *Server) Get(ctx context.Context, req *pb.GetRequest) (resp *pb.GetRespo
 		return nil, status.Errorf(codes.Internal, err.Error())
 	}
 
-	authorization, err := s.getSignedMessage()
-	if err != nil {
-		s.logger.Error("err getting signed message", zap.Error(err))
-		return nil, status.Errorf(codes.Internal, err.Error())
-	}
-
 	nodes := []*pb.Node{}
 
 	var r = &pb.GetResponse{
-		Pointer:       pointer,
-		Nodes:         nil,
-		Pba:           pba.GetPba(),
-		Authorization: authorization,
+		Pointer: pointer,
+		Nodes:   nil,
+		Pba:     pba.GetPba(),
 	}
 
 	if !s.config.Overlay || pointer.Remote == nil {
@@ -182,10 +175,9 @@ func (s *Server) Get(ctx context.Context, req *pb.GetRequest) (resp *pb.GetRespo
 		}
 	}
 	r = &pb.GetResponse{
-		Pointer:       pointer,
-		Nodes:         nodes,
-		Pba:           pba.GetPba(),
-		Authorization: authorization,
+		Pointer: pointer,
+		Nodes:   nodes,
+		Pba:     pba.GetPba(),
 	}
 
 	return r, nil
@@ -264,12 +256,3 @@ func (s *Server) PayerBandwidthAllocation(ctx context.Context, req *pb.PayerBand
 
 	return &pb.PayerBandwidthAllocationResponse{Pba: pba}, nil
 }
-
-func (s *Server) getSignedMessage() (*pb.SignedMessage, error) {
-	signature, err := auth.GenerateSignature(s.identity.ID.Bytes(), s.identity)
-	if err != nil {
-		return nil, err
-	}
-
-	return auth.NewSignedMessage(signature, s.identity)
-}
diff --git a/pkg/pointerdb/pointerdb_test.go b/pkg/pointerdb/pointerdb_test.go
index 8eae3ee88..40a197793 100644
--- a/pkg/pointerdb/pointerdb_test.go
+++ b/pkg/pointerdb/pointerdb_test.go
@@ -151,7 +151,6 @@ func TestServiceGet(t *testing.T) {
 			assert.NoError(t, err, errTag)
 			assert.True(t, pb.Equal(pr, resp.Pointer), errTag)
 
-			assert.NotNil(t, resp.GetAuthorization())
 			assert.NotNil(t, resp.GetPba())
 		}
 	}
diff --git a/pkg/storage/ec/client.go b/pkg/storage/ec/client.go
index 9d55188e4..941da857e 100644
--- a/pkg/storage/ec/client.go
+++ b/pkg/storage/ec/client.go
@@ -28,9 +28,9 @@ var mon = monkit.Package()
 
 // Client defines an interface for storing erasure coded data to piece store nodes
 type Client interface {
-	Put(ctx context.Context, nodes []*pb.Node, rs eestream.RedundancyStrategy, pieceID psclient.PieceID, data io.Reader, expiration time.Time, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (successfulNodes []*pb.Node, err error)
-	Get(ctx context.Context, nodes []*pb.Node, es eestream.ErasureScheme, pieceID psclient.PieceID, size int64, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (ranger.Ranger, error)
-	Delete(ctx context.Context, nodes []*pb.Node, pieceID psclient.PieceID, authorization *pb.SignedMessage) error
+	Put(ctx context.Context, nodes []*pb.Node, rs eestream.RedundancyStrategy, pieceID psclient.PieceID, data io.Reader, expiration time.Time, pba *pb.PayerBandwidthAllocation) (successfulNodes []*pb.Node, err error)
+	Get(ctx context.Context, nodes []*pb.Node, es eestream.ErasureScheme, pieceID psclient.PieceID, size int64, pba *pb.PayerBandwidthAllocation) (ranger.Ranger, error)
+	Delete(ctx context.Context, nodes []*pb.Node, pieceID psclient.PieceID, satelliteID storj.NodeID) error
 }
 
 type psClientFunc func(context.Context, transport.Client, *pb.Node, int) (psclient.Client, error)
@@ -56,7 +56,7 @@ func (ec *ecClient) newPSClient(ctx context.Context, n *pb.Node) (psclient.Clien
 	return ec.newPSClientFunc(ctx, ec.transport, n, 0)
 }
 
-func (ec *ecClient) Put(ctx context.Context, nodes []*pb.Node, rs eestream.RedundancyStrategy, pieceID psclient.PieceID, data io.Reader, expiration time.Time, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (successfulNodes []*pb.Node, err error) {
+func (ec *ecClient) Put(ctx context.Context, nodes []*pb.Node, rs eestream.RedundancyStrategy, pieceID psclient.PieceID, data io.Reader, expiration time.Time, pba *pb.PayerBandwidthAllocation) (successfulNodes []*pb.Node, err error) {
 	defer mon.Task()(&ctx)(&err)
 	if len(nodes) != rs.TotalCount() {
 		return nil, Error.New("size of nodes slice (%d) does not match total count (%d) of erasure scheme", len(nodes), rs.TotalCount())
@@ -93,7 +93,7 @@ func (ec *ecClient) Put(ctx context.Context, nodes []*pb.Node, rs eestream.Redun
 		}
 
 		go func(i int, node *pb.Node) {
-			err := ec.putPiece(psCtx, ctx, node, pieceID, readers[i], expiration, pba, authorization)
+			err := ec.putPiece(psCtx, ctx, node, pieceID, readers[i], expiration, pba)
 			infos <- info{i: i, err: err}
 		}(i, node)
 	}
@@ -133,7 +133,7 @@ func (ec *ecClient) Put(ctx context.Context, nodes []*pb.Node, rs eestream.Redun
 		case <-ctx.Done():
 			err = utils.CombineErrors(
 				Error.New("upload cancelled by user"),
-				ec.Delete(context.Background(), nodes, pieceID, authorization),
+				ec.Delete(context.Background(), nodes, pieceID, pba.SatelliteId),
 			)
 		default:
 		}
@@ -146,7 +146,7 @@ func (ec *ecClient) Put(ctx context.Context, nodes []*pb.Node, rs eestream.Redun
 	return successfulNodes, nil
 }
 
-func (ec *ecClient) putPiece(ctx, parent context.Context, node *pb.Node, pieceID psclient.PieceID, data io.ReadCloser, expiration time.Time, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (err error) {
+func (ec *ecClient) putPiece(ctx, parent context.Context, node *pb.Node, pieceID psclient.PieceID, data io.ReadCloser, expiration time.Time, pba *pb.PayerBandwidthAllocation) (err error) {
 	defer func() { err = errs.Combine(err, data.Close()) }()
 
 	if node == nil {
@@ -165,7 +165,7 @@ func (ec *ecClient) putPiece(ctx, parent context.Context, node *pb.Node, pieceID
 			pieceID, derivedPieceID, node.Id, err)
 		return err
 	}
-	err = ps.Put(ctx, derivedPieceID, data, expiration, pba, authorization)
+	err = ps.Put(ctx, derivedPieceID, data, expiration, pba)
 	defer func() { err = errs.Combine(err, ps.Close()) }()
 	// Canceled context means the piece upload was interrupted by user or due
 	// to slow connection. No error logging for this case.
@@ -189,7 +189,7 @@ func (ec *ecClient) putPiece(ctx, parent context.Context, node *pb.Node, pieceID
 }
 
 func (ec *ecClient) Get(ctx context.Context, nodes []*pb.Node, es eestream.ErasureScheme,
-	pieceID psclient.PieceID, size int64, pba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) (rr ranger.Ranger, err error) {
+	pieceID psclient.PieceID, size int64, pba *pb.PayerBandwidthAllocation) (rr ranger.Ranger, err error) {
 	defer mon.Task()(&ctx)(&err)
 
 	if len(nodes) != es.TotalCount() {
@@ -236,7 +236,6 @@ func (ec *ecClient) Get(ctx context.Context, nodes []*pb.Node, es eestream.Erasu
 				id:                derivedPieceID,
 				size:              pieceSize,
 				pba:               pba,
-				authorization:     authorization,
 			}
 
 			ch <- rangerInfo{i: i, rr: rr, err: nil}
@@ -258,7 +257,7 @@ func (ec *ecClient) Get(ctx context.Context, nodes []*pb.Node, es eestream.Erasu
 	return eestream.Unpad(rr, int(paddedSize-size))
 }
 
-func (ec *ecClient) Delete(ctx context.Context, nodes []*pb.Node, pieceID psclient.PieceID, authorization *pb.SignedMessage) (err error) {
+func (ec *ecClient) Delete(ctx context.Context, nodes []*pb.Node, pieceID psclient.PieceID, satelliteID storj.NodeID) (err error) {
 	defer mon.Task()(&ctx)(&err)
 
 	errch := make(chan error, len(nodes))
@@ -287,7 +286,7 @@ func (ec *ecClient) Delete(ctx context.Context, nodes []*pb.Node, pieceID psclie
 				errch <- err
 				return
 			}
-			err = ps.Delete(ctx, derivedPieceID, authorization)
+			err = ps.Delete(ctx, derivedPieceID, satelliteID)
 			// normally the bellow call should be deferred, but doing so fails
 			// randomly the unit tests
 			err = errs.Combine(err, ps.Close())
@@ -363,7 +362,6 @@ type lazyPieceRanger struct {
 	id                psclient.PieceID
 	size              int64
 	pba               *pb.PayerBandwidthAllocation
-	authorization     *pb.SignedMessage
 }
 
 // Size implements Ranger.Size
@@ -379,7 +377,7 @@ func (lr *lazyPieceRanger) Range(ctx context.Context, offset, length int64) (io.
 		if err != nil {
 			return nil, err
 		}
-		ranger, err := ps.Get(ctx, lr.id, lr.size, lr.pba, lr.authorization)
+		ranger, err := ps.Get(ctx, lr.id, lr.size, lr.pba)
 		if err != nil {
 			return nil, err
 		}
diff --git a/pkg/storage/ec/client_test.go b/pkg/storage/ec/client_test.go
index cb7f6f3d8..374feccbe 100644
--- a/pkg/storage/ec/client_test.go
+++ b/pkg/storage/ec/client_test.go
@@ -25,6 +25,7 @@ import (
 	"storj.io/storj/pkg/peertls/tlsopts"
 	"storj.io/storj/pkg/piecestore/psclient"
 	"storj.io/storj/pkg/ranger"
+	"storj.io/storj/pkg/storj"
 	"storj.io/storj/pkg/transport"
 )
 
@@ -155,8 +156,8 @@ TestLoop:
 			}
 			ps := NewMockPSClient(ctrl)
 			gomock.InOrder(
-				ps.EXPECT().Put(gomock.Any(), derivedID, gomock.Any(), ttl, gomock.Any(), gomock.Any()).Return(errs[n]).
-					Do(func(ctx context.Context, id psclient.PieceID, data io.Reader, ttl time.Time, ba *pb.PayerBandwidthAllocation, authorization *pb.SignedMessage) {
+				ps.EXPECT().Put(gomock.Any(), derivedID, gomock.Any(), ttl, &pb.PayerBandwidthAllocation{}).Return(errs[n]).
+					Do(func(ctx context.Context, id psclient.PieceID, data io.Reader, ttl time.Time, ba *pb.PayerBandwidthAllocation) {
 						// simulate that the mocked piece store client is reading the data
 						_, err := io.Copy(ioutil.Discard, data)
 						assert.NoError(t, err, errTag)
@@ -172,7 +173,7 @@ TestLoop:
 		r := io.LimitReader(rand.Reader, int64(size))
 		ec := ecClient{newPSClientFunc: mockNewPSClient(clients)}
 
-		successfulNodes, err := ec.Put(ctx, tt.nodes, rs, id, r, ttl, nil, nil)
+		successfulNodes, err := ec.Put(ctx, tt.nodes, rs, id, r, ttl, &pb.PayerBandwidthAllocation{})
 
 		if tt.errString != "" {
 			assert.EqualError(t, err, tt.errString, errTag)
@@ -269,12 +270,12 @@ TestLoop:
 					continue TestLoop
 				}
 				ps := NewMockPSClient(ctrl)
-				ps.EXPECT().Get(gomock.Any(), derivedID, int64(size/k), gomock.Any(), gomock.Any()).Return(ranger.ByteRanger(nil), errs[n])
+				ps.EXPECT().Get(gomock.Any(), derivedID, int64(size/k), gomock.Any()).Return(ranger.ByteRanger(nil), errs[n])
 				clients[n] = ps
 			}
 		}
 		ec := ecClient{newPSClientFunc: mockNewPSClient(clients), memoryLimit: tt.mbm}
-		rr, err := ec.Get(ctx, tt.nodes, es, id, int64(size), nil, nil)
+		rr, err := ec.Get(ctx, tt.nodes, es, id, int64(size), nil)
 		if err == nil {
 			_, err := rr.Range(ctx, 0, 0)
 			assert.NoError(t, err, errTag)
@@ -337,7 +338,7 @@ TestLoop:
 		}
 
 		ec := ecClient{newPSClientFunc: mockNewPSClient(clients)}
-		err := ec.Delete(ctx, tt.nodes, id, nil)
+		err := ec.Delete(ctx, tt.nodes, id, storj.NodeID{})
 
 		if tt.errString != "" {
 			assert.EqualError(t, err, tt.errString, errTag)
diff --git a/pkg/storage/ec/mocks/mock_client.go b/pkg/storage/ec/mocks/mock_client.go
index babfa7368..f29a62807 100644
--- a/pkg/storage/ec/mocks/mock_client.go
+++ b/pkg/storage/ec/mocks/mock_client.go
@@ -1,21 +1,20 @@
 // Code generated by MockGen. DO NOT EDIT.
 // Source: storj.io/storj/pkg/storage/ec (interfaces: Client)
 
-// Package mock_ecclient is a generated GoMock package.
-package mock_ecclient
+// Package mocks is a generated GoMock package.
+package mocks
 
 import (
 	context "context"
+	gomock "github.com/golang/mock/gomock"
 	io "io"
 	reflect "reflect"
-	time "time"
-
-	gomock "github.com/golang/mock/gomock"
-
 	eestream "storj.io/storj/pkg/eestream"
 	pb "storj.io/storj/pkg/pb"
-	client "storj.io/storj/pkg/piecestore/psclient"
+	psclient "storj.io/storj/pkg/piecestore/psclient"
 	ranger "storj.io/storj/pkg/ranger"
+	storj "storj.io/storj/pkg/storj"
+	time "time"
 )
 
 // MockClient is a mock of Client interface
@@ -42,7 +41,8 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder {
 }
 
 // Delete mocks base method
-func (m *MockClient) Delete(arg0 context.Context, arg1 []*pb.Node, arg2 client.PieceID, arg3 *pb.SignedMessage) error {
+func (m *MockClient) Delete(arg0 context.Context, arg1 []*pb.Node, arg2 psclient.PieceID, arg3 storj.NodeID) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -50,31 +50,36 @@ func (m *MockClient) Delete(arg0 context.Context, arg1 []*pb.Node, arg2 client.P
 
 // Delete indicates an expected call of Delete
 func (mr *MockClientMockRecorder) Delete(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClient)(nil).Delete), arg0, arg1, arg2, arg3)
 }
 
 // Get mocks base method
-func (m *MockClient) Get(arg0 context.Context, arg1 []*pb.Node, arg2 eestream.ErasureScheme, arg3 client.PieceID, arg4 int64, arg5 *pb.PayerBandwidthAllocation, arg6 *pb.SignedMessage) (ranger.Ranger, error) {
-	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+func (m *MockClient) Get(arg0 context.Context, arg1 []*pb.Node, arg2 eestream.ErasureScheme, arg3 psclient.PieceID, arg4 int64, arg5 *pb.PayerBandwidthAllocation) (ranger.Ranger, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2, arg3, arg4, arg5)
 	ret0, _ := ret[0].(ranger.Ranger)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get
-func (mr *MockClientMockRecorder) Get(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
+func (mr *MockClientMockRecorder) Get(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), arg0, arg1, arg2, arg3, arg4, arg5)
 }
 
 // Put mocks base method
-func (m *MockClient) Put(arg0 context.Context, arg1 []*pb.Node, arg2 eestream.RedundancyStrategy, arg3 client.PieceID, arg4 io.Reader, arg5 time.Time, arg6 *pb.PayerBandwidthAllocation, arg7 *pb.SignedMessage) ([]*pb.Node, error) {
-	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+func (m *MockClient) Put(arg0 context.Context, arg1 []*pb.Node, arg2 eestream.RedundancyStrategy, arg3 psclient.PieceID, arg4 io.Reader, arg5 time.Time, arg6 *pb.PayerBandwidthAllocation) ([]*pb.Node, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
 	ret0, _ := ret[0].([]*pb.Node)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Put indicates an expected call of Put
-func (mr *MockClientMockRecorder) Put(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+func (mr *MockClientMockRecorder) Put(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClient)(nil).Put), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
 }
diff --git a/pkg/storage/ec/psclient_mock_test.go b/pkg/storage/ec/psclient_mock_test.go
index e372c939e..73571f606 100644
--- a/pkg/storage/ec/psclient_mock_test.go
+++ b/pkg/storage/ec/psclient_mock_test.go
@@ -1,25 +1,19 @@
-// Copyright (C) 2019 Storj Labs, Inc.
-// See LICENSE for copying information.
-
 // Code generated by MockGen. DO NOT EDIT.
-// Source: storj.io/storj/pkg/piecestore/rpc/client (interfaces: Client)
-
-// mockgen -destination=pkg/storage/ec/psclient_mock_test.go storj.io/storj/pkg/piecestore/rpc/client Client
+// Source: storj.io/storj/pkg/piecestore/psclient (interfaces: Client)
 
 // Package ecclient is a generated GoMock package.
 package ecclient
 
 import (
 	context "context"
+	gomock "github.com/golang/mock/gomock"
 	io "io"
 	reflect "reflect"
-	time "time"
-
-	gomock "github.com/golang/mock/gomock"
-
 	pb "storj.io/storj/pkg/pb"
-	client "storj.io/storj/pkg/piecestore/psclient"
+	psclient "storj.io/storj/pkg/piecestore/psclient"
 	ranger "storj.io/storj/pkg/ranger"
+	storj "storj.io/storj/pkg/storj"
+	time "time"
 )
 
 // MockPSClient is a mock of Client interface
@@ -47,6 +41,7 @@ func (m *MockPSClient) EXPECT() *MockPSClientMockRecorder {
 
 // Close mocks base method
 func (m *MockPSClient) Close() error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -54,11 +49,13 @@ func (m *MockPSClient) Close() error {
 
 // Close indicates an expected call of Close
 func (mr *MockPSClientMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPSClient)(nil).Close))
 }
 
 // Delete mocks base method
-func (m *MockPSClient) Delete(arg0 context.Context, arg1 client.PieceID, arg2 *pb.SignedMessage) error {
+func (m *MockPSClient) Delete(arg0 context.Context, arg1 psclient.PieceID, arg2 storj.NodeID) error {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2)
 	ret0, _ := ret[0].(error)
 	return ret0
@@ -66,24 +63,28 @@ func (m *MockPSClient) Delete(arg0 context.Context, arg1 client.PieceID, arg2 *p
 
 // Delete indicates an expected call of Delete
 func (mr *MockPSClientMockRecorder) Delete(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPSClient)(nil).Delete), arg0, arg1, arg2)
 }
 
 // Get mocks base method
-func (m *MockPSClient) Get(arg0 context.Context, arg1 client.PieceID, arg2 int64, arg3 *pb.PayerBandwidthAllocation, arg4 *pb.SignedMessage) (ranger.Ranger, error) {
-	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2, arg3, arg4)
+func (m *MockPSClient) Get(arg0 context.Context, arg1 psclient.PieceID, arg2 int64, arg3 *pb.PayerBandwidthAllocation) (ranger.Ranger, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(ranger.Ranger)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // Get indicates an expected call of Get
-func (mr *MockPSClientMockRecorder) Get(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPSClient)(nil).Get), arg0, arg1, arg2, arg3, arg4)
+func (mr *MockPSClientMockRecorder) Get(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPSClient)(nil).Get), arg0, arg1, arg2, arg3)
 }
 
 // Meta mocks base method
-func (m *MockPSClient) Meta(arg0 context.Context, arg1 client.PieceID) (*pb.PieceSummary, error) {
+func (m *MockPSClient) Meta(arg0 context.Context, arg1 psclient.PieceID) (*pb.PieceSummary, error) {
+	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Meta", arg0, arg1)
 	ret0, _ := ret[0].(*pb.PieceSummary)
 	ret1, _ := ret[1].(error)
@@ -92,30 +93,20 @@ func (m *MockPSClient) Meta(arg0 context.Context, arg1 client.PieceID) (*pb.Piec
 
 // Meta indicates an expected call of Meta
 func (mr *MockPSClientMockRecorder) Meta(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Meta", reflect.TypeOf((*MockPSClient)(nil).Meta), arg0, arg1)
 }
 
 // Put mocks base method
-func (m *MockPSClient) Put(arg0 context.Context, arg1 client.PieceID, arg2 io.Reader, arg3 time.Time, arg4 *pb.PayerBandwidthAllocation, arg5 *pb.SignedMessage) error {
-	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3, arg4, arg5)
+func (m *MockPSClient) Put(arg0 context.Context, arg1 psclient.PieceID, arg2 io.Reader, arg3 time.Time, arg4 *pb.PayerBandwidthAllocation) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3, arg4)
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
 // Put indicates an expected call of Put
-func (mr *MockPSClientMockRecorder) Put(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockPSClient)(nil).Put), arg0, arg1, arg2, arg3, arg4, arg5)
-}
-
-// Stats mocks base method
-func (m *MockPSClient) Stats(arg0 context.Context) (*pb.StatSummary, error) {
-	ret := m.ctrl.Call(m, "Stats", arg0)
-	ret0, _ := ret[0].(*pb.StatSummary)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// Stats indicates an expected call of Stats
-func (mr *MockPSClientMockRecorder) Stats(arg0 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockPSClient)(nil).Stats), arg0)
+func (mr *MockPSClientMockRecorder) Put(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockPSClient)(nil).Put), arg0, arg1, arg2, arg3, arg4)
 }
diff --git a/pkg/storage/ec/transportclient_mock_test.go b/pkg/storage/ec/transportclient_mock_test.go
index 41b5ce32e..a3797a90b 100644
--- a/pkg/storage/ec/transportclient_mock_test.go
+++ b/pkg/storage/ec/transportclient_mock_test.go
@@ -1,6 +1,3 @@
-// Copyright (C) 2019 Storj Labs, Inc.
-// See LICENSE for copying information.
-
 // Code generated by MockGen. DO NOT EDIT.
 // Source: storj.io/storj/pkg/transport (interfaces: Client)
 
@@ -9,12 +6,12 @@ package ecclient
 
 import (
 	context "context"
-	reflect "reflect"
-
 	gomock "github.com/golang/mock/gomock"
 	grpc "google.golang.org/grpc"
-
-	"storj.io/storj/pkg/pb"
+	reflect "reflect"
+	identity "storj.io/storj/pkg/identity"
+	pb "storj.io/storj/pkg/pb"
+	transport "storj.io/storj/pkg/transport"
 )
 
 // MockClient is a mock of Client interface
@@ -40,18 +37,74 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder {
 	return m.recorder
 }
 
+// DialAddress mocks base method
+func (m *MockClient) DialAddress(arg0 context.Context, arg1 string, arg2 ...grpc.DialOption) (*grpc.ClientConn, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DialAddress", varargs...)
+	ret0, _ := ret[0].(*grpc.ClientConn)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DialAddress indicates an expected call of DialAddress
+func (mr *MockClientMockRecorder) DialAddress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DialAddress", reflect.TypeOf((*MockClient)(nil).DialAddress), varargs...)
+}
+
 // DialNode mocks base method
-func (m *MockClient) DialNode(arg0 context.Context, arg1 *pb.Node) (*grpc.ClientConn, error) {
-
-	arg1.Type.DPanicOnInvalid("mockclient dial node")
-
-	ret := m.ctrl.Call(m, "DialNode", arg0, arg1)
+func (m *MockClient) DialNode(arg0 context.Context, arg1 *pb.Node, arg2 ...grpc.DialOption) (*grpc.ClientConn, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DialNode", varargs...)
 	ret0, _ := ret[0].(*grpc.ClientConn)
 	ret1, _ := ret[1].(error)
 	return ret0, ret1
 }
 
 // DialNode indicates an expected call of DialNode
-func (mr *MockClientMockRecorder) DialNode(arg0, arg1 interface{}) *gomock.Call {
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DialNode", reflect.TypeOf((*MockClient)(nil).DialNode), arg0, arg1)
+func (mr *MockClientMockRecorder) DialNode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DialNode", reflect.TypeOf((*MockClient)(nil).DialNode), varargs...)
+}
+
+// Identity mocks base method
+func (m *MockClient) Identity() *identity.FullIdentity {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Identity")
+	ret0, _ := ret[0].(*identity.FullIdentity)
+	return ret0
+}
+
+// Identity indicates an expected call of Identity
+func (mr *MockClientMockRecorder) Identity() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockClient)(nil).Identity))
+}
+
+// WithObservers mocks base method
+func (m *MockClient) WithObservers(arg0 ...transport.Observer) *transport.Transport {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{}
+	for _, a := range arg0 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "WithObservers", varargs...)
+	ret0, _ := ret[0].(*transport.Transport)
+	return ret0
+}
+
+// WithObservers indicates an expected call of WithObservers
+func (mr *MockClientMockRecorder) WithObservers(arg0 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithObservers", reflect.TypeOf((*MockClient)(nil).WithObservers), arg0...)
 }
diff --git a/pkg/storage/segments/repairer.go b/pkg/storage/segments/repairer.go
index 6c6294425..c8dba28da 100644
--- a/pkg/storage/segments/repairer.go
+++ b/pkg/storage/segments/repairer.go
@@ -120,13 +120,12 @@ func (s *Repairer) Repair(ctx context.Context, path storj.Path, lostPieces []int
 		return Error.Wrap(err)
 	}
 
-	signedMessage := s.pdb.SignedMessage()
 	pbaGet, err := s.pdb.PayerBandwidthAllocation(ctx, pb.BandwidthAction_GET_REPAIR)
 	if err != nil {
 		return Error.Wrap(err)
 	}
 	// Download the segment using just the healthyNodes
-	rr, err := s.ec.Get(ctx, healthyNodes, rs, pid, pr.GetSegmentSize(), pbaGet, signedMessage)
+	rr, err := s.ec.Get(ctx, healthyNodes, rs, pid, pr.GetSegmentSize(), pbaGet)
 	if err != nil {
 		return Error.Wrap(err)
 	}
@@ -142,7 +141,7 @@ func (s *Repairer) Repair(ctx context.Context, path storj.Path, lostPieces []int
 		return Error.Wrap(err)
 	}
 	// Upload the repaired pieces to the repairNodes
-	successfulNodes, err := s.ec.Put(ctx, repairNodes, rs, pid, r, convertTime(pr.GetExpirationDate()), pbaPut, signedMessage)
+	successfulNodes, err := s.ec.Put(ctx, repairNodes, rs, pid, r, convertTime(pr.GetExpirationDate()), pbaPut)
 	if err != nil {
 		return Error.Wrap(err)
 	}
diff --git a/pkg/storage/segments/repairer_test.go b/pkg/storage/segments/repairer_test.go
index b9926878c..2d3b28ab8 100644
--- a/pkg/storage/segments/repairer_test.go
+++ b/pkg/storage/segments/repairer_test.go
@@ -101,14 +101,13 @@ func TestSegmentStoreRepairRemote(t *testing.T) {
 			}, nil, nil, nil),
 			mockOC.EXPECT().BulkLookup(gomock.Any(), gomock.Any()),
 			mockOC.EXPECT().Choose(gomock.Any(), gomock.Any()).Return(tt.newNodes, nil),
-			mockPDB.EXPECT().SignedMessage(),
 			mockPDB.EXPECT().PayerBandwidthAllocation(gomock.Any(), gomock.Any()),
 			mockEC.EXPECT().Get(
-				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
+				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
 			).Return(ranger.ByteRanger([]byte(tt.data)), nil),
 			mockPDB.EXPECT().PayerBandwidthAllocation(gomock.Any(), gomock.Any()),
 			mockEC.EXPECT().Put(
-				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
+				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
 			).Return(tt.newNodes, nil),
 			mockPDB.EXPECT().Put(
 				gomock.Any(), gomock.Any(), gomock.Any(),
diff --git a/pkg/storage/segments/store.go b/pkg/storage/segments/store.go
index 0487d8407..233c03db3 100644
--- a/pkg/storage/segments/store.go
+++ b/pkg/storage/segments/store.go
@@ -137,13 +137,12 @@ func (s *segmentStore) Put(ctx context.Context, data io.Reader, expiration time.
 
 		pieceID := psclient.NewPieceID()
 
-		authorization := s.pdb.SignedMessage()
 		pba, err := s.pdb.PayerBandwidthAllocation(ctx, pb.BandwidthAction_PUT)
 		if err != nil {
 			return Meta{}, Error.Wrap(err)
 		}
 
-		successfulNodes, err := s.ec.Put(ctx, nodes, s.rs, pieceID, sizedReader, expiration, pba, authorization)
+		successfulNodes, err := s.ec.Put(ctx, nodes, s.rs, pieceID, sizedReader, expiration, pba)
 		if err != nil {
 			return Meta{}, Error.Wrap(err)
 		}
@@ -218,8 +217,7 @@ func (s *segmentStore) Get(ctx context.Context, path storj.Path) (rr ranger.Rang
 			node.Type.DPanicOnInvalid("ss get")
 		}
 
-		authorization := s.pdb.SignedMessage()
-		rr, err = s.ec.Get(ctx, selected, rs, pid, pr.GetSegmentSize(), pba, authorization)
+		rr, err = s.ec.Get(ctx, selected, rs, pid, pr.GetSegmentSize(), pba)
 		if err != nil {
 			return nil, Meta{}, Error.Wrap(err)
 		}
@@ -269,7 +267,7 @@ func makeRemotePointer(nodes []*pb.Node, rs eestream.RedundancyStrategy, pieceID
 func (s *segmentStore) Delete(ctx context.Context, path storj.Path) (err error) {
 	defer mon.Task()(&ctx)(&err)
 
-	pr, nodes, _, err := s.pdb.Get(ctx, path)
+	pr, nodes, pba, err := s.pdb.Get(ctx, path)
 	if err != nil {
 		return Error.Wrap(err)
 	}
@@ -288,9 +286,8 @@ func (s *segmentStore) Delete(ctx context.Context, path storj.Path) (err error)
 			}
 		}
 
-		authorization := s.pdb.SignedMessage()
 		// ecclient sends delete request
-		err = s.ec.Delete(ctx, nodes, pid, authorization)
+		err = s.ec.Delete(ctx, nodes, pid, pba.SatelliteId)
 		if err != nil {
 			return Error.Wrap(err)
 		}
diff --git a/pkg/storage/segments/store_test.go b/pkg/storage/segments/store_test.go
index bbfb5e834..03e50672c 100644
--- a/pkg/storage/segments/store_test.go
+++ b/pkg/storage/segments/store_test.go
@@ -118,10 +118,9 @@ func TestSegmentStorePutRemote(t *testing.T) {
 					Type: pb.NodeType_STORAGE,
 				},
 			}, nil),
-			mockPDB.EXPECT().SignedMessage(),
 			mockPDB.EXPECT().PayerBandwidthAllocation(gomock.Any(), gomock.Any()),
 			mockEC.EXPECT().Put(
-				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
+				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
 			),
 			mockES.EXPECT().RequiredCount().Return(1),
 			mockES.EXPECT().TotalCount().Return(1),
@@ -282,9 +281,8 @@ func TestSegmentStoreGetRemote(t *testing.T) {
 				Metadata:       tt.metadata,
 			}, nil, nil, nil),
 			mockOC.EXPECT().BulkLookup(gomock.Any(), gomock.Any()),
-			mockPDB.EXPECT().SignedMessage(),
 			mockEC.EXPECT().Get(
-				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
+				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
 			),
 		}
 		gomock.InOrder(calls...)
@@ -393,9 +391,8 @@ func TestSegmentStoreDeleteRemote(t *testing.T) {
 				ExpirationDate: someTime,
 				SegmentSize:    tt.size,
 				Metadata:       tt.metadata,
-			}, nil, nil, nil),
+			}, nil, &pb.PayerBandwidthAllocation{}, nil),
 			mockOC.EXPECT().BulkLookup(gomock.Any(), gomock.Any()),
-			mockPDB.EXPECT().SignedMessage(),
 			mockEC.EXPECT().Delete(
 				gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(),
 			),