types

package

Go to main page

Versions in this module

v1

v1.5.0

Mar 25, 2021

Changes in this version

type Balance

+ func ToBalance(b Balance) *Balance

type Hash

+ func ToHash(h Hash) *Hash

v1.4.2

Dec 31, 2020

v1.4.0

Jul 2, 2020

Changes in this version

+ var PermissionAddress = GenerateBuiltinContractAddress(26)

+ var PrivacyDemoKVAddress = GenerateBuiltinContractAddress(27)

+ var PubKeyDistributionAddress = GenerateBuiltinContractAddress(24)

+ var RepAddress = GenerateBuiltinContractAddress(23)

+ var RewardContractAddressList = []Address

+ var SettlementAddress = GenerateBuiltinContractAddress(25)

type BlockType

+ func BlockTypeFromStr(s string) BlockType

type StateBlock

+ PrivateFor []string

+ PrivateFrom string

+ PrivateGroupID string

+ func (b *StateBlock) BuildHashData() []byte

+ func (b *StateBlock) GetHashWithoutPrivacy() Hash

+ func (b *StateBlock) IsPrivate() bool

v1.3.5

Mar 20, 2020

Changes in this version

+ const ALGO_HYBRID

+ const PovPublishStatusInit

+ const PovPublishStatusVerified

+ func CalcDifficultyRatioByBigInt(diffInt *big.Int, powLimitInt *big.Int) float64

type BigNum

+ func NewBigNumFromInt(x int64) *BigNum

+ func NewBigNumFromUint(x uint64) *BigNum

+ func (bn *BigNum) Div(x *BigNum, y *BigNum) *BigNum

+ func (bn *BigNum) DivBigInt(x *big.Int, y *big.Int) *BigNum

+ func (bn *BigNum) Mul(x *BigNum, y *BigNum) *BigNum

+ func (bn *BigNum) MulBigInt(x *big.Int, y *big.Int) *BigNum

type BlockType

+ const Online

type Hash

+ func HybridHashData(data []byte) Hash

+ func Sha256HashData(data []byte) (Hash, error)

+ type PovContractState struct

+ CodeHash Hash

+ StateHash Hash

+ func NewPovContractState() *PovContractState

+ func (cs *PovContractState) Deserialize(text []byte) error

+ func (cs *PovContractState) Serialize() ([]byte, error)

+ func (z *PovContractState) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovContractState) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovContractState) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovContractState) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovContractState) Msgsize() (s int)

+ type PovPublishState struct

+ BonusFee *BigNum

+ OracleAccounts []Address

+ PublishHeight uint64

+ VerifiedHeight uint64

+ VerifiedStatus int8

+ func NewPovPublishState() *PovPublishState

+ func (ps *PovPublishState) Deserialize(text []byte) error

+ func (ps *PovPublishState) Serialize() ([]byte, error)

+ func (z *PovPublishState) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovPublishState) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovPublishState) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovPublishState) Msgsize() (s int)

+ func (z *PovPublishState) UnmarshalMsg(bts []byte) (o []byte, err error)

type PovTD

+ Hybrid BigNum

+ type PovVerifierState struct

+ ActiveHeight map[string]uint64

+ TotalReward *BigNum

+ TotalVerify uint64

+ func NewPovVerifierState() *PovVerifierState

+ func (vs *PovVerifierState) Deserialize(text []byte) error

+ func (vs *PovVerifierState) Serialize() ([]byte, error)

+ func (z *PovVerifierState) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovVerifierState) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovVerifierState) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovVerifierState) Msgsize() (s int)

+ func (z *PovVerifierState) UnmarshalMsg(bts []byte) (o []byte, err error)

v1.3.2

Dec 24, 2019

Changes in this version

+ const BalanceSize

v1.3.1

Dec 3, 2019

Changes in this version

+ type PovDiffDayStat struct

+ AvgDiffRatio uint64

+ DayIndex uint32

+ MaxBlockTime uint32

+ MaxDiffRatio uint64

+ MinBlockTime uint32

+ MinDiffRatio uint64

+ func NewPovDiffDayStat() *PovDiffDayStat

+ func (ds *PovDiffDayStat) Deserialize(text []byte) error

+ func (ds *PovDiffDayStat) Serialize() ([]byte, error)

+ func (z *PovDiffDayStat) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovDiffDayStat) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovDiffDayStat) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovDiffDayStat) Msgsize() (s int)

+ func (z *PovDiffDayStat) UnmarshalMsg(bts []byte) (o []byte, err error)

v1.3.0

Oct 31, 2019

Changes in this version

+ const ALGO_LYRA2Z

+ const ALGO_NIST5

+ const ALGO_SCRYPT

+ const ALGO_SHA256D

+ const ALGO_UNKNOWN

+ const ALGO_VERSION_MASK

+ const ALGO_X11

+ const ALGO_X16R

+ const BigNumExtensionType

+ const HexBytesExtensionType

+ const PovMaxPrevOutIndex

+ const PovMaxTxInSequenceNum

+ const PovTxVersion

+ var BlackHoleAddress = GenerateBuiltinContractAddress(22)

+ var FFFFHash = NewHash("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")

+ var PovAuxPowChainID = 1688

+ var PovAuxPowHeaderMagic = []byte

+ func BigToCompact(n *big.Int) uint32

+ func CalcDifficultyRatio(bits uint32, powLimitBits uint32) float64

+ func CalcWorkBitsToBigInt(bits uint32) *big.Int

+ func CalcWorkIntToBigInt(diffNum *big.Int) *big.Int

