Merge branch 'main' of github.com:storacha/go-ucanto

Author: alanshaw

core/receipt/datamodel/archive.go

@@ -0,0 +1,37 @@
+package datamodel
+
+import (
+	_ "embed"
+	"fmt"
+	"sync"
+
+	"github.com/ipld/go-ipld-prime"
+	"github.com/ipld/go-ipld-prime/schema"
+)
+
+//go:embed archive.ipldsch
+var archive []byte
+
+var (
+	once sync.Once
+	ts   *schema.TypeSystem
+	err  error
+)
+
+func mustLoadSchema() *schema.TypeSystem {
+	once.Do(func() {
+		ts, err = ipld.LoadSchemaBytes(archive)
+	})
+	if err != nil {
+		panic(fmt.Errorf("failed to load IPLD schema: %w", err))
+	}
+	return ts
+}
+
+func ArchiveType() schema.Type {
+	return mustLoadSchema().TypeByName("Archive")
+}
+
+type ArchiveModel struct {
+	UcanReceipt0_9_1 ipld.Link
+}

core/receipt/datamodel/archive.ipldsch

@@ -0,0 +1,3 @@
+type Archive struct {
+	UcanReceipt0_9_1 Link (rename "ucan/receipt@0.9.1")
+}

core/receipt/datamodel/archive_test.go

@@ -0,0 +1,34 @@
+package datamodel_test
+
+import (
+	"testing"
+
+	"github.com/ipfs/go-cid"
+	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
+	"github.com/storacha/go-ucanto/core/ipld/block"
+	"github.com/storacha/go-ucanto/core/ipld/codec/cbor"
+	"github.com/storacha/go-ucanto/core/ipld/hash/sha256"
+	adm "github.com/storacha/go-ucanto/core/receipt/datamodel"
+)
+
+func TestArchiveEncodeDecode(t *testing.T) {
+	l := cidlink.Link{Cid: cid.MustParse("bafkreiem4twkqzsq2aj4shbycd4yvoj2cx72vezicletlhi7dijjciqpui")}
+	m0 := adm.ArchiveModel{
+		UcanReceipt0_9_1: l,
+	}
+	mblk, err := block.Encode(&m0, adm.ArchiveType(), cbor.Codec, sha256.Hasher)
+	if err != nil {
+		t.Fatalf("encoding archive model: %s", err)
+	}
+
+	m1 := adm.ArchiveModel{}
+	err = block.Decode(mblk, &m1, adm.ArchiveType(), cbor.Codec, sha256.Hasher)
+	if err != nil {
+		t.Fatalf("decoding agent message: %s", err)
+	}
+
+	d1 := m1.UcanReceipt0_9_1
+	if d1.String() != l.String() {
+		t.Fatalf("failed round trip link")
+	}
+}

core/receipt/datamodel/receipt_test.go

@@ -20,7 +20,7 @@ type resultErr struct {
 	Message string
 }
 
