From 7caf8d4345739840d2485ad66b9bb5de4433a521 Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Thu, 1 Jul 2021 16:37:01 -0600 Subject: [PATCH 1/7] integrate scale into babe library --- lib/babe/build.go | 23 ++-- lib/babe/build_test.go | 7 +- lib/babe/errors.go | 223 +++++++++++++++++++++++++++------- lib/babe/errors_test.go | 10 ++ lib/transaction/types.go | 35 ------ lib/transaction/types_test.go | 3 +- pkg/scale/decode.go | 2 + 7 files changed, 211 insertions(+), 92 deletions(-) diff --git a/lib/babe/build.go b/lib/babe/build.go index 66b181caf8..3c2d3ecbd2 100644 --- a/lib/babe/build.go +++ b/lib/babe/build.go @@ -29,8 +29,8 @@ import ( "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" + "github.com/ChainSafe/gossamer/pkg/scale" ) const ( @@ -305,14 +305,15 @@ func (b *BlockBuilder) buildBlockInherents(slot Slot) ([][]byte, error) { } // decode inherent extrinsics - exts, err := scale.Decode(inherentExts, [][]byte{}) + var exts [][]byte + err = scale.Unmarshal(inherentExts, &exts) if err != nil { return nil, err } // apply each inherent extrinsic - for _, ext := range exts.([][]byte) { - in, err := scale.Encode(ext) + for _, ext := range exts { + in, err := scale.Marshal(ext) if err != nil { return nil, err } @@ -328,7 +329,7 @@ func (b *BlockBuilder) buildBlockInherents(slot Slot) ([][]byte, error) { } } - return exts.([][]byte), nil + return exts, nil } func (b *BlockBuilder) addToQueue(txs []*transaction.ValidTransaction) { @@ -352,12 +353,18 @@ func ExtrinsicsToBody(inherents [][]byte, txs []*transaction.ValidTransaction) ( extrinsics := types.BytesArrayToExtrinsics(inherents) for _, tx := range txs { - decExt, err := scale.Decode(tx.Extrinsic, []byte{}) + var decExt []byte + err := scale.Unmarshal(tx.Extrinsic, &decExt) if err != nil { return nil, err } - extrinsics = append(extrinsics, decExt.([]byte)) + extrinsics = append(extrinsics, decExt) } - return types.NewBodyFromExtrinsics(extrinsics) + enc, err := scale.Marshal(extrinsics) + if err != nil { + return nil, err + } + body := types.Body(enc) + return &body, nil } diff --git a/lib/babe/build_test.go b/lib/babe/build_test.go index 73bb4b3165..d18247c833 100644 --- a/lib/babe/build_test.go +++ b/lib/babe/build_test.go @@ -26,8 +26,8 @@ import ( "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto/sr25519" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" + "github.com/ChainSafe/gossamer/pkg/scale" log "github.com/ChainSafe/log15" cscale "github.com/centrifuge/go-substrate-rpc-client/v2/scale" "github.com/centrifuge/go-substrate-rpc-client/v2/signature" @@ -223,11 +223,12 @@ func TestBuildAndApplyExtrinsic(t *testing.T) { // build extrinsic rawMeta, err := babeService.rt.Metadata() require.NoError(t, err) - decoded, err := scale.Decode(rawMeta, []byte{}) + var decoded []byte + err = scale.Unmarshal(rawMeta, []byte{}) require.NoError(t, err) meta := &ctypes.Metadata{} - err = ctypes.DecodeFromBytes(decoded.([]byte), meta) + err = ctypes.DecodeFromBytes(decoded, meta) require.NoError(t, err) rv, err := babeService.rt.Version() diff --git a/lib/babe/errors.go b/lib/babe/errors.go index d8f4b41d94..b7a44cb96f 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -17,8 +17,7 @@ import ( "errors" "fmt" - "github.com/ChainSafe/gossamer/lib/common/optional" - "github.com/ChainSafe/gossamer/lib/scale" + "github.com/ChainSafe/gossamer/pkg/scale" ) var ( @@ -81,82 +80,216 @@ func (e TransactionValidityError) Error() string { return fmt.Sprintf("transaction validity error: %s", e.msg) } -func determineCustomModuleErr(res []byte) error { - if len(res) < 3 { - return errInvalidResult - } - errMsg, err := optional.NewBytes(false, nil).DecodeBytes(res[2:]) - if err != nil { - return err - } - return fmt.Errorf("index: %d code: %d message: %s", res[0], res[1], errMsg.String()) +// A UnmarshalError is when unmarshalling fails +type UnmarshalError struct { + msg string } -func determineDispatchErr(res []byte) error { - switch res[0] { - case 0: - unKnownError, _ := scale.Decode(res[1:], []byte{}) - return &DispatchOutcomeError{fmt.Sprintf("unknown error: %s", string(unKnownError.([]byte)))} - case 1: +func (e UnmarshalError) Error() string { + return fmt.Sprintf("unmarshal error: %s", e.msg) +} + +// Other Some error occurred +type Other string + +// Index Returns VDT index +func (err Other) Index() uint { return 0 } + +// CannotLookup Failed to lookup some data +type CannotLookup struct{} + +// Index Returns VDT index +func (err CannotLookup) Index() uint { return 1 } + +// BadOrigin A bad origin +type BadOrigin struct{} + +// Index Returns VDT index +func (err BadOrigin) Index() uint { return 2 } + +// Module A custom error in a module +type Module struct { + Idx uint8 + Err uint8 + Message *string +} + +// Index Returns VDT index +func (err Module) Index() uint { return 3 } + +func (err Module) string() string { + return fmt.Sprintf("index: %d code: %d message: %x", err.Idx, err.Err, *err.Message) +} + +// ValidityCannotLookup Could not lookup some information that is required to validate the transaction +type ValidityCannotLookup struct{} + +// Index Returns VDT index +func (err ValidityCannotLookup) Index() uint { return 0 } + +// NoUnsignedValidator No validator found for the given unsigned transaction +type NoUnsignedValidator struct{} + +// Index Returns VDT index +func (err NoUnsignedValidator) Index() uint { return 1 } + +// UnknownCustom Any other custom unknown validity that is not covered +type UnknownCustom uint8 + +// Index Returns VDT index +func (err UnknownCustom) Index() uint { return 2 } + +// Call The call of the transaction is not expected +type Call struct{} + +// Index Returns VDT index +func (err Call) Index() uint { return 0 } + +// Payment General error to do with the inability to pay some fees (e.g. account balance too low) +type Payment struct{} + +// Index Returns VDT index +func (err Payment) Index() uint { return 1 } + +// Future General error to do with the transaction not yet being valid (e.g. nonce too high) +type Future struct{} + +// Index Returns VDT index +func (err Future) Index() uint { return 2 } + +// Stale General error to do with the transaction being outdated (e.g. nonce too low) +type Stale struct{} + +// Index Returns VDT index +func (err Stale) Index() uint { return 3 } + +// BadProof General error to do with the transaction’s proofs (e.g. signature) +type BadProof struct{} + +// Index Returns VDT index +func (err BadProof) Index() uint { return 4 } + +// AncientBirthBlock The transaction birth block is ancient +type AncientBirthBlock struct{} + +// Index Returns VDT index +func (err AncientBirthBlock) Index() uint { return 5 } + +// ExhaustsResources The transaction would exhaust the resources of current block +type ExhaustsResources struct{} + +// Index Returns VDT index +func (err ExhaustsResources) Index() uint { return 6 } + +// InvalidCustom Any other custom invalid validity that is not covered +type InvalidCustom uint8 + +// Index Returns VDT index +func (err InvalidCustom) Index() uint { return 7 } + +// BadMandatory An extrinsic with a Mandatory dispatch resulted in Error +type BadMandatory struct{} + +// Index Returns VDT index +func (err BadMandatory) Index() uint { return 8 } + +// MandatoryDispatch A transaction with a mandatory dispatch +type MandatoryDispatch struct{} + +// Index Returns VDT index +func (err MandatoryDispatch) Index() uint { return 9 } + +func determineDispatchErr(vdt scale.VaryingDataType) error { + switch val := vdt.Value().(type) { + case Other: + return &DispatchOutcomeError{fmt.Sprintf("unknown error: %s", val)} + case CannotLookup: return &DispatchOutcomeError{"failed lookup"} - case 2: + case BadOrigin: return &DispatchOutcomeError{"bad origin"} - case 3: - return &DispatchOutcomeError{fmt.Sprintf("custom module error: %s", determineCustomModuleErr(res[1:]))} + case Module: + return &DispatchOutcomeError{fmt.Sprintf("custom module error: %s", val.string())} } + return errInvalidResult } func determineInvalidTxnErr(res []byte) error { - switch res[0] { - case 0: + var c InvalidCustom + vdt := scale.MustNewVaryingDataType(Call{}, Payment{}, Future{}, Stale{}, BadProof{}, AncientBirthBlock{}, + ExhaustsResources{}, c, BadMandatory{}, MandatoryDispatch{}) + err := scale.Unmarshal(res, &vdt) + if err != nil { + return &UnmarshalError{err.Error()} + } + switch val := vdt.Value().(type) { + case Call: return &TransactionValidityError{"call of the transaction is not expected"} - case 1: + case Payment: return &TransactionValidityError{"invalid payment"} - case 2: + case Future: return &TransactionValidityError{"invalid transaction"} - case 3: + case Stale: return &TransactionValidityError{"outdated transaction"} - case 4: + case BadProof: return &TransactionValidityError{"bad proof"} - case 5: + case AncientBirthBlock: return &TransactionValidityError{"ancient birth block"} - case 6: + case ExhaustsResources: return &TransactionValidityError{"exhausts resources"} - case 7: - return &TransactionValidityError{fmt.Sprintf("unknown error: %d", res[1])} - case 8: + case InvalidCustom: + return &TransactionValidityError{fmt.Sprintf("unknown error: %d", val)} + case BadMandatory: return &TransactionValidityError{"mandatory dispatch error"} - case 9: + case MandatoryDispatch: return &TransactionValidityError{"invalid mandatory dispatch"} } return errInvalidResult } func determineUnknownTxnErr(res []byte) error { - switch res[0] { - case 0: + var c UnknownCustom + vdt := scale.MustNewVaryingDataType(ValidityCannotLookup{}, NoUnsignedValidator{}, c) + err := scale.Unmarshal(res, &vdt) + if err != nil { + return &UnmarshalError{err.Error()} + } + switch val := vdt.Value().(type) { + case ValidityCannotLookup: return &TransactionValidityError{"lookup failed"} - case 1: + case NoUnsignedValidator: return &TransactionValidityError{"validator not found"} - case 2: - return &TransactionValidityError{fmt.Sprintf("unknown error: %d", res[1])} + case UnknownCustom: + return &TransactionValidityError{fmt.Sprintf("unknown error: %d", val)} } return errInvalidResult } +// TODO wrap all errors in a Result to unmarshall func determineErr(res []byte) error { switch res[0] { - case 0: // DispatchOutcome - switch res[1] { - case 0: + case 0: + var e Other + vdt := scale.MustNewVaryingDataType(e, CannotLookup{}, BadOrigin{}, Module{}) + r := scale.NewResult(nil, vdt) + err := scale.Unmarshal(res[1:], &r) + if err != nil { + return err + } + + _, err = r.Unwrap() + if err != nil { + switch err := err.(type) { + case scale.WrappedErr: + vdt := err.Err.(scale.VaryingDataType) + return determineDispatchErr(vdt) + default: + return &UnmarshalError{"Unexpected result error type"} + } + } else { return nil - case 1: - return determineDispatchErr(res[2:]) - default: - return errInvalidResult } - case 1: // TransactionValidityError + case 1: switch res[1] { case 0: return determineInvalidTxnErr(res[2:]) diff --git a/lib/babe/errors_test.go b/lib/babe/errors_test.go index 8ec2923c6d..c495cde251 100644 --- a/lib/babe/errors_test.go +++ b/lib/babe/errors_test.go @@ -32,6 +32,16 @@ func TestApplyExtrinsicErrors(t *testing.T) { test: []byte{0, 1, 0, 0x04, 65}, expected: "dispatch outcome error: unknown error: A", }, + { + name: "Dispatch failed lookup", + test: []byte{0, 1, 1}, + expected: "dispatch outcome error: failed lookup", + }, + { + name: "Dispatch bad origin", + test: []byte{0, 1, 2}, + expected: "dispatch outcome error: bad origin", + }, { name: "Invalid txn payment error", test: []byte{1, 0, 1}, diff --git a/lib/transaction/types.go b/lib/transaction/types.go index 9c743c84a3..6d538ab37f 100644 --- a/lib/transaction/types.go +++ b/lib/transaction/types.go @@ -17,10 +17,7 @@ package transaction import ( - "encoding/binary" - "github.com/ChainSafe/gossamer/dot/types" - "github.com/ChainSafe/gossamer/lib/scale" ) // Validity struct see: https://github.com/paritytech/substrate/blob/5420de3face1349a97eb954ae71c5b0b940c31de/core/sr-primitives/src/transaction_validity.rs#L178 @@ -56,35 +53,3 @@ func NewValidTransaction(extrinsic types.Extrinsic, validity *Validity) *ValidTr Validity: validity, } } - -// Encode SCALE encodes the transaction -func (vt *ValidTransaction) Encode() ([]byte, error) { - enc := []byte(vt.Extrinsic) - - buf := make([]byte, 8) - binary.LittleEndian.PutUint64(buf, vt.Validity.Priority) - enc = append(enc, buf...) - - d, err := scale.Encode(vt.Validity.Requires) - if err != nil { - return nil, err - } - enc = append(enc, d...) - - d, err = scale.Encode(vt.Validity.Provides) - if err != nil { - return nil, err - } - enc = append(enc, d...) - - binary.LittleEndian.PutUint64(buf, vt.Validity.Longevity) - enc = append(enc, buf...) - - if vt.Validity.Propagate { - enc = append(enc, 1) - } else { - enc = append(enc, 0) - } - - return enc, nil -} diff --git a/lib/transaction/types_test.go b/lib/transaction/types_test.go index b1e9062a27..d59545dfc8 100644 --- a/lib/transaction/types_test.go +++ b/lib/transaction/types_test.go @@ -3,6 +3,7 @@ package transaction import ( "testing" + "github.com/ChainSafe/gossamer/pkg/scale" "github.com/stretchr/testify/require" ) @@ -18,7 +19,7 @@ func TestValidTransaction_Encode(t *testing.T) { extrinsic := []byte("nootwashere") vt := NewValidTransaction(extrinsic, validity) - enc, err := vt.Encode() + enc, err := scale.Marshal(vt) require.NoError(t, err) if len(enc) == 0 { diff --git a/pkg/scale/decode.go b/pkg/scale/decode.go index f08029485e..68f43405b6 100644 --- a/pkg/scale/decode.go +++ b/pkg/scale/decode.go @@ -240,6 +240,7 @@ func (ds *decodeState) decodeResult(dstv reflect.Value) (err error) { switch rb { case 0x00: tempElem := reflect.New(reflect.TypeOf(res.ok)) + tempElem.Elem().Set(reflect.ValueOf(res.ok)) err = ds.unmarshal(tempElem.Elem()) if err != nil { return @@ -251,6 +252,7 @@ func (ds *decodeState) decodeResult(dstv reflect.Value) (err error) { dstv.Set(reflect.ValueOf(res)) case 0x01: tempElem := reflect.New(reflect.TypeOf(res.err)) + tempElem.Elem().Set(reflect.ValueOf(res.err)) err = ds.unmarshal(tempElem.Elem()) if err != nil { return From 197a7cf36d3b756e0b40cafb18d1ae578157addc Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Fri, 2 Jul 2021 13:19:21 -0600 Subject: [PATCH 2/7] use results for unmarshalling --- lib/babe/errors.go | 85 ++++++++++++++++++++++++---------------------- 1 file changed, 44 insertions(+), 41 deletions(-) diff --git a/lib/babe/errors.go b/lib/babe/errors.go index b7a44cb96f..8027630453 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -214,14 +214,7 @@ func determineDispatchErr(vdt scale.VaryingDataType) error { return errInvalidResult } -func determineInvalidTxnErr(res []byte) error { - var c InvalidCustom - vdt := scale.MustNewVaryingDataType(Call{}, Payment{}, Future{}, Stale{}, BadProof{}, AncientBirthBlock{}, - ExhaustsResources{}, c, BadMandatory{}, MandatoryDispatch{}) - err := scale.Unmarshal(res, &vdt) - if err != nil { - return &UnmarshalError{err.Error()} - } +func determineInvalidTxnErr(vdt scale.VaryingDataType) error { switch val := vdt.Value().(type) { case Call: return &TransactionValidityError{"call of the transaction is not expected"} @@ -247,13 +240,7 @@ func determineInvalidTxnErr(res []byte) error { return errInvalidResult } -func determineUnknownTxnErr(res []byte) error { - var c UnknownCustom - vdt := scale.MustNewVaryingDataType(ValidityCannotLookup{}, NoUnsignedValidator{}, c) - err := scale.Unmarshal(res, &vdt) - if err != nil { - return &UnmarshalError{err.Error()} - } +func determineUnknownTxnErr(vdt scale.VaryingDataType) error { switch val := vdt.Value().(type) { case ValidityCannotLookup: return &TransactionValidityError{"lookup failed"} @@ -265,36 +252,52 @@ func determineUnknownTxnErr(res []byte) error { return errInvalidResult } -// TODO wrap all errors in a Result to unmarshall func determineErr(res []byte) error { - switch res[0] { - case 0: - var e Other - vdt := scale.MustNewVaryingDataType(e, CannotLookup{}, BadOrigin{}, Module{}) - r := scale.NewResult(nil, vdt) - err := scale.Unmarshal(res[1:], &r) - if err != nil { - return err - } + var other Other + var invalidCustom InvalidCustom + var unknownCustom UnknownCustom + + dispatchError := scale.MustNewVaryingDataType(other, CannotLookup{}, BadOrigin{}, Module{}) + invalid := scale.MustNewVaryingDataType(Call{}, Payment{}, Future{}, Stale{}, BadProof{}, AncientBirthBlock{}, + ExhaustsResources{}, invalidCustom, BadMandatory{}, MandatoryDispatch{}) + unknown := scale.MustNewVaryingDataType(ValidityCannotLookup{}, NoUnsignedValidator{}, unknownCustom) - _, err = r.Unwrap() - if err != nil { - switch err := err.(type) { - case scale.WrappedErr: - vdt := err.Err.(scale.VaryingDataType) - return determineDispatchErr(vdt) - default: - return &UnmarshalError{"Unexpected result error type"} + okRes := scale.NewResult(nil, dispatchError) + errRes := scale.NewResult(invalid, unknown) + result := scale.NewResult(okRes, errRes) + + err := scale.Unmarshal(res, &result) + if err != nil { + return err + } + + ok, err := result.Unwrap() + if err != nil { + switch o := err.(type) { + case scale.WrappedErr: + errResult := o.Err.(scale.Result) + ok, err = errResult.Unwrap() + if err != nil { + switch err := err.(type) { + case scale.WrappedErr: + return determineUnknownTxnErr(err.Err.(scale.VaryingDataType)) + } + } else { + return determineInvalidTxnErr(ok.(scale.VaryingDataType)) } - } else { - return nil } - case 1: - switch res[1] { - case 0: - return determineInvalidTxnErr(res[2:]) - case 1: - return determineUnknownTxnErr(res[2:]) + } else { + switch o := ok.(type) { + case scale.Result: + ok, err = o.Unwrap() + if err != nil { + switch err := err.(type) { + case scale.WrappedErr: + return determineDispatchErr(err.Err.(scale.VaryingDataType)) + } + } else { + return nil + } } } return errInvalidResult From fa3332784d5c7a70b5f2bd98dedf4168c3634e59 Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Fri, 2 Jul 2021 14:15:14 -0600 Subject: [PATCH 3/7] clean up code --- lib/babe/errors.go | 26 +++++++------------------- 1 file changed, 7 insertions(+), 19 deletions(-) diff --git a/lib/babe/errors.go b/lib/babe/errors.go index 8027630453..60c59a946f 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -199,7 +199,7 @@ type MandatoryDispatch struct{} // Index Returns VDT index func (err MandatoryDispatch) Index() uint { return 9 } -func determineDispatchErr(vdt scale.VaryingDataType) error { +func determineErrType(vdt scale.VaryingDataType) error { switch val := vdt.Value().(type) { case Other: return &DispatchOutcomeError{fmt.Sprintf("unknown error: %s", val)} @@ -209,13 +209,6 @@ func determineDispatchErr(vdt scale.VaryingDataType) error { return &DispatchOutcomeError{"bad origin"} case Module: return &DispatchOutcomeError{fmt.Sprintf("custom module error: %s", val.string())} - } - - return errInvalidResult -} - -func determineInvalidTxnErr(vdt scale.VaryingDataType) error { - switch val := vdt.Value().(type) { case Call: return &TransactionValidityError{"call of the transaction is not expected"} case Payment: @@ -236,12 +229,6 @@ func determineInvalidTxnErr(vdt scale.VaryingDataType) error { return &TransactionValidityError{"mandatory dispatch error"} case MandatoryDispatch: return &TransactionValidityError{"invalid mandatory dispatch"} - } - return errInvalidResult -} - -func determineUnknownTxnErr(vdt scale.VaryingDataType) error { - switch val := vdt.Value().(type) { case ValidityCannotLookup: return &TransactionValidityError{"lookup failed"} case NoUnsignedValidator: @@ -249,6 +236,7 @@ func determineUnknownTxnErr(vdt scale.VaryingDataType) error { case UnknownCustom: return &TransactionValidityError{fmt.Sprintf("unknown error: %d", val)} } + return errInvalidResult } @@ -268,7 +256,7 @@ func determineErr(res []byte) error { err := scale.Unmarshal(res, &result) if err != nil { - return err + return &UnmarshalError{err.Error()} } ok, err := result.Unwrap() @@ -280,20 +268,20 @@ func determineErr(res []byte) error { if err != nil { switch err := err.(type) { case scale.WrappedErr: - return determineUnknownTxnErr(err.Err.(scale.VaryingDataType)) + return determineErrType(err.Err.(scale.VaryingDataType)) } } else { - return determineInvalidTxnErr(ok.(scale.VaryingDataType)) + return determineErrType(ok.(scale.VaryingDataType)) } } } else { switch o := ok.(type) { case scale.Result: - ok, err = o.Unwrap() + _, err = o.Unwrap() if err != nil { switch err := err.(type) { case scale.WrappedErr: - return determineDispatchErr(err.Err.(scale.VaryingDataType)) + return determineErrType(err.Err.(scale.VaryingDataType)) } } else { return nil From 07bdba26f39367cbc74ff0b5cba775d49ad6ba78 Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Fri, 2 Jul 2021 14:24:22 -0600 Subject: [PATCH 4/7] fix switch to pass checks --- lib/babe/errors.go | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/lib/babe/errors.go b/lib/babe/errors.go index 60c59a946f..c4635082a0 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -269,10 +269,14 @@ func determineErr(res []byte) error { switch err := err.(type) { case scale.WrappedErr: return determineErrType(err.Err.(scale.VaryingDataType)) + default: + return errInvalidResult } } else { return determineErrType(ok.(scale.VaryingDataType)) } + default: + return errInvalidResult } } else { switch o := ok.(type) { @@ -282,11 +286,14 @@ func determineErr(res []byte) error { switch err := err.(type) { case scale.WrappedErr: return determineErrType(err.Err.(scale.VaryingDataType)) + default: + return errInvalidResult } } else { return nil } + default: + return errInvalidResult } } - return errInvalidResult } From b170d62cede99a0fd49b4f73178f4dab0ddf3e9f Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Mon, 5 Jul 2021 14:14:05 -0600 Subject: [PATCH 5/7] integrate scale into dot/sync --- dot/sync/test_helpers.go | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/dot/sync/test_helpers.go b/dot/sync/test_helpers.go index 4345afcb7f..b424b277c5 100644 --- a/dot/sync/test_helpers.go +++ b/dot/sync/test_helpers.go @@ -32,9 +32,9 @@ import ( "github.com/ChainSafe/gossamer/lib/runtime" rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage" "github.com/ChainSafe/gossamer/lib/runtime/wasmer" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" "github.com/ChainSafe/gossamer/lib/trie" + "github.com/ChainSafe/gossamer/pkg/scale" log "github.com/ChainSafe/log15" "github.com/stretchr/testify/require" @@ -166,10 +166,11 @@ func BuildBlock(t *testing.T, instance runtime.Instance, parent *types.Header, e require.NoError(t, err) // decode inherent extrinsics - exts, err := scale.Decode(inherentExts, [][]byte{}) + var exts [][]byte + err = scale.Unmarshal(inherentExts, &exts) require.NoError(t, err) - inExt := exts.([][]byte) + inExt := exts var body *types.Body if ext != nil { @@ -191,7 +192,7 @@ func BuildBlock(t *testing.T, instance runtime.Instance, parent *types.Header, e // apply each inherent extrinsic for _, ext := range inExt { - in, err := scale.Encode(ext) //nolint + in, err := scale.Marshal(ext) //nolint require.NoError(t, err) ret, err := instance.ApplyExtrinsic(in) From 295eda366931ec8f02fcb4d08237cd6cb5eeac3b Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Mon, 5 Jul 2021 15:03:23 -0600 Subject: [PATCH 6/7] cr feedback --- lib/babe/errors.go | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/lib/babe/errors.go b/lib/babe/errors.go index c4635082a0..e74f565ac2 100644 --- a/lib/babe/errors.go +++ b/lib/babe/errors.go @@ -60,6 +60,19 @@ var ( errNilRuntime = errors.New("runtime is nil") errInvalidResult = errors.New("invalid error value") errNoEpochData = errors.New("no epoch data found for upcoming epoch") + + other Other + invalidCustom InvalidCustom + unknownCustom UnknownCustom + + dispatchError = scale.MustNewVaryingDataType(other, CannotLookup{}, BadOrigin{}, Module{}) + invalid = scale.MustNewVaryingDataType(Call{}, Payment{}, Future{}, Stale{}, BadProof{}, AncientBirthBlock{}, + ExhaustsResources{}, invalidCustom, BadMandatory{}, MandatoryDispatch{}) + unknown = scale.MustNewVaryingDataType(ValidityCannotLookup{}, NoUnsignedValidator{}, unknownCustom) + + okRes = scale.NewResult(nil, dispatchError) + errRes = scale.NewResult(invalid, unknown) + result = scale.NewResult(okRes, errRes) ) // A DispatchOutcomeError is outcome of dispatching the extrinsic @@ -80,7 +93,7 @@ func (e TransactionValidityError) Error() string { return fmt.Sprintf("transaction validity error: %s", e.msg) } -// A UnmarshalError is when unmarshalling fails +// UnmarshalError occurs when unmarshalling fails type UnmarshalError struct { msg string } @@ -241,19 +254,6 @@ func determineErrType(vdt scale.VaryingDataType) error { } func determineErr(res []byte) error { - var other Other - var invalidCustom InvalidCustom - var unknownCustom UnknownCustom - - dispatchError := scale.MustNewVaryingDataType(other, CannotLookup{}, BadOrigin{}, Module{}) - invalid := scale.MustNewVaryingDataType(Call{}, Payment{}, Future{}, Stale{}, BadProof{}, AncientBirthBlock{}, - ExhaustsResources{}, invalidCustom, BadMandatory{}, MandatoryDispatch{}) - unknown := scale.MustNewVaryingDataType(ValidityCannotLookup{}, NoUnsignedValidator{}, unknownCustom) - - okRes := scale.NewResult(nil, dispatchError) - errRes := scale.NewResult(invalid, unknown) - result := scale.NewResult(okRes, errRes) - err := scale.Unmarshal(res, &result) if err != nil { return &UnmarshalError{err.Error()} From 3f02bf3d7c80cd5d993d057e42178eefea4441ff Mon Sep 17 00:00:00 2001 From: jimjbrettj Date: Mon, 5 Jul 2021 15:29:03 -0600 Subject: [PATCH 7/7] merge --- lib/babe/build_test.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/lib/babe/build_test.go b/lib/babe/build_test.go index 953689d153..b75825f719 100644 --- a/lib/babe/build_test.go +++ b/lib/babe/build_test.go @@ -27,8 +27,8 @@ import ( "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" + "github.com/ChainSafe/gossamer/pkg/scale" log "github.com/ChainSafe/log15" cscale "github.com/centrifuge/go-substrate-rpc-client/v3/scale" @@ -90,11 +90,13 @@ func createTestExtrinsic(t *testing.T, rt runtime.Instance, genHash common.Hash, rawMeta, err := rt.Metadata() require.NoError(t, err) - decoded, err := scale.Decode(rawMeta, []byte{}) + //decoded, err := scale.Decode(rawMeta, []byte{}) + var decoded []byte + err = scale.Unmarshal(rawMeta, &decoded) require.NoError(t, err) meta := &ctypes.Metadata{} - err = ctypes.DecodeFromBytes(decoded.([]byte), meta) + err = ctypes.DecodeFromBytes(decoded, meta) require.NoError(t, err) rv, err := rt.Version()