lotus/chain/types/message.go

161 lines
3.3 KiB
Go
Raw Normal View History

package types
import (
2019-08-21 17:15:28 +00:00
"bytes"
"fmt"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/filecoin-project/specs-actors/actors/abi/big"
block "github.com/ipfs/go-block-format"
"github.com/ipfs/go-cid"
xerrors "golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
)
2020-04-27 18:35:00 +00:00
const MessageVersion = 0
2020-03-25 19:13:09 +00:00
type ChainMsg interface {
Cid() cid.Cid
VMMessage() *Message
ToStorageBlock() (block.Block, error)
// FIXME: This is the *message* length, this name is misleading.
2020-03-25 19:13:09 +00:00
ChainLength() int
}
type Message struct {
2020-04-27 18:35:00 +00:00
Version int64
To address.Address
From address.Address
Nonce uint64
Value abi.TokenAmount
// TODO: remove
// TODO: remove
GasLimit int64
GasFeeCap abi.TokenAmount
GasPremium abi.TokenAmount
Method abi.MethodNum
Params []byte
}
func (m *Message) Caller() address.Address {
return m.From
2020-02-16 22:15:01 +00:00
}
func (m *Message) Receiver() address.Address {
return m.To
2020-02-16 22:15:01 +00:00
}
func (m *Message) ValueReceived() abi.TokenAmount {
return m.Value
2020-02-16 22:15:01 +00:00
}
func DecodeMessage(b []byte) (*Message, error) {
var msg Message
2019-08-21 17:15:28 +00:00
if err := msg.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
return nil, err
}
2020-04-27 18:35:00 +00:00
if msg.Version != MessageVersion {
return nil, fmt.Errorf("decoded message had incorrect version (%d)", msg.Version)
}
return &msg, nil
}
func (m *Message) Serialize() ([]byte, error) {
2019-08-21 17:15:28 +00:00
buf := new(bytes.Buffer)
if err := m.MarshalCBOR(buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
2020-03-25 11:29:35 +00:00
func (m *Message) ChainLength() int {
ser, err := m.Serialize()
if err != nil {
panic(err)
}
return len(ser)
}
func (m *Message) ToStorageBlock() (block.Block, error) {
data, err := m.Serialize()
if err != nil {
return nil, err
}
c, err := abi.CidBuilder.Sum(data)
if err != nil {
return nil, err
}
return block.NewBlockWithCid(data, c)
}
func (m *Message) Cid() cid.Cid {
b, err := m.ToStorageBlock()
if err != nil {
2019-11-16 23:41:14 +00:00
panic(fmt.Sprintf("failed to marshal message: %s", err)) // I think this is maybe sketchy, what happens if we try to serialize a message with an undefined address in it?
}
return b.Cid()
}
func (m *Message) RequiredFunds() BigInt {
return BigMul(m.GasFeeCap, NewInt(uint64(m.GasLimit)))
}
2019-09-27 23:55:15 +00:00
func (m *Message) VMMessage() *Message {
return m
}
2019-11-19 21:27:25 +00:00
func (m *Message) Equals(o *Message) bool {
return m.Cid() == o.Cid()
}
func (m *Message) ValidForBlockInclusion(minGas int64) error {
if m.Version != 0 {
return xerrors.New("'Version' unsupported")
}
if m.To == address.Undef {
return xerrors.New("'To' address cannot be empty")
}
if m.From == address.Undef {
return xerrors.New("'From' address cannot be empty")
}
if m.Value.LessThan(big.Zero()) {
return xerrors.New("'Value' field cannot be negative")
}
if m.Value.GreaterThan(TotalFilecoinInt) {
return xerrors.New("'Value' field cannot be greater than total filecoin supply")
}
if m.GasFeeCap.LessThan(big.Zero()) {
return xerrors.New("'GasPrice' field cannot be negative")
}
if m.GasLimit > build.BlockGasLimit {
return xerrors.New("'GasLimit' field cannot be greater than a block's gas limit")
}
// since prices might vary with time, this is technically semantic validation
if m.GasLimit < minGas {
return xerrors.New("'GasLimit' field cannot be less than the cost of storing a message on chain")
}
return nil
}
const TestGasLimit = 100e6