implementation

package
v0.0.7-alphanet Latest Latest
Warning

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

 Go to latest Published: Aug 11, 2023 License: GPL-3.0 Imports: 25 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	SwapRetrieveAssets       = 1
	SwapRetrieveLegacyPillar = 2
)

Variables

This section is empty.

Functions

func ApplyDecay 

func ApplyDecay(deposit *definition.SwapAssets, currentEpoch int)

func CanPerformAction 

func CanPerformAction(context vm_context.AccountVmContext) (*definition.BridgeInfoVariable, *definition.OrchestratorInfo, error)

func CanPerformEpochUpdate 

func CanPerformEpochUpdate(context vm_context.AccountVmContext, epoch *definition.LastEpochUpdate) error

CanPerformEpochUpdate checks if embedded contract can perform an epoch update, used most commonly to give rewards

  • returns util.EpochUpdateNotDue if not due

func CanPerformUpdate 

func CanPerformUpdate(context vm_context.AccountVmContext) error

CanPerformUpdate checks if embedded contract can be updated

  • returns util.ErrUpdateTooRecent if not due

func CheckBridgeHalted 

func CheckBridgeHalted(bridgeInfo *definition.BridgeInfoVariable, context vm_context.AccountVmContext) error

func CheckBridgeInitialized 

func CheckBridgeInitialized(context vm_context.AccountVmContext) (*definition.BridgeInfoVariable, error)

func CheckECDSASignature 

func CheckECDSASignature(message []byte, pubKeyStr, signatureStr string) (bool, error)

func CheckNetworkAndPairExist 

func CheckNetworkAndPairExist(context vm_context.AccountVmContext, networkClass uint32, chainId uint32, ztsOrToken string) (*definition.TokenPair, error)

CheckNetworkAndPairExist for unwrapping we return the associated zts for wrapping we return the associated tokenAddress

func CheckOrchestratorInfoInitialized 

func CheckOrchestratorInfoInitialized(context vm_context.AccountVmContext) (*definition.OrchestratorInfo, error)

func CheckSecurityInitialized 

func CheckSecurityInitialized(context vm_context.AccountVmContext) (*definition.SecurityInfoVariable, error)

func CheckSwapSignature 

func CheckSwapSignature(messageType int, addr types.Address, pubKeyStr string, signatureStr string) (bool, error)

func GetBasicMethodMessage 

func GetBasicMethodMessage(methodName string, tssNonce uint64, networkClass uint32, chainId uint64) ([]byte, error)

func GetChangePubKeyMessage 

func GetChangePubKeyMessage(methodName string, networkClass uint32, chainId, tssNonce uint64, pubKey string) ([]byte, error)

func GetHtlcProxyUnlockStatus 

func GetHtlcProxyUnlockStatus(context vm_context.AccountVmContext, address types.Address) (bool, error)

Neither the DenyProxyUnlock nor the AllowProxyUnlock methods delete the HtlcProxyUnlockInfo in storage This means there are really 3 states: Default, ExplicitDeny, ExplicitAllow And once an address has explicitly denied/allowed proxy unlock, it can no longer go back to using the default This is to ensure that if we ever change the default to deny, addresses that have called the Allow method will still work as expected

func GetMessageToSignEvm 

func GetMessageToSignEvm(data []byte) ([]byte, error)

func GetQsrCostForNextPillar 

func GetQsrCostForNextPillar(context vm_context.AccountVmContext) (*big.Int, error)

GetQsrCostForNextPillar returns PillarQsrStakeBaseAmount * PillarQsrStakeIncreaseAmount * len(definition.NormalPillarType)

func GetSentinelRevokeStatus 

func GetSentinelRevokeStatus(registrationTime int64, m *nom.Momentum) (bool, int64)

GetSentinelRevokeStatus returns true, timeWhileCanRevoke if sentinel *can* be revoked GetSentinelRevokeStatus returns false, timeUntilCanRevoke if sentinel *can't* be revoked

func GetSwapMessage 

func GetSwapMessage(operationMessage string, pubKey string, addr types.Address) []byte

func GetUnwrapTokenRequestMessage 

func GetUnwrapTokenRequestMessage(param *definition.UnwrapTokenParam) ([]byte, error)

func GetWrapTokenRequestMessage 

func GetWrapTokenRequestMessage(request *definition.WrapTokenRequest, contractAddress *ecommon.Address) ([]byte, error)

func HashByNetworkClass 

func HashByNetworkClass(data []byte, networkClass uint32) ([]byte, error)