+ func CompactToBig(compact uint32) *big.Int

+ func HashToBig(hash *Hash) *big.Int

+ type AddressToken struct

+ Address Address

+ Token Hash

+ func (at AddressToken) String() string

type Balance

+ func NewBalanceFromBigInt(num *big.Int) Balance

+ func (b Balance) Copy() Balance

+ type BigNum struct

+ func CalcWorkBitsToBigNum(bits uint32) *BigNum

+ func CalcWorkIntToBigNum(diffNum *big.Int) *BigNum

+ func NewBigNumFromBigInt(int *big.Int) *BigNum

+ func (bn *BigNum) Add(x *BigNum, y *BigNum) *BigNum

+ func (bn *BigNum) AddBigInt(x *big.Int, y *big.Int) *BigNum

+ func (bn *BigNum) Cmp(y *BigNum) int

+ func (bn *BigNum) CmpBigInt(y *big.Int) int

+ func (bn *BigNum) Copy() *BigNum

+ func (bn *BigNum) ExtensionType() int8

+ func (bn *BigNum) Len() int

+ func (bn *BigNum) MarshalBinaryTo(text []byte) error

+ func (bn *BigNum) Sub(x *BigNum, y *BigNum) *BigNum

+ func (bn *BigNum) SubBigInt(x *big.Int, y *big.Int) *BigNum

+ func (bn *BigNum) ToBigInt() *big.Int

+ func (bn *BigNum) UnmarshalBinary(text []byte) error

type Frontier

+ func (f *Frontier) Deserialize(text []byte) error

+ func (f *Frontier) Serialize() ([]byte, error)

+ type FrontierBlock struct

+ Fr *Frontier

+ HeaderBlk *StateBlock

+ func (fb *FrontierBlock) Deserialize(text []byte) error

+ func (fb *FrontierBlock) Serialize() ([]byte, error)

+ func (z *FrontierBlock) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *FrontierBlock) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *FrontierBlock) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *FrontierBlock) Msgsize() (s int)

+ func (z *FrontierBlock) UnmarshalMsg(bts []byte) (o []byte, err error)

type Hash

+ func BigToHash(num *big.Int) *Hash

+ func ScryptHashBytes(inputs ...[]byte) (Hash, error)

+ func ScryptHashData(data []byte) Hash

+ func Sha256DHashBytes(inputs ...[]byte) (Hash, error)

+ func Sha256DHashData(data []byte) Hash

+ func X11HashData(data []byte) Hash

+ func (h *Hash) FromBigInt(num *big.Int) error

+ func (h *Hash) ToBigInt() *big.Int

+ func (h Hash) ReverseByte() Hash

+ func (h Hash) ReverseEndian() Hash

+ type HexBytes []byte

+ func NewHexBytesFromData(data []byte) HexBytes

+ func NewHexBytesFromHex(hexStr string) HexBytes

+ func (hbs *HexBytes) SetHex(hexString string) error

+ func (hbs *HexBytes) UnmarshalBinary(text []byte) error

+ func (hbs *HexBytes) UnmarshalText(text []byte) error

+ func (hbs HexBytes) Bytes() []byte

+ func (hbs HexBytes) ExtensionType() int8

+ func (hbs HexBytes) Len() int

+ func (hbs HexBytes) MarshalBinaryTo(text []byte) error

+ func (hbs HexBytes) MarshalText() (text []byte, err error)

+ func (hbs HexBytes) String() string

type PovAccountState

+ Account Address

+ type PovAlgoType uint32

+ func NewPoVHashAlgoFromStr(name string) PovAlgoType

+ func (a PovAlgoType) String() string

+ type PovAuxHeader struct

+ AuxMerkleBranch []*Hash

+ AuxMerkleIndex int

+ ParBlockHeader PovBtcHeader

+ ParCoinBaseMerkle []*Hash

+ ParCoinBaseTx PovBtcTx

+ ParMerkleIndex int

+ ParentHash Hash

+ func NewPovAuxHeader() *PovAuxHeader

+ func (ah *PovAuxHeader) ComputePowHash(algo PovAlgoType) Hash

+ func (ah *PovAuxHeader) Deserialize(text []byte) error

+ func (ah *PovAuxHeader) Serialize() ([]byte, error)

+ func (z *PovAuxHeader) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovAuxHeader) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovAuxHeader) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovAuxHeader) Msgsize() (s int)

+ func (z *PovAuxHeader) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovBaseHeader struct

+ AlgoTargetInt *big.Int

+ Bits uint32

+ Hash Hash

+ Height uint64

+ MerkleRoot Hash

+ Nonce uint32

+ NormBits uint32

+ NormTargetInt *big.Int

+ Previous Hash

+ Timestamp uint32

+ Version uint32

+ func (bh *PovBaseHeader) Deserialize(text []byte) error

+ func (bh *PovBaseHeader) Serialize() ([]byte, error)

+ func (z *PovBaseHeader) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBaseHeader) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBaseHeader) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBaseHeader) Msgsize() (s int)

+ func (z *PovBaseHeader) UnmarshalMsg(bts []byte) (o []byte, err error)

type PovBlock

+ Body PovBody

+ Header PovHeader

+ func NewPovBlock() *PovBlock

+ func (blk *PovBlock) Copy() *PovBlock

+ func (blk *PovBlock) GetAccountTxs() []*PovTransaction

+ func (blk *PovBlock) GetAlgoEfficiency() uint

+ func (blk *PovBlock) GetAlgoType() PovAlgoType

+ func (blk *PovBlock) GetAllTxs() []*PovTransaction

+ func (blk *PovBlock) GetBits() uint32

