Events (#28)

* Implement Events/Event Record Type

* Add MetadataV8

* Add reflection to Event decoding

* Refactor metadata functions as methods

Author: philipstanislaus

types/event_record.go

@@ -0,0 +1,244 @@
+// Go Substrate RPC Client (GSRPC) provides APIs and types around Polkadot and any Substrate-based chain RPC calls
+//
+// Copyright 2019 Centrifuge GmbH
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+
+	"github.com/centrifuge/go-substrate-rpc-client/scale"
+)
+
+// EventRecordsRaw is a raw record for a set of events, represented as the raw bytes. It exists since
+// decoding of events can only be done with metadata, so events can't follow the static way of decoding
+// other types do. It exposes functions to decode events using metadata and targets.
+type EventRecordsRaw []byte
+
+type EventSystemExtrinsicSuccess struct {
+	Phase  Phase
+	Topics []Hash
+}
+type EventSystemExtrinsicFailed struct {
+	Phase         Phase
+	DispatchError DispatchError
+	Topics        []Hash
+}
+
+type EventBalancesTransfer struct {
+	Phase  Phase
+	From   AccountID
+	To     AccountID
+	Value  U128
+	Fees   U128
+	Topics []Hash
+}
+type EventIndicesNewAccountIndex struct {
+	Phase        Phase
+	AccountID    AccountID
+	AccountIndex AccountIndex
+	Topics       []Hash
+}
+type EventBalancesNewAccount struct {
+	Phase     Phase
+	AccountID AccountID
+	Balance   U128
+	Topics    []Hash
+}
+type EventBalancesReapedAccount struct {
+	Phase     Phase
+	AccountID AccountID
+	Topics    []Hash
+}
+type EventSessionNewSession struct {
+	Phase        Phase
+	SessionIndex U32
+	Topics       []Hash
+}
+
+// EventRecords is a default set of possible event records that can be used as a target for
+// `func (e EventRecordsRaw) Decode(...`
+type EventRecords struct {
+	System_ExtrinsicSuccess []EventSystemExtrinsicSuccess //nolint:stylecheck,golint
+	System_ExtrinsicFailed  []EventSystemExtrinsicFailed  //nolint:stylecheck,golint
+	Indices_NewAccountIndex []EventIndicesNewAccountIndex //nolint:stylecheck,golint
+	Balances_NewAccount     []EventBalancesNewAccount     //nolint:stylecheck,golint
+	Balances_ReapedAccount  []EventBalancesReapedAccount  //nolint:stylecheck,golint
+	Balances_Transfer       []EventBalancesTransfer       //nolint:stylecheck,golint
+	Session_NewSession      []EventSessionNewSession      //nolint:stylecheck,golint
+}
+
+// Decode decodes the events from an EventRecordRaw into a target t using the given Metadata m
+func (e EventRecordsRaw) Decode(m *Metadata, t interface{}) error {
+	// ensure t is a pointer
+	ttyp := reflect.TypeOf(t)
+	if ttyp.Kind() != reflect.Ptr {
+		return errors.New("target must be a pointer, but is " + fmt.Sprint(ttyp))
+	}
+	// ensure t is not a nil pointer
+	tval := reflect.ValueOf(t)
+	if tval.IsNil() {
+		return errors.New("target is a nil pointer")
+	}
+	val := tval.Elem()
+	typ := val.Type()
+	// ensure val can be set
+	if !val.CanSet() {
+		return fmt.Errorf("unsettable value %v", typ)
+	}
+	// ensure val points to a struct
+	if val.Kind() != reflect.Struct {
+		return fmt.Errorf("target must point to a struct, but is " + fmt.Sprint(typ))
+	}
+
+	decoder := scale.NewDecoder(bytes.NewReader(e))
+
+	// determine number of events
+	n, err := decoder.DecodeUintCompact()
+	if err != nil {
+		return err
+	}
+
+	// iterate over events
+	for i := uint64(0); i < n; i++ {
+		// decode EventID
+		id := EventID{}
+		err := decoder.Decode(&id)
+		if err != nil {
+			return fmt.Errorf("unable to decode EventID for event #%v: %v", i, err)
+		}
+
+		// ask metadata for method & event name for event
+		moduleName, eventName, err := m.FindEventNamesForEventID(id)
+		// moduleName, eventName, err := "System", "ExtrinsicSuccess", nil
+		if err != nil {
+			return fmt.Errorf("unable to find event with EventID %v in metadata for event #%v", id, i)
+		}
+
+		// check whether name for eventID exists in t
+		field := val.FieldByName(fmt.Sprintf("%v_%v", moduleName, eventName))
+		if !field.IsValid() {
+			return fmt.Errorf("unable to find field %v_%v for event #%v with EventID %v", moduleName, eventName, i, id)
+		}
+
+		// create a pointer to with the correct type that will hold the decoded event
+		holder := reflect.New(field.Type().Elem())
+		err = decoder.Decode(holder.Interface())
+		if err != nil {
+			return fmt.Errorf("unable to decode event #%v with EventID %v, field %v_%v: %v", i, id, moduleName,
+				eventName, err)
+		}
+
+		// add the decoded event to the slice
+		field.Set(reflect.Append(field, holder.Elem()))
+
+		// fmt.Println("Slice type", field.Type().Elem())
+	}
+	return nil
+}
+
+// Phase is an enum describing the current phase of the event (applying the extrinsic or finalized)
+type Phase struct {
+	IsApplyExtrinsic bool
+	AsApplyExtrinsic uint32
+	IsFinalization   bool
+}
+
+func (p *Phase) Decode(decoder scale.Decoder) error {
+	b, err := decoder.ReadOneByte()
+	if err != nil {
+		return err
+	}
+
+	if b == 0 {
+		p.IsApplyExtrinsic = true
+		err = decoder.Decode(&p.AsApplyExtrinsic)
+	} else if b == 1 {
+		p.IsFinalization = true
+	}
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p Phase) Encode(encoder scale.Encoder) error {
+	var err1, err2 error
+	if p.IsApplyExtrinsic {
+		err1 = encoder.PushByte(0)
+		err2 = encoder.Encode(p.AsApplyExtrinsic)
+	} else if p.IsFinalization {
+		err1 = encoder.PushByte(1)
+	}
+
+	if err1 != nil {
+		return err1
+	}
+	if err2 != nil {
+		return err2
+	}
+
+	return nil
+}
+
+// DispatchError is an error occurring during extrinsic dispatch
+type DispatchError struct {
+	HasModule bool
+	Module    uint8
+	Error     uint8
+}
+
+func (d *DispatchError) Decode(decoder scale.Decoder) error {
+	b, err := decoder.ReadOneByte()
+	if err != nil {
+		return err
+	}
+
+	if b == 1 {
+		d.HasModule = true
+		err = decoder.Decode(&d.Module)
+	}
+	if err != nil {
+		return err
+	}
+
+	return decoder.Decode(&d.Error)
+}
+
+func (d DispatchError) Encode(encoder scale.Encoder) error {
+	var err error
+	if d.HasModule {
+		err = encoder.PushByte(1)
+		if err != nil {
+			return err
+		}
+		err = encoder.Encode(d.Module)
+	} else {
+		err = encoder.PushByte(0)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	return encoder.Encode(&d.Error)
+}
+
+type EventID [2]byte

types/event_record_test.go

@@ -0,0 +1,104 @@
+// Go Substrate RPC Client (GSRPC) provides APIs and types around Polkadot and any Substrate-based chain RPC calls
+// Copyright (C) 2019  Centrifuge GmbH
+//
+// This file is part of Go Substrate RPC Client (GSRPC).
+//
+// GSRPC 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.
+//
+// GSRPC 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 this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package types_test
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/centrifuge/go-substrate-rpc-client/types"
+	"github.com/stretchr/testify/assert"
+)
+
+var examplePhaseApp = Phase{
+	IsApplyExtrinsic: true,
+	AsApplyExtrinsic: 42,
+}
+
+var examplePhaseFin = Phase{
+	IsFinalization: true,
+}
+
+var exampleEventApp = EventSystemExtrinsicSuccess{
+	Phase:  examplePhaseApp,
+	Topics: []Hash{{1, 2}},
+}
+
+var exampleEventFin = EventSystemExtrinsicSuccess{
+	Phase:  examplePhaseFin,
+	Topics: []Hash{{1, 2}},
+}
+
+var exampleEventFinEnc = []byte{0x1, 0x4, 0x1, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0} //nolint:lll
+
+func TestEventSystemExtrinsicSuccess_EncodedLength(t *testing.T) {
+	assertEncodedLength(t, []encodedLengthAssert{
+		{exampleEventApp, 38},
+		{exampleEventFin, 34},
+	})
+}
+
+func TestEventSystemExtrinsicSuccess_Encode(t *testing.T) {
+	encoded, err := EncodeToBytes(exampleEventFin)
+	assert.NoError(t, err)
+	assert.Equal(t, exampleEventFinEnc, encoded)
+}
+
+func TestEventSystemExtrinsicSuccess_Decode(t *testing.T) {
+	decoded := EventSystemExtrinsicSuccess{}
+	err := DecodeFromBytes(exampleEventFinEnc, &decoded)
+	assert.NoError(t, err)
+	assert.Equal(t, exampleEventFin, decoded)
+}
+
+func TestEventSystemExtrinsicSuccess_Hash(t *testing.T) {
+	assertHash(t, []hashAssert{
+		{exampleEventFin, MustHexDecodeString(
+			"0xfb1a0568e74c9e2ed9ec6a7cca8b680a24ca442e5cf391ca6d863e3b35a4c962")},
+	})
+}
+
+func ExampleEventRecordsRaw_Decode() {
+	e := EventRecordsRaw(MustHexDecodeString("0x100000000000000000000100000000000000020000000302d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48266d00000000000000000000000000000010a5d4e80000000000000000000000000002000000000000")) //nolint:lll
+
+	events := EventRecords{}
+	err := e.Decode(ExamplaryMetadataV8, &events)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Printf("Got %v System_ExtrinsicSuccess events\n", len(events.System_ExtrinsicSuccess))
+	fmt.Printf("Got %v System_ExtrinsicFailed events\n", len(events.System_ExtrinsicFailed))
+	fmt.Printf("Got %v Indices_NewAccountIndex events\n", len(events.Indices_NewAccountIndex))
+	fmt.Printf("Got %v Balances_Transfer events\n", len(events.Balances_Transfer))
+	t := events.Balances_Transfer[0]
+	fmt.Printf("Transfer: %v tokens from %#x to\n%#x with a fee of %v", t.Value, t.From, t.To, t.Fees)
+
+	// Output: Got 1 System_ExtrinsicSuccess events
+	// Got 1 System_ExtrinsicFailed events
+	// Got 1 Indices_NewAccountIndex events
+	// Got 1 Balances_Transfer events
+	// Transfer: 109 tokens from 0x3593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8e to
+	// 0xaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4826 with a fee of 3906250000
+}
+
+func TestDispatchError(t *testing.T) {
+	assertRoundtrip(t, DispatchError{HasModule: true, Module: 0xf1, Error: 0xa2})
+	assertRoundtrip(t, DispatchError{HasModule: false, Error: 0xa2})
+}