fix substrate issues

mailchain · Jul 12, 2020 · edfb870 · edfb870
1 parent cdd7abc
commit edfb870
Show file tree

Hide file tree

Showing 22 changed files with 352 additions and 38 deletions.
diff --git a/cmd/indexer/internal/substrate/extrinsic.go b/cmd/indexer/internal/substrate/extrinsic.go
@@ -14,6 +14,7 @@ import (
 	"github.com/mailchain/mailchain/crypto/sr25519"
 	"github.com/mailchain/mailchain/encoding"
 	"github.com/mailchain/mailchain/internal/protocols/substrate"
+	"github.com/minio/blake2b-simd"
 	"github.com/pkg/errors"
 )
 
@@ -95,11 +96,24 @@ func getToAddress(network string, dataPart []byte) ([]byte, error) {
 	return substrate.SS58AddressFormat(network, toPubKey)
 }
 
-func (t *Extrinsic) ToTransaction(network string, blk *types.Block, tx *types.Extrinsic) (*datastore.Transaction, error) {
+func ExtrinsicHash(ex *types.Extrinsic) ([]byte, error) {
 	w := bytes.NewBuffer([]byte{})
 	encoder := scale.NewEncoder(w)
 
-	if err := tx.Method.Args.Encode(*encoder); err != nil {
+	if err := ex.Encode(*encoder); err != nil {
+		return nil, err
+	}
+
+	h := blake2b.Sum256(w.Bytes())
+
+	return h[:], nil
+}
+
+func (t *Extrinsic) ToTransaction(network string, blk *types.Block, ex *types.Extrinsic) (*datastore.Transaction, error) {
+	w := bytes.NewBuffer([]byte{})
+	encoder := scale.NewEncoder(w)
+
+	if err := ex.Method.Args.Encode(*encoder); err != nil {
 		return nil, err
 	}
 
@@ -110,7 +124,7 @@ func (t *Extrinsic) ToTransaction(network string, blk *types.Block, tx *types.Ex
 		return nil, err
 	}
 
-	from, err := getFromAddress(network, &tx.Signature)
+	from, err := getFromAddress(network, &ex.Signature)
 	if err != nil {
 		return nil, err
 	}
@@ -120,10 +134,15 @@ func (t *Extrinsic) ToTransaction(network string, blk *types.Block, tx *types.Ex
 		return nil, err
 	}
 
+	hash, err := ExtrinsicHash(ex)
+	if err != nil {
+		return nil, err
+	}
+
 	return &datastore.Transaction{
 		From: from,
 		// BlockHash: blk.Hash().Bytes(),
-		// Hash:      tx.Hash().Bytes(),
+		Hash: hash,
 		Data: decodedData,
 		To:   to,
 		// Value:    *value,

diff --git a/cmd/indexer/internal/substrate/extrinsic_test.go b/cmd/indexer/internal/substrate/extrinsic_test.go
@@ -7,11 +7,12 @@ import (
 	"github.com/golang/mock/gomock"
 	"github.com/mailchain/go-substrate-rpc-client/types"
 	"github.com/mailchain/mailchain/cmd/indexer/internal/actions"
-	"github.com/mailchain/mailchain/cmd/indexer/internal/substrate"
+	target "github.com/mailchain/mailchain/cmd/indexer/internal/substrate"
 	"github.com/mailchain/mailchain/cmd/internal/datastore"
 	"github.com/mailchain/mailchain/cmd/internal/datastore/datastoretest"
 	"github.com/mailchain/mailchain/internal/protocols"
 	networks "github.com/mailchain/mailchain/internal/protocols/substrate"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestExtrinsic_Run(t *testing.T) {
@@ -63,14 +64,14 @@ func TestExtrinsic_Run(t *testing.T) {
 					e := b.Extrinsics[2]
 					return &e
 				}(),
-				&substrate.TxOptions{},
+				&target.TxOptions{},
 			},
 			false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			extrinsic := substrate.NewExtrinsicProcessor(
+			extrinsic := target.NewExtrinsicProcessor(
 				tt.fields.txStore,
 				tt.fields.rawTxStore,
 				tt.fields.pkStore,
@@ -82,3 +83,64 @@ func TestExtrinsic_Run(t *testing.T) {
 		})
 	}
 }
+
+func Test_ExtrinsicHash(t *testing.T) {
+	type args struct {
+		ex *types.Extrinsic
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    []byte
+		wantErr bool
+	}{
+		{
+			"success-timestamp-set",
+			args{
+				func() *types.Extrinsic {
+					b := getBlock(t, "0x7ce3d93396dac53f1ae5fba268afcaa623e224e359507d581439dea791bab971")
+					e := b.Extrinsics[0]
+					return &e
+				}(),
+			},
+			[]byte{0x94, 0x6c, 0x96, 0xef, 0x50, 0x2b, 0x4f, 0x4, 0x6e, 0x4f, 0xae, 0x52, 0x9, 0x52, 0x3a, 0xe3, 0xaa, 0x59, 0xa5, 0x66, 0x49, 0x2d, 0xf6, 0x4e, 0xdf, 0x38, 0x10, 0xd0, 0x35, 0x7c, 0x35, 0x51},
+			false,
+		},
+		{
+			"success-final-hint",
+			args{
+				func() *types.Extrinsic {
+					b := getBlock(t, "0x7ce3d93396dac53f1ae5fba268afcaa623e224e359507d581439dea791bab971")
+					e := b.Extrinsics[1]
+					return &e
+				}(),
+			},
+			[]byte{0x49, 0xf0, 0xb1, 0x75, 0x20, 0xe9, 0x77, 0x4f, 0x8d, 0x86, 0xf4, 0xba, 0xae, 0x6, 0x15, 0xe9, 0x2c, 0x54, 0xbd, 0x9f, 0x87, 0x35, 0xd6, 0xe8, 0xa7, 0xab, 0xeb, 0x8c, 0x76, 0x2a, 0x67, 0xd4},
+			false,
+		},
+		{
+			"success-contract",
+			args{
+				func() *types.Extrinsic {
+					b := getBlock(t, "0x7ce3d93396dac53f1ae5fba268afcaa623e224e359507d581439dea791bab971")
+					e := b.Extrinsics[2]
+					return &e
+				}(),
+			},
+			[]byte{0xdc, 0xd9, 0x48, 0x65, 0x81, 0x56, 0x13, 0x1f, 0x43, 0xb7, 0x8a, 0x4c, 0x85, 0xe1, 0x63, 0xa8, 0xa1, 0xaa, 0x33, 0x65, 0xa3, 0x92, 0xf4, 0x9e, 0x51, 0x43, 0x65, 0x20, 0x57, 0xfc, 0xf5, 0xe9},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := target.ExtrinsicHash(tt.args.ex)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("extrinsicHash() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !assert.Equal(t, tt.want, got) {
+				t.Errorf("extrinsicHash() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/...testdata/blocks/0x7ce3d93396dac53f1ae5fba268afcaa623e224e359507d581439dea791bab971 2.json b/...testdata/blocks/0x7ce3d93396dac53f1ae5fba268afcaa623e224e359507d581439dea791bab971 2.json
@@ -0,0 +1,26 @@
+{
+    "jsonrpc": "2.0",
+    "result": {
+        "block": {
+            "extrinsics": [
+                "0x280402000ba0fa77987101",
+                "0x1c040b007ab03f00",
+                "0xd10384fff49a6b6deb3cdb00d86e735ced8f48b649273fc6ff6a3bbba021a6b4a1c5d06701b6f94ea763c250533409727e26eda6f67661c8da4190dbf0988c4e0c4ee14465efe0f64267e836aeee21a7d44aec1c82a2013c8dd064aebe27559db0cece9b83007c000e02ff2a9aff809089623c64ccd7ca79b8fffb114cef2c251b2b3e4f2d5144eee962fb0002f40100910130783664363136393663363336383631363936653031306132353230303130313136323065666639663438333061373038653364373938333635363861306161346136343063353034643034383938343139363738333361306439633965353162366533"
+            ],
+            "header": {
+                "digest": {
+                    "logs": [
+                        "0x06617572612026f8c40f00000000",
+                        "0x0561757261010135748ca2ac77a329c7053b38bff94a18a504df23aea9a9c8e03e06f479b334b384996a0021447b5a4afebd32f2ee6ceb8cc832b107f7cd35400e5a17854d0407"
+                    ]
+                },
+                "extrinsicsRoot": "0x8765cd86b8d08b63fb315855894f5c357c4b25670c131f96b5bbad5aab6971a5",
+                "number": "0xfec21",
+                "parentHash": "0xf145d056d93bc8e1661cf334763b475f32ab3ee0155e3d6a33c825904509023d",
+                "stateRoot": "0x0a2164eece05fab911adfd891ea1e02e9e11a0a1f18e05f61ffefecc99b5dabf"
+            }
+        },
+        "justification": null
+    },
+    "id": 23
+}
diff --git a/cmd/mailchain/internal/http/handlers/messages.go b/cmd/mailchain/internal/http/handlers/messages.go
@@ -45,16 +45,19 @@ func GetMessages(inbox stores.State, receivers map[string]mailbox.Receiver, ks k
 	//   422: ValidationError
 	return func(w http.ResponseWriter, r *http.Request) {
 		ctx := r.Context()
+
 		req, err := parseGetMessagesRequest(r)
 		if err != nil {
 			errs.JSONWriter(w, http.StatusUnprocessableEntity, errors.WithStack(err))
 			return
 		}
+
 		receiver, ok := receivers[fmt.Sprintf("%s/%s", req.Protocol, req.Network)]
 		if !ok {
 			errs.JSONWriter(w, http.StatusUnprocessableEntity, errors.Errorf("receiver not supported on \"%s/%s\"", req.Protocol, req.Network))
 			return
 		}
+
 		if receiver == nil {
 			errs.JSONWriter(w, http.StatusUnprocessableEntity, errors.Errorf("no receiver configured for \"%s/%s\"", req.Protocol, req.Network))
 			return
@@ -64,29 +67,35 @@ func GetMessages(inbox stores.State, receivers map[string]mailbox.Receiver, ks k
 			errs.JSONWriter(w, http.StatusNotAcceptable, errors.Errorf("no private key found for address"))
 			return
 		}
-		transactions, err := receiver.Receive(ctx, req.Network, req.addressBytes)
+
+		transactions, err := receiver.Receive(ctx, req.Protocol, req.Network, req.addressBytes)
 		if mailbox.IsNetworkNotSupportedError(err) {
 			errs.JSONWriter(w, http.StatusNotAcceptable, errors.Errorf("network `%s` does not have etherscan client configured", req.Network))
 			return
 		}
+
 		if err != nil {
 			errs.JSONWriter(w, http.StatusInternalServerError, errors.WithStack(err))
 			return
 		}
+
 		decrypter, err := ks.GetDecrypter(req.addressBytes, req.Protocol, req.Network, cipher.AES256CBC, deriveKeyOptions)
 		if err != nil {
 			errs.JSONWriter(w, http.StatusInternalServerError, errors.WithMessage(err, "could not get `decrypter`"))
 			return
 		}
+
 		messages := make([]getMessage, 0)
 		for _, transactionData := range transactions { //nolint TODO: thats an arbitrary limit
 			message, err := mailbox.ReadMessage(transactionData.Data, decrypter)
 			if err != nil {
 				messages = append(messages, getMessage{
 					Status: err.Error(),
 				})
+
 				continue
 			}
+
 			readStatus, _ := inbox.GetReadStatus(message.ID)
 			messages = append(messages, getMessage{
 				Body: string(message.Body),
@@ -163,11 +172,6 @@ func parseGetMessagesRequest(r *http.Request) (*GetMessagesRequest, error) {
 		return nil, err
 	}
 
-	// TODO: validate address
-	// if !ethereum.IsAddressValid(addr) {
-	// 	return nil, errors.Errorf("'address' is invalid")
-	// }
-
 	addressBytes, err := address.DecodeByProtocol(addr, protocol)
 	if err != nil {
 		return nil, err

diff --git a/cmd/mailchain/internal/http/handlers/messages_test.go b/cmd/mailchain/internal/http/handlers/messages_test.go
@@ -102,7 +102,7 @@ func Test_GetMessages(t *testing.T) {
 					return map[string]mailbox.Receiver{
 						"ethereum/mainnet": func() mailbox.Receiver {
 							receiver := mailboxtest.NewMockReceiver(mockCtrl)
-							receiver.EXPECT().Receive(context.Background(), "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
+							receiver.EXPECT().Receive(context.Background(), "ethereum", "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
 								Return(nil, errors.New("network not supported")).Times(1)
 							return receiver
 						}(),
@@ -125,7 +125,7 @@ func Test_GetMessages(t *testing.T) {
 					return map[string]mailbox.Receiver{
 						"ethereum/mainnet": func() mailbox.Receiver {
 							receiver := mailboxtest.NewMockReceiver(mockCtrl)
-							receiver.EXPECT().Receive(context.Background(), "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
+							receiver.EXPECT().Receive(context.Background(), "ethereum", "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
 								Return(nil, errors.New("internal error")).Times(1)
 							return receiver
 						}(),
@@ -148,7 +148,7 @@ func Test_GetMessages(t *testing.T) {
 					return map[string]mailbox.Receiver{
 						"ethereum/mainnet": func() mailbox.Receiver {
 							receiver := mailboxtest.NewMockReceiver(mockCtrl)
-							receiver.EXPECT().Receive(context.Background(), "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
+							receiver.EXPECT().Receive(context.Background(), "ethereum", "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
 								Return([]mailbox.Transaction{}, nil).Times(1)
 							return receiver
 						}(),
@@ -177,7 +177,7 @@ func Test_GetMessages(t *testing.T) {
 					return map[string]mailbox.Receiver{
 						"ethereum/mainnet": func() mailbox.Receiver {
 							receiver := mailboxtest.NewMockReceiver(mockCtrl)
-							receiver.EXPECT().Receive(context.Background(), "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
+							receiver.EXPECT().Receive(context.Background(), "ethereum", "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
 								Return([]mailbox.Transaction{
 									{
 										Data:    encodingtest.MustDecodeHex("500801120f7365637265742d6c6f636174696f6e1a221620d3c47ef741473ebf42773d25687b7540a3d96429aec07dd1ce66c0d4fd16ea13"),
@@ -222,7 +222,7 @@ func Test_GetMessages(t *testing.T) {
 					return map[string]mailbox.Receiver{
 						"ethereum/mainnet": func() mailbox.Receiver {
 							receiver := mailboxtest.NewMockReceiver(mockCtrl)
-							receiver.EXPECT().Receive(context.Background(), "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
+							receiver.EXPECT().Receive(context.Background(), "ethereum", "mainnet", []byte{0x56, 0x2, 0xea, 0x95, 0x54, 0xb, 0xee, 0x46, 0xd0, 0x3b, 0xa3, 0x35, 0xee, 0xd6, 0xf4, 0x9d, 0x11, 0x7e, 0xab, 0x95, 0xc8, 0xab, 0x8b, 0x71, 0xba, 0xe2, 0xcd, 0xd1, 0xe5, 0x64, 0xa7, 0x61}).
 								Return([]mailbox.Transaction{}, nil).Times(1)
 							return receiver
 						}(),

diff --git a/cmd/mailchain/internal/settings/defaults/networks.go b/cmd/mailchain/internal/settings/defaults/networks.go
@@ -28,8 +28,8 @@ func SubstrateNetworkAny(network string) *NetworkDefaults {
 		// NameServiceAddress:    NameServiceAddressKind,
 		// NameServiceDomainName: NameServiceDomainNameKind,
 		PublicKeyFinder: SubstratePublicKeyFinder,
-		// Receiver:              mailchain.ClientEtherscanNoAuth,
-		Sender:   "substrate-rpc-" + network,
-		Disabled: false,
+		Receiver:        Mailchain,
+		Sender:          "substrate-rpc-" + network,
+		Disabled:        false,
 	}
 }
diff --git a/.../internal/settings/blockscout_receiver.go → .../internal/settings/receiver_blockscout.go b/.../internal/settings/blockscout_receiver.go → .../internal/settings/receiver_blockscout.go
diff --git a/...rnal/settings/blockscout_receiver_test.go → ...rnal/settings/receiver_blockscout_test.go b/...rnal/settings/blockscout_receiver_test.go → ...rnal/settings/receiver_blockscout_test.go
diff --git a/...n/internal/settings/etherscan_receiver.go → ...n/internal/settings/receiver_etherscan.go b/...n/internal/settings/etherscan_receiver.go → ...n/internal/settings/receiver_etherscan.go
diff --git a/...ernal/settings/etherscan_receiver_test.go → ...ernal/settings/receiver_etherscan_test.go b/...ernal/settings/etherscan_receiver_test.go → ...ernal/settings/receiver_etherscan_test.go
diff --git a/cmd/mailchain/internal/settings/receiver_mailchain.go b/cmd/mailchain/internal/settings/receiver_mailchain.go
@@ -0,0 +1,56 @@
+package settings //nolint: dupl
+
+import (
+	"github.com/mailchain/mailchain/cmd/internal/settings/output"
+	"github.com/mailchain/mailchain/cmd/internal/settings/values"
+	"github.com/mailchain/mailchain/internal/clients/mailchain"
+	"github.com/mailchain/mailchain/internal/mailbox"
+	"github.com/mailchain/mailchain/internal/protocols"
+	"github.com/mailchain/mailchain/internal/protocols/substrate"
+)
+
+// MailchainReceiver configuration element.
+type MailchainReceiver struct {
+	EnabledProtocolNetworks values.StringSlice
+	Address                 values.String
+}
+
+func mailchainReceiverNoAuth(s values.Store) *MailchainReceiver {
+	return &MailchainReceiver{
+		Address: values.NewDefaultString("http://localhost:8081", s, "receivers.mailchain.address"),
+		EnabledProtocolNetworks: values.NewDefaultStringSlice(
+			[]string{
+				protocols.Substrate + "/" + substrate.EdgewareBerlin,
+				protocols.Substrate + "/" + substrate.EdgewareMainnet,
+			},
+			s,
+			"receivers.mailchain.enabled-networks",
+		),
+	}
+}
+
+// Supports a map of what protocol and network combinations are supported.
+func (r MailchainReceiver) Supports() map[string]bool {
+	m := map[string]bool{}
+	for _, np := range r.EnabledProtocolNetworks.Get() {
+		m[np] = true
+	}
+
+	return m
+}
+
+// Produce `mailbox.Receiver` based on configuration settings.
+func (r MailchainReceiver) Produce() (mailbox.Receiver, error) {
+	return mailchain.NewReceiver(r.Address.Get())
+}
+
+// Output configuration as an `output.Element` for use in exporting configuration.
+func (r MailchainReceiver) Output() output.Element {
+	return output.Element{
+		FullName: "mailchain",
+		Attributes: []output.Attribute{
+			r.EnabledProtocolNetworks.Attribute(),
+			r.Address.Attribute(),
+		},
+	}
+}
diff --git a/cmd/mailchain/internal/settings/receivers.go b/cmd/mailchain/internal/settings/receivers.go
@@ -14,6 +14,7 @@ func receivers(s values.Store) *Receivers {
 			defaults.ClientEtherscanNoAuth:  etherscanReceiverNoAuth(s),
 			defaults.ClientEtherscan:        etherscanReceiver(s),
 			defaults.ClientBlockscoutNoAuth: blockscoutReceiverNoAuth(s),
+			defaults.Mailchain:              mailchainReceiverNoAuth(s),
 		},
 	}
 }