feat: postage stamping for gsoc

pkg/api/api.go

@@ -48,6 +48,7 @@ import (
 	"github.com/ethersphere/bee/v2/pkg/settlement/swap"
 	"github.com/ethersphere/bee/v2/pkg/settlement/swap/chequebook"
 	"github.com/ethersphere/bee/v2/pkg/settlement/swap/erc20"
+	"github.com/ethersphere/bee/v2/pkg/soc"
 	"github.com/ethersphere/bee/v2/pkg/status"
 	"github.com/ethersphere/bee/v2/pkg/steward"
 	storage "github.com/ethersphere/bee/v2/pkg/storage"
@@ -685,7 +686,12 @@ type putterSessionWrapper struct {
 }
 
 func (p *putterSessionWrapper) Put(ctx context.Context, chunk swarm.Chunk) error {
-	stamp, err := p.stamper.Stamp(chunk.Address())
+	idAddress, err := soc.IdentityAddress(chunk)
+	if err != nil {
+		return err
+	}
+
+	stamp, err := p.stamper.Stamp(chunk.Address(), idAddress)
 	if err != nil {
 		return err
 	}

pkg/api/envelope.go

@@ -59,7 +59,7 @@ func (s *Service) envelopePostHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	stamp, err := stamper.Stamp(paths.Address)
+	stamp, err := stamper.Stamp(paths.Address, paths.Address)
 	if err != nil {
 		logger.Debug("split write all failed", "error", err)
 		logger.Error(nil, "split write all failed")

pkg/postage/mock/stamper.go

@@ -17,6 +17,11 @@ func NewStamper() postage.Stamper {
 }
 
 // Stamp implements the Stamper interface. It returns an empty postage stamp.
-func (mockStamper) Stamp(_ swarm.Address) (*postage.Stamp, error) {
+func (mockStamper) Stamp(_, _ swarm.Address) (*postage.Stamp, error) {
 	return &postage.Stamp{}, nil
 }
+
+// Stamp implements the Stamper interface. It returns an empty postage stamp.
+func (mockStamper) BatchId() []byte {
+	return nil
+}

pkg/postage/stamp_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethersphere/bee/v2/pkg/postage"
 	"github.com/ethersphere/bee/v2/pkg/postage/batchstore/mock"
 	postagetesting "github.com/ethersphere/bee/v2/pkg/postage/testing"
+	"github.com/ethersphere/bee/v2/pkg/soc"
 	"github.com/ethersphere/bee/v2/pkg/storage/inmemstore"
 	chunktesting "github.com/ethersphere/bee/v2/pkg/storage/testing"
 )
@@ -103,7 +104,12 @@ func TestValidStamp(t *testing.T) {
 	// stamp on execution
 	ch := chunktesting.GenerateTestRandomChunk()
 
-	st, err := stamper.Stamp(ch.Address())
+	idAddress, err := soc.IdentityAddress(ch)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	st, err := stamper.Stamp(ch.Address(), idAddress)
 	if err != nil {
 		t.Fatal(err)
 	}

pkg/postage/stamper.go

@@ -21,7 +21,8 @@ var (
 
 // Stamper can issue stamps from the given address of chunk.
 type Stamper interface {
-	Stamp(swarm.Address) (*Stamp, error)
+	Stamp(idAddr, addr swarm.Address) (*Stamp, error)
+	BatchId() []byte
 }
 
 // stamper connects a stampissuer with a signer.
@@ -39,13 +40,13 @@ func NewStamper(store storage.Store, issuer *StampIssuer, signer crypto.Signer)
 
 // Stamp takes chunk, see if the chunk can be included in the batch and
 // signs it with the owner of the batch of this Stamp issuer.
-func (st *stamper) Stamp(addr swarm.Address) (*Stamp, error) {
+func (st *stamper) Stamp(addr, idAddr swarm.Address) (*Stamp, error) {
 	st.issuer.mtx.Lock()
 	defer st.issuer.mtx.Unlock()
 
 	item := &StampItem{
 		BatchID:      st.issuer.data.BatchID,
-		chunkAddress: addr,
+		chunkAddress: idAddr,
 	}
 	switch err := st.store.Get(item); {
 	case err == nil:
@@ -81,6 +82,11 @@ func (st *stamper) Stamp(addr swarm.Address) (*Stamp, error) {
 	return NewStamp(st.issuer.data.BatchID, item.BatchIndex, item.BatchTimestamp, sig), nil
 }
 
+// BatchId gives back batch id of stamper
+func (st *stamper) BatchId() []byte {
+	return st.issuer.data.BatchID
+}
+
 type presignedStamper struct {
 	stamp *Stamp
 	owner []byte
@@ -90,7 +96,7 @@ func NewPresignedStamper(stamp *Stamp, owner []byte) Stamper {
 	return &presignedStamper{stamp, owner}
 }
 
-func (st *presignedStamper) Stamp(addr swarm.Address) (*Stamp, error) {
+func (st *presignedStamper) Stamp(addr, _ swarm.Address) (*Stamp, error) {
 	// check stored stamp is against the chunk address
 	// Recover the public key from the signature
 	signerAddr, err := RecoverBatchOwner(addr, st.stamp)
@@ -104,3 +110,7 @@ func (st *presignedStamper) Stamp(addr swarm.Address) (*Stamp, error) {
 
 	return st.stamp, nil
 }
+
+func (st *presignedStamper) BatchId() []byte {
+	return st.stamp.BatchID()
+}

pkg/postage/stamper_test.go

@@ -33,7 +33,7 @@ func TestStamperStamping(t *testing.T) {
 		t.Helper()
 
 		chunkAddr := swarm.RandAddress(t)
-		stamp, err := stamper.Stamp(chunkAddr)
+		stamp, err := stamper.Stamp(chunkAddr, chunkAddr)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -71,12 +71,14 @@ func TestStamperStamping(t *testing.T) {
 		// issue another 15
 		// collision depth is 8, committed batch depth is 12, bucket volume 2^4
 		for i := 0; i < 14; i++ {
-			_, err = stamper.Stamp(swarm.RandAddressAt(t, chunkAddr, 8))
+			randAddr := swarm.RandAddressAt(t, chunkAddr, 8)
+			_, err = stamper.Stamp(randAddr, randAddr)
 			if err != nil {
 				t.Fatalf("error adding stamp at step %d: %v", i, err)
 			}
 		}
-		stamp, err := stamper.Stamp(swarm.RandAddressAt(t, chunkAddr, 8))
+		randAddr := swarm.RandAddressAt(t, chunkAddr, 8)
+		stamp, err := stamper.Stamp(randAddr, randAddr)
 		if err != nil {
 			t.Fatalf("error adding last stamp: %v", err)
 		}
@@ -95,13 +97,15 @@ func TestStamperStamping(t *testing.T) {
 		// issue another 15
 		// collision depth is 8, committed batch depth is 12, bucket volume 2^4
 		for i := 0; i < 15; i++ {
-			_, err = stamper.Stamp(swarm.RandAddressAt(t, chunkAddr, 8))
+			randAddr := swarm.RandAddressAt(t, chunkAddr, 8)
+			_, err = stamper.Stamp(randAddr, randAddr)
 			if err != nil {
 				t.Fatalf("error adding stamp at step %d: %v", i, err)
 			}
 		}
+		randAddr := swarm.RandAddressAt(t, chunkAddr, 8)
 		// the bucket should now be full, not allowing a stamp for the  pivot chunk
-		if _, err = stamper.Stamp(swarm.RandAddressAt(t, chunkAddr, 8)); !errors.Is(err, postage.ErrBucketFull) {
+		if _, err = stamper.Stamp(randAddr, randAddr); !errors.Is(err, postage.ErrBucketFull) {
 			t.Fatalf("expected ErrBucketFull, got %v", err)
 		}
 	})
@@ -117,7 +121,7 @@ func TestStamperStamping(t *testing.T) {
 			WithBatchIndex(index)
 		testSt := &testStore{Store: inmemstore.New(), stampItem: testItem}
 		stamper := postage.NewStamper(testSt, st, signer)
-		stamp, err := stamper.Stamp(chunkAddr)
+		stamp, err := stamper.Stamp(chunkAddr, chunkAddr)
 		if err != nil {
 			t.Fatal(err)
 		}

pkg/pss/pss.go

@@ -99,7 +99,7 @@ func (p *pss) Send(ctx context.Context, topic Topic, payload []byte, stamper pos
 		return err
 	}
 
-	stamp, err := stamper.Stamp(tc.Address())
+	stamp, err := stamper.Stamp(tc.Address(), tc.Address())
 	if err != nil {
 		return err
 	}

pkg/pss/pss_test.go

@@ -236,8 +236,15 @@ func ensureCalls(t *testing.T, calls *int, exp int) {
 	}
 }
 
-type stamper struct{}
+type stamper struct {
+	stamp *postage.Stamp
+}
+
+func (s *stamper) Stamp(_, _ swarm.Address) (*postage.Stamp, error) {
+	stamp := postagetesting.MustNewStamp()
+	return stamp, nil
+}
 
-func (s *stamper) Stamp(_ swarm.Address) (*postage.Stamp, error) {
-	return postagetesting.MustNewStamp(), nil
+func (s *stamper) BatchId() []byte {
+	return s.stamp.BatchID()
 }

pkg/steward/steward.go

@@ -61,7 +61,7 @@ func (s *steward) Reupload(ctx context.Context, root swarm.Address, stamper post
 			return err
 		}
 
-		stamp, err := stamper.Stamp(c.Address())
+		stamp, err := stamper.Stamp(c.Address(), c.Address())
 		if err != nil {
 			return fmt.Errorf("stamping chunk %s: %w", c.Address(), err)
 		}