+ func (blk *PovBlock) GetCoinBaseTx() *PovTransaction

+ func (blk *PovBlock) GetMinerAddr() Address

+ func (blk *PovBlock) GetTxByIndex(index int) *PovTransaction

+ func (blk *PovBlock) GetVersion() uint32

type PovBlockFrom

+ const PovBlockFromUnkonwn

type PovBody

+ Txs []*PovTransaction

+ func NewPovBody() *PovBody

+ func (b *PovBody) Copy() *PovBody

+ type PovBtcHeader struct

+ Bits uint32

+ MerkleRoot Hash

+ Nonce uint32

+ Previous Hash

+ Timestamp uint32

+ Version uint32

+ func (h *PovBtcHeader) BuildHashData() []byte

+ func (h *PovBtcHeader) ComputeHash() Hash

+ func (h *PovBtcHeader) ComputePowHash(algo PovAlgoType) Hash

+ func (h *PovBtcHeader) Deserialize(text []byte) error

+ func (h *PovBtcHeader) Serialize() ([]byte, error)

+ func (z *PovBtcHeader) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBtcHeader) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBtcHeader) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBtcHeader) Msgsize() (s int)

+ func (z *PovBtcHeader) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovBtcOutPoint struct

+ Hash Hash

+ Index uint32

+ func (p *PovBtcOutPoint) Deserialize(text []byte) error

+ func (p *PovBtcOutPoint) Serialize() ([]byte, error)

+ func (z *PovBtcOutPoint) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBtcOutPoint) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovBtcOutPoint) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovBtcOutPoint) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovBtcOutPoint) Msgsize() (s int)

+ type PovBtcTx struct

+ LockTime uint32

+ TxIn []*PovBtcTxIn

+ TxOut []*PovBtcTxOut

+ Version int32

+ func NewPovBtcTx(txIn []*PovBtcTxIn, txOut []*PovBtcTxOut) *PovBtcTx

+ func (tx *PovBtcTx) BuildHashData() []byte

+ func (tx *PovBtcTx) ComputeHash() Hash

+ func (tx *PovBtcTx) Deserialize(text []byte) error

+ func (tx *PovBtcTx) Serialize() ([]byte, error)

+ func (z *PovBtcTx) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBtcTx) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBtcTx) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBtcTx) Msgsize() (s int)

+ func (z *PovBtcTx) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovBtcTxIn struct

+ PreviousOutPoint PovBtcOutPoint

+ Sequence uint32

+ SignatureScript HexBytes

+ func (ti *PovBtcTxIn) BuildHashData() []byte

+ func (ti *PovBtcTxIn) Deserialize(text []byte) error

+ func (ti *PovBtcTxIn) Serialize() ([]byte, error)

+ func (z *PovBtcTxIn) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBtcTxIn) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBtcTxIn) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBtcTxIn) Msgsize() (s int)

+ func (z *PovBtcTxIn) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovBtcTxOut struct

+ PkScript HexBytes

+ Value int64

+ func (to *PovBtcTxOut) BuildHashData() []byte

+ func (to *PovBtcTxOut) Deserialize(text []byte) error

+ func (to *PovBtcTxOut) Serialize() ([]byte, error)

+ func (z *PovBtcTxOut) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBtcTxOut) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBtcTxOut) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBtcTxOut) Msgsize() (s int)

+ func (z *PovBtcTxOut) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovCoinBaseTx struct

+ Hash Hash

+ StateHash Hash

+ TxIns []*PovCoinBaseTxIn

+ TxNum uint32

+ TxOuts []*PovCoinBaseTxOut

+ Version uint32

+ func NewPovCoinBaseTx(txInNum int, txOutNum int) *PovCoinBaseTx

+ func (cbtx *PovCoinBaseTx) BuildHashData() []byte

+ func (cbtx *PovCoinBaseTx) ComputeHash() Hash

+ func (cbtx *PovCoinBaseTx) Copy() *PovCoinBaseTx

+ func (cbtx *PovCoinBaseTx) Deserialize(text []byte) error

+ func (cbtx *PovCoinBaseTx) GetCoinBaseData1() []byte

+ func (cbtx *PovCoinBaseTx) GetCoinBaseData2() []byte

+ func (cbtx *PovCoinBaseTx) GetHash() Hash

+ func (cbtx *PovCoinBaseTx) GetMinerTxOut() *PovCoinBaseTxOut

+ func (cbtx *PovCoinBaseTx) GetRepTxOut() *PovCoinBaseTxOut

+ func (cbtx *PovCoinBaseTx) Serialize() ([]byte, error)

+ func (z *PovCoinBaseTx) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovCoinBaseTx) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovCoinBaseTx) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovCoinBaseTx) Msgsize() (s int)

+ func (z *PovCoinBaseTx) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovCoinBaseTxIn struct

+ Extra HexBytes

+ PrevTxHash Hash

+ PrevTxIdx uint32

+ Sequence uint32

+ func (ti *PovCoinBaseTxIn) Copy() *PovCoinBaseTxIn

+ func (ti *PovCoinBaseTxIn) Deserialize(text []byte) error

+ func (ti *PovCoinBaseTxIn) Serialize() ([]byte, error)

+ func (z *PovCoinBaseTxIn) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovCoinBaseTxIn) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovCoinBaseTxIn) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovCoinBaseTxIn) Msgsize() (s int)

+ func (z *PovCoinBaseTxIn) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovCoinBaseTxOut struct

+ Address Address

+ Value Balance

+ func (to *PovCoinBaseTxOut) Copy() *PovCoinBaseTxOut

