Merge branch 'release/3.0'

Makefile

@@ -2,7 +2,7 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.
 
-.PHONY: gubiq android ios gubiq-cross swarm evm all test clean
+.PHONY: gubiq android ios gubiq-cross evm all test clean
 .PHONY: gubiq-linux gubiq-linux-386 gubiq-linux-amd64 gubiq-linux-mips64 gubiq-linux-mips64le
 .PHONY: gubiq-linux-arm gubiq-linux-arm-5 gubiq-linux-arm-6 gubiq-linux-arm-7 gubiq-linux-arm64
 .PHONY: gubiq-darwin gubiq-darwin-386 gubiq-darwin-amd64
@@ -16,11 +16,6 @@ gubiq:
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/gubiq\" to launch gubiq."
 
-swarm:
-	build/env.sh go run build/ci.go install ./cmd/swarm
-	@echo "Done building."
-	@echo "Run \"$(GOBIN)/swarm\" to launch swarm."
-
 all:
 	build/env.sh go run build/ci.go install
 
@@ -57,9 +52,6 @@ devtools:
 	@type "solc" 2> /dev/null || echo 'Please install solc'
 	@type "protoc" 2> /dev/null || echo 'Please install protoc'
 
-swarm-devtools:
-	env GOBIN= go install ./cmd/swarm/mimegen
-
 # Cross Compilation Targets (xgo)
 
 gubiq-cross: gubiq-linux gubiq-darwin gubiq-windows gubiq-android gubiq-ios

README.md

@@ -11,7 +11,7 @@ Binary archives are published at [releases](https://github.com/ubiq/go-ubiq/rele
 
 ## Building the source
 
-For prerequisites and detailed build instructions please read the [Ubiq's Installation Instructions](https://github.com/ubiq/go-ubiq/wiki/Building-Ubiq) on their wiki. 
+For prerequisites and detailed build instructions please read the [Ubiq's Installation Instructions](https://github.com/ubiq/go-ubiq/wiki/Building-Ubiq) on their wiki.
 
 *Note*: Keep in mind that Ubiq aims to be 100% compatible with Ethereum, so mostly all the documentation you can find on Ethereum wiki, will apply for sure to Ubiq.
 
@@ -35,12 +35,11 @@ The go-ubiq project comes with several wrappers/executables found in the `cmd` d
 | `evm` | Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode. Its purpose is to allow isolated, fine-grained debugging of EVM opcodes (e.g. `evm --code 60ff60ff --debug`). |
 | `gubiqrpctest` | Developer utility tool to support our [ethereum/rpc-test](https://github.com/ethereum/rpc-tests) test suite which validates baseline conformity to the [Ethereum JSON RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC) specs. Please see the [test suite's readme](https://github.com/ethereum/rpc-tests/blob/master/README.md) for details. |
 | `rlpdump` | Developer utility tool to convert binary RLP ([Recursive Length Prefix](https://github.com/ethereum/wiki/wiki/RLP)) dumps (data encoding used by the Ubiq protocol both network as well as consensus wise) to user friendlier hierarchical representation (e.g. `rlpdump --hex CE0183FFFFFFC4C304050583616263`). |
-| `swarm`    | Swarm daemon and tools. This is the entrypoint for the Swarm network. `swarm --help` for command line options and subcommands. See [Swarm README](https://github.com/ubiq/go-ubiq/tree/master/swarm) for more information. |
 | `puppeth`    | a CLI wizard that aids in creating a new Ubiq network. |
 
 ## Running gubiq
 
-Going through all the possible command line flags is out of scope here (please consult 
+Going through all the possible command line flags is out of scope here (please consult
 [Ubiq CLI Wiki page](https://github.com/ubiq/go-ubiq/wiki/Command-Line-Options)), but we've
 enumerated a few common parameter combos to get you up to speed quickly on how you can run your
 own Gubiq instance.
@@ -90,7 +89,7 @@ Specifying the `--testnet` flag however will reconfigure your Gubiq instance a b
    `gubiq attach <datadir>/testnet/gubiq.ipc`. Windows users are not affected by this.
  * Instead of connecting the main Ubiq network, the client will connect to the test network,
    which uses different P2P bootnodes, different network IDs and genesis states.
-   
+
 *Note: Although there are some internal protective measures to prevent transactions from crossing
 over between the main network and test network, you should make sure to always use separate accounts
 for play-money and real-money. Unless you manually move accounts, Gubiq will by default correctly

accounts/hd_test.go

@@ -44,10 +44,10 @@ func TestHDPathParsing(t *testing.T) {
 		{"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0, 0x80000000 + 0}},
 
 		// Hexadecimal absolute derivation paths
-		{"m/0x2C'/0x3c'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0}},
+		{"m/0x2C'/0x6c'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0}},
-		{"m/0x2C'/0x3c'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 128}},
+		{"m/0x2C'/0x6c'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 128}},
-		{"m/0x2C'/0x3c'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0x80000000 + 0}},
+		{"m/0x2C'/0x6c'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0x80000000 + 0}},
-		{"m/0x2C'/0x3c'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0x80000000 + 128}},
+		{"m/0x2C'/0x6c'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0x80000000 + 128}},
 		{"m/0x8000002C/0x8000006c/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0}},
 		{"m/0x8000002C/0x8000006c/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0x80000000 + 0}},
 
@@ -62,12 +62,12 @@ func TestHDPathParsing(t *testing.T) {
 		{"	m  /   44			'\n/\n   108	\n\n\t'   /\n0 ' /\t\t	0", DerivationPath{0x80000000 + 44, 0x80000000 + 108, 0x80000000 + 0, 0}},
 
 		// Invaid derivation paths
-		{"", nil},              // Empty relative derivation path
+		{"", nil},               // Empty relative derivation path
-		{"m", nil},             // Empty absolute derivation path
+		{"m", nil},              // Empty absolute derivation path
-		{"m/", nil},            // Missing last derivation component
+		{"m/", nil},             // Missing last derivation component
 		{"/44'/108'/0'/0", nil}, // Absolute path without m prefix, might be user error
-		{"m/2147483648'", nil}, // Overflows 32 bit integer
+		{"m/2147483648'", nil},  // Overflows 32 bit integer
-		{"m/-1'", nil},         // Cannot contain negative number
+		{"m/-1'", nil},          // Cannot contain negative number
 	}
 	for i, tt := range tests {
 		if path, err := ParseDerivationPath(tt.input); !reflect.DeepEqual(path, tt.output) {

build/ci.go

@@ -60,7 +60,6 @@ import (
 
 	"github.com/ubiq/go-ubiq/internal/build"
 	"github.com/ubiq/go-ubiq/params"
-	sv "github.com/ubiq/go-ubiq/swarm/version"
 )
 
 var (
@@ -82,12 +81,6 @@ var (
 		executablePath("wnode"),
 	}
 
-	// Files that end up in the swarm*.zip archive.
-	swarmArchiveFiles = []string{
-		"COPYING",
-		executablePath("swarm"),
-	}
-
 	// A debian package is created for all executables listed here.
 	debExecutables = []debExecutable{
 		{
@@ -116,16 +109,7 @@ var (
 		},
 		{
 			BinaryName:  "wnode",
-			Description: "Ethereum Whisper diagnostic tool",
+			Description: "Ubiq Whisper diagnostic tool",
-		},
-	}
-
-	// A debian package is created for all executables listed here.
-	debSwarmExecutables = []debExecutable{
-		{
-			BinaryName:  "swarm",
-			PackageName: "ethereum-swarm",
-			Description: "Ethereum Swarm daemon and tools",
 		},
 	}
 
@@ -135,21 +119,11 @@ var (
 		Executables: debExecutables,
 	}
 
-	debSwarm = debPackage{
-		Name:        "ethereum-swarm",
-		Version:     sv.Version,
-		Executables: debSwarmExecutables,
-	}
-
 	// Debian meta packages to build and push to Ubuntu PPA
 	debPackages = []debPackage{
-		debSwarm,
 		debEthereum,
 	}
 
-	// Packages to be cross-compiled by the xgo command
-	allCrossCompiledArchiveFiles = append(allToolsArchiveFiles, swarmArchiveFiles...)
-
 	// Distros for which packages are created.
 	// Note: vivid is unsupported because there is no golang-1.6 package for it.
 	// Note: wily is unsupported because it was officially deprecated on lanchpad.
@@ -402,10 +376,7 @@ func doArchive(cmdline []string) {
 
 		basegubiq = archiveBasename(*arch, params.ArchiveVersion(env.Commit))
 		gubiq     = "gubiq-" + basegubiq + ext
-		alltools = "gubiq-alltools-" + basegubiq + ext
+		alltools  = "gubiq-alltools-" + basegubiq + ext
-
-		baseswarm = archiveBasename(*arch, sv.ArchiveVersion(env.Commit))
-		swarm     = "swarm-" + baseswarm + ext
 	)
 	maybeSkipArchive(env)
 	if err := build.WriteArchive(gubiq, gubiqArchiveFiles); err != nil {
@@ -414,10 +385,7 @@ func doArchive(cmdline []string) {
 	if err := build.WriteArchive(alltools, allToolsArchiveFiles); err != nil {
 		log.Fatal(err)
 	}
-	if err := build.WriteArchive(swarm, swarmArchiveFiles); err != nil {
+	for _, archive := range []string{gubiq, alltools} {
-		log.Fatal(err)
-	}
-	for _, archive := range []string{gubiq, alltools, swarm} {
 		if err := archiveUpload(archive, *upload, *signer); err != nil {
 			log.Fatal(err)
 		}
@@ -1021,7 +989,7 @@ func doXgo(cmdline []string) {
 
 	if *alltools {
 		args = append(args, []string{"--dest", GOBIN}...)
-		for _, res := range allCrossCompiledArchiveFiles {
+		for _, res := range allToolsArchiveFiles {
 			if strings.HasPrefix(res, GOBIN) {
 				// Binary tool found, cross build it explicitly
 				args = append(args, "./"+filepath.Join("cmd", filepath.Base(res)))

build/update-license.go

@@ -72,8 +72,6 @@ var (
 		"internal/jsre/deps",
 		"log/",
 		"common/bitutil/bitutil",
-		// don't license generated files
-		"contracts/chequebook/contract/code.go",
 	}
 
 	// paths with this prefix are licensed as GPL. all other files are LGPL.

cmd/gubiq/main.go

@@ -35,9 +35,11 @@ import (
 	"github.com/ubiq/go-ubiq/eth"
 	"github.com/ubiq/go-ubiq/ethclient"
 	"github.com/ubiq/go-ubiq/internal/debug"
+	"github.com/ubiq/go-ubiq/internal/openrpc"
 	"github.com/ubiq/go-ubiq/log"
 	"github.com/ubiq/go-ubiq/metrics"
 	"github.com/ubiq/go-ubiq/node"
+	"github.com/ubiq/go-ubiq/rpc"
 	cli "gopkg.in/urfave/cli.v1"
 )
 
@@ -248,6 +250,10 @@ func init() {
 		console.Stdin.Close() // Resets terminal mode.
 		return nil
 	}
+
+	if err := rpc.SetDefaultOpenRPCSchemaRaw(openrpc.OpenRPCSchema); err != nil {
+		log.Crit("Setting OpenRPC default", "error", err)
+	}
 }
 
 func main() {

cmd/puppeth/wizard_intro.go

@@ -46,9 +46,9 @@ func makeWizard(network string) *wizard {
 // setting up a new or managing an existing Ubiq private network.
 func (w *wizard) run() {
 	fmt.Println("+-----------------------------------------------------------+")
-	fmt.Println("| Welcome to puppeth, your Ubiq private network manager |")
+	fmt.Println("| Welcome to puppeth, your Ubiq private network manager     |")
 	fmt.Println("|                                                           |")
-	fmt.Println("| This tool lets you create a new Ubiq network down to  |")
+	fmt.Println("| This tool lets you create a new Ubiq network down to      |")
 	fmt.Println("| the genesis block, bootnodes, miners and ethstats servers |")
 	fmt.Println("| without the hassle that it would normally entail.         |")
 	fmt.Println("|                                                           |")

cmd/swarm/access.go

@@ -1,297 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-package main
-
-import (
-	"crypto/rand"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"strings"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	"github.com/ubiq/go-ubiq/swarm/api/client"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var (
-	salt          = make([]byte, 32)
-	accessCommand = cli.Command{
-		CustomHelpTemplate: helpTemplate,
-		Name:               "access",
-		Usage:              "encrypts a reference and embeds it into a root manifest",
-		ArgsUsage:          "<ref>",
-		Description:        "encrypts a reference and embeds it into a root manifest",
-		Subcommands: []cli.Command{
-			{
-				CustomHelpTemplate: helpTemplate,
-				Name:               "new",
-				Usage:              "encrypts a reference and embeds it into a root manifest",
-				ArgsUsage:          "<ref>",
-				Description:        "encrypts a reference and embeds it into a root access manifest and prints the resulting manifest",
-				Subcommands: []cli.Command{
-					{
-						Action:             accessNewPass,
-						CustomHelpTemplate: helpTemplate,
-						Flags: []cli.Flag{
-							utils.PasswordFileFlag,
-							SwarmDryRunFlag,
-						},
-						Name:        "pass",
-						Usage:       "encrypts a reference with a password and embeds it into a root manifest",
-						ArgsUsage:   "<ref>",
-						Description: "encrypts a reference and embeds it into a root access manifest and prints the resulting manifest",
-					},
-					{
-						Action:             accessNewPK,
-						CustomHelpTemplate: helpTemplate,
-						Flags: []cli.Flag{
-							utils.PasswordFileFlag,
-							SwarmDryRunFlag,
-							SwarmAccessGrantKeyFlag,
-						},
-						Name:        "pk",
-						Usage:       "encrypts a reference with the node's private key and a given grantee's public key and embeds it into a root manifest",
-						ArgsUsage:   "<ref>",
-						Description: "encrypts a reference and embeds it into a root access manifest and prints the resulting manifest",
-					},
-					{
-						Action:             accessNewACT,
-						CustomHelpTemplate: helpTemplate,
-						Flags: []cli.Flag{
-							SwarmAccessGrantKeysFlag,
-							SwarmDryRunFlag,
-							utils.PasswordFileFlag,
-						},
-						Name:        "act",
-						Usage:       "encrypts a reference with the node's private key and a given grantee's public key and embeds it into a root manifest",
-						ArgsUsage:   "<ref>",
-						Description: "encrypts a reference and embeds it into a root access manifest and prints the resulting manifest",
-					},
-				},
-			},
-		},
-	}
-)
-
-func init() {
-	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
-		panic("reading from crypto/rand failed: " + err.Error())
-	}
-}
-
-func accessNewPass(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 1 {
-		utils.Fatalf("Expected 1 argument - the ref")
-	}
-
-	var (
-		ae        *api.AccessEntry
-		accessKey []byte
-		err       error
-		ref       = args[0]
-		password  = getPassPhrase("", 0, makePasswordList(ctx))
-		dryRun    = ctx.Bool(SwarmDryRunFlag.Name)
-	)
-	accessKey, ae, err = api.DoPassword(ctx, password, salt)
-	if err != nil {
-		utils.Fatalf("error getting session key: %v", err)
-	}
-	m, err := api.GenerateAccessControlManifest(ctx, ref, accessKey, ae)
-	if err != nil {
-		utils.Fatalf("had an error generating the manifest: %v", err)
-	}
-	if dryRun {
-		err = printManifests(m, nil)
-		if err != nil {
-			utils.Fatalf("had an error printing the manifests: %v", err)
-		}
-	} else {
-		err = uploadManifests(ctx, m, nil)
-		if err != nil {
-			utils.Fatalf("had an error uploading the manifests: %v", err)
-		}
-	}
-}
-
-func accessNewPK(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 1 {
-		utils.Fatalf("Expected 1 argument - the ref")
-	}
-
-	var (
-		ae               *api.AccessEntry
-		sessionKey       []byte
-		err              error
-		ref              = args[0]
-		privateKey       = getPrivKey(ctx)
-		granteePublicKey = ctx.String(SwarmAccessGrantKeyFlag.Name)
-		dryRun           = ctx.Bool(SwarmDryRunFlag.Name)
-	)
-	sessionKey, ae, err = api.DoPK(ctx, privateKey, granteePublicKey, salt)
-	if err != nil {
-		utils.Fatalf("error getting session key: %v", err)
-	}
-	m, err := api.GenerateAccessControlManifest(ctx, ref, sessionKey, ae)
-	if err != nil {
-		utils.Fatalf("had an error generating the manifest: %v", err)
-	}
-	if dryRun {
-		err = printManifests(m, nil)
-		if err != nil {
-			utils.Fatalf("had an error printing the manifests: %v", err)
-		}
-	} else {
-		err = uploadManifests(ctx, m, nil)
-		if err != nil {
-			utils.Fatalf("had an error uploading the manifests: %v", err)
-		}
-	}
-}
-
-func accessNewACT(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 1 {
-		utils.Fatalf("Expected 1 argument - the ref")
-	}
-
-	var (
-		ae                   *api.AccessEntry
-		actManifest          *api.Manifest
-		accessKey            []byte
-		err                  error
-		ref                  = args[0]
-		pkGrantees           = []string{}
-		passGrantees         = []string{}
-		pkGranteesFilename   = ctx.String(SwarmAccessGrantKeysFlag.Name)
-		passGranteesFilename = ctx.String(utils.PasswordFileFlag.Name)
-		privateKey           = getPrivKey(ctx)
-		dryRun               = ctx.Bool(SwarmDryRunFlag.Name)
-	)
-	if pkGranteesFilename == "" && passGranteesFilename == "" {
-		utils.Fatalf("you have to provide either a grantee public-keys file or an encryption passwords file (or both)")
-	}
-
-	if pkGranteesFilename != "" {
-		bytes, err := ioutil.ReadFile(pkGranteesFilename)
-		if err != nil {
-			utils.Fatalf("had an error reading the grantee public key list")
-		}
-		pkGrantees = strings.Split(strings.Trim(string(bytes), "\n"), "\n")
-	}
-
-	if passGranteesFilename != "" {
-		bytes, err := ioutil.ReadFile(passGranteesFilename)
-		if err != nil {
-			utils.Fatalf("could not read password filename: %v", err)
-		}
-		passGrantees = strings.Split(strings.Trim(string(bytes), "\n"), "\n")
-	}
-	accessKey, ae, actManifest, err = api.DoACT(ctx, privateKey, salt, pkGrantees, passGrantees)
-	if err != nil {
-		utils.Fatalf("error generating ACT manifest: %v", err)
-	}
-
-	if err != nil {
-		utils.Fatalf("error getting session key: %v", err)
-	}
-	m, err := api.GenerateAccessControlManifest(ctx, ref, accessKey, ae)
-	if err != nil {
-		utils.Fatalf("error generating root access manifest: %v", err)
-	}
-
-	if dryRun {
-		err = printManifests(m, actManifest)
-		if err != nil {
-			utils.Fatalf("had an error printing the manifests: %v", err)
-		}
-	} else {
-		err = uploadManifests(ctx, m, actManifest)
-		if err != nil {
-			utils.Fatalf("had an error uploading the manifests: %v", err)
-		}
-	}
-}
-
-func printManifests(rootAccessManifest, actManifest *api.Manifest) error {
-	js, err := json.Marshal(rootAccessManifest)
-	if err != nil {
-		return err
-	}
-	fmt.Println(string(js))
-
-	if actManifest != nil {
-		js, err := json.Marshal(actManifest)
-		if err != nil {
-			return err
-		}
-		fmt.Println(string(js))
-	}
-	return nil
-}
-
-func uploadManifests(ctx *cli.Context, rootAccessManifest, actManifest *api.Manifest) error {
-	bzzapi := strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-	client := client.NewClient(bzzapi)
-
-	var (
-		key string
-		err error
-	)
-	if actManifest != nil {
-		key, err = client.UploadManifest(actManifest, false)
-		if err != nil {
-			return err
-		}
-
-		rootAccessManifest.Entries[0].Access.Act = key
-	}
-	key, err = client.UploadManifest(rootAccessManifest, false)
-	if err != nil {
-		return err
-	}
-	fmt.Println(key)
-	return nil
-}
-
-// makePasswordList reads password lines from the file specified by the global --password flag
-// and also by the same subcommand --password flag.
-// This function ia a fork of utils.MakePasswordList to lookup cli context for subcommand.
-// Function ctx.SetGlobal is not setting the global flag value that can be accessed
-// by ctx.GlobalString using the current version of cli package.
-func makePasswordList(ctx *cli.Context) []string {
-	path := ctx.GlobalString(utils.PasswordFileFlag.Name)
-	if path == "" {
-		path = ctx.String(utils.PasswordFileFlag.Name)
-		if path == "" {
-			return nil
-		}
-	}
-	text, err := ioutil.ReadFile(path)
-	if err != nil {
-		utils.Fatalf("Failed to read password file: %v", err)
-	}
-	lines := strings.Split(string(text), "\n")
-	// Sanitise DOS line endings.
-	for i := range lines {
-		lines[i] = strings.TrimRight(lines[i], "\r")
-	}
-	return lines
-}

cmd/swarm/access_test.go

@@ -1,614 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"crypto/rand"
-	"encoding/hex"
-	"encoding/json"
-	"io"
-	"io/ioutil"
-	gorand "math/rand"
-	"net/http"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ubiq/go-ubiq/crypto"
-	"github.com/ubiq/go-ubiq/crypto/ecies"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	swarmapi "github.com/ubiq/go-ubiq/swarm/api/client"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-	"golang.org/x/crypto/sha3"
-)
-
-const (
-	hashRegexp = `[a-f\d]{128}`
-	data       = "notsorandomdata"
-)
-
-var DefaultCurve = crypto.S256()
-
-func TestACT(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	initCluster(t)
-
-	cases := []struct {
-		name string
-		f    func(t *testing.T)
-	}{
-		{"Password", testPassword},
-		{"PK", testPK},
-		{"ACTWithoutBogus", testACTWithoutBogus},
-		{"ACTWithBogus", testACTWithBogus},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, tc.f)
-	}
-}
-
-// testPassword tests for the correct creation of an ACT manifest protected by a password.
-// The test creates bogus content, uploads it encrypted, then creates the wrapping manifest with the Access entry
-// The parties participating - node (publisher), uploads to second node then disappears. Content which was uploaded
-// is then fetched through 2nd node. since the tested code is not key-aware - we can just
-// fetch from the 2nd node using HTTP BasicAuth
-func testPassword(t *testing.T) {
-	dataFilename := testutil.TempFileWithContent(t, data)
-	defer os.RemoveAll(dataFilename)
-
-	// upload the file with 'swarm up' and expect a hash
-	up := runSwarm(t,
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"up",
-		"--encrypt",
-		dataFilename)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-
-	if len(matches) < 1 {
-		t.Fatal("no matches found")
-	}
-
-	ref := matches[0]
-	tmp, err := ioutil.TempDir("", "swarm-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
-	password := "smth"
-	passwordFilename := testutil.TempFileWithContent(t, "smth")
-	defer os.RemoveAll(passwordFilename)
-
-	up = runSwarm(t,
-		"access",
-		"new",
-		"pass",
-		"--dry-run",
-		"--password",
-		passwordFilename,
-		ref,
-	)
-
-	_, matches = up.ExpectRegexp(".+")
-	up.ExpectExit()
-
-	if len(matches) == 0 {
-		t.Fatalf("stdout not matched")
-	}
-
-	var m api.Manifest
-
-	err = json.Unmarshal([]byte(matches[0]), &m)
-	if err != nil {
-		t.Fatalf("unmarshal manifest: %v", err)
-	}
-
-	if len(m.Entries) != 1 {
-		t.Fatalf("expected one manifest entry, got %v", len(m.Entries))
-	}
-
-	e := m.Entries[0]
-
-	ct := "application/bzz-manifest+json"
-	if e.ContentType != ct {
-		t.Errorf("expected %q content type, got %q", ct, e.ContentType)
-	}
-
-	if e.Access == nil {
-		t.Fatal("manifest access is nil")
-	}
-
-	a := e.Access
-
-	if a.Type != "pass" {
-		t.Errorf(`got access type %q, expected "pass"`, a.Type)
-	}
-	if len(a.Salt) < 32 {
-		t.Errorf(`got salt with length %v, expected not less the 32 bytes`, len(a.Salt))
-	}
-	if a.KdfParams == nil {
-		t.Fatal("manifest access kdf params is nil")
-	}
-	if a.Publisher != "" {
-		t.Fatal("should be empty")
-	}
-
-	client := swarmapi.NewClient(cluster.Nodes[0].URL)
-
-	hash, err := client.UploadManifest(&m, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	url := cluster.Nodes[0].URL + "/" + "bzz:/" + hash
-
-	httpClient := &http.Client{}
-	response, err := httpClient.Get(url)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if response.StatusCode != http.StatusUnauthorized {
-		t.Fatal("should be a 401")
-	}
-	authHeader := response.Header.Get("WWW-Authenticate")
-	if authHeader == "" {
-		t.Fatal("should be something here")
-	}
-
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	req.SetBasicAuth("", password)
-
-	response, err = http.DefaultClient.Do(req)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode != http.StatusOK {
-		t.Errorf("expected status %v, got %v", http.StatusOK, response.StatusCode)
-	}
-	d, err := ioutil.ReadAll(response.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(d) != data {
-		t.Errorf("expected decrypted data %q, got %q", data, string(d))
-	}
-
-	wrongPasswordFilename := testutil.TempFileWithContent(t, "just wr0ng")
-	defer os.RemoveAll(wrongPasswordFilename)
-
-	//download file with 'swarm down' with wrong password
-	up = runSwarm(t,
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"down",
-		"bzz:/"+hash,
-		tmp,
-		"--password",
-		wrongPasswordFilename)
-
-	_, matches = up.ExpectRegexp("unauthorized")
-	if len(matches) != 1 && matches[0] != "unauthorized" {
-		t.Fatal(`"unauthorized" not found in output"`)
-	}
-	up.ExpectExit()
-}
-
-// testPK tests for the correct creation of an ACT manifest between two parties (publisher and grantee).
-// The test creates bogus content, uploads it encrypted, then creates the wrapping manifest with the Access entry
-// The parties participating - node (publisher), uploads to second node (which is also the grantee) then disappears.
-// Content which was uploaded is then fetched through the grantee's http proxy. Since the tested code is private-key aware,
-// the test will fail if the proxy's given private key is not granted on the ACT.
-func testPK(t *testing.T) {
-	dataFilename := testutil.TempFileWithContent(t, data)
-	defer os.RemoveAll(dataFilename)
-
-	// upload the file with 'swarm up' and expect a hash
-	up := runSwarm(t,
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"up",
-		"--encrypt",
-		dataFilename)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-
-	if len(matches) < 1 {
-		t.Fatal("no matches found")
-	}
-
-	ref := matches[0]
-	pk := cluster.Nodes[0].PrivateKey
-	granteePubKey := crypto.CompressPubkey(&pk.PublicKey)
-
-	publisherDir, err := ioutil.TempDir("", "swarm-account-dir-temp")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	passwordFilename := testutil.TempFileWithContent(t, testPassphrase)
-	defer os.RemoveAll(passwordFilename)
-
-	_, publisherAccount := getTestAccount(t, publisherDir)
-	up = runSwarm(t,
-		"--bzzaccount",
-		publisherAccount.Address.String(),
-		"--password",
-		passwordFilename,
-		"--datadir",
-		publisherDir,
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"access",
-		"new",
-		"pk",
-		"--dry-run",
-		"--grant-key",
-		hex.EncodeToString(granteePubKey),
-		ref,
-	)
-
-	_, matches = up.ExpectRegexp(".+")
-	up.ExpectExit()
-
-	if len(matches) == 0 {
-		t.Fatalf("stdout not matched")
-	}
-
-	//get the public key from the publisher directory
-	publicKeyFromDataDir := runSwarm(t,
-		"--bzzaccount",
-		publisherAccount.Address.String(),
-		"--password",
-		passwordFilename,
-		"--datadir",
-		publisherDir,
-		"print-keys",
-		"--compressed",
-	)
-	_, publicKeyString := publicKeyFromDataDir.ExpectRegexp(".+")
-	publicKeyFromDataDir.ExpectExit()
-	pkComp := strings.Split(publicKeyString[0], "=")[1]
-	var m api.Manifest
-
-	err = json.Unmarshal([]byte(matches[0]), &m)
-	if err != nil {
-		t.Fatalf("unmarshal manifest: %v", err)
-	}
-
-	if len(m.Entries) != 1 {
-		t.Fatalf("expected one manifest entry, got %v", len(m.Entries))
-	}
-
-	e := m.Entries[0]
-
-	ct := "application/bzz-manifest+json"
-	if e.ContentType != ct {
-		t.Errorf("expected %q content type, got %q", ct, e.ContentType)
-	}
-
-	if e.Access == nil {
-		t.Fatal("manifest access is nil")
-	}
-
-	a := e.Access
-
-	if a.Type != "pk" {
-		t.Errorf(`got access type %q, expected "pk"`, a.Type)
-	}
-	if len(a.Salt) < 32 {
-		t.Errorf(`got salt with length %v, expected not less the 32 bytes`, len(a.Salt))
-	}
-	if a.KdfParams != nil {
-		t.Fatal("manifest access kdf params should be nil")
-	}
-	if a.Publisher != pkComp {
-		t.Fatal("publisher key did not match")
-	}
-	client := swarmapi.NewClient(cluster.Nodes[0].URL)
-
-	hash, err := client.UploadManifest(&m, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	httpClient := &http.Client{}
-
-	url := cluster.Nodes[0].URL + "/" + "bzz:/" + hash
-	response, err := httpClient.Get(url)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if response.StatusCode != http.StatusOK {
-		t.Fatal("should be a 200")
-	}
-	d, err := ioutil.ReadAll(response.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(d) != data {
-		t.Errorf("expected decrypted data %q, got %q", data, string(d))
-	}
-}
-
-// testACTWithoutBogus tests the creation of the ACT manifest end-to-end, without any bogus entries (i.e. default scenario = 3 nodes 1 unauthorized)
-func testACTWithoutBogus(t *testing.T) {
-	testACT(t, 0)
-}
-
-// testACTWithBogus tests the creation of the ACT manifest end-to-end, with 100 bogus entries (i.e. 100 EC keys + default scenario = 3 nodes 1 unauthorized = 103 keys in the ACT manifest)
-func testACTWithBogus(t *testing.T) {
-	testACT(t, 100)
-}
-
-// testACT tests the e2e creation, uploading and downloading of an ACT access control with both EC keys AND password protection
-// the test fires up a 3 node cluster, then randomly picks 2 nodes which will be acting as grantees to the data
-// set and also protects the ACT with a password. the third node should fail decoding the reference as it will not be granted access.
-// the third node then then tries to download using a correct password (and succeeds) then uses a wrong password and fails.
-// the publisher uploads through one of the nodes then disappears.
-func testACT(t *testing.T, bogusEntries int) {
-	var uploadThroughNode = cluster.Nodes[0]
-	client := swarmapi.NewClient(uploadThroughNode.URL)
-
-	r1 := gorand.New(gorand.NewSource(time.Now().UnixNano()))
-	nodeToSkip := r1.Intn(clusterSize) // a number between 0 and 2 (node indices in `cluster`)
-	dataFilename := testutil.TempFileWithContent(t, data)
-	defer os.RemoveAll(dataFilename)
-
-	// upload the file with 'swarm up' and expect a hash
-	up := runSwarm(t,
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"up",
-		"--encrypt",
-		dataFilename)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-
-	if len(matches) < 1 {
-		t.Fatal("no matches found")
-	}
-
-	ref := matches[0]
-	grantees := []string{}
-	for i, v := range cluster.Nodes {
-		if i == nodeToSkip {
-			continue
-		}
-		pk := v.PrivateKey
-		granteePubKey := crypto.CompressPubkey(&pk.PublicKey)
-		grantees = append(grantees, hex.EncodeToString(granteePubKey))
-	}
-
-	if bogusEntries > 0 {
-		bogusGrantees := []string{}
-
-		for i := 0; i < bogusEntries; i++ {
-			prv, err := ecies.GenerateKey(rand.Reader, DefaultCurve, nil)
-			if err != nil {
-				t.Fatal(err)
-			}
-			bogusGrantees = append(bogusGrantees, hex.EncodeToString(crypto.CompressPubkey(&prv.ExportECDSA().PublicKey)))
-		}
-		r2 := gorand.New(gorand.NewSource(time.Now().UnixNano()))
-		for i := 0; i < len(grantees); i++ {
-			insertAtIdx := r2.Intn(len(bogusGrantees))
-			bogusGrantees = append(bogusGrantees[:insertAtIdx], append([]string{grantees[i]}, bogusGrantees[insertAtIdx:]...)...)
-		}
-		grantees = bogusGrantees
-	}
-	granteesPubkeyListFile := testutil.TempFileWithContent(t, strings.Join(grantees, "\n"))
-	defer os.RemoveAll(granteesPubkeyListFile)
-
-	publisherDir, err := ioutil.TempDir("", "swarm-account-dir-temp")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(publisherDir)
-
-	passwordFilename := testutil.TempFileWithContent(t, testPassphrase)
-	defer os.RemoveAll(passwordFilename)
-	actPasswordFilename := testutil.TempFileWithContent(t, "smth")
-	defer os.RemoveAll(actPasswordFilename)
-	_, publisherAccount := getTestAccount(t, publisherDir)
-	up = runSwarm(t,
-		"--bzzaccount",
-		publisherAccount.Address.String(),
-		"--password",
-		passwordFilename,
-		"--datadir",
-		publisherDir,
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"access",
-		"new",
-		"act",
-		"--grant-keys",
-		granteesPubkeyListFile,
-		"--password",
-		actPasswordFilename,
-		ref,
-	)
-
-	_, matches = up.ExpectRegexp(`[a-f\d]{64}`)
-	up.ExpectExit()
-
-	if len(matches) == 0 {
-		t.Fatalf("stdout not matched")
-	}
-
-	//get the public key from the publisher directory
-	publicKeyFromDataDir := runSwarm(t,
-		"--bzzaccount",
-		publisherAccount.Address.String(),
-		"--password",
-		passwordFilename,
-		"--datadir",
-		publisherDir,
-		"print-keys",
-		"--compressed",
-	)
-	_, publicKeyString := publicKeyFromDataDir.ExpectRegexp(".+")
-	publicKeyFromDataDir.ExpectExit()
-	pkComp := strings.Split(publicKeyString[0], "=")[1]
-
-	hash := matches[0]
-	m, _, err := client.DownloadManifest(hash)
-	if err != nil {
-		t.Fatalf("unmarshal manifest: %v", err)
-	}
-
-	if len(m.Entries) != 1 {
-		t.Fatalf("expected one manifest entry, got %v", len(m.Entries))
-	}
-
-	e := m.Entries[0]
-
-	ct := "application/bzz-manifest+json"
-	if e.ContentType != ct {
-		t.Errorf("expected %q content type, got %q", ct, e.ContentType)
-	}
-
-	if e.Access == nil {
-		t.Fatal("manifest access is nil")
-	}
-
-	a := e.Access
-
-	if a.Type != "act" {
-		t.Fatalf(`got access type %q, expected "act"`, a.Type)
-	}
-	if len(a.Salt) < 32 {
-		t.Fatalf(`got salt with length %v, expected not less the 32 bytes`, len(a.Salt))
-	}
-
-	if a.Publisher != pkComp {
-		t.Fatal("publisher key did not match")
-	}
-	httpClient := &http.Client{}
-
-	// all nodes except the skipped node should be able to decrypt the content
-	for i, node := range cluster.Nodes {
-		log.Debug("trying to fetch from node", "node index", i)
-
-		url := node.URL + "/" + "bzz:/" + hash
-		response, err := httpClient.Get(url)
-		if err != nil {
-			t.Fatal(err)
-		}
-		log.Debug("got response from node", "response code", response.StatusCode)
-
-		if i == nodeToSkip {
-			log.Debug("reached node to skip", "status code", response.StatusCode)
-
-			if response.StatusCode != http.StatusUnauthorized {
-				t.Fatalf("should be a 401")
-			}
-
-			// try downloading using a password instead, using the unauthorized node
-			passwordUrl := strings.Replace(url, "http://", "http://:smth@", -1)
-			response, err = httpClient.Get(passwordUrl)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if response.StatusCode != http.StatusOK {
-				t.Fatal("should be a 200")
-			}
-
-			// now try with the wrong password, expect 401
-			passwordUrl = strings.Replace(url, "http://", "http://:smthWrong@", -1)
-			response, err = httpClient.Get(passwordUrl)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if response.StatusCode != http.StatusUnauthorized {
-				t.Fatal("should be a 401")
-			}
-			continue
-		}
-
-		if response.StatusCode != http.StatusOK {
-			t.Fatal("should be a 200")
-		}
-		d, err := ioutil.ReadAll(response.Body)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if string(d) != data {
-			t.Errorf("expected decrypted data %q, got %q", data, string(d))
-		}
-	}
-}
-
-// TestKeypairSanity is a sanity test for the crypto scheme for ACT. it asserts the correct shared secret according to
-// the specs at https://github.com/ethersphere/swarm-docs/blob/eb857afda906c6e7bb90d37f3f334ccce5eef230/act.md
-func TestKeypairSanity(t *testing.T) {
-	salt := make([]byte, 32)
-	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
-		t.Fatalf("reading from crypto/rand failed: %v", err.Error())
-	}
-	sharedSecret := "a85586744a1ddd56a7ed9f33fa24f40dd745b3a941be296a0d60e329dbdb896d"
-
-	for i, v := range []struct {
-		publisherPriv string
-		granteePub    string
-	}{
-		{
-			publisherPriv: "ec5541555f3bc6376788425e9d1a62f55a82901683fd7062c5eddcc373a73459",
-			granteePub:    "0226f213613e843a413ad35b40f193910d26eb35f00154afcde9ded57479a6224a",
-		},
-		{
-			publisherPriv: "70c7a73011aa56584a0009ab874794ee7e5652fd0c6911cd02f8b6267dd82d2d",
-			granteePub:    "02e6f8d5e28faaa899744972bb847b6eb805a160494690c9ee7197ae9f619181db",
-		},
-	} {
-		b, _ := hex.DecodeString(v.granteePub)
-		granteePub, _ := crypto.DecompressPubkey(b)
-		publisherPrivate, _ := crypto.HexToECDSA(v.publisherPriv)
-
-		ssKey, err := api.NewSessionKeyPK(publisherPrivate, granteePub, salt)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		hasher := sha3.NewLegacyKeccak256()
-		hasher.Write(salt)
-		shared, err := hex.DecodeString(sharedSecret)
-		if err != nil {
-			t.Fatal(err)
-		}
-		hasher.Write(shared)
-		sum := hasher.Sum(nil)
-
-		if !bytes.Equal(ssKey, sum) {
-			t.Fatalf("%d: got a session key mismatch", i)
-		}
-	}
-}

cmd/swarm/bootnodes.go

@@ -1,24 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-var SwarmBootnodes = []string{
-	// EF Swarm Bootnode - AWS - eu-central-1
-	"enode://4c113504601930bf2000c29bcd98d1716b6167749f58bad703bae338332fe93cc9d9204f08afb44100dc7bea479205f5d162df579f9a8f76f8b402d339709023@3.122.203.99:30301",
-	// EF Swarm Bootnode - AWS - us-west-2
-	"enode://89f2ede3371bff1ad9f2088f2012984e280287a4e2b68007c2a6ad994909c51886b4a8e9e2ecc97f9910aca538398e0a5804b0ee80a187fde1ba4f32626322ba@52.35.212.179:30301",
-}

cmd/swarm/config.go

@@ -1,447 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-
-	cli "gopkg.in/urfave/cli.v1"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/node"
-	"github.com/naoina/toml"
-
-	bzzapi "github.com/ubiq/go-ubiq/swarm/api"
-)
-
-var (
-	//flag definition for the dumpconfig command
-	DumpConfigCommand = cli.Command{
-		Action:      utils.MigrateFlags(dumpConfig),
-		Name:        "dumpconfig",
-		Usage:       "Show configuration values",
-		ArgsUsage:   "",
-		Flags:       app.Flags,
-		Category:    "MISCELLANEOUS COMMANDS",
-		Description: `The dumpconfig command shows configuration values.`,
-	}
-
-	//flag definition for the config file command
-	SwarmTomlConfigPathFlag = cli.StringFlag{
-		Name:  "config",
-		Usage: "TOML configuration file",
-	}
-)
-
-//constants for environment variables
-const (
-	SWARM_ENV_CHEQUEBOOK_ADDR         = "SWARM_CHEQUEBOOK_ADDR"
-	SWARM_ENV_ACCOUNT                 = "SWARM_ACCOUNT"
-	SWARM_ENV_LISTEN_ADDR             = "SWARM_LISTEN_ADDR"
-	SWARM_ENV_PORT                    = "SWARM_PORT"
-	SWARM_ENV_NETWORK_ID              = "SWARM_NETWORK_ID"
-	SWARM_ENV_SWAP_ENABLE             = "SWARM_SWAP_ENABLE"
-	SWARM_ENV_SWAP_API                = "SWARM_SWAP_API"
-	SWARM_ENV_SYNC_DISABLE            = "SWARM_SYNC_DISABLE"
-	SWARM_ENV_SYNC_UPDATE_DELAY       = "SWARM_ENV_SYNC_UPDATE_DELAY"
-	SWARM_ENV_MAX_STREAM_PEER_SERVERS = "SWARM_ENV_MAX_STREAM_PEER_SERVERS"
-	SWARM_ENV_LIGHT_NODE_ENABLE       = "SWARM_LIGHT_NODE_ENABLE"
-	SWARM_ENV_DELIVERY_SKIP_CHECK     = "SWARM_DELIVERY_SKIP_CHECK"
-	SWARM_ENV_ENS_API                 = "SWARM_ENS_API"
-	SWARM_ENV_ENS_ADDR                = "SWARM_ENS_ADDR"
-	SWARM_ENV_CORS                    = "SWARM_CORS"
-	SWARM_ENV_BOOTNODES               = "SWARM_BOOTNODES"
-	SWARM_ENV_PSS_ENABLE              = "SWARM_PSS_ENABLE"
-	SWARM_ENV_STORE_PATH              = "SWARM_STORE_PATH"
-	SWARM_ENV_STORE_CAPACITY          = "SWARM_STORE_CAPACITY"
-	SWARM_ENV_STORE_CACHE_CAPACITY    = "SWARM_STORE_CACHE_CAPACITY"
-	SWARM_ENV_BOOTNODE_MODE           = "SWARM_BOOTNODE_MODE"
-	SWARM_ACCESS_PASSWORD             = "SWARM_ACCESS_PASSWORD"
-	SWARM_AUTO_DEFAULTPATH            = "SWARM_AUTO_DEFAULTPATH"
-	SWARM_GLOBALSTORE_API             = "SWARM_GLOBALSTORE_API"
-	GETH_ENV_DATADIR                  = "GETH_DATADIR"
-)
-
-// These settings ensure that TOML keys use the same names as Go struct fields.
-var tomlSettings = toml.Config{
-	NormFieldName: func(rt reflect.Type, key string) string {
-		return key
-	},
-	FieldToKey: func(rt reflect.Type, field string) string {
-		return field
-	},
-	MissingField: func(rt reflect.Type, field string) error {
-		link := ""
-		if unicode.IsUpper(rune(rt.Name()[0])) && rt.PkgPath() != "main" {
-			link = fmt.Sprintf(", check github.com/ubiq/go-ubiq/swarm/api/config.go for available fields")
-		}
-		return fmt.Errorf("field '%s' is not defined in %s%s", field, rt.String(), link)
-	},
-}
-
-//before booting the swarm node, build the configuration
-func buildConfig(ctx *cli.Context) (config *bzzapi.Config, err error) {
-	//start by creating a default config
-	config = bzzapi.NewConfig()
-	//first load settings from config file (if provided)
-	config, err = configFileOverride(config, ctx)
-	if err != nil {
-		return nil, err
-	}
-	//override settings provided by environment variables
-	config = envVarsOverride(config)
-	//override settings provided by command line
-	config = cmdLineOverride(config, ctx)
-	//validate configuration parameters
-	err = validateConfig(config)
-
-	return
-}
-
-//finally, after the configuration build phase is finished, initialize
-func initSwarmNode(config *bzzapi.Config, stack *node.Node, ctx *cli.Context) {
-	//at this point, all vars should be set in the Config
-	//get the account for the provided swarm account
-	prvkey := getAccount(config.BzzAccount, ctx, stack)
-	//set the resolved config path (gubiq --datadir)
-	config.Path = expandPath(stack.InstanceDir())
-	//finally, initialize the configuration
-	config.Init(prvkey)
-	//configuration phase completed here
-	log.Debug("Starting Swarm with the following parameters:")
-	//after having created the config, print it to screen
-	log.Debug(printConfig(config))
-}
-
-//configFileOverride overrides the current config with the config file, if a config file has been provided
-func configFileOverride(config *bzzapi.Config, ctx *cli.Context) (*bzzapi.Config, error) {
-	var err error
-
-	//only do something if the -config flag has been set
-	if ctx.GlobalIsSet(SwarmTomlConfigPathFlag.Name) {
-		var filepath string
-		if filepath = ctx.GlobalString(SwarmTomlConfigPathFlag.Name); filepath == "" {
-			utils.Fatalf("Config file flag provided with invalid file path")
-		}
-		var f *os.File
-		f, err = os.Open(filepath)
-		if err != nil {
-			return nil, err
-		}
-		defer f.Close()
-
-		//decode the TOML file into a Config struct
-		//note that we are decoding into the existing defaultConfig;
-		//if an entry is not present in the file, the default entry is kept
-		err = tomlSettings.NewDecoder(f).Decode(&config)
-		// Add file name to errors that have a line number.
-		if _, ok := err.(*toml.LineError); ok {
-			err = errors.New(filepath + ", " + err.Error())
-		}
-	}
-	return config, err
-}
-
-// cmdLineOverride overrides the current config with whatever is provided through the command line
-// most values are not allowed a zero value (empty string), if not otherwise noted
-func cmdLineOverride(currentConfig *bzzapi.Config, ctx *cli.Context) *bzzapi.Config {
-	if keyid := ctx.GlobalString(SwarmAccountFlag.Name); keyid != "" {
-		currentConfig.BzzAccount = keyid
-	}
-
-	if chbookaddr := ctx.GlobalString(ChequebookAddrFlag.Name); chbookaddr != "" {
-		currentConfig.Contract = common.HexToAddress(chbookaddr)
-	}
-
-	if networkid := ctx.GlobalString(SwarmNetworkIdFlag.Name); networkid != "" {
-		id, err := strconv.ParseUint(networkid, 10, 64)
-		if err != nil {
-			utils.Fatalf("invalid cli flag %s: %v", SwarmNetworkIdFlag.Name, err)
-		}
-		if id != 0 {
-			currentConfig.NetworkID = id
-		}
-	}
-
-	if ctx.GlobalIsSet(utils.DataDirFlag.Name) {
-		if datadir := ctx.GlobalString(utils.DataDirFlag.Name); datadir != "" {
-			currentConfig.Path = expandPath(datadir)
-		}
-	}
-
-	bzzport := ctx.GlobalString(SwarmPortFlag.Name)
-	if len(bzzport) > 0 {
-		currentConfig.Port = bzzport
-	}
-
-	if bzzaddr := ctx.GlobalString(SwarmListenAddrFlag.Name); bzzaddr != "" {
-		currentConfig.ListenAddr = bzzaddr
-	}
-
-	if ctx.GlobalIsSet(SwarmSwapEnabledFlag.Name) {
-		currentConfig.SwapEnabled = true
-	}
-
-	if ctx.GlobalIsSet(SwarmSyncDisabledFlag.Name) {
-		currentConfig.SyncEnabled = false
-	}
-
-	if d := ctx.GlobalDuration(SwarmSyncUpdateDelay.Name); d > 0 {
-		currentConfig.SyncUpdateDelay = d
-	}
-
-	// any value including 0 is acceptable
-	currentConfig.MaxStreamPeerServers = ctx.GlobalInt(SwarmMaxStreamPeerServersFlag.Name)
-
-	if ctx.GlobalIsSet(SwarmLightNodeEnabled.Name) {
-		currentConfig.LightNodeEnabled = true
-	}
-
-	if ctx.GlobalIsSet(SwarmDeliverySkipCheckFlag.Name) {
-		currentConfig.DeliverySkipCheck = true
-	}
-
-	currentConfig.SwapAPI = ctx.GlobalString(SwarmSwapAPIFlag.Name)
-	if currentConfig.SwapEnabled && currentConfig.SwapAPI == "" {
-		utils.Fatalf(SWARM_ERR_SWAP_SET_NO_API)
-	}
-
-	if ctx.GlobalIsSet(EnsAPIFlag.Name) {
-		ensAPIs := ctx.GlobalStringSlice(EnsAPIFlag.Name)
-		// preserve backward compatibility to disable ENS with --ens-api=""
-		if len(ensAPIs) == 1 && ensAPIs[0] == "" {
-			ensAPIs = nil
-		}
-		for i := range ensAPIs {
-			ensAPIs[i] = expandPath(ensAPIs[i])
-		}
-
-		currentConfig.EnsAPIs = ensAPIs
-	}
-
-	if cors := ctx.GlobalString(CorsStringFlag.Name); cors != "" {
-		currentConfig.Cors = cors
-	}
-
-	if storePath := ctx.GlobalString(SwarmStorePath.Name); storePath != "" {
-		currentConfig.LocalStoreParams.ChunkDbPath = storePath
-	}
-
-	if storeCapacity := ctx.GlobalUint64(SwarmStoreCapacity.Name); storeCapacity != 0 {
-		currentConfig.LocalStoreParams.DbCapacity = storeCapacity
-	}
-
-	if storeCacheCapacity := ctx.GlobalUint(SwarmStoreCacheCapacity.Name); storeCacheCapacity != 0 {
-		currentConfig.LocalStoreParams.CacheCapacity = storeCacheCapacity
-	}
-
-	if ctx.GlobalIsSet(SwarmBootnodeModeFlag.Name) {
-		currentConfig.BootnodeMode = ctx.GlobalBool(SwarmBootnodeModeFlag.Name)
-	}
-
-	if ctx.GlobalIsSet(SwarmGlobalStoreAPIFlag.Name) {
-		currentConfig.GlobalStoreAPI = ctx.GlobalString(SwarmGlobalStoreAPIFlag.Name)
-	}
-
-	return currentConfig
-
-}
-
-// envVarsOverride overrides the current config with whatver is provided in environment variables
-// most values are not allowed a zero value (empty string), if not otherwise noted
-func envVarsOverride(currentConfig *bzzapi.Config) (config *bzzapi.Config) {
-	if keyid := os.Getenv(SWARM_ENV_ACCOUNT); keyid != "" {
-		currentConfig.BzzAccount = keyid
-	}
-
-	if chbookaddr := os.Getenv(SWARM_ENV_CHEQUEBOOK_ADDR); chbookaddr != "" {
-		currentConfig.Contract = common.HexToAddress(chbookaddr)
-	}
-
-	if networkid := os.Getenv(SWARM_ENV_NETWORK_ID); networkid != "" {
-		id, err := strconv.ParseUint(networkid, 10, 64)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_NETWORK_ID, err)
-		}
-		if id != 0 {
-			currentConfig.NetworkID = id
-		}
-	}
-
-	if datadir := os.Getenv(GETH_ENV_DATADIR); datadir != "" {
-		currentConfig.Path = expandPath(datadir)
-	}
-
-	bzzport := os.Getenv(SWARM_ENV_PORT)
-	if len(bzzport) > 0 {
-		currentConfig.Port = bzzport
-	}
-
-	if bzzaddr := os.Getenv(SWARM_ENV_LISTEN_ADDR); bzzaddr != "" {
-		currentConfig.ListenAddr = bzzaddr
-	}
-
-	if swapenable := os.Getenv(SWARM_ENV_SWAP_ENABLE); swapenable != "" {
-		swap, err := strconv.ParseBool(swapenable)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_SWAP_ENABLE, err)
-		}
-		currentConfig.SwapEnabled = swap
-	}
-
-	if syncdisable := os.Getenv(SWARM_ENV_SYNC_DISABLE); syncdisable != "" {
-		sync, err := strconv.ParseBool(syncdisable)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_SYNC_DISABLE, err)
-		}
-		currentConfig.SyncEnabled = !sync
-	}
-
-	if v := os.Getenv(SWARM_ENV_DELIVERY_SKIP_CHECK); v != "" {
-		skipCheck, err := strconv.ParseBool(v)
-		if err != nil {
-			currentConfig.DeliverySkipCheck = skipCheck
-		}
-	}
-
-	if v := os.Getenv(SWARM_ENV_SYNC_UPDATE_DELAY); v != "" {
-		d, err := time.ParseDuration(v)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_SYNC_UPDATE_DELAY, err)
-		}
-		currentConfig.SyncUpdateDelay = d
-	}
-
-	if max := os.Getenv(SWARM_ENV_MAX_STREAM_PEER_SERVERS); max != "" {
-		m, err := strconv.Atoi(max)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_MAX_STREAM_PEER_SERVERS, err)
-		}
-		currentConfig.MaxStreamPeerServers = m
-	}
-
-	if lne := os.Getenv(SWARM_ENV_LIGHT_NODE_ENABLE); lne != "" {
-		lightnode, err := strconv.ParseBool(lne)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_LIGHT_NODE_ENABLE, err)
-		}
-		currentConfig.LightNodeEnabled = lightnode
-	}
-
-	if swapapi := os.Getenv(SWARM_ENV_SWAP_API); swapapi != "" {
-		currentConfig.SwapAPI = swapapi
-	}
-
-	if currentConfig.SwapEnabled && currentConfig.SwapAPI == "" {
-		utils.Fatalf(SWARM_ERR_SWAP_SET_NO_API)
-	}
-
-	if ensapi := os.Getenv(SWARM_ENV_ENS_API); ensapi != "" {
-		currentConfig.EnsAPIs = strings.Split(ensapi, ",")
-	}
-
-	if ensaddr := os.Getenv(SWARM_ENV_ENS_ADDR); ensaddr != "" {
-		currentConfig.EnsRoot = common.HexToAddress(ensaddr)
-	}
-
-	if cors := os.Getenv(SWARM_ENV_CORS); cors != "" {
-		currentConfig.Cors = cors
-	}
-
-	if bm := os.Getenv(SWARM_ENV_BOOTNODE_MODE); bm != "" {
-		bootnodeMode, err := strconv.ParseBool(bm)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_ENV_BOOTNODE_MODE, err)
-		}
-		currentConfig.BootnodeMode = bootnodeMode
-	}
-
-	if api := os.Getenv(SWARM_GLOBALSTORE_API); api != "" {
-		currentConfig.GlobalStoreAPI = api
-	}
-
-	return currentConfig
-}
-
-// dumpConfig is the dumpconfig command.
-// writes a default config to STDOUT
-func dumpConfig(ctx *cli.Context) error {
-	cfg, err := buildConfig(ctx)
-	if err != nil {
-		utils.Fatalf(fmt.Sprintf("Uh oh - dumpconfig triggered an error %v", err))
-	}
-	comment := ""
-	out, err := tomlSettings.Marshal(&cfg)
-	if err != nil {
-		return err
-	}
-	io.WriteString(os.Stdout, comment)
-	os.Stdout.Write(out)
-	return nil
-}
-
-//validate configuration parameters
-func validateConfig(cfg *bzzapi.Config) (err error) {
-	for _, ensAPI := range cfg.EnsAPIs {
-		if ensAPI != "" {
-			if err := validateEnsAPIs(ensAPI); err != nil {
-				return fmt.Errorf("invalid format [tld:][contract-addr@]url for ENS API endpoint configuration %q: %v", ensAPI, err)
-			}
-		}
-	}
-	return nil
-}
-
-//validate EnsAPIs configuration parameter
-func validateEnsAPIs(s string) (err error) {
-	// missing contract address
-	if strings.HasPrefix(s, "@") {
-		return errors.New("missing contract address")
-	}
-	// missing url
-	if strings.HasSuffix(s, "@") {
-		return errors.New("missing url")
-	}
-	// missing tld
-	if strings.HasPrefix(s, ":") {
-		return errors.New("missing tld")
-	}
-	// missing url
-	if strings.HasSuffix(s, ":") {
-		return errors.New("missing url")
-	}
-	return nil
-}
-
-//print a Config as string
-func printConfig(config *bzzapi.Config) string {
-	out, err := tomlSettings.Marshal(&config)
-	if err != nil {
-		return fmt.Sprintf("Something is not right with the configuration: %v", err)
-	}
-	return string(out)
-}

cmd/swarm/config_test.go

@@ -1,575 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"os"
-	"os/exec"
-	"testing"
-	"time"
-
-	"github.com/docker/docker/pkg/reexec"
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/rpc"
-	"github.com/ubiq/go-ubiq/swarm"
-	"github.com/ubiq/go-ubiq/swarm/api"
-)
-
-func TestConfigDump(t *testing.T) {
-	swarm := runSwarm(t, "dumpconfig")
-	defaultConf := api.NewConfig()
-	out, err := tomlSettings.Marshal(&defaultConf)
-	if err != nil {
-		t.Fatal(err)
-	}
-	swarm.Expect(string(out))
-	swarm.ExpectExit()
-}
-
-func TestConfigFailsSwapEnabledNoSwapApi(t *testing.T) {
-	flags := []string{
-		fmt.Sprintf("--%s", SwarmNetworkIdFlag.Name), "42",
-		fmt.Sprintf("--%s", SwarmPortFlag.Name), "54545",
-		fmt.Sprintf("--%s", SwarmSwapEnabledFlag.Name),
-	}
-
-	swarm := runSwarm(t, flags...)
-	swarm.Expect("Fatal: " + SWARM_ERR_SWAP_SET_NO_API + "\n")
-	swarm.ExpectExit()
-}
-
-func TestConfigFailsNoBzzAccount(t *testing.T) {
-	flags := []string{
-		fmt.Sprintf("--%s", SwarmNetworkIdFlag.Name), "42",
-		fmt.Sprintf("--%s", SwarmPortFlag.Name), "54545",
-	}
-
-	swarm := runSwarm(t, flags...)
-	swarm.Expect("Fatal: " + SWARM_ERR_NO_BZZACCOUNT + "\n")
-	swarm.ExpectExit()
-}
-
-func TestConfigCmdLineOverrides(t *testing.T) {
-	dir, err := ioutil.TempDir("", "bzztest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-
-	conf, account := getTestAccount(t, dir)
-	node := &testNode{Dir: dir}
-
-	// assign ports
-	httpPort, err := assignTCPPort()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	flags := []string{
-		fmt.Sprintf("--%s", SwarmNetworkIdFlag.Name), "42",
-		fmt.Sprintf("--%s", SwarmPortFlag.Name), httpPort,
-		fmt.Sprintf("--%s", SwarmSyncDisabledFlag.Name),
-		fmt.Sprintf("--%s", CorsStringFlag.Name), "*",
-		fmt.Sprintf("--%s", SwarmAccountFlag.Name), account.Address.String(),
-		fmt.Sprintf("--%s", SwarmDeliverySkipCheckFlag.Name),
-		fmt.Sprintf("--%s", EnsAPIFlag.Name), "",
-		fmt.Sprintf("--%s", utils.DataDirFlag.Name), dir,
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), conf.IPCPath,
-	}
-	node.Cmd = runSwarm(t, flags...)
-	node.Cmd.InputLine(testPassphrase)
-	defer func() {
-		if t.Failed() {
-			node.Shutdown()
-		}
-	}()
-	// wait for the node to start
-	for start := time.Now(); time.Since(start) < 10*time.Second; time.Sleep(50 * time.Millisecond) {
-		node.Client, err = rpc.Dial(conf.IPCEndpoint())
-		if err == nil {
-			break
-		}
-	}
-	if node.Client == nil {
-		t.Fatal(err)
-	}
-
-	// load info
-	var info swarm.Info
-	if err := node.Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-
-	if info.Port != httpPort {
-		t.Fatalf("Expected port to be %s, got %s", httpPort, info.Port)
-	}
-
-	if info.NetworkID != 42 {
-		t.Fatalf("Expected network ID to be %d, got %d", 42, info.NetworkID)
-	}
-
-	if info.SyncEnabled {
-		t.Fatal("Expected Sync to be disabled, but is true")
-	}
-
-	if !info.DeliverySkipCheck {
-		t.Fatal("Expected DeliverySkipCheck to be enabled, but it is not")
-	}
-
-	if info.Cors != "*" {
-		t.Fatalf("Expected Cors flag to be set to %s, got %s", "*", info.Cors)
-	}
-
-	node.Shutdown()
-}
-
-func TestConfigFileOverrides(t *testing.T) {
-
-	// assign ports
-	httpPort, err := assignTCPPort()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	//create a config file
-	//first, create a default conf
-	defaultConf := api.NewConfig()
-	//change some values in order to test if they have been loaded
-	defaultConf.SyncEnabled = false
-	defaultConf.DeliverySkipCheck = true
-	defaultConf.NetworkID = 54
-	defaultConf.Port = httpPort
-	defaultConf.DbCapacity = 9000000
-	defaultConf.HiveParams.KeepAliveInterval = 6000000000
-	defaultConf.Swap.Params.Strategy.AutoCashInterval = 600 * time.Second
-	//defaultConf.SyncParams.KeyBufferSize = 512
-	//create a TOML string
-	out, err := tomlSettings.Marshal(&defaultConf)
-	if err != nil {
-		t.Fatalf("Error creating TOML file in TestFileOverride: %v", err)
-	}
-	//create file
-	f, err := ioutil.TempFile("", "testconfig.toml")
-	if err != nil {
-		t.Fatalf("Error writing TOML file in TestFileOverride: %v", err)
-	}
-	//write file
-	_, err = f.WriteString(string(out))
-	if err != nil {
-		t.Fatalf("Error writing TOML file in TestFileOverride: %v", err)
-	}
-	f.Sync()
-
-	dir, err := ioutil.TempDir("", "bzztest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	conf, account := getTestAccount(t, dir)
-	node := &testNode{Dir: dir}
-
-	flags := []string{
-		fmt.Sprintf("--%s", SwarmTomlConfigPathFlag.Name), f.Name(),
-		fmt.Sprintf("--%s", SwarmAccountFlag.Name), account.Address.String(),
-		fmt.Sprintf("--%s", EnsAPIFlag.Name), "",
-		fmt.Sprintf("--%s", utils.DataDirFlag.Name), dir,
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), conf.IPCPath,
-	}
-	node.Cmd = runSwarm(t, flags...)
-	node.Cmd.InputLine(testPassphrase)
-	defer func() {
-		if t.Failed() {
-			node.Shutdown()
-		}
-	}()
-	// wait for the node to start
-	for start := time.Now(); time.Since(start) < 10*time.Second; time.Sleep(50 * time.Millisecond) {
-		node.Client, err = rpc.Dial(conf.IPCEndpoint())
-		if err == nil {
-			break
-		}
-	}
-	if node.Client == nil {
-		t.Fatal(err)
-	}
-
-	// load info
-	var info swarm.Info
-	if err := node.Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-
-	if info.Port != httpPort {
-		t.Fatalf("Expected port to be %s, got %s", httpPort, info.Port)
-	}
-
-	if info.NetworkID != 54 {
-		t.Fatalf("Expected network ID to be %d, got %d", 54, info.NetworkID)
-	}
-
-	if info.SyncEnabled {
-		t.Fatal("Expected Sync to be disabled, but is true")
-	}
-
-	if !info.DeliverySkipCheck {
-		t.Fatal("Expected DeliverySkipCheck to be enabled, but it is not")
-	}
-
-	if info.DbCapacity != 9000000 {
-		t.Fatalf("Expected network ID to be %d, got %d", 54, info.NetworkID)
-	}
-
-	if info.HiveParams.KeepAliveInterval != 6000000000 {
-		t.Fatalf("Expected HiveParams KeepAliveInterval to be %d, got %d", uint64(6000000000), uint64(info.HiveParams.KeepAliveInterval))
-	}
-
-	if info.Swap.Params.Strategy.AutoCashInterval != 600*time.Second {
-		t.Fatalf("Expected SwapParams AutoCashInterval to be %ds, got %d", 600, info.Swap.Params.Strategy.AutoCashInterval)
-	}
-
-	//	if info.SyncParams.KeyBufferSize != 512 {
-	//		t.Fatalf("Expected info.SyncParams.KeyBufferSize to be %d, got %d", 512, info.SyncParams.KeyBufferSize)
-	//	}
-
-	node.Shutdown()
-}
-
-func TestConfigEnvVars(t *testing.T) {
-	// assign ports
-	httpPort, err := assignTCPPort()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	envVars := os.Environ()
-	envVars = append(envVars, fmt.Sprintf("%s=%s", SwarmPortFlag.EnvVar, httpPort))
-	envVars = append(envVars, fmt.Sprintf("%s=%s", SwarmNetworkIdFlag.EnvVar, "999"))
-	envVars = append(envVars, fmt.Sprintf("%s=%s", CorsStringFlag.EnvVar, "*"))
-	envVars = append(envVars, fmt.Sprintf("%s=%s", SwarmSyncDisabledFlag.EnvVar, "true"))
-	envVars = append(envVars, fmt.Sprintf("%s=%s", SwarmDeliverySkipCheckFlag.EnvVar, "true"))
-
-	dir, err := ioutil.TempDir("", "bzztest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	conf, account := getTestAccount(t, dir)
-	node := &testNode{Dir: dir}
-	flags := []string{
-		fmt.Sprintf("--%s", SwarmAccountFlag.Name), account.Address.String(),
-		"--ens-api", "",
-		"--datadir", dir,
-		"--ipcpath", conf.IPCPath,
-	}
-
-	//node.Cmd = runSwarm(t,flags...)
-	//node.Cmd.cmd.Env = envVars
-	//the above assignment does not work, so we need a custom Cmd here in order to pass envVars:
-	cmd := &exec.Cmd{
-		Path:   reexec.Self(),
-		Args:   append([]string{"swarm-test"}, flags...),
-		Stderr: os.Stderr,
-		Stdout: os.Stdout,
-	}
-	cmd.Env = envVars
-	//stdout, err := cmd.StdoutPipe()
-	//if err != nil {
-	//	t.Fatal(err)
-	//}
-	//stdout = bufio.NewReader(stdout)
-	var stdin io.WriteCloser
-	if stdin, err = cmd.StdinPipe(); err != nil {
-		t.Fatal(err)
-	}
-	if err := cmd.Start(); err != nil {
-		t.Fatal(err)
-	}
-
-	//cmd.InputLine(testPassphrase)
-	io.WriteString(stdin, testPassphrase+"\n")
-	defer func() {
-		if t.Failed() {
-			node.Shutdown()
-			cmd.Process.Kill()
-		}
-	}()
-	// wait for the node to start
-	for start := time.Now(); time.Since(start) < 10*time.Second; time.Sleep(50 * time.Millisecond) {
-		node.Client, err = rpc.Dial(conf.IPCEndpoint())
-		if err == nil {
-			break
-		}
-	}
-
-	if node.Client == nil {
-		t.Fatal(err)
-	}
-
-	// load info
-	var info swarm.Info
-	if err := node.Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-
-	if info.Port != httpPort {
-		t.Fatalf("Expected port to be %s, got %s", httpPort, info.Port)
-	}
-
-	if info.NetworkID != 999 {
-		t.Fatalf("Expected network ID to be %d, got %d", 999, info.NetworkID)
-	}
-
-	if info.Cors != "*" {
-		t.Fatalf("Expected Cors flag to be set to %s, got %s", "*", info.Cors)
-	}
-
-	if info.SyncEnabled {
-		t.Fatal("Expected Sync to be disabled, but is true")
-	}
-
-	if !info.DeliverySkipCheck {
-		t.Fatal("Expected DeliverySkipCheck to be enabled, but it is not")
-	}
-
-	node.Shutdown()
-	cmd.Process.Kill()
-}
-
-func TestConfigCmdLineOverridesFile(t *testing.T) {
-
-	// assign ports
-	httpPort, err := assignTCPPort()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	//create a config file
-	//first, create a default conf
-	defaultConf := api.NewConfig()
-	//change some values in order to test if they have been loaded
-	defaultConf.SyncEnabled = true
-	defaultConf.NetworkID = 54
-	defaultConf.Port = "8588"
-	defaultConf.DbCapacity = 9000000
-	defaultConf.HiveParams.KeepAliveInterval = 6000000000
-	defaultConf.Swap.Params.Strategy.AutoCashInterval = 600 * time.Second
-	//defaultConf.SyncParams.KeyBufferSize = 512
-	//create a TOML file
-	out, err := tomlSettings.Marshal(&defaultConf)
-	if err != nil {
-		t.Fatalf("Error creating TOML file in TestFileOverride: %v", err)
-	}
-	//write file
-	fname := "testconfig.toml"
-	f, err := ioutil.TempFile("", fname)
-	if err != nil {
-		t.Fatalf("Error writing TOML file in TestFileOverride: %v", err)
-	}
-	defer os.Remove(fname)
-	//write file
-	_, err = f.WriteString(string(out))
-	if err != nil {
-		t.Fatalf("Error writing TOML file in TestFileOverride: %v", err)
-	}
-	f.Sync()
-
-	dir, err := ioutil.TempDir("", "bzztest")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-	conf, account := getTestAccount(t, dir)
-	node := &testNode{Dir: dir}
-
-	expectNetworkId := uint64(77)
-
-	flags := []string{
-		fmt.Sprintf("--%s", SwarmNetworkIdFlag.Name), "77",
-		fmt.Sprintf("--%s", SwarmPortFlag.Name), httpPort,
-		fmt.Sprintf("--%s", SwarmSyncDisabledFlag.Name),
-		fmt.Sprintf("--%s", SwarmTomlConfigPathFlag.Name), f.Name(),
-		fmt.Sprintf("--%s", SwarmAccountFlag.Name), account.Address.String(),
-		fmt.Sprintf("--%s", EnsAPIFlag.Name), "",
-		fmt.Sprintf("--%s", utils.DataDirFlag.Name), dir,
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), conf.IPCPath,
-	}
-	node.Cmd = runSwarm(t, flags...)
-	node.Cmd.InputLine(testPassphrase)
-	defer func() {
-		if t.Failed() {
-			node.Shutdown()
-		}
-	}()
-	// wait for the node to start
-	for start := time.Now(); time.Since(start) < 10*time.Second; time.Sleep(50 * time.Millisecond) {
-		node.Client, err = rpc.Dial(conf.IPCEndpoint())
-		if err == nil {
-			break
-		}
-	}
-	if node.Client == nil {
-		t.Fatal(err)
-	}
-
-	// load info
-	var info swarm.Info
-	if err := node.Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-
-	if info.Port != httpPort {
-		t.Fatalf("Expected port to be %s, got %s", httpPort, info.Port)
-	}
-
-	if info.NetworkID != expectNetworkId {
-		t.Fatalf("Expected network ID to be %d, got %d", expectNetworkId, info.NetworkID)
-	}
-
-	if info.SyncEnabled {
-		t.Fatal("Expected Sync to be disabled, but is true")
-	}
-
-	if info.LocalStoreParams.DbCapacity != 9000000 {
-		t.Fatalf("Expected Capacity to be %d, got %d", 9000000, info.LocalStoreParams.DbCapacity)
-	}
-
-	if info.HiveParams.KeepAliveInterval != 6000000000 {
-		t.Fatalf("Expected HiveParams KeepAliveInterval to be %d, got %d", uint64(6000000000), uint64(info.HiveParams.KeepAliveInterval))
-	}
-
-	if info.Swap.Params.Strategy.AutoCashInterval != 600*time.Second {
-		t.Fatalf("Expected SwapParams AutoCashInterval to be %ds, got %d", 600, info.Swap.Params.Strategy.AutoCashInterval)
-	}
-
-	//	if info.SyncParams.KeyBufferSize != 512 {
-	//		t.Fatalf("Expected info.SyncParams.KeyBufferSize to be %d, got %d", 512, info.SyncParams.KeyBufferSize)
-	//	}
-
-	node.Shutdown()
-}
-
-func TestConfigValidate(t *testing.T) {
-	for _, c := range []struct {
-		cfg *api.Config
-		err string
-	}{
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"/data/testnet/gubiq.ipc",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"http://127.0.0.1:1234",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"ws://127.0.0.1:1234",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"test:/data/testnet/gubiq.ipc",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"test:ws://127.0.0.1:1234",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/gubiq.ipc",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:1234",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"test:314159265dD8dbb310642f98f50C066173C1259b@/data/testnet/gubiq.ipc",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"eth:314159265dD8dbb310642f98f50C066173C1259b@http://127.0.0.1:1234",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"eth:314159265dD8dbb310642f98f50C066173C1259b@ws://127.0.0.1:12344",
-			}},
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"eth:",
-			}},
-			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \"eth:\": missing url",
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"314159265dD8dbb310642f98f50C066173C1259b@",
-			}},
-			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \"314159265dD8dbb310642f98f50C066173C1259b@\": missing url",
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				":314159265dD8dbb310642f98f50C066173C1259",
-			}},
-			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \":314159265dD8dbb310642f98f50C066173C1259\": missing tld",
-		},
-		{
-			cfg: &api.Config{EnsAPIs: []string{
-				"@/data/testnet/gubiq.ipc",
-			}},
-			err: "invalid format [tld:][contract-addr@]url for ENS API endpoint configuration \"@/data/testnet/gubiq.ipc\": missing contract address",
-		},
-	} {
-		err := validateConfig(c.cfg)
-		if c.err != "" && err.Error() != c.err {
-			t.Errorf("expected error %q, got %q", c.err, err)
-		}
-		if c.err == "" && err != nil {
-			t.Errorf("unexpected error %q", err)
-		}
-	}
-}
-
-func assignTCPPort() (string, error) {
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		return "", err
-	}
-	l.Close()
-	_, port, err := net.SplitHostPort(l.Addr().String())
-	if err != nil {
-		return "", err
-	}
-	return port, nil
-}

cmd/swarm/db.go

@@ -1,147 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/swarm/storage"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var dbCommand = cli.Command{
-	Name:               "db",
-	CustomHelpTemplate: helpTemplate,
-	Usage:              "manage the local chunk database",
-	ArgsUsage:          "db COMMAND",
-	Description:        "Manage the local chunk database",
-	Subcommands: []cli.Command{
-		{
-			Action:             dbExport,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "export",
-			Usage:              "export a local chunk database as a tar archive (use - to send to stdout)",
-			ArgsUsage:          "<chunkdb> <file>",
-			Description: `
-Export a local chunk database as a tar archive (use - to send to stdout).
-
-    swarm db export ~/.ubiq/swarm/bzz-KEY/chunks chunks.tar
-
-The export may be quite large, consider piping the output through the Unix
-pv(1) tool to get a progress bar:
-
-    swarm db export ~/.ubiq/swarm/bzz-KEY/chunks - | pv > chunks.tar
-`,
-		},
-		{
-			Action:             dbImport,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "import",
-			Usage:              "import chunks from a tar archive into a local chunk database (use - to read from stdin)",
-			ArgsUsage:          "<chunkdb> <file>",
-			Description: `Import chunks from a tar archive into a local chunk database (use - to read from stdin).
-
-    swarm db import ~/.ubiq/swarm/bzz-KEY/chunks chunks.tar
-
-The import may be quite large, consider piping the input through the Unix
-pv(1) tool to get a progress bar:
-
-    pv chunks.tar | swarm db import ~/.ubiq/swarm/bzz-KEY/chunks -`,
-		},
-	},
-}
-
-func dbExport(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 3 {
-		utils.Fatalf("invalid arguments, please specify both <chunkdb> (path to a local chunk database), <file> (path to write the tar archive to, - for stdout) and the base key")
-	}
-
-	store, err := openLDBStore(args[0], common.Hex2Bytes(args[2]))
-	if err != nil {
-		utils.Fatalf("error opening local chunk database: %s", err)
-	}
-	defer store.Close()
-
-	var out io.Writer
-	if args[1] == "-" {
-		out = os.Stdout
-	} else {
-		f, err := os.Create(args[1])
-		if err != nil {
-			utils.Fatalf("error opening output file: %s", err)
-		}
-		defer f.Close()
-		out = f
-	}
-
-	count, err := store.Export(out)
-	if err != nil {
-		utils.Fatalf("error exporting local chunk database: %s", err)
-	}
-
-	log.Info(fmt.Sprintf("successfully exported %d chunks", count))
-}
-
-func dbImport(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 3 {
-		utils.Fatalf("invalid arguments, please specify both <chunkdb> (path to a local chunk database), <file> (path to read the tar archive from, - for stdin) and the base key")
-	}
-
-	store, err := openLDBStore(args[0], common.Hex2Bytes(args[2]))
-	if err != nil {
-		utils.Fatalf("error opening local chunk database: %s", err)
-	}
-	defer store.Close()
-
-	var in io.Reader
-	if args[1] == "-" {
-		in = os.Stdin
-	} else {
-		f, err := os.Open(args[1])
-		if err != nil {
-			utils.Fatalf("error opening input file: %s", err)
-		}
-		defer f.Close()
-		in = f
-	}
-
-	count, err := store.Import(in)
-	if err != nil {
-		utils.Fatalf("error importing local chunk database: %s", err)
-	}
-
-	log.Info(fmt.Sprintf("successfully imported %d chunks", count))
-}
-
-func openLDBStore(path string, basekey []byte) (*storage.LDBStore, error) {
-	if _, err := os.Stat(filepath.Join(path, "CURRENT")); err != nil {
-		return nil, fmt.Errorf("invalid chunkdb path: %s", err)
-	}
-
-	storeparams := storage.NewDefaultStoreParams()
-	ldbparams := storage.NewLDBStoreParams(storeparams, path)
-	ldbparams.BaseKey = basekey
-	return storage.NewLDBStore(ldbparams)
-}

cmd/swarm/download.go

@@ -1,112 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var downloadCommand = cli.Command{
-	Action:      download,
-	Name:        "down",
-	Flags:       []cli.Flag{SwarmRecursiveFlag, SwarmAccessPasswordFlag},
-	Usage:       "downloads a swarm manifest or a file inside a manifest",
-	ArgsUsage:   " <uri> [<dir>]",
-	Description: `Downloads a swarm bzz uri to the given dir. When no dir is provided, working directory is assumed. --recursive flag is expected when downloading a manifest with multiple entries.`,
-}
-
-func download(ctx *cli.Context) {
-	log.Debug("downloading content using swarm down")
-	args := ctx.Args()
-	dest := "."
-
-	switch len(args) {
-	case 0:
-		utils.Fatalf("Usage: swarm down [options] <bzz locator> [<destination path>]")
-	case 1:
-		log.Trace(fmt.Sprintf("swarm down: no destination path - assuming working dir"))
-	default:
-		log.Trace(fmt.Sprintf("destination path arg: %s", args[1]))
-		if absDest, err := filepath.Abs(args[1]); err == nil {
-			dest = absDest
-		} else {
-			utils.Fatalf("could not get download path: %v", err)
-		}
-	}
-
-	var (
-		bzzapi      = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-		isRecursive = ctx.Bool(SwarmRecursiveFlag.Name)
-		client      = swarm.NewClient(bzzapi)
-	)
-
-	if fi, err := os.Stat(dest); err == nil {
-		if isRecursive && !fi.Mode().IsDir() {
-			utils.Fatalf("destination path is not a directory!")
-		}
-	} else {
-		if !os.IsNotExist(err) {
-			utils.Fatalf("could not stat path: %v", err)
-		}
-	}
-
-	uri, err := api.Parse(args[0])
-	if err != nil {
-		utils.Fatalf("could not parse uri argument: %v", err)
-	}
-
-	dl := func(credentials string) error {
-		// assume behaviour according to --recursive switch
-		if isRecursive {
-			if err := client.DownloadDirectory(uri.Addr, uri.Path, dest, credentials); err != nil {
-				if err == swarm.ErrUnauthorized {
-					return err
-				}
-				return fmt.Errorf("directory %s: %v", uri.Path, err)
-			}
-		} else {
-			// we are downloading a file
-			log.Debug("downloading file/path from a manifest", "uri.Addr", uri.Addr, "uri.Path", uri.Path)
-
-			err := client.DownloadFile(uri.Addr, uri.Path, dest, credentials)
-			if err != nil {
-				if err == swarm.ErrUnauthorized {
-					return err
-				}
-				return fmt.Errorf("file %s from address: %s: %v", uri.Path, uri.Addr, err)
-			}
-		}
-		return nil
-	}
-	if passwords := makePasswordList(ctx); passwords != nil {
-		password := getPassPhrase(fmt.Sprintf("Downloading %s is restricted", uri), 0, passwords)
-		err = dl(password)
-	} else {
-		err = dl("")
-	}
-	if err != nil {
-		utils.Fatalf("download: %v", err)
-	}
-}

cmd/swarm/explore.go

@@ -1,59 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// Command bzzhash computes a swarm tree hash.
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/swarm/storage"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var hashesCommand = cli.Command{
-	Action:             hashes,
-	CustomHelpTemplate: helpTemplate,
-	Name:               "hashes",
-	Usage:              "print all hashes of a file to STDOUT",
-	ArgsUsage:          "<file>",
-	Description:        "Prints all hashes of a file to STDOUT",
-}
-
-func hashes(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) < 1 {
-		utils.Fatalf("Usage: swarm hashes <file name>")
-	}
-	f, err := os.Open(args[0])
-	if err != nil {
-		utils.Fatalf("Error opening file " + args[1])
-	}
-	defer f.Close()
-
-	fileStore := storage.NewFileStore(&storage.FakeChunkStore{}, storage.NewFileStoreParams())
-	refs, err := fileStore.GetAllReferences(context.TODO(), f, false)
-	if err != nil {
-		utils.Fatalf("%v\n", err)
-	} else {
-		for _, r := range refs {
-			fmt.Println(r.String())
-		}
-	}
-}

cmd/swarm/export_test.go

@@ -1,119 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"crypto/md5"
-	"io"
-	"net/http"
-	"os"
-	"runtime"
-	"strings"
-	"testing"
-
-	"github.com/ubiq/go-ubiq/swarm"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-)
-
-// TestCLISwarmExportImport perform the following test:
-// 1. runs swarm node
-// 2. uploads a random file
-// 3. runs an export of the local datastore
-// 4. runs a second swarm node
-// 5. imports the exported datastore
-// 6. fetches the uploaded random file from the second node
-func TestCLISwarmExportImport(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-	cluster := newTestCluster(t, 1)
-
-	// generate random 1mb file
-	content := testutil.RandomBytes(1, 1000000)
-	fileName := testutil.TempFileWithContent(t, string(content))
-	defer os.Remove(fileName)
-
-	// upload the file with 'swarm up' and expect a hash
-	up := runSwarm(t, "--bzzapi", cluster.Nodes[0].URL, "up", fileName)
-	_, matches := up.ExpectRegexp(`[a-f\d]{64}`)
-	up.ExpectExit()
-	hash := matches[0]
-
-	var info swarm.Info
-	if err := cluster.Nodes[0].Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-
-	cluster.Stop()
-	defer cluster.Cleanup()
-
-	// generate an export.tar
-	exportCmd := runSwarm(t, "db", "export", info.Path+"/chunks", info.Path+"/export.tar", strings.TrimPrefix(info.BzzKey, "0x"))
-	exportCmd.ExpectExit()
-
-	// start second cluster
-	cluster2 := newTestCluster(t, 1)
-
-	var info2 swarm.Info
-	if err := cluster2.Nodes[0].Client.Call(&info2, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-
-	// stop second cluster, so that we close LevelDB
-	cluster2.Stop()
-	defer cluster2.Cleanup()
-
-	// import the export.tar
-	importCmd := runSwarm(t, "db", "import", info2.Path+"/chunks", info.Path+"/export.tar", strings.TrimPrefix(info2.BzzKey, "0x"))
-	importCmd.ExpectExit()
-
-	// spin second cluster back up
-	cluster2.StartExistingNodes(t, 1, strings.TrimPrefix(info2.BzzAccount, "0x"))
-
-	// try to fetch imported file
-	res, err := http.Get(cluster2.Nodes[0].URL + "/bzz:/" + hash)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if res.StatusCode != 200 {
-		t.Fatalf("expected HTTP status %d, got %s", 200, res.Status)
-	}
-
-	// compare downloaded file with the generated random file
-	mustEqualFiles(t, bytes.NewReader(content), res.Body)
-}
-
-func mustEqualFiles(t *testing.T, up io.Reader, down io.Reader) {
-	h := md5.New()
-	upLen, err := io.Copy(h, up)
-	if err != nil {
-		t.Fatal(err)
-	}
-	upHash := h.Sum(nil)
-	h.Reset()
-	downLen, err := io.Copy(h, down)
-	if err != nil {
-		t.Fatal(err)
-	}
-	downHash := h.Sum(nil)
-
-	if !bytes.Equal(upHash, downHash) || upLen != downLen {
-		t.Fatalf("downloaded imported file md5=%x (length %v) is not the same as the generated one mp5=%x (length %v)", downHash, downLen, upHash, upLen)
-	}
-}

cmd/swarm/feeds.go

@@ -1,238 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// Command feed allows the user to create and update signed Swarm feeds
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/common/hexutil"
-	"github.com/ubiq/go-ubiq/crypto"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-	"github.com/ubiq/go-ubiq/swarm/storage/feed"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var feedCommand = cli.Command{
-	CustomHelpTemplate: helpTemplate,
-	Name:               "feed",
-	Usage:              "(Advanced) Create and update Swarm Feeds",
-	ArgsUsage:          "<create|update|info>",
-	Description:        "Works with Swarm Feeds",
-	Subcommands: []cli.Command{
-		{
-			Action:             feedCreateManifest,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "create",
-			Usage:              "creates and publishes a new feed manifest",
-			Description: `creates and publishes a new feed manifest pointing to a specified user's updates about a particular topic.
-					The feed topic can be built in the following ways:
-					* use --topic to set the topic to an arbitrary binary hex string.
-					* use --name to set the topic to a human-readable name.
-					    For example --name could be set to "profile-picture", meaning this feed allows to get this user's current profile picture.
-					* use both --topic and --name to create named subtopics. 
-						For example, --topic could be set to an Ubiq contract address and --name could be set to "comments", meaning
-						this feed tracks a discussion about that contract.
-					The --user flag allows to have this manifest refer to a user other than yourself. If not specified,
-					it will then default to your local account (--bzzaccount)`,
-			Flags: []cli.Flag{SwarmFeedNameFlag, SwarmFeedTopicFlag, SwarmFeedUserFlag},
-		},
-		{
-			Action:             feedUpdate,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "update",
-			Usage:              "updates the content of an existing Swarm Feed",
-			ArgsUsage:          "<0x Hex data>",
-			Description: `publishes a new update on the specified topic
-					The feed topic can be built in the following ways:
-					* use --topic to set the topic to an arbitrary binary hex string.
-					* use --name to set the topic to a human-readable name.
-					    For example --name could be set to "profile-picture", meaning this feed allows to get this user's current profile picture.
-					* use both --topic and --name to create named subtopics. 
-						For example, --topic could be set to an Ubiq contract address and --name could be set to "comments", meaning
-						this feed tracks a discussion about that contract.
-					
-					If you have a manifest, you can specify it with --manifest to refer to the feed,
-					instead of using --topic / --name
-					`,
-			Flags: []cli.Flag{SwarmFeedManifestFlag, SwarmFeedNameFlag, SwarmFeedTopicFlag},
-		},
-		{
-			Action:             feedInfo,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "info",
-			Usage:              "obtains information about an existing Swarm feed",
-			Description: `obtains information about an existing Swarm feed
-					The topic can be specified directly with the --topic flag as an hex string
-					If no topic is specified, the default topic (zero) will be used
-					The --name flag can be used to specify subtopics with a specific name.
-					The --user flag allows to refer to a user other than yourself. If not specified,
-					it will then default to your local account (--bzzaccount)
-					If you have a manifest, you can specify it with --manifest instead of --topic / --name / ---user
-					to refer to the feed`,
-			Flags: []cli.Flag{SwarmFeedManifestFlag, SwarmFeedNameFlag, SwarmFeedTopicFlag, SwarmFeedUserFlag},
-		},
-	},
-}
-
-func NewGenericSigner(ctx *cli.Context) feed.Signer {
-	return feed.NewGenericSigner(getPrivKey(ctx))
-}
-
-func getTopic(ctx *cli.Context) (topic feed.Topic) {
-	var name = ctx.String(SwarmFeedNameFlag.Name)
-	var relatedTopic = ctx.String(SwarmFeedTopicFlag.Name)
-	var relatedTopicBytes []byte
-	var err error
-
-	if relatedTopic != "" {
-		relatedTopicBytes, err = hexutil.Decode(relatedTopic)
-		if err != nil {
-			utils.Fatalf("Error parsing topic: %s", err)
-		}
-	}
-
-	topic, err = feed.NewTopic(name, relatedTopicBytes)
-	if err != nil {
-		utils.Fatalf("Error parsing topic: %s", err)
-	}
-	return topic
-}
-
-// swarm feed create <frequency> [--name <name>] [--data <0x Hexdata> [--multihash=false]]
-// swarm feed update <Manifest Address or ENS domain> <0x Hexdata> [--multihash=false]
-// swarm feed info <Manifest Address or ENS domain>
-
-func feedCreateManifest(ctx *cli.Context) {
-	var (
-		bzzapi = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-		client = swarm.NewClient(bzzapi)
-	)
-
-	newFeedUpdateRequest := feed.NewFirstRequest(getTopic(ctx))
-	newFeedUpdateRequest.Feed.User = feedGetUser(ctx)
-
-	manifestAddress, err := client.CreateFeedWithManifest(newFeedUpdateRequest)
-	if err != nil {
-		utils.Fatalf("Error creating feed manifest: %s", err.Error())
-		return
-	}
-	fmt.Println(manifestAddress) // output manifest address to the user in a single line (useful for other commands to pick up)
-
-}
-
-func feedUpdate(ctx *cli.Context) {
-	args := ctx.Args()
-
-	var (
-		bzzapi                  = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-		client                  = swarm.NewClient(bzzapi)
-		manifestAddressOrDomain = ctx.String(SwarmFeedManifestFlag.Name)
-	)
-
-	if len(args) < 1 {
-		fmt.Println("Incorrect number of arguments")
-		cli.ShowCommandHelpAndExit(ctx, "update", 1)
-		return
-	}
-
-	signer := NewGenericSigner(ctx)
-
-	data, err := hexutil.Decode(args[0])
-	if err != nil {
-		utils.Fatalf("Error parsing data: %s", err.Error())
-		return
-	}
-
-	var updateRequest *feed.Request
-	var query *feed.Query
-
-	if manifestAddressOrDomain == "" {
-		query = new(feed.Query)
-		query.User = signer.Address()
-		query.Topic = getTopic(ctx)
-	}
-
-	// Retrieve a feed update request
-	updateRequest, err = client.GetFeedRequest(query, manifestAddressOrDomain)
-	if err != nil {
-		utils.Fatalf("Error retrieving feed status: %s", err.Error())
-	}
-
-	// Check that the provided signer matches the request to sign
-	if updateRequest.User != signer.Address() {
-		utils.Fatalf("Signer address does not match the update request")
-	}
-
-	// set the new data
-	updateRequest.SetData(data)
-
-	// sign update
-	if err = updateRequest.Sign(signer); err != nil {
-		utils.Fatalf("Error signing feed update: %s", err.Error())
-	}
-
-	// post update
-	err = client.UpdateFeed(updateRequest)
-	if err != nil {
-		utils.Fatalf("Error updating feed: %s", err.Error())
-		return
-	}
-}
-
-func feedInfo(ctx *cli.Context) {
-	var (
-		bzzapi                  = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-		client                  = swarm.NewClient(bzzapi)
-		manifestAddressOrDomain = ctx.String(SwarmFeedManifestFlag.Name)
-	)
-
-	var query *feed.Query
-	if manifestAddressOrDomain == "" {
-		query = new(feed.Query)
-		query.Topic = getTopic(ctx)
-		query.User = feedGetUser(ctx)
-	}
-
-	metadata, err := client.GetFeedRequest(query, manifestAddressOrDomain)
-	if err != nil {
-		utils.Fatalf("Error retrieving feed metadata: %s", err.Error())
-		return
-	}
-	encodedMetadata, err := metadata.MarshalJSON()
-	if err != nil {
-		utils.Fatalf("Error encoding metadata to JSON for display:%s", err)
-	}
-	fmt.Println(string(encodedMetadata))
-}
-
-func feedGetUser(ctx *cli.Context) common.Address {
-	var user = ctx.String(SwarmFeedUserFlag.Name)
-	if user != "" {
-		return common.HexToAddress(user)
-	}
-	pk := getPrivKey(ctx)
-	if pk == nil {
-		utils.Fatalf("Cannot read private key. Must specify --user or --bzzaccount")
-	}
-	return crypto.PubkeyToAddress(pk.PublicKey)
-
-}

cmd/swarm/feeds_test.go

@@ -1,196 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"io/ioutil"
-	"os"
-	"testing"
-
-	"github.com/ubiq/go-ubiq/common/hexutil"
-	"github.com/ubiq/go-ubiq/crypto"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-	swarmhttp "github.com/ubiq/go-ubiq/swarm/api/http"
-	"github.com/ubiq/go-ubiq/swarm/storage/feed"
-	"github.com/ubiq/go-ubiq/swarm/storage/feed/lookup"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-)
-
-func TestCLIFeedUpdate(t *testing.T) {
-	srv := swarmhttp.NewTestSwarmServer(t, func(api *api.API) swarmhttp.TestServer {
-		return swarmhttp.NewServer(api, "")
-	}, nil)
-	log.Info("starting a test swarm server")
-	defer srv.Close()
-
-	// create a private key file for signing
-	privkeyHex := "0000000000000000000000000000000000000000000000000000000000001979"
-	privKey, _ := crypto.HexToECDSA(privkeyHex)
-	address := crypto.PubkeyToAddress(privKey.PublicKey)
-
-	pkFileName := testutil.TempFileWithContent(t, privkeyHex)
-	defer os.Remove(pkFileName)
-
-	// compose a topic. We'll be doing quotes about Miguel de Cervantes
-	var topic feed.Topic
-	subject := []byte("Miguel de Cervantes")
-	copy(topic[:], subject[:])
-	name := "quotes"
-
-	// prepare some data for the update
-	data := []byte("En boca cerrada no entran moscas")
-	hexData := hexutil.Encode(data)
-
-	flags := []string{
-		"--bzzapi", srv.URL,
-		"--bzzaccount", pkFileName,
-		"feed", "update",
-		"--topic", topic.Hex(),
-		"--name", name,
-		hexData}
-
-	// create an update and expect an exit without errors
-	log.Info("updating a feed with 'swarm feed update'")
-	cmd := runSwarm(t, flags...)
-	cmd.ExpectExit()
-
-	// now try to get the update using the client
-	client := swarm.NewClient(srv.URL)
-
-	// build the same topic as before, this time
-	// we use NewTopic to create a topic automatically.
-	topic, err := feed.NewTopic(name, subject)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Feed configures whose updates we will be looking up.
-	fd := feed.Feed{
-		Topic: topic,
-		User:  address,
-	}
-
-	// Build a query to get the latest update
-	query := feed.NewQueryLatest(&fd, lookup.NoClue)
-
-	// retrieve content!
-	reader, err := client.QueryFeed(query, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	retrieved, err := ioutil.ReadAll(reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// check we retrieved the sent information
-	if !bytes.Equal(data, retrieved) {
-		t.Fatalf("Received %s, expected %s", retrieved, data)
-	}
-
-	// Now retrieve info for the next update
-	flags = []string{
-		"--bzzapi", srv.URL,
-		"feed", "info",
-		"--topic", topic.Hex(),
-		"--user", address.Hex(),
-	}
-
-	log.Info("getting feed info with 'swarm feed info'")
-	cmd = runSwarm(t, flags...)
-	_, matches := cmd.ExpectRegexp(`.*`) // regex hack to extract stdout
-	cmd.ExpectExit()
-
-	// verify we can deserialize the result as a valid JSON
-	var request feed.Request
-	err = json.Unmarshal([]byte(matches[0]), &request)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// make sure the retrieved feed is the same
-	if request.Feed != fd {
-		t.Fatalf("Expected feed to be: %s, got %s", fd, request.Feed)
-	}
-
-	// test publishing a manifest
-	flags = []string{
-		"--bzzapi", srv.URL,
-		"--bzzaccount", pkFileName,
-		"feed", "create",
-		"--topic", topic.Hex(),
-	}
-
-	log.Info("Publishing manifest with 'swarm feed create'")
-	cmd = runSwarm(t, flags...)
-	_, matches = cmd.ExpectRegexp(`[a-f\d]{64}`)
-	cmd.ExpectExit()
-
-	manifestAddress := matches[0] // read the received feed manifest
-
-	// now attempt to lookup the latest update using a manifest instead
-	reader, err = client.QueryFeed(nil, manifestAddress)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	retrieved, err = ioutil.ReadAll(reader)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(data, retrieved) {
-		t.Fatalf("Received %s, expected %s", retrieved, data)
-	}
-
-	// test publishing a manifest for a different user
-	flags = []string{
-		"--bzzapi", srv.URL,
-		"feed", "create",
-		"--topic", topic.Hex(),
-		"--user", "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // different user
-	}
-
-	log.Info("Publishing manifest with 'swarm feed create' for a different user")
-	cmd = runSwarm(t, flags...)
-	_, matches = cmd.ExpectRegexp(`[a-f\d]{64}`)
-	cmd.ExpectExit()
-
-	manifestAddress = matches[0] // read the received feed manifest
-
-	// now let's try to update that user's manifest which we don't have the private key for
-	flags = []string{
-		"--bzzapi", srv.URL,
-		"--bzzaccount", pkFileName,
-		"feed", "update",
-		"--manifest", manifestAddress,
-		hexData}
-
-	// create an update and expect an error given there is a user mismatch
-	log.Info("updating a feed with 'swarm feed update'")
-	cmd = runSwarm(t, flags...)
-	cmd.ExpectRegexp("Fatal:.*") // best way so far to detect a failure.
-	cmd.ExpectExit()
-	if cmd.ExitStatus() == 0 {
-		t.Fatal("Expected nonzero exit code when updating a manifest with the wrong user. Got 0.")
-	}
-}

cmd/swarm/flags.go

@@ -1,184 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// Command feed allows the user to create and update signed Swarm feeds
-package main
-
-import cli "gopkg.in/urfave/cli.v1"
-
-var (
-	ChequebookAddrFlag = cli.StringFlag{
-		Name:   "chequebook",
-		Usage:  "chequebook contract address",
-		EnvVar: SWARM_ENV_CHEQUEBOOK_ADDR,
-	}
-	SwarmAccountFlag = cli.StringFlag{
-		Name:   "bzzaccount",
-		Usage:  "Swarm account key file",
-		EnvVar: SWARM_ENV_ACCOUNT,
-	}
-	SwarmListenAddrFlag = cli.StringFlag{
-		Name:   "httpaddr",
-		Usage:  "Swarm HTTP API listening interface",
-		EnvVar: SWARM_ENV_LISTEN_ADDR,
-	}
-	SwarmPortFlag = cli.StringFlag{
-		Name:   "bzzport",
-		Usage:  "Swarm local http api port",
-		EnvVar: SWARM_ENV_PORT,
-	}
-	SwarmNetworkIdFlag = cli.IntFlag{
-		Name:   "bzznetworkid",
-		Usage:  "Network identifier (integer, default 3=swarm testnet)",
-		EnvVar: SWARM_ENV_NETWORK_ID,
-	}
-	SwarmSwapEnabledFlag = cli.BoolFlag{
-		Name:   "swap",
-		Usage:  "Swarm SWAP enabled (default false)",
-		EnvVar: SWARM_ENV_SWAP_ENABLE,
-	}
-	SwarmSwapAPIFlag = cli.StringFlag{
-		Name:   "swap-api",
-		Usage:  "URL of the Ethereum API provider to use to settle SWAP payments",
-		EnvVar: SWARM_ENV_SWAP_API,
-	}
-	SwarmSyncDisabledFlag = cli.BoolTFlag{
-		Name:   "nosync",
-		Usage:  "Disable swarm syncing",
-		EnvVar: SWARM_ENV_SYNC_DISABLE,
-	}
-	SwarmSyncUpdateDelay = cli.DurationFlag{
-		Name:   "sync-update-delay",
-		Usage:  "Duration for sync subscriptions update after no new peers are added (default 15s)",
-		EnvVar: SWARM_ENV_SYNC_UPDATE_DELAY,
-	}
-	SwarmMaxStreamPeerServersFlag = cli.IntFlag{
-		Name:   "max-stream-peer-servers",
-		Usage:  "Limit of Stream peer servers, 0 denotes unlimited",
-		EnvVar: SWARM_ENV_MAX_STREAM_PEER_SERVERS,
-		Value:  10000, // A very large default value is possible as stream servers have very small memory footprint
-	}
-	SwarmLightNodeEnabled = cli.BoolFlag{
-		Name:   "lightnode",
-		Usage:  "Enable Swarm LightNode (default false)",
-		EnvVar: SWARM_ENV_LIGHT_NODE_ENABLE,
-	}
-	SwarmDeliverySkipCheckFlag = cli.BoolFlag{
-		Name:   "delivery-skip-check",
-		Usage:  "Skip chunk delivery check (default false)",
-		EnvVar: SWARM_ENV_DELIVERY_SKIP_CHECK,
-	}
-	EnsAPIFlag = cli.StringSliceFlag{
-		Name:   "ens-api",
-		Usage:  "ENS API endpoint for a TLD and with contract address, can be repeated, format [tld:][contract-addr@]url",
-		EnvVar: SWARM_ENV_ENS_API,
-	}
-	SwarmApiFlag = cli.StringFlag{
-		Name:  "bzzapi",
-		Usage: "Specifies the Swarm HTTP endpoint to connect to",
-		Value: "http://127.0.0.1:8500",
-	}
-	SwarmRecursiveFlag = cli.BoolFlag{
-		Name:  "recursive",
-		Usage: "Upload directories recursively",
-	}
-	SwarmWantManifestFlag = cli.BoolTFlag{
-		Name:  "manifest",
-		Usage: "Automatic manifest upload (default true)",
-	}
-	SwarmUploadDefaultPath = cli.StringFlag{
-		Name:  "defaultpath",
-		Usage: "path to file served for empty url path (none)",
-	}
-	SwarmAccessGrantKeyFlag = cli.StringFlag{
-		Name:  "grant-key",
-		Usage: "grants a given public key access to an ACT",
-	}
-	SwarmAccessGrantKeysFlag = cli.StringFlag{
-		Name:  "grant-keys",
-		Usage: "grants a given list of public keys in the following file (separated by line breaks) access to an ACT",
-	}
-	SwarmUpFromStdinFlag = cli.BoolFlag{
-		Name:  "stdin",
-		Usage: "reads data to be uploaded from stdin",
-	}
-	SwarmUploadMimeType = cli.StringFlag{
-		Name:  "mime",
-		Usage: "Manually specify MIME type",
-	}
-	SwarmEncryptedFlag = cli.BoolFlag{
-		Name:  "encrypt",
-		Usage: "use encrypted upload",
-	}
-	SwarmAccessPasswordFlag = cli.StringFlag{
-		Name:   "password",
-		Usage:  "Password",
-		EnvVar: SWARM_ACCESS_PASSWORD,
-	}
-	SwarmDryRunFlag = cli.BoolFlag{
-		Name:  "dry-run",
-		Usage: "dry-run",
-	}
-	CorsStringFlag = cli.StringFlag{
-		Name:   "corsdomain",
-		Usage:  "Domain on which to send Access-Control-Allow-Origin header (multiple domains can be supplied separated by a ',')",
-		EnvVar: SWARM_ENV_CORS,
-	}
-	SwarmStorePath = cli.StringFlag{
-		Name:   "store.path",
-		Usage:  "Path to leveldb chunk DB (default <$GETH_ENV_DIR>/swarm/bzz-<$BZZ_KEY>/chunks)",
-		EnvVar: SWARM_ENV_STORE_PATH,
-	}
-	SwarmStoreCapacity = cli.Uint64Flag{
-		Name:   "store.size",
-		Usage:  "Number of chunks (5M is roughly 20-25GB) (default 5000000)",
-		EnvVar: SWARM_ENV_STORE_CAPACITY,
-	}
-	SwarmStoreCacheCapacity = cli.UintFlag{
-		Name:   "store.cache.size",
-		Usage:  "Number of recent chunks cached in memory (default 5000)",
-		EnvVar: SWARM_ENV_STORE_CACHE_CAPACITY,
-	}
-	SwarmCompressedFlag = cli.BoolFlag{
-		Name:  "compressed",
-		Usage: "Prints encryption keys in compressed form",
-	}
-	SwarmBootnodeModeFlag = cli.BoolFlag{
-		Name:  "bootnode-mode",
-		Usage: "Run Swarm in Bootnode mode",
-	}
-	SwarmFeedNameFlag = cli.StringFlag{
-		Name:  "name",
-		Usage: "User-defined name for the new feed, limited to 32 characters. If combined with topic, it will refer to a subtopic with this name",
-	}
-	SwarmFeedTopicFlag = cli.StringFlag{
-		Name:  "topic",
-		Usage: "User-defined topic this feed is tracking, hex encoded. Limited to 64 hexadecimal characters",
-	}
-	SwarmFeedManifestFlag = cli.StringFlag{
-		Name:  "manifest",
-		Usage: "Refers to the feed through a manifest",
-	}
-	SwarmFeedUserFlag = cli.StringFlag{
-		Name:  "user",
-		Usage: "Indicates the user who updates the feed",
-	}
-	SwarmGlobalStoreAPIFlag = cli.StringFlag{
-		Name:   "globalstore-api",
-		Usage:  "URL of the Global Store API provider (only for testing)",
-		EnvVar: SWARM_GLOBALSTORE_API,
-	}
-)

cmd/swarm/fs.go

@@ -1,162 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/rpc"
-	"github.com/ubiq/go-ubiq/swarm/fuse"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var fsCommand = cli.Command{
-	Name:               "fs",
-	CustomHelpTemplate: helpTemplate,
-	Usage:              "perform FUSE operations",
-	ArgsUsage:          "fs COMMAND",
-	Description:        "Performs FUSE operations by mounting/unmounting/listing mount points. This assumes you already have a Swarm node running locally. For all operation you must reference the correct path to bzzd.ipc in order to communicate with the node",
-	Subcommands: []cli.Command{
-		{
-			Action:             mount,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "mount",
-			Usage:              "mount a swarm hash to a mount point",
-			ArgsUsage:          "swarm fs mount <manifest hash> <mount point>",
-			Description:        "Mounts a Swarm manifest hash to a given mount point. This assumes you already have a Swarm node running locally. You must reference the correct path to your bzzd.ipc file",
-		},
-		{
-			Action:             unmount,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "unmount",
-			Usage:              "unmount a swarmfs mount",
-			ArgsUsage:          "swarm fs unmount <mount point>",
-			Description:        "Unmounts a swarmfs mount residing at <mount point>. This assumes you already have a Swarm node running locally. You must reference the correct path to your bzzd.ipc file",
-		},
-		{
-			Action:             listMounts,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "list",
-			Usage:              "list swarmfs mounts",
-			ArgsUsage:          "swarm fs list",
-			Description:        "Lists all mounted swarmfs volumes. This assumes you already have a Swarm node running locally. You must reference the correct path to your bzzd.ipc file",
-		},
-	},
-}
-
-func mount(cliContext *cli.Context) {
-	args := cliContext.Args()
-	if len(args) < 2 {
-		utils.Fatalf("Usage: swarm fs mount <manifestHash> <file name>")
-	}
-
-	client, err := dialRPC(cliContext)
-	if err != nil {
-		utils.Fatalf("had an error dailing to RPC endpoint: %v", err)
-	}
-	defer client.Close()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	mf := &fuse.MountInfo{}
-	mountPoint, err := filepath.Abs(filepath.Clean(args[1]))
-	if err != nil {
-		utils.Fatalf("error expanding path for mount point: %v", err)
-	}
-	err = client.CallContext(ctx, mf, "swarmfs_mount", args[0], mountPoint)
-	if err != nil {
-		utils.Fatalf("had an error calling the RPC endpoint while mounting: %v", err)
-	}
-}
-
-func unmount(cliContext *cli.Context) {
-	args := cliContext.Args()
-
-	if len(args) < 1 {
-		utils.Fatalf("Usage: swarm fs unmount <mount path>")
-	}
-	client, err := dialRPC(cliContext)
-	if err != nil {
-		utils.Fatalf("had an error dailing to RPC endpoint: %v", err)
-	}
-	defer client.Close()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	mf := fuse.MountInfo{}
-	err = client.CallContext(ctx, &mf, "swarmfs_unmount", args[0])
-	if err != nil {
-		utils.Fatalf("encountered an error calling the RPC endpoint while unmounting: %v", err)
-	}
-	fmt.Printf("%s\n", mf.LatestManifest) //print the latest manifest hash for user reference
-}
-
-func listMounts(cliContext *cli.Context) {
-	client, err := dialRPC(cliContext)
-	if err != nil {
-		utils.Fatalf("had an error dailing to RPC endpoint: %v", err)
-	}
-	defer client.Close()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	mf := []fuse.MountInfo{}
-	err = client.CallContext(ctx, &mf, "swarmfs_listmounts")
-	if err != nil {
-		utils.Fatalf("encountered an error calling the RPC endpoint while listing mounts: %v", err)
-	}
-	if len(mf) == 0 {
-		fmt.Print("Could not found any swarmfs mounts. Please make sure you've specified the correct RPC endpoint\n")
-	} else {
-		fmt.Printf("Found %d swarmfs mount(s):\n", len(mf))
-		for i, mountInfo := range mf {
-			fmt.Printf("%d:\n", i)
-			fmt.Printf("\tMount point: %s\n", mountInfo.MountPoint)
-			fmt.Printf("\tLatest Manifest: %s\n", mountInfo.LatestManifest)
-			fmt.Printf("\tStart Manifest: %s\n", mountInfo.StartManifest)
-		}
-	}
-}
-
-func dialRPC(ctx *cli.Context) (*rpc.Client, error) {
-	endpoint := getIPCEndpoint(ctx)
-	log.Info("IPC endpoint", "path", endpoint)
-	return rpc.Dial(endpoint)
-}
-
-func getIPCEndpoint(ctx *cli.Context) string {
-	cfg := defaultNodeConfig
-	utils.SetNodeConfig(ctx, &cfg)
-
-	endpoint := cfg.IPCEndpoint()
-
-	if strings.HasPrefix(endpoint, "rpc:") || strings.HasPrefix(endpoint, "ipc:") {
-		// Backwards compatibility with gubiq < 1.5 which required
-		// these prefixes.
-		endpoint = endpoint[4:]
-	}
-	return endpoint
-}

cmd/swarm/fs_test.go

@@ -1,260 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// +build linux freebsd
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/log"
-)
-
-type testFile struct {
-	filePath string
-	content  string
-}
-
-// TestCLISwarmFsDefaultIPCPath tests if the most basic fs command, i.e., list
-// can find and correctly connect to a running Swarm node on the default
-// IPCPath.
-func TestCLISwarmFsDefaultIPCPath(t *testing.T) {
-	cluster := newTestCluster(t, 1)
-	defer cluster.Shutdown()
-
-	handlingNode := cluster.Nodes[0]
-	list := runSwarm(t, []string{
-		"--datadir", handlingNode.Dir,
-		"fs",
-		"list",
-	}...)
-
-	list.WaitExit()
-	if list.Err != nil {
-		t.Fatal(list.Err)
-	}
-}
-
-// TestCLISwarmFs is a high-level test of swarmfs
-//
-// This test fails on travis for macOS as this executable exits with code 1
-// and without any log messages in the log:
-// /Library/Filesystems/osxfuse.fs/Contents/Resources/load_osxfuse.
-// This is the reason for this file not being built on darwin architecture.
-func TestCLISwarmFs(t *testing.T) {
-	cluster := newTestCluster(t, 3)
-	defer cluster.Shutdown()
-
-	// create a tmp dir
-	mountPoint, err := ioutil.TempDir("", "swarm-test")
-	log.Debug("swarmfs cli test", "1st mount", mountPoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(mountPoint)
-
-	handlingNode := cluster.Nodes[0]
-	mhash := doUploadEmptyDir(t, handlingNode)
-	log.Debug("swarmfs cli test: mounting first run", "ipc path", filepath.Join(handlingNode.Dir, handlingNode.IpcPath))
-
-	mount := runSwarm(t, []string{
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), filepath.Join(handlingNode.Dir, handlingNode.IpcPath),
-		"fs",
-		"mount",
-		mhash,
-		mountPoint,
-	}...)
-	mount.ExpectExit()
-
-	filesToAssert := []*testFile{}
-
-	dirPath, err := createDirInDir(mountPoint, "testSubDir")
-	if err != nil {
-		t.Fatal(err)
-	}
-	dirPath2, err := createDirInDir(dirPath, "AnotherTestSubDir")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	dummyContent := "somerandomtestcontentthatshouldbeasserted"
-	dirs := []string{
-		mountPoint,
-		dirPath,
-		dirPath2,
-	}
-	files := []string{"f1.tmp", "f2.tmp"}
-	for _, d := range dirs {
-		for _, entry := range files {
-			tFile, err := createTestFileInPath(d, entry, dummyContent)
-			if err != nil {
-				t.Fatal(err)
-			}
-			filesToAssert = append(filesToAssert, tFile)
-		}
-	}
-	if len(filesToAssert) != len(dirs)*len(files) {
-		t.Fatalf("should have %d files to assert now, got %d", len(dirs)*len(files), len(filesToAssert))
-	}
-	hashRegexp := `[a-f\d]{64}`
-	log.Debug("swarmfs cli test: unmounting first run...", "ipc path", filepath.Join(handlingNode.Dir, handlingNode.IpcPath))
-
-	unmount := runSwarm(t, []string{
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), filepath.Join(handlingNode.Dir, handlingNode.IpcPath),
-		"fs",
-		"unmount",
-		mountPoint,
-	}...)
-	_, matches := unmount.ExpectRegexp(hashRegexp)
-	unmount.ExpectExit()
-
-	hash := matches[0]
-	if hash == mhash {
-		t.Fatal("this should not be equal")
-	}
-	log.Debug("swarmfs cli test: asserting no files in mount point")
-
-	//check that there's nothing in the mount folder
-	filesInDir, err := ioutil.ReadDir(mountPoint)
-	if err != nil {
-		t.Fatalf("had an error reading the directory: %v", err)
-	}
-
-	if len(filesInDir) != 0 {
-		t.Fatal("there shouldn't be anything here")
-	}
-
-	secondMountPoint, err := ioutil.TempDir("", "swarm-test")
-	log.Debug("swarmfs cli test", "2nd mount point at", secondMountPoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(secondMountPoint)
-
-	log.Debug("swarmfs cli test: remounting at second mount point", "ipc path", filepath.Join(handlingNode.Dir, handlingNode.IpcPath))
-
-	//remount, check files
-	newMount := runSwarm(t, []string{
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), filepath.Join(handlingNode.Dir, handlingNode.IpcPath),
-		"fs",
-		"mount",
-		hash, // the latest hash
-		secondMountPoint,
-	}...)
-
-	newMount.ExpectExit()
-	time.Sleep(1 * time.Second)
-
-	filesInDir, err = ioutil.ReadDir(secondMountPoint)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(filesInDir) == 0 {
-		t.Fatal("there should be something here")
-	}
-
-	log.Debug("swarmfs cli test: traversing file tree to see it matches previous mount")
-
-	for _, file := range filesToAssert {
-		file.filePath = strings.Replace(file.filePath, mountPoint, secondMountPoint, -1)
-		fileBytes, err := ioutil.ReadFile(file.filePath)
-
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !bytes.Equal(fileBytes, bytes.NewBufferString(file.content).Bytes()) {
-			t.Fatal("this should be equal")
-		}
-	}
-
-	log.Debug("swarmfs cli test: unmounting second run", "ipc path", filepath.Join(handlingNode.Dir, handlingNode.IpcPath))
-
-	unmountSec := runSwarm(t, []string{
-		fmt.Sprintf("--%s", utils.IPCPathFlag.Name), filepath.Join(handlingNode.Dir, handlingNode.IpcPath),
-		"fs",
-		"unmount",
-		secondMountPoint,
-	}...)
-
-	_, matches = unmountSec.ExpectRegexp(hashRegexp)
-	unmountSec.ExpectExit()
-
-	if matches[0] != hash {
-		t.Fatal("these should be equal - no changes made")
-	}
-}
-
-func doUploadEmptyDir(t *testing.T, node *testNode) string {
-	// create a tmp dir
-	tmpDir, err := ioutil.TempDir("", "swarm-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	hashRegexp := `[a-f\d]{64}`
-
-	flags := []string{
-		"--bzzapi", node.URL,
-		"--recursive",
-		"up",
-		tmpDir}
-
-	log.Info("swarmfs cli test: uploading dir with 'swarm up'")
-	up := runSwarm(t, flags...)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-	hash := matches[0]
-	log.Info("swarmfs cli test: dir uploaded", "hash", hash)
-	return hash
-}
-
-func createDirInDir(createInDir string, dirToCreate string) (string, error) {
-	fullpath := filepath.Join(createInDir, dirToCreate)
-	err := os.MkdirAll(fullpath, 0777)
-	if err != nil {
-		return "", err
-	}
-	return fullpath, nil
-}
-
-func createTestFileInPath(dir, filename, content string) (*testFile, error) {
-	tFile := &testFile{}
-	filePath := filepath.Join(dir, filename)
-	if file, err := os.Create(filePath); err == nil {
-		tFile.content = content
-		tFile.filePath = filePath
-
-		_, err = io.WriteString(file, content)
-		if err != nil {
-			return nil, err
-		}
-		file.Close()
-	}
-
-	return tFile, nil
-}

cmd/swarm/global-store/global_store.go

@@ -1,100 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"net"
-	"net/http"
-	"os"
-
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/rpc"
-	"github.com/ubiq/go-ubiq/swarm/storage/mock"
-	"github.com/ubiq/go-ubiq/swarm/storage/mock/db"
-	"github.com/ubiq/go-ubiq/swarm/storage/mock/mem"
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-// startHTTP starts a global store with HTTP RPC server.
-// It is used for "http" cli command.
-func startHTTP(ctx *cli.Context) (err error) {
-	server, cleanup, err := newServer(ctx)
-	if err != nil {
-		return err
-	}
-	defer cleanup()
-
-	listener, err := net.Listen("tcp", ctx.String("addr"))
-	if err != nil {
-		return err
-	}
-	log.Info("http", "address", listener.Addr().String())
-
-	return http.Serve(listener, server)
-}
-
-// startWS starts a global store with WebSocket RPC server.
-// It is used for "websocket" cli command.
-func startWS(ctx *cli.Context) (err error) {
-	server, cleanup, err := newServer(ctx)
-	if err != nil {
-		return err
-	}
-	defer cleanup()
-
-	listener, err := net.Listen("tcp", ctx.String("addr"))
-	if err != nil {
-		return err
-	}
-	origins := ctx.StringSlice("origins")
-	log.Info("websocket", "address", listener.Addr().String(), "origins", origins)
-
-	return http.Serve(listener, server.WebsocketHandler(origins))
-}
-
-// newServer creates a global store and returns its RPC server.
-// Returned cleanup function should be called only if err is nil.
-func newServer(ctx *cli.Context) (server *rpc.Server, cleanup func(), err error) {
-	log.PrintOrigins(true)
-	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(ctx.Int("verbosity")), log.StreamHandler(os.Stdout, log.TerminalFormat(false))))
-
-	cleanup = func() {}
-	var globalStore mock.GlobalStorer
-	dir := ctx.String("dir")
-	if dir != "" {
-		dbStore, err := db.NewGlobalStore(dir)
-		if err != nil {
-			return nil, nil, err
-		}
-		cleanup = func() {
-			dbStore.Close()
-		}
-		globalStore = dbStore
-		log.Info("database global store", "dir", dir)
-	} else {
-		globalStore = mem.NewGlobalStore()
-		log.Info("in-memory global store")
-	}
-
-	server = rpc.NewServer()
-	if err := server.RegisterName("mockStore", globalStore); err != nil {
-		cleanup()
-		return nil, nil, err
-	}
-
-	return server, cleanup, nil
-}

cmd/swarm/global-store/global_store_test.go

@@ -1,191 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/rpc"
-	mockRPC "github.com/ubiq/go-ubiq/swarm/storage/mock/rpc"
-)
-
-// TestHTTP_InMemory tests in-memory global store that exposes
-// HTTP server.
-func TestHTTP_InMemory(t *testing.T) {
-	testHTTP(t, true)
-}
-
-// TestHTTP_Database tests global store with persisted database
-// that exposes HTTP server.
-func TestHTTP_Database(t *testing.T) {
-	dir, err := ioutil.TempDir("", "swarm-global-store-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-
-	// create a fresh global store
-	testHTTP(t, true, "--dir", dir)
-
-	// check if data saved by the previous global store instance
-	testHTTP(t, false, "--dir", dir)
-}
-
-// testWebsocket starts global store binary with HTTP server
-// and validates that it can store and retrieve data.
-// If put is false, no data will be stored, only retrieved,
-// giving the possibility to check if data is present in the
-// storage directory.
-func testHTTP(t *testing.T, put bool, args ...string) {
-	addr := findFreeTCPAddress(t)
-	testCmd := runGlobalStore(t, append([]string{"http", "--addr", addr}, args...)...)
-	defer testCmd.Interrupt()
-
-	client, err := rpc.DialHTTP("http://" + addr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// wait until global store process is started as
-	// rpc.DialHTTP is actually not connecting
-	for i := 0; i < 1000; i++ {
-		_, err = http.DefaultClient.Get("http://" + addr)
-		if err == nil {
-			break
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	store := mockRPC.NewGlobalStore(client)
-	defer store.Close()
-
-	node := store.NewNodeStore(common.HexToAddress("123abc"))
-
-	wantKey := "key"
-	wantValue := "value"
-
-	if put {
-		err = node.Put([]byte(wantKey), []byte(wantValue))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	gotValue, err := node.Get([]byte(wantKey))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(gotValue) != wantValue {
-		t.Errorf("got value %s for key %s, want %s", string(gotValue), wantKey, wantValue)
-	}
-}
-
-// TestWebsocket_InMemory tests in-memory global store that exposes
-// WebSocket server.
-func TestWebsocket_InMemory(t *testing.T) {
-	testWebsocket(t, true)
-}
-
-// TestWebsocket_Database tests global store with persisted database
-// that exposes HTTP server.
-func TestWebsocket_Database(t *testing.T) {
-	dir, err := ioutil.TempDir("", "swarm-global-store-")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
-
-	// create a fresh global store
-	testWebsocket(t, true, "--dir", dir)
-
-	// check if data saved by the previous global store instance
-	testWebsocket(t, false, "--dir", dir)
-}
-
-// testWebsocket starts global store binary with WebSocket server
-// and validates that it can store and retrieve data.
-// If put is false, no data will be stored, only retrieved,
-// giving the possibility to check if data is present in the
-// storage directory.
-func testWebsocket(t *testing.T, put bool, args ...string) {
-	addr := findFreeTCPAddress(t)
-	testCmd := runGlobalStore(t, append([]string{"ws", "--addr", addr}, args...)...)
-	defer testCmd.Interrupt()
-
-	var client *rpc.Client
-	var err error
-	// wait until global store process is started
-	for i := 0; i < 1000; i++ {
-		client, err = rpc.DialWebsocket(context.Background(), "ws://"+addr, "")
-		if err == nil {
-			break
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	store := mockRPC.NewGlobalStore(client)
-	defer store.Close()
-
-	node := store.NewNodeStore(common.HexToAddress("123abc"))
-
-	wantKey := "key"
-	wantValue := "value"
-
-	if put {
-		err = node.Put([]byte(wantKey), []byte(wantValue))
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	gotValue, err := node.Get([]byte(wantKey))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(gotValue) != wantValue {
-		t.Errorf("got value %s for key %s, want %s", string(gotValue), wantKey, wantValue)
-	}
-}
-
-// findFreeTCPAddress returns a local address (IP:Port) to which
-// global store can listen on.
-func findFreeTCPAddress(t *testing.T) (addr string) {
-	t.Helper()
-
-	listener, err := net.Listen("tcp", "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer listener.Close()
-
-	return listener.Addr().String()
-}

cmd/swarm/global-store/main.go

@@ -1,104 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"os"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/log"
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-var gitCommit string // Git SHA1 commit hash of the release (set via linker flags)
-
-func main() {
-	err := newApp().Run(os.Args)
-	if err != nil {
-		log.Error(err.Error())
-		os.Exit(1)
-	}
-}
-
-// newApp construct a new instance of Swarm Global Store.
-// Method Run is called on it in the main function and in tests.
-func newApp() (app *cli.App) {
-	app = utils.NewApp(gitCommit, "Swarm Global Store")
-
-	app.Name = "global-store"
-
-	// app flags (for all commands)
-	app.Flags = []cli.Flag{
-		cli.IntFlag{
-			Name:  "verbosity",
-			Value: 3,
-			Usage: "verbosity level",
-		},
-	}
-
-	app.Commands = []cli.Command{
-		{
-			Name:    "http",
-			Aliases: []string{"h"},
-			Usage:   "start swarm global store with http server",
-			Action:  startHTTP,
-			// Flags only for "start" command.
-			// Allow app flags to be specified after the
-			// command argument.
-			Flags: append(app.Flags,
-				cli.StringFlag{
-					Name:  "dir",
-					Value: "",
-					Usage: "data directory",
-				},
-				cli.StringFlag{
-					Name:  "addr",
-					Value: "0.0.0.0:3033",
-					Usage: "address to listen for http connection",
-				},
-			),
-		},
-		{
-			Name:    "websocket",
-			Aliases: []string{"ws"},
-			Usage:   "start swarm global store with websocket server",
-			Action:  startWS,
-			// Flags only for "start" command.
-			// Allow app flags to be specified after the
-			// command argument.
-			Flags: append(app.Flags,
-				cli.StringFlag{
-					Name:  "dir",
-					Value: "",
-					Usage: "data directory",
-				},
-				cli.StringFlag{
-					Name:  "addr",
-					Value: "0.0.0.0:3033",
-					Usage: "address to listen for websocket connection",
-				},
-				cli.StringSliceFlag{
-					Name:  "origins",
-					Value: &cli.StringSlice{"*"},
-					Usage: "websocket origins",
-				},
-			),
-		},
-	}
-
-	return app
-}

cmd/swarm/global-store/run_test.go

@@ -1,49 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"testing"
-
-	"github.com/docker/docker/pkg/reexec"
-	"github.com/ubiq/go-ubiq/internal/cmdtest"
-)
-
-func init() {
-	reexec.Register("swarm-global-store", func() {
-		if err := newApp().Run(os.Args); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		os.Exit(0)
-	})
-}
-
-func runGlobalStore(t *testing.T, args ...string) *cmdtest.TestCmd {
-	tt := cmdtest.NewTestCmd(t, nil)
-	tt.Run("swarm-global-store", args...)
-	return tt
-}
-
-func TestMain(m *testing.M) {
-	if reexec.Init() {
-		return
-	}
-	os.Exit(m.Run())
-}

cmd/swarm/hash.go

@@ -1,58 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// Command bzzhash computes a swarm tree hash.
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/swarm/storage"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var hashCommand = cli.Command{
-	Action:             hash,
-	CustomHelpTemplate: helpTemplate,
-	Name:               "hash",
-	Usage:              "print the swarm hash of a file or directory",
-	ArgsUsage:          "<file>",
-	Description:        "Prints the swarm hash of file or directory",
-}
-
-func hash(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) < 1 {
-		utils.Fatalf("Usage: swarm hash <file name>")
-	}
-	f, err := os.Open(args[0])
-	if err != nil {
-		utils.Fatalf("Error opening file " + args[1])
-	}
-	defer f.Close()
-
-	stat, _ := f.Stat()
-	fileStore := storage.NewFileStore(&storage.FakeChunkStore{}, storage.NewFileStoreParams())
-	addr, _, err := fileStore.Store(context.TODO(), f, stat.Size(), false)
-	if err != nil {
-		utils.Fatalf("%v\n", err)
-	} else {
-		fmt.Printf("%v\n", addr)
-	}
-}

cmd/swarm/list.go

@@ -1,70 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-	"text/tabwriter"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var listCommand = cli.Command{
-	Action:             list,
-	CustomHelpTemplate: helpTemplate,
-	Name:               "ls",
-	Usage:              "list files and directories contained in a manifest",
-	ArgsUsage:          "<manifest> [<prefix>]",
-	Description:        "Lists files and directories contained in a manifest",
-}
-
-func list(ctx *cli.Context) {
-	args := ctx.Args()
-
-	if len(args) < 1 {
-		utils.Fatalf("Please supply a manifest reference as the first argument")
-	} else if len(args) > 2 {
-		utils.Fatalf("Too many arguments - usage 'swarm ls manifest [prefix]'")
-	}
-	manifest := args[0]
-
-	var prefix string
-	if len(args) == 2 {
-		prefix = args[1]
-	}
-
-	bzzapi := strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-	client := swarm.NewClient(bzzapi)
-	list, err := client.List(manifest, prefix, "")
-	if err != nil {
-		utils.Fatalf("Failed to generate file and directory list: %s", err)
-	}
-
-	w := tabwriter.NewWriter(os.Stdout, 1, 2, 2, ' ', 0)
-	defer w.Flush()
-	fmt.Fprintln(w, "HASH\tCONTENT TYPE\tPATH")
-	for _, prefix := range list.CommonPrefixes {
-		fmt.Fprintf(w, "%s\t%s\t%s\n", "", "DIR", prefix)
-	}
-	for _, entry := range list.Entries {
-		fmt.Fprintf(w, "%s\t%s\t%s\n", entry.Hash, entry.ContentType, entry.Path)
-	}
-}

cmd/swarm/main.go

@@ -1,469 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"crypto/ecdsa"
-	"encoding/hex"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/signal"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"syscall"
-
-	"github.com/ubiq/go-ubiq/accounts"
-	"github.com/ubiq/go-ubiq/accounts/keystore"
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/console"
-	"github.com/ubiq/go-ubiq/crypto"
-	"github.com/ubiq/go-ubiq/internal/debug"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/node"
-	"github.com/ubiq/go-ubiq/p2p/enode"
-	"github.com/ubiq/go-ubiq/rpc"
-	"github.com/ubiq/go-ubiq/swarm"
-	bzzapi "github.com/ubiq/go-ubiq/swarm/api"
-	swarmmetrics "github.com/ubiq/go-ubiq/swarm/metrics"
-	"github.com/ubiq/go-ubiq/swarm/storage/mock"
-	mockrpc "github.com/ubiq/go-ubiq/swarm/storage/mock/rpc"
-	"github.com/ubiq/go-ubiq/swarm/tracing"
-	sv "github.com/ubiq/go-ubiq/swarm/version"
-
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-const clientIdentifier = "swarm"
-const helpTemplate = `NAME:
-{{.HelpName}} - {{.Usage}}
-
-USAGE:
-{{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Category}}
-
-CATEGORY:
-{{.Category}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-{{.Description}}{{end}}{{if .VisibleFlags}}
-
-OPTIONS:
-{{range .VisibleFlags}}{{.}}
-{{end}}{{end}}
-`
-
-// Git SHA1 commit hash of the release (set via linker flags)
-// this variable will be assigned if corresponding parameter is passed with install, but not with test
-// e.g.: go install -ldflags "-X main.gitCommit=ed1312d01b19e04ef578946226e5d8069d5dfd5a" ./cmd/swarm
-var gitCommit string
-
-//declare a few constant error messages, useful for later error check comparisons in test
-var (
-	SWARM_ERR_NO_BZZACCOUNT   = "bzzaccount option is required but not set; check your config file, command line or environment variables"
-	SWARM_ERR_SWAP_SET_NO_API = "SWAP is enabled but --swap-api is not set"
-)
-
-// this help command gets added to any subcommand that does not define it explicitly
-var defaultSubcommandHelp = cli.Command{
-	Action:             func(ctx *cli.Context) { cli.ShowCommandHelpAndExit(ctx, "", 1) },
-	CustomHelpTemplate: helpTemplate,
-	Name:               "help",
-	Usage:              "shows this help",
-	Hidden:             true,
-}
-
-var defaultNodeConfig = node.DefaultConfig
-
-// This init function sets defaults so cmd/swarm can run alongside gubiq.
-func init() {
-	sv.GitCommit = gitCommit
-	defaultNodeConfig.Name = clientIdentifier
-	defaultNodeConfig.Version = sv.VersionWithCommit(gitCommit)
-	defaultNodeConfig.P2P.ListenAddr = ":30399"
-	defaultNodeConfig.IPCPath = "bzzd.ipc"
-	// Set flag defaults for --help display.
-	utils.ListenPortFlag.Value = 30399
-}
-
-var app = utils.NewApp("", "Ubiq Swarm")
-
-// This init function creates the cli.App.
-func init() {
-	app.Action = bzzd
-	app.Version = sv.ArchiveVersion(gitCommit)
-	app.Copyright = "Copyright 2013-2016 The go-ubiq Authors"
-	app.Commands = []cli.Command{
-		{
-			Action:             version,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "version",
-			Usage:              "Print version numbers",
-			Description:        "The output of this command is supposed to be machine-readable",
-		},
-		{
-			Action:             keys,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "print-keys",
-			Flags:              []cli.Flag{SwarmCompressedFlag},
-			Usage:              "Print public key information",
-			Description:        "The output of this command is supposed to be machine-readable",
-		},
-		// See upload.go
-		upCommand,
-		// See access.go
-		accessCommand,
-		// See feeds.go
-		feedCommand,
-		// See list.go
-		listCommand,
-		// See hash.go
-		hashCommand,
-		// See download.go
-		downloadCommand,
-		// See manifest.go
-		manifestCommand,
-		// See fs.go
-		fsCommand,
-		// See db.go
-		dbCommand,
-		// See config.go
-		DumpConfigCommand,
-		// hashesCommand
-		hashesCommand,
-	}
-
-	// append a hidden help subcommand to all commands that have subcommands
-	// if a help command was already defined above, that one will take precedence.
-	addDefaultHelpSubcommands(app.Commands)
-
-	sort.Sort(cli.CommandsByName(app.Commands))
-
-	app.Flags = []cli.Flag{
-		utils.IdentityFlag,
-		utils.DataDirFlag,
-		utils.BootnodesFlag,
-		utils.KeyStoreDirFlag,
-		utils.ListenPortFlag,
-		utils.DiscoveryV5Flag,
-		utils.NetrestrictFlag,
-		utils.NodeKeyFileFlag,
-		utils.NodeKeyHexFlag,
-		utils.MaxPeersFlag,
-		utils.NATFlag,
-		utils.IPCDisabledFlag,
-		utils.IPCPathFlag,
-		utils.PasswordFileFlag,
-		// bzzd-specific flags
-		CorsStringFlag,
-		EnsAPIFlag,
-		SwarmTomlConfigPathFlag,
-		SwarmSwapEnabledFlag,
-		SwarmSwapAPIFlag,
-		SwarmSyncDisabledFlag,
-		SwarmSyncUpdateDelay,
-		SwarmMaxStreamPeerServersFlag,
-		SwarmLightNodeEnabled,
-		SwarmDeliverySkipCheckFlag,
-		SwarmListenAddrFlag,
-		SwarmPortFlag,
-		SwarmAccountFlag,
-		SwarmNetworkIdFlag,
-		ChequebookAddrFlag,
-		// upload flags
-		SwarmApiFlag,
-		SwarmRecursiveFlag,
-		SwarmWantManifestFlag,
-		SwarmUploadDefaultPath,
-		SwarmUpFromStdinFlag,
-		SwarmUploadMimeType,
-		// bootnode mode
-		SwarmBootnodeModeFlag,
-		// storage flags
-		SwarmStorePath,
-		SwarmStoreCapacity,
-		SwarmStoreCacheCapacity,
-		SwarmGlobalStoreAPIFlag,
-	}
-	rpcFlags := []cli.Flag{
-		utils.WSEnabledFlag,
-		utils.WSListenAddrFlag,
-		utils.WSPortFlag,
-		utils.WSApiFlag,
-		utils.WSAllowedOriginsFlag,
-	}
-	app.Flags = append(app.Flags, rpcFlags...)
-	app.Flags = append(app.Flags, debug.Flags...)
-	app.Flags = append(app.Flags, swarmmetrics.Flags...)
-	app.Flags = append(app.Flags, tracing.Flags...)
-	app.Before = func(ctx *cli.Context) error {
-		runtime.GOMAXPROCS(runtime.NumCPU())
-		if err := debug.Setup(ctx, ""); err != nil {
-			return err
-		}
-		swarmmetrics.Setup(ctx)
-		tracing.Setup(ctx)
-		return nil
-	}
-	app.After = func(ctx *cli.Context) error {
-		debug.Exit()
-		return nil
-	}
-}
-
-func main() {
-	if err := app.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-func keys(ctx *cli.Context) error {
-	privateKey := getPrivKey(ctx)
-	pubkey := crypto.FromECDSAPub(&privateKey.PublicKey)
-	pubkeyhex := hex.EncodeToString(pubkey)
-	pubCompressed := hex.EncodeToString(crypto.CompressPubkey(&privateKey.PublicKey))
-	bzzkey := crypto.Keccak256Hash(pubkey).Hex()
-
-	if !ctx.Bool(SwarmCompressedFlag.Name) {
-		fmt.Println(fmt.Sprintf("bzzkey=%s", bzzkey[2:]))
-		fmt.Println(fmt.Sprintf("publicKey=%s", pubkeyhex))
-	}
-	fmt.Println(fmt.Sprintf("publicKeyCompressed=%s", pubCompressed))
-
-	return nil
-}
-
-func version(ctx *cli.Context) error {
-	fmt.Println(strings.Title(clientIdentifier))
-	fmt.Println("Version:", sv.VersionWithMeta)
-	if gitCommit != "" {
-		fmt.Println("Git Commit:", gitCommit)
-	}
-	fmt.Println("Go Version:", runtime.Version())
-	fmt.Println("OS:", runtime.GOOS)
-	return nil
-}
-
-func bzzd(ctx *cli.Context) error {
-	//build a valid bzzapi.Config from all available sources:
-	//default config, file config, command line and env vars
-
-	bzzconfig, err := buildConfig(ctx)
-	if err != nil {
-		utils.Fatalf("unable to configure swarm: %v", err)
-	}
-
-	cfg := defaultNodeConfig
-
-	//pss operates on ws
-	cfg.WSModules = append(cfg.WSModules, "pss")
-
-	//gubiq only supports --datadir via command line
-	//in order to be consistent within swarm, if we pass --datadir via environment variable
-	//or via config file, we get the same directory for gubiq and swarm
-	if _, err := os.Stat(bzzconfig.Path); err == nil {
-		cfg.DataDir = bzzconfig.Path
-	}
-
-	//optionally set the bootnodes before configuring the node
-	setSwarmBootstrapNodes(ctx, &cfg)
-	//setup the ethereum node
-	utils.SetNodeConfig(ctx, &cfg)
-
-	//always disable discovery from p2p package - swarm discovery is done with the `hive` protocol
-	cfg.P2P.NoDiscovery = true
-
-	stack, err := node.New(&cfg)
-	if err != nil {
-		utils.Fatalf("can't create node: %v", err)
-	}
-
-	//a few steps need to be done after the config phase is completed,
-	//due to overriding behavior
-	initSwarmNode(bzzconfig, stack, ctx)
-	//register BZZ as node.Service in the ethereum node
-	registerBzzService(bzzconfig, stack)
-	//start the node
-	utils.StartNode(stack)
-
-	go func() {
-		sigc := make(chan os.Signal, 1)
-		signal.Notify(sigc, syscall.SIGTERM)
-		defer signal.Stop(sigc)
-		<-sigc
-		log.Info("Got sigterm, shutting swarm down...")
-		stack.Stop()
-	}()
-
-	// add swarm bootnodes, because swarm doesn't use p2p package's discovery discv5
-	go func() {
-		s := stack.Server()
-
-		for _, n := range cfg.P2P.BootstrapNodes {
-			s.AddPeer(n)
-		}
-	}()
-
-	stack.Wait()
-	return nil
-}
-
-func registerBzzService(bzzconfig *bzzapi.Config, stack *node.Node) {
-	//define the swarm service boot function
-	boot := func(_ *node.ServiceContext) (node.Service, error) {
-		var nodeStore *mock.NodeStore
-		if bzzconfig.GlobalStoreAPI != "" {
-			// connect to global store
-			client, err := rpc.Dial(bzzconfig.GlobalStoreAPI)
-			if err != nil {
-				return nil, fmt.Errorf("global store: %v", err)
-			}
-			globalStore := mockrpc.NewGlobalStore(client)
-			// create a node store for this swarm key on global store
-			nodeStore = globalStore.NewNodeStore(common.HexToAddress(bzzconfig.BzzKey))
-		}
-		return swarm.NewSwarm(bzzconfig, nodeStore)
-	}
-	//register within the ethereum node
-	if err := stack.Register(boot); err != nil {
-		utils.Fatalf("Failed to register the Swarm service: %v", err)
-	}
-}
-
-func getAccount(bzzaccount string, ctx *cli.Context, stack *node.Node) *ecdsa.PrivateKey {
-	//an account is mandatory
-	if bzzaccount == "" {
-		utils.Fatalf(SWARM_ERR_NO_BZZACCOUNT)
-	}
-	// Try to load the arg as a hex key file.
-	if key, err := crypto.LoadECDSA(bzzaccount); err == nil {
-		log.Info("Swarm account key loaded", "address", crypto.PubkeyToAddress(key.PublicKey))
-		return key
-	}
-	// Otherwise try getting it from the keystore.
-	am := stack.AccountManager()
-	ks := am.Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
-
-	return decryptStoreAccount(ks, bzzaccount, utils.MakePasswordList(ctx))
-}
-
-// getPrivKey returns the private key of the specified bzzaccount
-// Used only by client commands, such as `feed`
-func getPrivKey(ctx *cli.Context) *ecdsa.PrivateKey {
-	// booting up the swarm node just as we do in bzzd action
-	bzzconfig, err := buildConfig(ctx)
-	if err != nil {
-		utils.Fatalf("unable to configure swarm: %v", err)
-	}
-	cfg := defaultNodeConfig
-	if _, err := os.Stat(bzzconfig.Path); err == nil {
-		cfg.DataDir = bzzconfig.Path
-	}
-	utils.SetNodeConfig(ctx, &cfg)
-	stack, err := node.New(&cfg)
-	if err != nil {
-		utils.Fatalf("can't create node: %v", err)
-	}
-	return getAccount(bzzconfig.BzzAccount, ctx, stack)
-}
-
-func decryptStoreAccount(ks *keystore.KeyStore, account string, passwords []string) *ecdsa.PrivateKey {
-	var a accounts.Account
-	var err error
-	if common.IsHexAddress(account) {
-		a, err = ks.Find(accounts.Account{Address: common.HexToAddress(account)})
-	} else if ix, ixerr := strconv.Atoi(account); ixerr == nil && ix > 0 {
-		if accounts := ks.Accounts(); len(accounts) > ix {
-			a = accounts[ix]
-		} else {
-			err = fmt.Errorf("index %d higher than number of accounts %d", ix, len(accounts))
-		}
-	} else {
-		utils.Fatalf("Can't find swarm account key %s", account)
-	}
-	if err != nil {
-		utils.Fatalf("Can't find swarm account key: %v - Is the provided bzzaccount(%s) from the right datadir/Path?", err, account)
-	}
-	keyjson, err := ioutil.ReadFile(a.URL.Path)
-	if err != nil {
-		utils.Fatalf("Can't load swarm account key: %v", err)
-	}
-	for i := 0; i < 3; i++ {
-		password := getPassPhrase(fmt.Sprintf("Unlocking swarm account %s [%d/3]", a.Address.Hex(), i+1), i, passwords)
-		key, err := keystore.DecryptKey(keyjson, password)
-		if err == nil {
-			return key.PrivateKey
-		}
-	}
-	utils.Fatalf("Can't decrypt swarm account key")
-	return nil
-}
-
-// getPassPhrase retrieves the password associated with bzz account, either by fetching
-// from a list of pre-loaded passwords, or by requesting it interactively from user.
-func getPassPhrase(prompt string, i int, passwords []string) string {
-	// non-interactive
-	if len(passwords) > 0 {
-		if i < len(passwords) {
-			return passwords[i]
-		}
-		return passwords[len(passwords)-1]
-	}
-
-	// fallback to interactive mode
-	if prompt != "" {
-		fmt.Println(prompt)
-	}
-	password, err := console.Stdin.PromptPassword("Passphrase: ")
-	if err != nil {
-		utils.Fatalf("Failed to read passphrase: %v", err)
-	}
-	return password
-}
-
-// addDefaultHelpSubcommand scans through defined CLI commands and adds
-// a basic help subcommand to each
-// if a help command is already defined, it will take precedence over the default.
-func addDefaultHelpSubcommands(commands []cli.Command) {
-	for i := range commands {
-		cmd := &commands[i]
-		if cmd.Subcommands != nil {
-			cmd.Subcommands = append(cmd.Subcommands, defaultSubcommandHelp)
-			addDefaultHelpSubcommands(cmd.Subcommands)
-		}
-	}
-}
-
-func setSwarmBootstrapNodes(ctx *cli.Context, cfg *node.Config) {
-	if ctx.GlobalIsSet(utils.BootnodesFlag.Name) || ctx.GlobalIsSet(utils.BootnodesV4Flag.Name) {
-		return
-	}
-
-	cfg.P2P.BootstrapNodes = []*enode.Node{}
-
-	for _, url := range SwarmBootnodes {
-		node, err := enode.ParseV4(url)
-		if err != nil {
-			log.Error("Bootstrap URL invalid", "enode", url, "err", err)
-		}
-		cfg.P2P.BootstrapNodes = append(cfg.P2P.BootstrapNodes, node)
-	}
-
-}

cmd/swarm/manifest.go

@@ -1,353 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// Command  MANIFEST update
-package main
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var manifestCommand = cli.Command{
-	Name:               "manifest",
-	CustomHelpTemplate: helpTemplate,
-	Usage:              "perform operations on swarm manifests",
-	ArgsUsage:          "COMMAND",
-	Description:        "Updates a MANIFEST by adding/removing/updating the hash of a path.\nCOMMAND could be: add, update, remove",
-	Subcommands: []cli.Command{
-		{
-			Action:             manifestAdd,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "add",
-			Usage:              "add a new path to the manifest",
-			ArgsUsage:          "<MANIFEST> <path> <hash>",
-			Description:        "Adds a new path to the manifest",
-		},
-		{
-			Action:             manifestUpdate,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "update",
-			Usage:              "update the hash for an already existing path in the manifest",
-			ArgsUsage:          "<MANIFEST> <path> <newhash>",
-			Description:        "Update the hash for an already existing path in the manifest",
-		},
-		{
-			Action:             manifestRemove,
-			CustomHelpTemplate: helpTemplate,
-			Name:               "remove",
-			Usage:              "removes a path from the manifest",
-			ArgsUsage:          "<MANIFEST> <path>",
-			Description:        "Removes a path from the manifest",
-		},
-	},
-}
-
-// manifestAdd adds a new entry to the manifest at the given path.
-// New entry hash, the last argument, must be the hash of a manifest
-// with only one entry, which meta-data will be added to the original manifest.
-// On success, this function will print new (updated) manifest's hash.
-func manifestAdd(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 3 {
-		utils.Fatalf("Need exactly three arguments <MHASH> <path> <HASH>")
-	}
-
-	var (
-		mhash = args[0]
-		path  = args[1]
-		hash  = args[2]
-	)
-
-	bzzapi := strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-	client := swarm.NewClient(bzzapi)
-
-	m, _, err := client.DownloadManifest(hash)
-	if err != nil {
-		utils.Fatalf("Error downloading manifest to add: %v", err)
-	}
-	l := len(m.Entries)
-	if l == 0 {
-		utils.Fatalf("No entries in manifest %s", hash)
-	} else if l > 1 {
-		utils.Fatalf("Too many entries in manifest %s", hash)
-	}
-
-	newManifest := addEntryToManifest(client, mhash, path, m.Entries[0])
-	fmt.Println(newManifest)
-}
-
-// manifestUpdate replaces an existing entry of the manifest at the given path.
-// New entry hash, the last argument, must be the hash of a manifest
-// with only one entry, which meta-data will be added to the original manifest.
-// On success, this function will print hash of the updated manifest.
-func manifestUpdate(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 3 {
-		utils.Fatalf("Need exactly three arguments <MHASH> <path> <HASH>")
-	}
-
-	var (
-		mhash = args[0]
-		path  = args[1]
-		hash  = args[2]
-	)
-
-	bzzapi := strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-	client := swarm.NewClient(bzzapi)
-
-	m, _, err := client.DownloadManifest(hash)
-	if err != nil {
-		utils.Fatalf("Error downloading manifest to update: %v", err)
-	}
-	l := len(m.Entries)
-	if l == 0 {
-		utils.Fatalf("No entries in manifest %s", hash)
-	} else if l > 1 {
-		utils.Fatalf("Too many entries in manifest %s", hash)
-	}
-
-	newManifest, _, defaultEntryUpdated := updateEntryInManifest(client, mhash, path, m.Entries[0], true)
-	if defaultEntryUpdated {
-		// Print informational message to stderr
-		// allowing the user to get the new manifest hash from stdout
-		// without the need to parse the complete output.
-		fmt.Fprintln(os.Stderr, "Manifest default entry is updated, too")
-	}
-	fmt.Println(newManifest)
-}
-
-// manifestRemove removes an existing entry of the manifest at the given path.
-// On success, this function will print hash of the manifest which does not
-// contain the path.
-func manifestRemove(ctx *cli.Context) {
-	args := ctx.Args()
-	if len(args) != 2 {
-		utils.Fatalf("Need exactly two arguments <MHASH> <path>")
-	}
-
-	var (
-		mhash = args[0]
-		path  = args[1]
-	)
-
-	bzzapi := strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-	client := swarm.NewClient(bzzapi)
-
-	newManifest := removeEntryFromManifest(client, mhash, path)
-	fmt.Println(newManifest)
-}
-
-func addEntryToManifest(client *swarm.Client, mhash, path string, entry api.ManifestEntry) string {
-	var longestPathEntry = api.ManifestEntry{}
-
-	mroot, isEncrypted, err := client.DownloadManifest(mhash)
-	if err != nil {
-		utils.Fatalf("Manifest download failed: %v", err)
-	}
-
-	// See if we path is in this Manifest or do we have to dig deeper
-	for _, e := range mroot.Entries {
-		if path == e.Path {
-			utils.Fatalf("Path %s already present, not adding anything", path)
-		} else {
-			if e.ContentType == api.ManifestType {
-				prfxlen := strings.HasPrefix(path, e.Path)
-				if prfxlen && len(path) > len(longestPathEntry.Path) {
-					longestPathEntry = e
-				}
-			}
-		}
-	}
-
-	if longestPathEntry.Path != "" {
-		// Load the child Manifest add the entry there
-		newPath := path[len(longestPathEntry.Path):]
-		newHash := addEntryToManifest(client, longestPathEntry.Hash, newPath, entry)
-
-		// Replace the hash for parent Manifests
-		newMRoot := &api.Manifest{}
-		for _, e := range mroot.Entries {
-			if longestPathEntry.Path == e.Path {
-				e.Hash = newHash
-			}
-			newMRoot.Entries = append(newMRoot.Entries, e)
-		}
-		mroot = newMRoot
-	} else {
-		// Add the entry in the leaf Manifest
-		entry.Path = path
-		mroot.Entries = append(mroot.Entries, entry)
-	}
-
-	newManifestHash, err := client.UploadManifest(mroot, isEncrypted)
-	if err != nil {
-		utils.Fatalf("Manifest upload failed: %v", err)
-	}
-	return newManifestHash
-}
-
-// updateEntryInManifest updates an existing entry o path with a new one in the manifest with provided mhash
-// finding the path recursively through all nested manifests. Argument isRoot is used for default
-// entry update detection. If the updated entry has the same hash as the default entry, then the
-// default entry in root manifest will be updated too.
-// Returned values are the new manifest hash, hash of the entry that was replaced by the new entry and
-// a a bool that is true if default entry is updated.
-func updateEntryInManifest(client *swarm.Client, mhash, path string, entry api.ManifestEntry, isRoot bool) (newManifestHash, oldHash string, defaultEntryUpdated bool) {
-	var (
-		newEntry         = api.ManifestEntry{}
-		longestPathEntry = api.ManifestEntry{}
-	)
-
-	mroot, isEncrypted, err := client.DownloadManifest(mhash)
-	if err != nil {
-		utils.Fatalf("Manifest download failed: %v", err)
-	}
-
-	// See if we path is in this Manifest or do we have to dig deeper
-	for _, e := range mroot.Entries {
-		if path == e.Path {
-			newEntry = e
-			// keep the reference of the hash of the entry that should be replaced
-			// for default entry detection
-			oldHash = e.Hash
-		} else {
-			if e.ContentType == api.ManifestType {
-				prfxlen := strings.HasPrefix(path, e.Path)
-				if prfxlen && len(path) > len(longestPathEntry.Path) {
-					longestPathEntry = e
-				}
-			}
-		}
-	}
-
-	if longestPathEntry.Path == "" && newEntry.Path == "" {
-		utils.Fatalf("Path %s not present in the Manifest, not setting anything", path)
-	}
-
-	if longestPathEntry.Path != "" {
-		// Load the child Manifest add the entry there
-		newPath := path[len(longestPathEntry.Path):]
-		var newHash string
-		newHash, oldHash, _ = updateEntryInManifest(client, longestPathEntry.Hash, newPath, entry, false)
-
-		// Replace the hash for parent Manifests
-		newMRoot := &api.Manifest{}
-		for _, e := range mroot.Entries {
-			if longestPathEntry.Path == e.Path {
-				e.Hash = newHash
-			}
-			newMRoot.Entries = append(newMRoot.Entries, e)
-
-		}
-		mroot = newMRoot
-	}
-
-	// update the manifest if the new entry is found and
-	// check if default entry should be updated
-	if newEntry.Path != "" || isRoot {
-		// Replace the hash for leaf Manifest
-		newMRoot := &api.Manifest{}
-		for _, e := range mroot.Entries {
-			if newEntry.Path == e.Path {
-				entry.Path = e.Path
-				newMRoot.Entries = append(newMRoot.Entries, entry)
-			} else if isRoot && e.Path == "" && e.Hash == oldHash {
-				entry.Path = e.Path
-				newMRoot.Entries = append(newMRoot.Entries, entry)
-				defaultEntryUpdated = true
-			} else {
-				newMRoot.Entries = append(newMRoot.Entries, e)
-			}
-		}
-		mroot = newMRoot
-	}
-
-	newManifestHash, err = client.UploadManifest(mroot, isEncrypted)
-	if err != nil {
-		utils.Fatalf("Manifest upload failed: %v", err)
-	}
-	return newManifestHash, oldHash, defaultEntryUpdated
-}
-
-func removeEntryFromManifest(client *swarm.Client, mhash, path string) string {
-	var (
-		entryToRemove    = api.ManifestEntry{}
-		longestPathEntry = api.ManifestEntry{}
-	)
-
-	mroot, isEncrypted, err := client.DownloadManifest(mhash)
-	if err != nil {
-		utils.Fatalf("Manifest download failed: %v", err)
-	}
-
-	// See if we path is in this Manifest or do we have to dig deeper
-	for _, entry := range mroot.Entries {
-		if path == entry.Path {
-			entryToRemove = entry
-		} else {
-			if entry.ContentType == api.ManifestType {
-				prfxlen := strings.HasPrefix(path, entry.Path)
-				if prfxlen && len(path) > len(longestPathEntry.Path) {
-					longestPathEntry = entry
-				}
-			}
-		}
-	}
-
-	if longestPathEntry.Path == "" && entryToRemove.Path == "" {
-		utils.Fatalf("Path %s not present in the Manifest, not removing anything", path)
-	}
-
-	if longestPathEntry.Path != "" {
-		// Load the child Manifest remove the entry there
-		newPath := path[len(longestPathEntry.Path):]
-		newHash := removeEntryFromManifest(client, longestPathEntry.Hash, newPath)
-
-		// Replace the hash for parent Manifests
-		newMRoot := &api.Manifest{}
-		for _, entry := range mroot.Entries {
-			if longestPathEntry.Path == entry.Path {
-				entry.Hash = newHash
-			}
-			newMRoot.Entries = append(newMRoot.Entries, entry)
-		}
-		mroot = newMRoot
-	}
-
-	if entryToRemove.Path != "" {
-		// remove the entry in this Manifest
-		newMRoot := &api.Manifest{}
-		for _, entry := range mroot.Entries {
-			if entryToRemove.Path != entry.Path {
-				newMRoot.Entries = append(newMRoot.Entries, entry)
-			}
-		}
-		mroot = newMRoot
-	}
-
-	newManifestHash, err := client.UploadManifest(mroot, isEncrypted)
-	if err != nil {
-		utils.Fatalf("Manifest upload failed: %v", err)
-	}
-	return newManifestHash
-}

cmd/swarm/manifest_test.go

@@ -1,597 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"github.com/ubiq/go-ubiq/swarm/api"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-	swarmhttp "github.com/ubiq/go-ubiq/swarm/api/http"
-)
-
-// TestManifestChange tests manifest add, update and remove
-// cli commands without encryption.
-func TestManifestChange(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	testManifestChange(t, false)
-}
-
-// TestManifestChange tests manifest add, update and remove
-// cli commands with encryption enabled.
-func TestManifestChangeEncrypted(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	testManifestChange(t, true)
-}
-
-// testManifestChange performs cli commands:
-// - manifest add
-// - manifest update
-// - manifest remove
-// on a manifest, testing the functionality of this
-// comands on paths that are in root manifest or a nested one.
-// Argument encrypt controls whether to use encryption or not.
-func testManifestChange(t *testing.T, encrypt bool) {
-	t.Parallel()
-	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
-	defer srv.Close()
-
-	tmp, err := ioutil.TempDir("", "swarm-manifest-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
-
-	origDir := filepath.Join(tmp, "orig")
-	if err := os.Mkdir(origDir, 0777); err != nil {
-		t.Fatal(err)
-	}
-
-	indexDataFilename := filepath.Join(origDir, "index.html")
-	err = ioutil.WriteFile(indexDataFilename, []byte("<h1>Test</h1>"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Files paths robots.txt and robots.html share the same prefix "robots."
-	// which will result a manifest with a nested manifest under path "robots.".
-	// This will allow testing manifest changes on both root and nested manifest.
-	err = ioutil.WriteFile(filepath.Join(origDir, "robots.txt"), []byte("Disallow: /"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = ioutil.WriteFile(filepath.Join(origDir, "robots.html"), []byte("<strong>No Robots Allowed</strong>"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = ioutil.WriteFile(filepath.Join(origDir, "mutants.txt"), []byte("Frank\nMarcus"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	args := []string{
-		"--bzzapi",
-		srv.URL,
-		"--recursive",
-		"--defaultpath",
-		indexDataFilename,
-		"up",
-		origDir,
-	}
-	if encrypt {
-		args = append(args, "--encrypt")
-	}
-
-	origManifestHash := runSwarmExpectHash(t, args...)
-
-	checkHashLength(t, origManifestHash, encrypt)
-
-	client := swarm.NewClient(srv.URL)
-
-	// upload a new file and use its manifest to add it the original manifest.
-	t.Run("add", func(t *testing.T) {
-		humansData := []byte("Ann\nBob")
-		humansDataFilename := filepath.Join(tmp, "humans.txt")
-		err = ioutil.WriteFile(humansDataFilename, humansData, 0666)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		humansManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"up",
-			humansDataFilename,
-		)
-
-		newManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"manifest",
-			"add",
-			origManifestHash,
-			"humans.txt",
-			humansManifestHash,
-		)
-
-		checkHashLength(t, newManifestHash, encrypt)
-
-		newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-		var found bool
-		for _, e := range newManifest.Entries {
-			if e.Path == "humans.txt" {
-				found = true
-				if e.Size != int64(len(humansData)) {
-					t.Errorf("expected humans.txt size %v, got %v", len(humansData), e.Size)
-				}
-				if e.ModTime.IsZero() {
-					t.Errorf("got zero mod time for humans.txt")
-				}
-				ct := "text/plain; charset=utf-8"
-				if e.ContentType != ct {
-					t.Errorf("expected content type %q, got %q", ct, e.ContentType)
-				}
-				break
-			}
-		}
-		if !found {
-			t.Fatal("no humans.txt in new manifest")
-		}
-
-		checkFile(t, client, newManifestHash, "humans.txt", humansData)
-	})
-
-	// upload a new file and use its manifest to add it the original manifest,
-	// but ensure that the file will be in the nested manifest of the original one.
-	t.Run("add nested", func(t *testing.T) {
-		robotsData := []byte(`{"disallow": "/"}`)
-		robotsDataFilename := filepath.Join(tmp, "robots.json")
-		err = ioutil.WriteFile(robotsDataFilename, robotsData, 0666)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		robotsManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"up",
-			robotsDataFilename,
-		)
-
-		newManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"manifest",
-			"add",
-			origManifestHash,
-			"robots.json",
-			robotsManifestHash,
-		)
-
-		checkHashLength(t, newManifestHash, encrypt)
-
-		newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-		var found bool
-	loop:
-		for _, e := range newManifest.Entries {
-			if e.Path == "robots." {
-				nestedManifest := downloadManifest(t, client, e.Hash, encrypt)
-				for _, e := range nestedManifest.Entries {
-					if e.Path == "json" {
-						found = true
-						if e.Size != int64(len(robotsData)) {
-							t.Errorf("expected robots.json size %v, got %v", len(robotsData), e.Size)
-						}
-						if e.ModTime.IsZero() {
-							t.Errorf("got zero mod time for robots.json")
-						}
-						ct := "application/json"
-						if e.ContentType != ct {
-							t.Errorf("expected content type %q, got %q", ct, e.ContentType)
-						}
-						break loop
-					}
-				}
-			}
-		}
-		if !found {
-			t.Fatal("no robots.json in new manifest")
-		}
-
-		checkFile(t, client, newManifestHash, "robots.json", robotsData)
-	})
-
-	// upload a new file and use its manifest to change the file it the original manifest.
-	t.Run("update", func(t *testing.T) {
-		indexData := []byte("<h1>Ethereum Swarm</h1>")
-		indexDataFilename := filepath.Join(tmp, "index.html")
-		err = ioutil.WriteFile(indexDataFilename, indexData, 0666)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		indexManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"up",
-			indexDataFilename,
-		)
-
-		newManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"manifest",
-			"update",
-			origManifestHash,
-			"index.html",
-			indexManifestHash,
-		)
-
-		checkHashLength(t, newManifestHash, encrypt)
-
-		newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-		var found bool
-		for _, e := range newManifest.Entries {
-			if e.Path == "index.html" {
-				found = true
-				if e.Size != int64(len(indexData)) {
-					t.Errorf("expected index.html size %v, got %v", len(indexData), e.Size)
-				}
-				if e.ModTime.IsZero() {
-					t.Errorf("got zero mod time for index.html")
-				}
-				ct := "text/html; charset=utf-8"
-				if e.ContentType != ct {
-					t.Errorf("expected content type %q, got %q", ct, e.ContentType)
-				}
-				break
-			}
-		}
-		if !found {
-			t.Fatal("no index.html in new manifest")
-		}
-
-		checkFile(t, client, newManifestHash, "index.html", indexData)
-
-		// check default entry change
-		checkFile(t, client, newManifestHash, "", indexData)
-	})
-
-	// upload a new file and use its manifest to change the file it the original manifest,
-	// but ensure that the file is in the nested manifest of the original one.
-	t.Run("update nested", func(t *testing.T) {
-		robotsData := []byte(`<string>Only humans allowed!!!</strong>`)
-		robotsDataFilename := filepath.Join(tmp, "robots.html")
-		err = ioutil.WriteFile(robotsDataFilename, robotsData, 0666)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		humansManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"up",
-			robotsDataFilename,
-		)
-
-		newManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"manifest",
-			"update",
-			origManifestHash,
-			"robots.html",
-			humansManifestHash,
-		)
-
-		checkHashLength(t, newManifestHash, encrypt)
-
-		newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-		var found bool
-	loop:
-		for _, e := range newManifest.Entries {
-			if e.Path == "robots." {
-				nestedManifest := downloadManifest(t, client, e.Hash, encrypt)
-				for _, e := range nestedManifest.Entries {
-					if e.Path == "html" {
-						found = true
-						if e.Size != int64(len(robotsData)) {
-							t.Errorf("expected robots.html size %v, got %v", len(robotsData), e.Size)
-						}
-						if e.ModTime.IsZero() {
-							t.Errorf("got zero mod time for robots.html")
-						}
-						ct := "text/html; charset=utf-8"
-						if e.ContentType != ct {
-							t.Errorf("expected content type %q, got %q", ct, e.ContentType)
-						}
-						break loop
-					}
-				}
-			}
-		}
-		if !found {
-			t.Fatal("no robots.html in new manifest")
-		}
-
-		checkFile(t, client, newManifestHash, "robots.html", robotsData)
-	})
-
-	// remove a file from the manifest.
-	t.Run("remove", func(t *testing.T) {
-		newManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"manifest",
-			"remove",
-			origManifestHash,
-			"mutants.txt",
-		)
-
-		checkHashLength(t, newManifestHash, encrypt)
-
-		newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-		var found bool
-		for _, e := range newManifest.Entries {
-			if e.Path == "mutants.txt" {
-				found = true
-				break
-			}
-		}
-		if found {
-			t.Fatal("mutants.txt is not removed")
-		}
-	})
-
-	// remove a file from the manifest, but ensure that the file is in
-	// the nested manifest of the original one.
-	t.Run("remove nested", func(t *testing.T) {
-		newManifestHash := runSwarmExpectHash(t,
-			"--bzzapi",
-			srv.URL,
-			"manifest",
-			"remove",
-			origManifestHash,
-			"robots.html",
-		)
-
-		checkHashLength(t, newManifestHash, encrypt)
-
-		newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-		var found bool
-	loop:
-		for _, e := range newManifest.Entries {
-			if e.Path == "robots." {
-				nestedManifest := downloadManifest(t, client, e.Hash, encrypt)
-				for _, e := range nestedManifest.Entries {
-					if e.Path == "html" {
-						found = true
-						break loop
-					}
-				}
-			}
-		}
-		if found {
-			t.Fatal("robots.html in not removed")
-		}
-	})
-}
-
-// TestNestedDefaultEntryUpdate tests if the default entry is updated
-// if the file in nested manifest used for it is also updated.
-func TestNestedDefaultEntryUpdate(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	testNestedDefaultEntryUpdate(t, false)
-}
-
-// TestNestedDefaultEntryUpdateEncrypted tests if the default entry
-// of encrypted upload is updated if the file in nested manifest
-// used for it is also updated.
-func TestNestedDefaultEntryUpdateEncrypted(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	testNestedDefaultEntryUpdate(t, true)
-}
-
-func testNestedDefaultEntryUpdate(t *testing.T, encrypt bool) {
-	t.Parallel()
-	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
-	defer srv.Close()
-
-	tmp, err := ioutil.TempDir("", "swarm-manifest-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
-
-	origDir := filepath.Join(tmp, "orig")
-	if err := os.Mkdir(origDir, 0777); err != nil {
-		t.Fatal(err)
-	}
-
-	indexData := []byte("<h1>Test</h1>")
-	indexDataFilename := filepath.Join(origDir, "index.html")
-	err = ioutil.WriteFile(indexDataFilename, indexData, 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Add another file with common prefix as the default entry to test updates of
-	// default entry with nested manifests.
-	err = ioutil.WriteFile(filepath.Join(origDir, "index.txt"), []byte("Test"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	args := []string{
-		"--bzzapi",
-		srv.URL,
-		"--recursive",
-		"--defaultpath",
-		indexDataFilename,
-		"up",
-		origDir,
-	}
-	if encrypt {
-		args = append(args, "--encrypt")
-	}
-
-	origManifestHash := runSwarmExpectHash(t, args...)
-
-	checkHashLength(t, origManifestHash, encrypt)
-
-	client := swarm.NewClient(srv.URL)
-
-	newIndexData := []byte("<h1>Ethereum Swarm</h1>")
-	newIndexDataFilename := filepath.Join(tmp, "index.html")
-	err = ioutil.WriteFile(newIndexDataFilename, newIndexData, 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	newIndexManifestHash := runSwarmExpectHash(t,
-		"--bzzapi",
-		srv.URL,
-		"up",
-		newIndexDataFilename,
-	)
-
-	newManifestHash := runSwarmExpectHash(t,
-		"--bzzapi",
-		srv.URL,
-		"manifest",
-		"update",
-		origManifestHash,
-		"index.html",
-		newIndexManifestHash,
-	)
-
-	checkHashLength(t, newManifestHash, encrypt)
-
-	newManifest := downloadManifest(t, client, newManifestHash, encrypt)
-
-	var found bool
-	for _, e := range newManifest.Entries {
-		if e.Path == "index." {
-			found = true
-			newManifest = downloadManifest(t, client, e.Hash, encrypt)
-			break
-		}
-	}
-	if !found {
-		t.Fatal("no index. path in new manifest")
-	}
-
-	found = false
-	for _, e := range newManifest.Entries {
-		if e.Path == "html" {
-			found = true
-			if e.Size != int64(len(newIndexData)) {
-				t.Errorf("expected index.html size %v, got %v", len(newIndexData), e.Size)
-			}
-			if e.ModTime.IsZero() {
-				t.Errorf("got zero mod time for index.html")
-			}
-			ct := "text/html; charset=utf-8"
-			if e.ContentType != ct {
-				t.Errorf("expected content type %q, got %q", ct, e.ContentType)
-			}
-			break
-		}
-	}
-	if !found {
-		t.Fatal("no html in new manifest")
-	}
-
-	checkFile(t, client, newManifestHash, "index.html", newIndexData)
-
-	// check default entry change
-	checkFile(t, client, newManifestHash, "", newIndexData)
-}
-
-func runSwarmExpectHash(t *testing.T, args ...string) (hash string) {
-	t.Helper()
-	hashRegexp := `[a-f\d]{64,128}`
-	up := runSwarm(t, args...)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-
-	if len(matches) < 1 {
-		t.Fatal("no matches found")
-	}
-	return matches[0]
-}
-
-func checkHashLength(t *testing.T, hash string, encrypted bool) {
-	t.Helper()
-	l := len(hash)
-	if encrypted && l != 128 {
-		t.Errorf("expected hash length 128, got %v", l)
-	}
-	if !encrypted && l != 64 {
-		t.Errorf("expected hash length 64, got %v", l)
-	}
-}
-
-func downloadManifest(t *testing.T, client *swarm.Client, hash string, encrypted bool) (manifest *api.Manifest) {
-	t.Helper()
-	m, isEncrypted, err := client.DownloadManifest(hash)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if encrypted != isEncrypted {
-		t.Error("new manifest encryption flag is not correct")
-	}
-	return m
-}
-
-func checkFile(t *testing.T, client *swarm.Client, hash, path string, expected []byte) {
-	t.Helper()
-	f, err := client.Download(hash, path)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	got, err := ioutil.ReadAll(f)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(got, expected) {
-		t.Errorf("expected file content %q, got %q", expected, got)
-	}
-}

cmd/swarm/mimegen/generator.go

@@ -1,124 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-package main
-
-// Standard "mime" package rely on system-settings, see mime.osInitMime
-// Swarm will run on many OS/Platform/Docker and must behave similar
-// This command generates code to add common mime types based on mime.types file
-//
-// mime.types file provided by mailcap, which follow https://www.iana.org/assignments/media-types/media-types.xhtml
-//
-// Get last version of mime.types file by:
-// docker run --rm -v $(pwd):/tmp alpine:edge /bin/sh -c "apk add -U mailcap; mv /etc/mime.types /tmp"
-
-import (
-	"bufio"
-	"bytes"
-	"flag"
-	"html/template"
-	"io/ioutil"
-	"strings"
-
-	"log"
-)
-
-var (
-	typesFlag   = flag.String("types", "", "Input mime.types file")
-	packageFlag = flag.String("package", "", "Golang package in output file")
-	outFlag     = flag.String("out", "", "Output file name for the generated mime types")
-)
-
-type mime struct {
-	Name string
-	Exts []string
-}
-
-type templateParams struct {
-	PackageName string
-	Mimes       []mime
-}
-
-func main() {
-	// Parse and ensure all needed inputs are specified
-	flag.Parse()
-	if *typesFlag == "" {
-		log.Fatalf("--types is required")
-	}
-	if *packageFlag == "" {
-		log.Fatalf("--types is required")
-	}
-	if *outFlag == "" {
-		log.Fatalf("--out is required")
-	}
-
-	params := templateParams{
-		PackageName: *packageFlag,
-	}
-
-	types, err := ioutil.ReadFile(*typesFlag)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	scanner := bufio.NewScanner(bytes.NewReader(types))
-	for scanner.Scan() {
-		txt := scanner.Text()
-		if strings.HasPrefix(txt, "#") || len(txt) == 0 {
-			continue
-		}
-		parts := strings.Fields(txt)
-		if len(parts) == 1 {
-			continue
-		}
-		params.Mimes = append(params.Mimes, mime{parts[0], parts[1:]})
-	}
-
-	if err = scanner.Err(); err != nil {
-		log.Fatal(err)
-	}
-
-	result := bytes.NewBuffer([]byte{})
-
-	if err := template.Must(template.New("_").Parse(tpl)).Execute(result, params); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := ioutil.WriteFile(*outFlag, result.Bytes(), 0600); err != nil {
-		log.Fatal(err)
-	}
-}
-
-var tpl = `// Code generated by github.com/ubiq/go-ubiq/cmd/swarm/mimegen. DO NOT EDIT.
-
-package {{ .PackageName }}
-
-import "mime"
-func init() {
-	var mimeTypes = map[string]string{
-{{- range .Mimes -}}
-	{{ $name := .Name -}}
-	{{- range .Exts }}
-		".{{ . }}": "{{ $name | html }}",
-	{{- end }}
-{{- end }}
-	}
-	for ext, name := range mimeTypes {
-		if err := mime.AddExtensionType(ext, name); err != nil {
-			panic(err)
-		}
-	}
-}
-`

cmd/swarm/run_test.go

@@ -1,480 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"net"
-	"os"
-	"path"
-	"path/filepath"
-	"runtime"
-	"sync"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/docker/docker/pkg/reexec"
-	"github.com/ubiq/go-ubiq/accounts"
-	"github.com/ubiq/go-ubiq/accounts/keystore"
-	"github.com/ubiq/go-ubiq/internal/cmdtest"
-	"github.com/ubiq/go-ubiq/node"
-	"github.com/ubiq/go-ubiq/p2p"
-	"github.com/ubiq/go-ubiq/rpc"
-	"github.com/ubiq/go-ubiq/swarm"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	swarmhttp "github.com/ubiq/go-ubiq/swarm/api/http"
-)
-
-var loglevel = flag.Int("loglevel", 3, "verbosity of logs")
-
-func init() {
-	// Run the app if we've been exec'd as "swarm-test" in runSwarm.
-	reexec.Register("swarm-test", func() {
-		if err := app.Run(os.Args); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		os.Exit(0)
-	})
-}
-
-const clusterSize = 3
-
-var clusteronce sync.Once
-var cluster *testCluster
-
-func initCluster(t *testing.T) {
-	clusteronce.Do(func() {
-		cluster = newTestCluster(t, clusterSize)
-	})
-}
-
-func serverFunc(api *api.API) swarmhttp.TestServer {
-	return swarmhttp.NewServer(api, "")
-}
-func TestMain(m *testing.M) {
-	// check if we have been reexec'd
-	if reexec.Init() {
-		return
-	}
-	os.Exit(m.Run())
-}
-
-func runSwarm(t *testing.T, args ...string) *cmdtest.TestCmd {
-	tt := cmdtest.NewTestCmd(t, nil)
-
-	// Boot "swarm". This actually runs the test binary but the TestMain
-	// function will prevent any tests from running.
-	tt.Run("swarm-test", args...)
-
-	return tt
-}
-
-type testCluster struct {
-	Nodes  []*testNode
-	TmpDir string
-}
-
-// newTestCluster starts a test swarm cluster of the given size.
-//
-// A temporary directory is created and each node gets a data directory inside
-// it.
-//
-// Each node listens on 127.0.0.1 with random ports for both the HTTP and p2p
-// ports (assigned by first listening on 127.0.0.1:0 and then passing the ports
-// as flags).
-//
-// When starting more than one node, they are connected together using the
-// admin SetPeer RPC method.
-
-func newTestCluster(t *testing.T, size int) *testCluster {
-	cluster := &testCluster{}
-	defer func() {
-		if t.Failed() {
-			cluster.Shutdown()
-		}
-	}()
-
-	tmpdir, err := ioutil.TempDir("", "swarm-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	cluster.TmpDir = tmpdir
-
-	// start the nodes
-	cluster.StartNewNodes(t, size)
-
-	if size == 1 {
-		return cluster
-	}
-
-	// connect the nodes together
-	for _, node := range cluster.Nodes {
-		if err := node.Client.Call(nil, "admin_addPeer", cluster.Nodes[0].Enode); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	// wait until all nodes have the correct number of peers
-outer:
-	for _, node := range cluster.Nodes {
-		var peers []*p2p.PeerInfo
-		for start := time.Now(); time.Since(start) < time.Minute; time.Sleep(50 * time.Millisecond) {
-			if err := node.Client.Call(&peers, "admin_peers"); err != nil {
-				t.Fatal(err)
-			}
-			if len(peers) == len(cluster.Nodes)-1 {
-				continue outer
-			}
-		}
-		t.Fatalf("%s only has %d / %d peers", node.Name, len(peers), len(cluster.Nodes)-1)
-	}
-
-	return cluster
-}
-
-func (c *testCluster) Shutdown() {
-	for _, node := range c.Nodes {
-		node.Shutdown()
-	}
-	os.RemoveAll(c.TmpDir)
-}
-
-func (c *testCluster) Stop() {
-	for _, node := range c.Nodes {
-		node.Shutdown()
-	}
-}
-
-func (c *testCluster) StartNewNodes(t *testing.T, size int) {
-	c.Nodes = make([]*testNode, 0, size)
-	for i := 0; i < size; i++ {
-		dir := filepath.Join(c.TmpDir, fmt.Sprintf("swarm%02d", i))
-		if err := os.Mkdir(dir, 0700); err != nil {
-			t.Fatal(err)
-		}
-
-		node := newTestNode(t, dir)
-		node.Name = fmt.Sprintf("swarm%02d", i)
-
-		c.Nodes = append(c.Nodes, node)
-	}
-}
-
-func (c *testCluster) StartExistingNodes(t *testing.T, size int, bzzaccount string) {
-	c.Nodes = make([]*testNode, 0, size)
-	for i := 0; i < size; i++ {
-		dir := filepath.Join(c.TmpDir, fmt.Sprintf("swarm%02d", i))
-		node := existingTestNode(t, dir, bzzaccount)
-		node.Name = fmt.Sprintf("swarm%02d", i)
-
-		c.Nodes = append(c.Nodes, node)
-	}
-}
-
-func (c *testCluster) Cleanup() {
-	os.RemoveAll(c.TmpDir)
-}
-
-type testNode struct {
-	Name       string
-	Addr       string
-	URL        string
-	Enode      string
-	Dir        string
-	IpcPath    string
-	PrivateKey *ecdsa.PrivateKey
-	Client     *rpc.Client
-	Cmd        *cmdtest.TestCmd
-}
-
-const testPassphrase = "swarm-test-passphrase"
-
-func getTestAccount(t *testing.T, dir string) (conf *node.Config, account accounts.Account) {
-	// create key
-	conf = &node.Config{
-		DataDir: dir,
-		IPCPath: "bzzd.ipc",
-		NoUSB:   true,
-	}
-	n, err := node.New(conf)
-	if err != nil {
-		t.Fatal(err)
-	}
-	account, err = n.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore).NewAccount(testPassphrase)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// use a unique IPCPath when running tests on Windows
-	if runtime.GOOS == "windows" {
-		conf.IPCPath = fmt.Sprintf("bzzd-%s.ipc", account.Address.String())
-	}
-
-	return conf, account
-}
-
-func existingTestNode(t *testing.T, dir string, bzzaccount string) *testNode {
-	conf, _ := getTestAccount(t, dir)
-	node := &testNode{Dir: dir}
-
-	// use a unique IPCPath when running tests on Windows
-	if runtime.GOOS == "windows" {
-		conf.IPCPath = fmt.Sprintf("bzzd-%s.ipc", bzzaccount)
-	}
-
-	// assign ports
-	ports, err := getAvailableTCPPorts(2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p2pPort := ports[0]
-	httpPort := ports[1]
-
-	// start the node
-	node.Cmd = runSwarm(t,
-		"--port", p2pPort,
-		"--nat", "extip:127.0.0.1",
-		"--datadir", dir,
-		"--ipcpath", conf.IPCPath,
-		"--ens-api", "",
-		"--bzzaccount", bzzaccount,
-		"--bzznetworkid", "321",
-		"--bzzport", httpPort,
-		"--verbosity", fmt.Sprint(*loglevel),
-	)
-	node.Cmd.InputLine(testPassphrase)
-	defer func() {
-		if t.Failed() {
-			node.Shutdown()
-		}
-	}()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// ensure that all ports have active listeners
-	// so that the next node will not get the same
-	// when calling getAvailableTCPPorts
-	err = waitTCPPorts(ctx, ports...)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// wait for the node to start
-	for start := time.Now(); time.Since(start) < 10*time.Second; time.Sleep(50 * time.Millisecond) {
-		node.Client, err = rpc.Dial(conf.IPCEndpoint())
-		if err == nil {
-			break
-		}
-	}
-	if node.Client == nil {
-		t.Fatal(err)
-	}
-
-	// load info
-	var info swarm.Info
-	if err := node.Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-	node.Addr = net.JoinHostPort("127.0.0.1", info.Port)
-	node.URL = "http://" + node.Addr
-
-	var nodeInfo p2p.NodeInfo
-	if err := node.Client.Call(&nodeInfo, "admin_nodeInfo"); err != nil {
-		t.Fatal(err)
-	}
-	node.Enode = nodeInfo.Enode
-	node.IpcPath = conf.IPCPath
-	return node
-}
-
-func newTestNode(t *testing.T, dir string) *testNode {
-
-	conf, account := getTestAccount(t, dir)
-	ks := keystore.NewKeyStore(path.Join(dir, "keystore"), 1<<18, 1)
-
-	pk := decryptStoreAccount(ks, account.Address.Hex(), []string{testPassphrase})
-
-	node := &testNode{Dir: dir, PrivateKey: pk}
-
-	// assign ports
-	ports, err := getAvailableTCPPorts(2)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p2pPort := ports[0]
-	httpPort := ports[1]
-
-	// start the node
-	node.Cmd = runSwarm(t,
-		"--port", p2pPort,
-		"--nat", "extip:127.0.0.1",
-		"--datadir", dir,
-		"--ipcpath", conf.IPCPath,
-		"--ens-api", "",
-		"--bzzaccount", account.Address.String(),
-		"--bzznetworkid", "321",
-		"--bzzport", httpPort,
-		"--verbosity", fmt.Sprint(*loglevel),
-	)
-	node.Cmd.InputLine(testPassphrase)
-	defer func() {
-		if t.Failed() {
-			node.Shutdown()
-		}
-	}()
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// ensure that all ports have active listeners
-	// so that the next node will not get the same
-	// when calling getAvailableTCPPorts
-	err = waitTCPPorts(ctx, ports...)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// wait for the node to start
-	for start := time.Now(); time.Since(start) < 10*time.Second; time.Sleep(50 * time.Millisecond) {
-		node.Client, err = rpc.Dial(conf.IPCEndpoint())
-		if err == nil {
-			break
-		}
-	}
-	if node.Client == nil {
-		t.Fatal(err)
-	}
-
-	// load info
-	var info swarm.Info
-	if err := node.Client.Call(&info, "bzz_info"); err != nil {
-		t.Fatal(err)
-	}
-	node.Addr = net.JoinHostPort("127.0.0.1", info.Port)
-	node.URL = "http://" + node.Addr
-
-	var nodeInfo p2p.NodeInfo
-	if err := node.Client.Call(&nodeInfo, "admin_nodeInfo"); err != nil {
-		t.Fatal(err)
-	}
-	node.Enode = nodeInfo.Enode
-	node.IpcPath = conf.IPCPath
-	return node
-}
-
-func (n *testNode) Shutdown() {
-	if n.Cmd != nil {
-		n.Cmd.Kill()
-	}
-}
-
-// getAvailableTCPPorts returns a set of ports that
-// nothing is listening on at the time.
-//
-// Function assignTCPPort cannot be called in sequence
-// and guardantee that the same port will be returned in
-// different calls as the listener is closed within the function,
-// not after all listeners are started and selected unique
-// available ports.
-func getAvailableTCPPorts(count int) (ports []string, err error) {
-	for i := 0; i < count; i++ {
-		l, err := net.Listen("tcp", "127.0.0.1:0")
-		if err != nil {
-			return nil, err
-		}
-		// defer close in the loop to be sure the same port will not
-		// be selected in the next iteration
-		defer l.Close()
-
-		_, port, err := net.SplitHostPort(l.Addr().String())
-		if err != nil {
-			return nil, err
-		}
-		ports = append(ports, port)
-	}
-	return ports, nil
-}
-
-// waitTCPPorts blocks until tcp connections can be
-// established on all provided ports. It runs all
-// ports dialers in parallel, and returns the first
-// encountered error.
-// See waitTCPPort also.
-func waitTCPPorts(ctx context.Context, ports ...string) error {
-	var err error
-	// mu locks err variable that is assigned in
-	// other goroutines
-	var mu sync.Mutex
-
-	// cancel is canceling all goroutines
-	// when the firs error is returned
-	// to prevent unnecessary waiting
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	var wg sync.WaitGroup
-	for _, port := range ports {
-		wg.Add(1)
-		go func(port string) {
-			defer wg.Done()
-
-			e := waitTCPPort(ctx, port)
-
-			mu.Lock()
-			defer mu.Unlock()
-			if e != nil && err == nil {
-				err = e
-				cancel()
-			}
-		}(port)
-	}
-	wg.Wait()
-
-	return err
-}
-
-// waitTCPPort blocks until tcp connection can be established
-// ona provided port. It has a 3 minute timeout as maximum,
-// to prevent long waiting, but it can be shortened with
-// a provided context instance. Dialer has a 10 second timeout
-// in every iteration, and connection refused error will be
-// retried in 100 milliseconds periods.
-func waitTCPPort(ctx context.Context, port string) error {
-	ctx, cancel := context.WithTimeout(ctx, 3*time.Minute)
-	defer cancel()
-
-	for {
-		c, err := (&net.Dialer{Timeout: 10 * time.Second}).DialContext(ctx, "tcp", "127.0.0.1:"+port)
-		if err != nil {
-			if operr, ok := err.(*net.OpError); ok {
-				if syserr, ok := operr.Err.(*os.SyscallError); ok && syserr.Err == syscall.ECONNREFUSED {
-					time.Sleep(100 * time.Millisecond)
-					continue
-				}
-			}
-			return err
-		}
-		return c.Close()
-	}
-}

cmd/swarm/swarm-smoke/feed_upload_and_sync.go

@@ -1,291 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"crypto/md5"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/ubiq/go-ubiq/common/hexutil"
-	"github.com/ubiq/go-ubiq/crypto"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/metrics"
-	"github.com/ubiq/go-ubiq/swarm/storage/feed"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-	"github.com/pborman/uuid"
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-const (
-	feedRandomDataLength = 8
-)
-
-func feedUploadAndSyncCmd(ctx *cli.Context, tuid string) error {
-	errc := make(chan error)
-
-	go func() {
-		errc <- feedUploadAndSync(ctx, tuid)
-	}()
-
-	select {
-	case err := <-errc:
-		if err != nil {
-			metrics.GetOrRegisterCounter(fmt.Sprintf("%s.fail", commandName), nil).Inc(1)
-		}
-		return err
-	case <-time.After(time.Duration(timeout) * time.Second):
-		metrics.GetOrRegisterCounter(fmt.Sprintf("%s.timeout", commandName), nil).Inc(1)
-
-		return fmt.Errorf("timeout after %v sec", timeout)
-	}
-}
-
-func feedUploadAndSync(c *cli.Context, tuid string) error {
-	log.Info("generating and uploading feeds to " + httpEndpoint(hosts[0]) + " and syncing")
-
-	// create a random private key to sign updates with and derive the address
-	pkFile, err := ioutil.TempFile("", "swarm-feed-smoke-test")
-	if err != nil {
-		return err
-	}
-	defer pkFile.Close()
-	defer os.Remove(pkFile.Name())
-
-	privkeyHex := "0000000000000000000000000000000000000000000000000000000000001976"
-	privKey, err := crypto.HexToECDSA(privkeyHex)
-	if err != nil {
-		return err
-	}
-	user := crypto.PubkeyToAddress(privKey.PublicKey)
-	userHex := hexutil.Encode(user.Bytes())
-
-	// save the private key to a file
-	_, err = io.WriteString(pkFile, privkeyHex)
-	if err != nil {
-		return err
-	}
-
-	// keep hex strings for topic and subtopic
-	var topicHex string
-	var subTopicHex string
-
-	// and create combination hex topics for bzz-feed retrieval
-	// xor'ed with topic (zero-value topic if no topic)
-	var subTopicOnlyHex string
-	var mergedSubTopicHex string
-
-	// generate random topic and subtopic and put a hex on them
-	topicBytes, err := generateRandomData(feed.TopicLength)
-	topicHex = hexutil.Encode(topicBytes)
-	subTopicBytes, err := generateRandomData(8)
-	subTopicHex = hexutil.Encode(subTopicBytes)
-	if err != nil {
-		return err
-	}
-	mergedSubTopic, err := feed.NewTopic(subTopicHex, topicBytes)
-	if err != nil {
-		return err
-	}
-	mergedSubTopicHex = hexutil.Encode(mergedSubTopic[:])
-	subTopicOnlyBytes, err := feed.NewTopic(subTopicHex, nil)
-	if err != nil {
-		return err
-	}
-	subTopicOnlyHex = hexutil.Encode(subTopicOnlyBytes[:])
-
-	// create feed manifest, topic only
-	var out bytes.Buffer
-	cmd := exec.Command("swarm", "--bzzapi", httpEndpoint(hosts[0]), "feed", "create", "--topic", topicHex, "--user", userHex)
-	cmd.Stdout = &out
-	log.Debug("create feed manifest topic cmd", "cmd", cmd)
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	manifestWithTopic := strings.TrimRight(out.String(), string([]byte{0x0a}))
-	if len(manifestWithTopic) != 64 {
-		return fmt.Errorf("unknown feed create manifest hash format (topic): (%d) %s", len(out.String()), manifestWithTopic)
-	}
-	log.Debug("create topic feed", "manifest", manifestWithTopic)
-	out.Reset()
-
-	// create feed manifest, subtopic only
-	cmd = exec.Command("swarm", "--bzzapi", httpEndpoint(hosts[0]), "feed", "create", "--name", subTopicHex, "--user", userHex)
-	cmd.Stdout = &out
-	log.Debug("create feed manifest subtopic cmd", "cmd", cmd)
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	manifestWithSubTopic := strings.TrimRight(out.String(), string([]byte{0x0a}))
-	if len(manifestWithSubTopic) != 64 {
-		return fmt.Errorf("unknown feed create manifest hash format (subtopic): (%d) %s", len(out.String()), manifestWithSubTopic)
-	}
-	log.Debug("create subtopic feed", "manifest", manifestWithTopic)
-	out.Reset()
-
-	// create feed manifest, merged topic
-	cmd = exec.Command("swarm", "--bzzapi", httpEndpoint(hosts[0]), "feed", "create", "--topic", topicHex, "--name", subTopicHex, "--user", userHex)
-	cmd.Stdout = &out
-	log.Debug("create feed manifest mergetopic cmd", "cmd", cmd)
-	err = cmd.Run()
-	if err != nil {
-		log.Error(err.Error())
-		return err
-	}
-	manifestWithMergedTopic := strings.TrimRight(out.String(), string([]byte{0x0a}))
-	if len(manifestWithMergedTopic) != 64 {
-		return fmt.Errorf("unknown feed create manifest hash format (mergedtopic): (%d) %s", len(out.String()), manifestWithMergedTopic)
-	}
-	log.Debug("create mergedtopic feed", "manifest", manifestWithMergedTopic)
-	out.Reset()
-
-	// create test data
-	data, err := generateRandomData(feedRandomDataLength)
-	if err != nil {
-		return err
-	}
-	h := md5.New()
-	h.Write(data)
-	dataHash := h.Sum(nil)
-	dataHex := hexutil.Encode(data)
-
-	// update with topic
-	cmd = exec.Command("swarm", "--bzzaccount", pkFile.Name(), "--bzzapi", httpEndpoint(hosts[0]), "feed", "update", "--topic", topicHex, dataHex)
-	cmd.Stdout = &out
-	log.Debug("update feed manifest topic cmd", "cmd", cmd)
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	log.Debug("feed update topic", "out", out)
-	out.Reset()
-
-	// update with subtopic
-	cmd = exec.Command("swarm", "--bzzaccount", pkFile.Name(), "--bzzapi", httpEndpoint(hosts[0]), "feed", "update", "--name", subTopicHex, dataHex)
-	cmd.Stdout = &out
-	log.Debug("update feed manifest subtopic cmd", "cmd", cmd)
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	log.Debug("feed update subtopic", "out", out)
-	out.Reset()
-
-	// update with merged topic
-	cmd = exec.Command("swarm", "--bzzaccount", pkFile.Name(), "--bzzapi", httpEndpoint(hosts[0]), "feed", "update", "--topic", topicHex, "--name", subTopicHex, dataHex)
-	cmd.Stdout = &out
-	log.Debug("update feed manifest merged topic cmd", "cmd", cmd)
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	log.Debug("feed update mergedtopic", "out", out)
-	out.Reset()
-
-	time.Sleep(3 * time.Second)
-
-	// retrieve the data
-	wg := sync.WaitGroup{}
-	for _, host := range hosts {
-		// raw retrieve, topic only
-		for _, hex := range []string{topicHex, subTopicOnlyHex, mergedSubTopicHex} {
-			wg.Add(1)
-			ruid := uuid.New()[:8]
-			go func(hex string, endpoint string, ruid string) {
-				for {
-					err := fetchFeed(hex, userHex, httpEndpoint(host), dataHash, ruid)
-					if err != nil {
-						continue
-					}
-
-					wg.Done()
-					return
-				}
-			}(hex, httpEndpoint(host), ruid)
-		}
-	}
-	wg.Wait()
-	log.Info("all endpoints synced random data successfully")
-
-	// upload test file
-	log.Info("feed uploading to "+httpEndpoint(hosts[0])+" and syncing", "seed", seed)
-
-	randomBytes := testutil.RandomBytes(seed, filesize*1000)
-
-	hash, err := upload(randomBytes, httpEndpoint(hosts[0]))
-	if err != nil {
-		return err
-	}
-	hashBytes, err := hexutil.Decode("0x" + hash)
-	if err != nil {
-		return err
-	}
-	multihashHex := hexutil.Encode(hashBytes)
-	fileHash := h.Sum(nil)
-
-	log.Info("uploaded successfully", "hash", hash, "digest", fmt.Sprintf("%x", fileHash))
-
-	// update file with topic
-	cmd = exec.Command("swarm", "--bzzaccount", pkFile.Name(), "--bzzapi", httpEndpoint(hosts[0]), "feed", "update", "--topic", topicHex, multihashHex)
-	cmd.Stdout = &out
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	log.Debug("feed update topic", "out", out)
-	out.Reset()
-
-	// update file with subtopic
-	cmd = exec.Command("swarm", "--bzzaccount", pkFile.Name(), "--bzzapi", httpEndpoint(hosts[0]), "feed", "update", "--name", subTopicHex, multihashHex)
-	cmd.Stdout = &out
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	log.Debug("feed update subtopic", "out", out)
-	out.Reset()
-
-	// update file with merged topic
-	cmd = exec.Command("swarm", "--bzzaccount", pkFile.Name(), "--bzzapi", httpEndpoint(hosts[0]), "feed", "update", "--topic", topicHex, "--name", subTopicHex, multihashHex)
-	cmd.Stdout = &out
-	err = cmd.Run()
-	if err != nil {
-		return err
-	}
-	log.Debug("feed update mergedtopic", "out", out)
-	out.Reset()
-
-	time.Sleep(3 * time.Second)
-
-	for _, host := range hosts {
-
-		// manifest retrieve, topic only
-		for _, url := range []string{manifestWithTopic, manifestWithSubTopic, manifestWithMergedTopic} {
-			wg.Add(1)
-			ruid := uuid.New()[:8]
-			go func(url string, endpoint string, ruid string) {
-				for {
-					err := fetch(url, endpoint, fileHash, ruid, "")
-					if err != nil {
-						continue
-					}
-
-					wg.Done()
-					return
-				}
-			}(url, httpEndpoint(host), ruid)
-		}
-
-	}
-	wg.Wait()
-	log.Info("all endpoints synced random file successfully")
-
-	return nil
-}

cmd/swarm/swarm-smoke/main.go

@@ -1,190 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"sort"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	gubiqmetrics "github.com/ubiq/go-ubiq/metrics"
-	"github.com/ubiq/go-ubiq/metrics/influxdb"
-	swarmmetrics "github.com/ubiq/go-ubiq/swarm/metrics"
-	"github.com/ubiq/go-ubiq/swarm/tracing"
-
-	"github.com/ubiq/go-ubiq/log"
-
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-var (
-	gitCommit string // Git SHA1 commit hash of the release (set via linker flags)
-)
-
-var (
-	allhosts     string
-	hosts        []string
-	filesize     int
-	syncDelay    int
-	httpPort     int
-	wsPort       int
-	verbosity    int
-	timeout      int
-	single       bool
-	trackTimeout int
-)
-
-func main() {
-
-	app := cli.NewApp()
-	app.Name = "smoke-test"
-	app.Usage = ""
-
-	app.Flags = []cli.Flag{
-		cli.StringFlag{
-			Name:        "hosts",
-			Value:       "",
-			Usage:       "comma-separated list of swarm hosts",
-			Destination: &allhosts,
-		},
-		cli.IntFlag{
-			Name:        "http-port",
-			Value:       80,
-			Usage:       "http port",
-			Destination: &httpPort,
-		},
-		cli.IntFlag{
-			Name:        "ws-port",
-			Value:       8546,
-			Usage:       "ws port",
-			Destination: &wsPort,
-		},
-		cli.IntFlag{
-			Name:        "filesize",
-			Value:       1024,
-			Usage:       "file size for generated random file in KB",
-			Destination: &filesize,
-		},
-		cli.IntFlag{
-			Name:        "sync-delay",
-			Value:       5,
-			Usage:       "duration of delay in seconds to wait for content to be synced",
-			Destination: &syncDelay,
-		},
-		cli.IntFlag{
-			Name:        "verbosity",
-			Value:       1,
-			Usage:       "verbosity",
-			Destination: &verbosity,
-		},
-		cli.IntFlag{
-			Name:        "timeout",
-			Value:       120,
-			Usage:       "timeout in seconds after which kill the process",
-			Destination: &timeout,
-		},
-		cli.BoolFlag{
-			Name:        "single",
-			Usage:       "whether to fetch content from a single node or from all nodes",
-			Destination: &single,
-		},
-		cli.IntFlag{
-			Name:        "track-timeout",
-			Value:       5,
-			Usage:       "timeout in seconds to wait for GetAllReferences to return",
-			Destination: &trackTimeout,
-		},
-	}
-
-	app.Flags = append(app.Flags, []cli.Flag{
-		utils.MetricsEnabledFlag,
-		swarmmetrics.MetricsInfluxDBEndpointFlag,
-		swarmmetrics.MetricsInfluxDBDatabaseFlag,
-		swarmmetrics.MetricsInfluxDBUsernameFlag,
-		swarmmetrics.MetricsInfluxDBPasswordFlag,
-		swarmmetrics.MetricsInfluxDBTagsFlag,
-	}...)
-
-	app.Flags = append(app.Flags, tracing.Flags...)
-
-	app.Commands = []cli.Command{
-		{
-			Name:    "upload_and_sync",
-			Aliases: []string{"c"},
-			Usage:   "upload and sync",
-			Action:  wrapCliCommand("upload-and-sync", uploadAndSyncCmd),
-		},
-		{
-			Name:    "feed_sync",
-			Aliases: []string{"f"},
-			Usage:   "feed update generate, upload and sync",
-			Action:  wrapCliCommand("feed-and-sync", feedUploadAndSyncCmd),
-		},
-		{
-			Name:    "upload_speed",
-			Aliases: []string{"u"},
-			Usage:   "measure upload speed",
-			Action:  wrapCliCommand("upload-speed", uploadSpeedCmd),
-		},
-		{
-			Name:    "sliding_window",
-			Aliases: []string{"s"},
-			Usage:   "measure network aggregate capacity",
-			Action:  wrapCliCommand("sliding-window", slidingWindowCmd),
-		},
-	}
-
-	sort.Sort(cli.FlagsByName(app.Flags))
-	sort.Sort(cli.CommandsByName(app.Commands))
-
-	app.Before = func(ctx *cli.Context) error {
-		tracing.Setup(ctx)
-		return nil
-	}
-
-	app.After = func(ctx *cli.Context) error {
-		return emitMetrics(ctx)
-	}
-
-	err := app.Run(os.Args)
-	if err != nil {
-		log.Error(err.Error())
-
-		os.Exit(1)
-	}
-}
-
-func emitMetrics(ctx *cli.Context) error {
-	if gubiqmetrics.Enabled {
-		var (
-			endpoint = ctx.GlobalString(swarmmetrics.MetricsInfluxDBEndpointFlag.Name)
-			database = ctx.GlobalString(swarmmetrics.MetricsInfluxDBDatabaseFlag.Name)
-			username = ctx.GlobalString(swarmmetrics.MetricsInfluxDBUsernameFlag.Name)
-			password = ctx.GlobalString(swarmmetrics.MetricsInfluxDBPasswordFlag.Name)
-			tags     = ctx.GlobalString(swarmmetrics.MetricsInfluxDBTagsFlag.Name)
-		)
-
-		tagsMap := utils.SplitTagsFlag(tags)
-		tagsMap["version"] = gitCommit
-		tagsMap["filesize"] = fmt.Sprintf("%v", filesize)
-
-		return influxdb.InfluxDBWithTagsOnce(gubiqmetrics.DefaultRegistry, endpoint, database, username, password, "swarm-smoke.", tagsMap)
-	}
-
-	return nil
-}

cmd/swarm/swarm-smoke/sliding_window.go

@@ -1,131 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"math/rand"
-	"time"
-
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/metrics"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-	"github.com/pborman/uuid"
-
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-type uploadResult struct {
-	hash   string
-	digest []byte
-}
-
-func slidingWindowCmd(ctx *cli.Context, tuid string) error {
-	errc := make(chan error)
-
-	go func() {
-		errc <- slidingWindow(ctx, tuid)
-	}()
-
-	select {
-	case err := <-errc:
-		if err != nil {
-			metrics.GetOrRegisterCounter(fmt.Sprintf("%s.fail", commandName), nil).Inc(1)
-		}
-		return err
-	case <-time.After(time.Duration(timeout) * time.Second):
-		metrics.GetOrRegisterCounter(fmt.Sprintf("%s.timeout", commandName), nil).Inc(1)
-
-		return fmt.Errorf("timeout after %v sec", timeout)
-	}
-}
-
-func slidingWindow(ctx *cli.Context, tuid string) error {
-	hashes := []uploadResult{} //swarm hashes of the uploads
-	nodes := len(hosts)
-	const iterationTimeout = 30 * time.Second
-	log.Info("sliding window test started", "tuid", tuid, "nodes", nodes, "filesize(kb)", filesize, "timeout", timeout)
-	uploadedBytes := 0
-	networkDepth := 0
-	errored := false
-
-outer:
-	for {
-		log.Info("uploading to "+httpEndpoint(hosts[0])+" and syncing", "seed", seed)
-
-		t1 := time.Now()
-
-		randomBytes := testutil.RandomBytes(seed, filesize*1000)
-
-		hash, err := upload(randomBytes, httpEndpoint(hosts[0]))
-		if err != nil {
-			log.Error(err.Error())
-			return err
-		}
-
-		metrics.GetOrRegisterResettingTimer("sliding-window.upload-time", nil).UpdateSince(t1)
-
-		fhash, err := digest(bytes.NewReader(randomBytes))
-		if err != nil {
-			log.Error(err.Error())
-			return err
-		}
-
-		log.Info("uploaded successfully", "hash", hash, "digest", fmt.Sprintf("%x", fhash), "sleeping", syncDelay)
-		hashes = append(hashes, uploadResult{hash: hash, digest: fhash})
-		time.Sleep(time.Duration(syncDelay) * time.Second)
-		uploadedBytes += filesize * 1000
-
-		for i, v := range hashes {
-			timeout := time.After(time.Duration(timeout) * time.Second)
-			errored = false
-
-		inner:
-			for {
-				select {
-				case <-timeout:
-					errored = true
-					log.Error("error retrieving hash. timeout", "hash idx", i, "err", err)
-					metrics.GetOrRegisterCounter("sliding-window.single.error", nil).Inc(1)
-					break inner
-				default:
-					idx := 1 + rand.Intn(len(hosts)-1)
-					ruid := uuid.New()[:8]
-					start := time.Now()
-					err := fetch(v.hash, httpEndpoint(hosts[idx]), v.digest, ruid, "")
-					if err != nil {
-						continue inner
-					}
-					metrics.GetOrRegisterResettingTimer("sliding-window.single.fetch-time", nil).UpdateSince(start)
-					break inner
-				}
-			}
-
-			if errored {
-				break outer
-			}
-			networkDepth = i
-			metrics.GetOrRegisterGauge("sliding-window.network-depth", nil).Update(int64(networkDepth))
-		}
-	}
-
-	log.Info("sliding window test finished", "errored?", errored, "networkDepth", networkDepth, "networkDepth(kb)", networkDepth*filesize)
-	log.Info("stats", "uploadedFiles", len(hashes), "uploadedKb", uploadedBytes/1000, "filesizeKb", filesize)
-
-	return nil
-}

cmd/swarm/swarm-smoke/upload_and_sync.go

@@ -1,194 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/metrics"
-	"github.com/ubiq/go-ubiq/rpc"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	"github.com/ubiq/go-ubiq/swarm/storage"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-	"github.com/pborman/uuid"
-
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-func uploadAndSyncCmd(ctx *cli.Context, tuid string) error {
-	randomBytes := testutil.RandomBytes(seed, filesize*1000)
-
-	errc := make(chan error)
-
-	go func() {
-		errc <- uplaodAndSync(ctx, randomBytes, tuid)
-	}()
-
-	select {
-	case err := <-errc:
-		if err != nil {
-			metrics.GetOrRegisterCounter(fmt.Sprintf("%s.fail", commandName), nil).Inc(1)
-		}
-		return err
-	case <-time.After(time.Duration(timeout) * time.Second):
-		metrics.GetOrRegisterCounter(fmt.Sprintf("%s.timeout", commandName), nil).Inc(1)
-
-		e := fmt.Errorf("timeout after %v sec", timeout)
-		// trigger debug functionality on randomBytes
-		err := trackChunks(randomBytes[:])
-		if err != nil {
-			e = fmt.Errorf("%v; triggerChunkDebug failed: %v", e, err)
-		}
-
-		return e
-	}
-}
-
-func trackChunks(testData []byte) error {
-	log.Warn("Test timed out; running chunk debug sequence")
-
-	addrs, err := getAllRefs(testData)
-	if err != nil {
-		return err
-	}
-	log.Trace("All references retrieved")
-
-	// has-chunks
-	for _, host := range hosts {
-		httpHost := fmt.Sprintf("ws://%s:%d", host, 8546)
-		log.Trace("Calling `Has` on host", "httpHost", httpHost)
-		rpcClient, err := rpc.Dial(httpHost)
-		if err != nil {
-			log.Trace("Error dialing host", "err", err)
-			return err
-		}
-		log.Trace("rpc dial ok")
-		var hasInfo []api.HasInfo
-		err = rpcClient.Call(&hasInfo, "bzz_has", addrs)
-		if err != nil {
-			log.Trace("Error calling host", "err", err)
-			return err
-		}
-		log.Trace("rpc call ok")
-		count := 0
-		for _, info := range hasInfo {
-			if !info.Has {
-				count++
-				log.Error("Host does not have chunk", "host", httpHost, "chunk", info.Addr)
-			}
-		}
-		if count == 0 {
-			log.Info("Host reported to have all chunks", "host", httpHost)
-		}
-	}
-	return nil
-}
-
-func getAllRefs(testData []byte) (storage.AddressCollection, error) {
-	log.Trace("Getting all references for given root hash")
-	datadir, err := ioutil.TempDir("", "chunk-debug")
-	if err != nil {
-		return nil, fmt.Errorf("unable to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(datadir)
-	fileStore, err := storage.NewLocalFileStore(datadir, make([]byte, 32))
-	if err != nil {
-		return nil, err
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(trackTimeout)*time.Second)
-	defer cancel()
-
-	reader := bytes.NewReader(testData)
-	return fileStore.GetAllReferences(ctx, reader, false)
-}
-
-func uplaodAndSync(c *cli.Context, randomBytes []byte, tuid string) error {
-	log.Info("uploading to "+httpEndpoint(hosts[0])+" and syncing", "tuid", tuid, "seed", seed)
-
-	t1 := time.Now()
-	hash, err := upload(randomBytes, httpEndpoint(hosts[0]))
-	if err != nil {
-		log.Error(err.Error())
-		return err
-	}
-	t2 := time.Since(t1)
-	metrics.GetOrRegisterResettingTimer("upload-and-sync.upload-time", nil).Update(t2)
-
-	fhash, err := digest(bytes.NewReader(randomBytes))
-	if err != nil {
-		log.Error(err.Error())
-		return err
-	}
-
-	log.Info("uploaded successfully", "tuid", tuid, "hash", hash, "took", t2, "digest", fmt.Sprintf("%x", fhash))
-
-	time.Sleep(time.Duration(syncDelay) * time.Second)
-
-	wg := sync.WaitGroup{}
-	if single {
-		randIndex := 1 + rand.Intn(len(hosts)-1)
-		ruid := uuid.New()[:8]
-		wg.Add(1)
-		go func(endpoint string, ruid string) {
-			for {
-				start := time.Now()
-				err := fetch(hash, endpoint, fhash, ruid, tuid)
-				if err != nil {
-					continue
-				}
-				ended := time.Since(start)
-
-				metrics.GetOrRegisterResettingTimer("upload-and-sync.single.fetch-time", nil).Update(ended)
-				log.Info("fetch successful", "tuid", tuid, "ruid", ruid, "took", ended, "endpoint", endpoint)
-				wg.Done()
-				return
-			}
-		}(httpEndpoint(hosts[randIndex]), ruid)
-	} else {
-		for _, endpoint := range hosts[1:] {
-			ruid := uuid.New()[:8]
-			wg.Add(1)
-			go func(endpoint string, ruid string) {
-				for {
-					start := time.Now()
-					err := fetch(hash, endpoint, fhash, ruid, tuid)
-					if err != nil {
-						continue
-					}
-					ended := time.Since(start)
-
-					metrics.GetOrRegisterResettingTimer("upload-and-sync.each.fetch-time", nil).Update(ended)
-					log.Info("fetch successful", "tuid", tuid, "ruid", ruid, "took", ended, "endpoint", endpoint)
-					wg.Done()
-					return
-				}
-			}(httpEndpoint(endpoint), ruid)
-		}
-	}
-	wg.Wait()
-	log.Info("all hosts synced random file successfully")
-
-	return nil
-}

cmd/swarm/swarm-smoke/upload_speed.go

@@ -1,73 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"time"
-
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/metrics"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-func uploadSpeedCmd(ctx *cli.Context, tuid string) error {
-	log.Info("uploading to "+hosts[0], "tuid", tuid, "seed", seed)
-	randomBytes := testutil.RandomBytes(seed, filesize*1000)
-
-	errc := make(chan error)
-
-	go func() {
-		errc <- uploadSpeed(ctx, tuid, randomBytes)
-	}()
-
-	select {
-	case err := <-errc:
-		if err != nil {
-			metrics.GetOrRegisterCounter(fmt.Sprintf("%s.fail", commandName), nil).Inc(1)
-		}
-		return err
-	case <-time.After(time.Duration(timeout) * time.Second):
-		metrics.GetOrRegisterCounter(fmt.Sprintf("%s.timeout", commandName), nil).Inc(1)
-
-		// trigger debug functionality on randomBytes
-
-		return fmt.Errorf("timeout after %v sec", timeout)
-	}
-}
-
-func uploadSpeed(c *cli.Context, tuid string, data []byte) error {
-	t1 := time.Now()
-	hash, err := upload(data, hosts[0])
-	if err != nil {
-		log.Error(err.Error())
-		return err
-	}
-	metrics.GetOrRegisterCounter("upload-speed.upload-time", nil).Inc(int64(time.Since(t1)))
-
-	fhash, err := digest(bytes.NewReader(data))
-	if err != nil {
-		log.Error(err.Error())
-		return err
-	}
-
-	log.Info("uploaded successfully", "hash", hash, "digest", fmt.Sprintf("%x", fhash))
-	return nil
-}

cmd/swarm/swarm-smoke/util.go

@@ -1,235 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"context"
-	"crypto/md5"
-	crand "crypto/rand"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math/rand"
-	"net/http"
-	"net/http/httptrace"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/metrics"
-	"github.com/ubiq/go-ubiq/swarm/api"
-	"github.com/ubiq/go-ubiq/swarm/api/client"
-	"github.com/ubiq/go-ubiq/swarm/spancontext"
-	opentracing "github.com/opentracing/opentracing-go"
-	"github.com/pborman/uuid"
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-var (
-	commandName = ""
-	seed        = int(time.Now().UTC().UnixNano())
-)
-
-func init() {
-	rand.Seed(int64(seed))
-}
-
-func httpEndpoint(host string) string {
-	return fmt.Sprintf("http://%s:%d", host, httpPort)
-}
-
-func wsEndpoint(host string) string {
-	return fmt.Sprintf("ws://%s:%d", host, wsPort)
-}
-
-func wrapCliCommand(name string, command func(*cli.Context, string) error) func(*cli.Context) error {
-	return func(ctx *cli.Context) error {
-		log.PrintOrigins(true)
-		log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(verbosity), log.StreamHandler(os.Stdout, log.TerminalFormat(false))))
-
-		// test uuid
-		tuid := uuid.New()[:8]
-
-		commandName = name
-
-		hosts = strings.Split(allhosts, ",")
-
-		defer func(now time.Time) {
-			totalTime := time.Since(now)
-			log.Info("total time", "tuid", tuid, "time", totalTime, "kb", filesize)
-			metrics.GetOrRegisterResettingTimer(name+".total-time", nil).Update(totalTime)
-		}(time.Now())
-
-		log.Info("smoke test starting", "tuid", tuid, "task", name, "timeout", timeout)
-		metrics.GetOrRegisterCounter(name, nil).Inc(1)
-
-		return command(ctx, tuid)
-	}
-}
-
-func fetchFeed(topic string, user string, endpoint string, original []byte, ruid string) error {
-	ctx, sp := spancontext.StartSpan(context.Background(), "feed-and-sync.fetch")
-	defer sp.Finish()
-
-	log.Trace("sleeping", "ruid", ruid)
-	time.Sleep(3 * time.Second)
-
-	log.Trace("http get request (feed)", "ruid", ruid, "api", endpoint, "topic", topic, "user", user)
-
-	var tn time.Time
-	reqUri := endpoint + "/bzz-feed:/?topic=" + topic + "&user=" + user
-	req, _ := http.NewRequest("GET", reqUri, nil)
-
-	opentracing.GlobalTracer().Inject(
-		sp.Context(),
-		opentracing.HTTPHeaders,
-		opentracing.HTTPHeadersCarrier(req.Header))
-
-	trace := client.GetClientTrace("feed-and-sync - http get", "feed-and-sync", ruid, &tn)
-
-	req = req.WithContext(httptrace.WithClientTrace(ctx, trace))
-	transport := http.DefaultTransport
-
-	//transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-
-	tn = time.Now()
-	res, err := transport.RoundTrip(req)
-	if err != nil {
-		log.Error(err.Error(), "ruid", ruid)
-		return err
-	}
-
-	log.Trace("http get response (feed)", "ruid", ruid, "api", endpoint, "topic", topic, "user", user, "code", res.StatusCode, "len", res.ContentLength)
-
-	if res.StatusCode != 200 {
-		return fmt.Errorf("expected status code %d, got %v (ruid %v)", 200, res.StatusCode, ruid)
-	}
-
-	defer res.Body.Close()
-
-	rdigest, err := digest(res.Body)
-	if err != nil {
-		log.Warn(err.Error(), "ruid", ruid)
-		return err
-	}
-
-	if !bytes.Equal(rdigest, original) {
-		err := fmt.Errorf("downloaded imported file md5=%x is not the same as the generated one=%x", rdigest, original)
-		log.Warn(err.Error(), "ruid", ruid)
-		return err
-	}
-
-	log.Trace("downloaded file matches random file", "ruid", ruid, "len", res.ContentLength)
-
-	return nil
-}
-
-// fetch is getting the requested `hash` from the `endpoint` and compares it with the `original` file
-func fetch(hash string, endpoint string, original []byte, ruid string, tuid string) error {
-	ctx, sp := spancontext.StartSpan(context.Background(), "upload-and-sync.fetch")
-	defer sp.Finish()
-
-	log.Info("http get request", "tuid", tuid, "ruid", ruid, "endpoint", endpoint, "hash", hash)
-
-	var tn time.Time
-	reqUri := endpoint + "/bzz:/" + hash + "/"
-	req, _ := http.NewRequest("GET", reqUri, nil)
-
-	opentracing.GlobalTracer().Inject(
-		sp.Context(),
-		opentracing.HTTPHeaders,
-		opentracing.HTTPHeadersCarrier(req.Header))
-
-	trace := client.GetClientTrace(commandName+" - http get", commandName, ruid, &tn)
-
-	req = req.WithContext(httptrace.WithClientTrace(ctx, trace))
-	transport := http.DefaultTransport
-
-	//transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-
-	tn = time.Now()
-	res, err := transport.RoundTrip(req)
-	if err != nil {
-		log.Error(err.Error(), "ruid", ruid)
-		return err
-	}
-	log.Info("http get response", "tuid", tuid, "ruid", ruid, "endpoint", endpoint, "hash", hash, "code", res.StatusCode, "len", res.ContentLength)
-
-	if res.StatusCode != 200 {
-		err := fmt.Errorf("expected status code %d, got %v", 200, res.StatusCode)
-		log.Warn(err.Error(), "ruid", ruid)
-		return err
-	}
-
-	defer res.Body.Close()
-
-	rdigest, err := digest(res.Body)
-	if err != nil {
-		log.Warn(err.Error(), "ruid", ruid)
-		return err
-	}
-
-	if !bytes.Equal(rdigest, original) {
-		err := fmt.Errorf("downloaded imported file md5=%x is not the same as the generated one=%x", rdigest, original)
-		log.Warn(err.Error(), "ruid", ruid)
-		return err
-	}
-
-	log.Trace("downloaded file matches random file", "ruid", ruid, "len", res.ContentLength)
-
-	return nil
-}
-
-// upload an arbitrary byte as a plaintext file  to `endpoint` using the api client
-func upload(data []byte, endpoint string) (string, error) {
-	swarm := client.NewClient(endpoint)
-	f := &client.File{
-		ReadCloser: ioutil.NopCloser(bytes.NewReader(data)),
-		ManifestEntry: api.ManifestEntry{
-			ContentType: "text/plain",
-			Mode:        0660,
-			Size:        int64(len(data)),
-		},
-	}
-
-	// upload data to bzz:// and retrieve the content-addressed manifest hash, hex-encoded.
-	return swarm.Upload(f, "", false)
-}
-
-func digest(r io.Reader) ([]byte, error) {
-	h := md5.New()
-	_, err := io.Copy(h, r)
-	if err != nil {
-		return nil, err
-	}
-	return h.Sum(nil), nil
-}
-
-// generates random data in heap buffer
-func generateRandomData(datasize int) ([]byte, error) {
-	b := make([]byte, datasize)
-	c, err := crand.Read(b)
-	if err != nil {
-		return nil, err
-	} else if c != datasize {
-		return nil, errors.New("short read")
-	}
-	return b, nil
-}

cmd/swarm/swarm-snapshot/create.go

@@ -1,157 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/node"
-	"github.com/ubiq/go-ubiq/p2p/simulations"
-	"github.com/ubiq/go-ubiq/p2p/simulations/adapters"
-	"github.com/ubiq/go-ubiq/swarm/network"
-	"github.com/ubiq/go-ubiq/swarm/network/simulation"
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-// create is used as the entry function for "create" app command.
-func create(ctx *cli.Context) error {
-	log.PrintOrigins(true)
-	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(ctx.Int("verbosity")), log.StreamHandler(os.Stdout, log.TerminalFormat(true))))
-
-	if len(ctx.Args()) < 1 {
-		return errors.New("argument should be the filename to verify or write-to")
-	}
-	filename, err := touchPath(ctx.Args()[0])
-	if err != nil {
-		return err
-	}
-	return createSnapshot(filename, ctx.Int("nodes"), strings.Split(ctx.String("services"), ","))
-}
-
-// createSnapshot creates a new snapshot on filesystem with provided filename,
-// number of nodes and service names.
-func createSnapshot(filename string, nodes int, services []string) (err error) {
-	log.Debug("create snapshot", "filename", filename, "nodes", nodes, "services", services)
-
-	sim := simulation.New(map[string]simulation.ServiceFunc{
-		"bzz": func(ctx *adapters.ServiceContext, b *sync.Map) (node.Service, func(), error) {
-			addr := network.NewAddr(ctx.Config.Node())
-			kad := network.NewKademlia(addr.Over(), network.NewKadParams())
-			hp := network.NewHiveParams()
-			hp.KeepAliveInterval = time.Duration(200) * time.Millisecond
-			hp.Discovery = true // discovery must be enabled when creating a snapshot
-
-			config := &network.BzzConfig{
-				OverlayAddr:  addr.Over(),
-				UnderlayAddr: addr.Under(),
-				HiveParams:   hp,
-			}
-			return network.NewBzz(config, kad, nil, nil, nil), nil, nil
-		},
-	})
-	defer sim.Close()
-
-	_, err = sim.AddNodes(nodes)
-	if err != nil {
-		return fmt.Errorf("add nodes: %v", err)
-	}
-
-	err = sim.Net.ConnectNodesRing(nil)
-	if err != nil {
-		return fmt.Errorf("connect nodes: %v", err)
-	}
-
-	ctx, cancelSimRun := context.WithTimeout(context.Background(), 2*time.Minute)
-	defer cancelSimRun()
-	if _, err := sim.WaitTillHealthy(ctx); err != nil {
-		return fmt.Errorf("wait for healthy kademlia: %v", err)
-	}
-
-	var snap *simulations.Snapshot
-	if len(services) > 0 {
-		// If service names are provided, include them in the snapshot.
-		// But, check if "bzz" service is not among them to remove it
-		// form the snapshot as it exists on snapshot creation.
-		var removeServices []string
-		var wantBzz bool
-		for _, s := range services {
-			if s == "bzz" {
-				wantBzz = true
-				break
-			}
-		}
-		if !wantBzz {
-			removeServices = []string{"bzz"}
-		}
-		snap, err = sim.Net.SnapshotWithServices(services, removeServices)
-	} else {
-		snap, err = sim.Net.Snapshot()
-	}
-	if err != nil {
-		return fmt.Errorf("create snapshot: %v", err)
-	}
-	jsonsnapshot, err := json.Marshal(snap)
-	if err != nil {
-		return fmt.Errorf("json encode snapshot: %v", err)
-	}
-	return ioutil.WriteFile(filename, jsonsnapshot, 0666)
-}
-
-// touchPath creates an empty file and all subdirectories
-// that are missing.
-func touchPath(filename string) (string, error) {
-	if path.IsAbs(filename) {
-		if _, err := os.Stat(filename); err == nil {
-			// path exists, overwrite
-			return filename, nil
-		}
-	}
-
-	d, f := path.Split(filename)
-	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
-	if err != nil {
-		return "", err
-	}
-
-	_, err = os.Stat(path.Join(dir, filename))
-	if err == nil {
-		// path exists, overwrite
-		return filename, nil
-	}
-
-	dirPath := path.Join(dir, d)
-	filePath := path.Join(dirPath, f)
-	if d != "" {
-		err = os.MkdirAll(dirPath, os.ModeDir)
-		if err != nil {
-			return "", err
-		}
-	}
-
-	return filePath, nil
-}

cmd/swarm/swarm-snapshot/create_test.go

@@ -1,143 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/ubiq/go-ubiq/p2p/simulations"
-)
-
-// TestSnapshotCreate is a high level e2e test that tests for snapshot generation.
-// It runs a few "create" commands with different flag values and loads generated
-// snapshot files to validate their content.
-func TestSnapshotCreate(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	for _, v := range []struct {
-		name     string
-		nodes    int
-		services string
-	}{
-		{
-			name: "defaults",
-		},
-		{
-			name:  "more nodes",
-			nodes: defaultNodes + 5,
-		},
-		{
-			name:     "services",
-			services: "stream,pss,zorglub",
-		},
-		{
-			name:     "services with bzz",
-			services: "bzz,pss",
-		},
-	} {
-		t.Run(v.name, func(t *testing.T) {
-			t.Parallel()
-
-			file, err := ioutil.TempFile("", "swarm-snapshot")
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer os.Remove(file.Name())
-
-			if err = file.Close(); err != nil {
-				t.Error(err)
-			}
-
-			args := []string{"create"}
-			if v.nodes > 0 {
-				args = append(args, "--nodes", strconv.Itoa(v.nodes))
-			}
-			if v.services != "" {
-				args = append(args, "--services", v.services)
-			}
-			testCmd := runSnapshot(t, append(args, file.Name())...)
-
-			testCmd.ExpectExit()
-			if code := testCmd.ExitStatus(); code != 0 {
-				t.Fatalf("command exit code %v, expected 0", code)
-			}
-
-			f, err := os.Open(file.Name())
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer func() {
-				err := f.Close()
-				if err != nil {
-					t.Error("closing snapshot file", "err", err)
-				}
-			}()
-
-			b, err := ioutil.ReadAll(f)
-			if err != nil {
-				t.Fatal(err)
-			}
-			var snap simulations.Snapshot
-			err = json.Unmarshal(b, &snap)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			wantNodes := v.nodes
-			if wantNodes == 0 {
-				wantNodes = defaultNodes
-			}
-			gotNodes := len(snap.Nodes)
-			if gotNodes != wantNodes {
-				t.Errorf("got %v nodes, want %v", gotNodes, wantNodes)
-			}
-
-			if len(snap.Conns) == 0 {
-				t.Error("no connections in a snapshot")
-			}
-
-			var wantServices []string
-			if v.services != "" {
-				wantServices = strings.Split(v.services, ",")
-			} else {
-				wantServices = []string{"bzz"}
-			}
-			// sort service names so they can be comparable
-			// as strings to every node sorted services
-			sort.Strings(wantServices)
-
-			for i, n := range snap.Nodes {
-				gotServices := n.Node.Config.Services
-				sort.Strings(gotServices)
-				if fmt.Sprint(gotServices) != fmt.Sprint(wantServices) {
-					t.Errorf("got services %v for node %v, want %v", gotServices, i, wantServices)
-				}
-			}
-
-		})
-	}
-}

cmd/swarm/swarm-snapshot/main.go

@@ -1,82 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"os"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"github.com/ubiq/go-ubiq/log"
-	cli "gopkg.in/urfave/cli.v1"
-)
-
-var gitCommit string // Git SHA1 commit hash of the release (set via linker flags)
-
-// default value for "create" command --nodes flag
-const defaultNodes = 10
-
-func main() {
-	err := newApp().Run(os.Args)
-	if err != nil {
-		log.Error(err.Error())
-		os.Exit(1)
-	}
-}
-
-// newApp construct a new instance of Swarm Snapshot Utility.
-// Method Run is called on it in the main function and in tests.
-func newApp() (app *cli.App) {
-	app = utils.NewApp(gitCommit, "Swarm Snapshot Utility")
-
-	app.Name = "swarm-snapshot"
-	app.Usage = ""
-
-	// app flags (for all commands)
-	app.Flags = []cli.Flag{
-		cli.IntFlag{
-			Name:  "verbosity",
-			Value: 1,
-			Usage: "verbosity level",
-		},
-	}
-
-	app.Commands = []cli.Command{
-		{
-			Name:    "create",
-			Aliases: []string{"c"},
-			Usage:   "create a swarm snapshot",
-			Action:  create,
-			// Flags only for "create" command.
-			// Allow app flags to be specified after the
-			// command argument.
-			Flags: append(app.Flags,
-				cli.IntFlag{
-					Name:  "nodes",
-					Value: defaultNodes,
-					Usage: "number of nodes",
-				},
-				cli.StringFlag{
-					Name:  "services",
-					Value: "bzz",
-					Usage: "comma separated list of services to boot the nodes with",
-				},
-			),
-		},
-	}
-
-	return app
-}

cmd/swarm/swarm-snapshot/run_test.go

@@ -1,49 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"testing"
-
-	"github.com/docker/docker/pkg/reexec"
-	"github.com/ubiq/go-ubiq/internal/cmdtest"
-)
-
-func init() {
-	reexec.Register("swarm-snapshot", func() {
-		if err := newApp().Run(os.Args); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		os.Exit(0)
-	})
-}
-
-func runSnapshot(t *testing.T, args ...string) *cmdtest.TestCmd {
-	tt := cmdtest.NewTestCmd(t, nil)
-	tt.Run("swarm-snapshot", args...)
-	return tt
-}
-
-func TestMain(m *testing.M) {
-	if reexec.Init() {
-		return
-	}
-	os.Exit(m.Run())
-}

cmd/swarm/upload.go

@@ -1,188 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-// Command bzzup uploads files to the swarm HTTP API.
-package main
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"os/user"
-	"path"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/ubiq/go-ubiq/log"
-	swarm "github.com/ubiq/go-ubiq/swarm/api/client"
-
-	"github.com/ubiq/go-ubiq/cmd/utils"
-	"gopkg.in/urfave/cli.v1"
-)
-
-var upCommand = cli.Command{
-	Action:             upload,
-	CustomHelpTemplate: helpTemplate,
-	Name:               "up",
-	Usage:              "uploads a file or directory to swarm using the HTTP API",
-	ArgsUsage:          "<file>",
-	Flags:              []cli.Flag{SwarmEncryptedFlag},
-	Description:        "uploads a file or directory to swarm using the HTTP API and prints the root hash",
-}
-
-func upload(ctx *cli.Context) {
-	args := ctx.Args()
-	var (
-		bzzapi          = strings.TrimRight(ctx.GlobalString(SwarmApiFlag.Name), "/")
-		recursive       = ctx.GlobalBool(SwarmRecursiveFlag.Name)
-		wantManifest    = ctx.GlobalBoolT(SwarmWantManifestFlag.Name)
-		defaultPath     = ctx.GlobalString(SwarmUploadDefaultPath.Name)
-		fromStdin       = ctx.GlobalBool(SwarmUpFromStdinFlag.Name)
-		mimeType        = ctx.GlobalString(SwarmUploadMimeType.Name)
-		client          = swarm.NewClient(bzzapi)
-		toEncrypt       = ctx.Bool(SwarmEncryptedFlag.Name)
-		autoDefaultPath = false
-		file            string
-	)
-	if autoDefaultPathString := os.Getenv(SWARM_AUTO_DEFAULTPATH); autoDefaultPathString != "" {
-		b, err := strconv.ParseBool(autoDefaultPathString)
-		if err != nil {
-			utils.Fatalf("invalid environment variable %s: %v", SWARM_AUTO_DEFAULTPATH, err)
-		}
-		autoDefaultPath = b
-	}
-	if len(args) != 1 {
-		if fromStdin {
-			tmp, err := ioutil.TempFile("", "swarm-stdin")
-			if err != nil {
-				utils.Fatalf("error create tempfile: %s", err)
-			}
-			defer os.Remove(tmp.Name())
-			n, err := io.Copy(tmp, os.Stdin)
-			if err != nil {
-				utils.Fatalf("error copying stdin to tempfile: %s", err)
-			} else if n == 0 {
-				utils.Fatalf("error reading from stdin: zero length")
-			}
-			file = tmp.Name()
-		} else {
-			utils.Fatalf("Need filename as the first and only argument")
-		}
-	} else {
-		file = expandPath(args[0])
-	}
-
-	if !wantManifest {
-		f, err := swarm.Open(file)
-		if err != nil {
-			utils.Fatalf("Error opening file: %s", err)
-		}
-		defer f.Close()
-		hash, err := client.UploadRaw(f, f.Size, toEncrypt)
-		if err != nil {
-			utils.Fatalf("Upload failed: %s", err)
-		}
-		fmt.Println(hash)
-		return
-	}
-
-	stat, err := os.Stat(file)
-	if err != nil {
-		utils.Fatalf("Error opening file: %s", err)
-	}
-
-	// define a function which either uploads a directory or single file
-	// based on the type of the file being uploaded
-	var doUpload func() (hash string, err error)
-	if stat.IsDir() {
-		doUpload = func() (string, error) {
-			if !recursive {
-				return "", errors.New("Argument is a directory and recursive upload is disabled")
-			}
-			if autoDefaultPath && defaultPath == "" {
-				defaultEntryCandidate := path.Join(file, "index.html")
-				log.Debug("trying to find default path", "path", defaultEntryCandidate)
-				defaultEntryStat, err := os.Stat(defaultEntryCandidate)
-				if err == nil && !defaultEntryStat.IsDir() {
-					log.Debug("setting auto detected default path", "path", defaultEntryCandidate)
-					defaultPath = defaultEntryCandidate
-				}
-			}
-			if defaultPath != "" {
-				// construct absolute default path
-				absDefaultPath, _ := filepath.Abs(defaultPath)
-				absFile, _ := filepath.Abs(file)
-				// make sure absolute directory ends with only one "/"
-				// to trim it from absolute default path and get relative default path
-				absFile = strings.TrimRight(absFile, "/") + "/"
-				if absDefaultPath != "" && absFile != "" && strings.HasPrefix(absDefaultPath, absFile) {
-					defaultPath = strings.TrimPrefix(absDefaultPath, absFile)
-				}
-			}
-			return client.UploadDirectory(file, defaultPath, "", toEncrypt)
-		}
-	} else {
-		doUpload = func() (string, error) {
-			f, err := swarm.Open(file)
-			if err != nil {
-				return "", fmt.Errorf("error opening file: %s", err)
-			}
-			defer f.Close()
-			if mimeType != "" {
-				f.ContentType = mimeType
-			}
-			return client.Upload(f, "", toEncrypt)
-		}
-	}
-	hash, err := doUpload()
-	if err != nil {
-		utils.Fatalf("Upload failed: %s", err)
-	}
-	fmt.Println(hash)
-}
-
-// Expands a file path
-// 1. replace tilde with users home dir
-// 2. expands embedded environment variables
-// 3. cleans the path, e.g. /a/b/../c -> /a/c
-// Note, it has limitations, e.g. ~someuser/tmp will not be expanded
-func expandPath(p string) string {
-	if i := strings.Index(p, ":"); i > 0 {
-		return p
-	}
-	if i := strings.Index(p, "@"); i > 0 {
-		return p
-	}
-	if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") {
-		if home := homeDir(); home != "" {
-			p = home + p[1:]
-		}
-	}
-	return path.Clean(os.ExpandEnv(p))
-}
-
-func homeDir() string {
-	if home := os.Getenv("HOME"); home != "" {
-		return home
-	}
-	if usr, err := user.Current(); err == nil {
-		return usr.HomeDir
-	}
-	return ""
-}

cmd/swarm/upload_test.go

@@ -1,356 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// go-ethereum is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ubiq/go-ubiq/log"
-	swarmapi "github.com/ubiq/go-ubiq/swarm/api/client"
-	"github.com/ubiq/go-ubiq/swarm/testutil"
-	"github.com/mattn/go-colorable"
-)
-
-func init() {
-	log.PrintOrigins(true)
-	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(colorable.NewColorableStderr(), log.TerminalFormat(true))))
-}
-
-func TestSwarmUp(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip()
-	}
-
-	initCluster(t)
-
-	cases := []struct {
-		name string
-		f    func(t *testing.T)
-	}{
-		{"NoEncryption", testNoEncryption},
-		{"Encrypted", testEncrypted},
-		{"RecursiveNoEncryption", testRecursiveNoEncryption},
-		{"RecursiveEncrypted", testRecursiveEncrypted},
-		{"DefaultPathAll", testDefaultPathAll},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, tc.f)
-	}
-}
-
-// testNoEncryption tests that running 'swarm up' makes the resulting file
-// available from all nodes via the HTTP API
-func testNoEncryption(t *testing.T) {
-	testDefault(false, t)
-}
-
-// testEncrypted tests that running 'swarm up --encrypted' makes the resulting file
-// available from all nodes via the HTTP API
-func testEncrypted(t *testing.T) {
-	testDefault(true, t)
-}
-
-func testRecursiveNoEncryption(t *testing.T) {
-	testRecursive(false, t)
-}
-
-func testRecursiveEncrypted(t *testing.T) {
-	testRecursive(true, t)
-}
-
-func testDefault(toEncrypt bool, t *testing.T) {
-	tmpFileName := testutil.TempFileWithContent(t, data)
-	defer os.Remove(tmpFileName)
-
-	// write data to file
-	hashRegexp := `[a-f\d]{64}`
-	flags := []string{
-		"--bzzapi", cluster.Nodes[0].URL,
-		"up",
-		tmpFileName}
-	if toEncrypt {
-		hashRegexp = `[a-f\d]{128}`
-		flags = []string{
-			"--bzzapi", cluster.Nodes[0].URL,
-			"up",
-			"--encrypt",
-			tmpFileName}
-	}
-	// upload the file with 'swarm up' and expect a hash
-	log.Info(fmt.Sprintf("uploading file with 'swarm up'"))
-	up := runSwarm(t, flags...)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-	hash := matches[0]
-	log.Info("file uploaded", "hash", hash)
-
-	// get the file from the HTTP API of each node
-	for _, node := range cluster.Nodes {
-		log.Info("getting file from node", "node", node.Name)
-
-		res, err := http.Get(node.URL + "/bzz:/" + hash)
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer res.Body.Close()
-
-		reply, err := ioutil.ReadAll(res.Body)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if res.StatusCode != 200 {
-			t.Fatalf("expected HTTP status 200, got %s", res.Status)
-		}
-		if string(reply) != data {
-			t.Fatalf("expected HTTP body %q, got %q", data, reply)
-		}
-		log.Debug("verifying uploaded file using `swarm down`")
-		//try to get the content with `swarm down`
-		tmpDownload, err := ioutil.TempDir("", "swarm-test")
-		tmpDownload = path.Join(tmpDownload, "tmpfile.tmp")
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmpDownload)
-
-		bzzLocator := "bzz:/" + hash
-		flags = []string{
-			"--bzzapi", cluster.Nodes[0].URL,
-			"down",
-			bzzLocator,
-			tmpDownload,
-		}
-
-		down := runSwarm(t, flags...)
-		down.ExpectExit()
-
-		fi, err := os.Stat(tmpDownload)
-		if err != nil {
-			t.Fatalf("could not stat path: %v", err)
-		}
-
-		switch mode := fi.Mode(); {
-		case mode.IsRegular():
-			downloadedBytes, err := ioutil.ReadFile(tmpDownload)
-			if err != nil {
-				t.Fatalf("had an error reading the downloaded file: %v", err)
-			}
-			if !bytes.Equal(downloadedBytes, bytes.NewBufferString(data).Bytes()) {
-				t.Fatalf("retrieved data and posted data not equal!")
-			}
-
-		default:
-			t.Fatalf("expected to download regular file, got %s", fi.Mode())
-		}
-	}
-
-	timeout := time.Duration(2 * time.Second)
-	httpClient := http.Client{
-		Timeout: timeout,
-	}
-
-	// try to squeeze a timeout by getting an non-existent hash from each node
-	for _, node := range cluster.Nodes {
-		_, err := httpClient.Get(node.URL + "/bzz:/1023e8bae0f70be7d7b5f74343088ba408a218254391490c85ae16278e230340")
-		// we're speeding up the timeout here since netstore has a 60 seconds timeout on a request
-		if err != nil && !strings.Contains(err.Error(), "Client.Timeout exceeded while awaiting headers") {
-			t.Fatal(err)
-		}
-		// this is disabled since it takes 60s due to netstore timeout
-		// if res.StatusCode != 404 {
-		// 	t.Fatalf("expected HTTP status 404, got %s", res.Status)
-		// }
-	}
-}
-
-func testRecursive(toEncrypt bool, t *testing.T) {
-	tmpUploadDir, err := ioutil.TempDir("", "swarm-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpUploadDir)
-	// create tmp files
-	for _, path := range []string{"tmp1", "tmp2"} {
-		if err := ioutil.WriteFile(filepath.Join(tmpUploadDir, path), bytes.NewBufferString(data).Bytes(), 0644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	hashRegexp := `[a-f\d]{64}`
-	flags := []string{
-		"--bzzapi", cluster.Nodes[0].URL,
-		"--recursive",
-		"up",
-		tmpUploadDir}
-	if toEncrypt {
-		hashRegexp = `[a-f\d]{128}`
-		flags = []string{
-			"--bzzapi", cluster.Nodes[0].URL,
-			"--recursive",
-			"up",
-			"--encrypt",
-			tmpUploadDir}
-	}
-	// upload the file with 'swarm up' and expect a hash
-	log.Info(fmt.Sprintf("uploading file with 'swarm up'"))
-	up := runSwarm(t, flags...)
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-	hash := matches[0]
-	log.Info("dir uploaded", "hash", hash)
-
-	// get the file from the HTTP API of each node
-	for _, node := range cluster.Nodes {
-		log.Info("getting file from node", "node", node.Name)
-		//try to get the content with `swarm down`
-		tmpDownload, err := ioutil.TempDir("", "swarm-test")
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmpDownload)
-		bzzLocator := "bzz:/" + hash
-		flagss := []string{
-			"--bzzapi", cluster.Nodes[0].URL,
-			"down",
-			"--recursive",
-			bzzLocator,
-			tmpDownload,
-		}
-
-		fmt.Println("downloading from swarm with recursive")
-		down := runSwarm(t, flagss...)
-		down.ExpectExit()
-
-		files, err := ioutil.ReadDir(tmpDownload)
-		for _, v := range files {
-			fi, err := os.Stat(path.Join(tmpDownload, v.Name()))
-			if err != nil {
-				t.Fatalf("got an error: %v", err)
-			}
-
-			switch mode := fi.Mode(); {
-			case mode.IsRegular():
-				if file, err := swarmapi.Open(path.Join(tmpDownload, v.Name())); err != nil {
-					t.Fatalf("encountered an error opening the file returned from the CLI: %v", err)
-				} else {
-					ff := make([]byte, len(data))
-					io.ReadFull(file, ff)
-					buf := bytes.NewBufferString(data)
-
-					if !bytes.Equal(ff, buf.Bytes()) {
-						t.Fatalf("retrieved data and posted data not equal!")
-					}
-				}
-			default:
-				t.Fatalf("this shouldnt happen")
-			}
-		}
-		if err != nil {
-			t.Fatalf("could not list files at: %v", files)
-		}
-	}
-}
-
-// testDefaultPathAll tests swarm recursive upload with relative and absolute
-// default paths and with encryption.
-func testDefaultPathAll(t *testing.T) {
-	testDefaultPath(false, false, t)
-	testDefaultPath(false, true, t)
-	testDefaultPath(true, false, t)
-	testDefaultPath(true, true, t)
-}
-
-func testDefaultPath(toEncrypt bool, absDefaultPath bool, t *testing.T) {
-	tmp, err := ioutil.TempDir("", "swarm-defaultpath-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmp)
-
-	err = ioutil.WriteFile(filepath.Join(tmp, "index.html"), []byte("<h1>Test</h1>"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = ioutil.WriteFile(filepath.Join(tmp, "robots.txt"), []byte("Disallow: /"), 0666)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defaultPath := "index.html"
-	if absDefaultPath {
-		defaultPath = filepath.Join(tmp, defaultPath)
-	}
-
-	args := []string{
-		"--bzzapi",
-		cluster.Nodes[0].URL,
-		"--recursive",
-		"--defaultpath",
-		defaultPath,
-		"up",
-		tmp,
-	}
-	if toEncrypt {
-		args = append(args, "--encrypt")
-	}
-
-	up := runSwarm(t, args...)
-	hashRegexp := `[a-f\d]{64,128}`
-	_, matches := up.ExpectRegexp(hashRegexp)
-	up.ExpectExit()
-	hash := matches[0]
-
-	client := swarmapi.NewClient(cluster.Nodes[0].URL)
-
-	m, isEncrypted, err := client.DownloadManifest(hash)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if toEncrypt != isEncrypted {
-		t.Error("downloaded manifest is not encrypted")
-	}
-
-	var found bool
-	var entriesCount int
-	for _, e := range m.Entries {
-		entriesCount++
-		if e.Path == "" {
-			found = true
-		}
-	}
-
-	if !found {
-		t.Error("manifest default entry was not found")
-	}
-
-	if entriesCount != 3 {
-		t.Errorf("manifest contains %v entries, expected %v", entriesCount, 3)
-	}
-}

consensus/ubqhash/algorithm.go

@@ -132,8 +132,6 @@ func blakeHasher(h hash.Hash) hasher {
 	}
 }
 
-
-
 // seedHash is the seed to use for generating a verification cache and the mining
 // dataset.
 func seedHash(block uint64) []byte {
@@ -1062,7 +1060,7 @@ var cacheSizes = [maxEpoch]uint64{
 	200014016, 200146624, 200276672, 200408128, 200540096, 200671168,
 	200801984, 200933312, 201062464, 201194944, 201326144, 201457472,
 	201588544, 201719744, 201850816, 201981632, 202111552, 202244032,
-	202374464, 202505152, 202636352, 202767808, 202898368, 203038836,
+	202374464, 202505152, 202636352, 202767808, 202898368, 203030336,
 	203159872, 203292608, 203423296, 203553472, 203685824, 203816896,
 	203947712, 204078272, 204208192, 204341056, 204472256, 204603328,
 	204733888, 204864448, 204996544, 205125568, 205258304, 205388864,

consensus/ubqhash/algorithm_test.go

@@ -706,20 +706,20 @@ func TestConcurrentDiskCacheGeneration(t *testing.T) {
 
 	// Define a heavy enough block, one from mainnet should do
 	block := types.NewBlockWithHeader(&types.Header{
-		Number:      big.NewInt(3311058),
+		Number:      big.NewInt(1047270),
-		ParentHash:  common.HexToHash("0xd783efa4d392943503f28438ad5830b2d5964696ffc285f338585e9fe0a37a05"),
+		ParentHash:  common.HexToHash("0x50162f5bb86b04d36ad3c0972942f3ad12012681364a9ecfd851163893973b1e"),
 		UncleHash:   common.HexToHash("0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"),
-		Coinbase:    common.HexToAddress("0xc0ea08a2d404d3172d2add29a45be56da40e2949"),
+		Coinbase:    common.HexToAddress("0xaeb7897adf9b1309d7ef2dca6f3f6afb65358abd"),
-		Root:        common.HexToHash("0x77d14e10470b5850332524f8cd6f69ad21f070ce92dca33ab2858300242ef2f1"),
+		Root:        common.HexToHash("0x48450163a72087d7f7c7f8e479ca5f9b46ba2dea65af31374869330438f092bc"),
-		TxHash:      common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"),
+		TxHash:      common.HexToHash("0xf3d988c1ba77b327ffe99f8f24d183f1dcca0a858dea397da90d19511f3e5243"),
-		ReceiptHash: common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"),
+		ReceiptHash: common.HexToHash("0x51f3538babf4e6315ac5843cbb6585b57024cfda57a3fbe51413549944496dcc"),
-		Difficulty:  big.NewInt(167925187834220),
+		Difficulty:  big.NewInt(4399410101192),
-		GasLimit:    4015682,
+		GasLimit:    8000000,
-		GasUsed:     0,
+		GasUsed:     21000,
-		Time:        1488928920,
+		Time:        1576671205,
-		Extra:       []byte("www.bw.com"),
+		Extra:       []byte("ubiqpool.maxhash.org"),
-		MixDigest:   common.HexToHash("0x3e140b0784516af5e5ec6730f2fb20cca22f32be399b9e4ad77d32541f798cd0"),
+		MixDigest:   common.HexToHash("0x8ce33f23cc18c394542ab28d35065706293eaf9c101007beb800f7e273266f82"),
-		Nonce:       types.EncodeNonce(0xf400cd0006070c49),
+		Nonce:       types.EncodeNonce(0x2b00b2d234c5134e),
 	})
 	// Simulate multiple processes sharing the same datadir
 	var pend sync.WaitGroup

consensus/ubqhash/api.go

@@ -24,7 +24,7 @@ import (
 	"github.com/ubiq/go-ubiq/core/types"
 )
 
-var errEthashStopped = errors.New("ubqhash stopped")
+var errUbqhashStopped = errors.New("ubqhash stopped")
 
 // API exposes ubqhash related methods for the RPC interface.
 type API struct {
@@ -51,7 +51,7 @@ func (api *API) GetWork() ([4]string, error) {
 	select {
 	case api.ubqhash.fetchWorkCh <- &sealWork{errc: errc, res: workCh}:
 	case <-api.ubqhash.exitCh:
-		return [4]string{}, errEthashStopped
+		return [4]string{}, errUbqhashStopped
 	}
 
 	select {

consensus/ubqhash/consensus.go

@@ -24,7 +24,7 @@ import (
 	"runtime"
 	"time"
 
-  mapset "github.com/deckarep/golang-set"
+	mapset "github.com/deckarep/golang-set"
 	"github.com/ubiq/go-ubiq/common"
 	"github.com/ubiq/go-ubiq/consensus"
 	"github.com/ubiq/go-ubiq/consensus/misc"
@@ -38,43 +38,55 @@ import (
 
 // Ubqhash proof-of-work protocol constants.
 var (
-	blockReward *big.Int = big.NewInt(8e+18) // Block reward in wei for successfully mining a block
+	maxUncles              = 2                // Maximum number of uncles allowed in a single block
-	maxUncles            = 2                 // Maximum number of uncles allowed in a single block
+	allowedFutureBlockTime = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks
-	allowedFutureBlockTime    = 15 * time.Second  // Max time from current time allowed for blocks, before they're considered future blocks
 )
 
 // Diff algo constants.
 var (
-	big88               = big.NewInt(88)
+	big88 = big.NewInt(88)
-	bigMinus99          = big.NewInt(-99)
-	nPowAveragingWindow = big.NewInt(21)
-	nPowMaxAdjustDown   = big.NewInt(16) // 16% adjustment down
-	nPowMaxAdjustUp     = big.NewInt(8)  // 8% adjustment up
 
-	diffChangeBlock       = big.NewInt(4088)
+	digishieldV3Config = &diffConfig{
-	nPowAveragingWindow88 = big.NewInt(88)
+		AveragingWindow: big.NewInt(21),
-	nPowMaxAdjustDown2    = big.NewInt(3) // 3% adjustment down
+		MaxAdjustDown:   big.NewInt(16), // 16%
-	nPowMaxAdjustUp2      = big.NewInt(2) // 2% adjustment up
+		MaxAdjustUp:     big.NewInt(8),  // 8%
+		Factor:          big.NewInt(100),
+	}
 
-	// Flux
+	digishieldV3ModConfig = &diffConfig{
-	fluxChangeBlock       = big.NewInt(8000)
+		AveragingWindow: big.NewInt(88),
-	nPowMaxAdjustDownFlux = big.NewInt(5) // 0.5% adjustment down
+		MaxAdjustDown:   big.NewInt(3), // 3%
-	nPowMaxAdjustUpFlux   = big.NewInt(3) // 0.3% adjustment up
+		MaxAdjustUp:     big.NewInt(2), // 2%
-	nPowDampFlux          = big.NewInt(1) // 0.1%
+		Factor:          big.NewInt(100),
+	}
+
+	fluxConfig = &diffConfig{
+		AveragingWindow: big.NewInt(88),
+		MaxAdjustDown:   big.NewInt(5), // 0.5%
+		MaxAdjustUp:     big.NewInt(3), // 0.3%
+		Dampen:          big.NewInt(1), // 0.1%
+		Factor:          big.NewInt(1000),
+	}
 )
 
+type diffConfig struct {
+	AveragingWindow *big.Int `json:"averagingWindow"`
+	MaxAdjustDown   *big.Int `json:"maxAdjustDown"`
+	MaxAdjustUp     *big.Int `json:"maxAdjustUp"`
+	Dampen          *big.Int `json:"dampen,omitempty"`
+	Factor          *big.Int `json:"factor"`
+}
+
 // Various error messages to mark blocks invalid. These should be private to
 // prevent engine specific errors from being referenced in the remainder of the
 // codebase, inherently breaking if the engine is swapped out. Please put common
 // error types into the consensus package.
 var (
-	errLargeBlockTime    = errors.New("timestamp too big")
 	errZeroBlockTime     = errors.New("timestamp equals parent's")
 	errTooManyUncles     = errors.New("too many uncles")
 	errDuplicateUncle    = errors.New("duplicate uncle")
 	errUncleIsAncestor   = errors.New("uncle is ancestor")
 	errDanglingUncle     = errors.New("uncle's parent is not ancestor")
-	errNonceOutOfRange   = errors.New("nonce out of range")
 	errInvalidDifficulty = errors.New("non-positive difficulty")
 	errInvalidMixDigest  = errors.New("invalid mix digest")
 	errInvalidPoW        = errors.New("invalid proof-of-work")
@@ -300,84 +312,39 @@ func (ubqhash *Ubqhash) verifyHeader(chain consensus.ChainReader, header, parent
 }
 
 // Difficulty timespans
-func averagingWindowTimespan() *big.Int {
+func averagingWindowTimespan(config *diffConfig) *big.Int {
 	x := new(big.Int)
-	return x.Mul(nPowAveragingWindow, big88)
+	return x.Mul(config.AveragingWindow, big88)
 }
 
-func minActualTimespan() *big.Int {
+func minActualTimespan(config *diffConfig, dampen bool) *big.Int {
-	x := new(big.Int)
-	y := new(big.Int)
-	z := new(big.Int)
-	x.Sub(big.NewInt(100), nPowMaxAdjustUp)
-	y.Mul(averagingWindowTimespan(), x)
-	z.Div(y, big.NewInt(100))
-	return z
-}
-
-func maxActualTimespan() *big.Int {
-	x := new(big.Int)
-	y := new(big.Int)
-	z := new(big.Int)
-	x.Add(big.NewInt(100), nPowMaxAdjustDown)
-	y.Mul(averagingWindowTimespan(), x)
-	z.Div(y, big.NewInt(100))
-	return z
-}
-
-func averagingWindowTimespan88() *big.Int {
-	x := new(big.Int)
-	return x.Mul(nPowAveragingWindow88, big88)
-}
-
-func minActualTimespan2() *big.Int {
-	x := new(big.Int)
-	y := new(big.Int)
-	z := new(big.Int)
-	x.Sub(big.NewInt(100), nPowMaxAdjustUp2)
-	y.Mul(averagingWindowTimespan88(), x)
-	z.Div(y, big.NewInt(100))
-	return z
-}
-
-func maxActualTimespan2() *big.Int {
-	x := new(big.Int)
-	y := new(big.Int)
-	z := new(big.Int)
-	x.Add(big.NewInt(100), nPowMaxAdjustDown2)
-	y.Mul(averagingWindowTimespan88(), x)
-	z.Div(y, big.NewInt(100))
-	return z
-}
-
-func minActualTimespanFlux(dampen bool) *big.Int {
 	x := new(big.Int)
 	y := new(big.Int)
 	z := new(big.Int)
 	if dampen {
-		x.Sub(big.NewInt(1000), nPowDampFlux)
+		x.Sub(config.Factor, config.Dampen)
-		y.Mul(averagingWindowTimespan88(), x)
+		y.Mul(averagingWindowTimespan(config), x)
-		z.Div(y, big.NewInt(1000))
+		z.Div(y, config.Factor)
 	} else {
-		x.Sub(big.NewInt(1000), nPowMaxAdjustUpFlux)
+		x.Sub(config.Factor, config.MaxAdjustUp)
-		y.Mul(averagingWindowTimespan88(), x)
+		y.Mul(averagingWindowTimespan(config), x)
-		z.Div(y, big.NewInt(1000))
+		z.Div(y, config.Factor)
 	}
 	return z
 }
 
-func maxActualTimespanFlux(dampen bool) *big.Int {
+func maxActualTimespan(config *diffConfig, dampen bool) *big.Int {
 	x := new(big.Int)
 	y := new(big.Int)
 	z := new(big.Int)
 	if dampen {
-		x.Add(big.NewInt(1000), nPowDampFlux)
+		x.Add(config.Factor, config.Dampen)
-		y.Mul(averagingWindowTimespan88(), x)
+		y.Mul(averagingWindowTimespan(config), x)
-		z.Div(y, big.NewInt(1000))
+		z.Div(y, config.Factor)
 	} else {
-		x.Add(big.NewInt(1000), nPowMaxAdjustDownFlux)
+		x.Add(config.Factor, config.MaxAdjustDown)
-		y.Mul(averagingWindowTimespan88(), x)
+		y.Mul(averagingWindowTimespan(config), x)
-		z.Div(y, big.NewInt(1000))
+		z.Div(y, config.Factor)
 	}
 	return z
 }
@@ -389,142 +356,77 @@ func (ubqhash *Ubqhash) CalcDifficulty(chain consensus.ChainReader, time uint64,
 	return CalcDifficulty(chain, time, parent)
 }
 
+// CalcDifficulty determines which difficulty algorithm to use for calculating a new block
 func CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int {
 	parentTime := parent.Time
 	parentNumber := parent.Number
 	parentDiff := parent.Difficulty
 
-	if parentNumber.Cmp(diffChangeBlock) < 0 {
+	config := chain.Config()
-		return calcDifficultyOrig(chain, parentNumber, parentDiff, parent)
+	ubqhashConfig := config.Ubqhash
-	}
+
-	if parentNumber.Cmp(fluxChangeBlock) < 0 {
+	if parentNumber.Cmp(ubqhashConfig.FluxBlock) < 0 {
-		// (chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header)
+		if parentNumber.Cmp(ubqhashConfig.DigishieldModBlock) < 0 {
-		return calcDifficulty2(chain, parentNumber, parentDiff, parent)
+			// Original DigishieldV3
-	} else {
+			return calcDifficultyDigishieldV3(chain, parentNumber, parentDiff, parent, digishieldV3Config)
-		// (chain consensus.ChainReader, time, parentTime, parentNumber, parentDiff *big.Int, parent *types.Header)
+		}
-		return fluxDifficulty(chain, big.NewInt(int64(time)), big.NewInt(int64(parentTime)), parentNumber, parentDiff, parent)
+		// Modified DigishieldV3
+		return calcDifficultyDigishieldV3(chain, parentNumber, parentDiff, parent, digishieldV3ModConfig)
 	}
+	// Flux
+	return calcDifficultyFlux(chain, big.NewInt(int64(time)), big.NewInt(int64(parentTime)), parentNumber, parentDiff, parent)
 }
 
-// Some weird constants to avoid constant memory allocs for them.
+// calcDifficultyDigishieldV3 is the original difficulty adjustment algorithm.
-var (
+// It returns the difficulty that a new block should have when created at time
-	expDiffPeriod = big.NewInt(100000)
-	big10         = big.NewInt(10)
-)
-
-// calcDifficultyLegacy is the difficulty adjustment algorithm. It returns
-// the difficulty that a new block should have when created at time given the
-// parent block's time and difficulty. The calculation uses the Legacy rules.
-func CalcDifficultyLegacy(time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int {
-	bigTime := new(big.Int).SetUint64(time)
-	bigParentTime := new(big.Int).SetUint64(parentTime)
-
-	// holds intermediate values to make the algo easier to read & audit
-	x := new(big.Int)
-	y := new(big.Int)
-
-	// 1 - (block_timestamp -parent_timestamp) // 10
-	x.Sub(bigTime, bigParentTime)
-	x.Div(x, big88)
-	x.Sub(common.Big1, x)
-
-	// max(1 - (block_timestamp - parent_timestamp) // 10, -99)))
-	if x.Cmp(bigMinus99) < 0 {
-		x.Set(bigMinus99)
-	}
-	// (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99))
-	y.Div(parentDiff, params.DifficultyBoundDivisor)
-	x.Mul(y, x)
-	x.Add(parentDiff, x)
-
-	// minimum difficulty can ever be (before exponential factor)
-	if x.Cmp(params.MinimumDifficulty) < 0 {
-		x.Set(params.MinimumDifficulty)
-	}
-
-	return x
-}
-
-// CalcDifficulty is the difficulty adjustment algorithm. It returns
-// the difficulty that a new block should have when created at time
 // given the parent block's time and difficulty.
-// Rewritten to be based on Digibyte's Digishield v3 retargeting
+// Based on Digibyte's Digishield v3 retargeting
-func calcDifficultyOrig(chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int {
+func calcDifficultyDigishieldV3(chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header, digishield *diffConfig) *big.Int {
 	// holds intermediate values to make the algo easier to read & audit
 	x := new(big.Int)
 	nFirstBlock := new(big.Int)
-	nFirstBlock.Sub(parentNumber, nPowAveragingWindow)
+	nFirstBlock.Sub(parentNumber, digishield.AveragingWindow)
 
 	log.Debug(fmt.Sprintf("CalcDifficulty parentNumber: %v parentDiff: %v", parentNumber, parentDiff))
 
 	// Check we have enough blocks
-	if parentNumber.Cmp(nPowAveragingWindow) < 1 {
+	if parentNumber.Cmp(digishield.AveragingWindow) < 1 {
-		log.Debug(fmt.Sprintf("CalcDifficulty: parentNumber(%+x) < nPowAveragingWindow(%+x)", parentNumber, nPowAveragingWindow))
+		log.Debug(fmt.Sprintf("CalcDifficulty: parentNumber(%+x) < digishieldV3Config.AveragingWindow(%+x)", parentNumber, digishield.AveragingWindow))
 		x.Set(parentDiff)
 		return x
 	}
 
 	// Limit adjustment step
 	// Use medians to prevent time-warp attacks
-	// nActualTimespan := nLastBlockTime - nFirstBlockTime
 	nLastBlockTime := chain.CalcPastMedianTime(parentNumber.Uint64(), parent)
 	nFirstBlockTime := chain.CalcPastMedianTime(nFirstBlock.Uint64(), parent)
 	nActualTimespan := new(big.Int)
 	nActualTimespan.Sub(nLastBlockTime, nFirstBlockTime)
 	log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v before dampening", nActualTimespan))
 
-	// nActualTimespan = AveragingWindowTimespan() + (nActualTimespan-AveragingWindowTimespan())/4
 	y := new(big.Int)
-	y.Sub(nActualTimespan, averagingWindowTimespan())
+	y.Sub(nActualTimespan, averagingWindowTimespan(digishield))
 	y.Div(y, big.NewInt(4))
-	nActualTimespan.Add(y, averagingWindowTimespan())
+	nActualTimespan.Add(y, averagingWindowTimespan(digishield))
 	log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v before bounds", nActualTimespan))
 
-	if nActualTimespan.Cmp(minActualTimespan()) < 0 {
+	if nActualTimespan.Cmp(minActualTimespan(digishield, false)) < 0 {
-		nActualTimespan.Set(minActualTimespan())
+		nActualTimespan.Set(minActualTimespan(digishield, false))
 		log.Debug("CalcDifficulty Minimum Timespan set")
-	} else if nActualTimespan.Cmp(maxActualTimespan()) > 0 {
+	} else if nActualTimespan.Cmp(maxActualTimespan(digishield, false)) > 0 {
-		nActualTimespan.Set(maxActualTimespan())
+		nActualTimespan.Set(maxActualTimespan(digishield, false))
 		log.Debug("CalcDifficulty Maximum Timespan set")
 	}
 
 	log.Debug(fmt.Sprintf("CalcDifficulty nActualTimespan = %v final\n", nActualTimespan))
 
 	// Retarget
-	x.Mul(parentDiff, averagingWindowTimespan())
+	x.Mul(parentDiff, averagingWindowTimespan(digishield))
 	log.Debug(fmt.Sprintf("CalcDifficulty parentDiff * AveragingWindowTimespan: %v", x))
 
 	x.Div(x, nActualTimespan)
 	log.Debug(fmt.Sprintf("CalcDifficulty x / nActualTimespan: %v", x))
 
-	return x
-}
-
-func calcDifficulty2(chain consensus.ChainReader, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int {
-	x := new(big.Int)
-	nFirstBlock := new(big.Int)
-	nFirstBlock.Sub(parentNumber, nPowAveragingWindow88)
-
-	nLastBlockTime := chain.CalcPastMedianTime(parentNumber.Uint64(), parent)
-	nFirstBlockTime := chain.CalcPastMedianTime(nFirstBlock.Uint64(), parent)
-
-	nActualTimespan := new(big.Int)
-	nActualTimespan.Sub(nLastBlockTime, nFirstBlockTime)
-
-	y := new(big.Int)
-	y.Sub(nActualTimespan, averagingWindowTimespan88())
-	y.Div(y, big.NewInt(4))
-	nActualTimespan.Add(y, averagingWindowTimespan88())
-
-	if nActualTimespan.Cmp(minActualTimespan2()) < 0 {
-		nActualTimespan.Set(minActualTimespan2())
-	} else if nActualTimespan.Cmp(maxActualTimespan2()) > 0 {
-		nActualTimespan.Set(maxActualTimespan2())
-	}
-
-	x.Mul(parentDiff, averagingWindowTimespan88())
-	x.Div(x, nActualTimespan)
-
 	if x.Cmp(params.MinimumDifficulty) < 0 {
 		x.Set(params.MinimumDifficulty)
 	}
@@ -532,10 +434,17 @@ func calcDifficulty2(chain consensus.ChainReader, parentNumber, parentDiff *big.
 	return x
 }
 
-func fluxDifficulty(chain consensus.ChainReader, time, parentTime, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int {
+func calcDifficultyFlux(chain consensus.ChainReader, time, parentTime, parentNumber, parentDiff *big.Int, parent *types.Header) *big.Int {
 	x := new(big.Int)
 	nFirstBlock := new(big.Int)
-	nFirstBlock.Sub(parentNumber, nPowAveragingWindow88)
+	nFirstBlock.Sub(parentNumber, fluxConfig.AveragingWindow)
+
+	// Check we have enough blocks
+	if parentNumber.Cmp(fluxConfig.AveragingWindow) < 1 {
+		log.Debug(fmt.Sprintf("CalcDifficulty: parentNumber(%+x) < fluxConfig.AveragingWindow(%+x)", parentNumber, fluxConfig.AveragingWindow))
+		x.Set(parentDiff)
+		return x
+	}
 
 	diffTime := new(big.Int)
 	diffTime.Sub(time, parentTime)
@@ -546,29 +455,29 @@ func fluxDifficulty(chain consensus.ChainReader, time, parentTime, parentNumber,
 	nActualTimespan.Sub(nLastBlockTime, nFirstBlockTime)
 
 	y := new(big.Int)
-	y.Sub(nActualTimespan, averagingWindowTimespan88())
+	y.Sub(nActualTimespan, averagingWindowTimespan(fluxConfig))
 	y.Div(y, big.NewInt(4))
-	nActualTimespan.Add(y, averagingWindowTimespan88())
+	nActualTimespan.Add(y, averagingWindowTimespan(fluxConfig))
 
-	if nActualTimespan.Cmp(minActualTimespanFlux(false)) < 0 {
+	if nActualTimespan.Cmp(minActualTimespan(fluxConfig, false)) < 0 {
 		doubleBig88 := new(big.Int)
 		doubleBig88.Mul(big88, big.NewInt(2))
 		if diffTime.Cmp(doubleBig88) > 0 {
-			nActualTimespan.Set(minActualTimespanFlux(true))
+			nActualTimespan.Set(minActualTimespan(fluxConfig, true))
 		} else {
-			nActualTimespan.Set(minActualTimespanFlux(false))
+			nActualTimespan.Set(minActualTimespan(fluxConfig, false))
 		}
-	} else if nActualTimespan.Cmp(maxActualTimespanFlux(false)) > 0 {
+	} else if nActualTimespan.Cmp(maxActualTimespan(fluxConfig, false)) > 0 {
 		halfBig88 := new(big.Int)
 		halfBig88.Div(big88, big.NewInt(2))
 		if diffTime.Cmp(halfBig88) < 0 {
-			nActualTimespan.Set(maxActualTimespanFlux(true))
+			nActualTimespan.Set(maxActualTimespan(fluxConfig, true))
 		} else {
-			nActualTimespan.Set(maxActualTimespanFlux(false))
+			nActualTimespan.Set(maxActualTimespan(fluxConfig, false))
 		}
 	}
 
-	x.Mul(parentDiff, averagingWindowTimespan88())
+	x.Mul(parentDiff, averagingWindowTimespan(fluxConfig))
 	x.Div(x, nActualTimespan)
 
 	if x.Cmp(params.MinimumDifficulty) < 0 {
@@ -666,7 +575,7 @@ func (ubqhash *Ubqhash) Prepare(chain consensus.ChainReader, header *types.Heade
 // setting the final state and assembling the block.
 func (ubqhash *Ubqhash) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
 	// Accumulate any block and uncle rewards and commit the final state root
-	accumulateRewards(state, header, uncles)
+	accumulateRewards(chain.Config(), state, header, uncles)
 	header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
 
 	// Header seems complete, assemble into a block and return
@@ -676,7 +585,6 @@ func (ubqhash *Ubqhash) Finalize(chain consensus.ChainReader, header *types.Head
 // Some weird constants to avoid constant memory allocs for them.
 var (
 	big2  = big.NewInt(2)
-	big8  = big.NewInt(8)
 	big32 = big.NewInt(32)
 )
 
@@ -703,56 +611,59 @@ func (ubqhash *Ubqhash) SealHash(header *types.Header) (hash common.Hash) {
 	return hash
 }
 
+// CalcBaseBlockReward calculates the base block reward as per the ubiq monetary policy.
+func CalcBaseBlockReward(config *params.UbqhashConfig, height *big.Int) (*big.Int, *big.Int) {
+	reward := new(big.Int)
+
+	for _, step := range config.MonetaryPolicy {
+		if height.Cmp(step.Block) > 0 {
+			reward = new(big.Int).Set(step.Reward)
+		} else {
+			break
+		}
+	}
+
+	return new(big.Int).Set(config.MonetaryPolicy[0].Reward), reward
+}
+
+// CalcUncleBlockReward calculates the uncle miner reward based on depth.
+func CalcUncleBlockReward(config *params.ChainConfig, blockHeight *big.Int, uncleHeight *big.Int, blockReward *big.Int) *big.Int {
+	reward := new(big.Int)
+	// calculate reward based on depth
+	reward.Add(uncleHeight, big2)
+	reward.Sub(reward, blockHeight)
+	reward.Mul(reward, blockReward)
+	reward.Div(reward, big2)
+
+	// negative uncle reward fix. (activates along-side EIP158)
+	if config.IsEIP158(blockHeight) && reward.Cmp(big.NewInt(0)) < 0 {
+		reward = big.NewInt(0)
+	}
+	return reward
+}
+
 // AccumulateRewards credits the coinbase of the given block with the mining
 // reward. The total reward consists of the static block reward and rewards for
 // included uncles. The coinbase of each uncle block is also rewarded.
-func accumulateRewards(state *state.StateDB, header *types.Header, uncles []*types.Header) {
+func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
-	reward := new(big.Int).Set(blockReward)
+	// block reward (miner)
+	initialReward, currentReward := CalcBaseBlockReward(config.Ubqhash, header.Number)
 
-	if header.Number.Cmp(big.NewInt(358363)) > 0 {
+	// Uncle reward step down fix. (activates along-side byzantium)
-		reward = big.NewInt(7e+18)
+	ufixReward := initialReward
-	}
+	if config.IsByzantium(header.Number) {
-	if header.Number.Cmp(big.NewInt(716727)) > 0 {
+		ufixReward = currentReward
-		reward = big.NewInt(6e+18)
-	}
-	if header.Number.Cmp(big.NewInt(1075090)) > 0 {
-		reward = big.NewInt(5e+18)
-	}
-	if header.Number.Cmp(big.NewInt(1433454)) > 0 {
-		reward = big.NewInt(4e+18)
-	}
-	if header.Number.Cmp(big.NewInt(1791818)) > 0 {
-		reward = big.NewInt(3e+18)
-	}
-	if header.Number.Cmp(big.NewInt(2150181)) > 0 {
-		reward = big.NewInt(2e+18)
-	}
-	if header.Number.Cmp(big.NewInt(2508545)) > 0 {
-		reward = big.NewInt(1e+18)
 	}
 
-	r := new(big.Int)
 	for _, uncle := range uncles {
-		r.Add(uncle.Number, big2)
+		// uncle block miner reward (depth === 1 ? baseBlockReward * 0.5 : 0)
-		r.Sub(r, header.Number)
+		uncleReward := CalcUncleBlockReward(config, header.Number, uncle.Number, ufixReward)
-		r.Mul(r, blockReward)
+		// update uncle miner balance
-		r.Div(r, big2)
+		state.AddBalance(uncle.Coinbase, uncleReward)
-
+		// include uncle bonus reward (baseBlockReward/32)
-		if header.Number.Cmp(big.NewInt(10)) < 0 {
+		uncleReward.Div(ufixReward, big32)
-			state.AddBalance(uncle.Coinbase, r)
+		currentReward.Add(currentReward, uncleReward)
-			r.Div(blockReward, big32)
-			if r.Cmp(big.NewInt(0)) < 0 {
-				r = big.NewInt(0)
-			}
-		} else {
-			if r.Cmp(big.NewInt(0)) < 0 {
-				r = big.NewInt(0)
-			}
-			state.AddBalance(uncle.Coinbase, r)
-			r.Div(blockReward, big32)
-		}
-
-		reward.Add(reward, r)
 	}
-	state.AddBalance(header.Coinbase, reward)
+	// update block miner balance
+	state.AddBalance(header.Coinbase, currentReward)
 }

consensus/ubqhash/consensus_test.go

@@ -17,17 +17,22 @@
 package ubqhash
 
 import (
-	"encoding/json"
+	// "encoding/json"
 	"math/big"
-	"os"
+	// "os"
-	"path/filepath"
+	// "path/filepath"
 	"testing"
 
-	"github.com/ubiq/go-ubiq/common/math"
+	// "github.com/ubiq/go-ubiq/common/math"
-	"github.com/ubiq/go-ubiq/core/types"
+	// "github.com/ubiq/go-ubiq/core"
+	// "github.com/ubiq/go-ubiq/core/types"
+	// "github.com/ubiq/go-ubiq/core/vm"
+	// "github.com/ubiq/go-ubiq/ethdb"
 	"github.com/ubiq/go-ubiq/params"
 )
 
+// TODO: write new difficulty tests
+/*
 type diffTest struct {
 	ParentTimestamp    uint64
 	ParentDifficulty   *big.Int
@@ -72,9 +77,24 @@ func TestCalcDifficulty(t *testing.T) {
 
 	config := &params.ChainConfig{HomesteadBlock: big.NewInt(1150000)}
 
+	var (
+		testdb    = ethdb.NewMemDatabase()
+		gspec     = &core.Genesis{Config: config}
+		genesis   = gspec.MustCommit(testdb)
+		blocks, _ = core.GenerateChain(config, genesis, NewFaker(), testdb, 88, nil)
+	)
+
+	headers := make([]*types.Header, len(blocks))
+	for i, block := range blocks {
+		headers[i] = block.Header()
+	}
+	// Run the header checker for blocks one-by-one, checking for both valid and invalid nonces
+	chain, _ := core.NewBlockChain(testdb, nil, config, NewFaker(), vm.Config{}, nil)
+	defer chain.Stop()
+
 	for name, test := range tests {
 		number := new(big.Int).Sub(test.CurrentBlocknumber, big.NewInt(1))
-		diff := CalcDifficulty(config, test.CurrentTimestamp, &types.Header{
+		diff := CalcDifficulty(chain, test.CurrentTimestamp, &types.Header{
 			Number:     number,
 			Time:       test.ParentTimestamp,
 			Difficulty: test.ParentDifficulty,
@@ -83,4 +103,120 @@ func TestCalcDifficulty(t *testing.T) {
 			t.Error(name, "failed. Expected", test.CurrentDifficulty, "and calculated", diff)
 		}
 	}
+}*/
+
+func TestCalcBaseBlockReward(t *testing.T) {
+	config := *params.MainnetChainConfig
+	_, reward := CalcBaseBlockReward(config.Ubqhash, big.NewInt(1))
+	if reward.Cmp(big.NewInt(8e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 8 (start)", "failed. Expected", big.NewInt(8e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(358363))
+	if reward.Cmp(big.NewInt(8e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 8 (end)", "failed. Expected", big.NewInt(8e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(358364))
+	if reward.Cmp(big.NewInt(7e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 7 (start)", "failed. Expected", big.NewInt(7e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(716727))
+	if reward.Cmp(big.NewInt(7e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 7 (end)", "failed. Expected", big.NewInt(7e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(716728))
+	if reward.Cmp(big.NewInt(6e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 6 (start)", "failed. Expected", big.NewInt(6e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1075090))
+	if reward.Cmp(big.NewInt(6e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 6 (end)", "failed. Expected", big.NewInt(6e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1075091))
+	if reward.Cmp(big.NewInt(5e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 5 (start)", "failed. Expected", big.NewInt(5e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1433454))
+	if reward.Cmp(big.NewInt(5e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 5 (end)", "failed. Expected", big.NewInt(5e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1433455))
+	if reward.Cmp(big.NewInt(4e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 4 (start)", "failed. Expected", big.NewInt(4e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1791818))
+	if reward.Cmp(big.NewInt(4e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 4 (end)", "failed. Expected", big.NewInt(4e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1791819))
+	if reward.Cmp(big.NewInt(3e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 3 (start)", "failed. Expected", big.NewInt(3e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(2150181))
+	if reward.Cmp(big.NewInt(3e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 3 (end)", "failed. Expected", big.NewInt(3e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(2150182))
+	if reward.Cmp(big.NewInt(2e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 2 (start)", "failed. Expected", big.NewInt(2e+18), "and calculated", reward)
+	}
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(2508545))
+	if reward.Cmp(big.NewInt(2e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 2 (end)", "failed. Expected", big.NewInt(2e+18), "and calculated", reward)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(2508546))
+	if reward.Cmp(big.NewInt(1e+18)) != 0 {
+		t.Error("TestCalcBaseBlockReward 1 (start)", "failed. Expected", big.NewInt(1e+18), "and calculated", reward)
+	}
+}
+
+func TestCalcUncleBlockReward(t *testing.T) {
+	config := params.MainnetChainConfig
+	reward := big.NewInt(8e+18)
+	// depth 1
+	u := CalcUncleBlockReward(config, big.NewInt(5), big.NewInt(4), reward)
+	if u.Cmp(big.NewInt(4e+18)) != 0 {
+		t.Error("TestCalcUncleBlockReward 8", "failed. Expected", big.NewInt(4e+18), "and calculated", u)
+	}
+
+	// depth 2
+	u = CalcUncleBlockReward(config, big.NewInt(8), big.NewInt(6), reward)
+	if u.Cmp(big.NewInt(0)) != 0 {
+		t.Error("TestCalcUncleBlockReward 8", "failed. Expected", big.NewInt(0), "and calculated", u)
+	}
+
+	// depth 3 (before negative fix)
+	u = CalcUncleBlockReward(config, big.NewInt(8), big.NewInt(5), reward)
+	if u.Cmp(big.NewInt(-4e+18)) != 0 {
+		t.Error("TestCalcUncleBlockReward 8", "failed. Expected", big.NewInt(-4e+18), "and calculated", u)
+	}
+
+	// depth 3 (after negative fix)
+	u = CalcUncleBlockReward(config, big.NewInt(10), big.NewInt(7), reward)
+	if u.Cmp(big.NewInt(0)) != 0 {
+		t.Error("TestCalcUncleBlockReward 8", "failed. Expected", big.NewInt(0), "and calculated", u)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(358364))
+	expected := big.NewInt(35e+17)
+	// depth 1 (after stepdown)
+	u = CalcUncleBlockReward(config, big.NewInt(8), big.NewInt(7), reward)
+	if u.Cmp(expected) != 0 {
+		t.Error("TestCalcUncleBlockReward 7", "failed. Expected", expected, "and calculated", u)
+	}
+
+	_, reward = CalcBaseBlockReward(config.Ubqhash, big.NewInt(1075091))
+	expected = big.NewInt(25e+17)
+	// depth 1 (after stepdown)
+	u = CalcUncleBlockReward(config, big.NewInt(8), big.NewInt(7), reward)
+	if u.Cmp(expected) != 0 {
+		t.Error("TestCalcUncleBlockReward 5", "failed. Expected", expected, "and calculated", u)
+	}
+
 }

consensus/ubqhash/ubqhash_test.go

@@ -142,7 +142,7 @@ func TestHashRate(t *testing.T) {
 	}
 
 	api := &API{ubqhash}
-	for i := 0; i < len(hashrate); i += 1 {
+	for i := 0; i < len(hashrate); i++ {
 		if res := api.SubmitHashRate(hashrate[i], ids[i]); !res {
 			t.Error("remote miner submit hashrate failed")
 		}

contracts/chequebook/api.go

@@ -1,68 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package chequebook
-
-import (
-	"errors"
-	"math/big"
-
-	"github.com/ubiq/go-ubiq/common"
-)
-
-const Version = "1.0"
-
-var errNoChequebook = errors.New("no chequebook")
-
-type API struct {
-	chequebookf func() *Chequebook
-}
-
-func NewAPI(ch func() *Chequebook) *API {
-	return &API{ch}
-}
-
-func (a *API) Balance() (string, error) {
-	ch := a.chequebookf()
-	if ch == nil {
-		return "", errNoChequebook
-	}
-	return ch.Balance().String(), nil
-}
-
-func (a *API) Issue(beneficiary common.Address, amount *big.Int) (cheque *Cheque, err error) {
-	ch := a.chequebookf()
-	if ch == nil {
-		return nil, errNoChequebook
-	}
-	return ch.Issue(beneficiary, amount)
-}
-
-func (a *API) Cash(cheque *Cheque) (txhash string, err error) {
-	ch := a.chequebookf()
-	if ch == nil {
-		return "", errNoChequebook
-	}
-	return ch.Cash(cheque)
-}
-
-func (a *API) Deposit(amount *big.Int) (txhash string, err error) {
-	ch := a.chequebookf()
-	if ch == nil {
-		return "", errNoChequebook
-	}
-	return ch.Deposit(amount)
-}

contracts/chequebook/cheque.go

@@ -1,641 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package chequebook package wraps the 'chequebook' Ethereum smart contract.
-//
-// The functions in this package allow using chequebook for
-// issuing, receiving, verifying cheques in ether; (auto)cashing cheques in ether
-// as well as (auto)depositing ether to the chequebook contract.
-package chequebook
-
-//go:generate abigen --sol contract/chequebook.sol --exc contract/mortal.sol:mortal,contract/owned.sol:owned --pkg contract --out contract/chequebook.go
-//go:generate go run ./gencode.go
-
-import (
-	"bytes"
-	"context"
-	"crypto/ecdsa"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"math/big"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/ubiq/go-ubiq/accounts/abi/bind"
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/common/hexutil"
-	"github.com/ubiq/go-ubiq/contracts/chequebook/contract"
-	"github.com/ubiq/go-ubiq/core/types"
-	"github.com/ubiq/go-ubiq/crypto"
-	"github.com/ubiq/go-ubiq/log"
-	"github.com/ubiq/go-ubiq/swarm/services/swap/swap"
-)
-
-// TODO(zelig): watch peer solvency and notify of bouncing cheques
-// TODO(zelig): enable paying with cheque by signing off
-
-// Some functionality requires interacting with the blockchain:
-// * setting current balance on peer's chequebook
-// * sending the transaction to cash the cheque
-// * depositing ether to the chequebook
-// * watching incoming ether
-
-var (
-	gasToCash = uint64(2000000) // gas cost of a cash transaction using chequebook
-	// gasToDeploy = uint64(3000000)
-)
-
-// Backend wraps all methods required for chequebook operation.
-type Backend interface {
-	bind.ContractBackend
-	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
-	BalanceAt(ctx context.Context, address common.Address, blockNum *big.Int) (*big.Int, error)
-}
-
-// Cheque represents a payment promise to a single beneficiary.
-type Cheque struct {
-	Contract    common.Address // address of chequebook, needed to avoid cross-contract submission
-	Beneficiary common.Address
-	Amount      *big.Int // cumulative amount of all funds sent
-	Sig         []byte   // signature Sign(Keccak256(contract, beneficiary, amount), prvKey)
-}
-
-func (ch *Cheque) String() string {
-	return fmt.Sprintf("contract: %s, beneficiary: %s, amount: %v, signature: %x", ch.Contract.Hex(), ch.Beneficiary.Hex(), ch.Amount, ch.Sig)
-}
-
-type Params struct {
-	ContractCode, ContractAbi string
-}
-
-var ContractParams = &Params{contract.ChequebookBin, contract.ChequebookABI}
-
-// Chequebook can create and sign cheques from a single contract to multiple beneficiaries.
-// It is the outgoing payment handler for peer to peer micropayments.
-type Chequebook struct {
-	path     string                      // path to chequebook file
-	prvKey   *ecdsa.PrivateKey           // private key to sign cheque with
-	lock     sync.Mutex                  //
-	backend  Backend                     // blockchain API
-	quit     chan bool                   // when closed causes autodeposit to stop
-	owner    common.Address              // owner address (derived from pubkey)
-	contract *contract.Chequebook        // abigen binding
-	session  *contract.ChequebookSession // abigen binding with Tx Opts
-
-	// persisted fields
-	balance      *big.Int                    // not synced with blockchain
-	contractAddr common.Address              // contract address
-	sent         map[common.Address]*big.Int //tallies for beneficiaries
-
-	txhash    string   // tx hash of last deposit tx
-	threshold *big.Int // threshold that triggers autodeposit if not nil
-	buffer    *big.Int // buffer to keep on top of balance for fork protection
-
-	log log.Logger // contextual logger with the contract address embedded
-}
-
-func (chbook *Chequebook) String() string {
-	return fmt.Sprintf("contract: %s, owner: %s, balance: %v, signer: %x", chbook.contractAddr.Hex(), chbook.owner.Hex(), chbook.balance, chbook.prvKey.PublicKey)
-}
-
-// NewChequebook creates a new Chequebook.
-func NewChequebook(path string, contractAddr common.Address, prvKey *ecdsa.PrivateKey, backend Backend) (self *Chequebook, err error) {
-	balance := new(big.Int)
-	sent := make(map[common.Address]*big.Int)
-
-	chbook, err := contract.NewChequebook(contractAddr, backend)
-	if err != nil {
-		return nil, err
-	}
-	transactOpts := bind.NewKeyedTransactor(prvKey)
-	session := &contract.ChequebookSession{
-		Contract:     chbook,
-		TransactOpts: *transactOpts,
-	}
-
-	self = &Chequebook{
-		prvKey:       prvKey,
-		balance:      balance,
-		contractAddr: contractAddr,
-		sent:         sent,
-		path:         path,
-		backend:      backend,
-		owner:        transactOpts.From,
-		contract:     chbook,
-		session:      session,
-		log:          log.New("contract", contractAddr),
-	}
-
-	if (contractAddr != common.Address{}) {
-		self.setBalanceFromBlockChain()
-		self.log.Trace("New chequebook initialised", "owner", self.owner, "balance", self.balance)
-	}
-	return
-}
-
-func (chbook *Chequebook) setBalanceFromBlockChain() {
-	balance, err := chbook.backend.BalanceAt(context.TODO(), chbook.contractAddr, nil)
-	if err != nil {
-		log.Error("Failed to retrieve chequebook balance", "err", err)
-	} else {
-		chbook.balance.Set(balance)
-	}
-}
-
-// LoadChequebook loads a chequebook from disk (file path).
-func LoadChequebook(path string, prvKey *ecdsa.PrivateKey, backend Backend, checkBalance bool) (self *Chequebook, err error) {
-	var data []byte
-	data, err = ioutil.ReadFile(path)
-	if err != nil {
-		return
-	}
-	self, _ = NewChequebook(path, common.Address{}, prvKey, backend)
-
-	err = json.Unmarshal(data, self)
-	if err != nil {
-		return nil, err
-	}
-	if checkBalance {
-		self.setBalanceFromBlockChain()
-	}
-	log.Trace("Loaded chequebook from disk", "path", path)
-
-	return
-}
-
-// chequebookFile is the JSON representation of a chequebook.
-type chequebookFile struct {
-	Balance  string
-	Contract string
-	Owner    string
-	Sent     map[string]string
-}
-
-// UnmarshalJSON deserialises a chequebook.
-func (chbook *Chequebook) UnmarshalJSON(data []byte) error {
-	var file chequebookFile
-	err := json.Unmarshal(data, &file)
-	if err != nil {
-		return err
-	}
-	_, ok := chbook.balance.SetString(file.Balance, 10)
-	if !ok {
-		return fmt.Errorf("cumulative amount sent: unable to convert string to big integer: %v", file.Balance)
-	}
-	chbook.contractAddr = common.HexToAddress(file.Contract)
-	for addr, sent := range file.Sent {
-		chbook.sent[common.HexToAddress(addr)], ok = new(big.Int).SetString(sent, 10)
-		if !ok {
-			return fmt.Errorf("beneficiary %v cumulative amount sent: unable to convert string to big integer: %v", addr, sent)
-		}
-	}
-	return nil
-}
-
-// MarshalJSON serialises a chequebook.
-func (chbook *Chequebook) MarshalJSON() ([]byte, error) {
-	var file = &chequebookFile{
-		Balance:  chbook.balance.String(),
-		Contract: chbook.contractAddr.Hex(),
-		Owner:    chbook.owner.Hex(),
-		Sent:     make(map[string]string),
-	}
-	for addr, sent := range chbook.sent {
-		file.Sent[addr.Hex()] = sent.String()
-	}
-	return json.Marshal(file)
-}
-
-// Save persists the chequebook on disk, remembering balance, contract address and
-// cumulative amount of funds sent for each beneficiary.
-func (chbook *Chequebook) Save() (err error) {
-	data, err := json.MarshalIndent(chbook, "", " ")
-	if err != nil {
-		return err
-	}
-	chbook.log.Trace("Saving chequebook to disk", chbook.path)
-
-	return ioutil.WriteFile(chbook.path, data, os.ModePerm)
-}
-
-// Stop quits the autodeposit go routine to terminate
-func (chbook *Chequebook) Stop() {
-	defer chbook.lock.Unlock()
-	chbook.lock.Lock()
-	if chbook.quit != nil {
-		close(chbook.quit)
-		chbook.quit = nil
-	}
-}
-
-// Issue creates a cheque signed by the chequebook owner's private key. The
-// signer commits to a contract (one that they own), a beneficiary and amount.
-func (chbook *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (ch *Cheque, err error) {
-	defer chbook.lock.Unlock()
-	chbook.lock.Lock()
-
-	if amount.Sign() <= 0 {
-		return nil, fmt.Errorf("amount must be greater than zero (%v)", amount)
-	}
-	if chbook.balance.Cmp(amount) < 0 {
-		err = fmt.Errorf("insufficient funds to issue cheque for amount: %v. balance: %v", amount, chbook.balance)
-	} else {
-		var sig []byte
-		sent, found := chbook.sent[beneficiary]
-		if !found {
-			sent = new(big.Int)
-			chbook.sent[beneficiary] = sent
-		}
-		sum := new(big.Int).Set(sent)
-		sum.Add(sum, amount)
-
-		sig, err = crypto.Sign(sigHash(chbook.contractAddr, beneficiary, sum), chbook.prvKey)
-		if err == nil {
-			ch = &Cheque{
-				Contract:    chbook.contractAddr,
-				Beneficiary: beneficiary,
-				Amount:      sum,
-				Sig:         sig,
-			}
-			sent.Set(sum)
-			chbook.balance.Sub(chbook.balance, amount) // subtract amount from balance
-		}
-	}
-
-	// auto deposit if threshold is set and balance is less then threshold
-	// note this is called even if issuing cheque fails
-	// so we reattempt depositing
-	if chbook.threshold != nil {
-		if chbook.balance.Cmp(chbook.threshold) < 0 {
-			send := new(big.Int).Sub(chbook.buffer, chbook.balance)
-			chbook.deposit(send)
-		}
-	}
-
-	return
-}
-
-// Cash is a convenience method to cash any cheque.
-func (chbook *Chequebook) Cash(ch *Cheque) (txhash string, err error) {
-	return ch.Cash(chbook.session)
-}
-
-// data to sign: contract address, beneficiary, cumulative amount of funds ever sent
-func sigHash(contract, beneficiary common.Address, sum *big.Int) []byte {
-	bigamount := sum.Bytes()
-	if len(bigamount) > 32 {
-		return nil
-	}
-	var amount32 [32]byte
-	copy(amount32[32-len(bigamount):32], bigamount)
-	input := append(contract.Bytes(), beneficiary.Bytes()...)
-	input = append(input, amount32[:]...)
-	return crypto.Keccak256(input)
-}
-
-// Balance returns the current balance of the chequebook.
-func (chbook *Chequebook) Balance() *big.Int {
-	defer chbook.lock.Unlock()
-	chbook.lock.Lock()
-	return new(big.Int).Set(chbook.balance)
-}
-
-// Owner returns the owner account of the chequebook.
-func (chbook *Chequebook) Owner() common.Address {
-	return chbook.owner
-}
-
-// Address returns the on-chain contract address of the chequebook.
-func (chbook *Chequebook) Address() common.Address {
-	return chbook.contractAddr
-}
-
-// Deposit deposits money to the chequebook account.
-func (chbook *Chequebook) Deposit(amount *big.Int) (string, error) {
-	defer chbook.lock.Unlock()
-	chbook.lock.Lock()
-	return chbook.deposit(amount)
-}
-
-// deposit deposits amount to the chequebook account.
-// The caller must hold self.lock.
-func (chbook *Chequebook) deposit(amount *big.Int) (string, error) {
-	// since the amount is variable here, we do not use sessions
-	depositTransactor := bind.NewKeyedTransactor(chbook.prvKey)
-	depositTransactor.Value = amount
-	chbookRaw := &contract.ChequebookRaw{Contract: chbook.contract}
-	tx, err := chbookRaw.Transfer(depositTransactor)
-	if err != nil {
-		chbook.log.Warn("Failed to fund chequebook", "amount", amount, "balance", chbook.balance, "target", chbook.buffer, "err", err)
-		return "", err
-	}
-	// assume that transaction is actually successful, we add the amount to balance right away
-	chbook.balance.Add(chbook.balance, amount)
-	chbook.log.Trace("Deposited funds to chequebook", "amount", amount, "balance", chbook.balance, "target", chbook.buffer)
-	return tx.Hash().Hex(), nil
-}
-
-// AutoDeposit (re)sets interval time and amount which triggers sending funds to the
-// chequebook. Contract backend needs to be set if threshold is not less than buffer, then
-// deposit will be triggered on every new cheque issued.
-func (chbook *Chequebook) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) {
-	defer chbook.lock.Unlock()
-	chbook.lock.Lock()
-	chbook.threshold = threshold
-	chbook.buffer = buffer
-	chbook.autoDeposit(interval)
-}
-
-// autoDeposit starts a goroutine that periodically sends funds to the chequebook
-// contract caller holds the lock the go routine terminates if Chequebook.quit is closed.
-func (chbook *Chequebook) autoDeposit(interval time.Duration) {
-	if chbook.quit != nil {
-		close(chbook.quit)
-		chbook.quit = nil
-	}
-	// if threshold >= balance autodeposit after every cheque issued
-	if interval == time.Duration(0) || chbook.threshold != nil && chbook.buffer != nil && chbook.threshold.Cmp(chbook.buffer) >= 0 {
-		return
-	}
-
-	ticker := time.NewTicker(interval)
-	chbook.quit = make(chan bool)
-	quit := chbook.quit
-
-	go func() {
-		for {
-			select {
-			case <-quit:
-				return
-			case <-ticker.C:
-				chbook.lock.Lock()
-				if chbook.balance.Cmp(chbook.buffer) < 0 {
-					amount := new(big.Int).Sub(chbook.buffer, chbook.balance)
-					txhash, err := chbook.deposit(amount)
-					if err == nil {
-						chbook.txhash = txhash
-					}
-				}
-				chbook.lock.Unlock()
-			}
-		}
-	}()
-}
-
-// Outbox can issue cheques from a single contract to a single beneficiary.
-type Outbox struct {
-	chequeBook  *Chequebook
-	beneficiary common.Address
-}
-
-// NewOutbox creates an outbox.
-func NewOutbox(chbook *Chequebook, beneficiary common.Address) *Outbox {
-	return &Outbox{chbook, beneficiary}
-}
-
-// Issue creates cheque.
-func (o *Outbox) Issue(amount *big.Int) (swap.Promise, error) {
-	return o.chequeBook.Issue(o.beneficiary, amount)
-}
-
-// AutoDeposit enables auto-deposits on the underlying chequebook.
-func (o *Outbox) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) {
-	o.chequeBook.AutoDeposit(interval, threshold, buffer)
-}
-
-// Stop helps satisfy the swap.OutPayment interface.
-func (o *Outbox) Stop() {}
-
-// String implements fmt.Stringer.
-func (o *Outbox) String() string {
-	return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", o.chequeBook.Address().Hex(), o.beneficiary.Hex(), o.chequeBook.Balance())
-}
-
-// Inbox can deposit, verify and cash cheques from a single contract to a single
-// beneficiary. It is the incoming payment handler for peer to peer micropayments.
-type Inbox struct {
-	lock        sync.Mutex
-	contract    common.Address              // peer's chequebook contract
-	beneficiary common.Address              // local peer's receiving address
-	sender      common.Address              // local peer's address to send cashing tx from
-	signer      *ecdsa.PublicKey            // peer's public key
-	txhash      string                      // tx hash of last cashing tx
-	session     *contract.ChequebookSession // abi contract backend with tx opts
-	quit        chan bool                   // when closed causes autocash to stop
-	maxUncashed *big.Int                    // threshold that triggers autocashing
-	cashed      *big.Int                    // cumulative amount cashed
-	cheque      *Cheque                     // last cheque, nil if none yet received
-	log         log.Logger                  // contextual logger with the contract address embedded
-}
-
-// NewInbox creates an Inbox. An Inboxes is not persisted, the cumulative sum is updated
-// from blockchain when first cheque is received.
-func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address, signer *ecdsa.PublicKey, abigen bind.ContractBackend) (self *Inbox, err error) {
-	if signer == nil {
-		return nil, fmt.Errorf("signer is null")
-	}
-	chbook, err := contract.NewChequebook(contractAddr, abigen)
-	if err != nil {
-		return nil, err
-	}
-	transactOpts := bind.NewKeyedTransactor(prvKey)
-	transactOpts.GasLimit = gasToCash
-	session := &contract.ChequebookSession{
-		Contract:     chbook,
-		TransactOpts: *transactOpts,
-	}
-	sender := transactOpts.From
-
-	self = &Inbox{
-		contract:    contractAddr,
-		beneficiary: beneficiary,
-		sender:      sender,
-		signer:      signer,
-		session:     session,
-		cashed:      new(big.Int).Set(common.Big0),
-		log:         log.New("contract", contractAddr),
-	}
-	self.log.Trace("New chequebook inbox initialized", "beneficiary", self.beneficiary, "signer", hexutil.Bytes(crypto.FromECDSAPub(signer)))
-	return
-}
-
-func (i *Inbox) String() string {
-	return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", i.contract.Hex(), i.beneficiary.Hex(), i.cheque.Amount)
-}
-
-// Stop quits the autocash goroutine.
-func (i *Inbox) Stop() {
-	defer i.lock.Unlock()
-	i.lock.Lock()
-	if i.quit != nil {
-		close(i.quit)
-		i.quit = nil
-	}
-}
-
-// Cash attempts to cash the current cheque.
-func (i *Inbox) Cash() (txhash string, err error) {
-	if i.cheque != nil {
-		txhash, err = i.cheque.Cash(i.session)
-		i.log.Trace("Cashing in chequebook cheque", "amount", i.cheque.Amount, "beneficiary", i.beneficiary)
-		i.cashed = i.cheque.Amount
-	}
-	return
-}
-
-// AutoCash (re)sets maximum time and amount which triggers cashing of the last uncashed
-// cheque if maxUncashed is set to 0, then autocash on receipt.
-func (i *Inbox) AutoCash(cashInterval time.Duration, maxUncashed *big.Int) {
-	defer i.lock.Unlock()
-	i.lock.Lock()
-	i.maxUncashed = maxUncashed
-	i.autoCash(cashInterval)
-}
-
-// autoCash starts a loop that periodically clears the last cheque
-// if the peer is trusted. Clearing period could be 24h or a week.
-// The caller must hold self.lock.
-func (i *Inbox) autoCash(cashInterval time.Duration) {
-	if i.quit != nil {
-		close(i.quit)
-		i.quit = nil
-	}
-	// if maxUncashed is set to 0, then autocash on receipt
-	if cashInterval == time.Duration(0) || i.maxUncashed != nil && i.maxUncashed.Sign() == 0 {
-		return
-	}
-
-	ticker := time.NewTicker(cashInterval)
-	i.quit = make(chan bool)
-	quit := i.quit
-
-	go func() {
-		for {
-			select {
-			case <-quit:
-				return
-			case <-ticker.C:
-				i.lock.Lock()
-				if i.cheque != nil && i.cheque.Amount.Cmp(i.cashed) != 0 {
-					txhash, err := i.Cash()
-					if err == nil {
-						i.txhash = txhash
-					}
-				}
-				i.lock.Unlock()
-			}
-		}
-	}()
-}
-
-// Receive is called to deposit the latest cheque to the incoming Inbox.
-// The given promise must be a *Cheque.
-func (i *Inbox) Receive(promise swap.Promise) (*big.Int, error) {
-	ch := promise.(*Cheque)
-
-	defer i.lock.Unlock()
-	i.lock.Lock()
-
-	var sum *big.Int
-	if i.cheque == nil {
-		// the sum is checked against the blockchain once a cheque is received
-		tally, err := i.session.Sent(i.beneficiary)
-		if err != nil {
-			return nil, fmt.Errorf("inbox: error calling backend to set amount: %v", err)
-		}
-		sum = tally
-	} else {
-		sum = i.cheque.Amount
-	}
-
-	amount, err := ch.Verify(i.signer, i.contract, i.beneficiary, sum)
-	var uncashed *big.Int
-	if err == nil {
-		i.cheque = ch
-
-		if i.maxUncashed != nil {
-			uncashed = new(big.Int).Sub(ch.Amount, i.cashed)
-			if i.maxUncashed.Cmp(uncashed) < 0 {
-				i.Cash()
-			}
-		}
-		i.log.Trace("Received cheque in chequebook inbox", "amount", amount, "uncashed", uncashed)
-	}
-
-	return amount, err
-}
-
-// Verify verifies cheque for signer, contract, beneficiary, amount, valid signature.
-func (ch *Cheque) Verify(signerKey *ecdsa.PublicKey, contract, beneficiary common.Address, sum *big.Int) (*big.Int, error) {
-	log.Trace("Verifying chequebook cheque", "cheque", ch, "sum", sum)
-	if sum == nil {
-		return nil, fmt.Errorf("invalid amount")
-	}
-
-	if ch.Beneficiary != beneficiary {
-		return nil, fmt.Errorf("beneficiary mismatch: %v != %v", ch.Beneficiary.Hex(), beneficiary.Hex())
-	}
-	if ch.Contract != contract {
-		return nil, fmt.Errorf("contract mismatch: %v != %v", ch.Contract.Hex(), contract.Hex())
-	}
-
-	amount := new(big.Int).Set(ch.Amount)
-	if sum != nil {
-		amount.Sub(amount, sum)
-		if amount.Sign() <= 0 {
-			return nil, fmt.Errorf("incorrect amount: %v <= 0", amount)
-		}
-	}
-
-	pubKey, err := crypto.SigToPub(sigHash(ch.Contract, beneficiary, ch.Amount), ch.Sig)
-	if err != nil {
-		return nil, fmt.Errorf("invalid signature: %v", err)
-	}
-	if !bytes.Equal(crypto.FromECDSAPub(pubKey), crypto.FromECDSAPub(signerKey)) {
-		return nil, fmt.Errorf("signer mismatch: %x != %x", crypto.FromECDSAPub(pubKey), crypto.FromECDSAPub(signerKey))
-	}
-	return amount, nil
-}
-
-// v/r/s representation of signature
-func sig2vrs(sig []byte) (v byte, r, s [32]byte) {
-	v = sig[64] + 27
-	copy(r[:], sig[:32])
-	copy(s[:], sig[32:64])
-	return
-}
-
-// Cash cashes the cheque by sending an Ethereum transaction.
-func (ch *Cheque) Cash(session *contract.ChequebookSession) (string, error) {
-	v, r, s := sig2vrs(ch.Sig)
-	tx, err := session.Cash(ch.Beneficiary, ch.Amount, v, r, s)
-	if err != nil {
-		return "", err
-	}
-	return tx.Hash().Hex(), nil
-}
-
-// ValidateCode checks that the on-chain code at address matches the expected chequebook
-// contract code. This is used to detect suicided chequebooks.
-func ValidateCode(ctx context.Context, b Backend, address common.Address) (ok bool, err error) {
-	code, err := b.CodeAt(ctx, address, nil)
-	if err != nil {
-		return false, err
-	}
-	return bytes.Equal(code, common.FromHex(contract.ContractDeployedCode)), nil
-}

contracts/chequebook/cheque_test.go

@@ -1,487 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package chequebook
-
-import (
-	"crypto/ecdsa"
-	"math/big"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/ubiq/go-ubiq/accounts/abi/bind"
-	"github.com/ubiq/go-ubiq/accounts/abi/bind/backends"
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/contracts/chequebook/contract"
-	"github.com/ubiq/go-ubiq/core"
-	"github.com/ubiq/go-ubiq/crypto"
-)
-
-var (
-	key0, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-	key1, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
-	key2, _ = crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
-	addr0   = crypto.PubkeyToAddress(key0.PublicKey)
-	addr1   = crypto.PubkeyToAddress(key1.PublicKey)
-	addr2   = crypto.PubkeyToAddress(key2.PublicKey)
-)
-
-func newTestBackend() *backends.SimulatedBackend {
-	return backends.NewSimulatedBackend(core.GenesisAlloc{
-		addr0: {Balance: big.NewInt(1000000000)},
-		addr1: {Balance: big.NewInt(1000000000)},
-		addr2: {Balance: big.NewInt(1000000000)},
-	}, 10000000)
-}
-
-func deploy(prvKey *ecdsa.PrivateKey, amount *big.Int, backend *backends.SimulatedBackend) (common.Address, error) {
-	deployTransactor := bind.NewKeyedTransactor(prvKey)
-	deployTransactor.Value = amount
-	addr, _, _, err := contract.DeployChequebook(deployTransactor, backend)
-	if err != nil {
-		return common.Address{}, err
-	}
-	backend.Commit()
-	return addr, nil
-}
-
-func TestIssueAndReceive(t *testing.T) {
-	path := filepath.Join(os.TempDir(), "chequebook-test.json")
-	backend := newTestBackend()
-	addr0, err := deploy(key0, big.NewInt(0), backend)
-	if err != nil {
-		t.Fatalf("deploy contract: expected no error, got %v", err)
-	}
-	chbook, err := NewChequebook(path, addr0, key0, backend)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	chbook.sent[addr1] = new(big.Int).SetUint64(42)
-	amount := common.Big1
-
-	if _, err = chbook.Issue(addr1, amount); err == nil {
-		t.Fatalf("expected insufficient funds error, got none")
-	}
-
-	chbook.balance = new(big.Int).Set(common.Big1)
-	if chbook.Balance().Cmp(common.Big1) != 0 {
-		t.Fatalf("expected: %v, got %v", "0", chbook.Balance())
-	}
-
-	ch, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if chbook.Balance().Sign() != 0 {
-		t.Errorf("expected: %v, got %v", "0", chbook.Balance())
-	}
-
-	chbox, err := NewInbox(key1, addr0, addr1, &key0.PublicKey, backend)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	received, err := chbox.Receive(ch)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if received.Cmp(big.NewInt(43)) != 0 {
-		t.Errorf("expected: %v, got %v", "43", received)
-	}
-
-}
-
-func TestCheckbookFile(t *testing.T) {
-	path := filepath.Join(os.TempDir(), "chequebook-test.json")
-	backend := newTestBackend()
-	chbook, err := NewChequebook(path, addr0, key0, backend)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	chbook.sent[addr1] = new(big.Int).SetUint64(42)
-	chbook.balance = new(big.Int).Set(common.Big1)
-
-	chbook.Save()
-
-	chbook, err = LoadChequebook(path, key0, backend, false)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if chbook.Balance().Cmp(common.Big1) != 0 {
-		t.Errorf("expected: %v, got %v", "0", chbook.Balance())
-	}
-
-	var ch *Cheque
-	if ch, err = chbook.Issue(addr1, common.Big1); err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if ch.Amount.Cmp(new(big.Int).SetUint64(43)) != 0 {
-		t.Errorf("expected: %v, got %v", "0", ch.Amount)
-	}
-
-	err = chbook.Save()
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-}
-
-func TestVerifyErrors(t *testing.T) {
-	path0 := filepath.Join(os.TempDir(), "chequebook-test-0.json")
-	backend := newTestBackend()
-	contr0, err := deploy(key0, common.Big2, backend)
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-	chbook0, err := NewChequebook(path0, contr0, key0, backend)
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-
-	path1 := filepath.Join(os.TempDir(), "chequebook-test-1.json")
-	contr1, _ := deploy(key1, common.Big2, backend)
-	chbook1, err := NewChequebook(path1, contr1, key1, backend)
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-
-	chbook0.sent[addr1] = new(big.Int).SetUint64(42)
-	chbook0.balance = new(big.Int).Set(common.Big2)
-	chbook1.balance = new(big.Int).Set(common.Big1)
-	amount := common.Big1
-	ch0, err := chbook0.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	received, err := chbox.Receive(ch0)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	if received.Cmp(big.NewInt(43)) != 0 {
-		t.Errorf("expected: %v, got %v", "43", received)
-	}
-
-	ch1, err := chbook0.Issue(addr2, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	received, err = chbox.Receive(ch1)
-	t.Logf("correct error: %v", err)
-	if err == nil {
-		t.Fatalf("expected receiver error, got none and value %v", received)
-	}
-
-	ch2, err := chbook1.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	received, err = chbox.Receive(ch2)
-	t.Logf("correct error: %v", err)
-	if err == nil {
-		t.Fatalf("expected sender error, got none and value %v", received)
-	}
-
-	_, err = chbook1.Issue(addr1, new(big.Int).SetInt64(-1))
-	t.Logf("correct error: %v", err)
-	if err == nil {
-		t.Fatalf("expected incorrect amount error, got none")
-	}
-
-	received, err = chbox.Receive(ch0)
-	t.Logf("correct error: %v", err)
-	if err == nil {
-		t.Fatalf("expected incorrect amount error, got none and value %v", received)
-	}
-
-}
-
-func TestDeposit(t *testing.T) {
-	path0 := filepath.Join(os.TempDir(), "chequebook-test-0.json")
-	backend := newTestBackend()
-	contr0, _ := deploy(key0, new(big.Int), backend)
-
-	chbook, err := NewChequebook(path0, contr0, key0, backend)
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-
-	balance := new(big.Int).SetUint64(42)
-	chbook.Deposit(balance)
-	backend.Commit()
-	if chbook.Balance().Cmp(balance) != 0 {
-		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())
-	}
-
-	amount := common.Big1
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	exp := new(big.Int).SetUint64(41)
-	if chbook.Balance().Cmp(exp) != 0 {
-		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())
-	}
-
-	// autodeposit on each issue
-	chbook.AutoDeposit(0, balance, balance)
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	if chbook.Balance().Cmp(balance) != 0 {
-		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())
-	}
-
-	// autodeposit off
-	chbook.AutoDeposit(0, common.Big0, balance)
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	exp = new(big.Int).SetUint64(40)
-	if chbook.Balance().Cmp(exp) != 0 {
-		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())
-	}
-
-	// autodeposit every 200ms if new cheque issued
-	interval := 200 * time.Millisecond
-	chbook.AutoDeposit(interval, common.Big1, balance)
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	exp = new(big.Int).SetUint64(38)
-	if chbook.Balance().Cmp(exp) != 0 {
-		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())
-	}
-
-	time.Sleep(3 * interval)
-	backend.Commit()
-	if chbook.Balance().Cmp(balance) != 0 {
-		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())
-	}
-
-	exp = new(big.Int).SetUint64(40)
-	chbook.AutoDeposit(4*interval, exp, balance)
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	time.Sleep(3 * interval)
-	backend.Commit()
-	if chbook.Balance().Cmp(exp) != 0 {
-		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())
-	}
-
-	_, err = chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	time.Sleep(1 * interval)
-	backend.Commit()
-
-	if chbook.Balance().Cmp(balance) != 0 {
-		t.Fatalf("expected balance %v, got %v", balance, chbook.Balance())
-	}
-
-	chbook.AutoDeposit(1*interval, common.Big0, balance)
-	chbook.Stop()
-
-	_, err = chbook.Issue(addr1, common.Big1)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	_, err = chbook.Issue(addr1, common.Big2)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	time.Sleep(1 * interval)
-	backend.Commit()
-
-	exp = new(big.Int).SetUint64(39)
-	if chbook.Balance().Cmp(exp) != 0 {
-		t.Fatalf("expected balance %v, got %v", exp, chbook.Balance())
-	}
-
-}
-
-func TestCash(t *testing.T) {
-	path := filepath.Join(os.TempDir(), "chequebook-test.json")
-	backend := newTestBackend()
-	contr0, _ := deploy(key0, common.Big2, backend)
-
-	chbook, err := NewChequebook(path, contr0, key0, backend)
-	if err != nil {
-		t.Errorf("expected no error, got %v", err)
-	}
-	chbook.sent[addr1] = new(big.Int).SetUint64(42)
-	amount := common.Big1
-	chbook.balance = new(big.Int).Set(common.Big1)
-	ch, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	// cashing latest cheque
-	if _, err = chbox.Receive(ch); err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if _, err = ch.Cash(chbook.session); err != nil {
-		t.Fatal("Cash failed:", err)
-	}
-	backend.Commit()
-
-	chbook.balance = new(big.Int).Set(common.Big3)
-	ch0, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	ch1, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	interval := 10 * time.Millisecond
-	// setting autocash with interval of 10ms
-	chbox.AutoCash(interval, nil)
-	_, err = chbox.Receive(ch0)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	_, err = chbox.Receive(ch1)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	// after 3x interval time and 2 cheques received, exactly one cashing tx is sent
-	time.Sleep(4 * interval)
-	backend.Commit()
-
-	// after stopping autocash no more tx are sent
-	ch2, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	chbox.Stop()
-	_, err = chbox.Receive(ch2)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	time.Sleep(2 * interval)
-	backend.Commit()
-
-	// autocash below 1
-	chbook.balance = big.NewInt(2)
-	chbox.AutoCash(0, common.Big1)
-
-	ch3, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	ch4, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	_, err = chbox.Receive(ch3)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-	_, err = chbox.Receive(ch4)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	// autochash on receipt when maxUncashed is 0
-	chbook.balance = new(big.Int).Set(common.Big2)
-	chbox.AutoCash(0, common.Big0)
-
-	ch5, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	ch6, err := chbook.Issue(addr1, amount)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-
-	_, err = chbox.Receive(ch5)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-	_, err = chbox.Receive(ch6)
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	backend.Commit()
-
-}

contracts/chequebook/contract/chequebook.go

@@ -1,367 +0,0 @@
-// Code generated - DO NOT EDIT.
-// This file is a generated binding and any manual changes will be lost.
-
-package contract
-
-import (
-	"math/big"
-	"strings"
-
-	ethereum "github.com/ubiq/go-ubiq"
-	"github.com/ubiq/go-ubiq/accounts/abi"
-	"github.com/ubiq/go-ubiq/accounts/abi/bind"
-	"github.com/ubiq/go-ubiq/common"
-	"github.com/ubiq/go-ubiq/core/types"
-	"github.com/ubiq/go-ubiq/event"
-)
-
-// ChequebookABI is the input ABI used to generate the binding from.
-const ChequebookABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"kill\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"sent\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"beneficiary\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"},{\"name\":\"sig_v\",\"type\":\"uint8\"},{\"name\":\"sig_r\",\"type\":\"bytes32\"},{\"name\":\"sig_s\",\"type\":\"bytes32\"}],\"name\":\"cash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"deadbeat\",\"type\":\"address\"}],\"name\":\"Overdraft\",\"type\":\"event\"}]"
-
-// ChequebookBin is the compiled bytecode used for deploying new contracts.
-const ChequebookBin = `0x606060405260008054600160a060020a033316600160a060020a03199091161790556102ec806100306000396000f3006060604052600436106100565763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166341c0e1b581146100585780637bf786f81461006b578063fbf788d61461009c575b005b341561006357600080fd5b6100566100ca565b341561007657600080fd5b61008a600160a060020a03600435166100f1565b60405190815260200160405180910390f35b34156100a757600080fd5b610056600160a060020a036004351660243560ff60443516606435608435610103565b60005433600160a060020a03908116911614156100ef57600054600160a060020a0316ff5b565b60016020526000908152604090205481565b600160a060020a0385166000908152600160205260408120548190861161012957600080fd5b3087876040516c01000000000000000000000000600160a060020a03948516810282529290931690910260148301526028820152604801604051809103902091506001828686866040516000815260200160405260006040516020015260405193845260ff90921660208085019190915260408085019290925260608401929092526080909201915160208103908084039060008661646e5a03f115156101cf57600080fd5b505060206040510351600054600160a060020a039081169116146101f257600080fd5b50600160a060020a03808716600090815260016020526040902054860390301631811161026257600160a060020a0387166000818152600160205260409081902088905582156108fc0290839051600060405180830381858888f19350505050151561025d57600080fd5b6102b7565b6000547f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f97890600160a060020a0316604051600160a060020a03909116815260200160405180910390a186600160a060020a0316ff5b505050505050505600a165627a7a72305820533e856fc37e3d64d1706bcc7dfb6b1d490c8d566ea498d9d01ec08965a896ca0029`
-
-// DeployChequebook deploys a new Ubiq contract, binding an instance of Chequebook to it.
-func DeployChequebook(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Chequebook, error) {
-	parsed, err := abi.JSON(strings.NewReader(ChequebookABI))
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ChequebookBin), backend)
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	return address, tx, &Chequebook{ChequebookCaller: ChequebookCaller{contract: contract}, ChequebookTransactor: ChequebookTransactor{contract: contract}, ChequebookFilterer: ChequebookFilterer{contract: contract}}, nil
-}
-
-// Chequebook is an auto generated Go binding around an Ubiq contract.
-type Chequebook struct {
-	ChequebookCaller     // Read-only binding to the contract
-	ChequebookTransactor // Write-only binding to the contract
-	ChequebookFilterer   // Log filterer for contract events
-}
-
-// ChequebookCaller is an auto generated read-only Go binding around an Ubiq contract.
-type ChequebookCaller struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ChequebookTransactor is an auto generated write-only Go binding around an Ubiq contract.
-type ChequebookTransactor struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ChequebookFilterer is an auto generated log filtering Go binding around an Ubiq contract events.
-type ChequebookFilterer struct {
-	contract *bind.BoundContract // Generic contract wrapper for the low level calls
-}
-
-// ChequebookSession is an auto generated Go binding around an Ubiq contract,
-// with pre-set call and transact options.
-type ChequebookSession struct {
-	Contract     *Chequebook       // Generic contract binding to set the session for
-	CallOpts     bind.CallOpts     // Call options to use throughout this session
-	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-}
-
-// ChequebookCallerSession is an auto generated read-only Go binding around an Ubiq contract,
-// with pre-set call options.
-type ChequebookCallerSession struct {
-	Contract *ChequebookCaller // Generic contract caller binding to set the session for
-	CallOpts bind.CallOpts     // Call options to use throughout this session
-}
-
-// ChequebookTransactorSession is an auto generated write-only Go binding around an Ubiq contract,
-// with pre-set transact options.
-type ChequebookTransactorSession struct {
-	Contract     *ChequebookTransactor // Generic contract transactor binding to set the session for
-	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
-}
-
-// ChequebookRaw is an auto generated low-level Go binding around an Ubiq contract.
-type ChequebookRaw struct {
-	Contract *Chequebook // Generic contract binding to access the raw methods on
-}
-
-// ChequebookCallerRaw is an auto generated low-level read-only Go binding around an Ubiq contract.
-type ChequebookCallerRaw struct {
-	Contract *ChequebookCaller // Generic read-only contract binding to access the raw methods on
-}
-
-// ChequebookTransactorRaw is an auto generated low-level write-only Go binding around an Ubiq contract.
-type ChequebookTransactorRaw struct {
-	Contract *ChequebookTransactor // Generic write-only contract binding to access the raw methods on
-}
-
-// NewChequebook creates a new instance of Chequebook, bound to a specific deployed contract.
-func NewChequebook(address common.Address, backend bind.ContractBackend) (*Chequebook, error) {
-	contract, err := bindChequebook(address, backend, backend, backend)
-	if err != nil {
-		return nil, err
-	}
-	return &Chequebook{ChequebookCaller: ChequebookCaller{contract: contract}, ChequebookTransactor: ChequebookTransactor{contract: contract}, ChequebookFilterer: ChequebookFilterer{contract: contract}}, nil
-}
-
-// NewChequebookCaller creates a new read-only instance of Chequebook, bound to a specific deployed contract.
-func NewChequebookCaller(address common.Address, caller bind.ContractCaller) (*ChequebookCaller, error) {
-	contract, err := bindChequebook(address, caller, nil, nil)
-	if err != nil {
-		return nil, err
-	}
-	return &ChequebookCaller{contract: contract}, nil
-}
-
-// NewChequebookTransactor creates a new write-only instance of Chequebook, bound to a specific deployed contract.
-func NewChequebookTransactor(address common.Address, transactor bind.ContractTransactor) (*ChequebookTransactor, error) {
-	contract, err := bindChequebook(address, nil, transactor, nil)
-	if err != nil {
-		return nil, err
-	}
-	return &ChequebookTransactor{contract: contract}, nil
-}
-
-// NewChequebookFilterer creates a new log filterer instance of Chequebook, bound to a specific deployed contract.
-func NewChequebookFilterer(address common.Address, filterer bind.ContractFilterer) (*ChequebookFilterer, error) {
-	contract, err := bindChequebook(address, nil, nil, filterer)
-	if err != nil {
-		return nil, err
-	}
-	return &ChequebookFilterer{contract: contract}, nil
-}
-
-// bindChequebook binds a generic wrapper to an already deployed contract.
-func bindChequebook(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
-	parsed, err := abi.JSON(strings.NewReader(ChequebookABI))
-	if err != nil {
-		return nil, err
-	}
-	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Chequebook *ChequebookRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Chequebook.Contract.ChequebookCaller.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Chequebook *ChequebookRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Chequebook.Contract.ChequebookTransactor.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Chequebook *ChequebookRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Chequebook.Contract.ChequebookTransactor.contract.Transact(opts, method, params...)
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (_Chequebook *ChequebookCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-	return _Chequebook.Contract.contract.Call(opts, result, method, params...)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (_Chequebook *ChequebookTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Chequebook.Contract.contract.Transfer(opts)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (_Chequebook *ChequebookTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	return _Chequebook.Contract.contract.Transact(opts, method, params...)
-}
-
-// Sent is a free data retrieval call binding the contract method 0x7bf786f8.
-//
-// Solidity: function sent( address) constant returns(uint256)
-func (_Chequebook *ChequebookCaller) Sent(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
-	var (
-		ret0 = new(*big.Int)
-	)
-	out := ret0
-	err := _Chequebook.contract.Call(opts, out, "sent", arg0)
-	return *ret0, err
-}
-
-// Sent is a free data retrieval call binding the contract method 0x7bf786f8.
-//
-// Solidity: function sent( address) constant returns(uint256)
-func (_Chequebook *ChequebookSession) Sent(arg0 common.Address) (*big.Int, error) {
-	return _Chequebook.Contract.Sent(&_Chequebook.CallOpts, arg0)
-}
-
-// Sent is a free data retrieval call binding the contract method 0x7bf786f8.
-//
-// Solidity: function sent( address) constant returns(uint256)
-func (_Chequebook *ChequebookCallerSession) Sent(arg0 common.Address) (*big.Int, error) {
-	return _Chequebook.Contract.Sent(&_Chequebook.CallOpts, arg0)
-}
-
-// Cash is a paid mutator transaction binding the contract method 0xfbf788d6.
-//
-// Solidity: function cash(beneficiary address, amount uint256, sig_v uint8, sig_r bytes32, sig_s bytes32) returns()
-func (_Chequebook *ChequebookTransactor) Cash(opts *bind.TransactOpts, beneficiary common.Address, amount *big.Int, sigV uint8, sigR [32]byte, sigS [32]byte) (*types.Transaction, error) {
-	return _Chequebook.contract.Transact(opts, "cash", beneficiary, amount, sigV, sigR, sigS)
-}
-
-// Cash is a paid mutator transaction binding the contract method 0xfbf788d6.
-//
-// Solidity: function cash(beneficiary address, amount uint256, sig_v uint8, sig_r bytes32, sig_s bytes32) returns()
-func (_Chequebook *ChequebookSession) Cash(beneficiary common.Address, amount *big.Int, sigV uint8, sigR [32]byte, sigS [32]byte) (*types.Transaction, error) {
-	return _Chequebook.Contract.Cash(&_Chequebook.TransactOpts, beneficiary, amount, sigV, sigR, sigS)
-}
-
-// Cash is a paid mutator transaction binding the contract method 0xfbf788d6.
-//
-// Solidity: function cash(beneficiary address, amount uint256, sig_v uint8, sig_r bytes32, sig_s bytes32) returns()
-func (_Chequebook *ChequebookTransactorSession) Cash(beneficiary common.Address, amount *big.Int, sigV uint8, sigR [32]byte, sigS [32]byte) (*types.Transaction, error) {
-	return _Chequebook.Contract.Cash(&_Chequebook.TransactOpts, beneficiary, amount, sigV, sigR, sigS)
-}
-
-// Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.
-//
-// Solidity: function kill() returns()
-func (_Chequebook *ChequebookTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error) {
-	return _Chequebook.contract.Transact(opts, "kill")
-}
-
-// Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.
-//
-// Solidity: function kill() returns()
-func (_Chequebook *ChequebookSession) Kill() (*types.Transaction, error) {
-	return _Chequebook.Contract.Kill(&_Chequebook.TransactOpts)
-}
-
-// Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.
-//
-// Solidity: function kill() returns()
-func (_Chequebook *ChequebookTransactorSession) Kill() (*types.Transaction, error) {
-	return _Chequebook.Contract.Kill(&_Chequebook.TransactOpts)
-}
-
-// ChequebookOverdraftIterator is returned from FilterOverdraft and is used to iterate over the raw logs and unpacked data for Overdraft events raised by the Chequebook contract.
-type ChequebookOverdraftIterator struct {
-	Event *ChequebookOverdraft // Event containing the contract specifics and raw log
-
-	contract *bind.BoundContract // Generic contract to use for unpacking event data
-	event    string              // Event name to use for unpacking event data
-
-	logs chan types.Log        // Log channel receiving the found contract events
-	sub  ethereum.Subscription // Subscription for errors, completion and termination
-	done bool                  // Whether the subscription completed delivering logs
-	fail error                 // Occurred error to stop iteration
-}
-
-// Next advances the iterator to the subsequent event, returning whether there
-// are any more events found. In case of a retrieval or parsing error, false is
-// returned and Error() can be queried for the exact failure.
-func (it *ChequebookOverdraftIterator) Next() bool {
-	// If the iterator failed, stop iterating
-	if it.fail != nil {
-		return false
-	}
-	// If the iterator completed, deliver directly whatever's available
-	if it.done {
-		select {
-		case log := <-it.logs:
-			it.Event = new(ChequebookOverdraft)
-			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
-				it.fail = err
-				return false
-			}
-			it.Event.Raw = log
-			return true
-
-		default:
-			return false
-		}
-	}
-	// Iterator still in progress, wait for either a data or an error event
-	select {
-	case log := <-it.logs:
-		it.Event = new(ChequebookOverdraft)
-		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
-			it.fail = err
-			return false
-		}
-		it.Event.Raw = log
-		return true
-
-	case err := <-it.sub.Err():
-		it.done = true
-		it.fail = err
-		return it.Next()
-	}
-}
-
-// Error retruned any retrieval or parsing error occurred during filtering.
-func (it *ChequebookOverdraftIterator) Error() error {
-	return it.fail
-}
-
-// Close terminates the iteration process, releasing any pending underlying
-// resources.
-func (it *ChequebookOverdraftIterator) Close() error {
-	it.sub.Unsubscribe()
-	return nil
-}
-
-// ChequebookOverdraft represents a Overdraft event raised by the Chequebook contract.
-type ChequebookOverdraft struct {
-	Deadbeat common.Address
-	Raw      types.Log // Blockchain specific contextual infos
-}
-
-// FilterOverdraft is a free log retrieval operation binding the contract event 0x2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f978.
-//
-// Solidity: event Overdraft(deadbeat address)
-func (_Chequebook *ChequebookFilterer) FilterOverdraft(opts *bind.FilterOpts) (*ChequebookOverdraftIterator, error) {
-
-	logs, sub, err := _Chequebook.contract.FilterLogs(opts, "Overdraft")
-	if err != nil {
-		return nil, err
-	}
-	return &ChequebookOverdraftIterator{contract: _Chequebook.contract, event: "Overdraft", logs: logs, sub: sub}, nil
-}
-
-// WatchOverdraft is a free log subscription operation binding the contract event 0x2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f978.
-//
-// Solidity: event Overdraft(deadbeat address)
-func (_Chequebook *ChequebookFilterer) WatchOverdraft(opts *bind.WatchOpts, sink chan<- *ChequebookOverdraft) (event.Subscription, error) {
-
-	logs, sub, err := _Chequebook.contract.WatchLogs(opts, "Overdraft")
-	if err != nil {
-		return nil, err
-	}
-	return event.NewSubscription(func(quit <-chan struct{}) error {
-		defer sub.Unsubscribe()
-		for {
-			select {
-			case log := <-logs:
-				// New log arrived, parse the event and forward to the user
-				event := new(ChequebookOverdraft)
-				if err := _Chequebook.contract.UnpackLog(event, "Overdraft", log); err != nil {
-					return err
-				}
-				event.Raw = log
-
-				select {
-				case sink <- event:
-				case err := <-sub.Err():
-					return err
-				case <-quit:
-					return nil
-				}
-			case err := <-sub.Err():
-				return err
-			case <-quit:
-				return nil
-			}
-		}
-	}), nil
-}

contracts/chequebook/contract/chequebook.sol

@@ -1,47 +0,0 @@
-pragma solidity ^0.4.18;
-
-import "./mortal.sol";
-
-/// @title Chequebook for Ethereum micropayments
-/// @author Daniel A. Nagy <daniel@ethereum.org>
-contract chequebook is mortal {
-    // Cumulative paid amount in wei to each beneficiary
-    mapping (address => uint256) public sent;
-
-    /// @notice Overdraft event
-    event Overdraft(address deadbeat);
-
-    // Allow sending ether to the chequebook.
-    function() public payable { }
-
-    /// @notice Cash cheque
-    ///
-    /// @param beneficiary beneficiary address
-    /// @param amount cumulative amount in wei
-    /// @param sig_v signature parameter v
-    /// @param sig_r signature parameter r
-    /// @param sig_s signature parameter s
-    /// The digital signature is calculated on the concatenated triplet of contract address, beneficiary address and cumulative amount
-    function cash(address beneficiary, uint256 amount, uint8 sig_v, bytes32 sig_r, bytes32 sig_s) public {
-        // Check if the cheque is old.
-        // Only cheques that are more recent than the last cashed one are considered.
-        require(amount > sent[beneficiary]);
-        // Check the digital signature of the cheque.
-        bytes32 hash = keccak256(address(this), beneficiary, amount);
-        require(owner == ecrecover(hash, sig_v, sig_r, sig_s));
-        // Attempt sending the difference between the cumulative amount on the cheque
-        // and the cumulative amount on the last cashed cheque to beneficiary.
-        uint256 diff = amount - sent[beneficiary];
-        if (diff <= this.balance) {
-            // update the cumulative amount before sending
-            sent[beneficiary] = amount;
-            beneficiary.transfer(diff);
-        } else {
-            // Upon failure, punish owner for writing a bounced cheque.
-            // owner.sendToDebtorsPrison();
-            Overdraft(owner);
-            // Compensate beneficiary.
-            selfdestruct(beneficiary);
-        }
-    }
-}

contracts/chequebook/contract/code.go

@@ -1,5 +0,0 @@
-package contract
-
-// ContractDeployedCode is used to detect suicides. This constant needs to be
-// updated when the contract code is changed.
-const ContractDeployedCode = "0x6060604052600436106100565763ffffffff7c010000000000000000000000000000000000000000000000000000000060003504166341c0e1b581146100585780637bf786f81461006b578063fbf788d61461009c575b005b341561006357600080fd5b6100566100ca565b341561007657600080fd5b61008a600160a060020a03600435166100f1565b60405190815260200160405180910390f35b34156100a757600080fd5b610056600160a060020a036004351660243560ff60443516606435608435610103565b60005433600160a060020a03908116911614156100ef57600054600160a060020a0316ff5b565b60016020526000908152604090205481565b600160a060020a0385166000908152600160205260408120548190861161012957600080fd5b3087876040516c01000000000000000000000000600160a060020a03948516810282529290931690910260148301526028820152604801604051809103902091506001828686866040516000815260200160405260006040516020015260405193845260ff90921660208085019190915260408085019290925260608401929092526080909201915160208103908084039060008661646e5a03f115156101cf57600080fd5b505060206040510351600054600160a060020a039081169116146101f257600080fd5b50600160a060020a03808716600090815260016020526040902054860390301631811161026257600160a060020a0387166000818152600160205260409081902088905582156108fc0290839051600060405180830381858888f19350505050151561025d57600080fd5b6102b7565b6000547f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f97890600160a060020a0316604051600160a060020a03909116815260200160405180910390a186600160a060020a0316ff5b505050505050505600a165627a7a72305820533e856fc37e3d64d1706bcc7dfb6b1d490c8d566ea498d9d01ec08965a896ca0029"

contracts/chequebook/contract/mortal.sol

@@ -1,10 +0,0 @@
-pragma solidity ^0.4.0;
-
-import "./owned.sol";
-
-contract mortal is owned {
-    function kill() public {
-        if (msg.sender == owner)
-            selfdestruct(owner);
-    }
-}

contracts/chequebook/contract/owned.sol

@@ -1,15 +0,0 @@
-pragma solidity ^0.4.0;
-
-contract owned {
-    address owner;
-
-    modifier onlyowner() {
-        if (msg.sender == owner) {
-            _;
-        }
-    }
-
-    function owned() public {
-        owner = msg.sender;
-    }
-}

contracts/chequebook/gencode.go

@@ -1,70 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// +build none
-
-// This program generates contract/code.go, which contains the chequebook code
-// after deployment.
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"math/big"
-
-	"github.com/ubiq/go-ubiq/accounts/abi/bind"
-	"github.com/ubiq/go-ubiq/accounts/abi/bind/backends"
-	"github.com/ubiq/go-ubiq/contracts/chequebook/contract"
-	"github.com/ubiq/go-ubiq/core"
-	"github.com/ubiq/go-ubiq/crypto"
-)
-
-var (
-	testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-	testAlloc  = core.GenesisAlloc{
-		crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(500000000000)},
-	}
-)
-
-func main() {
-	backend := backends.NewSimulatedBackend(testAlloc, uint64(100000000))
-	auth := bind.NewKeyedTransactor(testKey)
-
-	// Deploy the contract, get the code.
-	addr, _, _, err := contract.DeployChequebook(auth, backend)
-	if err != nil {
-		panic(err)
-	}
-	backend.Commit()
-	code, err := backend.CodeAt(nil, addr, nil)
-	if err != nil {
-		panic(err)
-	}
-	if len(code) == 0 {
-		panic("empty code")
-	}
-
-	// Write the output file.
-	content := fmt.Sprintf(`package contract
-
-// ContractDeployedCode is used to detect suicides. This constant needs to be
-// updated when the contract code is changed.
-const ContractDeployedCode = "%#x"
-`, code)
-	if err := ioutil.WriteFile("contract/code.go", []byte(content), 0644); err != nil {
-		panic(err)
-	}
-}

internal/openrpc/openrpc_schema_test.go

@@ -0,0 +1,14 @@
+package openrpc_test
+
+import (
+	"testing"
+
+	"github.com/ubiq/go-ubiq/internal/openrpc"
+	"github.com/ubiq/go-ubiq/rpc"
+)
+
+func TestDefaultSchema(t *testing.T) {
+	if err := rpc.SetDefaultOpenRPCSchemaRaw(openrpc.OpenRPCSchema); err != nil {
+		t.Fatal(err)
+	}
+}

internal/web3ext/web3ext.go

@@ -20,9 +20,8 @@ package web3ext
 var Modules = map[string]string{
 	"accounting": Accounting_JS,
 	"admin":      Admin_JS,
-	"chequebook": Chequebook_JS,
 	"clique":     Clique_JS,
-	"ubqhash":     Ubqhash_JS,
+	"ubqhash":    Ubqhash_JS,
 	"debug":      Debug_JS,
 	"eth":        Eth_JS,
 	"miner":      Miner_JS,
@@ -30,41 +29,9 @@ var Modules = map[string]string{
 	"personal":   Personal_JS,
 	"rpc":        RPC_JS,
 	"shh":        Shh_JS,
-	"swarmfs":    SWARMFS_JS,
 	"txpool":     TxPool_JS,
 }
 
-const Chequebook_JS = `
-web3._extend({
-	property: 'chequebook',
-	methods: [
-		new web3._extend.Method({
-			name: 'deposit',
-			call: 'chequebook_deposit',
-			params: 1,
-			inputFormatter: [null]
-		}),
-		new web3._extend.Property({
-			name: 'balance',
-			getter: 'chequebook_balance',
-			outputFormatter: web3._extend.utils.toDecimal
-		}),
-		new web3._extend.Method({
-			name: 'cash',
-			call: 'chequebook_cash',
-			params: 1,
-			inputFormatter: [null]
-		}),
-		new web3._extend.Method({
-			name: 'issue',
-			call: 'chequebook_issue',
-			params: 2,
-			inputFormatter: [null, null]
-		}),
-	]
-});
-`
-
 const Clique_JS = `
 web3._extend({
 	property: 'clique',
@@ -625,7 +592,13 @@ web3._extend({
 const RPC_JS = `
 web3._extend({
 	property: 'rpc',
-	methods: [],
+	methods: [
+		new web3._extend.Method({
+			name: 'discover',
+			call: 'rpc.discover',
+			params: 0
+		}),
+	],
 	properties: [
 		new web3._extend.Property({
 			name: 'modules',
@@ -655,30 +628,6 @@ web3._extend({
 });
 `
 
-const SWARMFS_JS = `
-web3._extend({
-	property: 'swarmfs',
-	methods:
-	[
-		new web3._extend.Method({
-			name: 'mount',
-			call: 'swarmfs_mount',
-			params: 2
-		}),
-		new web3._extend.Method({
-			name: 'unmount',
-			call: 'swarmfs_unmount',
-			params: 1
-		}),
-		new web3._extend.Method({
-			name: 'listmounts',
-			call: 'swarmfs_listmounts',
-			params: 0
-		}),
-	]
-});
-`
-
 const TxPool_JS = `
 web3._extend({
 	property: 'txpool',

p2p/protocols/protocol.go

@@ -38,13 +38,13 @@ import (
 	"sync"
 	"time"
 
+	opentracing "github.com/opentracing/opentracing-go"
 	"github.com/ubiq/go-ubiq/log"
 	"github.com/ubiq/go-ubiq/metrics"
 	"github.com/ubiq/go-ubiq/p2p"
+	"github.com/ubiq/go-ubiq/p2p/spancontext"
+	"github.com/ubiq/go-ubiq/p2p/tracing"
 	"github.com/ubiq/go-ubiq/rlp"
-	"github.com/ubiq/go-ubiq/swarm/spancontext"
-	"github.com/ubiq/go-ubiq/swarm/tracing"
-	opentracing "github.com/opentracing/opentracing-go"
 )
 
 // error codes used by this  protocol scheme

p2p/tracing/tracing.go

@@ -6,9 +6,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ubiq/go-ubiq/log"
 	jaeger "github.com/uber/jaeger-client-go"
 	jaegercfg "github.com/uber/jaeger-client-go/config"
+	"github.com/ubiq/go-ubiq/log"
 	cli "gopkg.in/urfave/cli.v1"
 )
 

params/config.go

@@ -39,10 +39,47 @@ var (
 		EIP150Hash:          common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
 		EIP155Block:         big.NewInt(10),
 		EIP158Block:         big.NewInt(10),
-		ByzantiumBlock:      big.NewInt(math.MaxInt64),
+		ByzantiumBlock:      big.NewInt(1075090), // Andromeda
-		ConstantinopleBlock: big.NewInt(math.MaxInt64),
+		ConstantinopleBlock: big.NewInt(1075090), // Andromeda
-		PetersburgBlock:     big.NewInt(math.MaxInt64),
+		PetersburgBlock:     big.NewInt(1075090), // Andromeda
-		Ubqhash:              new(UbqhashConfig),
+		Ubqhash: &UbqhashConfig{
+			DigishieldModBlock: big.NewInt(4088),
+			FluxBlock:          big.NewInt(8000),
+			MonetaryPolicy: []UbqhashMPStep{
+				UbqhashMPStep{
+					Block:  big.NewInt(0),
+					Reward: big.NewInt(8e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(358363),
+					Reward: big.NewInt(7e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(716727),
+					Reward: big.NewInt(6e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(1075090),
+					Reward: big.NewInt(5e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(1433454),
+					Reward: big.NewInt(4e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(1791818),
+					Reward: big.NewInt(3e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(2150181),
+					Reward: big.NewInt(2e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(2508545),
+					Reward: big.NewInt(1e+18),
+				},
+			},
+		},
 	}
 
 	// MainnetTrustedCheckpoint contains the light client trusted checkpoint for the main network.
@@ -65,7 +102,44 @@ var (
 		ByzantiumBlock:      big.NewInt(math.MaxInt64),
 		ConstantinopleBlock: big.NewInt(math.MaxInt64),
 		PetersburgBlock:     big.NewInt(math.MaxInt64),
-		Ubqhash:              new(UbqhashConfig),
+		Ubqhash: &UbqhashConfig{
+			DigishieldModBlock: big.NewInt(4088),
+			FluxBlock:          big.NewInt(8000),
+			MonetaryPolicy: []UbqhashMPStep{
+				UbqhashMPStep{
+					Block:  big.NewInt(0),
+					Reward: big.NewInt(8e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(358363),
+					Reward: big.NewInt(7e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(716727),
+					Reward: big.NewInt(6e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(1075090),
+					Reward: big.NewInt(5e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(1433454),
+					Reward: big.NewInt(4e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(1791818),
+					Reward: big.NewInt(3e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(2150181),
+					Reward: big.NewInt(2e+18),
+				},
+				UbqhashMPStep{
+					Block:  big.NewInt(2508545),
+					Reward: big.NewInt(1e+18),
+				},
+			},
+		},
 	}
 
 	// TestnetTrustedCheckpoint contains the light client trusted checkpoint for the Ropsten test network.
@@ -82,7 +156,7 @@ var (
 	//
 	// This configuration is intentionally not using keyed fields to force anyone
 	// adding flags to the config to also have to set these fields.
-	AllUbqhashProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, new(UbqhashConfig), nil}
+	AllUbqhashProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, &UbqhashConfig{big.NewInt(0), big.NewInt(0), []UbqhashMPStep{}}, nil}
 
 	// AllCliqueProtocolChanges contains every protocol change (EIPs) introduced
 	// and accepted by the Ubiq core developers into the Clique consensus.
@@ -91,7 +165,7 @@ var (
 	// adding flags to the config to also have to set these fields.
 	AllCliqueProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, nil, &CliqueConfig{Period: 0, Epoch: 30000}}
 
-	TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, new(UbqhashConfig), nil}
+	TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), big.NewInt(0), nil, &UbqhashConfig{big.NewInt(0), big.NewInt(0), []UbqhashMPStep{}}, nil}
 	TestRules       = TestChainConfig.Rules(new(big.Int))
 )
 
@@ -134,8 +208,18 @@ type ChainConfig struct {
 	Clique  *CliqueConfig  `json:"clique,omitempty"`
 }
 
+// Ubqhash monetary policy reward step
+type UbqhashMPStep struct {
+	Block  *big.Int `json:"block"`
+	Reward *big.Int `json:"reward"`
+}
+
 // UbqhashConfig is the consensus engine configs for proof-of-work based sealing.
-type UbqhashConfig struct{}
+type UbqhashConfig struct {
+	DigishieldModBlock *big.Int        `json:"digishieldModBlock,omitempty"` // Block to activate the DigiShield V3 mod
+	FluxBlock          *big.Int        `json:"fluxBlock"`                    // Block to activate the Flux difficulty algorithm
+	MonetaryPolicy     []UbqhashMPStep `json:"monetaryPolicy"`               // Blocks to step the block reward down
+}
 
 // String implements the stringer interface, returning the consensus engine details.
 func (c *UbqhashConfig) String() string {

params/version.go

@@ -21,10 +21,10 @@ import (
 )
 
 const (
-	VersionMajor = 2       // Major version component of the current release
+	VersionMajor = 3           // Major version component of the current release
-	VersionMinor = 3       // Minor version component of the current release
+	VersionMinor = 0           // Minor version component of the current release
-	VersionPatch = 0       // Patch version component of the current release
+	VersionPatch = 0           // Patch version component of the current release
-	VersionMeta  = "fleek" // Version metadata to append to the version string
+	VersionMeta  = "andromeda" // Version metadata to append to the version string
 )
 
 // Version holds the textual version string.

rpc/client.go

@@ -18,17 +18,13 @@ package rpc
 
 import (
 	"bytes"
-	"container/list"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"net"
 	"net/url"
 	"reflect"
 	"strconv"
-	"strings"
-	"sync"
 	"sync/atomic"
 	"time"
 
@@ -39,13 +35,14 @@ var (
 	ErrClientQuit                = errors.New("client is closed")
 	ErrNoResult                  = errors.New("no result in JSON-RPC response")
 	ErrSubscriptionQueueOverflow = errors.New("subscription queue overflow")
+	errClientReconnected         = errors.New("client reconnected")
+	errDead                      = errors.New("connection lost")
 )
 
 const (
 	// Timeouts
 	tcpKeepAliveInterval = 30 * time.Second
-	defaultDialTimeout   = 10 * time.Second // used when dialing if the context has no deadline
+	defaultDialTimeout   = 10 * time.Second // used if context has no deadline
-	defaultWriteTimeout  = 10 * time.Second // used for calls if the context has no deadline
 	subscribeTimeout     = 5 * time.Second  // overall timeout eth_subscribe, rpc_modules calls
 )
 
@@ -76,56 +73,57 @@ type BatchElem struct {
 	Error error
 }
 
-// A value of this type can a JSON-RPC request, notification, successful response or
-// error response. Which one it is depends on the fields.
-type jsonrpcMessage struct {
-	Version string          `json:"jsonrpc"`
-	ID      json.RawMessage `json:"id,omitempty"`
-	Method  string          `json:"method,omitempty"`
-	Params  json.RawMessage `json:"params,omitempty"`
-	Error   *jsonError      `json:"error,omitempty"`
-	Result  json.RawMessage `json:"result,omitempty"`
-}
-
-func (msg *jsonrpcMessage) isNotification() bool {
-	return msg.ID == nil && msg.Method != ""
-}
-
-func (msg *jsonrpcMessage) isResponse() bool {
-	return msg.hasValidID() && msg.Method == "" && len(msg.Params) == 0
-}
-
-func (msg *jsonrpcMessage) hasValidID() bool {
-	return len(msg.ID) > 0 && msg.ID[0] != '{' && msg.ID[0] != '['
-}
-
-func (msg *jsonrpcMessage) String() string {
-	b, _ := json.Marshal(msg)
-	return string(b)
-}
-
 // Client represents a connection to an RPC server.
 type Client struct {
-	idCounter   uint32
+	idgen    func() ID // for subscriptions
-	connectFunc func(ctx context.Context) (net.Conn, error)
+	isHTTP   bool
-	isHTTP      bool
+	services *serviceRegistry
 
-	// writeConn is only safe to access outside dispatch, with the
+	idCounter uint32
-	// write lock held. The write lock is taken by sending on
+
-	// requestOp and released by sending on sendDone.
+	// This function, if non-nil, is called when the connection is lost.
-	writeConn net.Conn
+	reconnectFunc reconnectFunc
+
+	// writeConn is used for writing to the connection on the caller's goroutine. It should
+	// only be accessed outside of dispatch, with the write lock held. The write lock is
+	// taken by sending on requestOp and released by sending on sendDone.
+	writeConn jsonWriter
 
 	// for dispatch
 	close       chan struct{}
-	closing     chan struct{}                  // closed when client is quitting
+	closing     chan struct{}    // closed when client is quitting
-	didClose    chan struct{}                  // closed when client quits
+	didClose    chan struct{}    // closed when client quits
-	reconnected chan net.Conn                  // where write/reconnect sends the new connection
+	reconnected chan ServerCodec // where write/reconnect sends the new connection
-	readErr     chan error                     // errors from read
+	readOp      chan readOp      // read messages
-	readResp    chan []*jsonrpcMessage         // valid messages from read
+	readErr     chan error       // errors from read
-	requestOp   chan *requestOp                // for registering response IDs
+	reqInit     chan *requestOp  // register response IDs, takes write lock
-	sendDone    chan error                     // signals write completion, releases write lock
+	reqSent     chan error       // signals write completion, releases write lock
-	respWait    map[string]*requestOp          // active requests
+	reqTimeout  chan *requestOp  // removes response IDs when call timeout expires
-	subs        map[string]*ClientSubscription // active subscriptions
+}
+
+type reconnectFunc func(ctx context.Context) (ServerCodec, error)
+
+type clientContextKey struct{}
+
+type clientConn struct {
+	codec   ServerCodec
+	handler *handler
+}
+
+func (c *Client) newClientConn(conn ServerCodec) *clientConn {
+	ctx := context.WithValue(context.Background(), clientContextKey{}, c)
+	handler := newHandler(ctx, conn, c.idgen, c.services)
+	return &clientConn{conn, handler}
+}
+
+func (cc *clientConn) close(err error, inflightReq *requestOp) {
+	cc.handler.close(err, inflightReq)
+	cc.codec.Close()
+}
+
+type readOp struct {
+	msgs  []*jsonrpcMessage
+	batch bool
 }
 
 type requestOp struct {
@@ -135,9 +133,14 @@ type requestOp struct {
 	sub  *ClientSubscription  // only set for EthSubscribe requests
 }
 
-func (op *requestOp) wait(ctx context.Context) (*jsonrpcMessage, error) {
+func (op *requestOp) wait(ctx context.Context, c *Client) (*jsonrpcMessage, error) {
 	select {
 	case <-ctx.Done():
+		// Send the timeout to dispatch so it can remove the request IDs.
+		select {
+		case c.reqTimeout <- op:
+		case <-c.closing:
+		}
 		return nil, ctx.Err()
 	case resp := <-op.resp:
 		return resp, op.err
@@ -181,36 +184,57 @@ func DialContext(ctx context.Context, rawurl string) (*Client, error) {
 	}
 }
 
-func newClient(initctx context.Context, connectFunc func(context.Context) (net.Conn, error)) (*Client, error) {
+// Client retrieves the client from the context, if any. This can be used to perform
-	conn, err := connectFunc(initctx)
+// 'reverse calls' in a handler method.
+func ClientFromContext(ctx context.Context) (*Client, bool) {
+	client, ok := ctx.Value(clientContextKey{}).(*Client)
+	return client, ok
+}
+
+func newClient(initctx context.Context, connect reconnectFunc) (*Client, error) {
+	conn, err := connect(initctx)
 	if err != nil {
 		return nil, err
 	}
+	c := initClient(conn, randomIDGenerator(), new(serviceRegistry))
+	c.reconnectFunc = connect
+	return c, nil
+}
+
+func initClient(conn ServerCodec, idgen func() ID, services *serviceRegistry) *Client {
 	_, isHTTP := conn.(*httpConn)
 	c := &Client{
-		writeConn:   conn,
+		idgen:       idgen,
 		isHTTP:      isHTTP,
-		connectFunc: connectFunc,
+		services:    services,
+		writeConn:   conn,
 		close:       make(chan struct{}),
 		closing:     make(chan struct{}),
 		didClose:    make(chan struct{}),
-		reconnected: make(chan net.Conn),
+		reconnected: make(chan ServerCodec),
+		readOp:      make(chan readOp),
 		readErr:     make(chan error),
-		readResp:    make(chan []*jsonrpcMessage),
+		reqInit:     make(chan *requestOp),
-		requestOp:   make(chan *requestOp),
+		reqSent:     make(chan error, 1),
-		sendDone:    make(chan error, 1),
+		reqTimeout:  make(chan *requestOp),
-		respWait:    make(map[string]*requestOp),
-		subs:        make(map[string]*ClientSubscription),
 	}
 	if !isHTTP {
 		go c.dispatch(conn)
 	}
-	return c, nil
+	return c
+}
+
+// RegisterName creates a service for the given receiver type under the given name. When no
+// methods on the given receiver match the criteria to be either a RPC method or a
+// subscription an error is returned. Otherwise a new service is created and added to the
+// service collection this client provides to the server.
+func (c *Client) RegisterName(name string, receiver interface{}) error {
+	return c.services.registerName(name, receiver)
 }
 
 func (c *Client) nextID() json.RawMessage {
 	id := atomic.AddUint32(&c.idCounter, 1)
-	return []byte(strconv.FormatUint(uint64(id), 10))
+	return strconv.AppendUint(nil, uint64(id), 10)
 }
 
 // SupportedModules calls the rpc_modules method, retrieving the list of
@@ -267,7 +291,7 @@ func (c *Client) CallContext(ctx context.Context, result interface{}, method str
 	}
 
 	// dispatch has accepted the request and will close the channel when it quits.
-	switch resp, err := op.wait(ctx); {
+	switch resp, err := op.wait(ctx, c); {
 	case err != nil:
 		return err
 	case resp.Error != nil:
@@ -325,7 +349,7 @@ func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error {
 	// Wait for all responses to come back.
 	for n := 0; n < len(b) && err == nil; n++ {
 		var resp *jsonrpcMessage
-		resp, err = op.wait(ctx)
+		resp, err = op.wait(ctx, c)
 		if err != nil {
 			break
 		}
@@ -352,6 +376,22 @@ func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error {
 	return err
 }
 
+// Notify sends a notification, i.e. a method call that doesn't expect a response.
+func (c *Client) Notify(ctx context.Context, method string, args ...interface{}) error {
+	op := new(requestOp)
+	msg, err := c.newMessage(method, args...)
+	if err != nil {
+		return err
+	}
+	msg.ID = nil
+
+	if c.isHTTP {
+		return c.sendHTTP(ctx, op, msg)
+	} else {
+		return c.send(ctx, op, msg)
+	}
+}
+
 // EthSubscribe registers a subscripion under the "eth" namespace.
 func (c *Client) EthSubscribe(ctx context.Context, channel interface{}, args ...interface{}) (*ClientSubscription, error) {
 	return c.Subscribe(ctx, "eth", channel, args...)
@@ -402,30 +442,30 @@ func (c *Client) Subscribe(ctx context.Context, namespace string, channel interf
 	if err := c.send(ctx, op, msg); err != nil {
 		return nil, err
 	}
-	if _, err := op.wait(ctx); err != nil {
+	if _, err := op.wait(ctx, c); err != nil {
 		return nil, err
 	}
 	return op.sub, nil
 }
 
 func (c *Client) newMessage(method string, paramsIn ...interface{}) (*jsonrpcMessage, error) {
-	params, err := json.Marshal(paramsIn)
+	msg := &jsonrpcMessage{Version: vsn, ID: c.nextID(), Method: method}
-	if err != nil {
+	if paramsIn != nil { // prevent sending "params":null
-		return nil, err
+		var err error
+		if msg.Params, err = json.Marshal(paramsIn); err != nil {
+			return nil, err
+		}
 	}
-	return &jsonrpcMessage{Version: "2.0", ID: c.nextID(), Method: method, Params: params}, nil
+	return msg, nil
 }
 
 // send registers op with the dispatch loop, then sends msg on the connection.
 // if sending fails, op is deregistered.
 func (c *Client) send(ctx context.Context, op *requestOp, msg interface{}) error {
 	select {
-	case c.requestOp <- op:
+	case c.reqInit <- op:
-		log.Trace("", "msg", log.Lazy{Fn: func() string {
-			return fmt.Sprint("sending ", msg)
-		}})
 		err := c.write(ctx, msg)
-		c.sendDone <- err
+		c.reqSent <- err
 		return err
 	case <-ctx.Done():
 		// This can happen if the client is overloaded or unable to keep up with
@@ -433,25 +473,17 @@ func (c *Client) send(ctx context.Context, op *requestOp, msg interface{}) error
 		return ctx.Err()
 	case <-c.closing:
 		return ErrClientQuit
-	case <-c.didClose:
-		return ErrClientQuit
 	}
 }
 
 func (c *Client) write(ctx context.Context, msg interface{}) error {
-	deadline, ok := ctx.Deadline()
-	if !ok {
-		deadline = time.Now().Add(defaultWriteTimeout)
-	}
 	// The previous write failed. Try to establish a new connection.
 	if c.writeConn == nil {
 		if err := c.reconnect(ctx); err != nil {
 			return err
 		}
 	}
-	c.writeConn.SetWriteDeadline(deadline)
+	err := c.writeConn.Write(ctx, msg)
-	err := json.NewEncoder(c.writeConn).Encode(msg)
-	c.writeConn.SetWriteDeadline(time.Time{})
 	if err != nil {
 		c.writeConn = nil
 	}
@@ -459,9 +491,18 @@ func (c *Client) write(ctx context.Context, msg interface{}) error {
 }
 
 func (c *Client) reconnect(ctx context.Context) error {
-	newconn, err := c.connectFunc(ctx)
+	if c.reconnectFunc == nil {
+		return errDead
+	}
+
+	if _, ok := ctx.Deadline(); !ok {
+		var cancel func()
+		ctx, cancel = context.WithTimeout(ctx, defaultDialTimeout)
+		defer cancel()
+	}
+	newconn, err := c.reconnectFunc(ctx)
 	if err != nil {
-		log.Trace(fmt.Sprintf("reconnect failed: %v", err))
+		log.Trace("RPC client reconnect failed", "err", err)
 		return err
 	}
 	select {
@@ -477,322 +518,107 @@ func (c *Client) reconnect(ctx context.Context) error {
 // dispatch is the main loop of the client.
 // It sends read messages to waiting calls to Call and BatchCall
 // and subscription notifications to registered subscriptions.
-func (c *Client) dispatch(conn net.Conn) {
+func (c *Client) dispatch(codec ServerCodec) {
-	// Spawn the initial read loop.
-	go c.read(conn)
-
 	var (
-		lastOp        *requestOp    // tracks last send operation
+		lastOp      *requestOp  // tracks last send operation
-		requestOpLock = c.requestOp // nil while the send lock is held
+		reqInitLock = c.reqInit // nil while the send lock is held
-		reading       = true        // if true, a read loop is running
+		conn        = c.newClientConn(codec)
+		reading     = true
 	)
-	defer close(c.didClose)
 	defer func() {
 		close(c.closing)
-		c.closeRequestOps(ErrClientQuit)
-		conn.Close()
 		if reading {
-			// Empty read channels until read is dead.
+			conn.close(ErrClientQuit, nil)
-			for {
+			c.drainRead()
-				select {
-				case <-c.readResp:
-				case <-c.readErr:
-					return
-				}
-			}
 		}
+		close(c.didClose)
 	}()
 
+	// Spawn the initial read loop.
+	go c.read(codec)
+
 	for {
 		select {
 		case <-c.close:
 			return
 
-		// Read path.
+		// Read path:
-		case batch := <-c.readResp:
+		case op := <-c.readOp:
-			for _, msg := range batch {
+			if op.batch {
-				switch {
+				conn.handler.handleBatch(op.msgs)
-				case msg.isNotification():
+			} else {
-					log.Trace("", "msg", log.Lazy{Fn: func() string {
+				conn.handler.handleMsg(op.msgs[0])
-						return fmt.Sprint("<-readResp: notification ", msg)
-					}})
-					c.handleNotification(msg)
-				case msg.isResponse():
-					log.Trace("", "msg", log.Lazy{Fn: func() string {
-						return fmt.Sprint("<-readResp: response ", msg)
-					}})
-					c.handleResponse(msg)
-				default:
-					log.Debug("", "msg", log.Lazy{Fn: func() string {
-						return fmt.Sprint("<-readResp: dropping weird message", msg)
-					}})
-					// TODO: maybe close
-				}
 			}
 
 		case err := <-c.readErr:
-			log.Debug("<-readErr", "err", err)
+			conn.handler.log.Debug("RPC connection read error", "err", err)
-			c.closeRequestOps(err)
+			conn.close(err, lastOp)
-			conn.Close()
 			reading = false
 
-		case newconn := <-c.reconnected:
+		// Reconnect:
-			log.Debug("<-reconnected", "reading", reading, "remote", conn.RemoteAddr())
+		case newcodec := <-c.reconnected:
+			log.Debug("RPC client reconnected", "reading", reading, "conn", newcodec.RemoteAddr())
 			if reading {
-				// Wait for the previous read loop to exit. This is a rare case.
+				// Wait for the previous read loop to exit. This is a rare case which
-				conn.Close()
+				// happens if this loop isn't notified in time after the connection breaks.
-				<-c.readErr
+				// In those cases the caller will notice first and reconnect. Closing the
+				// handler terminates all waiting requests (closing op.resp) except for
+				// lastOp, which will be transferred to the new handler.
+				conn.close(errClientReconnected, lastOp)
+				c.drainRead()
 			}
-			go c.read(newconn)
+			go c.read(newcodec)
 			reading = true
-			conn = newconn
+			conn = c.newClientConn(newcodec)
+			// Re-register the in-flight request on the new handler
+			// because that's where it will be sent.
+			conn.handler.addRequestOp(lastOp)
 
-		// Send path.
+		// Send path:
-		case op := <-requestOpLock:
+		case op := <-reqInitLock:
-			// Stop listening for further send ops until the current one is done.
+			// Stop listening for further requests until the current one has been sent.
-			requestOpLock = nil
+			reqInitLock = nil
 			lastOp = op
-			for _, id := range op.ids {
+			conn.handler.addRequestOp(op)
-				c.respWait[string(id)] = op
-			}
 
-		case err := <-c.sendDone:
+		case err := <-c.reqSent:
 			if err != nil {
-				// Remove response handlers for the last send. We remove those here
+				// Remove response handlers for the last send. When the read loop
-				// because the error is already handled in Call or BatchCall. When the
+				// goes down, it will signal all other current operations.
-				// read loop goes down, it will signal all other current operations.
+				conn.handler.removeRequestOp(lastOp)
-				for _, id := range lastOp.ids {
-					delete(c.respWait, string(id))
-				}
 			}
-			// Listen for send ops again.
+			// Let the next request in.
-			requestOpLock = c.requestOp
+			reqInitLock = c.reqInit
 			lastOp = nil
+
+		case op := <-c.reqTimeout:
+			conn.handler.removeRequestOp(op)
 		}
 	}
 }
 
-// closeRequestOps unblocks pending send ops and active subscriptions.
+// drainRead drops read messages until an error occurs.
-func (c *Client) closeRequestOps(err error) {
+func (c *Client) drainRead() {
-	didClose := make(map[*requestOp]bool)
-
-	for id, op := range c.respWait {
-		// Remove the op so that later calls will not close op.resp again.
-		delete(c.respWait, id)
-
-		if !didClose[op] {
-			op.err = err
-			close(op.resp)
-			didClose[op] = true
-		}
-	}
-	for id, sub := range c.subs {
-		delete(c.subs, id)
-		sub.quitWithError(err, false)
-	}
-}
-
-func (c *Client) handleNotification(msg *jsonrpcMessage) {
-	if !strings.HasSuffix(msg.Method, notificationMethodSuffix) {
-		log.Debug("dropping non-subscription message", "msg", msg)
-		return
-	}
-	var subResult struct {
-		ID     string          `json:"subscription"`
-		Result json.RawMessage `json:"result"`
-	}
-	if err := json.Unmarshal(msg.Params, &subResult); err != nil {
-		log.Debug("dropping invalid subscription message", "msg", msg)
-		return
-	}
-	if c.subs[subResult.ID] != nil {
-		c.subs[subResult.ID].deliver(subResult.Result)
-	}
-}
-
-func (c *Client) handleResponse(msg *jsonrpcMessage) {
-	op := c.respWait[string(msg.ID)]
-	if op == nil {
-		log.Debug("unsolicited response", "msg", msg)
-		return
-	}
-	delete(c.respWait, string(msg.ID))
-	// For normal responses, just forward the reply to Call/BatchCall.
-	if op.sub == nil {
-		op.resp <- msg
-		return
-	}
-	// For subscription responses, start the subscription if the server
-	// indicates success. EthSubscribe gets unblocked in either case through
-	// the op.resp channel.
-	defer close(op.resp)
-	if msg.Error != nil {
-		op.err = msg.Error
-		return
-	}
-	if op.err = json.Unmarshal(msg.Result, &op.sub.subid); op.err == nil {
-		go op.sub.start()
-		c.subs[op.sub.subid] = op.sub
-	}
-}
-
-// Reading happens on a dedicated goroutine.
-
-func (c *Client) read(conn net.Conn) error {
-	var (
-		buf json.RawMessage
-		dec = json.NewDecoder(conn)
-	)
-	readMessage := func() (rs []*jsonrpcMessage, err error) {
-		buf = buf[:0]
-		if err = dec.Decode(&buf); err != nil {
-			return nil, err
-		}
-		if isBatch(buf) {
-			err = json.Unmarshal(buf, &rs)
-		} else {
-			rs = make([]*jsonrpcMessage, 1)
-			err = json.Unmarshal(buf, &rs[0])
-		}
-		return rs, err
-	}
-
 	for {
-		resp, err := readMessage()
+		select {
+		case <-c.readOp:
+		case <-c.readErr:
+			return
+		}
+	}
+}
+
+// read decodes RPC messages from a codec, feeding them into dispatch.
+func (c *Client) read(codec ServerCodec) {
+	for {
+		msgs, batch, err := codec.Read()
+		if _, ok := err.(*json.SyntaxError); ok {
+			codec.Write(context.Background(), errorMessage(&parseError{err.Error()}))
+		}
 		if err != nil {
 			c.readErr <- err
-			return err
+			return
 		}
-		c.readResp <- resp
+		c.readOp <- readOp{msgs, batch}
 	}
 }
-
-// Subscriptions.
-
-// A ClientSubscription represents a subscription established through EthSubscribe.
-type ClientSubscription struct {
-	client    *Client
-	etype     reflect.Type
-	channel   reflect.Value
-	namespace string
-	subid     string
-	in        chan json.RawMessage
-
-	quitOnce sync.Once     // ensures quit is closed once
-	quit     chan struct{} // quit is closed when the subscription exits
-	errOnce  sync.Once     // ensures err is closed once
-	err      chan error
-}
-
-func newClientSubscription(c *Client, namespace string, channel reflect.Value) *ClientSubscription {
-	sub := &ClientSubscription{
-		client:    c,
-		namespace: namespace,
-		etype:     channel.Type().Elem(),
-		channel:   channel,
-		quit:      make(chan struct{}),
-		err:       make(chan error, 1),
-		in:        make(chan json.RawMessage),
-	}
-	return sub
-}
-
-// Err returns the subscription error channel. The intended use of Err is to schedule
-// resubscription when the client connection is closed unexpectedly.
-//
-// The error channel receives a value when the subscription has ended due
-// to an error. The received error is nil if Close has been called
-// on the underlying client and no other error has occurred.
-//
-// The error channel is closed when Unsubscribe is called on the subscription.
-func (sub *ClientSubscription) Err() <-chan error {
-	return sub.err
-}
-
-// Unsubscribe unsubscribes the notification and closes the error channel.
-// It can safely be called more than once.
-func (sub *ClientSubscription) Unsubscribe() {
-	sub.quitWithError(nil, true)
-	sub.errOnce.Do(func() { close(sub.err) })
-}
-
-func (sub *ClientSubscription) quitWithError(err error, unsubscribeServer bool) {
-	sub.quitOnce.Do(func() {
-		// The dispatch loop won't be able to execute the unsubscribe call
-		// if it is blocked on deliver. Close sub.quit first because it
-		// unblocks deliver.
-		close(sub.quit)
-		if unsubscribeServer {
-			sub.requestUnsubscribe()
-		}
-		if err != nil {
-			if err == ErrClientQuit {
-				err = nil // Adhere to subscription semantics.
-			}
-			sub.err <- err
-		}
-	})
-}
-
-func (sub *ClientSubscription) deliver(result json.RawMessage) (ok bool) {
-	select {
-	case sub.in <- result:
-		return true
-	case <-sub.quit:
-		return false
-	}
-}
-
-func (sub *ClientSubscription) start() {
-	sub.quitWithError(sub.forward())
-}
-
-func (sub *ClientSubscription) forward() (err error, unsubscribeServer bool) {
-	cases := []reflect.SelectCase{
-		{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sub.quit)},
-		{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sub.in)},
-		{Dir: reflect.SelectSend, Chan: sub.channel},
-	}
-	buffer := list.New()
-	defer buffer.Init()
-	for {
-		var chosen int
-		var recv reflect.Value
-		if buffer.Len() == 0 {
-			// Idle, omit send case.
-			chosen, recv, _ = reflect.Select(cases[:2])
-		} else {
-			// Non-empty buffer, send the first queued item.
-			cases[2].Send = reflect.ValueOf(buffer.Front().Value)
-			chosen, recv, _ = reflect.Select(cases)
-		}
-
-		switch chosen {
-		case 0: // <-sub.quit
-			return nil, false
-		case 1: // <-sub.in
-			val, err := sub.unmarshal(recv.Interface().(json.RawMessage))
-			if err != nil {
-				return err, true
-			}
-			if buffer.Len() == maxClientSubscriptionBuffer {
-				return ErrSubscriptionQueueOverflow, true
-			}
-			buffer.PushBack(val)
-		case 2: // sub.channel<-
-			cases[2].Send = reflect.Value{} // Don't hold onto the value.
-			buffer.Remove(buffer.Front())
-		}
-	}
-}
-
-func (sub *ClientSubscription) unmarshal(result json.RawMessage) (interface{}, error) {
-	val := reflect.New(sub.etype)
-	err := json.Unmarshal(result, val.Interface())
-	return val.Elem().Interface(), err
-}
-
-func (sub *ClientSubscription) requestUnsubscribe() error {
-	var result interface{}
-	return sub.client.Call(&result, sub.namespace+unsubscribeMethodSuffix, sub.subid)
-}

rpc/client_test.go

@@ -35,13 +35,13 @@ import (
 )
 
 func TestClientRequest(t *testing.T) {
-	server := newTestServer("service", new(Service))
+	server := newTestServer()
 	defer server.Stop()
 	client := DialInProc(server)
 	defer client.Close()
 
 	var resp Result
-	if err := client.Call(&resp, "service_echo", "hello", 10, &Args{"world"}); err != nil {
+	if err := client.Call(&resp, "test_echo", "hello", 10, &Args{"world"}); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(resp, Result{"hello", 10, &Args{"world"}}) {
@@ -50,19 +50,19 @@ func TestClientRequest(t *testing.T) {
 }
 
 func TestClientBatchRequest(t *testing.T) {
-	server := newTestServer("service", new(Service))
+	server := newTestServer()
 	defer server.Stop()
 	client := DialInProc(server)
 	defer client.Close()
 
 	batch := []BatchElem{
 		{
-			Method: "service_echo",
+			Method: "test_echo",
 			Args:   []interface{}{"hello", 10, &Args{"world"}},
 			Result: new(Result),
 		},
 		{
-			Method: "service_echo",
+			Method: "test_echo",
 			Args:   []interface{}{"hello2", 11, &Args{"world"}},
 			Result: new(Result),
 		},
@@ -77,12 +77,12 @@ func TestClientBatchRequest(t *testing.T) {
 	}
 	wantResult := []BatchElem{
 		{
-			Method: "service_echo",
+			Method: "test_echo",
 			Args:   []interface{}{"hello", 10, &Args{"world"}},
 			Result: &Result{"hello", 10, &Args{"world"}},
 		},
 		{
-			Method: "service_echo",
+			Method: "test_echo",
 			Args:   []interface{}{"hello2", 11, &Args{"world"}},
 			Result: &Result{"hello2", 11, &Args{"world"}},
 		},
@@ -90,7 +90,7 @@ func TestClientBatchRequest(t *testing.T) {
 			Method: "no_such_method",
 			Args:   []interface{}{1, 2, 3},
 			Result: new(int),
-			Error:  &jsonError{Code: -32601, Message: "The method no_such_method_ does not exist/is not available"},
+			Error:  &jsonError{Code: -32601, Message: "the method no_such_method does not exist/is not available"},
 		},
 	}
 	if !reflect.DeepEqual(batch, wantResult) {
@@ -98,6 +98,17 @@ func TestClientBatchRequest(t *testing.T) {
 	}
 }
 
+func TestClientNotify(t *testing.T) {
+	server := newTestServer()
+	defer server.Stop()
+	client := DialInProc(server)
+	defer client.Close()
+
+	if err := client.Notify(context.Background(), "test_echo", "hello", 10, &Args{"world"}); err != nil {
+		t.Fatal(err)
+	}
+}
+
 // func TestClientCancelInproc(t *testing.T) { testClientCancel("inproc", t) }
 func TestClientCancelWebsocket(t *testing.T) { testClientCancel("ws", t) }
 func TestClientCancelHTTP(t *testing.T)      { testClientCancel("http", t) }
@@ -106,7 +117,12 @@ func TestClientCancelIPC(t *testing.T)       { testClientCancel("ipc", t) }
 // This test checks that requests made through CallContext can be canceled by canceling
 // the context.
 func testClientCancel(transport string, t *testing.T) {
-	server := newTestServer("service", new(Service))
+	// These tests take a lot of time, run them all at once.
+	// You probably want to run with -parallel 1 or comment out
+	// the call to t.Parallel if you enable the logging.
+	t.Parallel()
+
+	server := newTestServer()
 	defer server.Stop()
 
 	// What we want to achieve is that the context gets canceled
@@ -142,11 +158,6 @@ func testClientCancel(transport string, t *testing.T) {
 		panic("unknown transport: " + transport)
 	}
 
-	// These tests take a lot of time, run them all at once.
-	// You probably want to run with -parallel 1 or comment out
-	// the call to t.Parallel if you enable the logging.
-	t.Parallel()
-
 	// The actual test starts here.
 	var (
 		wg       sync.WaitGroup
@@ -174,7 +185,8 @@ func testClientCancel(transport string, t *testing.T) {
 			}
 			// Now perform a call with the context.
 			// The key thing here is that no call will ever complete successfully.
-			err := client.CallContext(ctx, nil, "service_sleep", 2*maxContextCancelTimeout)
+			sleepTime := maxContextCancelTimeout + 20*time.Millisecond
+			err := client.CallContext(ctx, nil, "test_sleep", sleepTime)
 			if err != nil {
 				log.Debug(fmt.Sprint("got expected error:", err))
 			} else {
@@ -191,7 +203,7 @@ func testClientCancel(transport string, t *testing.T) {
 }
 
 func TestClientSubscribeInvalidArg(t *testing.T) {
-	server := newTestServer("service", new(Service))
+	server := newTestServer()
 	defer server.Stop()
 	client := DialInProc(server)
 	defer client.Close()
@@ -221,14 +233,14 @@ func TestClientSubscribeInvalidArg(t *testing.T) {
 }
 
 func TestClientSubscribe(t *testing.T) {
-	server := newTestServer("eth", new(NotificationTestService))
+	server := newTestServer()
 	defer server.Stop()
 	client := DialInProc(server)
 	defer client.Close()
 
 	nc := make(chan int)
 	count := 10
-	sub, err := client.EthSubscribe(context.Background(), nc, "someSubscription", count, 0)
+	sub, err := client.Subscribe(context.Background(), "nftest", nc, "someSubscription", count, 0)
 	if err != nil {
 		t.Fatal("can't subscribe:", err)
 	}
@@ -251,46 +263,17 @@ func TestClientSubscribe(t *testing.T) {
 	}
 }
 
-func TestClientSubscribeCustomNamespace(t *testing.T) {
+// In this test, the connection drops while Subscribe is waiting for a response.
-	namespace := "custom"
-	server := newTestServer(namespace, new(NotificationTestService))
-	defer server.Stop()
-	client := DialInProc(server)
-	defer client.Close()
-
-	nc := make(chan int)
-	count := 10
-	sub, err := client.Subscribe(context.Background(), namespace, nc, "someSubscription", count, 0)
-	if err != nil {
-		t.Fatal("can't subscribe:", err)
-	}
-	for i := 0; i < count; i++ {
-		if val := <-nc; val != i {
-			t.Fatalf("value mismatch: got %d, want %d", val, i)
-		}
-	}
-
-	sub.Unsubscribe()
-	select {
-	case v := <-nc:
-		t.Fatal("received value after unsubscribe:", v)
-	case err := <-sub.Err():
-		if err != nil {
-			t.Fatalf("Err returned a non-nil error after explicit unsubscribe: %q", err)
-		}
-	case <-time.After(1 * time.Second):
-		t.Fatalf("subscription not closed within 1s after unsubscribe")
-	}
-}
-
-// In this test, the connection drops while EthSubscribe is
-// waiting for a response.
 func TestClientSubscribeClose(t *testing.T) {
-	service := &NotificationTestService{
+	server := newTestServer()
+	service := &notificationTestService{
 		gotHangSubscriptionReq:  make(chan struct{}),
 		unblockHangSubscription: make(chan struct{}),
 	}
-	server := newTestServer("eth", service)
+	if err := server.RegisterName("nftest2", service); err != nil {
+		t.Fatal(err)
+	}
+
 	defer server.Stop()
 	client := DialInProc(server)
 	defer client.Close()
@@ -302,7 +285,7 @@ func TestClientSubscribeClose(t *testing.T) {
 		err  error
 	)
 	go func() {
-		sub, err = client.EthSubscribe(context.Background(), nc, "hangSubscription", 999)
+		sub, err = client.Subscribe(context.Background(), "nftest2", nc, "hangSubscription", 999)
 		errc <- err
 	}()
 
@@ -313,27 +296,26 @@ func TestClientSubscribeClose(t *testing.T) {
 	select {
 	case err := <-errc:
 		if err == nil {
-			t.Errorf("EthSubscribe returned nil error after Close")
+			t.Errorf("Subscribe returned nil error after Close")
 		}
 		if sub != nil {
-			t.Error("EthSubscribe returned non-nil subscription after Close")
+			t.Error("Subscribe returned non-nil subscription after Close")
 		}
 	case <-time.After(1 * time.Second):
-		t.Fatalf("EthSubscribe did not return within 1s after Close")
+		t.Fatalf("Subscribe did not return within 1s after Close")
 	}
 }
 
 // This test reproduces https://github.com/ubiq/go-ubiq/issues/17837 where the
 // client hangs during shutdown when Unsubscribe races with Client.Close.
 func TestClientCloseUnsubscribeRace(t *testing.T) {
-	service := &NotificationTestService{}
+	server := newTestServer()
-	server := newTestServer("eth", service)
 	defer server.Stop()
 
 	for i := 0; i < 20; i++ {
 		client := DialInProc(server)
 		nc := make(chan int)
-		sub, err := client.EthSubscribe(context.Background(), nc, "someSubscription", 3, 1)
+		sub, err := client.Subscribe(context.Background(), "nftest", nc, "someSubscription", 3, 1)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -350,7 +332,7 @@ func TestClientCloseUnsubscribeRace(t *testing.T) {
 // This test checks that Client doesn't lock up when a single subscriber
 // doesn't read subscription events.
 func TestClientNotificationStorm(t *testing.T) {
-	server := newTestServer("eth", new(NotificationTestService))
+	server := newTestServer()
 	defer server.Stop()
 
 	doTest := func(count int, wantError bool) {
@@ -362,7 +344,7 @@ func TestClientNotificationStorm(t *testing.T) {
 		// Subscribe on the server. It will start sending many notifications
 		// very quickly.
 		nc := make(chan int)
-		sub, err := client.EthSubscribe(ctx, nc, "someSubscription", count, 0)
+		sub, err := client.Subscribe(ctx, "nftest", nc, "someSubscription", count, 0)
 		if err != nil {
 			t.Fatal("can't subscribe:", err)
 		}
@@ -384,7 +366,7 @@ func TestClientNotificationStorm(t *testing.T) {
 				return
 			}
 			var r int
-			err := client.CallContext(ctx, &r, "eth_echo", i)
+			err := client.CallContext(ctx, &r, "nftest_echo", i)
 			if err != nil {
 				if !wantError {
 					t.Fatalf("(%d/%d) call error: %v", i, count, err)
@@ -399,7 +381,7 @@ func TestClientNotificationStorm(t *testing.T) {
 }
 
 func TestClientHTTP(t *testing.T) {
-	server := newTestServer("service", new(Service))
+	server := newTestServer()
 	defer server.Stop()
 
 	client, hs := httpTestClient(server, "http", nil)
@@ -416,7 +398,7 @@ func TestClientHTTP(t *testing.T) {
 	for i := range results {
 		i := i
 		go func() {
-			errc <- client.Call(&results[i], "service_echo",
+			errc <- client.Call(&results[i], "test_echo",
 				wantResult.String, wantResult.Int, wantResult.Args)
 		}()
 	}
@@ -445,16 +427,16 @@ func TestClientHTTP(t *testing.T) {
 
 func TestClientReconnect(t *testing.T) {
 	startServer := func(addr string) (*Server, net.Listener) {
-		srv := newTestServer("service", new(Service))
+		srv := newTestServer()
 		l, err := net.Listen("tcp", addr)
 		if err != nil {
-			t.Fatal(err)
+			t.Fatal("can't listen:", err)
 		}
 		go http.Serve(l, srv.WebsocketHandler([]string{"*"}))
 		return srv, l
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
 	defer cancel()
 
 	// Start a server and corresponding client.
@@ -466,21 +448,22 @@ func TestClientReconnect(t *testing.T) {
 
 	// Perform a call. This should work because the server is up.
 	var resp Result
-	if err := client.CallContext(ctx, &resp, "service_echo", "", 1, nil); err != nil {
+	if err := client.CallContext(ctx, &resp, "test_echo", "", 1, nil); err != nil {
 		t.Fatal(err)
 	}
 
-	// Shut down the server and try calling again. It shouldn't work.
+	// Shut down the server and allow for some cool down time so we can listen on the same
+	// address again.
 	l1.Close()
 	s1.Stop()
-	if err := client.CallContext(ctx, &resp, "service_echo", "", 2, nil); err == nil {
+	time.Sleep(2 * time.Second)
+
+	// Try calling again. It shouldn't work.
+	if err := client.CallContext(ctx, &resp, "test_echo", "", 2, nil); err == nil {
 		t.Error("successful call while the server is down")
 		t.Logf("resp: %#v", resp)
 	}
 
-	// Allow for some cool down time so we can listen on the same address again.
-	time.Sleep(2 * time.Second)
-
 	// Start it up again and call again. The connection should be reestablished.
 	// We spawn multiple calls here to check whether this hangs somehow.
 	s2, l2 := startServer(l1.Addr().String())
@@ -493,7 +476,7 @@ func TestClientReconnect(t *testing.T) {
 		go func() {
 			<-start
 			var resp Result
-			errors <- client.CallContext(ctx, &resp, "service_echo", "", 3, nil)
+			errors <- client.CallContext(ctx, &resp, "test_echo", "", 3, nil)
 		}()
 	}
 	close(start)
@@ -503,20 +486,12 @@ func TestClientReconnect(t *testing.T) {
 			errcount++
 		}
 	}
-	t.Log("err:", err)
+	t.Logf("%d errors, last error: %v", errcount, err)
 	if errcount > 1 {
 		t.Errorf("expected one error after disconnect, got %d", errcount)
 	}
 }
 
-func newTestServer(serviceName string, service interface{}) *Server {
-	server := NewServer()
-	if err := server.RegisterName(serviceName, service); err != nil {
-		panic(err)
-	}
-	return server
-}
-
 func httpTestClient(srv *Server, transport string, fl *flakeyListener) (*Client, *httptest.Server) {
 	// Create the HTTP server.
 	var hs *httptest.Server

rpc/doc.go

@@ -15,43 +15,49 @@
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 /*
-Package rpc provides access to the exported methods of an object across a network
+
-or other I/O connection. After creating a server instance objects can be registered,
+Package rpc implements bi-directional JSON-RPC 2.0 on multiple transports.
-making it visible from the outside. Exported methods that follow specific
+
-conventions can be called remotely. It also has support for the publish/subscribe
+It provides access to the exported methods of an object across a network or other I/O
-pattern.
+connection. After creating a server or client instance, objects can be registered to make
+them visible as 'services'. Exported methods that follow specific conventions can be
+called remotely. It also has support for the publish/subscribe pattern.
+
+RPC Methods
 
 Methods that satisfy the following criteria are made available for remote access:
- - object must be exported
+
  - method must be exported
  - method returns 0, 1 (response or error) or 2 (response and error) values
  - method argument(s) must be exported or builtin types
  - method returned value(s) must be exported or builtin types
 
 An example method:
+
  func (s *CalcService) Add(a, b int) (int, error)
 
-When the returned error isn't nil the returned integer is ignored and the error is
+When the returned error isn't nil the returned integer is ignored and the error is sent
-sent back to the client. Otherwise the returned integer is sent back to the client.
+back to the client. Otherwise the returned integer is sent back to the client.
 
-Optional arguments are supported by accepting pointer values as arguments. E.g.
+Optional arguments are supported by accepting pointer values as arguments. E.g. if we want
-if we want to do the addition in an optional finite field we can accept a mod
+to do the addition in an optional finite field we can accept a mod argument as pointer
-argument as pointer value.
+value.
 
- func (s *CalService) Add(a, b int, mod *int) (int, error)
+ func (s *CalcService) Add(a, b int, mod *int) (int, error)
 
-This RPC method can be called with 2 integers and a null value as third argument.
+This RPC method can be called with 2 integers and a null value as third argument. In that
-In that case the mod argument will be nil. Or it can be called with 3 integers,
+case the mod argument will be nil. Or it can be called with 3 integers, in that case mod
-in that case mod will be pointing to the given third argument. Since the optional
+will be pointing to the given third argument. Since the optional argument is the last
-argument is the last argument the RPC package will also accept 2 integers as
+argument the RPC package will also accept 2 integers as arguments. It will pass the mod
-arguments. It will pass the mod argument as nil to the RPC method.
+argument as nil to the RPC method.
 
-The server offers the ServeCodec method which accepts a ServerCodec instance. It will
+The server offers the ServeCodec method which accepts a ServerCodec instance. It will read
-read requests from the codec, process the request and sends the response back to the
+requests from the codec, process the request and sends the response back to the client
-client using the codec. The server can execute requests concurrently. Responses
+using the codec. The server can execute requests concurrently. Responses can be sent back
-can be sent back to the client out of order.
+to the client out of order.
 
 An example server which uses the JSON codec:
+
  type CalculatorService struct {}
 
  func (s *CalculatorService) Add(a, b int) int {
@@ -73,26 +79,40 @@ An example server which uses the JSON codec:
  for {
 	c, _ := l.AcceptUnix()
 	codec := v2.NewJSONCodec(c)
-	go server.ServeCodec(codec)
+	go server.ServeCodec(codec, 0)
  }
 
+Subscriptions
+
 The package also supports the publish subscribe pattern through the use of subscriptions.
-A method that is considered eligible for notifications must satisfy the following criteria:
+A method that is considered eligible for notifications must satisfy the following
- - object must be exported
+criteria:
+
  - method must be exported
  - first method argument type must be context.Context
  - method argument(s) must be exported or builtin types
- - method must return the tuple Subscription, error
+ - method must have return types (rpc.Subscription, error)
 
 An example method:
- func (s *BlockChainService) NewBlocks(ctx context.Context) (Subscription, error) {
+
+ func (s *BlockChainService) NewBlocks(ctx context.Context) (rpc.Subscription, error) {
  	...
  }
 
-Subscriptions are deleted when:
+When the service containing the subscription method is registered to the server, for
- - the user sends an unsubscribe request
+example under the "blockchain" namespace, a subscription is created by calling the
- - the connection which was used to create the subscription is closed. This can be initiated
+"blockchain_subscribe" method.
-   by the client and server. The server will close the connection on a write error or when
+
-   the queue of buffered notifications gets too big.
+Subscriptions are deleted when the user sends an unsubscribe request or when the
+connection which was used to create the subscription is closed. This can be initiated by
+the client and server. The server will close the connection for any write error.
+
+For more information about subscriptions, see https://github.com/ethereum/go-ethereum/wiki/RPC-PUB-SUB.
+
+Reverse Calls
+
+In any method handler, an instance of rpc.Client can be accessed through the
+ClientFromContext method. Using this client instance, server-to-client method calls can be
+performed on the RPC connection.
 */
 package rpc

rpc/errors.go

@@ -18,18 +18,31 @@ package rpc
 
 import "fmt"
 
-// request is for an unknown service
+const defaultErrorCode = -32000
-type methodNotFoundError struct {
+
-	service string
+type methodNotFoundError struct{ method string }
-	method  string
-}
 
 func (e *methodNotFoundError) ErrorCode() int { return -32601 }
 
 func (e *methodNotFoundError) Error() string {
-	return fmt.Sprintf("The method %s%s%s does not exist/is not available", e.service, serviceMethodSeparator, e.method)
+	return fmt.Sprintf("the method %s does not exist/is not available", e.method)
 }
 
+type subscriptionNotFoundError struct{ namespace, subscription string }
+
+func (e *subscriptionNotFoundError) ErrorCode() int { return -32601 }
+
+func (e *subscriptionNotFoundError) Error() string {
+	return fmt.Sprintf("no %q subscription in %s namespace", e.subscription, e.namespace)
+}
+
+// Invalid JSON was received by the server.
+type parseError struct{ message string }
+
+func (e *parseError) ErrorCode() int { return -32700 }
+
+func (e *parseError) Error() string { return e.message }
+
 // received message isn't a valid request
 type invalidRequestError struct{ message string }
 
@@ -50,17 +63,3 @@ type invalidParamsError struct{ message string }
 func (e *invalidParamsError) ErrorCode() int { return -32602 }
 
 func (e *invalidParamsError) Error() string { return e.message }
-
-// logic error, callback returned an error
-type callbackError struct{ message string }
-
-func (e *callbackError) ErrorCode() int { return -32000 }
-
-func (e *callbackError) Error() string { return e.message }
-
-// issued when a request is received after the server is issued to stop.
-type shutdownError struct{}
-
-func (e *shutdownError) ErrorCode() int { return -32000 }
-
-func (e *shutdownError) Error() string { return "server is shutting down" }

rpc/handler.go

@@ -0,0 +1,397 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rpc
+
+import (
+	"context"
+	"encoding/json"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/ubiq/go-ubiq/log"
+)
+
+// handler handles JSON-RPC messages. There is one handler per connection. Note that
+// handler is not safe for concurrent use. Message handling never blocks indefinitely
+// because RPCs are processed on background goroutines launched by handler.
+//
+// The entry points for incoming messages are:
+//
+//    h.handleMsg(message)
+//    h.handleBatch(message)
+//
+// Outgoing calls use the requestOp struct. Register the request before sending it
+// on the connection:
+//
+//    op := &requestOp{ids: ...}
+//    h.addRequestOp(op)
+//
+// Now send the request, then wait for the reply to be delivered through handleMsg:
+//
+//    if err := op.wait(...); err != nil {
+//        h.removeRequestOp(op) // timeout, etc.
+//    }
+//
+type handler struct {
+	reg            *serviceRegistry
+	unsubscribeCb  *callback
+	idgen          func() ID                      // subscription ID generator
+	respWait       map[string]*requestOp          // active client requests
+	clientSubs     map[string]*ClientSubscription // active client subscriptions
+	callWG         sync.WaitGroup                 // pending call goroutines
+	rootCtx        context.Context                // canceled by close()
+	cancelRoot     func()                         // cancel function for rootCtx
+	conn           jsonWriter                     // where responses will be sent
+	log            log.Logger
+	allowSubscribe bool
+
+	subLock    sync.Mutex
+	serverSubs map[ID]*Subscription
+}
+
+type callProc struct {
+	ctx       context.Context
+	notifiers []*Notifier
+}
+
+func newHandler(connCtx context.Context, conn jsonWriter, idgen func() ID, reg *serviceRegistry) *handler {
+	rootCtx, cancelRoot := context.WithCancel(connCtx)
+	h := &handler{
+		reg:            reg,
+		idgen:          idgen,
+		conn:           conn,
+		respWait:       make(map[string]*requestOp),
+		clientSubs:     make(map[string]*ClientSubscription),
+		rootCtx:        rootCtx,
+		cancelRoot:     cancelRoot,
+		allowSubscribe: true,
+		serverSubs:     make(map[ID]*Subscription),
+		log:            log.Root(),
+	}
+	if conn.RemoteAddr() != "" {
+		h.log = h.log.New("conn", conn.RemoteAddr())
+	}
+	h.unsubscribeCb = newCallback(reflect.Value{}, reflect.ValueOf(h.unsubscribe))
+	return h
+}
+
+// handleBatch executes all messages in a batch and returns the responses.
+func (h *handler) handleBatch(msgs []*jsonrpcMessage) {
+	// Emit error response for empty batches:
+	if len(msgs) == 0 {
+		h.startCallProc(func(cp *callProc) {
+			h.conn.Write(cp.ctx, errorMessage(&invalidRequestError{"empty batch"}))
+		})
+		return
+	}
+
+	// Handle non-call messages first:
+	calls := make([]*jsonrpcMessage, 0, len(msgs))
+	for _, msg := range msgs {
+		if handled := h.handleImmediate(msg); !handled {
+			calls = append(calls, msg)
+		}
+	}
+	if len(calls) == 0 {
+		return
+	}
+	// Process calls on a goroutine because they may block indefinitely:
+	h.startCallProc(func(cp *callProc) {
+		answers := make([]*jsonrpcMessage, 0, len(msgs))
+		for _, msg := range calls {
+			if answer := h.handleCallMsg(cp, msg); answer != nil {
+				answers = append(answers, answer)
+			}
+		}
+		h.addSubscriptions(cp.notifiers)
+		if len(answers) > 0 {
+			h.conn.Write(cp.ctx, answers)
+		}
+		for _, n := range cp.notifiers {
+			n.activate()
+		}
+	})
+}
+
+// handleMsg handles a single message.
+func (h *handler) handleMsg(msg *jsonrpcMessage) {
+	if ok := h.handleImmediate(msg); ok {
+		return
+	}
+	h.startCallProc(func(cp *callProc) {
+		answer := h.handleCallMsg(cp, msg)
+		h.addSubscriptions(cp.notifiers)
+		if answer != nil {
+			h.conn.Write(cp.ctx, answer)
+		}
+		for _, n := range cp.notifiers {
+			n.activate()
+		}
+	})
+}
+
+// close cancels all requests except for inflightReq and waits for
+// call goroutines to shut down.
+func (h *handler) close(err error, inflightReq *requestOp) {
+	h.cancelAllRequests(err, inflightReq)
+	h.cancelRoot()
+	h.callWG.Wait()
+	h.cancelServerSubscriptions(err)
+}
+
+// addRequestOp registers a request operation.
+func (h *handler) addRequestOp(op *requestOp) {
+	for _, id := range op.ids {
+		h.respWait[string(id)] = op
+	}
+}
+
+// removeRequestOps stops waiting for the given request IDs.
+func (h *handler) removeRequestOp(op *requestOp) {
+	for _, id := range op.ids {
+		delete(h.respWait, string(id))
+	}
+}
+
+// cancelAllRequests unblocks and removes pending requests and active subscriptions.
+func (h *handler) cancelAllRequests(err error, inflightReq *requestOp) {
+	didClose := make(map[*requestOp]bool)
+	if inflightReq != nil {
+		didClose[inflightReq] = true
+	}
+
+	for id, op := range h.respWait {
+		// Remove the op so that later calls will not close op.resp again.
+		delete(h.respWait, id)
+
+		if !didClose[op] {
+			op.err = err
+			close(op.resp)
+			didClose[op] = true
+		}
+	}
+	for id, sub := range h.clientSubs {
+		delete(h.clientSubs, id)
+		sub.quitWithError(err, false)
+	}
+}
+
+func (h *handler) addSubscriptions(nn []*Notifier) {
+	h.subLock.Lock()
+	defer h.subLock.Unlock()
+
+	for _, n := range nn {
+		if sub := n.takeSubscription(); sub != nil {
+			h.serverSubs[sub.ID] = sub
+		}
+	}
+}
+
+// cancelServerSubscriptions removes all subscriptions and closes their error channels.
+func (h *handler) cancelServerSubscriptions(err error) {
+	h.subLock.Lock()
+	defer h.subLock.Unlock()
+
+	for id, s := range h.serverSubs {
+		s.err <- err
+		close(s.err)
+		delete(h.serverSubs, id)
+	}
+}
+
+// startCallProc runs fn in a new goroutine and starts tracking it in the h.calls wait group.
+func (h *handler) startCallProc(fn func(*callProc)) {
+	h.callWG.Add(1)
+	go func() {
+		ctx, cancel := context.WithCancel(h.rootCtx)
+		defer h.callWG.Done()
+		defer cancel()
+		fn(&callProc{ctx: ctx})
+	}()
+}
+
+// handleImmediate executes non-call messages. It returns false if the message is a
+// call or requires a reply.
+func (h *handler) handleImmediate(msg *jsonrpcMessage) bool {
+	start := time.Now()
+	switch {
+	case msg.isNotification():
+		if strings.HasSuffix(msg.Method, notificationMethodSuffix) {
+			h.handleSubscriptionResult(msg)
+			return true
+		}
+		return false
+	case msg.isResponse():
+		h.handleResponse(msg)
+		h.log.Trace("Handled RPC response", "reqid", idForLog{msg.ID}, "t", time.Since(start))
+		return true
+	default:
+		return false
+	}
+}
+
+// handleSubscriptionResult processes subscription notifications.
+func (h *handler) handleSubscriptionResult(msg *jsonrpcMessage) {
+	var result subscriptionResult
+	if err := json.Unmarshal(msg.Params, &result); err != nil {
+		h.log.Debug("Dropping invalid subscription message")
+		return
+	}
+	if h.clientSubs[result.ID] != nil {
+		h.clientSubs[result.ID].deliver(result.Result)
+	}
+}
+
+// handleResponse processes method call responses.
+func (h *handler) handleResponse(msg *jsonrpcMessage) {
+	op := h.respWait[string(msg.ID)]
+	if op == nil {
+		h.log.Debug("Unsolicited RPC response", "reqid", idForLog{msg.ID})
+		return
+	}
+	delete(h.respWait, string(msg.ID))
+	// For normal responses, just forward the reply to Call/BatchCall.
+	if op.sub == nil {
+		op.resp <- msg
+		return
+	}
+	// For subscription responses, start the subscription if the server
+	// indicates success. EthSubscribe gets unblocked in either case through
+	// the op.resp channel.
+	defer close(op.resp)
+	if msg.Error != nil {
+		op.err = msg.Error
+		return
+	}
+	if op.err = json.Unmarshal(msg.Result, &op.sub.subid); op.err == nil {
+		go op.sub.start()
+		h.clientSubs[op.sub.subid] = op.sub
+	}
+}
+
+// handleCallMsg executes a call message and returns the answer.
+func (h *handler) handleCallMsg(ctx *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
+	start := time.Now()
+	switch {
+	case msg.isNotification():
+		h.handleCall(ctx, msg)
+		h.log.Debug("Served "+msg.Method, "t", time.Since(start))
+		return nil
+	case msg.isCall():
+		resp := h.handleCall(ctx, msg)
+		if resp.Error != nil {
+			h.log.Info("Served "+msg.Method, "reqid", idForLog{msg.ID}, "t", time.Since(start), "err", resp.Error.Message)
+		} else {
+			h.log.Debug("Served "+msg.Method, "reqid", idForLog{msg.ID}, "t", time.Since(start))
+		}
+		return resp
+	case msg.hasValidID():
+		return msg.errorResponse(&invalidRequestError{"invalid request"})
+	default:
+		return errorMessage(&invalidRequestError{"invalid request"})
+	}
+}
+
+// handleCall processes method calls.
+func (h *handler) handleCall(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
+	if msg.isSubscribe() {
+		return h.handleSubscribe(cp, msg)
+	}
+	var callb *callback
+	if msg.isUnsubscribe() {
+		callb = h.unsubscribeCb
+	} else {
+		callb = h.reg.callback(msg.Method)
+	}
+	if callb == nil {
+		return msg.errorResponse(&methodNotFoundError{method: msg.Method})
+	}
+	args, err := parsePositionalArguments(msg.Params, callb.argTypes)
+	if err != nil {
+		return msg.errorResponse(&invalidParamsError{err.Error()})
+	}
+
+	return h.runMethod(cp.ctx, msg, callb, args)
+}
+
+// handleSubscribe processes *_subscribe method calls.
+func (h *handler) handleSubscribe(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
+	if !h.allowSubscribe {
+		return msg.errorResponse(ErrNotificationsUnsupported)
+	}
+
+	// Subscription method name is first argument.
+	name, err := parseSubscriptionName(msg.Params)
+	if err != nil {
+		return msg.errorResponse(&invalidParamsError{err.Error()})
+	}
+	namespace := msg.namespace()
+	callb := h.reg.subscription(namespace, name)
+	if callb == nil {
+		return msg.errorResponse(&subscriptionNotFoundError{namespace, name})
+	}
+
+	// Parse subscription name arg too, but remove it before calling the callback.
+	argTypes := append([]reflect.Type{stringType}, callb.argTypes...)
+	args, err := parsePositionalArguments(msg.Params, argTypes)
+	if err != nil {
+		return msg.errorResponse(&invalidParamsError{err.Error()})
+	}
+	args = args[1:]
+
+	// Install notifier in context so the subscription handler can find it.
+	n := &Notifier{h: h, namespace: namespace}
+	cp.notifiers = append(cp.notifiers, n)
+	ctx := context.WithValue(cp.ctx, notifierKey{}, n)
+
+	return h.runMethod(ctx, msg, callb, args)
+}
+
+// runMethod runs the Go callback for an RPC method.
+func (h *handler) runMethod(ctx context.Context, msg *jsonrpcMessage, callb *callback, args []reflect.Value) *jsonrpcMessage {
+	result, err := callb.call(ctx, msg.Method, args)
+	if err != nil {
+		return msg.errorResponse(err)
+	}
+	return msg.response(result)
+}
+
+// unsubscribe is the callback function for all *_unsubscribe calls.
+func (h *handler) unsubscribe(ctx context.Context, id ID) (bool, error) {
+	h.subLock.Lock()
+	defer h.subLock.Unlock()
+
+	s := h.serverSubs[id]
+	if s == nil {
+		return false, ErrSubscriptionNotFound
+	}
+	close(s.err)
+	delete(h.serverSubs, id)
+	return true, nil
+}
+
+type idForLog struct{ json.RawMessage }
+
+func (id idForLog) String() string {
+	if s, err := strconv.Unquote(string(id.RawMessage)); err == nil {
+		return s
+	}
+	return string(id.RawMessage)
+}

rpc/http.go

@@ -37,38 +37,39 @@ import (
 
 const (
 	maxRequestContentLength = 1024 * 512
+	contentType             = "application/json"
 )
 
-var (
+// https://www.jsonrpc.org/historical/json-rpc-over-http.html#id13
-	// https://www.jsonrpc.org/historical/json-rpc-over-http.html#id13
+var acceptedContentTypes = []string{contentType, "application/json-rpc", "application/jsonrequest"}
-	acceptedContentTypes = []string{"application/json", "application/json-rpc", "application/jsonrequest"}
-	contentType          = acceptedContentTypes[0]
-	nullAddr, _          = net.ResolveTCPAddr("tcp", "127.0.0.1:0")
-)
 
 type httpConn struct {
 	client    *http.Client
 	req       *http.Request
 	closeOnce sync.Once
-	closed    chan struct{}
+	closed    chan interface{}
 }
 
 // httpConn is treated specially by Client.
-func (hc *httpConn) LocalAddr() net.Addr              { return nullAddr }
+func (hc *httpConn) Write(context.Context, interface{}) error {
-func (hc *httpConn) RemoteAddr() net.Addr             { return nullAddr }
+	panic("Write called on httpConn")
-func (hc *httpConn) SetReadDeadline(time.Time) error  { return nil }
-func (hc *httpConn) SetWriteDeadline(time.Time) error { return nil }
-func (hc *httpConn) SetDeadline(time.Time) error      { return nil }
-func (hc *httpConn) Write([]byte) (int, error)        { panic("Write called") }
-
-func (hc *httpConn) Read(b []byte) (int, error) {
-	<-hc.closed
-	return 0, io.EOF
 }
 
-func (hc *httpConn) Close() error {
+func (hc *httpConn) RemoteAddr() string {
+	return hc.req.URL.String()
+}
+
+func (hc *httpConn) Read() ([]*jsonrpcMessage, bool, error) {
+	<-hc.closed
+	return nil, false, io.EOF
+}
+
+func (hc *httpConn) Close() {
 	hc.closeOnce.Do(func() { close(hc.closed) })
-	return nil
+}
+
+func (hc *httpConn) Closed() <-chan interface{} {
+	return hc.closed
 }
 
 // HTTPTimeouts represents the configuration params for the HTTP RPC server.
@@ -114,8 +115,8 @@ func DialHTTPWithClient(endpoint string, client *http.Client) (*Client, error) {
 	req.Header.Set("Accept", contentType)
 
 	initctx := context.Background()
-	return newClient(initctx, func(context.Context) (net.Conn, error) {
+	return newClient(initctx, func(context.Context) (ServerCodec, error) {
-		return &httpConn{client: client, req: req, closed: make(chan struct{})}, nil
+		return &httpConn{client: client, req: req, closed: make(chan interface{})}, nil
 	})
 }
 
@@ -184,17 +185,30 @@ func (hc *httpConn) doRequest(ctx context.Context, msg interface{}) (io.ReadClos
 	return resp.Body, nil
 }
 
-// httpReadWriteNopCloser wraps a io.Reader and io.Writer with a NOP Close method.
+// httpServerConn turns a HTTP connection into a Conn.
-type httpReadWriteNopCloser struct {
+type httpServerConn struct {
 	io.Reader
 	io.Writer
+	r *http.Request
 }
 
-// Close does nothing and returns always nil
+func newHTTPServerConn(r *http.Request, w http.ResponseWriter) ServerCodec {
-func (t *httpReadWriteNopCloser) Close() error {
+	body := io.LimitReader(r.Body, maxRequestContentLength)
-	return nil
+	conn := &httpServerConn{Reader: body, Writer: w, r: r}
+	return NewJSONCodec(conn)
 }
 
+// Close does nothing and always returns nil.
+func (t *httpServerConn) Close() error { return nil }
+
+// RemoteAddr returns the peer address of the underlying connection.
+func (t *httpServerConn) RemoteAddr() string {
+	return t.r.RemoteAddr
+}
+
+// SetWriteDeadline does nothing and always returns nil.
+func (t *httpServerConn) SetWriteDeadline(time.Time) error { return nil }
+
 // NewHTTPServer creates a new HTTP RPC server around an API provider.
 //
 // Deprecated: Server implements http.Handler
@@ -226,7 +240,7 @@ func NewHTTPServer(cors []string, vhosts []string, timeouts HTTPTimeouts, srv *S
 }
 
 // ServeHTTP serves JSON-RPC requests over HTTP.
-func (srv *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	// Permit dumb empty requests for remote health-checks (AWS)
 	if r.Method == http.MethodGet && r.ContentLength == 0 && r.URL.RawQuery == "" {
 		return
@@ -249,12 +263,10 @@ func (srv *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		ctx = context.WithValue(ctx, "Origin", origin)
 	}
 
-	body := io.LimitReader(r.Body, maxRequestContentLength)
-	codec := NewJSONCodec(&httpReadWriteNopCloser{body, w})
-	defer codec.Close()
-
 	w.Header().Set("content-type", contentType)
-	srv.ServeSingleRequest(ctx, codec, OptionMethodInvocation)
+	codec := newHTTPServerConn(r, w)
+	defer codec.Close()
+	s.serveSingleRequest(ctx, codec)
 }
 
 // validateRequest returns a non-zero response code and error message if the

rpc/inproc.go

@@ -24,10 +24,10 @@ import (
 // DialInProc attaches an in-process connection to the given RPC server.
 func DialInProc(handler *Server) *Client {
 	initctx := context.Background()
-	c, _ := newClient(initctx, func(context.Context) (net.Conn, error) {
+	c, _ := newClient(initctx, func(context.Context) (ServerCodec, error) {
 		p1, p2 := net.Pipe()
 		go handler.ServeCodec(NewJSONCodec(p1), OptionMethodInvocation|OptionSubscriptions)
-		return p2, nil
+		return NewJSONCodec(p2), nil
 	})
 	return c
 }

rpc/ipc.go

@@ -25,17 +25,17 @@ import (
 )
 
 // ServeListener accepts connections on l, serving JSON-RPC on them.
-func (srv *Server) ServeListener(l net.Listener) error {
+func (s *Server) ServeListener(l net.Listener) error {
 	for {
 		conn, err := l.Accept()
 		if netutil.IsTemporaryError(err) {
-			log.Warn("IPC accept error", "err", err)
+			log.Warn("RPC accept error", "err", err)
 			continue
 		} else if err != nil {
 			return err
 		}
-		log.Trace("IPC accepted connection")
+		log.Trace("Accepted RPC connection", "conn", conn.RemoteAddr())
-		go srv.ServeCodec(NewJSONCodec(conn), OptionMethodInvocation|OptionSubscriptions)
+		go s.ServeCodec(NewJSONCodec(conn), OptionMethodInvocation|OptionSubscriptions)
 	}
 }
 
@@ -46,7 +46,11 @@ func (srv *Server) ServeListener(l net.Listener) error {
 // The context is used for the initial connection establishment. It does not
 // affect subsequent interactions with the client.
 func DialIPC(ctx context.Context, endpoint string) (*Client, error) {
-	return newClient(ctx, func(ctx context.Context) (net.Conn, error) {
+	return newClient(ctx, func(ctx context.Context) (ServerCodec, error) {
-		return newIPCConnection(ctx, endpoint)
+		conn, err := newIPCConnection(ctx, endpoint)
+		if err != nil {
+			return nil, err
+		}
+		return NewJSONCodec(conn), err
 	})
 }

rpc/json.go

@@ -18,36 +18,116 @@ package rpc
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"reflect"
-	"strconv"
 	"strings"
 	"sync"
-
+	"time"
-	"github.com/ubiq/go-ubiq/log"
 )
 
 const (
-	jsonrpcVersion           = "2.0"
+	vsn                      = "2.0"
-	serviceMethodSeparator   = "_"
 	subscribeMethodSuffix    = "_subscribe"
 	unsubscribeMethodSuffix  = "_unsubscribe"
 	notificationMethodSuffix = "_subscription"
+
+	defaultWriteTimeout = 10 * time.Second // used if context has no deadline
 )
 
-type jsonRequest struct {
+var (
-	Method  string          `json:"method"`
+	null                    = json.RawMessage("null")
-	Version string          `json:"jsonrpc"`
+	serviceMethodSeparators = []string{"_", "."}
-	Id      json.RawMessage `json:"id,omitempty"`
+	errInvalidMethodName    = errors.New("invalid method name")
-	Payload json.RawMessage `json:"params,omitempty"`
+)
+
+func elementizeMethodName(methodName string) (module, method string, err error) {
+	for _, sep := range serviceMethodSeparators {
+		if s := strings.SplitN(methodName, sep, 2); len(s) == 2 {
+			return s[0], s[1], nil
+		}
+	}
+	return "", "", errInvalidMethodName
 }
 
-type jsonSuccessResponse struct {
+type subscriptionResult struct {
-	Version string      `json:"jsonrpc"`
+	ID     string          `json:"subscription"`
-	Id      interface{} `json:"id,omitempty"`
+	Result json.RawMessage `json:"result,omitempty"`
-	Result  interface{} `json:"result"`
+}
+
+// A value of this type can a JSON-RPC request, notification, successful response or
+// error response. Which one it is depends on the fields.
+type jsonrpcMessage struct {
+	Version string          `json:"jsonrpc,omitempty"`
+	ID      json.RawMessage `json:"id,omitempty"`
+	Method  string          `json:"method,omitempty"`
+	Params  json.RawMessage `json:"params,omitempty"`
+	Error   *jsonError      `json:"error,omitempty"`
+	Result  json.RawMessage `json:"result,omitempty"`
+}
+
+func (msg *jsonrpcMessage) isNotification() bool {
+	return msg.ID == nil && msg.Method != ""
+}
+
+func (msg *jsonrpcMessage) isCall() bool {
+	return msg.hasValidID() && msg.Method != ""
+}
+
+func (msg *jsonrpcMessage) isResponse() bool {
+	return msg.hasValidID() && msg.Method == "" && msg.Params == nil && (msg.Result != nil || msg.Error != nil)
+}
+
+func (msg *jsonrpcMessage) hasValidID() bool {
+	return len(msg.ID) > 0 && msg.ID[0] != '{' && msg.ID[0] != '['
+}
+
+func (msg *jsonrpcMessage) isSubscribe() bool {
+	return strings.HasSuffix(msg.Method, subscribeMethodSuffix)
+}
+
+func (msg *jsonrpcMessage) isUnsubscribe() bool {
+	return strings.HasSuffix(msg.Method, unsubscribeMethodSuffix)
+}
+
+func (msg *jsonrpcMessage) namespace() string {
+	module, _, _ := elementizeMethodName(msg.Method)
+	return module // even if err != nil, empty string is returned so err can be ignored
+}
+
+func (msg *jsonrpcMessage) String() string {
+	b, _ := json.Marshal(msg)
+	return string(b)
+}
+
+func (msg *jsonrpcMessage) errorResponse(err error) *jsonrpcMessage {
+	resp := errorMessage(err)
+	resp.ID = msg.ID
+	return resp
+}
+
+func (msg *jsonrpcMessage) response(result interface{}) *jsonrpcMessage {
+	enc, err := json.Marshal(result)
+	if err != nil {
+		// TODO: wrap with 'internal server error'
+		return msg.errorResponse(err)
+	}
+	return &jsonrpcMessage{Version: vsn, ID: msg.ID, Result: enc}
+}
+
+func errorMessage(err error) *jsonrpcMessage {
+	msg := &jsonrpcMessage{Version: vsn, ID: null, Error: &jsonError{
+		Code:    defaultErrorCode,
+		Message: err.Error(),
+	}}
+	ec, ok := err.(Error)
+	if ok {
+		msg.Error.Code = ec.ErrorCode()
+	}
+	return msg
 }
 
 type jsonError struct {
@@ -56,35 +136,6 @@ type jsonError struct {
 	Data    interface{} `json:"data,omitempty"`
 }
 
-type jsonErrResponse struct {
-	Version string      `json:"jsonrpc"`
-	Id      interface{} `json:"id,omitempty"`
-	Error   jsonError   `json:"error"`
-}
-
-type jsonSubscription struct {
-	Subscription string      `json:"subscription"`
-	Result       interface{} `json:"result,omitempty"`
-}
-
-type jsonNotification struct {
-	Version string           `json:"jsonrpc"`
-	Method  string           `json:"method"`
-	Params  jsonSubscription `json:"params"`
-}
-
-// jsonCodec reads and writes JSON-RPC messages to the underlying connection. It
-// also has support for parsing arguments and serializing (result) objects.
-type jsonCodec struct {
-	closer sync.Once                 // close closed channel once
-	closed chan interface{}          // closed on Close
-	decMu  sync.Mutex                // guards the decoder
-	decode func(v interface{}) error // decoder to allow multiple transports
-	encMu  sync.Mutex                // guards the encoder
-	encode func(v interface{}) error // encoder to allow multiple transports
-	rw     io.ReadWriteCloser        // connection
-}
-
 func (err *jsonError) Error() string {
 	if err.Message == "" {
 		return fmt.Sprintf("json-rpc error %d", err.Code)
@@ -96,34 +147,126 @@ func (err *jsonError) ErrorCode() int {
 	return err.Code
 }
 
+// Conn is a subset of the methods of net.Conn which are sufficient for ServerCodec.
+type Conn interface {
+	io.ReadWriteCloser
+	SetWriteDeadline(time.Time) error
+}
+
+// ConnRemoteAddr wraps the RemoteAddr operation, which returns a description
+// of the peer address of a connection. If a Conn also implements ConnRemoteAddr, this
+// description is used in log messages.
+type ConnRemoteAddr interface {
+	RemoteAddr() string
+}
+
+// connWithRemoteAddr overrides the remote address of a connection.
+type connWithRemoteAddr struct {
+	Conn
+	addr string
+}
+
+func (c connWithRemoteAddr) RemoteAddr() string { return c.addr }
+
+// jsonCodec reads and writes JSON-RPC messages to the underlying connection. It also has
+// support for parsing arguments and serializing (result) objects.
+type jsonCodec struct {
+	remoteAddr string
+	closer     sync.Once                 // close closed channel once
+	closed     chan interface{}          // closed on Close
+	decode     func(v interface{}) error // decoder to allow multiple transports
+	encMu      sync.Mutex                // guards the encoder
+	encode     func(v interface{}) error // encoder to allow multiple transports
+	conn       Conn
+}
+
 // NewCodec creates a new RPC server codec with support for JSON-RPC 2.0 based
 // on explicitly given encoding and decoding methods.
-func NewCodec(rwc io.ReadWriteCloser, encode, decode func(v interface{}) error) ServerCodec {
+func NewCodec(conn Conn, encode, decode func(v interface{}) error) ServerCodec {
-	return &jsonCodec{
+	codec := &jsonCodec{
 		closed: make(chan interface{}),
 		encode: encode,
 		decode: decode,
-		rw:     rwc,
+		conn:   conn,
 	}
+	if ra, ok := conn.(ConnRemoteAddr); ok {
+		codec.remoteAddr = ra.RemoteAddr()
+	}
+	return codec
 }
 
 // NewJSONCodec creates a new RPC server codec with support for JSON-RPC 2.0.
-func NewJSONCodec(rwc io.ReadWriteCloser) ServerCodec {
+func NewJSONCodec(conn Conn) ServerCodec {
-	enc := json.NewEncoder(rwc)
+	enc := json.NewEncoder(conn)
-	dec := json.NewDecoder(rwc)
+	dec := json.NewDecoder(conn)
 	dec.UseNumber()
+	return NewCodec(conn, enc.Encode, dec.Decode)
+}
 
-	return &jsonCodec{
+func (c *jsonCodec) RemoteAddr() string {
-		closed: make(chan interface{}),
+	return c.remoteAddr
-		encode: enc.Encode,
+}
-		decode: dec.Decode,
+
-		rw:     rwc,
+func (c *jsonCodec) Read() (msg []*jsonrpcMessage, batch bool, err error) {
+	// Decode the next JSON object in the input stream.
+	// This verifies basic syntax, etc.
+	var rawmsg json.RawMessage
+	if err := c.decode(&rawmsg); err != nil {
+		return nil, false, err
 	}
+	msg, batch = parseMessage(rawmsg)
+	return msg, batch, nil
+}
+
+// Write sends a message to client.
+func (c *jsonCodec) Write(ctx context.Context, v interface{}) error {
+	c.encMu.Lock()
+	defer c.encMu.Unlock()
+
+	deadline, ok := ctx.Deadline()
+	if !ok {
+		deadline = time.Now().Add(defaultWriteTimeout)
+	}
+	c.conn.SetWriteDeadline(deadline)
+	return c.encode(v)
+}
+
+// Close the underlying connection
+func (c *jsonCodec) Close() {
+	c.closer.Do(func() {
+		close(c.closed)
+		c.conn.Close()
+	})
+}
+
+// Closed returns a channel which will be closed when Close is called
+func (c *jsonCodec) Closed() <-chan interface{} {
+	return c.closed
+}
+
+// parseMessage parses raw bytes as a (batch of) JSON-RPC message(s). There are no error
+// checks in this function because the raw message has already been syntax-checked when it
+// is called. Any non-JSON-RPC messages in the input return the zero value of
+// jsonrpcMessage.
+func parseMessage(raw json.RawMessage) ([]*jsonrpcMessage, bool) {
+	if !isBatch(raw) {
+		msgs := []*jsonrpcMessage{{}}
+		json.Unmarshal(raw, &msgs[0])
+		return msgs, false
+	}
+	dec := json.NewDecoder(bytes.NewReader(raw))
+	dec.Token() // skip '['
+	var msgs []*jsonrpcMessage
+	for dec.More() {
+		msgs = append(msgs, new(jsonrpcMessage))
+		dec.Decode(&msgs[len(msgs)-1])
+	}
+	return msgs, true
 }
 
 // isBatch returns true when the first non-whitespace characters is '['
-func isBatch(msg json.RawMessage) bool {
+func isBatch(raw json.RawMessage) bool {
-	for _, c := range msg {
+	for _, c := range raw {
 		// skip insignificant whitespace (http://www.ietf.org/rfc/rfc4627.txt)
 		if c == 0x20 || c == 0x09 || c == 0x0a || c == 0x0d {
 			continue
@@ -133,231 +276,67 @@ func isBatch(msg json.RawMessage) bool {
 	return false
 }
 
-// ReadRequestHeaders will read new requests without parsing the arguments. It will
-// return a collection of requests, an indication if these requests are in batch
-// form or an error when the incoming message could not be read/parsed.
-func (c *jsonCodec) ReadRequestHeaders() ([]rpcRequest, bool, Error) {
-	c.decMu.Lock()
-	defer c.decMu.Unlock()
-
-	var incomingMsg json.RawMessage
-	if err := c.decode(&incomingMsg); err != nil {
-		return nil, false, &invalidRequestError{err.Error()}
-	}
-	if isBatch(incomingMsg) {
-		return parseBatchRequest(incomingMsg)
-	}
-	return parseRequest(incomingMsg)
-}
-
-// checkReqId returns an error when the given reqId isn't valid for RPC method calls.
-// valid id's are strings, numbers or null
-func checkReqId(reqId json.RawMessage) error {
-	if len(reqId) == 0 {
-		return fmt.Errorf("missing request id")
-	}
-	if _, err := strconv.ParseFloat(string(reqId), 64); err == nil {
-		return nil
-	}
-	var str string
-	if err := json.Unmarshal(reqId, &str); err == nil {
-		return nil
-	}
-	return fmt.Errorf("invalid request id")
-}
-
-// parseRequest will parse a single request from the given RawMessage. It will return
-// the parsed request, an indication if the request was a batch or an error when
-// the request could not be parsed.
-func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
-	var in jsonRequest
-	if err := json.Unmarshal(incomingMsg, &in); err != nil {
-		return nil, false, &invalidMessageError{err.Error()}
-	}
-
-	if err := checkReqId(in.Id); err != nil {
-		return nil, false, &invalidMessageError{err.Error()}
-	}
-
-	// subscribe are special, they will always use `subscribeMethod` as first param in the payload
-	if strings.HasSuffix(in.Method, subscribeMethodSuffix) {
-		reqs := []rpcRequest{{id: &in.Id, isPubSub: true}}
-		if len(in.Payload) > 0 {
-			// first param must be subscription name
-			var subscribeMethod [1]string
-			if err := json.Unmarshal(in.Payload, &subscribeMethod); err != nil {
-				log.Debug(fmt.Sprintf("Unable to parse subscription method: %v\n", err))
-				return nil, false, &invalidRequestError{"Unable to parse subscription request"}
-			}
-
-			reqs[0].service, reqs[0].method = strings.TrimSuffix(in.Method, subscribeMethodSuffix), subscribeMethod[0]
-			reqs[0].params = in.Payload
-			return reqs, false, nil
-		}
-		return nil, false, &invalidRequestError{"Unable to parse subscription request"}
-	}
-
-	if strings.HasSuffix(in.Method, unsubscribeMethodSuffix) {
-		return []rpcRequest{{id: &in.Id, isPubSub: true,
-			method: in.Method, params: in.Payload}}, false, nil
-	}
-
-	elems := strings.Split(in.Method, serviceMethodSeparator)
-	if len(elems) != 2 {
-		return nil, false, &methodNotFoundError{in.Method, ""}
-	}
-
-	// regular RPC call
-	if len(in.Payload) == 0 {
-		return []rpcRequest{{service: elems[0], method: elems[1], id: &in.Id}}, false, nil
-	}
-
-	return []rpcRequest{{service: elems[0], method: elems[1], id: &in.Id, params: in.Payload}}, false, nil
-}
-
-// parseBatchRequest will parse a batch request into a collection of requests from the given RawMessage, an indication
-// if the request was a batch or an error when the request could not be read.
-func parseBatchRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
-	var in []jsonRequest
-	if err := json.Unmarshal(incomingMsg, &in); err != nil {
-		return nil, false, &invalidMessageError{err.Error()}
-	}
-
-	requests := make([]rpcRequest, len(in))
-	for i, r := range in {
-		if err := checkReqId(r.Id); err != nil {
-			return nil, false, &invalidMessageError{err.Error()}
-		}
-
-		id := &in[i].Id
-
-		// subscribe are special, they will always use `subscriptionMethod` as first param in the payload
-		if strings.HasSuffix(r.Method, subscribeMethodSuffix) {
-			requests[i] = rpcRequest{id: id, isPubSub: true}
-			if len(r.Payload) > 0 {
-				// first param must be subscription name
-				var subscribeMethod [1]string
-				if err := json.Unmarshal(r.Payload, &subscribeMethod); err != nil {
-					log.Debug(fmt.Sprintf("Unable to parse subscription method: %v\n", err))
-					return nil, false, &invalidRequestError{"Unable to parse subscription request"}
-				}
-
-				requests[i].service, requests[i].method = strings.TrimSuffix(r.Method, subscribeMethodSuffix), subscribeMethod[0]
-				requests[i].params = r.Payload
-				continue
-			}
-
-			return nil, true, &invalidRequestError{"Unable to parse (un)subscribe request arguments"}
-		}
-
-		if strings.HasSuffix(r.Method, unsubscribeMethodSuffix) {
-			requests[i] = rpcRequest{id: id, isPubSub: true, method: r.Method, params: r.Payload}
-			continue
-		}
-
-		if len(r.Payload) == 0 {
-			requests[i] = rpcRequest{id: id, params: nil}
-		} else {
-			requests[i] = rpcRequest{id: id, params: r.Payload}
-		}
-		if elem := strings.Split(r.Method, serviceMethodSeparator); len(elem) == 2 {
-			requests[i].service, requests[i].method = elem[0], elem[1]
-		} else {
-			requests[i].err = &methodNotFoundError{r.Method, ""}
-		}
-	}
-
-	return requests, true, nil
-}
-
-// ParseRequestArguments tries to parse the given params (json.RawMessage) with the given
-// types. It returns the parsed values or an error when the parsing failed.
-func (c *jsonCodec) ParseRequestArguments(argTypes []reflect.Type, params interface{}) ([]reflect.Value, Error) {
-	if args, ok := params.(json.RawMessage); !ok {
-		return nil, &invalidParamsError{"Invalid params supplied"}
-	} else {
-		return parsePositionalArguments(args, argTypes)
-	}
-}
-
 // parsePositionalArguments tries to parse the given args to an array of values with the
 // given types. It returns the parsed values or an error when the args could not be
 // parsed. Missing optional arguments are returned as reflect.Zero values.
-func parsePositionalArguments(rawArgs json.RawMessage, types []reflect.Type) ([]reflect.Value, Error) {
+func parsePositionalArguments(rawArgs json.RawMessage, types []reflect.Type) ([]reflect.Value, error) {
-	// Read beginning of the args array.
 	dec := json.NewDecoder(bytes.NewReader(rawArgs))
-	if tok, _ := dec.Token(); tok != json.Delim('[') {
+	var args []reflect.Value
-		return nil, &invalidParamsError{"non-array args"}
+	tok, err := dec.Token()
-	}
+	switch {
-	// Read args.
+	case err == io.EOF || tok == nil && err == nil:
-	args := make([]reflect.Value, 0, len(types))
+		// "params" is optional and may be empty. Also allow "params":null even though it's
-	for i := 0; dec.More(); i++ {
+		// not in the spec because our own client used to send it.
-		if i >= len(types) {
+	case err != nil:
-			return nil, &invalidParamsError{fmt.Sprintf("too many arguments, want at most %d", len(types))}
+		return nil, err
+	case tok == json.Delim('['):
+		// Read argument array.
+		if args, err = parseArgumentArray(dec, types); err != nil {
+			return nil, err
 		}
-		argval := reflect.New(types[i])
+	default:
-		if err := dec.Decode(argval.Interface()); err != nil {
+		return nil, errors.New("non-array args")
-			return nil, &invalidParamsError{fmt.Sprintf("invalid argument %d: %v", i, err)}
-		}
-		if argval.IsNil() && types[i].Kind() != reflect.Ptr {
-			return nil, &invalidParamsError{fmt.Sprintf("missing value for required argument %d", i)}
-		}
-		args = append(args, argval.Elem())
-	}
-	// Read end of args array.
-	if _, err := dec.Token(); err != nil {
-		return nil, &invalidParamsError{err.Error()}
 	}
 	// Set any missing args to nil.
 	for i := len(args); i < len(types); i++ {
 		if types[i].Kind() != reflect.Ptr {
-			return nil, &invalidParamsError{fmt.Sprintf("missing value for required argument %d", i)}
+			return nil, fmt.Errorf("missing value for required argument %d", i)
 		}
 		args = append(args, reflect.Zero(types[i]))
 	}
 	return args, nil
 }
 
-// CreateResponse will create a JSON-RPC success response with the given id and reply as result.
+func parseArgumentArray(dec *json.Decoder, types []reflect.Type) ([]reflect.Value, error) {
-func (c *jsonCodec) CreateResponse(id interface{}, reply interface{}) interface{} {
+	args := make([]reflect.Value, 0, len(types))
-	return &jsonSuccessResponse{Version: jsonrpcVersion, Id: id, Result: reply}
+	for i := 0; dec.More(); i++ {
+		if i >= len(types) {
+			return args, fmt.Errorf("too many arguments, want at most %d", len(types))
+		}
+		argval := reflect.New(types[i])
+		if err := dec.Decode(argval.Interface()); err != nil {
+			return args, fmt.Errorf("invalid argument %d: %v", i, err)
+		}
+		if argval.IsNil() && types[i].Kind() != reflect.Ptr {
+			return args, fmt.Errorf("missing value for required argument %d", i)
+		}
+		args = append(args, argval.Elem())
+	}
+	// Read end of args array.
+	_, err := dec.Token()
+	return args, err
 }
 
-// CreateErrorResponse will create a JSON-RPC error response with the given id and error.
+// parseSubscriptionName extracts the subscription name from an encoded argument array.
-func (c *jsonCodec) CreateErrorResponse(id interface{}, err Error) interface{} {
+func parseSubscriptionName(rawArgs json.RawMessage) (string, error) {
-	return &jsonErrResponse{Version: jsonrpcVersion, Id: id, Error: jsonError{Code: err.ErrorCode(), Message: err.Error()}}
+	dec := json.NewDecoder(bytes.NewReader(rawArgs))
-}
+	if tok, _ := dec.Token(); tok != json.Delim('[') {
-
+		return "", errors.New("non-array args")
-// CreateErrorResponseWithInfo will create a JSON-RPC error response with the given id and error.
+	}
-// info is optional and contains additional information about the error. When an empty string is passed it is ignored.
+	v, _ := dec.Token()
-func (c *jsonCodec) CreateErrorResponseWithInfo(id interface{}, err Error, info interface{}) interface{} {
+	method, ok := v.(string)
-	return &jsonErrResponse{Version: jsonrpcVersion, Id: id,
+	if !ok {
-		Error: jsonError{Code: err.ErrorCode(), Message: err.Error(), Data: info}}
+		return "", errors.New("expected subscription name as first argument")
-}
+	}
-
+	return method, nil
-// CreateNotification will create a JSON-RPC notification with the given subscription id and event as params.
-func (c *jsonCodec) CreateNotification(subid, namespace string, event interface{}) interface{} {
-	return &jsonNotification{Version: jsonrpcVersion, Method: namespace + notificationMethodSuffix,
-		Params: jsonSubscription{Subscription: subid, Result: event}}
-}
-
-// Write message to client
-func (c *jsonCodec) Write(res interface{}) error {
-	c.encMu.Lock()
-	defer c.encMu.Unlock()
-
-	return c.encode(res)
-}
-
-// Close the underlying connection
-func (c *jsonCodec) Close() {
-	c.closer.Do(func() {
-		close(c.closed)
-		c.rw.Close()
-	})
-}
-
-// Closed returns a channel which will be closed when Close is called
-func (c *jsonCodec) Closed() <-chan interface{} {
-	return c.closed
 }

rpc/json_test.go

@@ -1,178 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"reflect"
-	"strconv"
-	"testing"
-)
-
-type RWC struct {
-	*bufio.ReadWriter
-}
-
-func (rwc *RWC) Close() error {
-	return nil
-}
-
-func TestJSONRequestParsing(t *testing.T) {
-	server := NewServer()
-	service := new(Service)
-
-	if err := server.RegisterName("calc", service); err != nil {
-		t.Fatalf("%v", err)
-	}
-
-	req := bytes.NewBufferString(`{"id": 1234, "jsonrpc": "2.0", "method": "calc_add", "params": [11, 22]}`)
-	var str string
-	reply := bytes.NewBufferString(str)
-	rw := &RWC{bufio.NewReadWriter(bufio.NewReader(req), bufio.NewWriter(reply))}
-
-	codec := NewJSONCodec(rw)
-
-	requests, batch, err := codec.ReadRequestHeaders()
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-
-	if batch {
-		t.Fatalf("Request isn't a batch")
-	}
-
-	if len(requests) != 1 {
-		t.Fatalf("Expected 1 request but got %d requests - %v", len(requests), requests)
-	}
-
-	if requests[0].service != "calc" {
-		t.Fatalf("Expected service 'calc' but got '%s'", requests[0].service)
-	}
-
-	if requests[0].method != "add" {
-		t.Fatalf("Expected method 'Add' but got '%s'", requests[0].method)
-	}
-
-	if rawId, ok := requests[0].id.(*json.RawMessage); ok {
-		id, e := strconv.ParseInt(string(*rawId), 0, 64)
-		if e != nil {
-			t.Fatalf("%v", e)
-		}
-		if id != 1234 {
-			t.Fatalf("Expected id 1234 but got %d", id)
-		}
-	} else {
-		t.Fatalf("invalid request, expected *json.RawMesage got %T", requests[0].id)
-	}
-
-	var arg int
-	args := []reflect.Type{reflect.TypeOf(arg), reflect.TypeOf(arg)}
-
-	v, err := codec.ParseRequestArguments(args, requests[0].params)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-
-	if len(v) != 2 {
-		t.Fatalf("Expected 2 argument values, got %d", len(v))
-	}
-
-	if v[0].Int() != 11 || v[1].Int() != 22 {
-		t.Fatalf("expected %d == 11 && %d == 22", v[0].Int(), v[1].Int())
-	}
-}
-
-func TestJSONRequestParamsParsing(t *testing.T) {
-
-	var (
-		stringT = reflect.TypeOf("")
-		intT    = reflect.TypeOf(0)
-		intPtrT = reflect.TypeOf(new(int))
-
-		stringV = reflect.ValueOf("abc")
-		i       = 1
-		intV    = reflect.ValueOf(i)
-		intPtrV = reflect.ValueOf(&i)
-	)
-
-	var validTests = []struct {
-		input    string
-		argTypes []reflect.Type
-		expected []reflect.Value
-	}{
-		{`[]`, []reflect.Type{}, []reflect.Value{}},
-		{`[]`, []reflect.Type{intPtrT}, []reflect.Value{intPtrV}},
-		{`[1]`, []reflect.Type{intT}, []reflect.Value{intV}},
-		{`[1,"abc"]`, []reflect.Type{intT, stringT}, []reflect.Value{intV, stringV}},
-		{`[null]`, []reflect.Type{intPtrT}, []reflect.Value{intPtrV}},
-		{`[null,"abc"]`, []reflect.Type{intPtrT, stringT, intPtrT}, []reflect.Value{intPtrV, stringV, intPtrV}},
-		{`[null,"abc",null]`, []reflect.Type{intPtrT, stringT, intPtrT}, []reflect.Value{intPtrV, stringV, intPtrV}},
-	}
-
-	codec := jsonCodec{}
-
-	for _, test := range validTests {
-		params := (json.RawMessage)([]byte(test.input))
-		args, err := codec.ParseRequestArguments(test.argTypes, params)
-
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		var match []interface{}
-		json.Unmarshal([]byte(test.input), &match)
-
-		if len(args) != len(test.argTypes) {
-			t.Fatalf("expected %d parsed args, got %d", len(test.argTypes), len(args))
-		}
-
-		for i, arg := range args {
-			expected := test.expected[i]
-
-			if arg.Kind() != expected.Kind() {
-				t.Errorf("expected type for param %d in %s", i, test.input)
-			}
-
-			if arg.Kind() == reflect.Int && arg.Int() != expected.Int() {
-				t.Errorf("expected int(%d), got int(%d) in %s", expected.Int(), arg.Int(), test.input)
-			}
-
-			if arg.Kind() == reflect.String && arg.String() != expected.String() {
-				t.Errorf("expected string(%s), got string(%s) in %s", expected.String(), arg.String(), test.input)
-			}
-		}
-	}
-
-	var invalidTests = []struct {
-		input    string
-		argTypes []reflect.Type
-	}{
-		{`[]`, []reflect.Type{intT}},
-		{`[null]`, []reflect.Type{intT}},
-		{`[1]`, []reflect.Type{stringT}},
-		{`[1,2]`, []reflect.Type{stringT}},
-		{`["abc", null]`, []reflect.Type{stringT, intT}},
-	}
-
-	for i, test := range invalidTests {
-		if _, err := codec.ParseRequestArguments(test.argTypes, test.input); err == nil {
-			t.Errorf("expected test %d - %s to fail", i, test.input)
-		}
-	}
-}

rpc/openrpc.go

@@ -14,11 +14,12 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-// +build !race
+package rpc
 
-package stream
+type OpenRPCDiscoverSchemaT struct {
-
+	OpenRPC    string                   `json:"openrpc"`
-// Provide a flag to reduce the scope of tests when running them
+	Info       map[string]interface{}   `json:"info"`
-// with race detector. Some of the tests are doing a lot of allocations
+	Servers    []map[string]interface{} `json:"servers"`
-// on the heap, and race detector uses much more memory to track them.
+	Methods    []map[string]interface{} `json:"methods"`
-const raceTest = false
+	Components map[string]interface{}   `json:"components"`
+}

rpc/server.go

@@ -18,11 +18,10 @@ package rpc
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"fmt"
-	"reflect"
+	"io"
-	"runtime"
-	"strings"
-	"sync"
 	"sync/atomic"
 
 	mapset "github.com/deckarep/golang-set"
@@ -31,7 +30,19 @@ import (
 
 const MetadataApi = "rpc"
 
-// CodecOption specifies which type of messages this codec supports
+var (
+	// defaultOpenRPCSchemaRaw can be used to establish a default (package-wide) OpenRPC schema from raw JSON.
+	// Methods will be cross referenced with actual registered method names in order to serve
+	// only server-enabled methods, enabling user and on-the-fly server endpoint availability configuration.
+	defaultOpenRPCSchemaRaw string
+
+	errOpenRPCDiscoverUnavailable   = errors.New("openrpc discover data unavailable")
+	errOpenRPCDiscoverSchemaInvalid = errors.New("openrpc discover data invalid")
+)
+
+// CodecOption specifies which type of messages a codec supports.
+//
+// Deprecated: this option is no longer honored by Server.
 type CodecOption int
 
 const (
@@ -42,22 +53,129 @@ const (
 	OptionSubscriptions = 1 << iota // support pub sub
 )
 
-// NewServer will create a new server instance with no registered handlers.
+// Server is an RPC server.
+type Server struct {
+	services         serviceRegistry
+	idgen            func() ID
+	run              int32
+	codecs           mapset.Set
+	OpenRPCSchemaRaw string
+}
+
+// NewServer creates a new server instance with no registered handlers.
 func NewServer() *Server {
 	server := &Server{
-		services: make(serviceRegistry),
+		idgen:            randomIDGenerator(),
-		codecs:   mapset.NewSet(),
+		codecs:           mapset.NewSet(),
-		run:      1,
+		run:              1,
+		OpenRPCSchemaRaw: defaultOpenRPCSchemaRaw,
 	}
-
+	// Register the default service providing meta information about the RPC service such
-	// register a default service which will provide meta information about the RPC service such as the services and
+	// as the services and methods it offers.
-	// methods it offers.
 	rpcService := &RPCService{server}
 	server.RegisterName(MetadataApi, rpcService)
-
 	return server
 }
 
+func validateOpenRPCSchemaRaw(schemaJSON string) error {
+	if schemaJSON == "" {
+		return errOpenRPCDiscoverSchemaInvalid
+	}
+	var schema OpenRPCDiscoverSchemaT
+	if err := json.Unmarshal([]byte(schemaJSON), &schema); err != nil {
+		return fmt.Errorf("%v: %v", errOpenRPCDiscoverSchemaInvalid, err)
+	}
+	return nil
+}
+
+// SetDefaultOpenRPCSchemaRaw validates and sets the package-wide OpenRPC schema data.
+func SetDefaultOpenRPCSchemaRaw(schemaJSON string) error {
+	if err := validateOpenRPCSchemaRaw(schemaJSON); err != nil {
+		return err
+	}
+	defaultOpenRPCSchemaRaw = schemaJSON
+	return nil
+}
+
+// SetOpenRPCSchemaRaw validates and sets the raw OpenRPC schema data for a server.
+func (s *Server) SetOpenRPCSchemaRaw(schemaJSON string) error {
+	if err := validateOpenRPCSchemaRaw(schemaJSON); err != nil {
+		return err
+	}
+	s.OpenRPCSchemaRaw = schemaJSON
+	return nil
+}
+
+// RegisterName creates a service for the given receiver type under the given name. When no
+// methods on the given receiver match the criteria to be either a RPC method or a
+// subscription an error is returned. Otherwise a new service is created and added to the
+// service collection this server provides to clients.
+func (s *Server) RegisterName(name string, receiver interface{}) error {
+	return s.services.registerName(name, receiver)
+}
+
+// ServeCodec reads incoming requests from codec, calls the appropriate callback and writes
+// the response back using the given codec. It will block until the codec is closed or the
+// server is stopped. In either case the codec is closed.
+//
+// Note that codec options are no longer supported.
+func (s *Server) ServeCodec(codec ServerCodec, options CodecOption) {
+	defer codec.Close()
+
+	// Don't serve if server is stopped.
+	if atomic.LoadInt32(&s.run) == 0 {
+		return
+	}
+
+	// Add the codec to the set so it can be closed by Stop.
+	s.codecs.Add(codec)
+	defer s.codecs.Remove(codec)
+
+	c := initClient(codec, s.idgen, &s.services)
+	<-codec.Closed()
+	c.Close()
+}
+
+// serveSingleRequest reads and processes a single RPC request from the given codec. This
+// is used to serve HTTP connections. Subscriptions and reverse calls are not allowed in
+// this mode.
+func (s *Server) serveSingleRequest(ctx context.Context, codec ServerCodec) {
+	// Don't serve if server is stopped.
+	if atomic.LoadInt32(&s.run) == 0 {
+		return
+	}
+
+	h := newHandler(ctx, codec, s.idgen, &s.services)
+	h.allowSubscribe = false
+	defer h.close(io.EOF, nil)
+
+	reqs, batch, err := codec.Read()
+	if err != nil {
+		if err != io.EOF {
+			codec.Write(ctx, errorMessage(&invalidMessageError{"parse error"}))
+		}
+		return
+	}
+	if batch {
+		h.handleBatch(reqs)
+	} else {
+		h.handleMsg(reqs[0])
+	}
+}
+
+// Stop stops reading new requests, waits for stopPendingRequestTimeout to allow pending
+// requests to finish, then closes all codecs which will cancel pending requests and
+// subscriptions.
+func (s *Server) Stop() {
+	if atomic.CompareAndSwapInt32(&s.run, 1, 0) {
+		log.Debug("RPC server shutting down")
+		s.codecs.Each(func(c interface{}) bool {
+			c.(ServerCodec).Close()
+			return true
+		})
+	}
+}
+
 // RPCService gives meta information about the server.
 // e.g. gives information about the loaded modules.
 type RPCService struct {
@@ -66,377 +184,75 @@ type RPCService struct {
 
 // Modules returns the list of RPC services with their version number
 func (s *RPCService) Modules() map[string]string {
+	s.server.services.mu.Lock()
+	defer s.server.services.mu.Unlock()
+
 	modules := make(map[string]string)
-	for name := range s.server.services {
+	for name := range s.server.services.services {
 		modules[name] = "1.0"
 	}
 	return modules
 }
 
-// RegisterName will create a service for the given rcvr type under the given name. When no methods on the given rcvr
+func (s *RPCService) methods() map[string][]string {
-// match the criteria to be either a RPC method or a subscription an error is returned. Otherwise a new service is
+	s.server.services.mu.Lock()
-// created and added to the service collection this server instance serves.
+	defer s.server.services.mu.Unlock()
-func (s *Server) RegisterName(name string, rcvr interface{}) error {
-	if s.services == nil {
-		s.services = make(serviceRegistry)
-	}
 
-	svc := new(service)
+	methods := make(map[string][]string)
-	svc.typ = reflect.TypeOf(rcvr)
+	for name, ser := range s.server.services.services {
-	rcvrVal := reflect.ValueOf(rcvr)
+		for s := range ser.callbacks {
-
+			_, ok := methods[name]
-	if name == "" {
+			if !ok {
-		return fmt.Errorf("no service name for type %s", svc.typ.String())
+				methods[name] = []string{s}
-	}
-	if !isExported(reflect.Indirect(rcvrVal).Type().Name()) {
-		return fmt.Errorf("%s is not exported", reflect.Indirect(rcvrVal).Type().Name())
-	}
-
-	methods, subscriptions := suitableCallbacks(rcvrVal, svc.typ)
-
-	if len(methods) == 0 && len(subscriptions) == 0 {
-		return fmt.Errorf("Service %T doesn't have any suitable methods/subscriptions to expose", rcvr)
-	}
-
-	// already a previous service register under given name, merge methods/subscriptions
-	if regsvc, present := s.services[name]; present {
-		for _, m := range methods {
-			regsvc.callbacks[formatName(m.method.Name)] = m
-		}
-		for _, s := range subscriptions {
-			regsvc.subscriptions[formatName(s.method.Name)] = s
-		}
-		return nil
-	}
-
-	svc.name = name
-	svc.callbacks, svc.subscriptions = methods, subscriptions
-
-	s.services[svc.name] = svc
-	return nil
-}
-
-// serveRequest will reads requests from the codec, calls the RPC callback and
-// writes the response to the given codec.
-//
-// If singleShot is true it will process a single request, otherwise it will handle
-// requests until the codec returns an error when reading a request (in most cases
-// an EOF). It executes requests in parallel when singleShot is false.
-func (s *Server) serveRequest(ctx context.Context, codec ServerCodec, singleShot bool, options CodecOption) error {
-	var pend sync.WaitGroup
-
-	defer func() {
-		if err := recover(); err != nil {
-			const size = 64 << 10
-			buf := make([]byte, size)
-			buf = buf[:runtime.Stack(buf, false)]
-			log.Error(string(buf))
-		}
-		s.codecsMu.Lock()
-		s.codecs.Remove(codec)
-		s.codecsMu.Unlock()
-	}()
-
-	//	ctx, cancel := context.WithCancel(context.Background())
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	// if the codec supports notification include a notifier that callbacks can use
-	// to send notification to clients. It is tied to the codec/connection. If the
-	// connection is closed the notifier will stop and cancels all active subscriptions.
-	if options&OptionSubscriptions == OptionSubscriptions {
-		ctx = context.WithValue(ctx, notifierKey{}, newNotifier(codec))
-	}
-	s.codecsMu.Lock()
-	if atomic.LoadInt32(&s.run) != 1 { // server stopped
-		s.codecsMu.Unlock()
-		return &shutdownError{}
-	}
-	s.codecs.Add(codec)
-	s.codecsMu.Unlock()
-
-	// test if the server is ordered to stop
-	for atomic.LoadInt32(&s.run) == 1 {
-		reqs, batch, err := s.readRequest(codec)
-		if err != nil {
-			// If a parsing error occurred, send an error
-			if err.Error() != "EOF" {
-				log.Debug(fmt.Sprintf("read error %v\n", err))
-				codec.Write(codec.CreateErrorResponse(nil, err))
-			}
-			// Error or end of stream, wait for requests and tear down
-			pend.Wait()
-			return nil
-		}
-
-		// check if server is ordered to shutdown and return an error
-		// telling the client that his request failed.
-		if atomic.LoadInt32(&s.run) != 1 {
-			err = &shutdownError{}
-			if batch {
-				resps := make([]interface{}, len(reqs))
-				for i, r := range reqs {
-					resps[i] = codec.CreateErrorResponse(&r.id, err)
-				}
-				codec.Write(resps)
 			} else {
-				codec.Write(codec.CreateErrorResponse(&reqs[0].id, err))
+				methods[name] = append(methods[name], s)
-			}
-			return nil
-		}
-		// If a single shot request is executing, run and return immediately
-		if singleShot {
-			if batch {
-				s.execBatch(ctx, codec, reqs)
-			} else {
-				s.exec(ctx, codec, reqs[0])
-			}
-			return nil
-		}
-		// For multi-shot connections, start a goroutine to serve and loop back
-		pend.Add(1)
-
-		go func(reqs []*serverRequest, batch bool) {
-			defer pend.Done()
-			if batch {
-				s.execBatch(ctx, codec, reqs)
-			} else {
-				s.exec(ctx, codec, reqs[0])
-			}
-		}(reqs, batch)
-	}
-	return nil
-}
-
-// ServeCodec reads incoming requests from codec, calls the appropriate callback and writes the
-// response back using the given codec. It will block until the codec is closed or the server is
-// stopped. In either case the codec is closed.
-func (s *Server) ServeCodec(codec ServerCodec, options CodecOption) {
-	defer codec.Close()
-	s.serveRequest(context.Background(), codec, false, options)
-}
-
-// ServeSingleRequest reads and processes a single RPC request from the given codec. It will not
-// close the codec unless a non-recoverable error has occurred. Note, this method will return after
-// a single request has been processed!
-func (s *Server) ServeSingleRequest(ctx context.Context, codec ServerCodec, options CodecOption) {
-	s.serveRequest(ctx, codec, true, options)
-}
-
-// Stop will stop reading new requests, wait for stopPendingRequestTimeout to allow pending requests to finish,
-// close all codecs which will cancel pending requests/subscriptions.
-func (s *Server) Stop() {
-	if atomic.CompareAndSwapInt32(&s.run, 1, 0) {
-		log.Debug("RPC Server shutdown initiatied")
-		s.codecsMu.Lock()
-		defer s.codecsMu.Unlock()
-		s.codecs.Each(func(c interface{}) bool {
-			c.(ServerCodec).Close()
-			return true
-		})
-	}
-}
-
-// createSubscription will call the subscription callback and returns the subscription id or error.
-func (s *Server) createSubscription(ctx context.Context, c ServerCodec, req *serverRequest) (ID, error) {
-	// subscription have as first argument the context following optional arguments
-	args := []reflect.Value{req.callb.rcvr, reflect.ValueOf(ctx)}
-	args = append(args, req.args...)
-	reply := req.callb.method.Func.Call(args)
-
-	if !reply[1].IsNil() { // subscription creation failed
-		return "", reply[1].Interface().(error)
-	}
-
-	return reply[0].Interface().(*Subscription).ID, nil
-}
-
-// handle executes a request and returns the response from the callback.
-func (s *Server) handle(ctx context.Context, codec ServerCodec, req *serverRequest) (interface{}, func()) {
-	if req.err != nil {
-		return codec.CreateErrorResponse(&req.id, req.err), nil
-	}
-
-	if req.isUnsubscribe { // cancel subscription, first param must be the subscription id
-		if len(req.args) >= 1 && req.args[0].Kind() == reflect.String {
-			notifier, supported := NotifierFromContext(ctx)
-			if !supported { // interface doesn't support subscriptions (e.g. http)
-				return codec.CreateErrorResponse(&req.id, &callbackError{ErrNotificationsUnsupported.Error()}), nil
-			}
-
-			subid := ID(req.args[0].String())
-			if err := notifier.unsubscribe(subid); err != nil {
-				return codec.CreateErrorResponse(&req.id, &callbackError{err.Error()}), nil
-			}
-
-			return codec.CreateResponse(req.id, true), nil
-		}
-		return codec.CreateErrorResponse(&req.id, &invalidParamsError{"Expected subscription id as first argument"}), nil
-	}
-
-	if req.callb.isSubscribe {
-		subid, err := s.createSubscription(ctx, codec, req)
-		if err != nil {
-			return codec.CreateErrorResponse(&req.id, &callbackError{err.Error()}), nil
-		}
-
-		// active the subscription after the sub id was successfully sent to the client
-		activateSub := func() {
-			notifier, _ := NotifierFromContext(ctx)
-			notifier.activate(subid, req.svcname)
-		}
-
-		return codec.CreateResponse(req.id, subid), activateSub
-	}
-
-	// regular RPC call, prepare arguments
-	if len(req.args) != len(req.callb.argTypes) {
-		rpcErr := &invalidParamsError{fmt.Sprintf("%s%s%s expects %d parameters, got %d",
-			req.svcname, serviceMethodSeparator, req.callb.method.Name,
-			len(req.callb.argTypes), len(req.args))}
-		return codec.CreateErrorResponse(&req.id, rpcErr), nil
-	}
-
-	arguments := []reflect.Value{req.callb.rcvr}
-	if req.callb.hasCtx {
-		arguments = append(arguments, reflect.ValueOf(ctx))
-	}
-	if len(req.args) > 0 {
-		arguments = append(arguments, req.args...)
-	}
-
-	// execute RPC method and return result
-	reply := req.callb.method.Func.Call(arguments)
-	if len(reply) == 0 {
-		return codec.CreateResponse(req.id, nil), nil
-	}
-	if req.callb.errPos >= 0 { // test if method returned an error
-		if !reply[req.callb.errPos].IsNil() {
-			e := reply[req.callb.errPos].Interface().(error)
-			res := codec.CreateErrorResponse(&req.id, &callbackError{e.Error()})
-			return res, nil
-		}
-	}
-	return codec.CreateResponse(req.id, reply[0].Interface()), nil
-}
-
-// exec executes the given request and writes the result back using the codec.
-func (s *Server) exec(ctx context.Context, codec ServerCodec, req *serverRequest) {
-	var response interface{}
-	var callback func()
-	if req.err != nil {
-		response = codec.CreateErrorResponse(&req.id, req.err)
-	} else {
-		response, callback = s.handle(ctx, codec, req)
-	}
-
-	if err := codec.Write(response); err != nil {
-		log.Error(fmt.Sprintf("%v\n", err))
-		codec.Close()
-	}
-
-	// when request was a subscribe request this allows these subscriptions to be actived
-	if callback != nil {
-		callback()
-	}
-}
-
-// execBatch executes the given requests and writes the result back using the codec.
-// It will only write the response back when the last request is processed.
-func (s *Server) execBatch(ctx context.Context, codec ServerCodec, requests []*serverRequest) {
-	responses := make([]interface{}, len(requests))
-	var callbacks []func()
-	for i, req := range requests {
-		if req.err != nil {
-			responses[i] = codec.CreateErrorResponse(&req.id, req.err)
-		} else {
-			var callback func()
-			if responses[i], callback = s.handle(ctx, codec, req); callback != nil {
-				callbacks = append(callbacks, callback)
 			}
 		}
 	}
-
+	return methods
-	if err := codec.Write(responses); err != nil {
-		log.Error(fmt.Sprintf("%v\n", err))
-		codec.Close()
-	}
-
-	// when request holds one of more subscribe requests this allows these subscriptions to be activated
-	for _, c := range callbacks {
-		c()
-	}
 }
 
-// readRequest requests the next (batch) request from the codec. It will return the collection
+// Discover returns a configured schema that is audited for actual server availability.
-// of requests, an indication if the request was a batch, the invalid request identifier and an
+// Only methods that the server makes available are included in the 'methods' array of
-// error when the request could not be read/parsed.
+// the discover schema. Components are not audited.
-func (s *Server) readRequest(codec ServerCodec) ([]*serverRequest, bool, Error) {
+func (s *RPCService) Discover() (schema *OpenRPCDiscoverSchemaT, err error) {
-	reqs, batch, err := codec.ReadRequestHeaders()
+	if s.server.OpenRPCSchemaRaw == "" {
+		return nil, errOpenRPCDiscoverUnavailable
+	}
+	schema = &OpenRPCDiscoverSchemaT{
+		Servers: make([]map[string]interface{}, 0),
+	}
+	err = json.Unmarshal([]byte(s.server.OpenRPCSchemaRaw), schema)
 	if err != nil {
-		return nil, batch, err
+		log.Crit("openrpc json umarshal", "error", err)
 	}
 
-	requests := make([]*serverRequest, len(reqs))
+	// Audit documented schema methods vs. actual server availability
+	// This removes methods described in the OpenRPC JSON schema document
+	// which are not currently exposed on the server's API.
+	// This is done on the fly (as opposed to at servre init or schema setting)
+	// because it's possible that exposed APIs could be modified in proc.
+	schemaMethodsAvailable := []map[string]interface{}{}
+	serverMethodsAvailable := s.methods()
 
-	// verify requests
+	for _, m := range schema.Methods {
-	for i, r := range reqs {
+		module, path, err := elementizeMethodName(m["name"].(string))
-		var ok bool
+		if err != nil {
-		var svc *service
+			return nil, err
-
+		}
-		if r.err != nil {
+		paths, ok := serverMethodsAvailable[module]
-			requests[i] = &serverRequest{id: r.id, err: r.err}
+		if !ok {
 			continue
 		}
 
-		if r.isPubSub && strings.HasSuffix(r.method, unsubscribeMethodSuffix) {
+		// the module exists, does the path exist?
-			requests[i] = &serverRequest{id: r.id, isUnsubscribe: true}
+		for _, pa := range paths {
-			argTypes := []reflect.Type{reflect.TypeOf("")} // expect subscription id as first arg
+			if pa == path {
-			if args, err := codec.ParseRequestArguments(argTypes, r.params); err == nil {
+				schemaMethodsAvailable = append(schemaMethodsAvailable, m)
-				requests[i].args = args
+				break
-			} else {
-				requests[i].err = &invalidParamsError{err.Error()}
 			}
-			continue
 		}
-
-		if svc, ok = s.services[r.service]; !ok { // rpc method isn't available
-			requests[i] = &serverRequest{id: r.id, err: &methodNotFoundError{r.service, r.method}}
-			continue
-		}
-
-		if r.isPubSub { // eth_subscribe, r.method contains the subscription method name
-			if callb, ok := svc.subscriptions[r.method]; ok {
-				requests[i] = &serverRequest{id: r.id, svcname: svc.name, callb: callb}
-				if r.params != nil && len(callb.argTypes) > 0 {
-					argTypes := []reflect.Type{reflect.TypeOf("")}
-					argTypes = append(argTypes, callb.argTypes...)
-					if args, err := codec.ParseRequestArguments(argTypes, r.params); err == nil {
-						requests[i].args = args[1:] // first one is service.method name which isn't an actual argument
-					} else {
-						requests[i].err = &invalidParamsError{err.Error()}
-					}
-				}
-			} else {
-				requests[i] = &serverRequest{id: r.id, err: &methodNotFoundError{r.service, r.method}}
-			}
-			continue
-		}
-
-		if callb, ok := svc.callbacks[r.method]; ok { // lookup RPC method
-			requests[i] = &serverRequest{id: r.id, svcname: svc.name, callb: callb}
-			if r.params != nil && len(callb.argTypes) > 0 {
-				if args, err := codec.ParseRequestArguments(callb.argTypes, r.params); err == nil {
-					requests[i].args = args
-				} else {
-					requests[i].err = &invalidParamsError{err.Error()}
-				}
-			}
-			continue
-		}
-
-		requests[i] = &serverRequest{id: r.id, err: &methodNotFoundError{r.service, r.method}}
 	}
-
+	schema.Methods = schemaMethodsAvailable
-	return requests, batch, nil
+	return
 }

rpc/server_test.go

@@ -17,146 +17,136 @@
 package rpc
 
 import (
-	"context"
+	"bufio"
-	"encoding/json"
+	"bytes"
+	"io"
+	"io/ioutil"
 	"net"
-	"reflect"
+	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 )
 
-type Service struct{}
-
-type Args struct {
-	S string
-}
-
-func (s *Service) NoArgsRets() {
-}
-
-type Result struct {
-	String string
-	Int    int
-	Args   *Args
-}
-
-func (s *Service) Echo(str string, i int, args *Args) Result {
-	return Result{str, i, args}
-}
-
-func (s *Service) EchoWithCtx(ctx context.Context, str string, i int, args *Args) Result {
-	return Result{str, i, args}
-}
-
-func (s *Service) Sleep(ctx context.Context, duration time.Duration) {
-	select {
-	case <-time.After(duration):
-	case <-ctx.Done():
-	}
-}
-
-func (s *Service) Rets() (string, error) {
-	return "", nil
-}
-
-func (s *Service) InvalidRets1() (error, string) {
-	return nil, ""
-}
-
-func (s *Service) InvalidRets2() (string, string) {
-	return "", ""
-}
-
-func (s *Service) InvalidRets3() (string, string, error) {
-	return "", "", nil
-}
-
-func (s *Service) Subscription(ctx context.Context) (*Subscription, error) {
-	return nil, nil
-}
-
 func TestServerRegisterName(t *testing.T) {
 	server := NewServer()
-	service := new(Service)
+	service := new(testService)
-
-	if err := server.RegisterName("calc", service); err != nil {
-		t.Fatalf("%v", err)
-	}
-
-	if len(server.services) != 2 {
-		t.Fatalf("Expected 2 service entries, got %d", len(server.services))
-	}
-
-	svc, ok := server.services["calc"]
-	if !ok {
-		t.Fatalf("Expected service calc to be registered")
-	}
-
-	if len(svc.callbacks) != 5 {
-		t.Errorf("Expected 5 callbacks for service 'calc', got %d", len(svc.callbacks))
-	}
-
-	if len(svc.subscriptions) != 1 {
-		t.Errorf("Expected 1 subscription for service 'calc', got %d", len(svc.subscriptions))
-	}
-}
-
-func testServerMethodExecution(t *testing.T, method string) {
-	server := NewServer()
-	service := new(Service)
 
 	if err := server.RegisterName("test", service); err != nil {
 		t.Fatalf("%v", err)
 	}
 
-	stringArg := "string arg"
+	if len(server.services.services) != 2 {
-	intArg := 1122
+		t.Fatalf("Expected 2 service entries, got %d", len(server.services.services))
-	argsArg := &Args{"abcde"}
+	}
-	params := []interface{}{stringArg, intArg, argsArg}
 
-	request := map[string]interface{}{
+	svc, ok := server.services.services["test"]
-		"id":      12345,
+	if !ok {
-		"method":  "test_" + method,
+		t.Fatalf("Expected service calc to be registered")
-		"version": "2.0",
+	}
-		"params":  params,
+
+	wantCallbacks := 7
+	if len(svc.callbacks) != wantCallbacks {
+		t.Errorf("Expected %d callbacks for service 'service', got %d", wantCallbacks, len(svc.callbacks))
+	}
+}
+
+func TestServer(t *testing.T) {
+	files, err := ioutil.ReadDir("testdata")
+	if err != nil {
+		t.Fatal("where'd my testdata go?")
+	}
+	for _, f := range files {
+		if f.IsDir() || strings.HasPrefix(f.Name(), ".") {
+			continue
+		}
+		path := filepath.Join("testdata", f.Name())
+		name := strings.TrimSuffix(f.Name(), filepath.Ext(f.Name()))
+		t.Run(name, func(t *testing.T) {
+			runTestScript(t, path)
+		})
+	}
+}
+
+func runTestScript(t *testing.T, file string) {
+	server := newTestServer()
+	content, err := ioutil.ReadFile(file)
+	if err != nil {
+		t.Fatal(err)
 	}
 
 	clientConn, serverConn := net.Pipe()
 	defer clientConn.Close()
-
+	go server.ServeCodec(NewJSONCodec(serverConn), OptionMethodInvocation|OptionSubscriptions)
-	go server.ServeCodec(NewJSONCodec(serverConn), OptionMethodInvocation)
+	readbuf := bufio.NewReader(clientConn)
-
+	for _, line := range strings.Split(string(content), "\n") {
-	out := json.NewEncoder(clientConn)
+		line = strings.TrimSpace(line)
-	in := json.NewDecoder(clientConn)
+		switch {
-
+		case len(line) == 0 || strings.HasPrefix(line, "//"):
-	if err := out.Encode(request); err != nil {
+			// skip comments, blank lines
-		t.Fatal(err)
+			continue
-	}
+		case strings.HasPrefix(line, "--> "):
-
+			t.Log(line)
-	response := jsonSuccessResponse{Result: &Result{}}
+			// write to connection
-	if err := in.Decode(&response); err != nil {
+			clientConn.SetWriteDeadline(time.Now().Add(5 * time.Second))
-		t.Fatal(err)
+			if _, err := io.WriteString(clientConn, line[4:]+"\n"); err != nil {
-	}
+				t.Fatalf("write error: %v", err)
-
+			}
-	if result, ok := response.Result.(*Result); ok {
+		case strings.HasPrefix(line, "<-- "):
-		if result.String != stringArg {
+			t.Log(line)
-			t.Errorf("expected %s, got : %s\n", stringArg, result.String)
+			want := line[4:]
+			// read line from connection and compare text
+			clientConn.SetReadDeadline(time.Now().Add(5 * time.Second))
+			sent, err := readbuf.ReadString('\n')
+			if err != nil {
+				t.Fatalf("read error: %v", err)
+			}
+			sent = strings.TrimRight(sent, "\r\n")
+			if sent != want {
+				t.Errorf("wrong line from server\ngot:  %s\nwant: %s", sent, want)
+			}
+		default:
+			panic("invalid line in test script: " + line)
 		}
-		if result.Int != intArg {
-			t.Errorf("expected %d, got %d\n", intArg, result.Int)
-		}
-		if !reflect.DeepEqual(result.Args, argsArg) {
-			t.Errorf("expected %v, got %v\n", argsArg, result)
-		}
-	} else {
-		t.Fatalf("invalid response: expected *Result - got: %T", response.Result)
 	}
 }
 
-func TestServerMethodExecution(t *testing.T) {
+// This test checks that responses are delivered for very short-lived connections that
-	testServerMethodExecution(t, "echo")
+// only carry a single request.
-}
+func TestServerShortLivedConn(t *testing.T) {
+	server := newTestServer()
+	defer server.Stop()
 
-func TestServerMethodWithCtx(t *testing.T) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	testServerMethodExecution(t, "echoWithCtx")
+	if err != nil {
+		t.Fatal("can't listen:", err)
+	}
+	defer listener.Close()
+	go server.ServeListener(listener)
+
+	var (
+		request  = `{"jsonrpc":"2.0","id":1,"method":"rpc_modules"}` + "\n"
+		wantResp = `{"jsonrpc":"2.0","id":1,"result":{"nftest":"1.0","rpc":"1.0","test":"1.0"}}` + "\n"
+		deadline = time.Now().Add(10 * time.Second)
+	)
+	for i := 0; i < 20; i++ {
+		conn, err := net.Dial("tcp", listener.Addr().String())
+		if err != nil {
+			t.Fatal("can't dial:", err)
+		}
+		defer conn.Close()
+		conn.SetDeadline(deadline)
+		// Write the request, then half-close the connection so the server stops reading.
+		conn.Write([]byte(request))
+		conn.(*net.TCPConn).CloseWrite()
+		// Now try to get the response.
+		buf := make([]byte, 2000)
+		n, err := conn.Read(buf)
+		if err != nil {
+			t.Fatal("read error:", err)
+		}
+		if !bytes.Equal(buf[:n], []byte(wantResp)) {
+			t.Fatalf("wrong response: %s", buf[:n])
+		}
+	}
 }

rpc/service.go

@@ -0,0 +1,284 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rpc
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"sync"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/ubiq/go-ubiq/log"
+)
+
+var (
+	contextType      = reflect.TypeOf((*context.Context)(nil)).Elem()
+	errorType        = reflect.TypeOf((*error)(nil)).Elem()
+	subscriptionType = reflect.TypeOf(Subscription{})
+	stringType       = reflect.TypeOf("")
+)
+
+type serviceRegistry struct {
+	mu       sync.Mutex
+	services map[string]service
+}
+
+// service represents a registered object.
+type service struct {
+	name          string               // name for service
+	callbacks     map[string]*callback // registered handlers
+	subscriptions map[string]*callback // available subscriptions/notifications
+}
+
+// callback is a method callback which was registered in the server
+type callback struct {
+	fn          reflect.Value  // the function
+	rcvr        reflect.Value  // receiver object of method, set if fn is method
+	argTypes    []reflect.Type // input argument types
+	hasCtx      bool           // method's first argument is a context (not included in argTypes)
+	errPos      int            // err return idx, of -1 when method cannot return error
+	isSubscribe bool           // true if this is a subscription callback
+}
+
+func (r *serviceRegistry) registerName(name string, rcvr interface{}) error {
+	rcvrVal := reflect.ValueOf(rcvr)
+	if name == "" {
+		return fmt.Errorf("no service name for type %s", rcvrVal.Type().String())
+	}
+	callbacks := suitableCallbacks(rcvrVal)
+	if len(callbacks) == 0 {
+		return fmt.Errorf("service %T doesn't have any suitable methods/subscriptions to expose", rcvr)
+	}
+
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.services == nil {
+		r.services = make(map[string]service)
+	}
+	svc, ok := r.services[name]
+	if !ok {
+		svc = service{
+			name:          name,
+			callbacks:     make(map[string]*callback),
+			subscriptions: make(map[string]*callback),
+		}
+		r.services[name] = svc
+	}
+	for name, cb := range callbacks {
+		if cb.isSubscribe {
+			svc.subscriptions[name] = cb
+		} else {
+			svc.callbacks[name] = cb
+		}
+	}
+	return nil
+}
+
+// callback returns the callback corresponding to the given RPC method name.
+func (r *serviceRegistry) callback(method string) *callback {
+	module, mthd, err := elementizeMethodName(method)
+	if err != nil {
+		return nil
+	}
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.services[module].callbacks[mthd]
+}
+
+// subscription returns a subscription callback in the given service.
+func (r *serviceRegistry) subscription(service, name string) *callback {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.services[service].subscriptions[name]
+}
+
+// suitableCallbacks iterates over the methods of the given type. It determines if a method
+// satisfies the criteria for a RPC callback or a subscription callback and adds it to the
+// collection of callbacks. See server documentation for a summary of these criteria.
+func suitableCallbacks(receiver reflect.Value) map[string]*callback {
+	typ := receiver.Type()
+	callbacks := make(map[string]*callback)
+	for m := 0; m < typ.NumMethod(); m++ {
+		method := typ.Method(m)
+		if method.PkgPath != "" {
+			continue // method not exported
+		}
+		cb := newCallback(receiver, method.Func)
+		if cb == nil {
+			continue // function invalid
+		}
+		name := formatName(method.Name)
+		callbacks[name] = cb
+	}
+	return callbacks
+}
+
+// newCallback turns fn (a function) into a callback object. It returns nil if the function
+// is unsuitable as an RPC callback.
+func newCallback(receiver, fn reflect.Value) *callback {
+	fntype := fn.Type()
+	c := &callback{fn: fn, rcvr: receiver, errPos: -1, isSubscribe: isPubSub(fntype)}
+	// Determine parameter types. They must all be exported or builtin types.
+	c.makeArgTypes()
+	if !allExportedOrBuiltin(c.argTypes) {
+		return nil
+	}
+	// Verify return types. The function must return at most one error
+	// and/or one other non-error value.
+	outs := make([]reflect.Type, fntype.NumOut())
+	for i := 0; i < fntype.NumOut(); i++ {
+		outs[i] = fntype.Out(i)
+	}
+	if len(outs) > 2 || !allExportedOrBuiltin(outs) {
+		return nil
+	}
+	// If an error is returned, it must be the last returned value.
+	switch {
+	case len(outs) == 1 && isErrorType(outs[0]):
+		c.errPos = 0
+	case len(outs) == 2:
+		if isErrorType(outs[0]) || !isErrorType(outs[1]) {
+			return nil
+		}
+		c.errPos = 1
+	}
+	return c
+}
+
+// makeArgTypes composes the argTypes list.
+func (c *callback) makeArgTypes() {
+	fntype := c.fn.Type()
+	// Skip receiver and context.Context parameter (if present).
+	firstArg := 0
+	if c.rcvr.IsValid() {
+		firstArg++
+	}
+	if fntype.NumIn() > firstArg && fntype.In(firstArg) == contextType {
+		c.hasCtx = true
+		firstArg++
+	}
+	// Add all remaining parameters.
+	c.argTypes = make([]reflect.Type, fntype.NumIn()-firstArg)
+	for i := firstArg; i < fntype.NumIn(); i++ {
+		c.argTypes[i-firstArg] = fntype.In(i)
+	}
+}
+
+// call invokes the callback.
+func (c *callback) call(ctx context.Context, method string, args []reflect.Value) (res interface{}, errRes error) {
+	// Create the argument slice.
+	fullargs := make([]reflect.Value, 0, 2+len(args))
+	if c.rcvr.IsValid() {
+		fullargs = append(fullargs, c.rcvr)
+	}
+	if c.hasCtx {
+		fullargs = append(fullargs, reflect.ValueOf(ctx))
+	}
+	fullargs = append(fullargs, args...)
+
+	// Catch panic while running the callback.
+	defer func() {
+		if err := recover(); err != nil {
+			const size = 64 << 10
+			buf := make([]byte, size)
+			buf = buf[:runtime.Stack(buf, false)]
+			log.Error("RPC method " + method + " crashed: " + fmt.Sprintf("%v\n%s", err, buf))
+			errRes = errors.New("method handler crashed")
+		}
+	}()
+	// Run the callback.
+	results := c.fn.Call(fullargs)
+	if len(results) == 0 {
+		return nil, nil
+	}
+	if c.errPos >= 0 && !results[c.errPos].IsNil() {
+		// Method has returned non-nil error value.
+		err := results[c.errPos].Interface().(error)
+		return reflect.Value{}, err
+	}
+	return results[0].Interface(), nil
+}
+
+// Is this an exported - upper case - name?
+func isExported(name string) bool {
+	rune, _ := utf8.DecodeRuneInString(name)
+	return unicode.IsUpper(rune)
+}
+
+// Are all those types exported or built-in?
+func allExportedOrBuiltin(types []reflect.Type) bool {
+	for _, typ := range types {
+		for typ.Kind() == reflect.Ptr {
+			typ = typ.Elem()
+		}
+		// PkgPath will be non-empty even for an exported type,
+		// so we need to check the type name as well.
+		if !isExported(typ.Name()) && typ.PkgPath() != "" {
+			return false
+		}
+	}
+	return true
+}
+
+// Is t context.Context or *context.Context?
+func isContextType(t reflect.Type) bool {
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t == contextType
+}
+
+// Does t satisfy the error interface?
+func isErrorType(t reflect.Type) bool {
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t.Implements(errorType)
+}
+
+// Is t Subscription or *Subscription?
+func isSubscriptionType(t reflect.Type) bool {
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	return t == subscriptionType
+}
+
+// isPubSub tests whether the given method has as as first argument a context.Context and
+// returns the pair (Subscription, error).
+func isPubSub(methodType reflect.Type) bool {
+	// numIn(0) is the receiver type
+	if methodType.NumIn() < 2 || methodType.NumOut() != 2 {
+		return false
+	}
+	return isContextType(methodType.In(1)) &&
+		isSubscriptionType(methodType.Out(0)) &&
+		isErrorType(methodType.Out(1))
+}
+
+// formatName converts to first character of name to lowercase.
+func formatName(name string) string {
+	ret := []rune(name)
+	if len(ret) > 0 {
+		ret[0] = unicode.ToLower(ret[0])
+	}
+	return string(ret)
+}

rpc/stdio.go

@@ -26,8 +26,8 @@ import (
 
 // DialStdIO creates a client on stdin/stdout.
 func DialStdIO(ctx context.Context) (*Client, error) {
-	return newClient(ctx, func(_ context.Context) (net.Conn, error) {
+	return newClient(ctx, func(_ context.Context) (ServerCodec, error) {
-		return stdioConn{}, nil
+		return NewJSONCodec(stdioConn{}), nil
 	})
 }
 
@@ -45,20 +45,8 @@ func (io stdioConn) Close() error {
 	return nil
 }
 
-func (io stdioConn) LocalAddr() net.Addr {
+func (io stdioConn) RemoteAddr() string {
-	return &net.UnixAddr{Name: "stdio", Net: "stdio"}
+	return "/dev/stdin"
-}
-
-func (io stdioConn) RemoteAddr() net.Addr {
-	return &net.UnixAddr{Name: "stdio", Net: "stdio"}
-}
-
-func (io stdioConn) SetDeadline(t time.Time) error {
-	return &net.OpError{Op: "set", Net: "stdio", Source: nil, Addr: nil, Err: errors.New("deadline not supported")}
-}
-
-func (io stdioConn) SetReadDeadline(t time.Time) error {
-	return &net.OpError{Op: "set", Net: "stdio", Source: nil, Addr: nil, Err: errors.New("deadline not supported")}
 }
 
 func (io stdioConn) SetWriteDeadline(t time.Time) error {

rpc/subscription.go

@@ -17,9 +17,19 @@
 package rpc
 
 import (
+	"bufio"
+	"container/list"
 	"context"
+	crand "crypto/rand"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
 	"errors"
+	"math/rand"
+	"reflect"
+	"strings"
 	"sync"
+	"time"
 )
 
 var (
@@ -29,10 +39,147 @@ var (
 	ErrSubscriptionNotFound = errors.New("subscription not found")
 )
 
+var globalGen = randomIDGenerator()
+
 // ID defines a pseudo random number that is used to identify RPC subscriptions.
 type ID string
 
-// a Subscription is created by a notifier and tight to that notifier. The client can use
+// NewID returns a new, random ID.
+func NewID() ID {
+	return globalGen()
+}
+
+// randomIDGenerator returns a function generates a random IDs.
+func randomIDGenerator() func() ID {
+	seed, err := binary.ReadVarint(bufio.NewReader(crand.Reader))
+	if err != nil {
+		seed = int64(time.Now().Nanosecond())
+	}
+	var (
+		mu  sync.Mutex
+		rng = rand.New(rand.NewSource(seed))
+	)
+	return func() ID {
+		mu.Lock()
+		defer mu.Unlock()
+		id := make([]byte, 16)
+		rng.Read(id)
+		return encodeID(id)
+	}
+}
+
+func encodeID(b []byte) ID {
+	id := hex.EncodeToString(b)
+	id = strings.TrimLeft(id, "0")
+	if id == "" {
+		id = "0" // ID's are RPC quantities, no leading zero's and 0 is 0x0.
+	}
+	return ID("0x" + id)
+}
+
+type notifierKey struct{}
+
+// NotifierFromContext returns the Notifier value stored in ctx, if any.
+func NotifierFromContext(ctx context.Context) (*Notifier, bool) {
+	n, ok := ctx.Value(notifierKey{}).(*Notifier)
+	return n, ok
+}
+
+// Notifier is tied to a RPC connection that supports subscriptions.
+// Server callbacks use the notifier to send notifications.
+type Notifier struct {
+	h         *handler
+	namespace string
+
+	mu           sync.Mutex
+	sub          *Subscription
+	buffer       []json.RawMessage
+	callReturned bool
+	activated    bool
+}
+
+// CreateSubscription returns a new subscription that is coupled to the
+// RPC connection. By default subscriptions are inactive and notifications
+// are dropped until the subscription is marked as active. This is done
+// by the RPC server after the subscription ID is send to the client.
+func (n *Notifier) CreateSubscription() *Subscription {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+
+	if n.sub != nil {
+		panic("can't create multiple subscriptions with Notifier")
+	} else if n.callReturned {
+		panic("can't create subscription after subscribe call has returned")
+	}
+	n.sub = &Subscription{ID: n.h.idgen(), namespace: n.namespace, err: make(chan error, 1)}
+	return n.sub
+}
+
+// Notify sends a notification to the client with the given data as payload.
+// If an error occurs the RPC connection is closed and the error is returned.
+func (n *Notifier) Notify(id ID, data interface{}) error {
+	enc, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	n.mu.Lock()
+	defer n.mu.Unlock()
+
+	if n.sub == nil {
+		panic("can't Notify before subscription is created")
+	} else if n.sub.ID != id {
+		panic("Notify with wrong ID")
+	}
+	if n.activated {
+		return n.send(n.sub, enc)
+	}
+	n.buffer = append(n.buffer, enc)
+	return nil
+}
+
+// Closed returns a channel that is closed when the RPC connection is closed.
+// Deprecated: use subscription error channel
+func (n *Notifier) Closed() <-chan interface{} {
+	return n.h.conn.Closed()
+}
+
+// takeSubscription returns the subscription (if one has been created). No subscription can
+// be created after this call.
+func (n *Notifier) takeSubscription() *Subscription {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+	n.callReturned = true
+	return n.sub
+}
+
+// acticate is called after the subscription ID was sent to client. Notifications are
+// buffered before activation. This prevents notifications being sent to the client before
+// the subscription ID is sent to the client.
+func (n *Notifier) activate() error {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+
+	for _, data := range n.buffer {
+		if err := n.send(n.sub, data); err != nil {
+			return err
+		}
+	}
+	n.activated = true
+	return nil
+}
+
+func (n *Notifier) send(sub *Subscription, data json.RawMessage) error {
+	params, _ := json.Marshal(&subscriptionResult{ID: string(sub.ID), Result: data})
+	ctx := context.Background()
+	return n.h.conn.Write(ctx, &jsonrpcMessage{
+		Version: vsn,
+		Method:  n.namespace + notificationMethodSuffix,
+		Params:  params,
+	})
+}
+
+// A Subscription is created by a notifier and tight to that notifier. The client can use
 // this subscription to wait for an unsubscribe request for the client, see Err().
 type Subscription struct {
 	ID        ID
@@ -45,105 +192,136 @@ func (s *Subscription) Err() <-chan error {
 	return s.err
 }
 
-// notifierKey is used to store a notifier within the connection context.
+// MarshalJSON marshals a subscription as its ID.
-type notifierKey struct{}
+func (s *Subscription) MarshalJSON() ([]byte, error) {
-
+	return json.Marshal(s.ID)
-// Notifier is tight to a RPC connection that supports subscriptions.
-// Server callbacks use the notifier to send notifications.
-type Notifier struct {
-	codec    ServerCodec
-	subMu    sync.Mutex
-	active   map[ID]*Subscription
-	inactive map[ID]*Subscription
-	buffer   map[ID][]interface{} // unsent notifications of inactive subscriptions
 }
 
-// newNotifier creates a new notifier that can be used to send subscription
+// ClientSubscription is a subscription established through the Client's Subscribe or
-// notifications to the client.
+// EthSubscribe methods.
-func newNotifier(codec ServerCodec) *Notifier {
+type ClientSubscription struct {
-	return &Notifier{
+	client    *Client
-		codec:    codec,
+	etype     reflect.Type
-		active:   make(map[ID]*Subscription),
+	channel   reflect.Value
-		inactive: make(map[ID]*Subscription),
+	namespace string
-		buffer:   make(map[ID][]interface{}),
+	subid     string
+	in        chan json.RawMessage
+
+	quitOnce sync.Once     // ensures quit is closed once
+	quit     chan struct{} // quit is closed when the subscription exits
+	errOnce  sync.Once     // ensures err is closed once
+	err      chan error
+}
+
+func newClientSubscription(c *Client, namespace string, channel reflect.Value) *ClientSubscription {
+	sub := &ClientSubscription{
+		client:    c,
+		namespace: namespace,
+		etype:     channel.Type().Elem(),
+		channel:   channel,
+		quit:      make(chan struct{}),
+		err:       make(chan error, 1),
+		in:        make(chan json.RawMessage),
 	}
+	return sub
 }
 
-// NotifierFromContext returns the Notifier value stored in ctx, if any.
+// Err returns the subscription error channel. The intended use of Err is to schedule
-func NotifierFromContext(ctx context.Context) (*Notifier, bool) {
+// resubscription when the client connection is closed unexpectedly.
-	n, ok := ctx.Value(notifierKey{}).(*Notifier)
+//
-	return n, ok
+// The error channel receives a value when the subscription has ended due
+// to an error. The received error is nil if Close has been called
+// on the underlying client and no other error has occurred.
+//
+// The error channel is closed when Unsubscribe is called on the subscription.
+func (sub *ClientSubscription) Err() <-chan error {
+	return sub.err
 }
 
-// CreateSubscription returns a new subscription that is coupled to the
+// Unsubscribe unsubscribes the notification and closes the error channel.
-// RPC connection. By default subscriptions are inactive and notifications
+// It can safely be called more than once.
-// are dropped until the subscription is marked as active. This is done
+func (sub *ClientSubscription) Unsubscribe() {
-// by the RPC server after the subscription ID is send to the client.
+	sub.quitWithError(nil, true)
-func (n *Notifier) CreateSubscription() *Subscription {
+	sub.errOnce.Do(func() { close(sub.err) })
-	s := &Subscription{ID: NewID(), err: make(chan error)}
-	n.subMu.Lock()
-	n.inactive[s.ID] = s
-	n.subMu.Unlock()
-	return s
 }
 
-// Notify sends a notification to the client with the given data as payload.
+func (sub *ClientSubscription) quitWithError(err error, unsubscribeServer bool) {
-// If an error occurs the RPC connection is closed and the error is returned.
+	sub.quitOnce.Do(func() {
-func (n *Notifier) Notify(id ID, data interface{}) error {
+		// The dispatch loop won't be able to execute the unsubscribe call
-	n.subMu.Lock()
+		// if it is blocked on deliver. Close sub.quit first because it
-	defer n.subMu.Unlock()
+		// unblocks deliver.
-
+		close(sub.quit)
-	if sub, active := n.active[id]; active {
+		if unsubscribeServer {
-		n.send(sub, data)
+			sub.requestUnsubscribe()
-	} else {
-		n.buffer[id] = append(n.buffer[id], data)
-	}
-	return nil
-}
-
-func (n *Notifier) send(sub *Subscription, data interface{}) error {
-	notification := n.codec.CreateNotification(string(sub.ID), sub.namespace, data)
-	err := n.codec.Write(notification)
-	if err != nil {
-		n.codec.Close()
-	}
-	return err
-}
-
-// Closed returns a channel that is closed when the RPC connection is closed.
-func (n *Notifier) Closed() <-chan interface{} {
-	return n.codec.Closed()
-}
-
-// unsubscribe a subscription.
-// If the subscription could not be found ErrSubscriptionNotFound is returned.
-func (n *Notifier) unsubscribe(id ID) error {
-	n.subMu.Lock()
-	defer n.subMu.Unlock()
-	if s, found := n.active[id]; found {
-		close(s.err)
-		delete(n.active, id)
-		return nil
-	}
-	return ErrSubscriptionNotFound
-}
-
-// activate enables a subscription. Until a subscription is enabled all
-// notifications are dropped. This method is called by the RPC server after
-// the subscription ID was sent to client. This prevents notifications being
-// send to the client before the subscription ID is send to the client.
-func (n *Notifier) activate(id ID, namespace string) {
-	n.subMu.Lock()
-	defer n.subMu.Unlock()
-
-	if sub, found := n.inactive[id]; found {
-		sub.namespace = namespace
-		n.active[id] = sub
-		delete(n.inactive, id)
-		// Send buffered notifications.
-		for _, data := range n.buffer[id] {
-			n.send(sub, data)
 		}
-		delete(n.buffer, id)
+		if err != nil {
+			if err == ErrClientQuit {
+				err = nil // Adhere to subscription semantics.
+			}
+			sub.err <- err
+		}
+	})
+}
+
+func (sub *ClientSubscription) deliver(result json.RawMessage) (ok bool) {
+	select {
+	case sub.in <- result:
+		return true
+	case <-sub.quit:
+		return false
 	}
 }
+
+func (sub *ClientSubscription) start() {
+	sub.quitWithError(sub.forward())
+}
+
+func (sub *ClientSubscription) forward() (err error, unsubscribeServer bool) {
+	cases := []reflect.SelectCase{
+		{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sub.quit)},
+		{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sub.in)},
+		{Dir: reflect.SelectSend, Chan: sub.channel},
+	}
+	buffer := list.New()
+	defer buffer.Init()
+	for {
+		var chosen int
+		var recv reflect.Value
+		if buffer.Len() == 0 {
+			// Idle, omit send case.
+			chosen, recv, _ = reflect.Select(cases[:2])
+		} else {
+			// Non-empty buffer, send the first queued item.
+			cases[2].Send = reflect.ValueOf(buffer.Front().Value)
+			chosen, recv, _ = reflect.Select(cases)
+		}
+
+		switch chosen {
+		case 0: // <-sub.quit
+			return nil, false
+		case 1: // <-sub.in
+			val, err := sub.unmarshal(recv.Interface().(json.RawMessage))
+			if err != nil {
+				return err, true
+			}
+			if buffer.Len() == maxClientSubscriptionBuffer {
+				return ErrSubscriptionQueueOverflow, true
+			}
+			buffer.PushBack(val)
+		case 2: // sub.channel<-
+			cases[2].Send = reflect.Value{} // Don't hold onto the value.
+			buffer.Remove(buffer.Front())
+		}
+	}
+}
+
+func (sub *ClientSubscription) unmarshal(result json.RawMessage) (interface{}, error) {
+	val := reflect.New(sub.etype)
+	err := json.Unmarshal(result, val.Interface())
+	return val.Elem().Interface(), err
+}
+
+func (sub *ClientSubscription) requestUnsubscribe() error {
+	var result interface{}
+	return sub.client.Call(&result, sub.namespace+unsubscribeMethodSuffix, sub.subid)
+}

rpc/subscription_test.go

@@ -17,232 +17,62 @@
 package rpc
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"net"
-	"sync"
+	"strings"
 	"testing"
 	"time"
 )
 
-type NotificationTestService struct {
+func TestNewID(t *testing.T) {
-	mu                      sync.Mutex
+	hexchars := "0123456789ABCDEFabcdef"
-	unsubscribed            chan string
+	for i := 0; i < 100; i++ {
-	gotHangSubscriptionReq  chan struct{}
+		id := string(NewID())
-	unblockHangSubscription chan struct{}
+		if !strings.HasPrefix(id, "0x") {
-}
+			t.Fatalf("invalid ID prefix, want '0x...', got %s", id)
+		}
 
-func (s *NotificationTestService) Echo(i int) int {
+		id = id[2:]
-	return i
+		if len(id) == 0 || len(id) > 32 {
-}
+			t.Fatalf("invalid ID length, want len(id) > 0 && len(id) <= 32), got %d", len(id))
+		}
 
-func (s *NotificationTestService) Unsubscribe(subid string) {
+		for i := 0; i < len(id); i++ {
-	if s.unsubscribed != nil {
+			if strings.IndexByte(hexchars, id[i]) == -1 {
-		s.unsubscribed <- subid
+				t.Fatalf("unexpected byte, want any valid hex char, got %c", id[i])
-	}
-}
-
-func (s *NotificationTestService) SomeSubscription(ctx context.Context, n, val int) (*Subscription, error) {
-	notifier, supported := NotifierFromContext(ctx)
-	if !supported {
-		return nil, ErrNotificationsUnsupported
-	}
-
-	// by explicitly creating an subscription we make sure that the subscription id is send back to the client
-	// before the first subscription.Notify is called. Otherwise the events might be send before the response
-	// for the eth_subscribe method.
-	subscription := notifier.CreateSubscription()
-
-	go func() {
-		// test expects n events, if we begin sending event immediately some events
-		// will probably be dropped since the subscription ID might not be send to
-		// the client.
-		for i := 0; i < n; i++ {
-			if err := notifier.Notify(subscription.ID, val+i); err != nil {
-				return
 			}
 		}
-
-		select {
-		case <-notifier.Closed():
-		case <-subscription.Err():
-		}
-		if s.unsubscribed != nil {
-			s.unsubscribed <- string(subscription.ID)
-		}
-	}()
-
-	return subscription, nil
-}
-
-// HangSubscription blocks on s.unblockHangSubscription before
-// sending anything.
-func (s *NotificationTestService) HangSubscription(ctx context.Context, val int) (*Subscription, error) {
-	notifier, supported := NotifierFromContext(ctx)
-	if !supported {
-		return nil, ErrNotificationsUnsupported
-	}
-
-	s.gotHangSubscriptionReq <- struct{}{}
-	<-s.unblockHangSubscription
-	subscription := notifier.CreateSubscription()
-
-	go func() {
-		notifier.Notify(subscription.ID, val)
-	}()
-	return subscription, nil
-}
-
-func TestNotifications(t *testing.T) {
-	server := NewServer()
-	service := &NotificationTestService{unsubscribed: make(chan string)}
-
-	if err := server.RegisterName("eth", service); err != nil {
-		t.Fatalf("unable to register test service %v", err)
-	}
-
-	clientConn, serverConn := net.Pipe()
-
-	go server.ServeCodec(NewJSONCodec(serverConn), OptionMethodInvocation|OptionSubscriptions)
-
-	out := json.NewEncoder(clientConn)
-	in := json.NewDecoder(clientConn)
-
-	n := 5
-	val := 12345
-	request := map[string]interface{}{
-		"id":      1,
-		"method":  "eth_subscribe",
-		"version": "2.0",
-		"params":  []interface{}{"someSubscription", n, val},
-	}
-
-	// create subscription
-	if err := out.Encode(request); err != nil {
-		t.Fatal(err)
-	}
-
-	var subid string
-	response := jsonSuccessResponse{Result: subid}
-	if err := in.Decode(&response); err != nil {
-		t.Fatal(err)
-	}
-
-	var ok bool
-	if _, ok = response.Result.(string); !ok {
-		t.Fatalf("expected subscription id, got %T", response.Result)
-	}
-
-	for i := 0; i < n; i++ {
-		var notification jsonNotification
-		if err := in.Decode(&notification); err != nil {
-			t.Fatalf("%v", err)
-		}
-
-		if int(notification.Params.Result.(float64)) != val+i {
-			t.Fatalf("expected %d, got %d", val+i, notification.Params.Result)
-		}
-	}
-
-	clientConn.Close() // causes notification unsubscribe callback to be called
-	select {
-	case <-service.unsubscribed:
-	case <-time.After(1 * time.Second):
-		t.Fatal("Unsubscribe not called after one second")
 	}
 }
 
-func waitForMessages(t *testing.T, in *json.Decoder, successes chan<- jsonSuccessResponse,
+func TestSubscriptions(t *testing.T) {
-	failures chan<- jsonErrResponse, notifications chan<- jsonNotification, errors chan<- error) {
-
-	// read and parse server messages
-	for {
-		var rmsg json.RawMessage
-		if err := in.Decode(&rmsg); err != nil {
-			return
-		}
-
-		var responses []map[string]interface{}
-		if rmsg[0] == '[' {
-			if err := json.Unmarshal(rmsg, &responses); err != nil {
-				errors <- fmt.Errorf("Received invalid message: %s", rmsg)
-				return
-			}
-		} else {
-			var msg map[string]interface{}
-			if err := json.Unmarshal(rmsg, &msg); err != nil {
-				errors <- fmt.Errorf("Received invalid message: %s", rmsg)
-				return
-			}
-			responses = append(responses, msg)
-		}
-
-		for _, msg := range responses {
-			// determine what kind of msg was received and broadcast
-			// it to over the corresponding channel
-			if _, found := msg["result"]; found {
-				successes <- jsonSuccessResponse{
-					Version: msg["jsonrpc"].(string),
-					Id:      msg["id"],
-					Result:  msg["result"],
-				}
-				continue
-			}
-			if _, found := msg["error"]; found {
-				params := msg["params"].(map[string]interface{})
-				failures <- jsonErrResponse{
-					Version: msg["jsonrpc"].(string),
-					Id:      msg["id"],
-					Error:   jsonError{int(params["subscription"].(float64)), params["message"].(string), params["data"]},
-				}
-				continue
-			}
-			if _, found := msg["params"]; found {
-				params := msg["params"].(map[string]interface{})
-				notifications <- jsonNotification{
-					Version: msg["jsonrpc"].(string),
-					Method:  msg["method"].(string),
-					Params:  jsonSubscription{params["subscription"].(string), params["result"]},
-				}
-				continue
-			}
-			errors <- fmt.Errorf("Received invalid message: %s", msg)
-		}
-	}
-}
-
-// TestSubscriptionMultipleNamespaces ensures that subscriptions can exists
-// for multiple different namespaces.
-func TestSubscriptionMultipleNamespaces(t *testing.T) {
 	var (
 		namespaces        = []string{"eth", "shh", "bzz"}
-		service           = NotificationTestService{}
+		service           = &notificationTestService{}
-		subCount          = len(namespaces) * 2
+		subCount          = len(namespaces)
 		notificationCount = 3
 
 		server                 = NewServer()
 		clientConn, serverConn = net.Pipe()
 		out                    = json.NewEncoder(clientConn)
 		in                     = json.NewDecoder(clientConn)
-		successes              = make(chan jsonSuccessResponse)
+		successes              = make(chan subConfirmation)
-		failures               = make(chan jsonErrResponse)
+		notifications          = make(chan subscriptionResult)
-		notifications          = make(chan jsonNotification)
+		errors                 = make(chan error, subCount*notificationCount+1)
-		errors                 = make(chan error, 10)
 	)
 
 	// setup and start server
 	for _, namespace := range namespaces {
-		if err := server.RegisterName(namespace, &service); err != nil {
+		if err := server.RegisterName(namespace, service); err != nil {
 			t.Fatalf("unable to register test service %v", err)
 		}
 	}
-
 	go server.ServeCodec(NewJSONCodec(serverConn), OptionMethodInvocation|OptionSubscriptions)
 	defer server.Stop()
 
 	// wait for message and write them to the given channels
-	go waitForMessages(t, in, successes, failures, notifications, errors)
+	go waitForMessages(in, successes, notifications, errors)
 
 	// create subscriptions one by one
 	for i, namespace := range namespaces {
@@ -252,27 +82,11 @@ func TestSubscriptionMultipleNamespaces(t *testing.T) {
 			"version": "2.0",
 			"params":  []interface{}{"someSubscription", notificationCount, i},
 		}
-
 		if err := out.Encode(&request); err != nil {
 			t.Fatalf("Could not create subscription: %v", err)
 		}
 	}
 
-	// create all subscriptions in 1 batch
-	var requests []interface{}
-	for i, namespace := range namespaces {
-		requests = append(requests, map[string]interface{}{
-			"id":      i,
-			"method":  fmt.Sprintf("%s_subscribe", namespace),
-			"version": "2.0",
-			"params":  []interface{}{"someSubscription", notificationCount, i},
-		})
-	}
-
-	if err := out.Encode(&requests); err != nil {
-		t.Fatalf("Could not create subscription in batch form: %v", err)
-	}
-
 	timeout := time.After(30 * time.Second)
 	subids := make(map[string]string, subCount)
 	count := make(map[string]int, subCount)
@@ -285,17 +99,14 @@ func TestSubscriptionMultipleNamespaces(t *testing.T) {
 		}
 		return done
 	}
-
 	for !allReceived() {
 		select {
-		case suc := <-successes: // subscription created
+		case confirmation := <-successes: // subscription created
-			subids[namespaces[int(suc.Id.(float64))]] = suc.Result.(string)
+			subids[namespaces[confirmation.reqid]] = string(confirmation.subid)
 		case notification := <-notifications:
-			count[notification.Params.Subscription]++
+			count[notification.ID]++
 		case err := <-errors:
 			t.Fatal(err)
-		case failure := <-failures:
-			t.Errorf("received error: %v", failure.Error)
 		case <-timeout:
 			for _, namespace := range namespaces {
 				subid, found := subids[namespace]
@@ -311,3 +122,85 @@ func TestSubscriptionMultipleNamespaces(t *testing.T) {
 		}
 	}
 }
+
+// This test checks that unsubscribing works.
+func TestServerUnsubscribe(t *testing.T) {
+	// Start the server.
+	server := newTestServer()
+	service := &notificationTestService{unsubscribed: make(chan string)}
+	server.RegisterName("nftest2", service)
+	p1, p2 := net.Pipe()
+	go server.ServeCodec(NewJSONCodec(p1), OptionMethodInvocation|OptionSubscriptions)
+
+	p2.SetDeadline(time.Now().Add(10 * time.Second))
+
+	// Subscribe.
+	p2.Write([]byte(`{"jsonrpc":"2.0","id":1,"method":"nftest2_subscribe","params":["someSubscription",0,10]}`))
+
+	// Handle received messages.
+	resps := make(chan subConfirmation)
+	notifications := make(chan subscriptionResult)
+	errors := make(chan error)
+	go waitForMessages(json.NewDecoder(p2), resps, notifications, errors)
+
+	// Receive the subscription ID.
+	var sub subConfirmation
+	select {
+	case sub = <-resps:
+	case err := <-errors:
+		t.Fatal(err)
+	}
+
+	// Unsubscribe and check that it is handled on the server side.
+	p2.Write([]byte(`{"jsonrpc":"2.0","method":"nftest2_unsubscribe","params":["` + sub.subid + `"]}`))
+	for {
+		select {
+		case id := <-service.unsubscribed:
+			if id != string(sub.subid) {
+				t.Errorf("wrong subscription ID unsubscribed")
+			}
+			return
+		case err := <-errors:
+			t.Fatal(err)
+		case <-notifications:
+			// drop notifications
+		}
+	}
+}
+
+type subConfirmation struct {
+	reqid int
+	subid ID
+}
+
+func waitForMessages(in *json.Decoder, successes chan subConfirmation, notifications chan subscriptionResult, errors chan error) {
+	for {
+		var msg jsonrpcMessage
+		if err := in.Decode(&msg); err != nil {
+			errors <- fmt.Errorf("decode error: %v", err)
+			return
+		}
+		switch {
+		case msg.isNotification():
+			var res subscriptionResult
+			if err := json.Unmarshal(msg.Params, &res); err != nil {
+				errors <- fmt.Errorf("invalid subscription result: %v", err)
+			} else {
+				notifications <- res
+			}
+		case msg.isResponse():
+			var c subConfirmation
+			if msg.Error != nil {
+				errors <- msg.Error
+			} else if err := json.Unmarshal(msg.Result, &c.subid); err != nil {
+				errors <- fmt.Errorf("invalid response: %v", err)
+			} else {
+				json.Unmarshal(msg.ID, &c.reqid)
+				successes <- c
+			}
+		default:
+			errors <- fmt.Errorf("unrecognized message: %v", msg)
+			return
+		}
+	}
+}

rpc/testdata/invalid-badid.js

@@ -0,0 +1,7 @@
+// This test checks processing of messages with invalid ID.
+
+--> {"id":[],"method":"test_foo"}
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}
+
+--> {"id":{},"method":"test_foo"}
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}

rpc/testdata/invalid-batch.js

@@ -0,0 +1,14 @@
+// This test checks the behavior of batches with invalid elements.
+// Empty batches are not allowed. Batches may contain junk.
+
+--> []
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"empty batch"}}
+
+--> [1]
+<-- [{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]
+
+--> [1,2,3]
+<-- [{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]
+
+--> [{"jsonrpc":"2.0","id":1,"method":"test_echo","params":["foo",1]},55,{"jsonrpc":"2.0","id":2,"method":"unknown_method"},{"foo":"bar"}]
+<-- [{"jsonrpc":"2.0","id":1,"result":{"String":"foo","Int":1,"Args":null}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}},{"jsonrpc":"2.0","id":2,"error":{"code":-32601,"message":"the method unknown_method does not exist/is not available"}},{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}]

rpc/testdata/invalid-idonly.js

@@ -0,0 +1,7 @@
+// This test checks processing of messages that contain just the ID and nothing else.
+
+--> {"id":1}
+<-- {"jsonrpc":"2.0","id":1,"error":{"code":-32600,"message":"invalid request"}}
+
+--> {"jsonrpc":"2.0","id":1}
+<-- {"jsonrpc":"2.0","id":1,"error":{"code":-32600,"message":"invalid request"}}

rpc/testdata/invalid-nonobj.js

@@ -0,0 +1,4 @@
+// This test checks behavior for invalid requests.
+
+--> 1
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"invalid request"}}

rpc/testdata/invalid-syntax.json

@@ -0,0 +1,5 @@
+// This test checks that an error is written for invalid JSON requests.
+
+--> 'f
+<-- {"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"invalid character '\\'' looking for beginning of value"}}
+

rpc/testdata/reqresp-batch.js

@@ -0,0 +1,8 @@
+// There is no response for all-notification batches.
+
+--> [{"jsonrpc":"2.0","method":"test_echo","params":["x",99]}]
+
+// This test checks regular batch calls.
+
+--> [{"jsonrpc":"2.0","id":2,"method":"test_echo","params":[]}, {"jsonrpc":"2.0","id": 3,"method":"test_echo","params":["x",3]}]
+<-- [{"jsonrpc":"2.0","id":2,"error":{"code":-32602,"message":"missing value for required argument 0"}},{"jsonrpc":"2.0","id":3,"result":{"String":"x","Int":3,"Args":null}}]

rpc/testdata/reqresp-echo.js

@@ -0,0 +1,16 @@
+// This test calls the test_echo method.
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": []}
+<-- {"jsonrpc":"2.0","id":2,"error":{"code":-32602,"message":"missing value for required argument 0"}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": ["x"]}
+<-- {"jsonrpc":"2.0","id":2,"error":{"code":-32602,"message":"missing value for required argument 1"}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": ["x", 3]}
+<-- {"jsonrpc":"2.0","id":2,"result":{"String":"x","Int":3,"Args":null}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echo", "params": ["x", 3, {"S": "foo"}]}
+<-- {"jsonrpc":"2.0","id":2,"result":{"String":"x","Int":3,"Args":{"S":"foo"}}}
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "test_echoWithCtx", "params": ["x", 3, {"S": "foo"}]}
+<-- {"jsonrpc":"2.0","id":2,"result":{"String":"x","Int":3,"Args":{"S":"foo"}}}

rpc/testdata/reqresp-namedparam.js

@@ -0,0 +1,5 @@
+// This test checks that an error response is sent for calls
+// with named parameters. 
+
+--> {"jsonrpc":"2.0","method":"test_echo","params":{"int":23},"id":3}
+<-- {"jsonrpc":"2.0","id":3,"error":{"code":-32602,"message":"non-array args"}}

rpc/testdata/reqresp-noargsrets.js

@@ -0,0 +1,4 @@
+// This test calls the test_noArgsRets method.
+
+--> {"jsonrpc": "2.0", "id": "foo", "method": "test_noArgsRets", "params": []}
+<-- {"jsonrpc":"2.0","id":"foo","result":null}

rpc/testdata/reqresp-nomethod.js

@@ -0,0 +1,4 @@
+// This test calls a method that doesn't exist.
+
+--> {"jsonrpc": "2.0", "id": 2, "method": "invalid_method", "params": [2, 3]}
+<-- {"jsonrpc":"2.0","id":2,"error":{"code":-32601,"message":"the method invalid_method does not exist/is not available"}}

rpc/testdata/reqresp-noparam.js

@@ -0,0 +1,4 @@
+// This test checks that calls with no parameters work.
+
+--> {"jsonrpc":"2.0","method":"test_noArgsRets","id":3}
+<-- {"jsonrpc":"2.0","id":3,"result":null}

rpc/testdata/reqresp-paramsnull.js

@@ -0,0 +1,4 @@
+// This test checks that calls with "params":null work.
+
+--> {"jsonrpc":"2.0","method":"test_noArgsRets","params":null,"id":3}
+<-- {"jsonrpc":"2.0","id":3,"result":null}

rpc/testdata/revcall.js

@@ -0,0 +1,6 @@
+// This test checks reverse calls.
+
+--> {"jsonrpc":"2.0","id":2,"method":"test_callMeBack","params":["foo",[1]]}
+<-- {"jsonrpc":"2.0","id":1,"method":"foo","params":[1]}
+--> {"jsonrpc":"2.0","id":1,"result":"my result"}
+<-- {"jsonrpc":"2.0","id":2,"result":"my result"}

rpc/testdata/revcall2.js

@@ -0,0 +1,7 @@
+// This test checks reverse calls.
+
+--> {"jsonrpc":"2.0","id":2,"method":"test_callMeBackLater","params":["foo",[1]]}
+<-- {"jsonrpc":"2.0","id":2,"result":null}
+<-- {"jsonrpc":"2.0","id":1,"method":"foo","params":[1]}
+--> {"jsonrpc":"2.0","id":1,"result":"my result"}
+

rpc/testdata/subscription.js

@@ -0,0 +1,12 @@
+// This test checks basic subscription support.
+
+--> {"jsonrpc":"2.0","id":1,"method":"nftest_subscribe","params":["someSubscription",5,1]}
+<-- {"jsonrpc":"2.0","id":1,"result":"0x1"}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":1}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":2}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":3}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":4}}
+<-- {"jsonrpc":"2.0","method":"nftest_subscription","params":{"subscription":"0x1","result":5}}
+
+--> {"jsonrpc":"2.0","id":2,"method":"nftest_echo","params":[11]}
+<-- {"jsonrpc":"2.0","id":2,"result":11}