diff --git a/chain/deals/client_utils.go b/chain/deals/client_utils.go
index 9c26f4268..8a68f1cdd 100644
--- a/chain/deals/client_utils.go
+++ b/chain/deals/client_utils.go
@@ -25,7 +25,7 @@ func (c *Client) failDeal(id cid.Cid, cerr error) {
 	}
 
 	// TODO: store in some sort of audit log
-	log.Errorf("deal %s failed: %s", id, cerr)
+	log.Errorf("deal %s failed: %+v", id, cerr)
 }
 
 func (c *Client) dataSize(ctx context.Context, data cid.Cid) (int64, error) {
diff --git a/chain/deals/provider.go b/chain/deals/provider.go
index 18420fb14..608432352 100644
--- a/chain/deals/provider.go
+++ b/chain/deals/provider.go
@@ -162,7 +162,7 @@ func (p *Provider) onIncoming(deal MinerDeal) {
 func (p *Provider) onUpdated(ctx context.Context, update minerDealUpdate) {
 	log.Infof("Deal %s updated state to %d", update.id, update.newState)
 	if update.err != nil {
-		log.Errorf("deal %s (newSt: %d) failed: %s", update.id, update.newState, update.err)
+		log.Errorf("deal %s (newSt: %d) failed: %+v", update.id, update.newState, update.err)
 		p.failDeal(update.id, update.err)
 		return
 	}
diff --git a/chain/deals/provider_utils.go b/chain/deals/provider_utils.go
index 5931cefc9..547ff8c76 100644
--- a/chain/deals/provider_utils.go
+++ b/chain/deals/provider_utils.go
@@ -26,7 +26,7 @@ func (p *Provider) failDeal(id cid.Cid, cerr error) {
 		cerr = xerrors.Errorf("unknown error (fail called at %s:%d)", f, l)
 	}
 
-	log.Errorf("deal %s failed: %s", id, cerr)
+	log.Warnf("deal %s failed: %s", id, cerr)
 
 	err := p.sendSignedResponse(&Response{
 		State:    api.DealFailed,
diff --git a/lib/sectorbuilder/sectorbuilder.go b/lib/sectorbuilder/sectorbuilder.go
index 9484823b0..58f37cf56 100644
--- a/lib/sectorbuilder/sectorbuilder.go
+++ b/lib/sectorbuilder/sectorbuilder.go
@@ -231,11 +231,20 @@ func toReadableFile(r io.Reader, n int64) (*os.File, func() error, error) {
 	go func() {
 		defer wait.Unlock()
 
-		_, werr = io.CopyN(w, r, n)
+		copied, werr := io.CopyN(w, r, n)
+		if werr != nil {
+			log.Warnf("toReadableFile: copy error: %+v", werr)
+		}
 
 		err := w.Close()
 		if werr == nil {
 			werr = err
+			log.Warnf("toReadableFile: close error: %+v", err)
+			return
+		}
+		if copied != n {
+			log.Warnf("copied different amount than expected: %d != %d", copied, n)
+			werr = xerrors.Errorf("copied different amount than expected: %d != %d", copied, n)
 		}
 	}()
 
diff --git a/storage/sealing.go b/storage/sealing.go
index d1883be3d..625a35c1b 100644
--- a/storage/sealing.go
+++ b/storage/sealing.go
@@ -114,7 +114,7 @@ func (m *Miner) onSectorUpdated(ctx context.Context, update sectorUpdate) {
 }
 
 func (m *Miner) failSector(id uint64, err error) {
-	log.Error(err)
+	log.Errorf("sector %d error: %+v", id, err)
 	panic(err) // todo: better error handling strategy
 }
 
diff --git a/storage/sector/store_test.go b/storage/sector/store_test.go
index 5d473ba18..a2e1d00ac 100644
--- a/storage/sector/store_test.go
+++ b/storage/sector/store_test.go
@@ -5,8 +5,8 @@ import (
 	"testing"
 )
 
-func TestComputePaddedSize(t *testing.T)  {
+func TestComputePaddedSize(t *testing.T) {
 	assert.Equal(t, uint64(1040384), computePaddedSize(1000000))
 	assert.Equal(t, uint64(1016), computePaddedSize(548))
 	assert.Equal(t, uint64(4064), computePaddedSize(2048))
-}
\ No newline at end of file
+}
diff --git a/storage/sectorblocks/blocks.go b/storage/sectorblocks/blocks.go
index 28b864e7a..4f1049f23 100644
--- a/storage/sectorblocks/blocks.go
+++ b/storage/sectorblocks/blocks.go
@@ -11,6 +11,7 @@ import (
 	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/ipfs/go-unixfs"
+	"golang.org/x/xerrors"
 	"sync"
 
 	"github.com/ipfs/go-cid"
@@ -89,13 +90,13 @@ func (st *SectorBlocks) writeRef(cid cid.Cid, pieceRef string, offset uint64, si
 		err = nil
 	}
 	if err != nil {
-		return err
+		return xerrors.Errorf("getting existing refs: %w", err)
 	}
 
 	var refs []api.SealedRef
 	if len(v) > 0 {
 		if err := cbor.DecodeInto(v, &refs); err != nil {
-			return err
+			return xerrors.Errorf("decoding existing refs: %w", err)
 		}
 	}
 
@@ -107,7 +108,7 @@ func (st *SectorBlocks) writeRef(cid cid.Cid, pieceRef string, offset uint64, si
 
 	newRef, err := cbor.DumpObject(&refs)
 	if err != nil {
-		return err
+		return xerrors.Errorf("serializing refs: %w", err)
 	}
 	return st.keys.Put(dshelp.CidToDsKey(cid), newRef) // TODO: batch somehow
 }
@@ -128,20 +129,20 @@ func (r *refStorer) Read(p []byte) (n int, err error) {
 	for {
 		data, offset, nd, err := r.blockReader.ReadBlock(context.TODO())
 		if err != nil {
-			return 0, err
+			return 0, xerrors.Errorf("reading block: %w", err)
 		}
 
 		if len(data) == 0 {
 			// TODO: batch
 			// TODO: GC
 			if err := r.intermediate.Put(nd); err != nil {
-				return 0, err
+				return 0, xerrors.Errorf("storing intermediate node: %w", err)
 			}
 			continue
 		}
 
 		if err := r.writeRef(nd.Cid(), r.pieceRef, offset, uint32(len(data))); err != nil {
-			return 0, err
+			return 0, xerrors.Errorf("writing ref: %w", err)
 		}
 
 		read := copy(p, data)