+ func (to *PovCoinBaseTxOut) Deserialize(text []byte) error

+ func (to *PovCoinBaseTxOut) Serialize() ([]byte, error)

+ func (z *PovCoinBaseTxOut) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovCoinBaseTxOut) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovCoinBaseTxOut) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovCoinBaseTxOut) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovCoinBaseTxOut) Msgsize() (s int)

type PovHeader

+ AuxHdr *PovAuxHeader

+ BasHdr PovBaseHeader

+ CbTx *PovCoinBaseTx

+ func NewPovHeader() *PovHeader

+ func (h *PovHeader) BuildHashData() []byte

+ func (h *PovHeader) ComputeHash() Hash

+ func (h *PovHeader) ComputePowHash() Hash

+ func (h *PovHeader) GetAlgoEfficiency() uint

+ func (h *PovHeader) GetAlgoTargetInt() *big.Int

+ func (h *PovHeader) GetAlgoType() PovAlgoType

+ func (h *PovHeader) GetBits() uint32

+ func (h *PovHeader) GetMinerAddr() Address

+ func (h *PovHeader) GetMinerReward() Balance

+ func (h *PovHeader) GetNormBits() uint32

+ func (h *PovHeader) GetNormTargetInt() *big.Int

+ func (h *PovHeader) GetRepAddr() Address

+ func (h *PovHeader) GetRepReward() Balance

+ func (h *PovHeader) GetVersion() uint32

+ type PovMinerDayStat struct

+ DayIndex uint32

+ MinerNum uint32

+ MinerStats map[string]*PovMinerStatItem

+ func NewPovMinerDayStat() *PovMinerDayStat

+ func (mds *PovMinerDayStat) Deserialize(text []byte) error

+ func (mds *PovMinerDayStat) Serialize() ([]byte, error)

+ func (z *PovMinerDayStat) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovMinerDayStat) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovMinerDayStat) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovMinerDayStat) Msgsize() (s int)

+ func (z *PovMinerDayStat) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovMinerStatItem struct

+ BlockNum uint32

+ FirstHeight uint64

+ IsMiner bool

+ LastHeight uint64

+ RepBlockNum uint32

+ RepReward Balance

+ RewardAmount Balance

+ func NewPovMinerStatItem() *PovMinerStatItem

+ func (msi *PovMinerStatItem) Deserialize(text []byte) error

+ func (msi *PovMinerStatItem) Serialize() ([]byte, error)

+ func (z *PovMinerStatItem) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovMinerStatItem) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovMinerStatItem) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovMinerStatItem) Msgsize() (s int)

+ func (z *PovMinerStatItem) UnmarshalMsg(bts []byte) (o []byte, err error)

type PovRepState

+ Account Address

+ Height uint64

+ Status uint32

+ type PovTD struct

+ Chain BigNum

+ Scrypt BigNum

+ Sha256d BigNum

+ X11 BigNum

+ func NewPovTD() *PovTD

+ func (td *PovTD) Copy() *PovTD

+ func (td *PovTD) Deserialize(text []byte) error

+ func (td *PovTD) Serialize() ([]byte, error)

+ func (z *PovTD) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovTD) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovTD) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovTD) Msgsize() (s int)

+ func (z *PovTD) UnmarshalMsg(bts []byte) (o []byte, err error)

type PovTokenState

+ Hash Hash

type PovTransaction

+ CbTx *PovCoinBaseTx

+ func (tx *PovTransaction) Copy() *PovTransaction

+ func (tx *PovTransaction) IsCbTx() bool

+ type StateBlockList []*StateBlock

+ func (bs *StateBlockList) Deserialize(text []byte) error

+ func (bs *StateBlockList) Serialize() ([]byte, error)

+ func (z *StateBlockList) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *StateBlockList) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z StateBlockList) EncodeMsg(en *msgp.Writer) (err error)

+ func (z StateBlockList) MarshalMsg(b []byte) (o []byte, err error)

+ func (z StateBlockList) Msgsize() (s int)

v1.2.4

Aug 8, 2019

Changes in this version

+ const AbiExtensionType

+ const AddressExtensionType

+ const AddressLen

+ const AddressPrefix

+ const AddressSize

+ const BalanceExtensionType

+ const BalanceMaxPrecision

+ const FrontierSize

+ const HashExtensionType

+ const HashSize

+ const SeedExtensionType

+ const SeedSize

+ const SignatureExtensionType

+ const SignatureSize

+ const WorkExtensionType

+ const WorkSize

+ var AddressEncoding = base32.NewEncoding(addressEncodingAlphabet)

+ var ChainContractAddressList = []Address

+ var ErrBadBlockType = errors.New("bad block type")

+ var ErrNotABlock = errors.New("block type is not_a_block")

+ var MinerAddress = GenerateBuiltinContractAddress(3)

+ var MintageAddress = HexToAddress("qlc_3qjky1ptg9qkzm8iertdzrnx9btjbaea33snh1w4g395xqqczye4kgcfyfs1")

+ var NEP5PledgeAddress = HexToAddress("qlc_3fwi6r1fzjwmiys819pw8jxrcmcottsj4iq56kkgcmzi3b87596jwskwqrr5")

+ var RewardsAddress = HexToAddress("qlc_3oinqggowa7f1rsjfmib476ggz6s4fp8578odjzerzztkrifqkqdz5zjztb3")

+ var WorkThreshold = uint64(0xfffffe0000000000)

+ var ZeroAddress = Address

+ var ZeroBalance = Balance

+ var ZeroHash = Hash

+ var ZeroSeed = Seed

