Create issues-notion-sync.yml

Fix iterator and update

.github/workflows/issues-notion-sync.yml

@@ -0,0 +1,29 @@
+name: Notion Sync
+
+on:
+  workflow_dispatch:
+  issues:
+    types:
+      [
+        opened,
+        edited,
+        labeled,
+        unlabeled,
+        assigned,
+        unassigned,
+        milestoned,
+        demilestoned,
+        reopened,
+        closed,
+      ]
+
+jobs:
+  notion_job:
+    runs-on: ubuntu-latest
+    name: Add GitHub Issues to Notion
+    steps:
+      - name: Add GitHub Issues to Notion
+        uses: vulcanize/notion-github-action@v1.2.4-issueid
+        with:
+          notion-token: ${{ secrets.NOTION_TOKEN }}
+          notion-db: ${{ secrets.NOTION_DATABASE }}

.gitignore

@@ -1,2 +1,4 @@
 .idea/
+.vscode/
 ipld-eth-state-snapshot
+mocks/

Makefile

@@ -1,7 +1,7 @@
 MOCKS_DIR = $(CURDIR)/mocks
 mockgen_cmd=mockgen
 
-.PHONY: mocks
+.PHONY: mocks test
 
 mocks: mocks/snapshot/publisher.go
 
@@ -14,3 +14,6 @@ clean:
 build:
 	go fmt ./...
 	go build
+
+test: mocks
+	go clean -testcache && go test -v ./...

README.md