func IsAcceleratorRunning 

func IsAcceleratorRunning(context vm_context.AccountVmContext) error

func IsJSON 

func IsJSON(s string) bool

func PillarGetRevokeStatus 

func PillarGetRevokeStatus(old *definition.PillarInfo, m *nom.Momentum) (bool, int64)

PillarGetRevokeStatus returns status and cooldown. If Pillar *can* be revoked, returns 

true, timeWhileCanRevoke

If Pillar *can't* be revoked, returns 

false, timeUntilCanRevoke

func PubKeyToKeyId 

func PubKeyToKeyId(pubKey []byte) []byte

func PubKeyToKeyIdHash 

func PubKeyToKeyIdHash(pubKey []byte) types.Hash

func SignLegacyPillarMessage 

func SignLegacyPillarMessage(address types.Address, prv []byte, pub string) (string, error)

SignLegacyPillarMessage is used for in contract tests

func SignRetrieveAssetsMessage 

func SignRetrieveAssetsMessage(address types.Address, prv []byte, pub string) (string, error)

SignRetrieveAssetsMessage is used for in contract tests

func TimeChallenge 

func TimeChallenge(context vm_context.AccountVmContext, methodName string, hash []byte, delay uint64) (*definition.TimeChallengeInfo, error)

Types

type ActivateSporkMethod 

type ActivateSporkMethod struct {
	MethodName string
}

func (*ActivateSporkMethod) GetPlasma 

func (p *ActivateSporkMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ActivateSporkMethod) ReceiveBlock 

func (p *ActivateSporkMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ActivateSporkMethod) ValidateSendBlock 

func (p *ActivateSporkMethod) ValidateSendBlock(block *nom.AccountBlock) error

type AddPhaseMethod 

type AddPhaseMethod struct {
	MethodName string
}

func (*AddPhaseMethod) Fee 

func (p *AddPhaseMethod) Fee() (*big.Int, error)

func (*AddPhaseMethod) GetPlasma 

func (p *AddPhaseMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*AddPhaseMethod) ReceiveBlock 

func (p *AddPhaseMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*AddPhaseMethod) ValidateSendBlock 

func (p *AddPhaseMethod) ValidateSendBlock(block *nom.AccountBlock) error

type AllowHtlcProxyUnlockMethod 

type AllowHtlcProxyUnlockMethod struct {
	MethodName string
}

func (*AllowHtlcProxyUnlockMethod) GetPlasma 

func (p *AllowHtlcProxyUnlockMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*AllowHtlcProxyUnlockMethod) ReceiveBlock 

func (p *AllowHtlcProxyUnlockMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*AllowHtlcProxyUnlockMethod) ValidateSendBlock 

func (p *AllowHtlcProxyUnlockMethod) ValidateSendBlock(block *nom.AccountBlock) error

type BurnMethod 

type BurnMethod struct {
	MethodName string
}

func (*BurnMethod) GetPlasma 

func (p *BurnMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*BurnMethod) ReceiveBlock 

func (p *BurnMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*BurnMethod) ValidateSendBlock 

func (p *BurnMethod) ValidateSendBlock(block *nom.AccountBlock) error

type BurnZnnMethod 

type BurnZnnMethod struct {
	MethodName string
}

func (*BurnZnnMethod) Fee 

func (p *BurnZnnMethod) Fee() (*big.Int, error)

func (*BurnZnnMethod) GetPlasma 

func (p *BurnZnnMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*BurnZnnMethod) ReceiveBlock 

func (p *BurnZnnMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*BurnZnnMethod) ValidateSendBlock 