+ var ZeroSignature = Signature

+ func IsChainContractAddress(address Address) bool

+ func IsContractAddress(address Address) bool

+ func IsValidHexAddress(hexStr string) bool

+ func KeypairFromPrivateKey(privateKey string) (ed25519.PublicKey, ed25519.PrivateKey)

+ func KeypairFromSeed(seed string, index uint32) (ed25519.PublicKey, ed25519.PrivateKey, error)

+ type Account struct

+ func NewAccount(key ed25519.PrivateKey) *Account

+ func (a *Account) Address() Address

+ func (a *Account) PrivateKey() ed25519.PrivateKey

+ func (a *Account) Sign(hash Hash) Signature

+ func (a *Account) String() string

+ func (z *Account) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Account) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z Account) EncodeMsg(en *msgp.Writer) (err error)

+ func (z Account) MarshalMsg(b []byte) (o []byte, err error)

+ func (z Account) Msgsize() (s int)

+ type AccountMeta struct

+ Address Address

+ CoinBalance Balance

+ CoinNetwork Balance

+ CoinOracle Balance

+ CoinStorage Balance

+ CoinVote Balance

+ Tokens []*TokenMeta

+ func (a *AccountMeta) GetBalance() Balance

+ func (a *AccountMeta) GetNetwork() Balance

+ func (a *AccountMeta) GetOracle() Balance

+ func (a *AccountMeta) GetStorage() Balance

+ func (a *AccountMeta) GetVote() Balance

+ func (a *AccountMeta) TotalBalance() Balance

+ func (a *AccountMeta) VoteWeight() Balance

+ func (am *AccountMeta) Token(tt Hash) *TokenMeta

+ func (z *AccountMeta) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *AccountMeta) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *AccountMeta) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *AccountMeta) Msgsize() (s int)

+ func (z *AccountMeta) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type Address [AddressSize]byte

+ func BytesToAddress(b []byte) (Address, error)

+ func GenerateAddress() (Address, ed25519.PrivateKey, error)

+ func GenerateBuiltinContractAddress(suffix byte) (Address, error)

+ func HexToAddress(hexStr string) (Address, error)

+ func PubToAddress(pub ed25519.PublicKey) Address

+ func (addr *Address) ExtensionType() int8

+ func (addr *Address) Len() int

+ func (addr *Address) SetBytes(b []byte) error

+ func (addr *Address) ToHash() Hash

+ func (addr *Address) UnmarshalBinary(text []byte) error

+ func (addr *Address) UnmarshalText(text []byte) error

+ func (addr Address) Bytes() []byte

+ func (addr Address) Checksum() []byte

+ func (addr Address) IsZero() bool

+ func (addr Address) MarshalBinaryTo(text []byte) error

+ func (addr Address) MarshalText() (text []byte, err error)

+ func (addr Address) String() string

+ func (addr Address) Verify(data []byte, signature []byte) bool

+ func (z *Address) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Address) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Address) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *Address) Msgsize() (s int)

+ func (z *Address) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type Balance struct

+ func BytesToBalance(b []byte) Balance

+ func NewBalance(x int64) Balance

+ func StringToBalance(b string) Balance

+ func (b *Balance) ExtensionType() int8

+ func (b *Balance) Len() int

+ func (b *Balance) MarshalBinaryTo(text []byte) error

+ func (b *Balance) MarshalJSON() ([]byte, error)

+ func (b *Balance) UnmarshalBinary(text []byte) error

+ func (b *Balance) UnmarshalJSON(text []byte) error

+ func (b *Balance) UnmarshalText(text []byte) error

+ func (b Balance) Add(n Balance) Balance

+ func (b Balance) Bytes() []byte

+ func (b Balance) Compare(n Balance) BalanceComp

+ func (b Balance) Div(n int64) (Balance, error)

+ func (b Balance) Equal(b2 Balance) bool

+ func (b Balance) IsZero() bool

+ func (b Balance) MarshalText() ([]byte, error)

+ func (b Balance) Mul(n int64) Balance

+ func (b Balance) String() string

+ func (b Balance) Sub(n Balance) Balance

+ type BalanceComp byte

+ const BalanceCompBigger

+ const BalanceCompEqual

+ const BalanceCompSmaller

+ type Benefit struct

+ Balance Balance

+ Network Balance

+ Oracle Balance

+ Storage Balance

+ Total Balance

+ Vote Balance

+ func (b *Benefit) String() string

+ func (z *Benefit) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Benefit) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Benefit) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *Benefit) Msgsize() (s int)

+ func (z *Benefit) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type Block interface

+ Deserialize func([]byte) error

+ Serialize func() ([]byte, error)

+ type BlockType byte

+ const Change

+ const ContractError

+ const ContractRefund

+ const ContractReward

+ const ContractSend

+ const Invalid

+ const Open

+ const Receive

+ const Send

+ const SmartContract

+ const State

+ func (e *BlockType) UnmarshalJSON(b []byte) error

+ func (e BlockType) Equal(t BlockType) bool

+ func (e BlockType) MarshalJSON() ([]byte, error)

+ func (t BlockType) String() string

+ func (z *BlockType) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *BlockType) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z BlockType) EncodeMsg(en *msgp.Writer) (err error)

+ func (z BlockType) MarshalMsg(b []byte) (o []byte, err error)

+ func (z BlockType) Msgsize() (s int)

+ type Frontier struct

+ HeaderBlock Hash

+ OpenBlock Hash

+ func (f *Frontier) IsZero() bool

+ func (z *Frontier) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Frontier) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z Frontier) EncodeMsg(en *msgp.Writer) (err error)