@@ -52,3 +52,8 @@ Config format:
     chainID = "1" # $ETH_CHAIN_ID
     genesisBlock = "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3" # $ETH_GENESIS_BLOCK
 ```
+
+## Tests
+
+* Install [mockgen](https://github.com/golang/mock#installation)
+* `make test`

cmd/stateSnapshot.go

@@ -44,7 +44,7 @@ func stateSnapshot() {
 	mode := snapshot.SnapshotMode(modeStr)
 	config, err := snapshot.NewConfig(mode)
 	if err != nil {
-		logWithCommand.Fatal("unable to initialize config: %v", err)
+		logWithCommand.Fatalf("unable to initialize config: %v", err)
 	}
 	logWithCommand.Infof("opening levelDB and ancient data at %s and %s",
 		config.Eth.LevelDBPath, config.Eth.AncientDBPath)
@@ -56,7 +56,7 @@ func stateSnapshot() {
 	recoveryFile := viper.GetString(snapshot.SNAPSHOT_RECOVERY_FILE_TOML)
 	if recoveryFile == "" {
 		recoveryFile = fmt.Sprintf("./%d_snapshot_recovery", height)
-		logWithCommand.Infof("no recovery file set, creating default: %s", recoveryFile)
+		logWithCommand.Infof("no recovery file set, using default: %s", recoveryFile)
 	}
 
 	pub, err := snapshot.NewPublisher(mode, config)

go.mod

@@ -14,7 +14,7 @@ require (
 	github.com/sirupsen/logrus v1.6.0
 	github.com/spf13/cobra v1.0.0
 	github.com/spf13/viper v1.7.0
-	github.com/vulcanize/go-eth-state-node-iterator v1.0.3
+	github.com/vulcanize/go-eth-state-node-iterator v1.1.0
 )
 
 require (
@@ -114,4 +114,4 @@ require (
 	lukechampine.com/blake3 v1.1.7 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.10.18 => github.com/vulcanize/go-ethereum v1.10.18-statediff-4.0.2-alpha
+replace github.com/ethereum/go-ethereum v1.10.18 => github.com/vulcanize/go-ethereum v1.10.18-statediff-3.2.2

go.sum

@@ -776,10 +776,10 @@ github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/X
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
-github.com/vulcanize/go-eth-state-node-iterator v1.0.3 h1:gtkU0aP7aW0tPBfzxVSymRhX9eyIQv7HiGkGVGwoh8I=
-github.com/vulcanize/go-eth-state-node-iterator v1.0.3/go.mod h1:a1aRW1/fEmcpY8AAU47p9TNL3QNjpeqCJd/hLtFKVL8=
-github.com/vulcanize/go-ethereum v1.10.18-statediff-4.0.2-alpha h1:gTcfBHoaRpsRbP1/dnurg5LFUaqsQMTNqs4R4S2wm9U=
-github.com/vulcanize/go-ethereum v1.10.18-statediff-4.0.2-alpha/go.mod h1:HelXH7UT1uWdb+St6UAj4pPf93GOggjIV7pVbrWIZ3o=
+github.com/vulcanize/go-eth-state-node-iterator v1.1.0 h1:wbOpP9BnqDcN8OWbuOw/QvR7Mde5JuuI15SGfLil0ZE=
+github.com/vulcanize/go-eth-state-node-iterator v1.1.0/go.mod h1:a1aRW1/fEmcpY8AAU47p9TNL3QNjpeqCJd/hLtFKVL8=
+github.com/vulcanize/go-ethereum v1.10.18-statediff-3.2.2 h1:hAZFOtnfdHtVgiwtcNFZDxCEN01c4W5Xsw+1K/IlHBA=
+github.com/vulcanize/go-ethereum v1.10.18-statediff-3.2.2/go.mod h1:HelXH7UT1uWdb+St6UAj4pPf93GOggjIV7pVbrWIZ3o=
 github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM=
 github.com/willf/bitset v1.1.3/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=

pkg/snapshot/file/publisher.go

@@ -18,7 +18,6 @@ package publisher
 import (
 	"encoding/csv"
 	"fmt"
-	"math/big"
 	"os"
 	"path/filepath"
 	"sync/atomic"
@@ -161,20 +160,20 @@ func (p *publisher) BeginTx() (snapt.Tx, error) {
 
 // PublishRaw derives a cid from raw bytes and provided codec and multihash type, and writes it to the db tx
 // returns the CID and blockstore prefixed multihash key
-func (tx fileWriters) publishRaw(codec uint64, raw []byte, height *big.Int) (cid, prefixedKey string, err error) {
+func (tx fileWriters) publishRaw(codec uint64, raw []byte) (cid, prefixedKey string, err error) {
 	c, err := ipld.RawdataToCid(codec, raw, multihash.KECCAK_256)
 	if err != nil {
 		return
 	}
 	cid = c.String()
-	prefixedKey, err = tx.publishIPLD(c, raw, height)
+	prefixedKey, err = tx.publishIPLD(c, raw)
 	return
 }
 
-func (tx fileWriters) publishIPLD(c cid.Cid, raw []byte, height *big.Int) (string, error) {
+func (tx fileWriters) publishIPLD(c cid.Cid, raw []byte) (string, error) {
 	dbKey := dshelp.MultihashToDsKey(c.Hash())
 	prefixedKey := blockstore.BlockPrefix.String() + dbKey.String()
-	return prefixedKey, tx.write(&snapt.TableIPLDBlock, height.String(), prefixedKey, raw)
+	return prefixedKey, tx.write(&snapt.TableIPLDBlock, prefixedKey, raw)
 }
 
 // PublishHeader writes the header to the ipfs backing pg datastore and adds secondary
@@ -184,7 +183,7 @@ func (p *publisher) PublishHeader(header *types.Header) error {
 	if err != nil {
 		return err
 	}
-	if _, err = p.writers.publishIPLD(headerNode.Cid(), headerNode.RawData(), header.Number); err != nil {
+	if _, err = p.writers.publishIPLD(headerNode.Cid(), headerNode.RawData()); err != nil {
 		return err
 	}
 
@@ -206,19 +205,19 @@ func (p *publisher) PublishHeader(header *types.Header) error {
 
 // PublishStateNode writes the state node to the ipfs backing datastore and adds secondary indexes
 // in the state_cids table
-func (p *publisher) PublishStateNode(node *snapt.Node, headerID string, height *big.Int, snapTx snapt.Tx) error {
+func (p *publisher) PublishStateNode(node *snapt.Node, headerID string, snapTx snapt.Tx) error {
 	var stateKey string
 	if !snapt.IsNullHash(node.Key) {
 		stateKey = node.Key.Hex()
 	}
 
 	tx := snapTx.(fileTx)
-	stateCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStateTrie, node.Value, height)
+	stateCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStateTrie, node.Value)
 	if err != nil {
 		return err
 	}
 
-	err = tx.write(&snapt.TableStateNode, height.String(), headerID, stateKey, stateCIDStr, node.Path,
+	err = tx.write(&snapt.TableStateNode, headerID, stateKey, stateCIDStr, node.Path,
 		node.NodeType, false, mhKey)
 	if err != nil {
 		return err
@@ -234,19 +233,19 @@ func (p *publisher) PublishStateNode(node *snapt.Node, headerID string, height *
 
 // PublishStorageNode writes the storage node to the ipfs backing pg datastore and adds secondary
 // indexes in the storage_cids table
-func (p *publisher) PublishStorageNode(node *snapt.Node, headerID string, height *big.Int, statePath []byte, snapTx snapt.Tx) error {
+func (p *publisher) PublishStorageNode(node *snapt.Node, headerID string, statePath []byte, snapTx snapt.Tx) error {
 	var storageKey string
 	if !snapt.IsNullHash(node.Key) {
 		storageKey = node.Key.Hex()
 	}
 
 	tx := snapTx.(fileTx)
-	storageCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStorageTrie, node.Value, height)
+	storageCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStorageTrie, node.Value)
 	if err != nil {
 		return err
 	}
 
-	err = tx.write(&snapt.TableStorageNode, height.String(), headerID, statePath, storageKey, storageCIDStr, node.Path,
+	err = tx.write(&snapt.TableStorageNode, headerID, statePath, storageKey, storageCIDStr, node.Path,
 		node.NodeType, false, mhKey)
 	if err != nil {
 		return err
@@ -261,7 +260,7 @@ func (p *publisher) PublishStorageNode(node *snapt.Node, headerID string, height
 }
 
 // PublishCode writes code to the ipfs backing pg datastore
-func (p *publisher) PublishCode(height *big.Int, codeHash common.Hash, codeBytes []byte, snapTx snapt.Tx) error {
+func (p *publisher) PublishCode(codeHash common.Hash, codeBytes []byte, snapTx snapt.Tx) error {
 	// no codec for code, doesn't matter though since blockstore key is multihash-derived
 	mhKey, err := shared.MultihashKeyFromKeccak256(codeHash)
 	if err != nil {
@@ -269,7 +268,7 @@ func (p *publisher) PublishCode(height *big.Int, codeHash common.Hash, codeBytes
 	}
 
 	tx := snapTx.(fileTx)
-	if err = tx.write(&snapt.TableIPLDBlock, height.String(), mhKey, codeBytes); err != nil {
+	if err = tx.write(&snapt.TableIPLDBlock, mhKey, codeBytes); err != nil {
 		return fmt.Errorf("error publishing code IPLD: %v", err)
 	}
 	// increment code node counter.

pkg/snapshot/file/publisher_test.go

@@ -38,7 +38,7 @@ func writeFiles(t *testing.T, dir string) *publisher {
 	test.NoError(t, err)
 
 	headerID := fixt.Block1_Header.Hash().String()
-	test.NoError(t, pub.PublishStateNode(&fixt.Block1_StateNode0, headerID, fixt.Block1_Header.Number, tx))
+	test.NoError(t, pub.PublishStateNode(&fixt.Block1_StateNode0, headerID, tx))
 
 	test.NoError(t, tx.Commit())
 	return pub

pkg/snapshot/pg/publisher.go

@@ -18,7 +18,6 @@ package pg
 import (
 	"context"
 	"fmt"
-	"math/big"
 	"sync/atomic"
 	"time"
 
@@ -89,20 +88,20 @@ func (p *publisher) BeginTx() (snapt.Tx, error) {
 
 // PublishRaw derives a cid from raw bytes and provided codec and multihash type, and writes it to the db tx
 // returns the CID and blockstore prefixed multihash key
-func (tx pubTx) publishRaw(codec uint64, raw []byte, height *big.Int) (cid, prefixedKey string, err error) {
+func (tx pubTx) publishRaw(codec uint64, raw []byte) (cid, prefixedKey string, err error) {
 	c, err := ipld.RawdataToCid(codec, raw, multihash.KECCAK_256)
 	if err != nil {
 		return
 	}
 	cid = c.String()
-	prefixedKey, err = tx.publishIPLD(c, raw, height)
+	prefixedKey, err = tx.publishIPLD(c, raw)
 	return
 }
 
-func (tx pubTx) publishIPLD(c cid.Cid, raw []byte, height *big.Int) (string, error) {
+func (tx pubTx) publishIPLD(c cid.Cid, raw []byte) (string, error) {
 	dbKey := dshelp.MultihashToDsKey(c.Hash())
 	prefixedKey := blockstore.BlockPrefix.String() + dbKey.String()
-	_, err := tx.Exec(snapt.TableIPLDBlock.ToInsertStatement(), height.Uint64(), prefixedKey, raw)
+	_, err := tx.Exec(snapt.TableIPLDBlock.ToInsertStatement(), prefixedKey, raw)
 	return prefixedKey, err
 }
 
@@ -120,7 +119,7 @@ func (p *publisher) PublishHeader(header *types.Header) (err error) {
 	tx := pubTx{snapTx, nil}
 	defer func() { err = snapt.CommitOrRollback(tx, err) }()
 
-	if _, err = tx.publishIPLD(headerNode.Cid(), headerNode.RawData(), header.Number); err != nil {
+	if _, err = tx.publishIPLD(headerNode.Cid(), headerNode.RawData()); err != nil {
 		return err
 	}
 
@@ -133,20 +132,20 @@ func (p *publisher) PublishHeader(header *types.Header) (err error) {
 }
 
 // PublishStateNode writes the state node to the ipfs backing datastore and adds secondary indexes in the state_cids table
-func (p *publisher) PublishStateNode(node *snapt.Node, headerID string, height *big.Int, snapTx snapt.Tx) error {
+func (p *publisher) PublishStateNode(node *snapt.Node, headerID string, snapTx snapt.Tx) error {
 	var stateKey string
 	if !snapt.IsNullHash(node.Key) {
 		stateKey = node.Key.Hex()
 	}
 
 	tx := snapTx.(pubTx)
-	stateCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStateTrie, node.Value, height)
+	stateCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStateTrie, node.Value)
 	if err != nil {
 		return err
 	}
 
 	_, err = tx.Exec(snapt.TableStateNode.ToInsertStatement(),
-		height.Uint64(), headerID, stateKey, stateCIDStr, node.Path, node.NodeType, false, mhKey)
+		headerID, stateKey, stateCIDStr, node.Path, node.NodeType, false, mhKey)
 	if err != nil {
 		return err
 	}
@@ -160,20 +159,20 @@ func (p *publisher) PublishStateNode(node *snapt.Node, headerID string, height *
 }
 
 // PublishStorageNode writes the storage node to the ipfs backing pg datastore and adds secondary indexes in the storage_cids table
-func (p *publisher) PublishStorageNode(node *snapt.Node, headerID string, height *big.Int, statePath []byte, snapTx snapt.Tx) error {
+func (p *publisher) PublishStorageNode(node *snapt.Node, headerID string, statePath []byte, snapTx snapt.Tx) error {
 	var storageKey string
 	if !snapt.IsNullHash(node.Key) {
 		storageKey = node.Key.Hex()
 	}
 
 	tx := snapTx.(pubTx)
-	storageCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStorageTrie, node.Value, height)
+	storageCIDStr, mhKey, err := tx.publishRaw(ipld.MEthStorageTrie, node.Value)
 	if err != nil {
 		return err
 	}
 
 	_, err = tx.Exec(snapt.TableStorageNode.ToInsertStatement(),
-		height.Uint64(), headerID, statePath, storageKey, storageCIDStr, node.Path, node.NodeType, false, mhKey)
+		headerID, statePath, storageKey, storageCIDStr, node.Path, node.NodeType, false, mhKey)
 	if err != nil {
 		return err
 	}
@@ -187,7 +186,7 @@ func (p *publisher) PublishStorageNode(node *snapt.Node, headerID string, height
 }
 
 // PublishCode writes code to the ipfs backing pg datastore
-func (p *publisher) PublishCode(height *big.Int, codeHash common.Hash, codeBytes []byte, snapTx snapt.Tx) error {
+func (p *publisher) PublishCode(codeHash common.Hash, codeBytes []byte, snapTx snapt.Tx) error {
 	// no codec for code, doesn't matter though since blockstore key is multihash-derived
 	mhKey, err := shared.MultihashKeyFromKeccak256(codeHash)
 	if err != nil {
@@ -195,7 +194,7 @@ func (p *publisher) PublishCode(height *big.Int, codeHash common.Hash, codeBytes
 	}
 
 	tx := snapTx.(pubTx)
-	if _, err = tx.Exec(snapt.TableIPLDBlock.ToInsertStatement(), height.Uint64(), mhKey, codeBytes); err != nil {
+	if _, err = tx.Exec(snapt.TableIPLDBlock.ToInsertStatement(), mhKey, codeBytes); err != nil {
 		return fmt.Errorf("error publishing code IPLD: %v", err)
 	}
 

pkg/snapshot/pg/publisher_test.go

@@ -36,7 +36,7 @@ func writeData(t *testing.T) *publisher {
 	test.NoError(t, err)
 
 	headerID := fixt.Block1_Header.Hash().String()
-	test.NoError(t, pub.PublishStateNode(&fixt.Block1_StateNode0, headerID, fixt.Block1_Header.Number, tx))
+	test.NoError(t, pub.PublishStateNode(&fixt.Block1_StateNode0, headerID, tx))
 
 	test.NoError(t, tx.Commit())
 	return pub
@@ -73,7 +73,6 @@ func TestBasic(t *testing.T) {
 	test.NoError(t, err)
 
 	headerNode, err := ipld.NewEthHeader(&fixt.Block1_Header)
-	test.NoError(t, err)
 	test.ExpectEqual(t, headerNode.Cid().String(), header.CID)
 	test.ExpectEqual(t, fixt.Block1_Header.Hash().String(), header.BlockHash)
 }

pkg/snapshot/service.go

@@ -19,7 +19,6 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"math/big"
 	"sync"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -102,18 +101,21 @@ func (s *Service) CreateSnapshot(params SnapshotParams) error {
 	if err != nil {
 		return err
 	}
+
 	headerID := header.Hash().String()
 	s.tracker = newTracker(s.recoveryFile, int(params.Workers))
-	go s.tracker.run()
-	go s.tracker.captureSignal()
+	s.tracker.captureSignal()
 
 	var iters []trie.NodeIterator
 	// attempt to restore from recovery file if it exists
 	iters, err = s.tracker.restore(tree)
 	if err != nil {
+		log.Errorf("restore error: %s", err.Error())
 		return err
 	}
+
 	if iters != nil {
+		log.Debugf("restored iterators; count: %d", len(iters))
 		if params.Workers < uint(len(iters)) {
 			return fmt.Errorf(
 				"number of recovered workers (%d) is greater than number configured (%d)",
@@ -121,6 +123,7 @@ func (s *Service) CreateSnapshot(params SnapshotParams) error {
 			)
 		}
 	} else { // nothing to restore
+		log.Debugf("no iterators to restore")
 		if params.Workers > 1 {
 			iters = iter.SubtrieIterators(tree, params.Workers)
 		} else {
@@ -134,14 +137,14 @@ func (s *Service) CreateSnapshot(params SnapshotParams) error {
 	defer func() {
 		err := s.tracker.haltAndDump()
 		if err != nil {
-			log.Error("failed to write recovery file: ", err)
+			log.Errorf("failed to write recovery file: %v", err)
 		}
 	}()
 
 	if len(iters) > 0 {
-		return s.createSnapshotAsync(iters, headerID, new(big.Int).SetUint64(params.Height))
+		return s.createSnapshotAsync(iters, headerID)
 	} else {
-		return s.createSnapshot(iters[0], headerID, new(big.Int).SetUint64(params.Height))
+		return s.createSnapshot(iters[0], headerID)
 	}
 }
 
@@ -194,7 +197,7 @@ func resolveNode(it trie.NodeIterator, trieDB *trie.Database) (*nodeResult, erro
 	}, nil
 }
 
-func (s *Service) createSnapshot(it trie.NodeIterator, headerID string, height *big.Int) error {
+func (s *Service) createSnapshot(it trie.NodeIterator, headerID string) error {
 	tx, err := s.ipfsPublisher.BeginTx()
 	if err != nil {
 		return err
@@ -229,7 +232,7 @@ func (s *Service) createSnapshot(it trie.NodeIterator, headerID string, height *
 			encodedPath := trie.HexToCompact(valueNodePath)
 			leafKey := encodedPath[1:]
 			res.node.Key = common.BytesToHash(leafKey)
-			err := s.ipfsPublisher.PublishStateNode(&res.node, headerID, height, tx)
+			err := s.ipfsPublisher.PublishStateNode(&res.node, headerID, tx)
 			if err != nil {
 				return err
 			}
@@ -243,17 +246,17 @@ func (s *Service) createSnapshot(it trie.NodeIterator, headerID string, height *
 					return errors.New("missing code")
 				}
 
-				if err = s.ipfsPublisher.PublishCode(height, codeHash, codeBytes, tx); err != nil {
+				if err = s.ipfsPublisher.PublishCode(codeHash, codeBytes, tx); err != nil {
 					return err
 				}
 			}
 
-			if tx, err = s.storageSnapshot(account.Root, headerID, height, res.node.Path, tx); err != nil {
+			if tx, err = s.storageSnapshot(account.Root, headerID, res.node.Path, tx); err != nil {
 				return fmt.Errorf("failed building storage snapshot for account %+v\r\nerror: %w", account, err)
 			}
 		case Extension, Branch:
 			res.node.Key = common.BytesToHash([]byte{})
-			if err := s.ipfsPublisher.PublishStateNode(&res.node, headerID, height, tx); err != nil {
+			if err := s.ipfsPublisher.PublishStateNode(&res.node, headerID, tx); err != nil {
 				return err
 			}
 		default:
@@ -264,14 +267,14 @@ func (s *Service) createSnapshot(it trie.NodeIterator, headerID string, height *
 }
 
 // Full-trie concurrent snapshot
-func (s *Service) createSnapshotAsync(iters []trie.NodeIterator, headerID string, height *big.Int) error {
+func (s *Service) createSnapshotAsync(iters []trie.NodeIterator, headerID string) error {
 	errors := make(chan error)
 	var wg sync.WaitGroup
 	for _, it := range iters {
 		wg.Add(1)
 		go func(it trie.NodeIterator) {
 			defer wg.Done()
-			if err := s.createSnapshot(it, headerID, height); err != nil {
+			if err := s.createSnapshot(it, headerID); err != nil {
 				errors <- err
 			}
 		}(it)
@@ -292,7 +295,7 @@ func (s *Service) createSnapshotAsync(iters []trie.NodeIterator, headerID string
 	return err
 }
 
-func (s *Service) storageSnapshot(sr common.Hash, headerID string, height *big.Int, statePath []byte, tx Tx) (Tx, error) {
+func (s *Service) storageSnapshot(sr common.Hash, headerID string, statePath []byte, tx Tx) (Tx, error) {
 	if bytes.Equal(sr.Bytes(), emptyContractRoot.Bytes()) {
 		return tx, nil
 	}
@@ -336,7 +339,7 @@ func (s *Service) storageSnapshot(sr common.Hash, headerID string, height *big.I
 		default:
 			return nil, errors.New("unexpected node type")
 		}
-		if err = s.ipfsPublisher.PublishStorageNode(&res.node, headerID, height, statePath, tx); err != nil {
+		if err = s.ipfsPublisher.PublishStorageNode(&res.node, headerID, statePath, tx); err != nil {
 			return nil, err
 		}
 	}

pkg/snapshot/service_test.go

@@ -2,7 +2,6 @@ package snapshot
 
 import (
 	"errors"
-	"math/big"
 	"os"
 	"path/filepath"
 	"testing"
@@ -44,8 +43,9 @@ func TestCreateSnapshot(t *testing.T) {
 			Times(workers)
 		pub.EXPECT().PrepareTxForBatch(gomock.Any(), gomock.Any()).Return(tx, nil).
 			AnyTimes()
-		pub.EXPECT().PublishStateNode(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
-			Times(len(fixt.Block1_StateNodePaths))
+		pub.EXPECT().PublishStateNode(gomock.Any(), gomock.Any(), gomock.Any()).
+			// Use MinTimes as duplicate nodes are expected at boundaries
+			MinTimes(len(fixt.Block1_StateNodePaths))
 
 		// TODO: fixtures for storage node
 		// pub.EXPECT().PublishStorageNode(gomock.Eq(fixt.StorageNode), gomock.Eq(int64(0)), gomock.Any())
@@ -79,7 +79,7 @@ func TestCreateSnapshot(t *testing.T) {
 	}
 }
 
-func failingPublishStateNode(_ *snapt.Node, _ string, _ *big.Int, _ snapt.Tx) error {
+func failingPublishStateNode(_ *snapt.Node, _ string, _ snapt.Tx) error {
 	return errors.New("failingPublishStateNode")
 }
 
@@ -89,7 +89,7 @@ func TestRecovery(t *testing.T) {
 		pub.EXPECT().PublishHeader(gomock.Any()).AnyTimes()
 		pub.EXPECT().BeginTx().Return(tx, nil).AnyTimes()
 		pub.EXPECT().PrepareTxForBatch(gomock.Any(), gomock.Any()).Return(tx, nil).AnyTimes()
-		pub.EXPECT().PublishStateNode(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).
+		pub.EXPECT().PublishStateNode(gomock.Any(), gomock.Any(), gomock.Any()).
 			Times(workers).
 			DoAndReturn(failingPublishStateNode)
 		tx.EXPECT().Commit().AnyTimes()
@@ -117,7 +117,7 @@ func TestRecovery(t *testing.T) {
 			t.Fatal("cannot stat recovery file:", err)
 		}
 
-		pub.EXPECT().PublishStateNode(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
+		pub.EXPECT().PublishStateNode(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
 		err = service.CreateSnapshot(params)
 		if err != nil {
 			t.Fatal(err)

pkg/snapshot/tracker.go

@@ -22,7 +22,11 @@ type trackedIter struct {
 func (it *trackedIter) Next(descend bool) bool {
 	ret := it.NodeIterator.Next(descend)
 	if !ret {
-		it.tracker.stopChan <- it
+		if it.tracker.running {
+			it.tracker.stopChan <- it
+		} else {
+			log.Errorf("iterator stopped after tracker halted: path=%x", it.Path())
+		}
 	}
 	return ret
 }
@@ -34,9 +38,7 @@ type iteratorTracker struct {
 	stopChan  chan *trackedIter
 	started   map[*trackedIter]struct{}
 	stopped   []*trackedIter
-
-	haltChan chan struct{}
-	done     chan struct{}
+	running   bool
 }
 
 func newTracker(file string, buf int) iteratorTracker {
@@ -45,8 +47,7 @@ func newTracker(file string, buf int) iteratorTracker {
 		startChan:    make(chan *trackedIter, buf),
 		stopChan:     make(chan *trackedIter, buf),
 		started:      map[*trackedIter]struct{}{},
-		haltChan:     make(chan struct{}),
-		done:         make(chan struct{}),
+		running:      true,
 	}
 }
 
@@ -62,23 +63,7 @@ func (tr *iteratorTracker) captureSignal() {
 	}()
 }
 
-// listens for starts/stops and manages current state
-func (tr *iteratorTracker) run() {
-loop:
-	for {
-		select {
-		case start := <-tr.startChan:
-			tr.started[start] = struct{}{}
-		case stop := <-tr.stopChan:
-			tr.stopped = append(tr.stopped, stop)
-		case <-tr.haltChan:
-			break loop
-		default:
-		}
-	}
-	tr.done <- struct{}{}
-}
-
+// Wraps an iterator in a trackedIter. This should not be called once halts are possible.
 func (tr *iteratorTracker) tracked(it trie.NodeIterator) (ret *trackedIter) {
 	ret = &trackedIter{it, tr}
 	tr.startChan <- ret
@@ -87,7 +72,7 @@ func (tr *iteratorTracker) tracked(it trie.NodeIterator) (ret *trackedIter) {
 
 // dumps iterator path and bounds to a text file so it can be restored later
 func (tr *iteratorTracker) dump() error {
-	log.Info("Dumping recovery state to: ", tr.recoveryFile)
+	log.Debug("Dumping recovery state to: ", tr.recoveryFile)
 	var rows [][]string
 	for it, _ := range tr.started {
 		var endPath []byte
@@ -118,6 +103,7 @@ func (tr *iteratorTracker) restore(tree state.Trie) ([]trie.NodeIterator, error)
 		}
 		return nil, err
 	}
+	log.Debug("Restoring recovery state from: ", tr.recoveryFile)
 	defer file.Close()
 	in := csv.NewReader(file)
 	in.FieldsPerRecord = 2
@@ -137,15 +123,19 @@ func (tr *iteratorTracker) restore(tree state.Trie) ([]trie.NodeIterator, error)
 			}
 		}
 
-		it := iter.NewPrefixBoundIterator(tree, paths[0], paths[1])
+		// Force the lower bound path to an even length
+		if len(paths[0])&0b1 == 1 {
+			decrementPath(paths[0]) // decrement first to avoid skipped nodes
+			paths[0] = append(paths[0], 0)
+		}
+		it := iter.NewPrefixBoundIterator(tree.NodeIterator(iter.HexToKeyBytes(paths[0])), paths[1])
 		ret = append(ret, tr.tracked(it))
 	}
 	return ret, nil
 }
 
 func (tr *iteratorTracker) haltAndDump() error {
-	tr.haltChan <- struct{}{}
-	<-tr.done
+	tr.running = false
 
 	// drain any pending events
 	close(tr.startChan)

pkg/snapshot/util.go

@@ -28,3 +28,26 @@ func NewPublisher(mode SnapshotMode, config *Config) (snapt.Publisher, error) {
 	}
 	return nil, fmt.Errorf("invalid snapshot mode: %s", mode)
 }
+
+// Subtracts 1 from the last byte in a path slice, carrying if needed.
+// Does nothing, returning false, for all-zero inputs.
+func decrementPath(path []byte) bool {
+	// check for all zeros
+	allzero := true
+	for i := 0; i < len(path); i++ {
+		allzero = allzero && path[i] == 0
+	}
+	if allzero {
+		return false
+	}
+	for i := len(path) - 1; i >= 0; i-- {
+		val := path[i]
+		path[i]--
+		if val == 0 {
+			path[i] = 0xf
+		} else {
+			return true
+		}
+	}
+	return true
+}

pkg/types/publisher.go

@@ -1,17 +1,15 @@
 package types
 
 import (
-	"math/big"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
 type Publisher interface {
 	PublishHeader(header *types.Header) error
-	PublishStateNode(node *Node, headerID string, height *big.Int, tx Tx) error
-	PublishStorageNode(node *Node, headerID string, height *big.Int, statePath []byte, tx Tx) error
-	PublishCode(height *big.Int, codeHash common.Hash, codeBytes []byte, tx Tx) error
+	PublishStateNode(node *Node, headerID string, tx Tx) error
+	PublishStorageNode(node *Node, headerID string, statePath []byte, tx Tx) error
+	PublishCode(codeHash common.Hash, codeBytes []byte, tx Tx) error
 	BeginTx() (Tx, error)
 	PrepareTxForBatch(tx Tx, batchSize uint) (Tx, error)
 }

pkg/types/schema.go

@@ -3,11 +3,10 @@ package types
 var TableIPLDBlock = Table{
 	`public.blocks`,
 	[]column{
-		{"block_number", bigint},
 		{"key", text},
 		{"data", bytea},
 	},
-	"ON CONFLICT (key, block_number) DO NOTHING",
+	`ON CONFLICT (key) DO NOTHING`,
 }
 
 var TableNodeInfo = Table{
@@ -41,13 +40,12 @@ var TableHeader = Table{
 		{"times_validated", integer},
 		{"coinbase", varchar},
 	},
-	"ON CONFLICT (block_hash, block_number) DO UPDATE SET (parent_hash, cid, td, node_id, reward, state_root, tx_root, receipt_root, uncle_root, bloom, timestamp, mh_key, times_validated, coinbase) = (EXCLUDED.parent_hash, EXCLUDED.cid, EXCLUDED.td, EXCLUDED.node_id, EXCLUDED.reward, EXCLUDED.state_root, EXCLUDED.tx_root, EXCLUDED.receipt_root, EXCLUDED.uncle_root, EXCLUDED.bloom, EXCLUDED.timestamp, EXCLUDED.mh_key, eth.header_cids.times_validated + 1, EXCLUDED.coinbase)",
+	"ON CONFLICT (block_hash) DO UPDATE SET (parent_hash, cid, td, node_id, reward, state_root, tx_root, receipt_root, uncle_root, bloom, timestamp, mh_key, times_validated, coinbase) = (EXCLUDED.parent_hash, EXCLUDED.cid, EXCLUDED.td, EXCLUDED.node_id, EXCLUDED.reward, EXCLUDED.state_root, EXCLUDED.tx_root, EXCLUDED.receipt_root, EXCLUDED.uncle_root, EXCLUDED.bloom, EXCLUDED.timestamp, EXCLUDED.mh_key, eth.header_cids.times_validated + 1, EXCLUDED.coinbase)",
 }
 
 var TableStateNode = Table{
 	"eth.state_cids",
 	[]column{
-		{"block_number", bigint},
 		{"header_id", varchar},
 		{"state_leaf_key", varchar},
 		{"cid", text},
@@ -56,13 +54,12 @@ var TableStateNode = Table{
 		{"diff", boolean},
 		{"mh_key", text},
 	},
-	"ON CONFLICT (header_id, state_path, block_number) DO UPDATE SET (state_leaf_key, cid, node_type, diff, mh_key) = (EXCLUDED.state_leaf_key, EXCLUDED.cid, EXCLUDED.node_type, EXCLUDED.diff, EXCLUDED.mh_key)",
+	`ON CONFLICT (header_id, state_path) DO UPDATE SET (state_leaf_key, cid, node_type, diff, mh_key) = (EXCLUDED.state_leaf_key, EXCLUDED.cid, EXCLUDED.node_type, EXCLUDED.diff, EXCLUDED.mh_key)`,
 }
 
 var TableStorageNode = Table{
 	"eth.storage_cids",
 	[]column{
-		{"block_number", bigint},
 		{"header_id", varchar},
 		{"state_path", bytea},
 		{"storage_leaf_key", varchar},
@@ -72,5 +69,5 @@ var TableStorageNode = Table{
 		{"diff", boolean},
 		{"mh_key", text},
 	},
-	"ON CONFLICT (header_id, state_path, storage_path, block_number) DO UPDATE SET (storage_leaf_key, cid, node_type, diff, mh_key) = (EXCLUDED.storage_leaf_key, EXCLUDED.cid, EXCLUDED.node_type, EXCLUDED.diff, EXCLUDED.mh_key)",
+	"ON CONFLICT (header_id, state_path, storage_path) DO UPDATE SET (storage_leaf_key, cid, node_type, diff, mh_key) = (EXCLUDED.storage_leaf_key, EXCLUDED.cid, EXCLUDED.node_type, EXCLUDED.diff, EXCLUDED.mh_key)",
 }