payload

README

Payload

An Avalanche Unsigned Warp Message already includes a networkID, sourceChainID, and payload field. The payload field can be parsed into one of the types included in this package to be further handled by the VM.

Hash

Hash:

+-----------------+----------+-----------+
|         codecID :   uint16 |   2 bytes |
+-----------------+----------+-----------+
|          typeID :   uint32 |   4 bytes |
+-----------------+----------+-----------+
|            hash : [32]byte |  32 bytes |
+-----------------+----------+-----------+
                             |  38 bytes |
                             +-----------+

• codecID is the codec version used to serialize the payload and is hardcoded to 0x0000
• typeID is the payload type identifier and is 0x00000000 for Hash
• hash is a hash from the sourceChainID. The format of the expected preimage is chain specific. Some examples for valid hash values are:
  • root of a merkle tree
  • accepted block hash on the source chain
  • accepted transaction hash on the source chain

AddressedCall

AddressedCall:

+---------------------+--------+----------------------------------+
|             codecID : uint16 |                          2 bytes |
+---------------------+--------+----------------------------------+
|              typeID : uint32 |                          4 bytes |
+---------------------+--------+----------------------------------+
|       sourceAddress : []byte |                 4 + len(address) |
+---------------------+--------+----------------------------------+
|             payload : []byte |                 4 + len(payload) |
+---------------------+--------+----------------------------------+
                               | 14 + len(payload) + len(address) |
                               +----------------------------------+

• codecID is the codec version used to serialize the payload and is hardcoded to 0x0000
• typeID is the payload type identifier and is 0x00000001 for AddressedCall
• sourceAddress is the address that sent this message from the source chain
• payload is an arbitrary byte array payload

Documentation

Index

• Constants
• Variables
• type AddressedCall
  • func NewAddressedCall(sourceAddress []byte, payload []byte) (*AddressedCall, error)
  • func ParseAddressedCall(b []byte) (*AddressedCall, error)
  • func (a *AddressedCall) Bytes() []byte
• type Hash
  • func NewHash(hash ids.ID) (*Hash, error)
  • func ParseHash(b []byte) (*Hash, error)
  • func (b *Hash) Bytes() []byte
• type Payload
  • func Parse(bytes []byte) (Payload, error)

Constants

const (
	CodecVersion = 0

	MaxMessageSize = 24 * units.KiB
)

Variables

var Codec codec.Manager

var ErrWrongType = errors.New("wrong payload type")

Types

type AddressedCall

type AddressedCall struct {
	SourceAddress []byte `serialize:"true"`
	Payload       []byte `serialize:"true"`
	// contains filtered or unexported fields
}

AddressedCall defines the format for delivering a call across VMs including a source address and a payload.

Note: If a destination address is expected, it should be encoded in the payload.

func NewAddressedCall

func NewAddressedCall(sourceAddress []byte, payload []byte) (*AddressedCall, error)

NewAddressedCall creates a new *AddressedCall and initializes it.

func ParseAddressedCall

func ParseAddressedCall(b []byte) (*AddressedCall, error)

ParseAddressedCall converts a slice of bytes into an initialized AddressedCall.

func (*AddressedCall) Bytes

func (a *AddressedCall) Bytes() []byte

Bytes returns the binary representation of this payload. It assumes that the payload is initialized from either NewAddressedCall or Parse.

type Hash

type Hash struct {
	Hash ids.ID `serialize:"true"`
	// contains filtered or unexported fields
}

func NewHash

func NewHash(hash ids.ID) (*Hash, error)

NewHash creates a new *Hash and initializes it.

func ParseHash

func ParseHash(b []byte) (*Hash, error)

ParseHash converts a slice of bytes into an initialized Hash.

func (*Hash) Bytes

func (b *Hash) Bytes() []byte

Bytes returns the binary representation of this payload. It assumes that the payload is initialized from either NewHash or Parse.

type Payload

type Payload interface {
	// Bytes returns the binary representation of this payload.
	Bytes() []byte
	// contains filtered or unexported methods
}

Payload provides a common interface for all payloads implemented by this package.

func Parse

func Parse(bytes []byte) (Payload, error)