actions

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 8, 2023 License: BSD-3-Clause Imports: 12 Imported by: 1

Documentation

Index

Constants

View Source 
const MaxMetadataSize = 256
View Source 
const WarpTransferSize = crypto.PublicKeyLen + consts.IDLen +
	consts.Uint64Len + 1 + consts.Uint64Len + consts.Uint64Len +
	consts.IDLen + consts.Uint64Len + consts.Uint64Len + consts.IDLen

Variables

View Source 
var (
	OutputValueZero              = []byte("value is zero")
	OutputAssetIsNative          = []byte("cannot mint native asset")
	OutputAssetAlreadyExists     = []byte("asset already exists")
	OutputAssetMissing           = []byte("asset missing")
	OutputInTickZero             = []byte("in rate is zero")
	OutputOutTickZero            = []byte("out rate is zero")
	OutputSupplyZero             = []byte("supply is zero")
	OutputSupplyMisaligned       = []byte("supply is misaligned")
	OutputOrderMissing           = []byte("order is missing")
	OutputUnauthorized           = []byte("unauthorized")
	OutputWrongIn                = []byte("wrong in asset")
	OutputWrongOut               = []byte("wrong out asset")
	OutputWrongOwner             = []byte("wrong owner")
	OutputInsufficientInput      = []byte("insufficient input")
	OutputInsufficientOutput     = []byte("insufficient output")
	OutputValueMisaligned        = []byte("value is misaligned")
	OutputMetadataTooLarge       = []byte("metadata is too large")
	OutputSameInOut              = []byte("same asset used for in and out")
	OutputConflictingAsset       = []byte("warp has same asset as another")
	OutputAnycast                = []byte("anycast output")
	OutputNotWarpAsset           = []byte("not warp asset")
	OutputWarpAsset              = []byte("warp asset")
	OutputWrongDestination       = []byte("wrong destination")
	OutputMustFill               = []byte("must fill request")
	OutputWarpVerificationFailed = []byte("warp verification failed")
)
View Source 
var ErrNoSwapToFill = errors.New("no swap to fill")

Functions

func ImportedAssetID 

func ImportedAssetID(assetID ids.ID, sourceChainID ids.ID) ids.ID

func ImportedAssetMetadata 

func ImportedAssetMetadata(assetID ids.ID, sourceChainID ids.ID) []byte

func UnmarshalBurnAsset 

