Simplify, simplify!

eth/backend.go

@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"os"
 	"runtime"
 	"sync"
 
@@ -319,7 +320,11 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
 	stack.RegisterProtocols(eth.Protocols())
 	stack.RegisterLifecycle(eth)
 	stack.RegisterLifecycle(confidentialStoreEngine)
-	stack.RegisterLifecycle(&offchain.Env{})
+
+	// TODO(lthibault):  replace this with a proper CLI flag.
+	if os.Getenv("SUAVE_EXPERIMENTAL_IPFS") != "" {
+		stack.RegisterLifecycle(&offchain.Env{})
+	}
 
 	// Successful startup; push a marker and check previous unclean shutdowns.
 	eth.shutdownTracker.MarkStartup()

suave/datastore/ipfs.go → suave/offchain/blockstore.go

@@ -1,4 +1,4 @@
-package datastore
+package offchain
 
 import (
 	"context"
@@ -11,17 +11,17 @@ import (
 	"github.com/multiformats/go-multihash"
 )
 
-type IPFS struct {
-	API iface.CoreAPI
+type Blockstore struct {
+	API iface.BlockAPI
 }
 
-func (c *IPFS) Get(ctx context.Context, cid cid.Cid) (io.Reader, error) {
+func (b Blockstore) Get(ctx context.Context, cid cid.Cid) (io.Reader, error) {
 	p := path.FromCid(cid)
-	return c.API.Block().Get(ctx, p)
+	return b.API.Get(ctx, p)
 }
 
-func (c *IPFS) Put(ctx context.Context, r io.Reader) (cid.Cid, error) {
-	bs, err := c.API.Block().Put(ctx, r,
+func (b Blockstore) Put(ctx context.Context, r io.Reader) (cid.Cid, error) {
+	bs, err := b.API.Put(ctx, r,
 		// options.Block.Pin(false),  // TODO:  refcounting
 		options.Block.Hash(multihash.BLAKE3, 512))
 	if err != nil {

suave/offchain/blockstore_test.go

@@ -0,0 +1,46 @@
+package offchain_test
+
+import (
+	"log"
+	"os"
+	"os/exec"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/suave/offchain"
+	iface "github.com/ipfs/kubo/core/coreiface"
+	"github.com/stretchr/testify/require"
+)
+
+var api iface.CoreAPI
+
+func TestMain(m *testing.M) {
+	// Check if IPFS is available in the environment before attempting
+	// to run the integration tests.
+	cmd := exec.Command("which", "ipfs")
+	switch err := cmd.Run().(type) {
+	case *exec.ExitError:
+		if status := err.ExitCode(); status > 0 {
+			log.Println("ipfs not found in $PATH.  Skipping...")
+		} else {
+			os.Exit(status) // abort; we still don't know if IPFS is available
+		}
+
+	case error:
+		log.Fatal(err)
+	}
+
+	os.Exit(m.Run())
+}
+
+func TestBlockstore(t *testing.T) {
+	t.Parallel()
+
+	env := offchain.Env{
+		IPFS: api,
+	}
+	require.NoError(t, env.Start(), "failed to bind offchain environment")
+	defer func() {
+		require.NoError(t, env.Stop(), "failed to release offchain environment")
+	}()
+
+}

suave/offchain/offchain.go

@@ -1,39 +1,26 @@
 package offchain
 
 import (
-	"context"
-	"io"
-
-	"github.com/ethereum/go-ethereum/suave/datastore"
-	"github.com/ipfs/go-cid"
 	"github.com/ipfs/kubo/client/rpc"
 	iface "github.com/ipfs/kubo/core/coreiface"
 )
 
-type Datastore interface {
-	Get(context.Context, cid.Cid) (io.Reader, error)
-	Put(context.Context, io.Reader) (cid.Cid, error)
-}
-
 type Env struct {
-	Core  iface.CoreAPI
-	Store Datastore
+	IPFS iface.CoreAPI
 }
 
 func (env *Env) Start() (err error) {
-	if env.Store == nil {
-		// Import IPFS into the off-chain environment
-		if env.Core, err = rpc.NewLocalApi(); err == nil {
-			env.Store = &datastore.IPFS{
-				API: env.Core,
-			}
-		}
-
-	}
-
+	// Bind IPFS into the off-chain environment
+	env.IPFS, err = rpc.NewLocalApi()
 	return
 }
 
 func (env *Env) Stop() error {
 	return nil
 }
+
+func (env *Env) Blockstore() Blockstore {
+	return Blockstore{
+		API: env.IPFS.Block(),
+	}
+}