7633439845
Our block.Block was JSONized in a bit different fashion than result.Block in its NextConsensus and Index fields. It's not good for notifications because third-party clients would probably expect to see the same format. Also, using completely different Block representation is probably making our client a bit weaker as this representation is harder to use with other neo-go components. So use the same approach we took for Transactions and wrap block.Block which is to be serialized in proper way. Fix `Script` JSONization along the way, 3.0 node wraps it within `witnesses`.
87 lines
2.1 KiB
Go
87 lines
2.1 KiB
Go
package result
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
|
|
"github.com/nspcc-dev/neo-go/pkg/core/block"
|
|
"github.com/nspcc-dev/neo-go/pkg/core/blockchainer"
|
|
"github.com/nspcc-dev/neo-go/pkg/io"
|
|
"github.com/nspcc-dev/neo-go/pkg/util"
|
|
)
|
|
|
|
type (
|
|
// Block wrapper used for the representation of
|
|
// block.Block / block.Base on the RPC Server.
|
|
Block struct {
|
|
*block.Block
|
|
BlockMetadata
|
|
}
|
|
|
|
// BlockMetadata is an additional metadata added to standard
|
|
// block.Block.
|
|
BlockMetadata struct {
|
|
Size int `json:"size"`
|
|
NextBlockHash *util.Uint256 `json:"nextblockhash,omitempty"`
|
|
Confirmations uint32 `json:"confirmations"`
|
|
}
|
|
)
|
|
|
|
// NewBlock creates a new Block wrapper.
|
|
func NewBlock(b *block.Block, chain blockchainer.Blockchainer) Block {
|
|
res := Block{
|
|
Block: b,
|
|
BlockMetadata: BlockMetadata{
|
|
Size: io.GetVarSize(b),
|
|
Confirmations: chain.BlockHeight() - b.Index - 1,
|
|
},
|
|
}
|
|
|
|
hash := chain.GetHeaderHash(int(b.Index) + 1)
|
|
if !hash.Equals(util.Uint256{}) {
|
|
res.NextBlockHash = &hash
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
// MarshalJSON implements json.Marshaler interface.
|
|
func (b Block) MarshalJSON() ([]byte, error) {
|
|
output, err := json.Marshal(b.BlockMetadata)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
baseBytes, err := json.Marshal(b.Block)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// We have to keep both "fields" at the same level in json in order to
|
|
// match C# API, so there's no way to marshall Block correctly with
|
|
// standard json.Marshaller tool.
|
|
if output[len(output)-1] != '}' || baseBytes[0] != '{' {
|
|
return nil, errors.New("can't merge internal jsons")
|
|
}
|
|
output[len(output)-1] = ','
|
|
output = append(output, baseBytes[1:]...)
|
|
return output, nil
|
|
}
|
|
|
|
// UnmarshalJSON implements json.Unmarshaler interface.
|
|
func (b *Block) UnmarshalJSON(data []byte) error {
|
|
// As block.Block and BlockMetadata are at the same level in json,
|
|
// do unmarshalling separately for both structs.
|
|
meta := new(BlockMetadata)
|
|
base := new(block.Block)
|
|
err := json.Unmarshal(data, meta)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = json.Unmarshal(data, base)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
b.Block = base
|
|
b.BlockMetadata = *meta
|
|
return nil
|
|
}
|