func UnmarshalBurnAsset(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func UnmarshalCreateAsset 

func UnmarshalCreateAsset(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func UnmarshalExportAsset 

func UnmarshalExportAsset(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func UnmarshalImportAsset 

func UnmarshalImportAsset(p *codec.Packer, wm *warp.Message) (chain.Action, error)

func UnmarshalMintAsset 

func UnmarshalMintAsset(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func UnmarshalModifyAsset 

func UnmarshalModifyAsset(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func UnmarshalSequencerMsg 

func UnmarshalSequencerMsg(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func UnmarshalTransfer 

func UnmarshalTransfer(p *codec.Packer, _ *warp.Message) (chain.Action, error)

func ValidSwapParams 

func ValidSwapParams(
	value uint64,
	swapIn uint64,
	assetOut ids.ID,
	swapOut uint64,
	swapExpiry int64,
) bool

Types

type BurnAsset 

type BurnAsset struct {
	// Asset is the [TxID] that created the asset.
	Asset ids.ID `json:"asset"`

	// Number of assets to mint to [To].
	Value uint64 `json:"value"`
}

func (*BurnAsset) Execute 

func (b *BurnAsset) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	_ ids.ID,
	_ bool,
) (*chain.Result, error)

func (*BurnAsset) Marshal 

func (b *BurnAsset) Marshal(p *codec.Packer)

func (*BurnAsset) MaxUnits 

func (*BurnAsset) MaxUnits(chain.Rules) uint64

func (*BurnAsset) StateKeys 

func (b *BurnAsset) StateKeys(rauth chain.Auth, _ ids.ID) [][]byte

func (*BurnAsset) ValidRange 

func (*BurnAsset) ValidRange(chain.Rules) (int64, int64)

type CreateAsset 

type CreateAsset struct {
	// Metadata is creator-specified information about the asset. This can be
	// modified using the [ModifyAsset] action.
	Metadata []byte `json:"metadata"`
}

func (*CreateAsset) Execute 

func (c *CreateAsset) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	txID ids.ID,
	_ bool,
) (*chain.Result, error)

func (*CreateAsset) Marshal 

func (c *CreateAsset) Marshal(p *codec.Packer)

func (*CreateAsset) MaxUnits 

func (c *CreateAsset) MaxUnits(chain.Rules) uint64

func (*CreateAsset) StateKeys 

func (*CreateAsset) StateKeys(_ chain.Auth, txID ids.ID) [][]byte

func (*CreateAsset) ValidRange 

func (*CreateAsset) ValidRange(chain.Rules) (int64, int64)

type ExportAsset 

type ExportAsset struct {
	To          crypto.PublicKey `json:"to"`
	Asset       ids.ID           `json:"asset"`
	Value       uint64           `json:"value"`
	Return      bool             `json:"return"`
	Reward      uint64           `json:"reward"`
	SwapIn      uint64           `json:"swapIn"`
	AssetOut    ids.ID           `json:"assetOut"`
	SwapOut     uint64           `json:"swapOut"`
	SwapExpiry  int64            `json:"swapExpiry"`
	Destination ids.ID           `json:"destination"`
}

func (*ExportAsset) Execute 

func (e *ExportAsset) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	txID ids.ID,
	_ bool,
) (*chain.Result, error)

func (*ExportAsset) Marshal 

func (e *ExportAsset) Marshal(p *codec.Packer)

func (*ExportAsset) MaxUnits 

func (*ExportAsset) MaxUnits(chain.Rules) uint64

func (*ExportAsset) StateKeys 

func (e *ExportAsset) StateKeys(rauth chain.Auth, _ ids.ID) [][]byte

func (*ExportAsset) ValidRange 

func (*ExportAsset) ValidRange(chain.Rules) (int64, int64)

type ImportAsset 

type ImportAsset struct {
	// Fill indicates if the actor wishes to fill the order request in the warp
	// message. This must be true if the warp message is in a block with
	// a timestamp < [SwapExpiry].
	Fill bool `json:"fill"`
	// contains filtered or unexported fields
}

func (*ImportAsset) Execute 

func (i *ImportAsset) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	t int64,
	rauth chain.Auth,
	_ ids.ID,
	warpVerified bool,
) (*chain.Result, error)

func (*ImportAsset) Marshal 

func (i *ImportAsset) Marshal(p *codec.Packer)

All we encode that is action specific for now is the type byte from the registry.

func (*ImportAsset) MaxUnits 

func (i *ImportAsset) MaxUnits(chain.Rules) uint64

func (*ImportAsset) StateKeys 

func (i *ImportAsset) StateKeys(rauth chain.Auth, _ ids.ID) [][]byte

func (*ImportAsset) ValidRange 

func (*ImportAsset) ValidRange(chain.Rules) (int64, int64)

type MintAsset 

type MintAsset struct {
	// To is the recipient of the [Value].
	To crypto.PublicKey `json:"to"`

	// Asset is the [TxID] that created the asset.
	Asset ids.ID `json:"asset"`

	// Number of assets to mint to [To].
	Value uint64 `json:"value"`
}

func (*MintAsset) Execute 

func (m *MintAsset) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	_ ids.ID,
	_ bool,
) (*chain.Result, error)

func (*MintAsset) Marshal 

func (m *MintAsset) Marshal(p *codec.Packer)

func (*MintAsset) MaxUnits 

func (*MintAsset) MaxUnits(chain.Rules) uint64

func (*MintAsset) StateKeys 

func (m *MintAsset) StateKeys(chain.Auth, ids.ID) [][]byte

func (*MintAsset) ValidRange 

func (*MintAsset) ValidRange(chain.Rules) (int64, int64)

type ModifyAsset 

type ModifyAsset struct {
	// Asset is the [TxID] that created the asset.
	Asset ids.ID

	// Owner will be the new owner of the [Asset].
	//
	// If you want to retain ownership, set this to the signer. If you want to
	// revoke ownership, set this to another key or the empty public key.
	Owner crypto.PublicKey `json:"owner"`

	// Metadata is the new metadata of the [Asset].
	//
	// If you want this to stay the same, you must set it to be the same value.
	Metadata []byte `json:"metadata"`
}

func (*ModifyAsset) Execute 

func (m *ModifyAsset) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	_ ids.ID,
	_ bool,
) (*chain.Result, error)