+ func (z Frontier) MarshalMsg(b []byte) (o []byte, err error)

+ func (z Frontier) Msgsize() (s int)

+ type Frontiers []*Frontier

+ func (fs Frontiers) Len() int

+ func (fs Frontiers) Less(i, j int) bool

+ func (fs Frontiers) Swap(i, j int)

+ func (z *Frontiers) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Frontiers) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z Frontiers) EncodeMsg(en *msgp.Writer) (err error)

+ func (z Frontiers) MarshalMsg(b []byte) (o []byte, err error)

+ func (z Frontiers) Msgsize() (s int)

+ type GenesisTokenInfo struct

+ Decimals uint8

+ Owner Address

+ PledgeAddress Address

+ PledgeAmount *big.Int

+ TokenId Hash

+ TokenName string

+ TokenSymbol string

+ TotalSupply *big.Int

+ WithdrawTime int64

+ type Hash [HashSize]byte

+ func BytesToHash(data []byte) (Hash, error)

+ func HashBytes(inputs ...[]byte) (Hash, error)

+ func HashData(data []byte) Hash

+ func NewHash(hexStr string) (Hash, error)

+ func (h *Hash) ExtensionType() int8

+ func (h *Hash) IsZero() bool

+ func (h *Hash) Len() int

+ func (h *Hash) Of(hexString string) error

+ func (h *Hash) UnmarshalBinary(text []byte) error

+ func (h *Hash) UnmarshalText(text []byte) error

+ func (h Hash) Bytes() []byte

+ func (h Hash) Cmp(h2 Hash) int

+ func (h Hash) MarshalBinaryTo(text []byte) error

+ func (h Hash) MarshalText() (text []byte, err error)

+ func (h Hash) String() string

+ func (z *Hash) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *Hash) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *Hash) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *Hash) Msgsize() (s int)

+ func (z *Hash) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PendingInfo struct

+ Amount Balance

+ Source Address

+ Type Hash

+ func (z *PendingInfo) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PendingInfo) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PendingInfo) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PendingInfo) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PendingInfo) Msgsize() (s int)

+ type PendingKey struct

+ Address Address

+ Hash Hash

+ func (z *PendingKey) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PendingKey) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PendingKey) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PendingKey) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PendingKey) Msgsize() (s int)

+ type PerformanceTime struct

+ Hash Hash

+ T0 int64

+ T1 int64

+ T2 int64

+ T3 int64

+ func NewPerformanceTime() *PerformanceTime

+ func (p *PerformanceTime) String() string

+ type PovAccountState struct

+ Balance Balance

+ Hash Hash

+ Network Balance

+ Oracle Balance

+ RepState *PovRepState

+ Storage Balance

+ TokenStates []*PovTokenState

+ Vote Balance

+ func NewPovAccountState() *PovAccountState

+ func (as *PovAccountState) Clone() *PovAccountState

+ func (as *PovAccountState) Deserialize(text []byte) error

+ func (as *PovAccountState) GetTokenState(tokenType Hash) *PovTokenState

+ func (as *PovAccountState) Serialize() ([]byte, error)

+ func (as *PovAccountState) String() string

+ func (as *PovAccountState) TotalBalance() Balance

+ func (z *PovAccountState) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovAccountState) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovAccountState) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovAccountState) Msgsize() (s int)

+ func (z *PovAccountState) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovBlock struct

+ Coinbase Address

+ Hash Hash

+ Height uint64

+ MerkleRoot Hash

+ Nonce uint64

+ Previous Hash

+ Signature Signature

+ StateHash Hash

+ Target Signature

+ Timestamp int64

+ Transactions []*PovTransaction

+ TxNum uint32

+ VoteSignature Signature

+ func NewPovBlockWithBody(header *PovHeader, body *PovBody) *PovBlock

+ func NewPovBlockWithHeader(header *PovHeader) *PovBlock

+ func (blk *PovBlock) Clone() *PovBlock

+ func (blk *PovBlock) ComputeHash() Hash

+ func (blk *PovBlock) ComputeVoteHash() Hash

+ func (blk *PovBlock) Deserialize(text []byte) error

+ func (blk *PovBlock) GetBody() *PovBody

+ func (blk *PovBlock) GetCoinbase() Address

+ func (blk *PovBlock) GetHash() Hash

+ func (blk *PovBlock) GetHeader() *PovHeader

+ func (blk *PovBlock) GetHeight() uint64

+ func (blk *PovBlock) GetMerkleRoot() Hash

+ func (blk *PovBlock) GetNonce() uint64

+ func (blk *PovBlock) GetPrevious() Hash

+ func (blk *PovBlock) GetSignature() Signature

+ func (blk *PovBlock) GetStateHash() Hash

+ func (blk *PovBlock) GetTarget() Signature

+ func (blk *PovBlock) GetTimestamp() int64

+ func (blk *PovBlock) GetTxNum() uint32

+ func (blk *PovBlock) GetVoteSignature() Signature

+ func (blk *PovBlock) Serialize() ([]byte, error)

+ func (blk *PovBlock) String() string

+ func (z *PovBlock) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBlock) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBlock) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBlock) Msgsize() (s int)

+ func (z *PovBlock) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovBlockFrom uint16

+ const PovBlockFromLocal

+ const PovBlockFromRemoteBroadcast

+ const PovBlockFromRemoteFetch

+ const PovBlockFromRemoteSync

+ const Unkonwn

+ func (z *PovBlockFrom) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBlockFrom) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovBlockFrom) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovBlockFrom) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovBlockFrom) Msgsize() (s int)

