use ipld cbor Blockstore interface

mst/diff.go

···
 
 	"github.com/bluesky-social/indigo/util"
 	cid "github.com/ipfs/go-cid"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	cbor "github.com/ipfs/go-ipld-cbor"
 )
 
 type DiffOp struct {
···
 }
 
 // TODO: this code isn't great, should be rewritten on top of the baseline datastructures once functional and correct
-func DiffTrees(ctx context.Context, bs blockstore.Blockstore, from, to cid.Cid) ([]*DiffOp, error) {
+func DiffTrees(ctx context.Context, bs cbor.IpldBlockstore, from, to cid.Cid) ([]*DiffOp, error) {
 	cst := util.CborStore(bs)
 
 	if from == cid.Undef {
···
 	return false
 }
 
-func identityDiff(ctx context.Context, bs blockstore.Blockstore, root cid.Cid) ([]*DiffOp, error) {
+func identityDiff(ctx context.Context, bs cbor.IpldBlockstore, root cid.Cid) ([]*DiffOp, error) {
 	cst := util.CborStore(bs)
 	tt := LoadMST(cst, root)
 

repo/repo.go

···
 type Repo struct {
 	sc  SignedCommit
 	cst cbor.IpldStore
-	bs  blockstore.Blockstore
+	bs  cbor.IpldBlockstore
 
 	repoCid cid.Cid
 
···
 	return buf.Bytes(), nil
 }
 
-func IngestRepo(ctx context.Context, bs blockstore.Blockstore, r io.Reader) (cid.Cid, error) {
+func IngestRepo(ctx context.Context, bs cbor.IpldBlockstore, r io.Reader) (cid.Cid, error) {
 	ctx, span := otel.Tracer("repo").Start(ctx, "Ingest")
 	defer span.End()
 
···
 	return OpenRepo(ctx, bs, root)
 }
 
-func NewRepo(ctx context.Context, did string, bs blockstore.Blockstore) *Repo {
+func NewRepo(ctx context.Context, did string, bs cbor.IpldBlockstore) *Repo {
 	cst := util.CborStore(bs)
 
 	t := mst.NewEmptyMST(cst)
···
 	}
 }
 
-func OpenRepo(ctx context.Context, bs blockstore.Blockstore, root cid.Cid) (*Repo, error) {
+func OpenRepo(ctx context.Context, bs cbor.IpldBlockstore, root cid.Cid) (*Repo, error) {
 	cst := util.CborStore(bs)
 
 	var sc SignedCommit
···
 	return r.sc
 }
 
-func (r *Repo) Blockstore() blockstore.Blockstore {
+func (r *Repo) Blockstore() cbor.IpldBlockstore {
 	return r.bs
 }
 
···
 	return mst.DiffTrees(ctx, r.bs, oldTree, curptr)
 }
 
-func (r *Repo) CopyDataTo(ctx context.Context, bs blockstore.Blockstore) error {
+func (r *Repo) CopyDataTo(ctx context.Context, bs cbor.IpldBlockstore) error {
 	return copyRecCbor(ctx, r.bs, bs, r.sc.Data, make(map[cid.Cid]struct{}))
 }
 
-func copyRecCbor(ctx context.Context, from, to blockstore.Blockstore, c cid.Cid, seen map[cid.Cid]struct{}) error {
+func copyRecCbor(ctx context.Context, from, to cbor.IpldBlockstore, c cid.Cid, seen map[cid.Cid]struct{}) error {
 	if _, ok := seen[c]; ok {
 		return nil
 	}

util/cbor.go

···
 package util
 
 import (
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	mh "github.com/multiformats/go-multihash"
 )
 
-func CborStore(bs blockstore.Blockstore) *cbor.BasicIpldStore {
+func CborStore(bs cbor.IpldBlockstore) *cbor.BasicIpldStore {
 	cst := cbor.NewCborStore(bs)
 	cst.DefaultMultihash = mh.SHA2_256
 	return cst