func (*ModifyAsset) Marshal 

func (m *ModifyAsset) Marshal(p *codec.Packer)

func (*ModifyAsset) MaxUnits 

func (m *ModifyAsset) MaxUnits(chain.Rules) uint64

func (*ModifyAsset) StateKeys 

func (m *ModifyAsset) StateKeys(chain.Auth, ids.ID) [][]byte

func (*ModifyAsset) ValidRange 

func (*ModifyAsset) ValidRange(chain.Rules) (int64, int64)

type SequencerMsg 

type SequencerMsg struct {
	//TODO might need to add this back in at some point but rn it should be fine
	ChainId     []byte           `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	Data        []byte           `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	FromAddress crypto.PublicKey `json:"from_address"`
}

func (*SequencerMsg) Execute 

func (t *SequencerMsg) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	_ ids.ID,
	_ bool,
) (*chain.Result, error)

func (*SequencerMsg) Marshal 

func (t *SequencerMsg) Marshal(p *codec.Packer)

func (*SequencerMsg) MaxUnits 

func (*SequencerMsg) MaxUnits(chain.Rules) uint64

func (*SequencerMsg) StateKeys 

func (t *SequencerMsg) StateKeys(rauth chain.Auth, _ ids.ID) [][]byte

func (*SequencerMsg) ValidRange 

func (*SequencerMsg) ValidRange(chain.Rules) (int64, int64)

type Transfer 

type Transfer struct {
	// To is the recipient of the [Value].
	To crypto.PublicKey `json:"to"`

	// Asset to transfer to [To].
	Asset ids.ID

	// Amount are transferred to [To].
	Value uint64 `json:"value"`
}

func (*Transfer) Execute 

func (t *Transfer) Execute(
	ctx context.Context,
	r chain.Rules,
	db chain.Database,
	_ int64,
	rauth chain.Auth,
	_ ids.ID,
	_ bool,
) (*chain.Result, error)

func (*Transfer) Marshal 

func (t *Transfer) Marshal(p *codec.Packer)

func (*Transfer) MaxUnits 

func (*Transfer) MaxUnits(chain.Rules) uint64

func (*Transfer) StateKeys 

func (t *Transfer) StateKeys(rauth chain.Auth, _ ids.ID) [][]byte

func (*Transfer) ValidRange 

func (*Transfer) ValidRange(chain.Rules) (int64, int64)

type WarpTransfer 

type WarpTransfer struct {
	To    crypto.PublicKey `json:"to"`
	Asset ids.ID           `json:"asset"`
	Value uint64           `json:"value"`

	// Return is set to true when a warp message is sending funds back to the
	// chain where they were created.
	Return bool `json:"return"`

	// Reward is the amount of [Asset] to send the [Actor] that submits this
	// transaction.
	Reward uint64 `json:"reward"`

	// SwapIn is the amount of [Asset] we are willing to swap for [AssetOut].
	SwapIn uint64 `json:"swapIn"`
	// AssetOut is the asset we are seeking to get for [SwapIn].
	AssetOut ids.ID `json:"assetOut"`
	// SwapOut is the amount of [AssetOut] we are seeking.
	SwapOut uint64 `json:"swapOut"`
	// SwapExpiry is the unix timestamp at which the swap becomes invalid (and
	// the message can be processed without a swap.
	SwapExpiry int64 `json:"swapExpiry"`

	// TxID is the transaction that created this message. This is used to ensure
	// there is WarpID uniqueness.
	TxID ids.ID `json:"txID"`
}

func UnmarshalWarpTransfer 

func UnmarshalWarpTransfer(b []byte) (*WarpTransfer, error)

func (*WarpTransfer) Marshal 

func (w *WarpTransfer) Marshal() ([]byte, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.