+ type PovBlocks []*PovBlock

+ func (bs *PovBlocks) Deserialize(text []byte) error

+ func (bs *PovBlocks) Serialize() ([]byte, error)

+ func (z *PovBlocks) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBlocks) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovBlocks) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovBlocks) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovBlocks) Msgsize() (s int)

+ type PovBody struct

+ Transactions []*PovTransaction

+ func (body *PovBody) Deserialize(text []byte) error

+ func (body *PovBody) Serialize() ([]byte, error)

+ func (z *PovBody) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovBody) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovBody) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovBody) Msgsize() (s int)

+ func (z *PovBody) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovHeader struct

+ Coinbase Address

+ Hash Hash

+ Height uint64

+ MerkleRoot Hash

+ Nonce uint64

+ Previous Hash

+ Signature Signature

+ StateHash Hash

+ Target Signature

+ Timestamp int64

+ TxNum uint32

+ VoteSignature Signature

+ func (header *PovHeader) Copy() *PovHeader

+ func (header *PovHeader) Deserialize(text []byte) error

+ func (header *PovHeader) GetCoinbase() Address

+ func (header *PovHeader) GetHash() Hash

+ func (header *PovHeader) GetHeight() uint64

+ func (header *PovHeader) GetMerkleRoot() Hash

+ func (header *PovHeader) GetNonce() uint64

+ func (header *PovHeader) GetPrevious() Hash

+ func (header *PovHeader) GetSignature() Signature

+ func (header *PovHeader) GetStateHash() Hash

+ func (header *PovHeader) GetTarget() Signature

+ func (header *PovHeader) GetTimestamp() int64

+ func (header *PovHeader) GetTxNum() uint32

+ func (header *PovHeader) GetVoteSignature() Signature

+ func (header *PovHeader) Serialize() ([]byte, error)

+ func (z *PovHeader) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovHeader) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovHeader) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovHeader) Msgsize() (s int)

+ func (z *PovHeader) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovRepState struct

+ Balance Balance

+ Network Balance

+ Oracle Balance

+ Storage Balance

+ Total Balance

+ Vote Balance

+ func NewPovRepState() *PovRepState

+ func (rs *PovRepState) CalcTotal() Balance

+ func (rs *PovRepState) Clone() *PovRepState

+ func (rs *PovRepState) Deserialize(text []byte) error

+ func (rs *PovRepState) Serialize() ([]byte, error)

+ func (rs *PovRepState) String() string

+ func (z *PovRepState) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovRepState) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *PovRepState) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *PovRepState) Msgsize() (s int)

+ func (z *PovRepState) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type PovTokenState struct

+ Balance Balance

+ Representative Address

+ Type Hash

+ func NewPovTokenState() *PovTokenState

+ func (ts *PovTokenState) Clone() *PovTokenState

+ func (ts *PovTokenState) Deserialize(text []byte) error

+ func (ts *PovTokenState) Serialize() ([]byte, error)

+ func (ts *PovTokenState) String() string

+ func (z *PovTokenState) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovTokenState) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovTokenState) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovTokenState) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovTokenState) Msgsize() (s int)

+ type PovTransaction struct

+ Block *StateBlock

+ Hash Hash

+ func (tx *PovTransaction) Deserialize(text []byte) error

+ func (tx *PovTransaction) GetHash() Hash

+ func (tx *PovTransaction) Serialize() ([]byte, error)

+ func (z *PovTransaction) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovTransaction) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovTransaction) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovTransaction) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovTransaction) Msgsize() (s int)

+ type PovTransactions []*PovTransaction

+ func (s PovTransactions) Len() int

+ func (s PovTransactions) Swap(i, j int)

+ type PovTxByHash PovTransactions

+ func (s PovTxByHash) Len() int

+ func (s PovTxByHash) Less(i, j int) bool

+ func (s PovTxByHash) Swap(i, j int)

+ type PovTxLookup struct

+ BlockHash Hash

+ BlockHeight uint64

+ TxIndex uint64

+ func (txl *PovTxLookup) Deserialize(text []byte) error

+ func (txl *PovTxLookup) Serialize() ([]byte, error)

+ func (z *PovTxLookup) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *PovTxLookup) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z PovTxLookup) EncodeMsg(en *msgp.Writer) (err error)

+ func (z PovTxLookup) MarshalMsg(b []byte) (o []byte, err error)

+ func (z PovTxLookup) Msgsize() (s int)

+ type Seed [SeedSize]byte

+ func BytesToSeed(b []byte) (*Seed, error)

+ func NewSeed() (*Seed, error)

+ func (s *Seed) Account(index uint32) (*Account, error)

+ func (s *Seed) ExtensionType() int8

+ func (s *Seed) IsZero() bool

+ func (s *Seed) Len() int

+ func (s *Seed) MarshalBinaryTo(text []byte) error

+ func (s *Seed) MarshalJSON() ([]byte, error)

+ func (s *Seed) MasterAddress() Address

+ func (s *Seed) String() string

+ func (s *Seed) UnmarshalBinary(text []byte) error

+ type Signature [SignatureSize]byte

+ func BytesToSignature(b []byte) (Signature, error)

+ func NewSignature(hexStr string) (Signature, error)

+ func (s *Signature) ExtensionType() int8

+ func (s *Signature) FromBigInt(num *big.Int) error

+ func (s *Signature) IsZero() bool

+ func (s *Signature) Len() int

+ func (s *Signature) Of(hexString string) error

+ func (s *Signature) ToBigInt() *big.Int

+ func (s *Signature) UnmarshalBinary(text []byte) error

