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
}