func (p *BurnZnnMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CancelFuseMethod 

type CancelFuseMethod struct {
	MethodName string
}

func (*CancelFuseMethod) GetPlasma 

func (p *CancelFuseMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CancelFuseMethod) ReceiveBlock 

func (p *CancelFuseMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CancelFuseMethod) ValidateSendBlock 

func (p *CancelFuseMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CancelLiquidityStakeMethod 

type CancelLiquidityStakeMethod struct {
	MethodName string
}

func (*CancelLiquidityStakeMethod) GetPlasma 

func (p *CancelLiquidityStakeMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CancelLiquidityStakeMethod) ReceiveBlock 

func (p *CancelLiquidityStakeMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CancelLiquidityStakeMethod) ValidateSendBlock 

func (p *CancelLiquidityStakeMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CancelStakeMethod 

type CancelStakeMethod struct {
	MethodName string
}

func (*CancelStakeMethod) GetPlasma 

func (p *CancelStakeMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CancelStakeMethod) ReceiveBlock 

func (p *CancelStakeMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CancelStakeMethod) ValidateSendBlock 

func (p *CancelStakeMethod) ValidateSendBlock(block *nom.AccountBlock) error

type ChangeAdministratorLiquidity 

type ChangeAdministratorLiquidity struct {
	MethodName string
}

func (*ChangeAdministratorLiquidity) GetPlasma 

func (p *ChangeAdministratorLiquidity) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ChangeAdministratorLiquidity) ReceiveBlock 

func (p *ChangeAdministratorLiquidity) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ChangeAdministratorLiquidity) ValidateSendBlock 

func (p *ChangeAdministratorLiquidity) ValidateSendBlock(block *nom.AccountBlock) error

type ChangeAdministratorMethod 

type ChangeAdministratorMethod struct {
	MethodName string
}

func (*ChangeAdministratorMethod) GetPlasma 

func (p *ChangeAdministratorMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ChangeAdministratorMethod) ReceiveBlock 

func (p *ChangeAdministratorMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ChangeAdministratorMethod) ValidateSendBlock 

func (p *ChangeAdministratorMethod) ValidateSendBlock(block *nom.AccountBlock) error

type ChangeTssECDSAPubKeyMethod 

type ChangeTssECDSAPubKeyMethod struct {
	MethodName string
}

func (*ChangeTssECDSAPubKeyMethod) GetPlasma 

func (p *ChangeTssECDSAPubKeyMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ChangeTssECDSAPubKeyMethod) ReceiveBlock 

func (p *ChangeTssECDSAPubKeyMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ChangeTssECDSAPubKeyMethod) ValidateSendBlock 

func (p *ChangeTssECDSAPubKeyMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CollectRewardMethod 

type CollectRewardMethod struct {
	MethodName string
	Plasma     uint64
}

CollectRewardMethod is a common embedded.method used to issue tokens to users based on RewardDeposit object. When issuing rewards, the embedded adds the respected value in the RewardDeposit object in the DB and afterwards, the users will call this method to receive the tokens.

func (*CollectRewardMethod) GetPlasma 

func (p *CollectRewardMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CollectRewardMethod) ReceiveBlock 

func (p *CollectRewardMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CollectRewardMethod) ValidateSendBlock 

func (p *CollectRewardMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CreateHtlcMethod 

type CreateHtlcMethod struct {
	MethodName string
}

func (*CreateHtlcMethod) GetPlasma 

func (p *CreateHtlcMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CreateHtlcMethod) ReceiveBlock 

func (p *CreateHtlcMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CreateHtlcMethod) ValidateSendBlock 

func (p *CreateHtlcMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CreateProjectMethod 

type CreateProjectMethod struct {
	MethodName string
}

func (*CreateProjectMethod) GetPlasma 

func (p *CreateProjectMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CreateProjectMethod) ReceiveBlock 

func (p *CreateProjectMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CreateProjectMethod) ValidateSendBlock 

func (p *CreateProjectMethod) ValidateSendBlock(block *nom.AccountBlock) error

type CreateSporkMethod 

type CreateSporkMethod struct {
	MethodName string
}

func (*CreateSporkMethod) GetPlasma 

func (p *CreateSporkMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*CreateSporkMethod) ReceiveBlock 

func (p *CreateSporkMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*CreateSporkMethod) ValidateSendBlock 

func (p *CreateSporkMethod) ValidateSendBlock(block *nom.AccountBlock) error

type DelegateMethod 

type DelegateMethod struct {
	MethodName string
}

func (*DelegateMethod) GetPlasma 

func (p *DelegateMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*DelegateMethod) ReceiveBlock 

func (p *DelegateMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*DelegateMethod) ValidateSendBlock 

func (p *DelegateMethod) ValidateSendBlock(block *nom.AccountBlock) error

type DenyHtlcProxyUnlockMethod 

type DenyHtlcProxyUnlockMethod struct {
	MethodName string
}

func (*DenyHtlcProxyUnlockMethod) GetPlasma 

func (p *DenyHtlcProxyUnlockMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*DenyHtlcProxyUnlockMethod) ReceiveBlock 

func (p *DenyHtlcProxyUnlockMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*DenyHtlcProxyUnlockMethod) ValidateSendBlock 

func (p *DenyHtlcProxyUnlockMethod) ValidateSendBlock(block *nom.AccountBlock) error

type DepositQsrMethod 

type DepositQsrMethod struct {
	MethodName string
}

func (*DepositQsrMethod) GetPlasma 

func (p *DepositQsrMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*DepositQsrMethod) ReceiveBlock 

func (p *DepositQsrMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*DepositQsrMethod) ValidateSendBlock 

func (p *DepositQsrMethod) ValidateSendBlock(block *nom.AccountBlock) error

type DonateMethod 

type DonateMethod struct {
	MethodName string
}

func (*DonateMethod) GetPlasma 

func (p *DonateMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*DonateMethod) ReceiveBlock 

func (p *DonateMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*DonateMethod) ValidateSendBlock 

func (p *DonateMethod) ValidateSendBlock(block *nom.AccountBlock) error

type EmergencyLiquidity 

type EmergencyLiquidity struct {
	MethodName string
}

func (*EmergencyLiquidity) GetPlasma 

func (p *EmergencyLiquidity) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*EmergencyLiquidity) ReceiveBlock 

func (p *EmergencyLiquidity) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*EmergencyLiquidity) ValidateSendBlock 

func (p *EmergencyLiquidity) ValidateSendBlock(block *nom.AccountBlock) error

type EmergencyMethod 

type EmergencyMethod struct {
	MethodName string
}

func (*EmergencyMethod) GetPlasma 

func (p *EmergencyMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*EmergencyMethod) ReceiveBlock 

func (p *EmergencyMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*EmergencyMethod) ValidateSendBlock 

func (p *EmergencyMethod) ValidateSendBlock(block *nom.AccountBlock) error

type FundMethod 

type FundMethod struct {
	MethodName string
}

func (*FundMethod) Fee 

func (p *FundMethod) Fee() (*big.Int, error)

func (*FundMethod) GetPlasma 

func (p *FundMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*FundMethod) ReceiveBlock 

func (p *FundMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*FundMethod) ValidateSendBlock 

func (p *FundMethod) ValidateSendBlock(block *nom.AccountBlock) error

type FuseMethod 

type FuseMethod struct {
	MethodName string
}

func (*FuseMethod) GetPlasma 

func (p *FuseMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*FuseMethod) ReceiveBlock 

func (p *FuseMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*FuseMethod) ValidateSendBlock 

func (p *FuseMethod) ValidateSendBlock(block *nom.AccountBlock) error

type HaltMethod 

type HaltMethod struct {
	MethodName string
}

func (*HaltMethod) GetPlasma 

func (p *HaltMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*HaltMethod) ReceiveBlock 

func (p *HaltMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*HaltMethod) ValidateSendBlock 

func (p *HaltMethod) ValidateSendBlock(block *nom.AccountBlock) error

type IssueMethod 

type IssueMethod struct {
	MethodName string
}

func (*IssueMethod) GetPlasma 

func (p *IssueMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*IssueMethod) ReceiveBlock 

func (p *IssueMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*IssueMethod) ValidateSendBlock 

func (p *IssueMethod) ValidateSendBlock(block *nom.AccountBlock) error

type LegacyRegisterMethod 

type LegacyRegisterMethod struct {
	MethodName string
}

func (*LegacyRegisterMethod) GetPlasma 

func (p *LegacyRegisterMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*LegacyRegisterMethod) ReceiveBlock 

func (p *LegacyRegisterMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*LegacyRegisterMethod) ValidateSendBlock 

func (p *LegacyRegisterMethod) ValidateSendBlock(block *nom.AccountBlock) error

type LiquidityStakeMethod 

type LiquidityStakeMethod struct {
	MethodName string
}

func (*LiquidityStakeMethod) GetPlasma 

func (p *LiquidityStakeMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*LiquidityStakeMethod) ReceiveBlock 

func (p *LiquidityStakeMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*LiquidityStakeMethod) ValidateSendBlock 

func (p *LiquidityStakeMethod) ValidateSendBlock(block *nom.AccountBlock) error

type MintMethod 

type MintMethod struct {
	MethodName string
}

func (*MintMethod) GetPlasma 

func (p *MintMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*MintMethod) ReceiveBlock 

func (p *MintMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*MintMethod) ValidateSendBlock 

func (p *MintMethod) ValidateSendBlock(block *nom.AccountBlock) error

type NominateGuardiansLiquidity 

type NominateGuardiansLiquidity struct {
	MethodName string
}

func (*NominateGuardiansLiquidity) GetPlasma 

func (p *NominateGuardiansLiquidity) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*NominateGuardiansLiquidity) ReceiveBlock 

func (p *NominateGuardiansLiquidity) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*NominateGuardiansLiquidity) ValidateSendBlock 