+ func (s *Signature) UnmarshalText(text []byte) error

+ func (s Signature) Bytes() []byte

+ func (s Signature) MarshalBinaryTo(text []byte) error

+ func (s Signature) MarshalText() (text []byte, err error)

+ func (s Signature) String() string

+ type StateBlock struct

+ Address Address

+ Balance Balance

+ Data []byte

+ Extra Hash

+ Link Hash

+ Message Hash

+ Network Balance

+ Oracle Balance

+ PoVHeight uint64

+ Previous Hash

+ Receiver []byte

+ Representative Address

+ Sender []byte

+ Signature Signature

+ Storage Balance

+ Timestamp int64

+ Token Hash

+ Type BlockType

+ Vote Balance

+ Work Work

+ func (b *StateBlock) Clone() *StateBlock

+ func (b *StateBlock) Deserialize(text []byte) error

+ func (b *StateBlock) GetAddress() Address

+ func (b *StateBlock) GetBalance() Balance

+ func (b *StateBlock) GetData() []byte

+ func (b *StateBlock) GetExtra() Hash

+ func (b *StateBlock) GetHash() Hash

+ func (b *StateBlock) GetLink() Hash

+ func (b *StateBlock) GetMessage() Hash

+ func (b *StateBlock) GetNetwork() Balance

+ func (b *StateBlock) GetOracle() Balance

+ func (b *StateBlock) GetPrevious() Hash

+ func (b *StateBlock) GetReceiver() []byte

+ func (b *StateBlock) GetRepresentative() Address

+ func (b *StateBlock) GetSender() []byte

+ func (b *StateBlock) GetSignature() Signature

+ func (b *StateBlock) GetStorage() Balance

+ func (b *StateBlock) GetTimestamp() int64

+ func (b *StateBlock) GetToken() Hash

+ func (b *StateBlock) GetType() BlockType

+ func (b *StateBlock) GetVote() Balance

+ func (b *StateBlock) GetWork() Work

+ func (b *StateBlock) IsContractBlock() bool

+ func (b *StateBlock) IsOpen() bool

+ func (b *StateBlock) IsReceiveBlock() bool

+ func (b *StateBlock) IsSendBlock() bool

+ func (b *StateBlock) IsValid() bool

+ func (b *StateBlock) Parent() Hash

+ func (b *StateBlock) Root() Hash

+ func (b *StateBlock) Serialize() ([]byte, error)

+ func (b *StateBlock) Size() int

+ func (b *StateBlock) String() string

+ func (b *StateBlock) TotalBalance() Balance

+ func (z *StateBlock) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *StateBlock) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *StateBlock) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *StateBlock) Msgsize() (s int)

+ func (z *StateBlock) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type SynchronizedKind byte

+ const Synchronized

+ const UnSynchronized

+ func (z *SynchronizedKind) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *SynchronizedKind) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z SynchronizedKind) EncodeMsg(en *msgp.Writer) (err error)

+ func (z SynchronizedKind) MarshalMsg(b []byte) (o []byte, err error)

+ func (z SynchronizedKind) Msgsize() (s int)

+ type TimeSorter []int64

+ func (s TimeSorter) Len() int

+ func (s TimeSorter) Less(i, j int) bool

+ func (s TimeSorter) Swap(i, j int)

+ type TokenInfo struct

+ Decimals uint8

+ NEP5TxId string

+ Owner Address

+ PledgeAddress Address

+ PledgeAmount *big.Int

+ TokenId Hash

+ TokenName string

+ TokenSymbol string

+ TotalSupply *big.Int

+ WithdrawTime int64

+ type TokenMeta struct

+ Balance Balance

+ BelongTo Address

+ BlockCount int64

+ Header Hash

+ Modified int64

+ OpenBlock Hash

+ Representative Address

+ Type Hash

+ func (z *TokenMeta) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *TokenMeta) EncodeMsg(en *msgp.Writer) (err error)

+ func (z *TokenMeta) MarshalMsg(b []byte) (o []byte, err error)

+ func (z *TokenMeta) Msgsize() (s int)

+ func (z *TokenMeta) UnmarshalMsg(bts []byte) (o []byte, err error)

+ type UncheckedBlockWalkFunc func(block Block, link Hash, unCheckType UncheckedKind, sync SynchronizedKind) error

+ type UncheckedKind byte

+ const UncheckedKindLink

+ const UncheckedKindPrevious

+ func (z *UncheckedKind) DecodeMsg(dc *msgp.Reader) (err error)

+ func (z *UncheckedKind) UnmarshalMsg(bts []byte) (o []byte, err error)

+ func (z UncheckedKind) EncodeMsg(en *msgp.Writer) (err error)

+ func (z UncheckedKind) MarshalMsg(b []byte) (o []byte, err error)

+ func (z UncheckedKind) Msgsize() (s int)

+ type Work uint64

+ func (w *Work) ExtensionType() int8

+ func (w *Work) Len() int

+ func (w *Work) MarshalBinaryTo(text []byte) error

+ func (w *Work) ParseWorkHexString(hexString string) error

+ func (w *Work) UnmarshalBinary(text []byte) error

+ func (w *Work) UnmarshalText(text []byte) error

+ func (w Work) IsValid(root Hash) bool

+ func (w Work) MarshalText() (text []byte, err error)

+ func (w Work) String() string

+ type Worker struct

+ Threshold uint64

+ func NewWorker(work Work, root Hash) (*Worker, error)

+ func (w *Worker) IsValid() bool

+ func (w *Worker) NewWork() Work

+ func (w *Worker) Reset()

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