-func TestEncodeDecode(t *testing.T) {
+func TestReceiptEncodeDecode(t *testing.T) {
 	typ, err := rdm.NewReceiptModelType([]byte(`
 		type Result union {
 			| Ok "ok"

core/receipt/receipt.go

@@ -2,13 +2,17 @@ package receipt
 
 import (
 	// for go:embed
+
+	"bytes"
 	_ "embed"
 	"fmt"
+	"io"
 	"iter"
 
 	"github.com/ipld/go-ipld-prime/datamodel"
 	"github.com/ipld/go-ipld-prime/node/bindnode"
 	"github.com/ipld/go-ipld-prime/schema"
+	"github.com/storacha/go-ucanto/core/car"
 	"github.com/storacha/go-ucanto/core/dag/blockstore"
 	"github.com/storacha/go-ucanto/core/delegation"
 	"github.com/storacha/go-ucanto/core/invocation"
@@ -38,6 +42,10 @@ type Receipt[O, X any] interface {
 	Issuer() ucan.Principal
 	Proofs() delegation.Proofs
 	Signature() signature.SignatureView
+	Archive() io.Reader
+	Export() iter.Seq2[block.Block, error]
+	Clone() (Receipt[O, X], error)
+	AttachInvocation(invocation invocation.Invocation) error
 }
 
 func toResultModel[O, X any](res result.Result[O, X]) rdm.ResultModel[O, X] {
@@ -55,30 +63,45 @@ func fromResultModel[O, X any](resultModel rdm.ResultModel[O, X]) result.Result[
 	return result.Error[O, X](*resultModel.Error)
 }
 
+var _ Receipt[any, any] = (*receipt[any, any])(nil)
+
 type receipt[O, X any] struct {
 	rt   block.Block
 	blks blockstore.BlockReader
 	data *rdm.ReceiptModel[O, X]
 }
 
-var _ Receipt[any, any] = (*receipt[any, any])(nil)
-
-func (r *receipt[O, X]) Blocks() iter.Seq2[block.Block, error] {
-	var iterators []iter.Seq2[block.Block, error]
+func NewReceipt[O, X any](root ipld.Link, blocks blockstore.BlockReader, typ schema.Type, opts ...bindnode.Option) (Receipt[O, X], error) {
+	rblock, ok, err := blocks.Get(root)
+	if err != nil {
+		return nil, fmt.Errorf("getting receipt root block: %w", err)
+	}
+	if !ok {
+		return nil, fmt.Errorf("missing receipt root block: %s", root)
+	}
 
-	if inv, ok := r.Ran().Invocation(); ok {
-		iterators = append(iterators, inv.Blocks())
+	rmdl := rdm.ReceiptModel[O, X]{}
+	err = block.Decode(rblock, &rmdl, typ, cbor.Codec, sha256.Hasher, opts...)
+	if err != nil {
+		return nil, fmt.Errorf("decoding receipt: %w", err)
 	}
 
-	for _, prf := range r.Proofs() {
-		if delegation, ok := prf.Delegation(); ok {
-			iterators = append(iterators, delegation.Blocks())
-		}
+	rcpt := receipt[O, X]{
+		rt:   rblock,
+		blks: blocks,
+		data: &rmdl,
 	}
 
-	iterators = append(iterators, func(yield func(block.Block, error) bool) { yield(r.Root(), nil) })
+	return &rcpt, nil
+}
 
-	return iterable.Concat2(iterators...)
+func NewAnyReceipt(root ipld.Link, blocks blockstore.BlockReader, opts ...bindnode.Option) (AnyReceipt, error) {
+	anyReceiptType := rdm.TypeSystem().TypeByName("Receipt")
+	return NewReceipt[ipld.Node, ipld.Node](root, blocks, anyReceiptType, opts...)
+}
+
+func (r *receipt[O, X]) Blocks() iter.Seq2[block.Block, error] {
+	return r.blks.Iterator()
 }
 
 func (r *receipt[O, X]) Fx() fx.Effects {
@@ -156,33 +179,96 @@ func (r *receipt[O, X]) Signature() signature.SignatureView {
 	return signature.NewSignatureView(signature.Decode(r.data.Sig))
 }
 
-func NewReceipt[O, X any](root ipld.Link, blocks blockstore.BlockReader, typ schema.Type, opts ...bindnode.Option) (Receipt[O, X], error) {
-	rblock, ok, err := blocks.Get(root)
+func (r *receipt[O, X]) Archive() io.Reader {
+	// We create a descriptor block to describe what this DAG represents
+	variant, err := block.Encode(
+		&rdm.ArchiveModel{UcanReceipt0_9_1: r.rt.Link()},
+		rdm.ArchiveType(),
+		cbor.Codec,
+		sha256.Hasher,
+	)
 	if err != nil {
-		return nil, fmt.Errorf("getting receipt root block: %w", err)
+		reader, _ := io.Pipe()
+		reader.CloseWithError(fmt.Errorf("hashing variant block bytes: %w", err))
+		return reader
 	}
-	if !ok {
-		return nil, fmt.Errorf("missing receipt root block: %s", root)
+
+	return car.Encode([]ipld.Link{variant.Link()}, func(yield func(ipld.Block, error) bool) {
+		for b, err := range r.Export() {
+			if !yield(b, err) || err != nil {
+				return
+			}
+		}
+		yield(variant, nil)
+	})
+}
+
+// Export ONLY the blocks that comprise the receipt, its original invocation and its proofs
+// This differs from Blocks(), which simply returns all the blocks in the backing blockstore
+func (r *receipt[O, X]) Export() iter.Seq2[block.Block, error] {
+	var iterators []iter.Seq2[block.Block, error]
+
+	if inv, ok := r.Ran().Invocation(); ok {
+		iterators = append(iterators, inv.Export())
 	}
 
-	rmdl := rdm.ReceiptModel[O, X]{}
-	err = block.Decode(rblock, &rmdl, typ, cbor.Codec, sha256.Hasher, opts...)
+	for _, prf := range r.Proofs() {
+		if delegation, ok := prf.Delegation(); ok {
+			iterators = append(iterators, delegation.Export())
+		}
+	}
+
+	iterators = append(iterators, func(yield func(block.Block, error) bool) { yield(r.Root(), nil) })
+
+	return iterable.Concat2(iterators...)
+}
+
+// Clone returns a new Receipt by copying r's backing blockstore.
+func (r *receipt[O, X]) Clone() (Receipt[O, X], error) {
+	blks, err := blockstore.NewBlockStore(blockstore.WithBlocksIterator(r.blks.Iterator()))
 	if err != nil {
-		return nil, fmt.Errorf("decoding receipt: %w", err)
+		return nil, fmt.Errorf("creating block reader: %w", err)
 	}
+	return &receipt[O, X]{
+		rt:   r.rt,
+		blks: blks,
+		data: r.data,
+	}, nil
+}
 
-	rcpt := receipt[O, X]{
-		rt:   rblock,
-		blks: blocks,
-		data: &rmdl,
+// AttachInvocation adds the invocation's blocks to the receipt's blockstore.
+// If r already has an invocation, it returns r unchanged.
+// If the invocation doesn't match r's ran, it returns an error.
+func (r *receipt[O, X]) AttachInvocation(invocation invocation.Invocation) error {
+	// confirm the invocation matches the receipt
+	ran := r.Ran()
+	if ran.Link().String() != invocation.Link().String() {
+		return fmt.Errorf("expected invocation with CID %s, got %s", ran.Link(), invocation.Link())
 	}
 
-	return &rcpt, nil
-}
+	// don't add the invocation if it's already there
+	if _, ok := ran.Invocation(); ok {
+		return nil
+	}
 
-func NewAnyReceipt(root ipld.Link, blocks blockstore.BlockReader, opts ...bindnode.Option) (AnyReceipt, error) {
-	anyReceiptType := rdm.TypeSystem().TypeByName("Receipt")
-	return NewReceipt[ipld.Node, ipld.Node](root, blocks, anyReceiptType, opts...)
+	// no need to copy receipt blocks if the backing BlockReader is actually a BlockStore
+	if bs, ok := r.blks.(blockstore.BlockStore); ok {
+		for b, err := range invocation.Export() {
+			if err != nil {
+				return fmt.Errorf("attaching invocation blocks: %w", err)
+			}
+			bs.Put(b)
+		}
+	} else {
+		blks, err := blockstore.NewBlockReader(blockstore.WithBlocksIterator(iterable.Concat2(r.blks.Iterator(), invocation.Export())))
+		if err != nil {
+			return fmt.Errorf("creating block reader: %w", err)
+		}
+
+		r.blks = blks
+	}
+
+	return nil
 }
 
 type ReceiptReader[O, X any] interface {
@@ -233,6 +319,46 @@ func Rebind[O, X any](from AnyReceipt, successType schema.Type, errorType schema
 	return rdr.Read(from.Root().Link(), from.Blocks())
 }
 
+func Extract(b []byte) (AnyReceipt, error) {
+	roots, blks, err := car.Decode(bytes.NewReader(b))
+	if err != nil {
+		return nil, fmt.Errorf("decoding CAR: %s", err)
+	}
+	if len(roots) == 0 {
+		return nil, fmt.Errorf("missing root CID in receipt archive")
+	}
+	if len(roots) > 1 {
+		return nil, fmt.Errorf("unexpected number of root CIDs in archive: %d", len(roots))
+	}
+
+	br, err := blockstore.NewBlockReader(blockstore.WithBlocksIterator(blks))
+	if err != nil {
+		return nil, fmt.Errorf("creating block reader: %w", err)
+	}
+
+	rt, ok, err := br.Get(roots[0])
+	if err != nil {
+		return nil, fmt.Errorf("getting root block: %w", err)
+	}
+	if !ok {
+		return nil, fmt.Errorf("missing root block: %s", roots[0])
+	}
+
+	model := rdm.ArchiveModel{}
+	err = block.Decode(
+		rt,
+		&model,
+		rdm.ArchiveType(),
+		cbor.Codec,
+		sha256.Hasher,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("decoding root block: %w", err)
+	}
+
+	return NewAnyReceipt(model.UcanReceipt0_9_1, br)
+}
+
 // Option is an option configuring a UCAN delegation.
 type Option func(cfg *receiptConfig) error