func (p *NominateGuardiansLiquidity) ValidateSendBlock(block *nom.AccountBlock) error

type NominateGuardiansMethod 

type NominateGuardiansMethod struct {
	MethodName string
}

func (*NominateGuardiansMethod) GetPlasma 

func (p *NominateGuardiansMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*NominateGuardiansMethod) ReceiveBlock 

func (p *NominateGuardiansMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*NominateGuardiansMethod) ValidateSendBlock 

func (p *NominateGuardiansMethod) ValidateSendBlock(block *nom.AccountBlock) error

type ProposeAdministratorLiquidity 

type ProposeAdministratorLiquidity struct {
	MethodName string
}

func (*ProposeAdministratorLiquidity) GetPlasma 

func (p *ProposeAdministratorLiquidity) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ProposeAdministratorLiquidity) ReceiveBlock 

func (p *ProposeAdministratorLiquidity) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ProposeAdministratorLiquidity) ValidateSendBlock 

func (p *ProposeAdministratorLiquidity) ValidateSendBlock(block *nom.AccountBlock) error

type ProposeAdministratorMethod 

type ProposeAdministratorMethod struct {
	MethodName string
}

func (*ProposeAdministratorMethod) GetPlasma 

func (p *ProposeAdministratorMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ProposeAdministratorMethod) ReceiveBlock 

