Remove context and fix e2e deployed (#40)

* Remove useless context from client

* Add methods to generate KeyringPair from seed/phrase

* Change end to end tests to use pivate key from ENV variable or skip tests if that variable is unset or empty

Author: philipstanislaus

client/client.go

@@ -34,15 +34,11 @@ type Client interface {
 
 	URL() string
 	//MetaData(cache bool) (*MetadataVersioned, error)
-
-	Ctx() context.Context
 }
 
 type client struct {
 	gethrpc.Client
 
-	ctx context.Context
-
 	url string
 
 	// metadataVersioned is the metadata cache to prevent unnecessary requests
@@ -56,11 +52,6 @@ func (c client) URL() string {
 	return c.url
 }
 
-// Ctx returns the context.Context
-func (c client) Ctx() context.Context {
-	return c.ctx
-}
-
 // TODO move to State struct
 //func (c *client) MetaData(cache bool) (m *MetadataVersioned, err error) {
 //	if cache && c.metadataVersioned != nil {
@@ -92,7 +83,7 @@ func Connect(url string) (Client, error) {
 	if err != nil {
 		return nil, err
 	}
-	cc := client{*c, ctx, url}
+	cc := client{*c, url}
 	return &cc, nil
 }
 

signature/signature.go

@@ -19,12 +19,12 @@ package signature
 import (
 	"encoding/hex"
 	"fmt"
-	"log"
+	"os"
 	"os/exec"
+	"regexp"
 	"strings"
 )
 
-// const subkeyCmd = "/Users/philipstanislaus/go/src/github.com/paritytech/substrate/target/debug/subkey"
 const subkeyCmd = "subkey"
 
 type KeyringPair struct {
@@ -36,6 +36,46 @@ type KeyringPair struct {
 	PublicKey []byte
 }
 
+var rePubKey = regexp.MustCompile(`Public key \(hex\): 0x([a-f0-9]*)\n`)
+var reAddress = regexp.MustCompile(`Address \(SS58\): ([a-zA-Z0-9]*)\n`)
+
+func KeyringPairFromSecret(seedOrPhrase string) (KeyringPair, error) {
+	// use "subkey" command for creation of public key and address
+	cmd := exec.Command(subkeyCmd, "inspect", seedOrPhrase)
+
+	// execute the command, get the output
+	out, err := cmd.Output()
+	if err != nil {
+		return KeyringPair{}, fmt.Errorf("failed to generate keyring pair from secret: %v", err.Error())
+	}
+
+	if string(out) == "Invalid phrase/URI given" {
+		return KeyringPair{}, fmt.Errorf("failed to generate keyring pair from secret: invalid phrase/URI given")
+	}
+
+	// find the pub key
+	resPk := rePubKey.FindStringSubmatch(string(out))
+	if len(resPk) != 2 {
+		return KeyringPair{}, fmt.Errorf("failed to generate keyring pair from secret, pubkey not found in output: %v", resPk)
+	}
+	pk, err := hex.DecodeString(string(resPk[1]))
+	if err != nil {
+		return KeyringPair{}, fmt.Errorf("failed to generate keyring pair from secret, could not hex decode pubkey: %v", string(resPk[1]))
+	}
+
+	// find the address
+	addr := reAddress.FindStringSubmatch(string(out))
+	if len(addr) != 2 {
+		return KeyringPair{}, fmt.Errorf("failed to generate keyring pair from secret, address not found in output: %v", addr)
+	}
+
+	return KeyringPair{
+		URI:       seedOrPhrase,
+		Address:   addr[1],
+		PublicKey: pk,
+	}, nil
+}
+
 var TestKeyringPairAlice = KeyringPair{
 	URI:       "//Alice",
 	PublicKey: []byte{0xd4, 0x35, 0x93, 0xc7, 0x15, 0xfd, 0xd3, 0x1c, 0x61, 0x14, 0x1a, 0xbd, 0x4, 0xa9, 0x9f, 0xd6, 0x82, 0x2c, 0x85, 0x58, 0x85, 0x4c, 0xcd, 0xe3, 0x9a, 0x56, 0x84, 0xe7, 0xa5, 0x6d, 0xa2, 0x7d}, //nolint:lll
@@ -52,7 +92,7 @@ func Sign(data []byte, privateKeyURI string) ([]byte, error) {
 	dataHex := hex.EncodeToString(data)
 	cmd.Stdin = strings.NewReader(dataHex)
 
-	log.Printf("echo -n \"%v\" | %v sign %v --hex", dataHex, subkeyCmd, privateKeyURI)
+	// log.Printf("echo -n \"%v\" | %v sign %v --hex", dataHex, subkeyCmd, privateKeyURI)
 
 	// execute the command, get the output
 	out, err := cmd.Output()
@@ -85,12 +125,12 @@ func Verify(data []byte, sig []byte, privateKeyURI string) (bool, error) {
 	dataHex := hex.EncodeToString(data)
 	cmd.Stdin = strings.NewReader(dataHex)
 
-	log.Printf("echo -n \"%v\" | %v verify %v %v --hex", dataHex, subkeyCmd, sigHex, privateKeyURI)
+	// log.Printf("echo -n \"%v\" | %v verify %v %v --hex", dataHex, subkeyCmd, sigHex, privateKeyURI)
 
 	// execute the command, get the output
 	out, err := cmd.Output()
 	if err != nil {
-		log.Fatal("Failed to verify with subkey", err.Error())
+		return false, fmt.Errorf("failed to verify with subkey: %v", err.Error())
 	}
 
 	// remove line feed
@@ -102,3 +142,18 @@ func Verify(data []byte, sig []byte, privateKeyURI string) (bool, error) {
 	valid := outStr == "Signature verifies correctly."
 	return valid, nil
 }
+
+// LoadKeyringPairFromEnv looks up whether the env variable TEST_PRIV_KEY is set and is not empty and tries to use its
+// content as a private phrase, seed or URI to derive a key ring pair. Panics if the private phrase, seed or URI is
+// not valid or the keyring pair cannot be derived
+func LoadKeyringPairFromEnv() (kp KeyringPair, ok bool) {
+	priv, ok := os.LookupEnv("TEST_PRIV_KEY")
+	if !ok || priv == "" {
+		return kp, false
+	}
+	kp, err := KeyringPairFromSecret(priv)
+	if err != nil {
+		panic(fmt.Errorf("cannot load keyring pair from env or use fallback: %v", err))
+	}
+	return kp, true
+}

signature/signature_test.go

@@ -21,9 +21,37 @@ import (
 	"testing"
 
 	. "github.com/centrifuge/go-substrate-rpc-client/signature"
+	"github.com/centrifuge/go-substrate-rpc-client/types"
 	"github.com/stretchr/testify/assert"
 )
 
+var testSecretPhrase = "little orbit comfort eyebrow talk pink flame ridge bring milk equip blood"
+var testSecretSeed = "0x167d9a020688544ea246b056799d6a771e97c9da057e4d0b87024537f99177bc"
+var testPubKey = "0xdc64bef918ddda3126a39a11113767741ddfdf91399f055e1d963f2ae1ec2535"
+var testAddressSS58 = "5H3gKVQU7DfNFfNGkgTrD7p715jjg7QXtat8X3UxiSyw7APW"
+
+func TestKeyRingPairFromSecretPhrase(t *testing.T) {
+	p, err := KeyringPairFromSecret(testSecretPhrase)
+	assert.NoError(t, err)
+
+	assert.Equal(t, KeyringPair{
+		URI: testSecretPhrase,
+		Address: testAddressSS58,
+		PublicKey: types.MustHexDecodeString(testPubKey),
+	}, p)
+}
+
+func TestKeyringPairFromSecretSeed(t *testing.T) {
+	p, err := KeyringPairFromSecret(testSecretSeed)
+	assert.NoError(t, err)
+
+	assert.Equal(t, KeyringPair{
+		URI: testSecretSeed,
+		Address: testAddressSS58,
+		PublicKey: types.MustHexDecodeString(testPubKey),
+	}, p)
+}
+
 func TestSignAndVerify(t *testing.T) {
 	data := []byte("hello!")
 

teste2e/author_submit_and_watch_extrinsic_test.go

@@ -33,6 +33,11 @@ func TestAuthor_SubmitAndWatchExtrinsic(t *testing.T) {
 		t.Skip("skipping end-to-end test in short mode.")
 	}
 
+	from, ok := signature.LoadKeyringPairFromEnv()
+	if !ok {
+		t.Skip("skipping end-to-end that requires a private key because TEST_PRIV_KEY is not set or empty")
+	}
+
 	api, err := gsrpc.NewSubstrateAPI(config.Default().RPCURL)
 	if err != nil {
 		panic(err)
@@ -70,7 +75,7 @@ func TestAuthor_SubmitAndWatchExtrinsic(t *testing.T) {
 		panic(err)
 	}
 
-	key, err := types.CreateStorageKey(meta, "System", "AccountNonce", signature.TestKeyringPairAlice.PublicKey)
+	key, err := types.CreateStorageKey(meta, "System", "AccountNonce", from.PublicKey)
 	if err != nil {
 		panic(err)
 	}
@@ -91,7 +96,7 @@ func TestAuthor_SubmitAndWatchExtrinsic(t *testing.T) {
 		Tip:         0,
 	}
 
-	err = ext.Sign(signature.TestKeyringPairAlice, o)
+	err = ext.Sign(from, o)
 	if err != nil {
 		panic(err)
 	}

teste2e/author_submit_extrinsic_test.go

@@ -32,6 +32,11 @@ func TestChain_SubmitExtrinsic(t *testing.T) {
 		t.Skip("skipping end-to-end test in short mode.")
 	}
 
+	from, ok := signature.LoadKeyringPairFromEnv()
+	if !ok {
+		t.Skip("skipping end-to-end that requires a private key because TEST_PRIV_KEY is not set or empty")
+	}
+
 	api, err := gsrpc.NewSubstrateAPI(config.Default().RPCURL)
 	if err != nil {
 		panic(err)
@@ -74,7 +79,7 @@ func TestChain_SubmitExtrinsic(t *testing.T) {
 		panic(err)
 	}
 
-	key, err := types.CreateStorageKey(meta, "System", "AccountNonce", signature.TestKeyringPairAlice.PublicKey)
+	key, err := types.CreateStorageKey(meta, "System", "AccountNonce", from.PublicKey)
 	if err != nil {
 		panic(err)
 	}
@@ -98,7 +103,7 @@ func TestChain_SubmitExtrinsic(t *testing.T) {
 
 		extI := ext
 
-		err = extI.Sign(signature.TestKeyringPairAlice, o)
+		err = extI.Sign(from, o)
 		if err != nil {
 			panic(err)
 		}