diff --git a/dot/core/service_test.go b/dot/core/service_test.go index 53bf84cfcf..965aa6a5d7 100644 --- a/dot/core/service_test.go +++ b/dot/core/service_test.go @@ -33,12 +33,12 @@ import ( "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/keystore" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/runtime/extrinsic" runtimemocks "github.com/ChainSafe/gossamer/lib/runtime/mocks" "github.com/ChainSafe/gossamer/lib/runtime/storage" "github.com/ChainSafe/gossamer/lib/runtime/wasmer" "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/mock" "github.com/stretchr/testify/require" @@ -287,9 +287,10 @@ func TestHandleChainReorg_WithReorg_Transactions(t *testing.T) { addTestBlocksToState(t, height, s.blockState.(*state.BlockState)) // create extrinsic - ext := extrinsic.NewIncludeDataExt([]byte("nootwashere")) - tx, err := ext.Encode() + enc, err := scale.Marshal([]byte("nootwashere")) require.NoError(t, err) + // we prefix with []byte{2} here since that's the enum index for the old IncludeDataExt extrinsic + tx := append([]byte{2}, enc...) bhash := s.blockState.BestBlockHash() rt, err := s.blockState.GetRuntime(&bhash) diff --git a/dot/rpc/modules/api_mocks.go b/dot/rpc/modules/api_mocks.go index 46885f58f7..613300810e 100644 --- a/dot/rpc/modules/api_mocks.go +++ b/dot/rpc/modules/api_mocks.go @@ -56,8 +56,8 @@ func NewMockCoreAPI() *modulesmocks.MockCoreAPI { } // NewMockVersion creates and returns an runtime Version interface mock -func NewMockVersion() *runtimemocks.MockVersion { - m := new(runtimemocks.MockVersion) +func NewMockVersion() *runtimemocks.Version { + m := new(runtimemocks.Version) m.On("SpecName").Return([]byte(`mock-spec`)) m.On("ImplName").Return(nil) m.On("AuthoringVersion").Return(uint32(0)) diff --git a/dot/rpc/modules/state.go b/dot/rpc/modules/state.go index 6944b8396f..c5443627ae 100644 --- a/dot/rpc/modules/state.go +++ b/dot/rpc/modules/state.go @@ -443,7 +443,7 @@ func (*StateModule) SubscribeStorage(_ *http.Request, _ *StateStorageQueryRangeR } // ConvertAPIs runtime.APIItems to []interface -func ConvertAPIs(in []*runtime.APIItem) []interface{} { +func ConvertAPIs(in []runtime.APIItem) []interface{} { ret := make([]interface{}, 0) for _, item := range in { encStr := hex.EncodeToString(item.Name[:]) diff --git a/dot/state/block_notify_test.go b/dot/state/block_notify_test.go index c9b1e366a7..9df42600a7 100644 --- a/dot/state/block_notify_test.go +++ b/dot/state/block_notify_test.go @@ -182,8 +182,8 @@ func TestService_RegisterUnRegisterConcurrentCalls(t *testing.T) { } // NewMockVersion creates and returns an runtime Version interface mock -func NewMockVersion(specVer uint32) *runtimemocks.MockVersion { - m := new(runtimemocks.MockVersion) +func NewMockVersion(specVer uint32) *runtimemocks.Version { + m := new(runtimemocks.Version) m.On("SpecName").Return([]byte(`mock-spec`)) m.On("ImplName").Return(nil) m.On("AuthoringVersion").Return(uint32(0)) diff --git a/lib/runtime/extrinsic/extrinsic.go b/lib/runtime/extrinsic/extrinsic.go deleted file mode 100644 index cd42cc939d..0000000000 --- a/lib/runtime/extrinsic/extrinsic.go +++ /dev/null @@ -1,351 +0,0 @@ -package extrinsic - -import ( - "encoding/binary" - "errors" - "io" - "math/big" - - "github.com/ChainSafe/gossamer/lib/common" - "github.com/ChainSafe/gossamer/lib/common/optional" - "github.com/ChainSafe/gossamer/lib/crypto/sr25519" - "github.com/ChainSafe/gossamer/lib/scale" -) - -//nolint -const ( - AuthoritiesChangeType = 0 - TransferType = 1 - IncludeDataType = 2 - StorageChangeType = 3 - // TODO: implement when storage changes trie is completed. Also add changesTrieConfig field in genesis. - //ChangesTrieConfigUpdateType = 4 -) - -// Extrinsic represents a runtime Extrinsic -type Extrinsic interface { - Type() int - Encode() ([]byte, error) - Decode(r io.Reader) error -} - -// DecodeExtrinsic decodes an Extrinsic from a Reader -func DecodeExtrinsic(r io.Reader) (Extrinsic, error) { - typ, err := common.ReadByte(r) - if err != nil { - return nil, err - } - - switch typ { - case AuthoritiesChangeType: - ext := new(AuthoritiesChangeExt) - return ext, ext.Decode(r) - case TransferType: - ext := new(TransferExt) - return ext, ext.Decode(r) - case IncludeDataType: - ext := new(IncludeDataExt) - return ext, ext.Decode(r) - case StorageChangeType: - ext := new(StorageChangeExt) - return ext, ext.Decode(r) - default: - return nil, errors.New("cannot decode invalid extrinsic type") - } -} - -// AuthoritiesChangeExt represents an Extrinsic::AuthoritiesChange -type AuthoritiesChangeExt struct { - authorityIDs [][32]byte -} - -// NewAuthoritiesChangeExt returns an AuthoritiesChangeExt -func NewAuthoritiesChangeExt(authorityIDs [][32]byte) *AuthoritiesChangeExt { - return &AuthoritiesChangeExt{ - authorityIDs: authorityIDs, - } -} - -// Type returns AuthoritiesChangeType -func (e *AuthoritiesChangeExt) Type() int { - return AuthoritiesChangeType -} - -// Encode returns the SCALE encoding of the AuthoritiesChangeExt -func (e *AuthoritiesChangeExt) Encode() ([]byte, error) { - // TODO: scale should work with arrays of [32]byte - enc, err := scale.Encode(big.NewInt(int64(len(e.authorityIDs)))) - if err != nil { - return nil, err - } - - for _, id := range e.authorityIDs { - enc = append(enc, id[:]...) - } - - return append([]byte{AuthoritiesChangeType}, enc...), nil -} - -// Decode decodes the SCALE encoding into a AuthoritiesChangeExt -func (e *AuthoritiesChangeExt) Decode(r io.Reader) error { - sd := &scale.Decoder{Reader: r} - d, err := sd.Decode(e.authorityIDs) - if err != nil { - return err - } - - e.authorityIDs = d.([][32]byte) - return nil -} - -// Transfer represents a runtime Transfer -type Transfer struct { - from [32]byte - to [32]byte - amount uint64 - nonce uint64 -} - -// NewTransfer returns a Transfer -func NewTransfer(from, to [32]byte, amount, nonce uint64) *Transfer { - return &Transfer{ - from: from, - to: to, - amount: amount, - nonce: nonce, - } -} - -// Encode returns the SCALE encoding of the Transfer -func (t *Transfer) Encode() ([]byte, error) { - enc := []byte{} - - buf := make([]byte, 8) - - enc = append(enc, t.from[:]...) - enc = append(enc, t.to[:]...) - - binary.LittleEndian.PutUint64(buf, t.amount) - enc = append(enc, buf...) - - binary.LittleEndian.PutUint64(buf, t.nonce) - enc = append(enc, buf...) - - return enc, nil -} - -// Decode decodes the SCALE encoding into a Transfer -func (t *Transfer) Decode(r io.Reader) (err error) { - t.from, err = common.ReadHash(r) - if err != nil { - return err - } - - t.to, err = common.ReadHash(r) - if err != nil { - return err - } - - t.amount, err = common.ReadUint64(r) - if err != nil { - return err - } - - t.nonce, err = common.ReadUint64(r) - if err != nil { - return err - } - - return nil -} - -// AsSignedExtrinsic returns a TransferExt that includes the transfer and a signature. -func (t *Transfer) AsSignedExtrinsic(key *sr25519.PrivateKey) (*TransferExt, error) { - enc, err := t.Encode() - if err != nil { - return nil, err - } - - sig, err := key.Sign(enc) - if err != nil { - return nil, err - } - - sigb := [64]byte{} - copy(sigb[:], sig) - - return NewTransferExt(t, sigb), nil -} - -// TransferExt represents an Extrinsic::Transfer -type TransferExt struct { - transfer *Transfer - signature [sr25519.SignatureLength]byte -} - -// NewTransferExt returns a TransferExt -func NewTransferExt(transfer *Transfer, signature [sr25519.SignatureLength]byte) *TransferExt { - return &TransferExt{ - transfer: transfer, - signature: signature, - } -} - -// Type returns TransferType -func (e *TransferExt) Type() int { - return TransferType -} - -// Encode returns the SCALE encoding of the TransferExt -func (e *TransferExt) Encode() ([]byte, error) { - enc := []byte{TransferType} - - tenc, err := e.transfer.Encode() - if err != nil { - return nil, err - } - - enc = append(enc, tenc...) - enc = append(enc, e.signature[:]...) - - return enc, nil -} - -// Decode decodes the SCALE encoding into a TransferExt -func (e *TransferExt) Decode(r io.Reader) error { - e.transfer = new(Transfer) - err := e.transfer.Decode(r) - if err != nil { - return err - } - - _, err = r.Read(e.signature[:]) - if err != nil { - return err - } - - return nil -} - -// IncludeDataExt represents an Extrinsic::IncludeData -type IncludeDataExt struct { - data []byte -} - -// NewIncludeDataExt returns a IncludeDataExt -func NewIncludeDataExt(data []byte) *IncludeDataExt { - return &IncludeDataExt{ - data: data, - } -} - -// Type returns IncludeDataType -func (e *IncludeDataExt) Type() int { - return IncludeDataType -} - -// Encode returns the SCALE encoding of the IncludeDataExt -func (e *IncludeDataExt) Encode() ([]byte, error) { - enc, err := scale.Encode(e.data) - if err != nil { - return nil, err - } - - return append([]byte{IncludeDataType}, enc...), nil -} - -// Decode decodes the SCALE encoding into a IncludeDataExt -func (e *IncludeDataExt) Decode(r io.Reader) error { - sd := &scale.Decoder{Reader: r} - d, err := sd.Decode(e.data) - if err != nil { - return err - } - - e.data = d.([]byte) - return nil -} - -// StorageChangeExt represents an Extrinsic::StorageChange -type StorageChangeExt struct { - key []byte - value *optional.Bytes -} - -// NewStorageChangeExt returns a StorageChangesExt -func NewStorageChangeExt(key []byte, value *optional.Bytes) *StorageChangeExt { - return &StorageChangeExt{ - key: key, - value: value, - } -} - -// Type returns StorageChangeType -func (e *StorageChangeExt) Type() int { - return StorageChangeType -} - -// Encode returns the SCALE encoding of the StorageChangeExt -func (e *StorageChangeExt) Encode() ([]byte, error) { - enc := []byte{StorageChangeType} - - d, err := scale.Encode(e.key) - if err != nil { - return nil, err - } - - enc = append(enc, d...) - - if e.value.Exists() { - enc = append(enc, 1) - d, err = scale.Encode(e.value.Value()) - if err != nil { - return nil, err - } - - enc = append(enc, d...) - } else { - enc = append(enc, 0) - } - - return enc, nil -} - -// Decode decodes the SCALE encoding into a StorageChangeExt -func (e *StorageChangeExt) Decode(r io.Reader) error { - sd := &scale.Decoder{Reader: r} - d, err := sd.Decode([]byte{}) - if err != nil { - return err - } - - e.key = d.([]byte) - - exists, err := common.ReadByte(r) - if err != nil { - return err - } - - if exists == 1 { - d, err = sd.Decode([]byte{}) - if err != nil { - return err - } - - e.value = optional.NewBytes(true, d.([]byte)) - } else { - e.value = optional.NewBytes(false, nil) - } - - return nil -} - -// Key returns the extrinsic's key -func (e *StorageChangeExt) Key() []byte { - return e.key -} - -// Value returns the extrinsic's value -func (e *StorageChangeExt) Value() *optional.Bytes { - return e.value -} diff --git a/lib/runtime/extrinsic/extrinsic_test.go b/lib/runtime/extrinsic/extrinsic_test.go deleted file mode 100644 index 615e308202..0000000000 --- a/lib/runtime/extrinsic/extrinsic_test.go +++ /dev/null @@ -1,163 +0,0 @@ -package extrinsic - -import ( - "bytes" - "encoding/binary" - "testing" - - "github.com/ChainSafe/gossamer/lib/common" - "github.com/ChainSafe/gossamer/lib/common/optional" - "github.com/ChainSafe/gossamer/lib/crypto/sr25519" - "github.com/ChainSafe/gossamer/lib/keystore" - - "github.com/stretchr/testify/require" -) - -func TestAuthoritiesChangeExt_Encode(t *testing.T) { - t.Skip() - - // TODO: scale isn't working for arrays of [32]byte - kp, err := sr25519.GenerateKeypair() - require.NoError(t, err) - - pub := kp.Public().Encode() - pubk := [32]byte{} - copy(pubk[:], pub) - - authorities := [][32]byte{pubk} - - ext := NewAuthoritiesChangeExt(authorities) - - enc, err := ext.Encode() - require.NoError(t, err) - - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - require.Equal(t, ext, res) -} - -var alice, _ = common.HexToHash("0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d") -var bob, _ = common.HexToHash("0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22") - -func TestTransfer_AsSignedExtrinsic(t *testing.T) { - kr, err := keystore.NewSr25519Keyring() - require.NoError(t, err) - - transfer := NewTransfer(alice, bob, 1000, 1) - _, err = transfer.AsSignedExtrinsic(kr.Alice().Private().(*sr25519.PrivateKey)) - require.NoError(t, err) -} - -func TestTransferExt_Encode(t *testing.T) { - transfer := NewTransfer(alice, bob, 1000, 1) - sig := [64]byte{} - ext := NewTransferExt(transfer, sig) - - enc, err := ext.Encode() - require.NoError(t, err) - - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - require.Equal(t, ext, res) -} - -func TestTransferExt_Decode(t *testing.T) { - // from substrate test runtime - enc := []byte{1, 212, 53, 147, 199, 21, 253, 211, 28, 97, 20, 26, 189, 4, 169, 159, 214, 130, 44, 133, 88, 133, 76, 205, 227, 154, 86, 132, 231, 165, 109, 162, 125, 144, 181, 171, 32, 92, 105, 116, 201, 234, 132, 27, 230, 136, 134, 70, 51, 220, 156, 168, 163, 87, 132, 62, 234, 207, 35, 20, 100, 153, 101, 254, 34, 69, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 114, 13, 234, 84, 192, 135, 6, 254, 94, 142, 207, 135, 126, 177, 25, 27, 198, 159, 97, 165, 198, 228, 77, 117, 113, 253, 247, 97, 221, 110, 47, 9, 87, 209, 62, 254, 81, 200, 217, 45, 214, 53, 170, 217, 160, 137, 43, 78, 183, 89, 45, 2, 64, 120, 114, 100, 116, 148, 247, 92, 234, 57, 255, 139} - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - amount := binary.LittleEndian.Uint64([]byte{69, 0, 0, 0, 0, 0, 0, 0}) - nonce := binary.LittleEndian.Uint64([]byte{1, 0, 0, 0, 0, 0, 0, 0}) - - sig, _ := common.HexToBytes("0x720dea54c08706fe5e8ecf877eb1191bc69f61a5c6e44d7571fdf761dd6e2f0957d13efe51c8d92dd635aad9a0892b4eb7592d02407872647494f75cea39ff8b") - sigb := [sr25519.SignatureLength]byte{} - copy(sigb[:], sig) - - expected := &TransferExt{ - transfer: &Transfer{ - from: alice, - to: bob, - amount: amount, - nonce: nonce, - }, - signature: sigb, - } - - var transfer *TransferExt - var ok bool - - if transfer, ok = res.(*TransferExt); !ok { - t.Fatal("Fail: got wrong extrinsic type") - } - - require.Equal(t, expected, transfer) -} - -func TestIncludeDataExt_Encode(t *testing.T) { - data := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} - ext := NewIncludeDataExt(data) - - enc, err := ext.Encode() - require.NoError(t, err) - - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - require.Equal(t, ext, res) -} - -func TestIncludeDataExt_Decode(t *testing.T) { - enc := []byte{2, 32, 111, 0, 0, 0, 0, 0, 0, 0} - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - expected := &IncludeDataExt{ - data: []byte{111, 0, 0, 0, 0, 0, 0, 0}, - } - - require.Equal(t, expected, res) -} - -func TestStorageChangeExt_Encode(t *testing.T) { - key := []byte("noot") - value := optional.NewBytes(true, []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}) - ext := NewStorageChangeExt(key, value) - - enc, err := ext.Encode() - require.NoError(t, err) - - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - require.Equal(t, ext, res) -} - -func TestStorageChangeExt_Decode(t *testing.T) { - enc := []byte{3, 16, 77, 1, 2, 3, 1, 4, 99} - r := &bytes.Buffer{} - r.Write(enc) - res, err := DecodeExtrinsic(r) - require.NoError(t, err) - - expected := &StorageChangeExt{ - key: []byte{77, 1, 2, 3}, - value: optional.NewBytes(true, []byte{99}), - } - - require.Equal(t, expected, res) -} diff --git a/lib/runtime/extrinsic/unchecked_extrinsic.go b/lib/runtime/extrinsic/unchecked_extrinsic.go deleted file mode 100644 index f95836bf17..0000000000 --- a/lib/runtime/extrinsic/unchecked_extrinsic.go +++ /dev/null @@ -1,226 +0,0 @@ -// Copyright 2020 ChainSafe Systems (ON) Corp. -// This file is part of gossamer. -// -// The gossamer 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 gossamer 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 gossamer library. If not, see . -package extrinsic - -import ( - "math/big" - - "github.com/ChainSafe/gossamer/lib/crypto" - "github.com/ChainSafe/gossamer/lib/scale" -) - -// Pallet index for module extrinsic is calling -type Pallet byte - -// consts for node_runtime Pallets -const ( - System Pallet = iota - Utility - Babe - Timestamp - Authorship - Indices - Balances - Staking - Session -) - -// PalletFunction for function index within pallet -type PalletFunction byte - -// pallet_balances function index -const ( - PB_Transfer PalletFunction = iota - PB_Set_balance - PB_Force_transfer - PB_Transfer_keep_alive -) - -// pallet_system function index -const ( - SYS_fill_block PalletFunction = iota - SYS_remark - SYS_set_heap_pages - SYS_set_code - SYS_set_storage - SYS_kill_storage - SYS_kill_prefix -) - -// session function index -const ( - SESS_set_keys PalletFunction = iota -) - -// Function struct to represent extrinsic call function -type Function struct { - Pall Pallet - PallFunc PalletFunction - FuncCallData interface{} -} - -// Signature struct to represent signature parts -type Signature struct { - Address []byte - Sig []byte - Extra []byte -} - -// UncheckedExtrinsic generic implementation of pre-verification extrinsic -type UncheckedExtrinsic struct { - Signature Signature - Function Function -} - -// CreateUncheckedExtrinsic builds UncheckedExtrinsic given function interface, index, genesisHash and Keypair -func CreateUncheckedExtrinsic(fnc *Function, index *big.Int, signer crypto.Keypair, additional interface{}) (*UncheckedExtrinsic, error) { - extra := struct { - Era [1]byte // TODO determine how Era is determined (Immortal is [1]byte{0}, Mortal is [2]byte{X, 0}, Need to determine how X is calculated) - Nonce *big.Int - ChargeTransactionPayment *big.Int - }{ - [1]byte{0}, - index, - big.NewInt(0), - } - - payload := buildPayload(fnc, extra, additional) - payloadEnc, err := payload.Encode() - if err != nil { - return nil, err - } - - signedPayload, err := signer.Sign(payloadEnc) - if err != nil { - return nil, err - } - - extraEnc, err := scale.Encode(extra) - if err != nil { - return nil, err - } - // TODO this changes mortality, determine how to set - //extraEnc = append([]byte{22}, extraEnc...) - - signature := Signature{ - Address: signer.Public().Encode(), - Sig: signedPayload, - Extra: extraEnc, - } - ux := &UncheckedExtrinsic{ - Function: *fnc, - Signature: signature, - } - return ux, nil -} - -// CreateUncheckedExtrinsicUnsigned to build unsigned extrinsic -func CreateUncheckedExtrinsicUnsigned(fnc *Function) (*UncheckedExtrinsic, error) { - ux := &UncheckedExtrinsic{ - Function: *fnc, - } - return ux, nil -} - -// Encode scale encode UncheckedExtrinsic -func (ux *UncheckedExtrinsic) Encode() ([]byte, error) { - // TODO deal with signed/unsigned encoding - enc := []byte{} - sigEnc, err := ux.Signature.Encode() - if err != nil { - return nil, err - } - enc = append(enc, sigEnc...) - - fncEnc, err := ux.Function.Encode() - if err != nil { - return nil, err - } - enc = append(enc, fncEnc...) - - sEnc, err := scale.Encode(enc) - if err != nil { - return nil, err - } - - return sEnc, nil -} - -// Encode to encode Signature type -func (s *Signature) Encode() ([]byte, error) { - enc := []byte{} - //TODO determine why this 255 byte is here - addEnc, err := scale.Encode(append([]byte{255}, s.Address...)) - if err != nil { - return nil, err - } - enc = append(enc, addEnc...) - // TODO find better way to handle keytype - enc = append(enc, []byte{1}...) //this seems to represent signing key type 0 - Ed25519, 1 - Sr22219, 2 - Ecdsa - enc = append(enc, s.Sig...) - enc = append(enc, s.Extra...) - return enc, nil -} - -// Encode scale encode the UncheckedExtrinsic -func (f *Function) Encode() ([]byte, error) { - enc := []byte{byte(f.Pall), byte(f.PallFunc)} - dataEnc, err := scale.Encode(f.FuncCallData) - if err != nil { - return nil, err - } - return append(enc, dataEnc...), nil -} - -// payload struct to hold items that need to be signed -type payload struct { - Function Function - Extra interface{} - AdditionSigned interface{} -} - -func buildPayload(fnc *Function, extra, additional interface{}) payload { - return payload{ - Function: *fnc, - Extra: extra, - AdditionSigned: additional, - } -} - -// Encode scale encode SignedPayload -func (sp *payload) Encode() ([]byte, error) { - enc, err := sp.Function.Encode() - if err != nil { - return nil, err - } - - exEnc, err := scale.Encode(sp.Extra) - if err != nil { - return nil, err - } - - // TODO this changes mortality, determine how to set - //exEnc = append([]byte{22}, exEnc...) // testing era - enc = append(enc, exEnc...) - - addEnc, err := scale.Encode(sp.AdditionSigned) - if err != nil { - return nil, err - } - enc = append(enc, addEnc...) - - return enc, nil -} diff --git a/lib/runtime/extrinsic/unchecked_extrinsic_test.go b/lib/runtime/extrinsic/unchecked_extrinsic_test.go deleted file mode 100644 index 089dce66c3..0000000000 --- a/lib/runtime/extrinsic/unchecked_extrinsic_test.go +++ /dev/null @@ -1,107 +0,0 @@ -// Copyright 2020 ChainSafe Systems (ON) Corp. -// This file is part of gossamer. -// -// The gossamer 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 gossamer 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 gossamer library. If not, see . -package extrinsic - -import ( - "fmt" - "log" - "math/big" - "os" - "testing" - - "github.com/ChainSafe/gossamer/lib/common" - "github.com/ChainSafe/gossamer/lib/keystore" - "github.com/stretchr/testify/require" -) - -var kr keystore.Sr25519Keyring - -type testTransCall struct { - Type byte - To [32]byte - Amt *big.Int -} - -var testTransFunc *Function - -func TestCreateUncheckedExtrinsic(t *testing.T) { - var nonce uint64 - signer := kr.Alice() - genesisHash := common.Hash{} - additional := struct { - SpecVersion uint32 - GenesisHash common.Hash - CurrentBlockHash common.Hash - }{193, genesisHash, genesisHash} - - ux, err := CreateUncheckedExtrinsic(testTransFunc, new(big.Int).SetUint64(nonce), signer, additional) - require.NoError(t, err) - - require.Equal(t, testTransFunc, &ux.Function) - require.Equal(t, signer.Public().Encode(), ux.Signature.Address) - require.Equal(t, 64, len(ux.Signature.Sig)) -} - -func TestCreateUncheckedExtrinsicUnsigned(t *testing.T) { - ux, err := CreateUncheckedExtrinsicUnsigned(createFunction()) - require.NoError(t, err) - require.Equal(t, testTransFunc, &ux.Function) -} - -func TestUncheckedExtrinsic_Encode(t *testing.T) { - var nonce uint64 - signer := kr.Alice() - genesisHash := common.Hash{} - additional := struct { - SpecVersion uint32 - GenesisHash common.Hash - CurrentBlockHash common.Hash - }{193, genesisHash, genesisHash} - - ux, err := CreateUncheckedExtrinsic(testTransFunc, new(big.Int).SetUint64(nonce), signer, additional) - require.NoError(t, err) - - uxEnc, err := ux.Encode() - require.NoError(t, err) - - require.Equal(t, 141, len(uxEnc)) -} - -func TestMain(m *testing.M) { - k, err := keystore.NewSr25519Keyring() - if err != nil { - log.Fatal(fmt.Errorf("error initialising keyring")) - } - kr = *k - testTransFunc = createFunction() - // Start all tests - code := m.Run() - os.Exit(code) -} - -func createFunction() *Function { - testCallData := testTransCall{ - Type: byte(255), - To: [32]byte{}, - Amt: big.NewInt(1000), - } - - return &Function{ - Pall: Balances, - PallFunc: PB_Transfer, - FuncCallData: testCallData, - } -} diff --git a/lib/runtime/life/exports.go b/lib/runtime/life/exports.go index 6d0e3728b6..a25475853b 100644 --- a/lib/runtime/life/exports.go +++ b/lib/runtime/life/exports.go @@ -3,13 +3,12 @@ package life import ( "bytes" "fmt" - "io" + "strings" "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" - scale2 "github.com/ChainSafe/gossamer/pkg/scale" + "github.com/ChainSafe/gossamer/pkg/scale" ) // ValidateTransaction runs the extrinsic through runtime function TaggedTransactionQueue_validate_transaction and returns *Validity @@ -24,8 +23,7 @@ func (in *Instance) ValidateTransaction(e types.Extrinsic) (*transaction.Validit } v := transaction.NewValidity(0, [][]byte{{}}, [][]byte{{}}, 0, false) - _, err = scale.Decode(ret[1:], v) - + err = scale.Unmarshal(ret[1:], v) return v, err } @@ -38,12 +36,14 @@ func (in *Instance) Version() (runtime.Version, error) { version := &runtime.VersionData{} err = version.Decode(res) - if err == io.EOF { - // TODO: kusama seems to use the legacy version format - lversion := &runtime.LegacyVersionData{} - err = lversion.Decode(res) - return lversion, err - } else if err != nil { + // error comes from scale now, so do a string check + if err != nil { + if strings.Contains(err.Error(), "EOF") { + // TODO: kusama seems to use the legacy version format + lversion := &runtime.LegacyVersionData{} + err = lversion.Decode(res) + return lversion, err + } return nil, err } @@ -63,7 +63,7 @@ func (in *Instance) BabeConfiguration() (*types.BabeConfiguration, error) { } bc := new(types.BabeConfiguration) - _, err = scale.Decode(data, bc) + err = scale.Unmarshal(data, bc) if err != nil { return nil, err } @@ -78,17 +78,18 @@ func (in *Instance) GrandpaAuthorities() ([]types.Authority, error) { return nil, err } - adr, err := scale.Decode(ret, []types.GrandpaAuthoritiesRaw{}) + var gar []types.GrandpaAuthoritiesRaw + err = scale.Unmarshal(ret, &gar) if err != nil { return nil, err } - return types.GrandpaAuthoritiesRawToAuthorities(adr.([]types.GrandpaAuthoritiesRaw)) + return types.GrandpaAuthoritiesRawToAuthorities(gar) } // InitializeBlock calls runtime API function Core_initialise_block func (in *Instance) InitializeBlock(header *types.Header) error { - encodedHeader, err := scale2.Marshal(*header) + encodedHeader, err := scale.Marshal(*header) if err != nil { return fmt.Errorf("cannot encode header: %w", err) } @@ -116,7 +117,7 @@ func (in *Instance) FinalizeBlock() (*types.Header, error) { } bh := types.NewEmptyHeader() - err = scale2.Unmarshal(data, bh) + err = scale.Unmarshal(data, bh) if err != nil { return nil, err } diff --git a/lib/runtime/life/exports_test.go b/lib/runtime/life/exports_test.go index 55fb294546..88a9dcb628 100644 --- a/lib/runtime/life/exports_test.go +++ b/lib/runtime/life/exports_test.go @@ -12,7 +12,7 @@ import ( "github.com/ChainSafe/gossamer/lib/runtime" "github.com/ChainSafe/gossamer/lib/runtime/storage" "github.com/ChainSafe/gossamer/lib/trie" - scale2 "github.com/ChainSafe/gossamer/pkg/scale" + "github.com/ChainSafe/gossamer/pkg/scale" "github.com/stretchr/testify/require" ) @@ -145,12 +145,12 @@ func buildBlock(t *testing.T, instance runtime.Instance) *types.Block { //// decode inherent extrinsics var exts [][]byte - err = scale2.Unmarshal(inherentExts, &exts) + err = scale.Unmarshal(inherentExts, &exts) require.NoError(t, err) // apply each inherent extrinsic for _, ext := range exts { - in, err := scale2.Marshal(ext) //nolint + in, err := scale.Marshal(ext) //nolint require.NoError(t, err) ret, err := instance.ApplyExtrinsic(append([]byte{1}, in...)) @@ -237,14 +237,14 @@ func TestInstance_ExecuteBlock_KusamaRuntime_KusamaBlock1(t *testing.T) { // block data is received from querying a polkadot node body := []byte{8, 40, 4, 2, 0, 11, 144, 17, 14, 179, 110, 1, 16, 4, 20, 0, 0} var exts [][]byte - err = scale2.Unmarshal(body, &exts) + err = scale.Unmarshal(body, &exts) require.NoError(t, err) require.Equal(t, 2, len(exts)) // digest from polkadot.js digestBytes := common.MustHexToBytes("0x0c0642414245340201000000ef55a50f00000000044241424549040118ca239392960473fe1bc65f94ee27d890a49c1b200c006ff5dcc525330ecc16770100000000000000b46f01874ce7abbb5220e8fd89bede0adad14c73039d91e28e881823433e723f0100000000000000d684d9176d6eb69887540c9a89fa6097adea82fc4b0ff26d1062b488f352e179010000000000000068195a71bdde49117a616424bdc60a1733e96acb1da5aeab5d268cf2a572e94101000000000000001a0575ef4ae24bdfd31f4cb5bd61239ae67c12d4e64ae51ac756044aa6ad8200010000000000000018168f2aad0081a25728961ee00627cfe35e39833c805016632bf7c14da5800901000000000000000000000000000000000000000000000000000000000000000000000000000000054241424501014625284883e564bc1e4063f5ea2b49846cdddaa3761d04f543b698c1c3ee935c40d25b869247c36c6b8a8cbbd7bb2768f560ab7c276df3c62df357a7e3b1ec8d") digest := types.NewDigest() - err = scale2.Unmarshal(digestBytes, &digest) + err = scale.Unmarshal(digestBytes, &digest) require.NoError(t, err) // kusama block 1, from polkadot.js @@ -287,14 +287,14 @@ func TestInstance_ExecuteBlock_PolkadotRuntime_PolkadotBlock1(t *testing.T) { // block data is received from querying a polkadot node body := []byte{8, 40, 4, 3, 0, 11, 80, 149, 160, 81, 114, 1, 16, 4, 20, 0, 0} var exts [][]byte - err = scale2.Unmarshal(body, &exts) + err = scale.Unmarshal(body, &exts) require.NoError(t, err) require.Equal(t, 2, len(exts)) // digest data received from querying polkadot node digestBytes := common.MustHexToBytes("0x0c0642414245b501010000000093decc0f00000000362ed8d6055645487fe42e9c8640be651f70a3a2a03658046b2b43f021665704501af9b1ca6e974c257e3d26609b5f68b5b0a1da53f7f252bbe5d94948c39705c98ffa4b869dd44ac29528e3723d619cc7edf1d3f7b7a57a957f6a7e9bdb270a044241424549040118fa3437b10f6e7af8f31362df3a179b991a8c56313d1bcd6307a4d0c734c1ae310100000000000000d2419bc8835493ac89eb09d5985281f5dff4bc6c7a7ea988fd23af05f301580a0100000000000000ccb6bef60defc30724545d57440394ed1c71ea7ee6d880ed0e79871a05b5e40601000000000000005e67b64cf07d4d258a47df63835121423551712844f5b67de68e36bb9a21e12701000000000000006236877b05370265640c133fec07e64d7ca823db1dc56f2d3584b3d7c0f1615801000000000000006c52d02d95c30aa567fda284acf25025ca7470f0b0c516ddf94475a1807c4d250100000000000000000000000000000000000000000000000000000000000000000000000000000005424142450101d468680c844b19194d4dfbdc6697a35bf2b494bda2c5a6961d4d4eacfbf74574379ba0d97b5bb650c2e8670a63791a727943bcb699dc7a228bdb9e0a98c9d089") digest := types.NewDigest() - err = scale2.Unmarshal(digestBytes, &digest) + err = scale.Unmarshal(digestBytes, &digest) require.NoError(t, err) // polkadot block 1, from polkadot.js diff --git a/lib/runtime/life/resolver.go b/lib/runtime/life/resolver.go index 8c42dcd351..2bf0e70948 100644 --- a/lib/runtime/life/resolver.go +++ b/lib/runtime/life/resolver.go @@ -16,9 +16,8 @@ import ( "github.com/ChainSafe/gossamer/lib/crypto/secp256k1" "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/trie" - pscale "github.com/ChainSafe/gossamer/pkg/scale" + "github.com/ChainSafe/gossamer/pkg/scale" "github.com/perlin-network/life/exec" ) @@ -424,26 +423,27 @@ func storageAppend(storage runtime.Storage, key, valueToAppend []byte) error { if len(valueCurr) == 0 { valueRes = valueToAppend } else { - // remove length prefix from existing value - r := &bytes.Buffer{} - _, _ = r.Write(valueCurr) - dec := &scale.Decoder{Reader: r} - currLength, err := dec.DecodeBigInt() //nolint - + var currLength *big.Int + err := scale.Unmarshal(valueCurr, &currLength) if err != nil { logger.Trace("[ext_storage_append_version_1] item in storage is not SCALE encoded, overwriting", "key", key) storage.Set(key, append([]byte{4}, valueToAppend...)) return nil } - // append new item - valueRes = append(r.Bytes(), valueToAppend...) + lengthBytes, err := scale.Marshal(currLength) + if err != nil { + return err + } + // append new item, pop off number of bytes required for length encoding, + // since we're not using old scale.Decoder + valueRes = append(valueCurr[len(lengthBytes):], valueToAppend...) // increase length by 1 nextLength = big.NewInt(0).Add(currLength, big.NewInt(1)) } - lengthEnc, err := scale.Encode(nextLength) + lengthEnc, err := scale.Marshal(nextLength) if err != nil { logger.Trace("[ext_storage_append_version_1] failed to encode new length", "error", err) return err @@ -481,16 +481,15 @@ func ext_trie_blake2_256_ordered_root_version_1(vm *exec.VirtualMachine) int64 { data := asMemorySlice(memory, dataSpan) t := trie.NewEmptyTrie() - v, err := scale.Decode(data, [][]byte{}) + var v [][]byte + err := scale.Unmarshal(data, &v) if err != nil { logger.Error("[ext_trie_blake2_256_ordered_root_version_1]", "error", err) return 0 } - values := v.([][]byte) - - for i, val := range values { - key, err := scale.Encode(big.NewInt(int64(i))) //nolint + for i, val := range v { + key, err := scale.Marshal(big.NewInt(int64(i))) //nolint if err != nil { logger.Error("[ext_blake2_256_enumerated_trie_root]", "error", err) return 0 @@ -792,7 +791,7 @@ func ext_crypto_ed25519_public_keys_version_1(vm *exec.VirtualMachine) int64 { encodedKeys = append(encodedKeys, key.Encode()...) } - prefix, err := pscale.Marshal(big.NewInt(int64(len(keys)))) + prefix, err := scale.Marshal(big.NewInt(int64(len(keys)))) if err != nil { logger.Error("[ext_crypto_ed25519_public_keys_version_1] failed to allocate memory", err) ret, _ := toWasmMemory(memory, []byte{0}) @@ -975,7 +974,7 @@ func ext_crypto_sr25519_public_keys_version_1(vm *exec.VirtualMachine) int64 { encodedKeys = append(encodedKeys, key.Encode()...) } - prefix, err := pscale.Marshal(big.NewInt(int64(len(keys)))) + prefix, err := scale.Marshal(big.NewInt(int64(len(keys)))) if err != nil { logger.Error("[ext_crypto_sr25519_public_keys_version_1] failed to allocate memory", err) ret, _ := toWasmMemory(memory, []byte{0}) @@ -1285,7 +1284,7 @@ func ext_trie_blake2_256_root_version_1(vm *exec.VirtualMachine) int64 { // this function is expecting an array of (key, value) tuples var kvs [][]byte - err := pscale.Unmarshal(data, &kvs) + err := scale.Unmarshal(data, &kvs) if err != nil { logger.Error("[ext_trie_blake2_256_root_version_1]", "error", err) return 0 diff --git a/lib/runtime/life/resolver_test.go b/lib/runtime/life/resolver_test.go index db3b98db7d..98babab58b 100644 --- a/lib/runtime/life/resolver_test.go +++ b/lib/runtime/life/resolver_test.go @@ -32,8 +32,8 @@ import ( "github.com/ChainSafe/gossamer/lib/keystore" "github.com/ChainSafe/gossamer/lib/runtime" "github.com/ChainSafe/gossamer/lib/runtime/storage" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/trie" + "github.com/ChainSafe/gossamer/pkg/scale" "github.com/stretchr/testify/require" ) @@ -46,13 +46,14 @@ func Test_ext_allocator_malloc_version_1(t *testing.T) { size := make([]byte, 4) binary.LittleEndian.PutUint32(size, 1) - enc, err := scale.Encode(size) + enc, err := scale.Marshal(size) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_allocator_malloc_version_1", enc) require.NoError(t, err) - res, err := scale.Decode(ret, []byte{}) + var res []byte + err = scale.Unmarshal(ret, &res) require.NoError(t, err) require.Equal(t, size, res) } @@ -61,13 +62,14 @@ func Test_ext_hashing_blake2_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_blake2_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Blake2bHash(data) @@ -79,13 +81,14 @@ func Test_ext_hashing_twox_128_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_twox_128_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Twox128Hash(data) @@ -100,7 +103,7 @@ func Test_ext_storage_get_version_1(t *testing.T) { testvalue := []byte{1, 2} ctx.Storage.Set(testkey, testvalue) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_get_version_1", enc) @@ -120,9 +123,9 @@ func Test_ext_storage_set_version_1(t *testing.T) { testkey := []byte("noot") testvalue := []byte("washere") - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encValue, err := scale.Encode(testvalue) + encValue, err := scale.Marshal(testvalue) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_set_version_1", append(encKey, encValue...)) @@ -141,7 +144,7 @@ func Test_ext_storage_next_key_version_1(t *testing.T) { nextkey := []byte("oot") ctx.Storage.Set(nextkey, []byte{1}) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_next_key_version_1", enc) @@ -159,13 +162,14 @@ func Test_ext_hashing_twox_64_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_twox_64_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Twox64(data) @@ -179,7 +183,7 @@ func Test_ext_storage_clear_version_1(t *testing.T) { testkey := []byte("noot") ctx.Storage.Set(testkey, []byte{1}) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_clear_version_1", enc) @@ -198,7 +202,7 @@ func Test_ext_storage_clear_prefix_version_1(t *testing.T) { testkey2 := []byte("spaghet") ctx.Storage.Set(testkey2, []byte{2}) - enc, err := scale.Encode(testkey[:3]) + enc, err := scale.Marshal(testkey[:3]) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_clear_prefix_version_1", enc) @@ -211,35 +215,6 @@ func Test_ext_storage_clear_prefix_version_1(t *testing.T) { require.NotNil(t, val) } -func Test_ext_storage_read_version_1(t *testing.T) { - inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) - - testkey := []byte("noot") - testvalue := []byte("washere") - ctx.Storage.Set(testkey, testvalue) - - testoffset := uint32(2) - testBufferSize := uint32(100) - - encKey, err := scale.Encode(testkey) - require.NoError(t, err) - encOffset, err := scale.Encode(testoffset) - require.NoError(t, err) - encBufferSize, err := scale.Encode(testBufferSize) - require.NoError(t, err) - - ret, err := inst.Exec("rtm_ext_storage_read_version_1", append(append(encKey, encOffset...), encBufferSize...)) - require.NoError(t, err) - - buf := &bytes.Buffer{} - buf.Write(ret) - - read, err := new(optional.Bytes).Decode(buf) - require.NoError(t, err) - val := read.Value() - require.Equal(t, testvalue[testoffset:], val[:len(testvalue)-int(testoffset)]) -} - func Test_ext_storage_append_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) @@ -247,57 +222,62 @@ func Test_ext_storage_append_version_1(t *testing.T) { testvalue := []byte("was") testvalueAppend := []byte("here") - encKey, err := scale.Encode(testkey) + encKey1, err := scale.Marshal(testkey) require.NoError(t, err) - encVal, err := scale.Encode(testvalue) + + encVal1, err := scale.Marshal(testvalue) require.NoError(t, err) - doubleEncVal, err := scale.Encode(encVal) + + doubleEncVal1, err := scale.Marshal(encVal1) require.NoError(t, err) - encArr, err := scale.Encode([][]byte{testvalue}) + encArr1, err := scale.Marshal([][]byte{testvalue}) require.NoError(t, err) // place SCALE encoded value in storage - _, err = inst.Exec("rtm_ext_storage_append_version_1", append(encKey, doubleEncVal...)) + _, err = inst.Exec("rtm_ext_storage_append_version_1", append(encKey1, doubleEncVal1...)) require.NoError(t, err) val := ctx.Storage.Get(testkey) - require.Equal(t, encArr, val) + require.Equal(t, encArr1, val) - encValueAppend, err := scale.Encode(testvalueAppend) + encValueAppend1, err := scale.Marshal(testvalueAppend) require.NoError(t, err) - doubleEncValueAppend, err := scale.Encode(encValueAppend) + + doubleEncValueAppend1, err := scale.Marshal(encValueAppend1) require.NoError(t, err) - _, err = inst.Exec("rtm_ext_storage_append_version_1", append(encKey, doubleEncValueAppend...)) + _, err = inst.Exec("rtm_ext_storage_append_version_1", append(encKey1, doubleEncValueAppend1...)) require.NoError(t, err) ret := ctx.Storage.Get(testkey) require.NotNil(t, ret) - dec, err := scale.Decode(ret, [][]byte{}) + + var dec1 [][]byte + err = scale.Unmarshal(ret, &dec1) require.NoError(t, err) - res := dec.([][]byte) - require.Equal(t, 2, len(res)) - require.Equal(t, testvalue, res[0]) - require.Equal(t, testvalueAppend, res[1]) + require.Equal(t, 2, len(dec1)) + require.Equal(t, testvalue, dec1[0]) + require.Equal(t, testvalueAppend, dec1[1]) - expected, err := scale.Encode([][]byte{testvalue, testvalueAppend}) + expected1, err := scale.Marshal([][]byte{testvalue, testvalueAppend}) require.NoError(t, err) - require.Equal(t, expected, ret) + require.Equal(t, expected1, ret) } func Test_ext_trie_blake2_256_ordered_root_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) testvalues := []string{"static", "even-keeled", "Future-proofed"} - encValues, err := scale.Encode(testvalues) + encValues, err := scale.Marshal(testvalues) require.NoError(t, err) res, err := inst.Exec("rtm_ext_trie_blake2_256_ordered_root_version_1", encValues) require.NoError(t, err) - hash, err := scale.Decode(res, []byte{}) + var hash []byte + err = scale.Unmarshal(res, &hash) require.NoError(t, err) expected := common.MustHexToHash("0xd847b86d0219a384d11458e829e9f4f4cce7e3cc2e6dcd0e8a6ad6f12c64a737") @@ -311,9 +291,9 @@ func Test_ext_storage_root_version_1(t *testing.T) { //testkey := []byte("noot") //testvalue := []byte("washere") // - //encKey, err := scale.Encode(testkey) + //encKey, err := scale.Marshal(testkey) //require.NoError(t, err) - //encValue, err := scale.Encode(testvalue) + //encValue, err := scale.Marshal(testvalue) //require.NoError(t, err) // //_, err = inst.Exec("rtm_ext_storage_set_version_1", append(encKey, encValue...)) @@ -322,7 +302,8 @@ func Test_ext_storage_root_version_1(t *testing.T) { ret, err := inst.Exec("rtm_ext_storage_root_version_1", []byte{}) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected := trie.EmptyHash @@ -336,7 +317,7 @@ func Test_ext_storage_exists_version_1(t *testing.T) { testvalue := []byte{1, 2} ctx.Storage.Set(testkey, testvalue) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_exists_version_1", enc) @@ -344,7 +325,7 @@ func Test_ext_storage_exists_version_1(t *testing.T) { require.Equal(t, byte(1), ret[0]) nonexistent := []byte("none") - enc, err = scale.Encode(nonexistent) + enc, err = scale.Marshal(nonexistent) require.NoError(t, err) ret, err = inst.Exec("rtm_ext_storage_exists_version_1", enc) @@ -363,13 +344,13 @@ func Test_ext_default_child_storage_set_version_1(t *testing.T) { require.NoError(t, err) require.Nil(t, val) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) - encVal, err := scale.Encode(testValue) + encVal, err := scale.Marshal(testValue) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_set_version_1", append(append(encChildKey, encKey...), encVal...)) @@ -389,10 +370,10 @@ func Test_ext_default_child_storage_get_version_1(t *testing.T) { err = ctx.Storage.SetChildStorage(testChildKey, testKey, testValue) require.NoError(t, err) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_get_version_1", append(encChildKey, encKey...)) @@ -418,16 +399,16 @@ func Test_ext_default_child_storage_read_version_1(t *testing.T) { testOffset := uint32(2) testBufferSize := uint32(100) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) - encBufferSize, err := scale.Encode(testBufferSize) + encBufferSize, err := scale.Marshal(testBufferSize) require.NoError(t, err) - encOffset, err := scale.Encode(testOffset) + encOffset, err := scale.Marshal(testOffset) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_read_version_1", append(append(encChildKey, encKey...), append(encOffset, encBufferSize...)...)) @@ -457,10 +438,10 @@ func Test_ext_default_child_storage_clear_version_1(t *testing.T) { require.NoError(t, err) require.Equal(t, testValue, val) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_clear_version_1", append(encChildKey, encKey...)) @@ -482,7 +463,7 @@ func Test_ext_default_child_storage_storage_kill_version_1(t *testing.T) { require.NoError(t, err) require.NotNil(t, child) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_storage_kill_version_1", encChildKey) @@ -501,10 +482,10 @@ func Test_ext_default_child_storage_exists_version_1(t *testing.T) { err = ctx.Storage.SetChildStorage(testChildKey, testKey, testValue) require.NoError(t, err) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_exists_version_1", append(encChildKey, encKey...)) @@ -545,10 +526,10 @@ func Test_ext_default_child_storage_clear_prefix_version_1(t *testing.T) { require.NoError(t, err) require.Equal(t, 3, len(keys)) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encPrefix, err := scale.Encode(prefix) + encPrefix, err := scale.Marshal(prefix) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_clear_prefix_version_1", append(encChildKey, encPrefix...)) @@ -574,19 +555,20 @@ func Test_ext_default_child_storage_root_version_1(t *testing.T) { rootHash, err := child.Hash() require.NoError(t, err) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_root_version_1", append(encChildKey, encKey...)) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) // Convert decoded interface to common Hash - actualValue := common.BytesToHash(hash.([]byte)) + actualValue := common.BytesToHash(hash) require.Equal(t, rootHash, actualValue) } @@ -611,10 +593,10 @@ func Test_ext_default_child_storage_next_key_version_1(t *testing.T) { require.NoError(t, err) } - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(key) + encKey, err := scale.Marshal(key) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_next_key_version_1", append(encChildKey, encKey...)) @@ -650,13 +632,14 @@ func Test_ext_crypto_ed25519_public_keys_version_1(t *testing.T) { res, err := inst.Exec("rtm_ext_crypto_ed25519_public_keys_version_1", idData) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) - value, err := scale.Decode(out.([]byte), [][32]byte{}) + var ret [][32]byte + err = scale.Unmarshal(out, &ret) require.NoError(t, err) - ret := value.([][32]byte) sort.Slice(ret, func(i int, j int) bool { return ret[i][0] < ret[j][0] }) require.Equal(t, pubKeys, ret) } @@ -680,10 +663,11 @@ func Test_ext_crypto_ed25519_generate_version_1(t *testing.T) { ret, err := inst.Exec("rtm_ext_crypto_ed25519_generate_version_1", params) require.NoError(t, err) - out, err := scale.Decode(ret, []byte{}) + var out []byte + err = scale.Unmarshal(ret, &out) require.NoError(t, err) - pubKey, err := ed25519.NewPublicKey(out.([]byte)) + pubKey, err := ed25519.NewPublicKey(out) require.NoError(t, err) require.Equal(t, 1, ks.Size()) kp := ks.GetKeypair(pubKey) @@ -701,21 +685,22 @@ func Test_ext_crypto_ed25519_sign_version_1(t *testing.T) { ks.Insert(kp) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) res, err := inst.Exec("rtm_ext_crypto_ed25519_sign_version_1", append(append(idData, encPubKey...), encMsg...)) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) value, err := new(optional.FixedSizeBytes).Decode(buf) require.NoError(t, err) @@ -736,16 +721,16 @@ func Test_ext_crypto_ed25519_verify_version_1(t *testing.T) { ks.Insert(kp) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) sign, err := kp.Private().Sign(msgData) require.NoError(t, err) - encSign, err := scale.Encode(sign) + encSign, err := scale.Marshal(sign) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_ed25519_verify_version_1", append(append(encSign, encMsg...), encPubKey...)) @@ -782,13 +767,14 @@ func Test_ext_crypto_sr25519_public_keys_version_1(t *testing.T) { res, err := inst.Exec("rtm_ext_crypto_sr25519_public_keys_version_1", idData) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) - value, err := scale.Decode(out.([]byte), [][32]byte{}) + var ret [][32]byte + err = scale.Unmarshal(out, &ret) require.NoError(t, err) - ret := value.([][32]byte) sort.Slice(ret, func(i int, j int) bool { return ret[i][0] < ret[j][0] }) require.Equal(t, pubKeys, ret) } @@ -812,10 +798,11 @@ func Test_ext_crypto_sr25519_generate_version_1(t *testing.T) { ret, err := inst.Exec("rtm_ext_crypto_sr25519_generate_version_1", params) require.NoError(t, err) - out, err := scale.Decode(ret, []byte{}) + var out []byte + err = scale.Unmarshal(ret, &out) require.NoError(t, err) - pubKey, err := ed25519.NewPublicKey(out.([]byte)) + pubKey, err := ed25519.NewPublicKey(out) require.NoError(t, err) require.Equal(t, 1, ks.Size()) @@ -836,21 +823,22 @@ func Test_ext_crypto_sr25519_sign_version_1(t *testing.T) { ks.Insert(kp) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) res, err := inst.Exec("rtm_ext_crypto_sr25519_sign_version_1", append(append(idData, encPubKey...), encMsg...)) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) value, err := new(optional.FixedSizeBytes).Decode(buf) require.NoError(t, err) @@ -872,16 +860,16 @@ func Test_ext_crypto_sr25519_verify_version_1(t *testing.T) { require.Equal(t, 0, ks.Size()) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) sign, err := kp.Private().Sign(msgData) require.NoError(t, err) - encSign, err := scale.Encode(sign) + encSign, err := scale.Marshal(sign) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_sr25519_verify_version_1", append(append(encSign, encMsg...), encPubKey...)) @@ -911,19 +899,20 @@ func Test_ext_crypto_secp256k1_ecdsa_recover_version_1(t *testing.T) { expectedPubKey := kp.Public().Encode() - encSign, err := scale.Encode(sigData) + encSign, err := scale.Marshal(sigData) require.NoError(t, err) - encMsg, err := scale.Encode(blakeHash.ToBytes()) + encMsg, err := scale.Marshal(blakeHash.ToBytes()) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_secp256k1_ecdsa_recover_version_1", append(encSign, encMsg...)) require.NoError(t, err) - out, err := scale.Decode(ret, []byte{}) + var out []byte + err = scale.Unmarshal(ret, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) uncomPubKey, err := new(types.Result).Decode(buf) require.NoError(t, err) @@ -942,13 +931,14 @@ func Test_ext_hashing_keccak_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_keccak_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Keccak256(data) @@ -960,13 +950,14 @@ func Test_ext_hashing_sha2_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_sha2_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected := common.Sha256(data) @@ -977,13 +968,14 @@ func Test_ext_hashing_blake2_128_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_blake2_128_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Blake2b128(data) @@ -995,13 +987,14 @@ func Test_ext_hashing_twox_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_twox_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Twox256(data) @@ -1013,14 +1006,15 @@ func Test_ext_trie_blake2_256_root_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) testinput := []string{"noot", "was", "here", "??"} - encInput, err := scale.Encode(testinput) + encInput, err := scale.Marshal(testinput) require.NoError(t, err) encInput[0] = encInput[0] >> 1 res, err := inst.Exec("rtm_ext_trie_blake2_256_root_version_1", encInput) require.NoError(t, err) - hash, err := scale.Decode(res, []byte{}) + var hash []byte + err = scale.Unmarshal(res, &hash) require.NoError(t, err) tt := trie.NewEmptyTrie() diff --git a/lib/runtime/mocks/version.go b/lib/runtime/mocks/version.go index 9d2703dedc..5f6989faac 100644 --- a/lib/runtime/mocks/version.go +++ b/lib/runtime/mocks/version.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.8.0. DO NOT EDIT. +// Code generated by mockery 2.9.0. DO NOT EDIT. package mocks @@ -7,21 +7,21 @@ import ( mock "github.com/stretchr/testify/mock" ) -// MockVersion is an autogenerated mock type for the Version type -type MockVersion struct { +// Version is an autogenerated mock type for the Version type +type Version struct { mock.Mock } // APIItems provides a mock function with given fields: -func (_m *MockVersion) APIItems() []*runtime.APIItem { +func (_m *Version) APIItems() []runtime.APIItem { ret := _m.Called() - var r0 []*runtime.APIItem - if rf, ok := ret.Get(0).(func() []*runtime.APIItem); ok { + var r0 []runtime.APIItem + if rf, ok := ret.Get(0).(func() []runtime.APIItem); ok { r0 = rf() } else { if ret.Get(0) != nil { - r0 = ret.Get(0).([]*runtime.APIItem) + r0 = ret.Get(0).([]runtime.APIItem) } } @@ -29,7 +29,7 @@ func (_m *MockVersion) APIItems() []*runtime.APIItem { } // AuthoringVersion provides a mock function with given fields: -func (_m *MockVersion) AuthoringVersion() uint32 { +func (_m *Version) AuthoringVersion() uint32 { ret := _m.Called() var r0 uint32 @@ -43,7 +43,7 @@ func (_m *MockVersion) AuthoringVersion() uint32 { } // Encode provides a mock function with given fields: -func (_m *MockVersion) Encode() ([]byte, error) { +func (_m *Version) Encode() ([]byte, error) { ret := _m.Called() var r0 []byte @@ -66,7 +66,7 @@ func (_m *MockVersion) Encode() ([]byte, error) { } // ImplName provides a mock function with given fields: -func (_m *MockVersion) ImplName() []byte { +func (_m *Version) ImplName() []byte { ret := _m.Called() var r0 []byte @@ -82,7 +82,7 @@ func (_m *MockVersion) ImplName() []byte { } // ImplVersion provides a mock function with given fields: -func (_m *MockVersion) ImplVersion() uint32 { +func (_m *Version) ImplVersion() uint32 { ret := _m.Called() var r0 uint32 @@ -96,7 +96,7 @@ func (_m *MockVersion) ImplVersion() uint32 { } // SpecName provides a mock function with given fields: -func (_m *MockVersion) SpecName() []byte { +func (_m *Version) SpecName() []byte { ret := _m.Called() var r0 []byte @@ -112,7 +112,7 @@ func (_m *MockVersion) SpecName() []byte { } // SpecVersion provides a mock function with given fields: -func (_m *MockVersion) SpecVersion() uint32 { +func (_m *Version) SpecVersion() uint32 { ret := _m.Called() var r0 uint32 @@ -126,7 +126,7 @@ func (_m *MockVersion) SpecVersion() uint32 { } // TransactionVersion provides a mock function with given fields: -func (_m *MockVersion) TransactionVersion() uint32 { +func (_m *Version) TransactionVersion() uint32 { ret := _m.Called() var r0 uint32 diff --git a/lib/runtime/version.go b/lib/runtime/version.go index b4e7aac4c0..0856f65fac 100644 --- a/lib/runtime/version.go +++ b/lib/runtime/version.go @@ -17,11 +17,7 @@ package runtime import ( - "bytes" - "math/big" - - "github.com/ChainSafe/gossamer/lib/common" - "github.com/ChainSafe/gossamer/lib/scale" + "github.com/ChainSafe/gossamer/pkg/scale" ) // Version represents the data returned by runtime call core_version @@ -31,7 +27,7 @@ type Version interface { AuthoringVersion() uint32 SpecVersion() uint32 ImplVersion() uint32 - APIItems() []*APIItem + APIItems() []APIItem TransactionVersion() uint32 Encode() ([]byte, error) } @@ -49,11 +45,11 @@ type LegacyVersionData struct { authoringVersion uint32 specVersion uint32 implVersion uint32 - apiItems []*APIItem + apiItems []APIItem } // NewLegacyVersionData returns a new LegacyVersionData -func NewLegacyVersionData(specName, implName []byte, authoringVersion, specVersion, implVersion uint32, apiItems []*APIItem) *LegacyVersionData { +func NewLegacyVersionData(specName, implName []byte, authoringVersion, specVersion, implVersion uint32, apiItems []APIItem) *LegacyVersionData { return &LegacyVersionData{ specName: specName, implName: implName, @@ -65,131 +61,81 @@ func NewLegacyVersionData(specName, implName []byte, authoringVersion, specVersi } // SpecName returns the spec name -func (v *LegacyVersionData) SpecName() []byte { - return v.specName +func (lvd *LegacyVersionData) SpecName() []byte { + return lvd.specName } // ImplName returns the implementation name -func (v *LegacyVersionData) ImplName() []byte { - return v.implName +func (lvd *LegacyVersionData) ImplName() []byte { + return lvd.implName } // AuthoringVersion returns the authoring version -func (v *LegacyVersionData) AuthoringVersion() uint32 { - return v.authoringVersion +func (lvd *LegacyVersionData) AuthoringVersion() uint32 { + return lvd.authoringVersion } // SpecVersion returns the spec version -func (v *LegacyVersionData) SpecVersion() uint32 { - return v.specVersion +func (lvd *LegacyVersionData) SpecVersion() uint32 { + return lvd.specVersion } // ImplVersion returns the implementation version -func (v *LegacyVersionData) ImplVersion() uint32 { - return v.implVersion +func (lvd *LegacyVersionData) ImplVersion() uint32 { + return lvd.implVersion } // APIItems returns the API items -func (v *LegacyVersionData) APIItems() []*APIItem { - return v.apiItems +func (lvd *LegacyVersionData) APIItems() []APIItem { + return lvd.apiItems } // TransactionVersion returns the transaction version -func (v *LegacyVersionData) TransactionVersion() uint32 { +func (lvd *LegacyVersionData) TransactionVersion() uint32 { return 0 } -// Encode returns the SCALE encoding of the Version -func (v *LegacyVersionData) Encode() ([]byte, error) { - info := &struct { - SpecName []byte - ImplName []byte - AuthoringVersion uint32 - SpecVersion uint32 - ImplVersion uint32 - }{ - SpecName: v.specName, - ImplName: v.implName, - AuthoringVersion: v.authoringVersion, - SpecVersion: v.specVersion, - ImplVersion: v.implVersion, - } +type legacyVersionData struct { + SpecName []byte + ImplName []byte + AuthoringVersion uint32 + SpecVersion uint32 + ImplVersion uint32 + APIItems []APIItem +} - enc, err := scale.Encode(info) - if err != nil { - return nil, err +// Encode returns the SCALE encoding of the Version +func (lvd *LegacyVersionData) Encode() ([]byte, error) { + info := legacyVersionData{ + SpecName: lvd.specName, + ImplName: lvd.implName, + AuthoringVersion: lvd.authoringVersion, + SpecVersion: lvd.specVersion, + ImplVersion: lvd.implVersion, + APIItems: lvd.apiItems, } - b, err := scale.Encode(big.NewInt(int64(len(v.apiItems)))) + enc, err := scale.Marshal(info) if err != nil { return nil, err } - enc = append(enc, b...) - - for _, apiItem := range v.apiItems { - enc = append(enc, apiItem.Name[:]...) - - b, err = scale.Encode(apiItem.Ver) - if err != nil { - return nil, err - } - enc = append(enc, b...) - } - return enc, nil } // Decode to scale decode []byte to VersionAPI struct -func (v *LegacyVersionData) Decode(in []byte) error { - r := &bytes.Buffer{} - _, err := r.Write(in) - if err != nil { - return err - } - sd := scale.Decoder{Reader: r} - - type Info struct { - SpecName []byte - ImplName []byte - AuthoringVersion uint32 - SpecVersion uint32 - ImplVersion uint32 - } - - ret, err := sd.Decode(new(Info)) +func (lvd *LegacyVersionData) Decode(in []byte) error { + var info legacyVersionData + err := scale.Unmarshal(in, &info) if err != nil { return err } - info := ret.(*Info) - - v.specName = info.SpecName - v.implName = info.ImplName - v.authoringVersion = info.AuthoringVersion - v.specVersion = info.SpecVersion - v.implVersion = info.ImplVersion - - numApis, err := sd.DecodeInteger() - if err != nil { - return err - } - - for i := 0; i < int(numApis); i++ { - name, err := common.Read8Bytes(r) //nolint - if err != nil { - return err - } - - version, err := common.ReadUint32(r) - if err != nil { - return err - } - - v.apiItems = append(v.apiItems, &APIItem{ - Name: name, - Ver: version, - }) - } + lvd.specName = info.SpecName + lvd.implName = info.ImplName + lvd.authoringVersion = info.AuthoringVersion + lvd.specVersion = info.SpecVersion + lvd.implVersion = info.ImplVersion + lvd.apiItems = info.APIItems return nil } @@ -201,12 +147,12 @@ type VersionData struct { authoringVersion uint32 specVersion uint32 implVersion uint32 - apiItems []*APIItem + apiItems []APIItem transactionVersion uint32 } // NewVersionData returns a new VersionData -func NewVersionData(specName, implName []byte, authoringVersion, specVersion, implVersion uint32, apiItems []*APIItem, transactionVersion uint32) *VersionData { +func NewVersionData(specName, implName []byte, authoringVersion, specVersion, implVersion uint32, apiItems []APIItem, transactionVersion uint32) *VersionData { return &VersionData{ specName: specName, implName: implName, @@ -219,138 +165,84 @@ func NewVersionData(specName, implName []byte, authoringVersion, specVersion, im } // SpecName returns the spec name -func (v *VersionData) SpecName() []byte { - return v.specName +func (vd *VersionData) SpecName() []byte { + return vd.specName } // ImplName returns the implementation name -func (v *VersionData) ImplName() []byte { - return v.implName +func (vd *VersionData) ImplName() []byte { + return vd.implName } // AuthoringVersion returns the authoring version -func (v *VersionData) AuthoringVersion() uint32 { - return v.authoringVersion +func (vd *VersionData) AuthoringVersion() uint32 { + return vd.authoringVersion } // SpecVersion returns the spec version -func (v *VersionData) SpecVersion() uint32 { - return v.specVersion +func (vd *VersionData) SpecVersion() uint32 { + return vd.specVersion } // ImplVersion returns the implementation version -func (v *VersionData) ImplVersion() uint32 { - return v.implVersion +func (vd *VersionData) ImplVersion() uint32 { + return vd.implVersion } // APIItems returns the API items -func (v *VersionData) APIItems() []*APIItem { - return v.apiItems +func (vd *VersionData) APIItems() []APIItem { + return vd.apiItems } // TransactionVersion returns the transaction version -func (v *VersionData) TransactionVersion() uint32 { - return v.transactionVersion +func (vd *VersionData) TransactionVersion() uint32 { + return vd.transactionVersion } -// Encode returns the SCALE encoding of the Version -func (v *VersionData) Encode() ([]byte, error) { - info := &struct { - SpecName []byte - ImplName []byte - AuthoringVersion uint32 - SpecVersion uint32 - ImplVersion uint32 - }{ - SpecName: v.specName, - ImplName: v.implName, - AuthoringVersion: v.authoringVersion, - SpecVersion: v.specVersion, - ImplVersion: v.implVersion, - } - - enc, err := scale.Encode(info) - if err != nil { - return nil, err - } - - b, err := scale.Encode(big.NewInt(int64(len(v.apiItems)))) - if err != nil { - return nil, err - } - enc = append(enc, b...) - - for _, apiItem := range v.apiItems { - enc = append(enc, apiItem.Name[:]...) - - b, err = scale.Encode(apiItem.Ver) - if err != nil { - return nil, err - } - enc = append(enc, b...) - } +type versionData struct { + SpecName []byte + ImplName []byte + AuthoringVersion uint32 + SpecVersion uint32 + ImplVersion uint32 + APIItems []APIItem + TransactionVersion uint32 +} - b, err = scale.Encode(v.transactionVersion) +// Encode returns the SCALE encoding of the Version +func (vd *VersionData) Encode() ([]byte, error) { + info := versionData{ + SpecName: vd.specName, + ImplName: vd.implName, + AuthoringVersion: vd.authoringVersion, + SpecVersion: vd.specVersion, + ImplVersion: vd.implVersion, + APIItems: vd.apiItems, + TransactionVersion: vd.transactionVersion, + } + + enc, err := scale.Marshal(info) if err != nil { return nil, err } - enc = append(enc, b...) - return enc, nil } // Decode to scale decode []byte to VersionAPI struct -func (v *VersionData) Decode(in []byte) error { - r := &bytes.Buffer{} - _, err := r.Write(in) +func (vd *VersionData) Decode(in []byte) error { + var info versionData + err := scale.Unmarshal(in, &info) if err != nil { return err } - sd := scale.Decoder{Reader: r} - - type Info struct { - SpecName []byte - ImplName []byte - AuthoringVersion uint32 - SpecVersion uint32 - ImplVersion uint32 - } - ret, err := sd.Decode(new(Info)) - if err != nil { - return err - } + vd.specName = info.SpecName + vd.implName = info.ImplName + vd.authoringVersion = info.AuthoringVersion + vd.specVersion = info.SpecVersion + vd.implVersion = info.ImplVersion + vd.apiItems = info.APIItems + vd.transactionVersion = info.TransactionVersion - info := ret.(*Info) - - v.specName = info.SpecName - v.implName = info.ImplName - v.authoringVersion = info.AuthoringVersion - v.specVersion = info.SpecVersion - v.implVersion = info.ImplVersion - - numApis, err := sd.DecodeInteger() - if err != nil { - return err - } - - for i := 0; i < int(numApis); i++ { - name, err := common.Read8Bytes(r) //nolint - if err != nil { - return err - } - - version, err := common.ReadUint32(r) - if err != nil { - return err - } - - v.apiItems = append(v.apiItems, &APIItem{ - Name: name, - Ver: version, - }) - } - - v.transactionVersion, err = common.ReadUint32(r) - return err + return nil } diff --git a/lib/runtime/version_test.go b/lib/runtime/version_test.go index 9a7f06e9cd..84eddb6897 100644 --- a/lib/runtime/version_test.go +++ b/lib/runtime/version_test.go @@ -7,7 +7,7 @@ import ( ) func TestVersionData(t *testing.T) { - testAPIItem := &APIItem{ + testAPIItem := APIItem{ Name: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}, Ver: 99, } @@ -18,7 +18,7 @@ func TestVersionData(t *testing.T) { 0, 25, 0, - []*APIItem{testAPIItem}, + []APIItem{testAPIItem}, 5, ) @@ -32,7 +32,7 @@ func TestVersionData(t *testing.T) { } func TestLegacyVersionData(t *testing.T) { - testAPIItem := &APIItem{ + testAPIItem := APIItem{ Name: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}, Ver: 99, } @@ -43,7 +43,7 @@ func TestLegacyVersionData(t *testing.T) { 0, 25, 0, - []*APIItem{testAPIItem}, + []APIItem{testAPIItem}, ) b, err := version.Encode() diff --git a/lib/runtime/wasmer/exports.go b/lib/runtime/wasmer/exports.go index eff5b2c987..6e4ed7e526 100644 --- a/lib/runtime/wasmer/exports.go +++ b/lib/runtime/wasmer/exports.go @@ -18,13 +18,12 @@ package wasmer import ( "fmt" - "io" + "strings" "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" - scale2 "github.com/ChainSafe/gossamer/pkg/scale" + "github.com/ChainSafe/gossamer/pkg/scale" ) // ValidateTransaction runs the extrinsic through runtime function TaggedTransactionQueue_validate_transaction and returns *Validity @@ -39,7 +38,7 @@ func (in *Instance) ValidateTransaction(e types.Extrinsic) (*transaction.Validit } v := transaction.NewValidity(0, [][]byte{{}}, [][]byte{{}}, 0, false) - _, err = scale.Decode(ret[1:], v) + err = scale.Unmarshal(ret[1:], v) return v, err } @@ -51,19 +50,21 @@ func (in *Instance) Version() (runtime.Version, error) { return in.version, nil } - version := new(runtime.VersionData) res, err := in.exec(runtime.CoreVersion, []byte{}) if err != nil { return nil, err } + version := &runtime.VersionData{} err = version.Decode(res) - if err == io.EOF { - // kusama seems to use the legacy version format - lversion := &runtime.LegacyVersionData{} - err = lversion.Decode(res) - return lversion, err - } else if err != nil { + // error comes from scale now, so do a string check + if err != nil { + if strings.Contains(err.Error(), "EOF") { + // TODO: kusama seems to use the legacy version format + lversion := &runtime.LegacyVersionData{} + err = lversion.Decode(res) + return lversion, err + } return nil, err } @@ -83,7 +84,7 @@ func (in *Instance) BabeConfiguration() (*types.BabeConfiguration, error) { } bc := new(types.BabeConfiguration) - _, err = scale.Decode(data, bc) + err = scale.Unmarshal(data, bc) if err != nil { return nil, err } @@ -98,17 +99,18 @@ func (in *Instance) GrandpaAuthorities() ([]types.Authority, error) { return nil, err } - adr, err := scale.Decode(ret, []types.GrandpaAuthoritiesRaw{}) + var gar []types.GrandpaAuthoritiesRaw + err = scale.Unmarshal(ret, &gar) if err != nil { return nil, err } - return types.GrandpaAuthoritiesRawToAuthorities(adr.([]types.GrandpaAuthoritiesRaw)) + return types.GrandpaAuthoritiesRawToAuthorities(gar) } // InitializeBlock calls runtime API function Core_initialise_block func (in *Instance) InitializeBlock(header *types.Header) error { - encodedHeader, err := scale2.Marshal(*header) + encodedHeader, err := scale.Marshal(*header) if err != nil { return fmt.Errorf("cannot encode header: %w", err) } @@ -136,7 +138,7 @@ func (in *Instance) FinalizeBlock() (*types.Header, error) { } bh := types.NewEmptyHeader() - err = scale2.Unmarshal(data, bh) + err = scale.Unmarshal(data, bh) if err != nil { return nil, err } diff --git a/lib/runtime/wasmer/imports.go b/lib/runtime/wasmer/imports.go index 0c5a928f0d..3fa88f3fe3 100644 --- a/lib/runtime/wasmer/imports.go +++ b/lib/runtime/wasmer/imports.go @@ -117,7 +117,6 @@ import ( "reflect" "unsafe" - "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/common/optional" rtype "github.com/ChainSafe/gossamer/lib/common/types" @@ -127,9 +126,9 @@ import ( "github.com/ChainSafe/gossamer/lib/crypto/sr25519" "github.com/ChainSafe/gossamer/lib/runtime" rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" "github.com/ChainSafe/gossamer/lib/trie" + "github.com/ChainSafe/gossamer/pkg/scale" wasm "github.com/wasmerio/go-ext-wasm/wasmer" ) @@ -303,7 +302,7 @@ func ext_crypto_ed25519_public_keys_version_1(context unsafe.Pointer, keyTypeID encodedKeys = append(encodedKeys, key.Encode()...) } - prefix, err := scale.Encode(big.NewInt(int64(len(keys)))) + prefix, err := scale.Marshal(big.NewInt(int64(len(keys)))) if err != nil { logger.Error("[ext_crypto_ed25519_public_keys_version_1] failed to allocate memory", err) ret, _ := toWasmMemory(instanceContext, []byte{0}) @@ -564,7 +563,7 @@ func ext_crypto_sr25519_public_keys_version_1(context unsafe.Pointer, keyTypeID encodedKeys = append(encodedKeys, key.Encode()...) } - prefix, err := scale.Encode(big.NewInt(int64(len(keys)))) + prefix, err := scale.Marshal(big.NewInt(int64(len(keys)))) if err != nil { logger.Error("[ext_crypto_sr25519_public_keys_version_1] failed to allocate memory", err) ret, _ := toWasmMemory(instanceContext, []byte{0}) @@ -772,13 +771,13 @@ func ext_trie_blake2_256_root_version_1(context unsafe.Pointer, dataSpan C.int64 data[0] = data[0] << 1 // this function is expecting an array of (key, value) tuples - kvs, err := scale.Decode(data, [][]byte{}) + var keyValues [][]byte + err := scale.Unmarshal(data, &keyValues) if err != nil { logger.Error("[ext_trie_blake2_256_root_version_1]", "error", err) return 0 } - keyValues := kvs.([][]byte) if len(keyValues)%2 != 0 { // TODO: this can be removed when we have decoding of slices of structs logger.Warn("[ext_trie_blake2_256_root_version_1] odd number of input key-values, skipping last value") keyValues = keyValues[:len(keyValues)-1] @@ -816,16 +815,15 @@ func ext_trie_blake2_256_ordered_root_version_1(context unsafe.Pointer, dataSpan data := asMemorySlice(instanceContext, dataSpan) t := trie.NewEmptyTrie() - v, err := scale.Decode(data, [][]byte{}) + var values [][]byte + err := scale.Unmarshal(data, &values) if err != nil { logger.Error("[ext_trie_blake2_256_ordered_root_version_1]", "error", err) return 0 } - values := v.([][]byte) - for i, val := range values { - key, err := scale.Encode(big.NewInt(int64(i))) //nolint + key, err := scale.Marshal(big.NewInt(int64(i))) //nolint if err != nil { logger.Error("[ext_blake2_256_enumerated_trie_root]", "error", err) return 0 @@ -1494,7 +1492,7 @@ func ext_offchain_network_state_version_1(context unsafe.Pointer) C.int64_t { return 0 } - nsEnc, err := scale.Encode(runtimeCtx.Network.NetworkState()) + nsEnc, err := scale.Marshal(runtimeCtx.Network.NetworkState()) if err != nil { logger.Error("[ext_offchain_network_state_version_1] failed at encoding network state", "error", err) return 0 @@ -1539,14 +1537,12 @@ func ext_offchain_submit_transaction_version_1(context unsafe.Pointer, data C.in instanceContext := wasm.IntoInstanceContext(context) extBytes := asMemorySlice(instanceContext, data) - var decExt interface{} - decExt, err := scale.Decode(extBytes, decExt) + var extrinsic []byte + err := scale.Unmarshal(extBytes, &extrinsic) if err != nil { logger.Error("[ext_offchain_submit_transaction_version_1] failed to decode extrinsic data", "error", err) } - extrinsic := types.Extrinsic(decExt.([]byte)) - // validate the transaction txv := transaction.NewValidity(0, [][]byte{{}}, [][]byte{{}}, 0, false) vtx := transaction.NewValidTransaction(extrinsic, txv) @@ -1575,37 +1571,40 @@ func storageAppend(storage runtime.Storage, key, valueToAppend []byte) error { // this function assumes the item in storage is a SCALE encoded array of items // the valueToAppend is a new item, so it appends the item and increases the length prefix by 1 valueCurr := storage.Get(key) + if len(valueCurr) == 0 { valueRes = valueToAppend } else { - // remove length prefix from existing value - r := &bytes.Buffer{} - _, _ = r.Write(valueCurr) - dec := &scale.Decoder{Reader: r} - currLength, err := dec.DecodeBigInt() //nolint + var currLength *big.Int + err := scale.Unmarshal(valueCurr, &currLength) if err != nil { logger.Trace("[ext_storage_append_version_1] item in storage is not SCALE encoded, overwriting", "key", key) storage.Set(key, append([]byte{4}, valueToAppend...)) return nil } - // append new item - valueRes = append(r.Bytes(), valueToAppend...) + lengthBytes, err := scale.Marshal(currLength) + if err != nil { + return err + } + // append new item, pop off number of bytes required for length encoding, + // since we're not using old scale.Decoder + valueRes = append(valueCurr[len(lengthBytes):], valueToAppend...) // increase length by 1 nextLength = big.NewInt(0).Add(currLength, big.NewInt(1)) } - finalVal, err := scale.Encode(nextLength) + lengthEnc, err := scale.Marshal(nextLength) if err != nil { logger.Trace("[ext_storage_append_version_1] failed to encode new length", "error", err) return err } // append new length prefix to start of items array - finalVal = append(finalVal, valueRes...) - logger.Debug("[ext_storage_append_version_1]", "resulting value", fmt.Sprintf("0x%x", finalVal)) - storage.Set(key, finalVal) + lengthEnc = append(lengthEnc, valueRes...) + logger.Debug("[ext_storage_append_version_1]", "resulting value", fmt.Sprintf("0x%x", lengthEnc)) + storage.Set(key, lengthEnc) return nil } diff --git a/lib/runtime/wasmer/imports_test.go b/lib/runtime/wasmer/imports_test.go index a8cf31ff53..46c3a0c1ff 100644 --- a/lib/runtime/wasmer/imports_test.go +++ b/lib/runtime/wasmer/imports_test.go @@ -33,8 +33,8 @@ import ( "github.com/ChainSafe/gossamer/lib/keystore" "github.com/ChainSafe/gossamer/lib/runtime" "github.com/ChainSafe/gossamer/lib/runtime/storage" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/trie" + "github.com/ChainSafe/gossamer/pkg/scale" log "github.com/ChainSafe/log15" "github.com/stretchr/testify/require" ) @@ -61,13 +61,14 @@ func Test_ext_hashing_blake2_128_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_blake2_128_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Blake2b128(data) @@ -79,13 +80,14 @@ func Test_ext_hashing_blake2_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_blake2_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Blake2bHash(data) @@ -97,13 +99,14 @@ func Test_ext_hashing_keccak_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_keccak_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Keccak256(data) @@ -115,13 +118,14 @@ func Test_ext_hashing_twox_128_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_twox_128_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Twox128Hash(data) @@ -133,13 +137,14 @@ func Test_ext_hashing_twox_64_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_twox_64_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected, err := common.Twox64(data) @@ -151,13 +156,14 @@ func Test_ext_hashing_sha2_256_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) data := []byte("helloworld") - enc, err := scale.Encode(data) + enc, err := scale.Marshal(data) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_hashing_sha2_256_version_1", enc) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected := common.Sha256(data) @@ -170,7 +176,7 @@ func Test_ext_storage_clear_version_1(t *testing.T) { testkey := []byte("noot") inst.ctx.Storage.Set(testkey, []byte{1}) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_clear_version_1", enc) @@ -189,7 +195,7 @@ func Test_ext_storage_clear_prefix_version_1_hostAPI(t *testing.T) { testkey2 := []byte("even-keeled") inst.ctx.Storage.Set(testkey2, []byte("Future-proofed")) - enc, err := scale.Encode(testkey[:3]) + enc, err := scale.Marshal(testkey[:3]) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_clear_prefix_version_1", enc) @@ -211,7 +217,7 @@ func Test_ext_storage_clear_prefix_version_1(t *testing.T) { testkey2 := []byte("spaghet") inst.ctx.Storage.Set(testkey2, []byte{2}) - enc, err := scale.Encode(testkey[:3]) + enc, err := scale.Marshal(testkey[:3]) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_clear_prefix_version_1", enc) @@ -231,7 +237,7 @@ func Test_ext_storage_get_version_1(t *testing.T) { testvalue := []byte{1, 2} inst.ctx.Storage.Set(testkey, testvalue) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_get_version_1", enc) @@ -252,7 +258,7 @@ func Test_ext_storage_exists_version_1(t *testing.T) { testvalue := []byte{1, 2} inst.ctx.Storage.Set(testkey, testvalue) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_exists_version_1", enc) @@ -260,7 +266,7 @@ func Test_ext_storage_exists_version_1(t *testing.T) { require.Equal(t, byte(1), ret[0]) nonexistent := []byte("none") - enc, err = scale.Encode(nonexistent) + enc, err = scale.Marshal(nonexistent) require.NoError(t, err) ret, err = inst.Exec("rtm_ext_storage_exists_version_1", enc) @@ -277,7 +283,7 @@ func Test_ext_storage_next_key_version_1(t *testing.T) { nextkey := []byte("oot") inst.ctx.Storage.Set(nextkey, []byte{1}) - enc, err := scale.Encode(testkey) + enc, err := scale.Marshal(testkey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_next_key_version_1", enc) @@ -301,11 +307,11 @@ func Test_ext_storage_read_version_1(t *testing.T) { testoffset := uint32(2) testBufferSize := uint32(100) - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encOffset, err := scale.Encode(testoffset) + encOffset, err := scale.Marshal(testoffset) require.NoError(t, err) - encBufferSize, err := scale.Encode(testBufferSize) + encBufferSize, err := scale.Marshal(testBufferSize) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_read_version_1", append(append(encKey, encOffset...), encBufferSize...)) @@ -330,11 +336,11 @@ func Test_ext_storage_read_version_1_again(t *testing.T) { testoffset := uint32(8) testBufferSize := uint32(5) - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encOffset, err := scale.Encode(testoffset) + encOffset, err := scale.Marshal(testoffset) require.NoError(t, err) - encBufferSize, err := scale.Encode(testBufferSize) + encBufferSize, err := scale.Marshal(testBufferSize) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_read_version_1", append(append(encKey, encOffset...), encBufferSize...)) @@ -360,11 +366,11 @@ func Test_ext_storage_read_version_1_OffsetLargerThanValue(t *testing.T) { testoffset := uint32(len(testvalue)) testBufferSize := uint32(8) - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encOffset, err := scale.Encode(testoffset) + encOffset, err := scale.Marshal(testoffset) require.NoError(t, err) - encBufferSize, err := scale.Encode(testBufferSize) + encBufferSize, err := scale.Marshal(testBufferSize) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_storage_read_version_1", append(append(encKey, encOffset...), encBufferSize...)) @@ -385,7 +391,8 @@ func Test_ext_storage_root_version_1(t *testing.T) { ret, err := inst.Exec("rtm_ext_storage_root_version_1", []byte{}) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) expected := trie.EmptyHash @@ -398,9 +405,9 @@ func Test_ext_storage_set_version_1(t *testing.T) { testkey := []byte("noot") testvalue := []byte("washere") - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encValue, err := scale.Encode(testvalue) + encValue, err := scale.Marshal(testvalue) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_set_version_1", append(encKey, encValue...)) @@ -418,9 +425,9 @@ func Test_ext_offline_index_set_version_1(t *testing.T) { testkey := []byte("noot") testvalue := []byte("washere") - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encValue, err := scale.Encode(testvalue) + encValue, err := scale.Marshal(testvalue) require.NoError(t, err) _, err = inst.Exec("rtm_ext_offline_index_set_version_1", append(encKey, encValue...)) @@ -495,13 +502,14 @@ func Test_ext_crypto_ed25519_public_keys_version_1(t *testing.T) { res, err := inst.Exec("rtm_ext_crypto_ed25519_public_keys_version_1", idData) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) - value, err := scale.Decode(out.([]byte), [][32]byte{}) + var ret [][32]byte + err = scale.Unmarshal(out, &ret) require.NoError(t, err) - ret := value.([][32]byte) sort.Slice(ret, func(i int, j int) bool { return ret[i][0] < ret[j][0] }) require.Equal(t, pubKeys, ret) } @@ -517,21 +525,22 @@ func Test_ext_crypto_ed25519_sign_version_1(t *testing.T) { ks.Insert(kp) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) res, err := inst.Exec("rtm_ext_crypto_ed25519_sign_version_1", append(append(idData, encPubKey...), encMsg...)) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) value, err := new(optional.FixedSizeBytes).Decode(buf) require.NoError(t, err) @@ -552,16 +561,16 @@ func Test_ext_crypto_ed25519_verify_version_1(t *testing.T) { ks.Insert(kp) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) sign, err := kp.Private().Sign(msgData) require.NoError(t, err) - encSign, err := scale.Encode(sign) + encSign, err := scale.Marshal(sign) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_ed25519_verify_version_1", append(append(encSign, encMsg...), encPubKey...)) @@ -595,10 +604,11 @@ func Test_ext_crypto_sr25519_generate_version_1(t *testing.T) { ret, err := inst.Exec("rtm_ext_crypto_sr25519_generate_version_1", params) require.NoError(t, err) - out, err := scale.Decode(ret, []byte{}) + var out []byte + err = scale.Unmarshal(ret, &out) require.NoError(t, err) - pubKey, err := ed25519.NewPublicKey(out.([]byte)) + pubKey, err := ed25519.NewPublicKey(out) require.NoError(t, err) require.Equal(t, 1, ks.Size()) @@ -621,19 +631,20 @@ func Test_ext_crypto_secp256k1_ecdsa_recover_version_1(t *testing.T) { expectedPubKey := kp.Public().Encode() - encSign, err := scale.Encode(sigData) + encSign, err := scale.Marshal(sigData) require.NoError(t, err) - encMsg, err := scale.Encode(blakeHash.ToBytes()) + encMsg, err := scale.Marshal(blakeHash.ToBytes()) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_secp256k1_ecdsa_recover_version_1", append(encSign, encMsg...)) require.NoError(t, err) - out, err := scale.Decode(ret, []byte{}) + var out []byte + err = scale.Unmarshal(ret, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) uncomPubKey, err := new(types.Result).Decode(buf) require.NoError(t, err) @@ -664,19 +675,20 @@ func Test_ext_crypto_secp256k1_ecdsa_recover_compressed_version_1(t *testing.T) expectedPubKey := kp.Public().Encode() - encSign, err := scale.Encode(sigData) + encSign, err := scale.Marshal(sigData) require.NoError(t, err) - encMsg, err := scale.Encode(blakeHash.ToBytes()) + encMsg, err := scale.Marshal(blakeHash.ToBytes()) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_secp256k1_ecdsa_recover_compressed_version_1", append(encSign, encMsg...)) require.NoError(t, err) - out, err := scale.Decode(ret, []byte{}) + var out []byte + err = scale.Unmarshal(ret, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) uncomPubKey, err := new(types.Result).Decode(buf) require.NoError(t, err) @@ -712,13 +724,14 @@ func Test_ext_crypto_sr25519_public_keys_version_1(t *testing.T) { res, err := inst.Exec("rtm_ext_crypto_sr25519_public_keys_version_1", idData) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) - value, err := scale.Decode(out.([]byte), [][32]byte{}) + var ret [][32]byte + err = scale.Unmarshal(out, &ret) require.NoError(t, err) - ret := value.([][32]byte) sort.Slice(ret, func(i int, j int) bool { return ret[i][0] < ret[j][0] }) require.Equal(t, pubKeys, ret) } @@ -736,21 +749,22 @@ func Test_ext_crypto_sr25519_sign_version_1(t *testing.T) { ks.Insert(kp) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) res, err := inst.Exec("rtm_ext_crypto_sr25519_sign_version_1", append(append(idData, encPubKey...), encMsg...)) require.NoError(t, err) - out, err := scale.Decode(res, []byte{}) + var out []byte + err = scale.Unmarshal(res, &out) require.NoError(t, err) buf := &bytes.Buffer{} - buf.Write(out.([]byte)) + buf.Write(out) value, err := new(optional.FixedSizeBytes).Decode(buf) require.NoError(t, err) @@ -772,16 +786,16 @@ func Test_ext_crypto_sr25519_verify_version_1(t *testing.T) { require.Equal(t, 0, ks.Size()) pubKeyData := kp.Public().Encode() - encPubKey, err := scale.Encode(pubKeyData) + encPubKey, err := scale.Marshal(pubKeyData) require.NoError(t, err) msgData := []byte("Hello world!") - encMsg, err := scale.Encode(msgData) + encMsg, err := scale.Marshal(msgData) require.NoError(t, err) sign, err := kp.Private().Sign(msgData) require.NoError(t, err) - encSign, err := scale.Encode(sign) + encSign, err := scale.Marshal(sign) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_crypto_sr25519_verify_version_1", append(append(encSign, encMsg...), encPubKey...)) @@ -808,16 +822,16 @@ func Test_ext_default_child_storage_read_version_1(t *testing.T) { testOffset := uint32(2) testBufferSize := uint32(100) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) - encBufferSize, err := scale.Encode(testBufferSize) + encBufferSize, err := scale.Marshal(testBufferSize) require.NoError(t, err) - encOffset, err := scale.Encode(testOffset) + encOffset, err := scale.Marshal(testOffset) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_read_version_1", append(append(encChildKey, encKey...), append(encOffset, encBufferSize...)...)) @@ -847,10 +861,10 @@ func Test_ext_default_child_storage_clear_version_1(t *testing.T) { require.NoError(t, err) require.Equal(t, testValue, val) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_clear_version_1", append(encChildKey, encKey...)) @@ -888,10 +902,10 @@ func Test_ext_default_child_storage_clear_prefix_version_1(t *testing.T) { require.NoError(t, err) require.Equal(t, 3, len(keys)) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encPrefix, err := scale.Encode(prefix) + encPrefix, err := scale.Marshal(prefix) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_clear_prefix_version_1", append(encChildKey, encPrefix...)) @@ -911,10 +925,10 @@ func Test_ext_default_child_storage_exists_version_1(t *testing.T) { err = inst.ctx.Storage.SetChildStorage(testChildKey, testKey, testValue) require.NoError(t, err) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_exists_version_1", append(encChildKey, encKey...)) @@ -937,10 +951,10 @@ func Test_ext_default_child_storage_get_version_1(t *testing.T) { err = inst.ctx.Storage.SetChildStorage(testChildKey, testKey, testValue) require.NoError(t, err) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_get_version_1", append(encChildKey, encKey...)) @@ -975,10 +989,10 @@ func Test_ext_default_child_storage_next_key_version_1(t *testing.T) { require.NoError(t, err) } - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(key) + encKey, err := scale.Marshal(key) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_next_key_version_1", append(encChildKey, encKey...)) @@ -1007,19 +1021,20 @@ func Test_ext_default_child_storage_root_version_1(t *testing.T) { rootHash, err := child.Hash() require.NoError(t, err) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) ret, err := inst.Exec("rtm_ext_default_child_storage_root_version_1", append(encChildKey, encKey...)) require.NoError(t, err) - hash, err := scale.Decode(ret, []byte{}) + var hash []byte + err = scale.Unmarshal(ret, &hash) require.NoError(t, err) // Convert decoded interface to common Hash - actualValue := common.BytesToHash(hash.([]byte)) + actualValue := common.BytesToHash(hash) require.Equal(t, rootHash, actualValue) } @@ -1034,13 +1049,13 @@ func Test_ext_default_child_storage_set_version_1(t *testing.T) { require.NoError(t, err) require.Nil(t, val) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) - encKey, err := scale.Encode(testKey) + encKey, err := scale.Marshal(testKey) require.NoError(t, err) - encVal, err := scale.Encode(testValue) + encVal, err := scale.Marshal(testValue) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_set_version_1", append(append(encChildKey, encKey...), encVal...)) @@ -1062,7 +1077,7 @@ func Test_ext_default_child_storage_storage_kill_version_1(t *testing.T) { require.NoError(t, err) require.NotNil(t, child) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) _, err = inst.Exec("rtm_ext_default_child_storage_storage_kill_version_1", encChildKey) @@ -1086,7 +1101,7 @@ func Test_ext_default_child_storage_storage_kill_version_2_limit_all(t *testing. require.NoError(t, err) require.NotNil(t, child) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) testLimit := uint32(2) @@ -1119,7 +1134,7 @@ func Test_ext_default_child_storage_storage_kill_version_2_limit_1(t *testing.T) require.NoError(t, err) require.NotNil(t, child) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) testLimit := uint32(1) @@ -1152,7 +1167,7 @@ func Test_ext_default_child_storage_storage_kill_version_2_limit_none(t *testing require.NoError(t, err) require.NotNil(t, child) - encChildKey, err := scale.Encode(testChildKey) + encChildKey, err := scale.Marshal(testChildKey) require.NoError(t, err) optLimit, err := optional.NewBytes(false, nil).Encode() @@ -1174,14 +1189,14 @@ func Test_ext_storage_append_version_1(t *testing.T) { testvalue := []byte("was") testvalueAppend := []byte("here") - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encVal, err := scale.Encode(testvalue) + encVal, err := scale.Marshal(testvalue) require.NoError(t, err) - doubleEncVal, err := scale.Encode(encVal) + doubleEncVal, err := scale.Marshal(encVal) require.NoError(t, err) - encArr, err := scale.Encode([][]byte{testvalue}) + encArr, err := scale.Marshal([][]byte{testvalue}) require.NoError(t, err) // place SCALE encoded value in storage @@ -1191,9 +1206,9 @@ func Test_ext_storage_append_version_1(t *testing.T) { val := inst.ctx.Storage.Get(testkey) require.Equal(t, encArr, val) - encValueAppend, err := scale.Encode(testvalueAppend) + encValueAppend, err := scale.Marshal(testvalueAppend) require.NoError(t, err) - doubleEncValueAppend, err := scale.Encode(encValueAppend) + doubleEncValueAppend, err := scale.Marshal(encValueAppend) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_append_version_1", append(encKey, doubleEncValueAppend...)) @@ -1201,15 +1216,16 @@ func Test_ext_storage_append_version_1(t *testing.T) { ret := inst.ctx.Storage.Get(testkey) require.NotNil(t, ret) - dec, err := scale.Decode(ret, [][]byte{}) + + var res [][]byte + err = scale.Unmarshal(ret, &res) require.NoError(t, err) - res := dec.([][]byte) require.Equal(t, 2, len(res)) require.Equal(t, testvalue, res[0]) require.Equal(t, testvalueAppend, res[1]) - expected, err := scale.Encode([][]byte{testvalue, testvalueAppend}) + expected, err := scale.Marshal([][]byte{testvalue, testvalueAppend}) require.NoError(t, err) require.Equal(t, expected, ret) } @@ -1222,14 +1238,14 @@ func Test_ext_storage_append_version_1_again(t *testing.T) { testvalue := []byte("abc") testvalueAppend := []byte("def") - encKey, err := scale.Encode(testkey) + encKey, err := scale.Marshal(testkey) require.NoError(t, err) - encVal, err := scale.Encode(testvalue) + encVal, err := scale.Marshal(testvalue) require.NoError(t, err) - doubleEncVal, err := scale.Encode(encVal) + doubleEncVal, err := scale.Marshal(encVal) require.NoError(t, err) - encArr, err := scale.Encode([][]byte{testvalue}) + encArr, err := scale.Marshal([][]byte{testvalue}) require.NoError(t, err) // place SCALE encoded value in storage @@ -1239,9 +1255,9 @@ func Test_ext_storage_append_version_1_again(t *testing.T) { val := inst.ctx.Storage.Get(testkey) require.Equal(t, encArr, val) - encValueAppend, err := scale.Encode(testvalueAppend) + encValueAppend, err := scale.Marshal(testvalueAppend) require.NoError(t, err) - doubleEncValueAppend, err := scale.Encode(encValueAppend) + doubleEncValueAppend, err := scale.Marshal(encValueAppend) require.NoError(t, err) _, err = inst.Exec("rtm_ext_storage_append_version_1", append(encKey, doubleEncValueAppend...)) @@ -1249,15 +1265,16 @@ func Test_ext_storage_append_version_1_again(t *testing.T) { ret := inst.ctx.Storage.Get(testkey) require.NotNil(t, ret) - dec, err := scale.Decode(ret, [][]byte{}) + + var res [][]byte + err = scale.Unmarshal(ret, &res) require.NoError(t, err) - res := dec.([][]byte) require.Equal(t, 2, len(res)) require.Equal(t, testvalue, res[0]) require.Equal(t, testvalueAppend, res[1]) - expected, err := scale.Encode([][]byte{testvalue, testvalueAppend}) + expected, err := scale.Marshal([][]byte{testvalue, testvalueAppend}) require.NoError(t, err) require.Equal(t, expected, ret) } @@ -1266,13 +1283,14 @@ func Test_ext_trie_blake2_256_ordered_root_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) testvalues := []string{"static", "even-keeled", "Future-proofed"} - encValues, err := scale.Encode(testvalues) + encValues, err := scale.Marshal(testvalues) require.NoError(t, err) res, err := inst.Exec("rtm_ext_trie_blake2_256_ordered_root_version_1", encValues) require.NoError(t, err) - hash, err := scale.Decode(res, []byte{}) + var hash []byte + err = scale.Unmarshal(res, &hash) require.NoError(t, err) expected := common.MustHexToHash("0xd847b86d0219a384d11458e829e9f4f4cce7e3cc2e6dcd0e8a6ad6f12c64a737") @@ -1283,14 +1301,15 @@ func Test_ext_trie_blake2_256_root_version_1(t *testing.T) { inst := NewTestInstance(t, runtime.HOST_API_TEST_RUNTIME) testinput := []string{"noot", "was", "here", "??"} - encInput, err := scale.Encode(testinput) + encInput, err := scale.Marshal(testinput) require.NoError(t, err) encInput[0] = encInput[0] >> 1 res, err := inst.Exec("rtm_ext_trie_blake2_256_root_version_1", encInput) require.NoError(t, err) - hash, err := scale.Decode(res, []byte{}) + var hash []byte + err = scale.Unmarshal(res, &hash) require.NoError(t, err) tt := trie.NewEmptyTrie() diff --git a/lib/runtime/wasmtime/exports.go b/lib/runtime/wasmtime/exports.go index ef52eacbf6..1089436327 100644 --- a/lib/runtime/wasmtime/exports.go +++ b/lib/runtime/wasmtime/exports.go @@ -22,9 +22,8 @@ import ( "github.com/ChainSafe/gossamer/dot/types" "github.com/ChainSafe/gossamer/lib/runtime" - "github.com/ChainSafe/gossamer/lib/scale" "github.com/ChainSafe/gossamer/lib/transaction" - scale2 "github.com/ChainSafe/gossamer/pkg/scale" + "github.com/ChainSafe/gossamer/pkg/scale" ) // Metadata calls runtime function Metadata_metadata @@ -59,12 +58,13 @@ func (in *Instance) BabeConfiguration() (*types.BabeConfiguration, error) { return nil, err } - cfg, err := scale.Decode(ret, new(types.BabeConfiguration)) + var cfg types.BabeConfiguration + err = scale.Unmarshal(ret, &cfg) if err != nil { return nil, err } - return cfg.(*types.BabeConfiguration), nil + return &cfg, nil } // GrandpaAuthorities returns the genesis authorities from the runtime @@ -73,13 +73,13 @@ func (in *Instance) GrandpaAuthorities() ([]types.Authority, error) { if err != nil { return nil, err } - - adr, err := scale.Decode(ret, []*types.GrandpaAuthoritiesRaw{}) + var gar []types.GrandpaAuthoritiesRaw + err = scale.Unmarshal(ret, &gar) if err != nil { return nil, err } - return types.GrandpaAuthoritiesRawToAuthorities(adr.([]types.GrandpaAuthoritiesRaw)) + return types.GrandpaAuthoritiesRawToAuthorities(gar) } // ValidateTransaction runs the extrinsic through runtime function TaggedTransactionQueue_validate_transaction and returns *Validity @@ -94,7 +94,7 @@ func (in *Instance) ValidateTransaction(e types.Extrinsic) (*transaction.Validit } v := transaction.NewValidity(0, [][]byte{{}}, [][]byte{{}}, 0, false) - _, err = scale.Decode(ret[1:], v) + err = scale.Unmarshal(ret[1:], v) return v, err } @@ -102,7 +102,7 @@ func (in *Instance) ValidateTransaction(e types.Extrinsic) (*transaction.Validit //nolint // InitializeBlock calls runtime API function Core_initialize_block func (in *Instance) InitializeBlock(header *types.Header) error { - encodedHeader, err := scale2.Marshal(*header) + encodedHeader, err := scale.Marshal(*header) if err != nil { return fmt.Errorf("cannot encode header: %w", err) } @@ -130,7 +130,7 @@ func (in *Instance) FinalizeBlock() (*types.Header, error) { } bh := types.NewEmptyHeader() - err = scale2.Unmarshal(data, bh) + err = scale.Unmarshal(data, bh) if err != nil { return nil, err }