func (p *ProposeAdministratorMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ProposeAdministratorMethod) ValidateSendBlock 

func (p *ProposeAdministratorMethod) ValidateSendBlock(block *nom.AccountBlock) error

type ReclaimHtlcMethod 

type ReclaimHtlcMethod struct {
	MethodName string
}

func (*ReclaimHtlcMethod) GetPlasma 

func (p *ReclaimHtlcMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*ReclaimHtlcMethod) ReceiveBlock 

func (p *ReclaimHtlcMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*ReclaimHtlcMethod) ValidateSendBlock 

func (p *ReclaimHtlcMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RedeemMethod 

type RedeemMethod struct {
	MethodName string
}

func (*RedeemMethod) GetPlasma 

func (p *RedeemMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RedeemMethod) ReceiveBlock 

func (p *RedeemMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RedeemMethod) ValidateSendBlock 

func (p *RedeemMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RegisterMethod 

type RegisterMethod struct {
	MethodName string
}

func (*RegisterMethod) GetPlasma 

func (p *RegisterMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RegisterMethod) ReceiveBlock 

func (p *RegisterMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RegisterMethod) ValidateSendBlock 

func (p *RegisterMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RegisterSentinelMethod 

type RegisterSentinelMethod struct {
	MethodName string
}

func (*RegisterSentinelMethod) GetPlasma 

func (method *RegisterSentinelMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RegisterSentinelMethod) ReceiveBlock 

func (method *RegisterSentinelMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RegisterSentinelMethod) ValidateSendBlock 

func (method *RegisterSentinelMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RemoveNetworkMethod 

type RemoveNetworkMethod struct {
	MethodName string
}

func (*RemoveNetworkMethod) GetPlasma 

func (p *RemoveNetworkMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RemoveNetworkMethod) ReceiveBlock 

func (p *RemoveNetworkMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RemoveNetworkMethod) ValidateSendBlock 

func (p *RemoveNetworkMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RemoveTokenPairMethod 

type RemoveTokenPairMethod struct {
	MethodName string
}

func (*RemoveTokenPairMethod) GetPlasma 

func (p *RemoveTokenPairMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RemoveTokenPairMethod) ReceiveBlock 

func (p *RemoveTokenPairMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RemoveTokenPairMethod) ValidateSendBlock 

func (p *RemoveTokenPairMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RevokeMethod 

type RevokeMethod struct {
	MethodName string
}

func (*RevokeMethod) GetPlasma 

func (p *RevokeMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RevokeMethod) ReceiveBlock 

func (p *RevokeMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RevokeMethod) ValidateSendBlock 

func (p *RevokeMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RevokeSentinelMethod 

type RevokeSentinelMethod struct {
	MethodName string
}

func (*RevokeSentinelMethod) GetPlasma 

func (method *RevokeSentinelMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RevokeSentinelMethod) ReceiveBlock 

func (method *RevokeSentinelMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RevokeSentinelMethod) ValidateSendBlock 

func (method *RevokeSentinelMethod) ValidateSendBlock(block *nom.AccountBlock) error

type RevokeUnwrapRequestMethod 

type RevokeUnwrapRequestMethod struct {
	MethodName string
}

func (*RevokeUnwrapRequestMethod) GetPlasma 

func (p *RevokeUnwrapRequestMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*RevokeUnwrapRequestMethod) ReceiveBlock 

func (p *RevokeUnwrapRequestMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*RevokeUnwrapRequestMethod) ValidateSendBlock 

func (p *RevokeUnwrapRequestMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetAdditionalReward 

type SetAdditionalReward struct {
	MethodName string
}

func (*SetAdditionalReward) GetPlasma 

func (p *SetAdditionalReward) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetAdditionalReward) ReceiveBlock 

func (p *SetAdditionalReward) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetAdditionalReward) ValidateSendBlock 

func (p *SetAdditionalReward) ValidateSendBlock(block *nom.AccountBlock) error

type SetAllowKeygenMethod 

type SetAllowKeygenMethod struct {
	MethodName string
}

func (*SetAllowKeygenMethod) GetPlasma 

func (p *SetAllowKeygenMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetAllowKeygenMethod) ReceiveBlock 

func (p *SetAllowKeygenMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetAllowKeygenMethod) ValidateSendBlock 

func (p *SetAllowKeygenMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetBridgeMetadataMethod 

type SetBridgeMetadataMethod struct {
	MethodName string
}

func (*SetBridgeMetadataMethod) GetPlasma 

func (p *SetBridgeMetadataMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetBridgeMetadataMethod) ReceiveBlock 

func (p *SetBridgeMetadataMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetBridgeMetadataMethod) ValidateSendBlock 

func (p *SetBridgeMetadataMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetIsHalted 

type SetIsHalted struct {
	MethodName string
}

func (*SetIsHalted) GetPlasma 

func (p *SetIsHalted) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetIsHalted) ReceiveBlock 

func (p *SetIsHalted) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetIsHalted) ValidateSendBlock 

func (p *SetIsHalted) ValidateSendBlock(block *nom.AccountBlock) error

type SetNetworkMetadataMethod 

type SetNetworkMetadataMethod struct {
	MethodName string
}

func (*SetNetworkMetadataMethod) GetPlasma 

func (p *SetNetworkMetadataMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetNetworkMetadataMethod) ReceiveBlock 

func (p *SetNetworkMetadataMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetNetworkMetadataMethod) ValidateSendBlock 

func (p *SetNetworkMetadataMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetNetworkMethod 

type SetNetworkMethod struct {
	MethodName string
}

func (*SetNetworkMethod) GetPlasma 

func (p *SetNetworkMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetNetworkMethod) ReceiveBlock 

func (p *SetNetworkMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetNetworkMethod) ValidateSendBlock 

func (p *SetNetworkMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetOrchestratorInfoMethod 

type SetOrchestratorInfoMethod struct {
	MethodName string
}

func (*SetOrchestratorInfoMethod) GetPlasma 

func (p *SetOrchestratorInfoMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetOrchestratorInfoMethod) ReceiveBlock 

func (p *SetOrchestratorInfoMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetOrchestratorInfoMethod) ValidateSendBlock 

func (p *SetOrchestratorInfoMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetTokenPairMethod 

type SetTokenPairMethod struct {
	MethodName string
}

func (*SetTokenPairMethod) GetPlasma 

func (p *SetTokenPairMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetTokenPairMethod) ReceiveBlock 

func (p *SetTokenPairMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetTokenPairMethod) ValidateSendBlock 

func (p *SetTokenPairMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SetTokenTupleMethod 

type SetTokenTupleMethod struct {
	MethodName string
}

func (*SetTokenTupleMethod) GetPlasma 

func (p *SetTokenTupleMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SetTokenTupleMethod) ReceiveBlock 

func (p *SetTokenTupleMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SetTokenTupleMethod) ValidateSendBlock 

func (p *SetTokenTupleMethod) ValidateSendBlock(block *nom.AccountBlock) error

type StakeMethod 

type StakeMethod struct {
	MethodName string
}

func (*StakeMethod) GetPlasma 

func (p *StakeMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*StakeMethod) ReceiveBlock 

func (p *StakeMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*StakeMethod) ValidateSendBlock 

func (p *StakeMethod) ValidateSendBlock(block *nom.AccountBlock) error

type SwapRetrieveAssetsMethod 

type SwapRetrieveAssetsMethod struct {
	MethodName string
}

func (*SwapRetrieveAssetsMethod) GetPlasma 

func (p *SwapRetrieveAssetsMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*SwapRetrieveAssetsMethod) ReceiveBlock 

func (p *SwapRetrieveAssetsMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*SwapRetrieveAssetsMethod) ValidateSendBlock 

func (p *SwapRetrieveAssetsMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UndelegateMethod 

type UndelegateMethod struct {
	MethodName string
}

func (*UndelegateMethod) GetPlasma 

func (p *UndelegateMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UndelegateMethod) ReceiveBlock 

func (p *UndelegateMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UndelegateMethod) ValidateSendBlock 

func (p *UndelegateMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UnhaltMethod 

type UnhaltMethod struct {
	MethodName string
}

func (*UnhaltMethod) GetPlasma 

func (p *UnhaltMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UnhaltMethod) ReceiveBlock 

func (p *UnhaltMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UnhaltMethod) ValidateSendBlock 

func (p *UnhaltMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UnlockHtlcMethod 

type UnlockHtlcMethod struct {
	MethodName string
}

func (*UnlockHtlcMethod) GetPlasma 

func (p *UnlockHtlcMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UnlockHtlcMethod) ReceiveBlock 

func (p *UnlockHtlcMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UnlockHtlcMethod) ValidateSendBlock 

func (p *UnlockHtlcMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UnlockLiquidityStakeEntries 

type UnlockLiquidityStakeEntries struct {
	MethodName string
}

func (*UnlockLiquidityStakeEntries) GetPlasma 

func (p *UnlockLiquidityStakeEntries) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UnlockLiquidityStakeEntries) ReceiveBlock 

func (p *UnlockLiquidityStakeEntries) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UnlockLiquidityStakeEntries) ValidateSendBlock 

func (p *UnlockLiquidityStakeEntries) ValidateSendBlock(block *nom.AccountBlock) error

type UnwrapTokenMethod 

type UnwrapTokenMethod struct {
	MethodName string
}

func (*UnwrapTokenMethod) GetPlasma 

func (p *UnwrapTokenMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UnwrapTokenMethod) ReceiveBlock 

func (p *UnwrapTokenMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UnwrapTokenMethod) ValidateSendBlock 

func (p *UnwrapTokenMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateEmbeddedAcceleratorMethod 

type UpdateEmbeddedAcceleratorMethod struct {
	MethodName string
}

func (*UpdateEmbeddedAcceleratorMethod) GetPlasma 

func (p *UpdateEmbeddedAcceleratorMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateEmbeddedAcceleratorMethod) ReceiveBlock 

func (p *UpdateEmbeddedAcceleratorMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateEmbeddedAcceleratorMethod) ValidateSendBlock 

func (p *UpdateEmbeddedAcceleratorMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateEmbeddedLiquidityMethod 

type UpdateEmbeddedLiquidityMethod struct {
	MethodName string
}

func (*UpdateEmbeddedLiquidityMethod) GetPlasma 

func (method *UpdateEmbeddedLiquidityMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateEmbeddedLiquidityMethod) ReceiveBlock 

func (method *UpdateEmbeddedLiquidityMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateEmbeddedLiquidityMethod) ValidateSendBlock 

func (method *UpdateEmbeddedLiquidityMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateEmbeddedPillarMethod 

type UpdateEmbeddedPillarMethod struct {
	MethodName string
}

func (*UpdateEmbeddedPillarMethod) GetPlasma 

func (p *UpdateEmbeddedPillarMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateEmbeddedPillarMethod) ReceiveBlock 

func (p *UpdateEmbeddedPillarMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateEmbeddedPillarMethod) ValidateSendBlock 

func (p *UpdateEmbeddedPillarMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateEmbeddedSentinelMethod 

type UpdateEmbeddedSentinelMethod struct {
	MethodName string
}

func (*UpdateEmbeddedSentinelMethod) GetPlasma 

func (method *UpdateEmbeddedSentinelMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateEmbeddedSentinelMethod) ReceiveBlock 

func (method *UpdateEmbeddedSentinelMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateEmbeddedSentinelMethod) ValidateSendBlock 

func (method *UpdateEmbeddedSentinelMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateEmbeddedStakeMethod 

type UpdateEmbeddedStakeMethod struct {
	MethodName string
}

func (*UpdateEmbeddedStakeMethod) GetPlasma 

func (p *UpdateEmbeddedStakeMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateEmbeddedStakeMethod) ReceiveBlock 

func (p *UpdateEmbeddedStakeMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateEmbeddedStakeMethod) ValidateSendBlock 

func (p *UpdateEmbeddedStakeMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdatePhaseMethod 

type UpdatePhaseMethod struct {
	MethodName string
}

func (*UpdatePhaseMethod) GetPlasma 

func (p *UpdatePhaseMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdatePhaseMethod) ReceiveBlock 

func (p *UpdatePhaseMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdatePhaseMethod) ValidateSendBlock 

func (p *UpdatePhaseMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdatePillarMethod 

type UpdatePillarMethod struct {
	MethodName string
}

func (*UpdatePillarMethod) GetPlasma 

func (p *UpdatePillarMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdatePillarMethod) ReceiveBlock 

func (p *UpdatePillarMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdatePillarMethod) ValidateSendBlock 

func (p *UpdatePillarMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateRewardEmbeddedLiquidityMethod 

type UpdateRewardEmbeddedLiquidityMethod struct {
	MethodName string
}

func (*UpdateRewardEmbeddedLiquidityMethod) GetPlasma 

func (method *UpdateRewardEmbeddedLiquidityMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateRewardEmbeddedLiquidityMethod) ReceiveBlock 

func (method *UpdateRewardEmbeddedLiquidityMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateRewardEmbeddedLiquidityMethod) ValidateSendBlock 

func (method *UpdateRewardEmbeddedLiquidityMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateTokenMethod 

type UpdateTokenMethod struct {
	MethodName string
}

func (*UpdateTokenMethod) GetPlasma 

func (p *UpdateTokenMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateTokenMethod) ReceiveBlock 

func (p *UpdateTokenMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateTokenMethod) ValidateSendBlock 

func (p *UpdateTokenMethod) ValidateSendBlock(block *nom.AccountBlock) error

type UpdateWrapRequestMethod 

type UpdateWrapRequestMethod struct {
	MethodName string
}

func (*UpdateWrapRequestMethod) GetPlasma 

func (p *UpdateWrapRequestMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*UpdateWrapRequestMethod) ReceiveBlock 

func (p *UpdateWrapRequestMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*UpdateWrapRequestMethod) ValidateSendBlock 

func (p *UpdateWrapRequestMethod) ValidateSendBlock(block *nom.AccountBlock) error

type VoteByNameMethod 

type VoteByNameMethod struct {
	MethodName string
}

func (*VoteByNameMethod) Fee 

func (p *VoteByNameMethod) Fee() (*big.Int, error)

func (*VoteByNameMethod) GetPlasma 

func (p *VoteByNameMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*VoteByNameMethod) ReceiveBlock 

func (p *VoteByNameMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*VoteByNameMethod) ValidateSendBlock 

func (p *VoteByNameMethod) ValidateSendBlock(block *nom.AccountBlock) error

type VoteByProdAddressMethod 

type VoteByProdAddressMethod struct {
	MethodName string
}

func (*VoteByProdAddressMethod) Fee 

func (p *VoteByProdAddressMethod) Fee() (*big.Int, error)

func (*VoteByProdAddressMethod) GetPlasma 

func (p *VoteByProdAddressMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*VoteByProdAddressMethod) ReceiveBlock 

func (p *VoteByProdAddressMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*VoteByProdAddressMethod) ValidateSendBlock 

func (p *VoteByProdAddressMethod) ValidateSendBlock(block *nom.AccountBlock) error

type WithdrawQsrMethod 

type WithdrawQsrMethod struct {
	MethodName string
}

func (*WithdrawQsrMethod) GetPlasma 

func (p *WithdrawQsrMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*WithdrawQsrMethod) ReceiveBlock 

func (p *WithdrawQsrMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*WithdrawQsrMethod) ValidateSendBlock 

func (p *WithdrawQsrMethod) ValidateSendBlock(block *nom.AccountBlock) error

type WrapTokenMethod 

type WrapTokenMethod struct {
	MethodName string
}

func (*WrapTokenMethod) GetPlasma 

func (p *WrapTokenMethod) GetPlasma(plasmaTable *constants.PlasmaTable) (uint64, error)

func (*WrapTokenMethod) ReceiveBlock 

func (p *WrapTokenMethod) ReceiveBlock(context vm_context.AccountVmContext, sendBlock *nom.AccountBlock) ([]*nom.AccountBlock, error)

func (*WrapTokenMethod) ValidateSendBlock 

func (p *WrapTokenMethod) ValidateSendBlock(block *nom.AccountBlock) 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.