The highest tagged major version is v2.

payload

package

v1.29.2 Latest Latest Go to latest Published: Jun 6, 2026 License: BSD-3-Clause Imports: 5 Imported by: 1

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/luxfi/node

Links

Open Source Insights

README ¶

Payload

An Lux 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 ¶

View Source

const (
	CodecVersion = 0

	MaxMessageSize = 24 * constants.KiB
)

Variables ¶

View Source

var Codec pcodecs.Manager

View Source

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

Functions ¶

This section is empty.

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)

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL