types

package
v1.0.19 Latest Latest
Warning

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

 Go to latest Published: Feb 20, 2023 License: ISC Imports: 21 Imported by: 10

Documentation

Overview

Copyright 2017-2018 The qitmeer developers

Index

Constants

View Source 
const (
	// Greater than or equal to
	FloorFeeType = 0

	// Strict equality
	EqualFeeType = 1
)
View Source 
const (
	// AtomsPerCent is the number of atomic units in one coin cent.
	// TODO, relocate the coin related item to chain's params
	AtomsPerCent = 1e6

	// AtomsPerCoin is the number of atomic units in one coin.
	// TODO, relocate the coin related item to chain's params
	AtomsPerCoin = 1e8

	// MaxAmount is the maximum transaction amount allowed in atoms.
	// TODO, relocate the coin related item to chain's params
	MaxAmount = 21e6 * AtomsPerCoin
)
View Source 
const (

	// TxVersion is the current latest supported transaction version.
	TxVersion uint32 = 1

	// NullValueIn is a null value for an input witness.
	NullValueIn uint64 = 0

	// NullBlockHeight is the null value for an input witness. It references
	// the genesis block.
	NullBlockOrder uint32 = 0x00000000

	// NullTxIndex is the null transaction index in a block for an input
	// witness.
	NullTxIndex uint32 = 0xffffffff

	// MaxTxInSequenceNum is the maximum sequence number the sequence field
	// of a transaction input can be.
	MaxTxInSequenceNum uint32 = 0xffffffff

	// MaxPrevOutIndex is the maximum index the index field of a previous
	// outpoint can be.
	MaxPrevOutIndex uint32 = 0xffffffff

	// SequenceLockTimeDisabled is a flag that if set on a transaction
	// input's sequence number, the sequence number will not be interpreted
	// as a relative locktime.
	SequenceLockTimeDisabled = 1 << 31

	// SequenceLockTimeIsSeconds is a flag that if set on a transaction
	// input's sequence number, the relative locktime has units of 512
	// seconds.
	SequenceLockTimeIsSeconds = 1 << 22

	// SequenceLockTimeMask is a mask that extracts the relative locktime
	// when masked against the transaction input sequence number.
	SequenceLockTimeMask = 0x0000ffff

	// TODO, revisit lock time define
	// SequenceLockTimeGranularity is the defined time based granularity
	// for seconds-based relative time locks.  When converting from seconds
	// to a sequence number, the value is right shifted by this amount,
	// therefore the granularity of relative time locks in 512 or 2^9
	// seconds.  Enforced relative lock times are multiples of 512 seconds.
	SequenceLockTimeGranularity = 9

	// MaxMessagePayload is the maximum bytes a message can be regardless of other
	// individual limits imposed by messages themselves.
	MaxMessagePayload = (1024 * 1024 * 32) // 32MB

	// NoExpiryValue is the value of expiry that indicates the transaction
	// has no expiry.
	NoExpiryValue uint32 = 0

	// SupperPrevOutIndex is the supper index field of a previous
	// outpoint can be.
	SupperPrevOutIndex uint32 = 0xfffffffe

	// TokenInSequence is the maximum tx type the sequence field
	// of a transaction input can be.
	TxTypeInSequence uint32 = 0x400
)
View Source 
const (
	// MaxBlockWeight defines the maximum block weight
	MaxBlockWeight = 4000000

	// MaxBlockSigOpsCost is the maximum number of signature operations
	// allowed for a block. It is calculated via a weighted algorithm which
	// weights segregated witness sig ops lower than regular sig ops.
	MaxBlockSigOpsCost = 80000
)
View Source 
const MaxBlockHeaderPayload = 4 + (hash.HashSize * 3) + 4 + 4 + 8 + 1 + 1 + 42*4

MaxBlockHeaderPayload is the maximum number of bytes a block header can be. Version 4 bytes + ParentRoot 32 bytes + TxRoot 32 bytes + StateRoot 32 bytes + Difficulty 4 bytes + Timestamp 4 bytes + nonce 8 bytes + powType 1 byte + edges_bits 1 byte + 42circles 42*4 bytes total 117 + 169 = 286 hash pow only need 117 bytes cuckoo need 286 bytes

View Source 
const MaxBlockPayload = 1048576 // 1024*1024 (1MB)

MaxBlockPayload is the maximum bytes a block message can be in bytes.

View Source 
const MaxBlocksPerMsg = 500

MaxBlocksPerMsg is the maximum number of blocks allowed per message.

View Source 
const MaxParentsPerBlock = 50

Limited parents quantity

View Source 
const MaxTxPerBlock = (MaxBlockPayload / minTxPayload) + 1

MaxTxPerBlock is the maximum number of transactions that could possibly fit into a block.

View Source 
const (
	// crosschain export tx fork for genesis locked utxo
	MeerEVMForkInput = math.MaxInt64
)
View Source 
const TxIndexUnknown = -1

TxIndexUnknown is the value returned for a transaction index that is unknown. This is typically because the transaction has not been inserted into a block yet.

Variables

View Source 
var CoinIDList = []CoinID{MEERA, MEERB}
View Source 
var CoinNameMap = map[CoinID]string{}
View Source 
var ErrInvalidNetAddr = errors.New("provided net.Addr is not a net.TCPAddr")

ErrInvalidNetAddr describes an error that indicates the caller didn't specify a TCP address as required.

View Source 
var MeerEVMTxs = []TxType{
	TxTypeCrossChainImport,
	TxTypeCrossChainExport,
	TxTypeCrossChainVM,
}
View Source 
var StdTxs = []TxType{TxTypeRegular, TxTypeCoinbase}

Standard transaction type

View Source 
var TokenTxs = []TxType{
	TxTypeTokenNew,
	TxTypeTokenRenew,
	TxTypeTokenInvalidate,
	TxTypeTokenValidate,
	TxTypeTokenMint,
}

Functions

func CheckCoinID 

func CheckCoinID(id CoinID) error

Check if a valid coinId, current only check if the coinId is known.

func CheckGenesisLock 

func CheckGenesisLock(tx *Transaction) error

CheckGenesisLock returns an error if a transaction is not a genesis_lock transaction. It makes sure the number of inputs/outputs, and related scripts are valid.

genesis_lock transactions are specified as below:

1.) Inputs: genesis output 1 [index 0] genesis output 2 [index 1] ...

2.) Outputs: OP_STAKE_LOCK tagged output [index 0] OP_RETURN push of input 1's stake reward receiving address [index 1] OP_STAKE_LOCK tagged output [index 2] OP_RETURN push of input 2's stake reward receiving address [index 3] ... Note: The output OP_RETURN pushes should be of size 20 bytes (standard address).

3.) NO changes are allowed for the tx && NO fee are allowed for this tx. inputs amount == output amount

func GetBlockWeight 

func GetBlockWeight(blk *Block) int

GetBlockWeight computes the value of the weight metric for a given block.

func GetParentsRoot 

func GetParentsRoot(parents []*hash.Hash) hash.Hash

This function get the simple hash use each parents string, so it can't use to check for block body .At present we use the merkles tree.

func GetSupportCoinsForCrossChain 

func GetSupportCoinsForCrossChain() map[CoinID]bool

cross chain

func GetTransactionWeight 

func GetTransactionWeight(tx *Tx) int64

func IsCoinBaseTx 

func IsCoinBaseTx(tx *Transaction) bool

IsCoinBaseTx determines whether or not a transaction is a coinbase. A coinbase is a special transaction created by miners that has no inputs. This is represented in the block chain by a transaction with a single input that has a previous output transaction index set to the maximum value along with a zero hash.

This function only differs from IsCoinBase in that it works with a raw wire transaction as opposed to a higher level util transaction.

func IsCrossChainExportTx 

func IsCrossChainExportTx(tx *Transaction) bool

func IsCrossChainImportTx 

func IsCrossChainImportTx(tx *Transaction) bool

func IsCrossChainTx 

func IsCrossChainTx(tx *Transaction) bool

func IsCrossChainVMTx 

func IsCrossChainVMTx(tx *Transaction) bool

func IsGenesisLockTx 

func IsGenesisLockTx(tx *Transaction) bool

IsGenesisLockTx returns whether or not a transaction is a genesis_lock transaction.

func IsKnownCoinID 

func IsKnownCoinID(id CoinID) bool

func IsMeerEVMForkInput 

func IsMeerEVMForkInput(ip *TxInput) bool

func IsSequenceLockTimeDisabled 

func IsSequenceLockTimeDisabled(sequence uint32) bool

func IsTokenInvalidateTx 

func IsTokenInvalidateTx(tx *Transaction) bool

func IsTokenMintTx 

func IsTokenMintTx(tx *Transaction) bool

func IsTokenNewTx 

func IsTokenNewTx(tx *Transaction) bool

func IsTokenRenewTx 

func IsTokenRenewTx(tx *Transaction) bool

func IsTokenTx 

func IsTokenTx(tx *Transaction) bool

func IsTokenUnmintTx 

func IsTokenUnmintTx(tx *Transaction) bool

func IsTokenValidateTx 

func IsTokenValidateTx(tx *Transaction) bool

func MaxNetAddressPayload 

func MaxNetAddressPayload(pver uint32) uint32

MaxNetAddressPayload returns the max payload size for the NetAddress based on the protocol version.

func MaxTxPerTxTree 

func MaxTxPerTxTree(pver uint32) uint64

MaxTxPerTxTree returns the maximum number of transactions that could possibly fit into a block per ekach merkle root for the given protocol version.

func ReadNetAddress 

func ReadNetAddress(r io.Reader, pver uint32, na *NetAddress, ts bool) error

readNetAddress reads an encoded NetAddress from r depending on the protocol version and whether or not the timestamp is included per ts. Some messages like version do not include the timestamp.

func ReadOutPoint 

func ReadOutPoint(r io.Reader, version uint32, op *TxOutPoint) error

ReadOutPoint reads the next sequence of bytes from r as an OutPoint.

func WriteNetAddress 

func WriteNetAddress(w io.Writer, pver uint32, na *NetAddress, ts bool) error

writeNetAddress serializes a NetAddress to w depending on the protocol version and whether or not the timestamp is included per ts. Some messages like version do not include the timestamp.

func WriteOutPoint 

func WriteOutPoint(w io.Writer, pver uint32, version uint32, op *TxOutPoint) error

WriteOutPoint encodes for an OutPoint to w.

Types

type Account 

type Account Address

An identifier for an account of the system, which stand for a address

type Address 

type Address interface {
	// String returns the string encoding of the transaction output
	// destination.
	//
	// Please note that String differs subtly from EncodeAddress: String
	// will return the value as a string without any conversion, while
	// EncodeAddress may convert destination types (for example,
	// converting pubkeys to P2PKH addresses) before encoding as a
	// payment address string.
	String() string

	// with encode
	Encode() string

	// Hash160 returns the Hash160(data) where data is the data normally
	// hashed to 160 bits from the respective address type.
	Hash160() *[20]byte

	EcType() ecc.EcType

	// raw byte in script, aka the hash in the most case
	Script() []byte

	// IsForNetwork returns whether or not the address is associated with the
	// passed network.
	IsForNetwork(net protocol.Network) bool
}

type AddressType 

type AddressType byte
const (
	LegerAddress    AddressType = 0x01
	ContractAddress AddressType = 0x02
)

type Amount 

type Amount struct {
	Value int64
	Id    CoinID
}

Amount represents the base coin monetary unit (colloquially referred to as an `Atom'). A single Amount is equal to 1e-8 of a coin. size is 10 bytes ( value -> 8 byte , coinId -> 2 byte)

func NewAmount 

func NewAmount(f float64) (*Amount, error)

NewAmount creates an Amount from a floating point value representing some value in the currency. NewAmount errors if f is NaN or +-Infinity, but does not check that the amount is within the total amount of coins producible as f may not refer to an amount at a single moment in time.

NewAmount is for specifically for converting qitmeer to Atoms (atomic units). For creating a new Amount with an int64 value which denotes a quantity of Atoms, do a simple type conversion from type int64 to Amount.

func NewMeer 

func NewMeer(a uint64) (*Amount, error)

func (*Amount) Add 

func (z *Amount) Add(x, y *Amount) (*Amount, error)

func (*Amount) Format 

func (a *Amount) Format(u AmountUnit) string

Format formats a monetary amount counted in coin base units as a string for a given unit. The conversion will succeed for any unit, however, known units will be formated with an appended label describing the units with SI notation, or "atom" for the base unit.

func (*Amount) MulF64 

func (a *Amount) MulF64(f float64) *Amount

MulF64 multiplies an Amount by a floating point value. While this is not an operation that must typically be done by a full node or wallet, it is useful for services that build on top of qitmeer (for example, calculating a fee by multiplying by a percentage).

func (*Amount) String 

func (a *Amount) String() string

String is the equivalent of calling Format with AmountCoin.

func (*Amount) ToCoin 

func (a *Amount) ToCoin() float64

ToCoin is the equivalent of calling ToUnit with AmountCoin.

func (*Amount) ToUnit 

func (a *Amount) ToUnit(u AmountUnit) float64

ToUnit converts a monetary amount counted in coin base units to a floating point value representing an amount of coins.

type AmountGroup 

type AmountGroup []Amount

AmountGroup represents a group of multiple Amount,

type AmountMap 

type AmountMap map[CoinID]int64

AmountMap represents a map of multiple Amount,

func (AmountMap) Add 

func (am AmountMap) Add(other AmountMap)

type AmountSorter 

type AmountSorter []Amount

AmountSorter implements sort.Interface to allow a slice of Amounts to be sorted.

func (AmountSorter) Len 

func (s AmountSorter) Len() int

Len returns the number of Amounts in the slice. It is part of the sort.Interface implementation.

func (AmountSorter) Less 

func (s AmountSorter) Less(i, j int) bool

Less returns whether the Amount with index i should sort before the Amount with index j. It is part of the sort.Interface implementation.

func (AmountSorter) Swap 

func (s AmountSorter) Swap(i, j int)

Swap swaps the Amounts at the passed indices. It is part of the sort.Interface implementation.

type AmountUnit 

type AmountUnit int

AmountUnit describes a method of converting an Amount to something other than the base unit of a coin. The value of the AmountUnit is the exponent component of the decadic multiple to convert from an amount in coins to an amount counted in atomic units. 

const (
	AmountMegaCoin  AmountUnit = 6
	AmountKiloCoin  AmountUnit = 3
	AmountCoin      AmountUnit = 0
	AmountMilliCoin AmountUnit = -3
	AmountMicroCoin AmountUnit = -6
	AmountAtom      AmountUnit = -8
)

These constants define various units used when describing a coin monetary amount.

func (AmountUnit) String 

func (u AmountUnit) String() string

String returns the unit as a string. For recognized units, the SI prefix is used, or "Atom" for the base unit. For all unrecognized units, "1eN MEER" is returned, where N is the AmountUnit.

type AuthorityId 

type AuthorityId Address

/ An identifier for an authority in the consensus algorithm.

type Block 

type Block struct {
	Header       BlockHeader
	Parents      []*hash.Hash
	Transactions []*Transaction //tx  6

}

func (*Block) AddParent 

func (b *Block) AddParent(h *hash.Hash) error

AddTransaction adds a transaction to the message.

func (*Block) AddTransaction 

func (b *Block) AddTransaction(tx *Transaction) error

AddTransaction adds a transaction to the message.

func (*Block) BlockHash 

func (block *Block) BlockHash() hash.Hash

BlockHash computes the block identifier hash for this block.

func (*Block) Decode 

func (b *Block) Decode(r io.Reader, pver uint32) error

decodes r into the receiver. See Deserialize for decoding blocks stored to disk, such as in a database, as opposed to decoding blocks .

func (*Block) Deserialize 

func (b *Block) Deserialize(r io.Reader) error

Deserialize decodes a block from r into the receiver using a format that is suitable for long-term storage such as a database while respecting the Version field in the block.

func (*Block) DeserializeTxLoc 

func (b *Block) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error)

DeserializeTxLoc decodes r in the same manner Deserialize does, but it takes a byte buffer instead of a generic reader and returns a slice containing the start and length of each transaction within the raw data that is being deserialized.

func (*Block) Encode 

func (block *Block) Encode(w io.Writer, pver uint32) error

Encode encodes the receiver to w using the protocol encoding. This is part of the Message interface implementation. See Serialize for encoding blocks to be stored to disk, such as in a database, as opposed to encoding blocks for the wire.

func (*Block) Serialize 

func (block *Block) Serialize(w io.Writer) error

Serialize encodes the block to w using a format that suitable for long-term storage such as a database while respecting the Version field in the block.

func (*Block) SerializeSize 

func (block *Block) SerializeSize() int

SerializeSize returns the number of bytes it would take to serialize the the block.

type BlockHeader 

type BlockHeader struct {

	// block version
	Version uint32

	// The merkle root of the previous parent blocks (the dag layer)
	ParentRoot hash.Hash

	// The merkle root of the tx tree  (tx of the block)
	// included Witness here instead of the separated witness commitment
	TxRoot hash.Hash

	// The merkle root of state tire (the app data layer)
	// can all of the state data (stake, receipt, utxo) in state root?
	StateRoot hash.Hash

	// Difficulty target for tx
	Difficulty uint32

	// TimeStamp
	Timestamp time.Time

	// pow blake2bd | cuckaroo | cuckatoo
	Pow pow.IPow
}

func (*BlockHeader) BlockData 

func (bh *BlockHeader) BlockData() []byte

BlockData computes the block data for block hash. Block data has the dynamic length.

  • blake2bd data is 117 bytes .
  • cuckoo data is 282 bytes .

func (*BlockHeader) BlockHash 

func (h *BlockHeader) BlockHash() hash.Hash

BlockHash computes the block identifier hash for the given block header.

func (*BlockHeader) Deserialize 

func (h *BlockHeader) Deserialize(r io.Reader) error

Deserialize decodes a block header from r into the receiver using a format that is suitable for long-term storage such as a database while respecting the Version field.

func (*BlockHeader) Serialize 

func (h *BlockHeader) Serialize(w io.Writer) error

Serialize encodes a block header from r into the receiver using a format that is suitable for long-term storage such as a database while respecting the Version field.

type BlockReceipt 

type BlockReceipt struct {
	BlockNumber uint64

	// The merkle root of storage trie (for kv)
	StorageRoot hash.Hash

	// The merkle root for change logs trie
	// 1.) ordered storage keys that changed the storage, k also map to tx(one or many) (how them changed)
	// 2.) a parent MT also linked, which representing changes happened over the last change range of blocks.
	//     which refer to block(s) that caused the change rather than the tx included from the current block
	//     which provide proof that any group of change range blocks either don't change a storage item
	//     or can find out which tx exactly did.
	ChangeRoot hash.Hash

	// The event digest of a block, which is chain-specific, useful for light-clients.
	// Events are an array of data fragments that runtime encode events for light-client
	// for example authority set changes (ex. validator set changes)
	// fast warp sync by tracking validator set changes trustlessly
	Events []Event
}

type BlockTemplate 

type BlockTemplate struct {
	// Block is a block that is ready to be solved by miners.  Thus, it is
	// completely valid with the exception of satisfying the proof-of-work
	// requirement.
	Block *Block

	// Fees contains the amount of fees each transaction in the generated
	// template pays in base units.  Since the first transaction is the
	// coinbase, the first entry (offset 0) will contain the negative of the
	// sum of the fees of all other transactions.
	Fees []int64

	// SigOpCounts contains the number of signature operations each
	// transaction in the generated template performs.
	SigOpCounts []int64

	// Height is the height at which the block template connects to the main
	// chain.
	Height uint64

	// Blues is the count of the blue set in the block past set to
	// the DAG
	Blues int64

	// ValidPayAddress indicates whether or not the template coinbase pays
	// to an address or is redeemable by anyone.  See the documentation on
	// NewBlockTemplate for details on which this can be useful to generate
	// templates without a coinbase payment address.
	ValidPayAddress bool

	//pow diff
	Difficulty uint32

	BlockFeesMap AmountMap

	TxMerklePath  []*hash.Hash
	TxWitnessRoot *hash.Hash
}

BlockTemplate houses a block that has yet to be solved along with additional details about the fees and the number of signature operations for each transaction in the block.

type BloomUpdateType 

type BloomUpdateType uint8

BloomUpdateType specifies how the filter is updated when a match is found 

const (
	// BloomUpdateNone indicates the filter is not adjusted when a match is
	// found.
	BloomUpdateNone BloomUpdateType = 0

	// BloomUpdateAll indicates if the filter matches any data element in a
	// public key script, the outpoint is serialized and inserted into the
	// filter.
	BloomUpdateAll BloomUpdateType = 1

	// BloomUpdateP2PubkeyOnly indicates if the filter matches a data
	// element in a public key script and the script is of the standard
	// pay-to-pubkey or multisig, the outpoint is serialized and inserted
	// into the filter.
	BloomUpdateP2PubkeyOnly BloomUpdateType = 2

	// MaxFilterLoadHashFuncs is the maximum number of hash functions to
	// load into the Bloom filter.
	MaxFilterLoadHashFuncs = 50

	// MaxFilterLoadFilterSize is the maximum size in bytes a filter may be.
	MaxFilterLoadFilterSize = 36000
)

type Bytes 

type Bytes []byte

type CBlock 

type CBlock struct {
	Header        CBlockHeader
	CTransactions []*ContractTransaction //ctx
}

type CBlockHeader 

type CBlockHeader struct {

	//Contract block number
	CBlockNum *big.Int

	//Parent block hash
	CBlockParent hash.Hash

	// The merkle root of contract storage
	ContractRoot hash.Hash

	// The merkle root the ctx receipt trie  (proof of changes)
	// receipt generated after ctx processed (aka. post-tx info)
	ReceiptRoot hash.Hash

	// bloom filter for log entry of ctx receipt
	// can we remove/combine with cbf ?
	LogBloom hash.Hash

	// Difficulty target for ctx
	CDifficulty uint32
	// Nonce for ctx
	CNonce uint64
}

Contract block header

type CoinID 

type CoinID uint16

from 0 ~ 65535 0 ~ 255 : Qitmeer reserved 

const (
	MEERA CoinID = 0
	MEERB CoinID = 1

	QitmeerReservedID CoinID = 255
)

func NewCoinID 

func NewCoinID(name string) CoinID

func (CoinID) Bytes 

func (c CoinID) Bytes() []byte

func (CoinID) IsBase 

func (c CoinID) IsBase() bool

Is it the main coin ?

func (CoinID) Name 

func (c CoinID) Name() string

type Config 

type Config struct {
	Id *big.Int `json:"Id"  required:"true" min:"0"`
}

func (Config) MarshalJSON 

func (c Config) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON

func (*Config) UnmarshalJSON 

func (c *Config) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON

type ContractTransaction 

type ContractTransaction struct {
	From      Account
	To        Account
	Value     uint64
	GasPrice  uint64
	GasLimit  uint64
	Nonce     uint64
	Input     []byte
	Signature []byte
}

type Event 

type Event []byte

block execution event, ex. validator change event

type FeeType 

type FeeType byte

type Genesis 

type Genesis struct {
	Config *Config `json:"config" required:"true"`
	Nonce  uint64  `json:"nonce"  required:"true" min:"1"`
}

func (Genesis) MarshalJSON 

func (g Genesis) MarshalJSON() ([]byte, error)

MarshalJSON marshals as JSON

func (*Genesis) UnmarshalJSON 

func (g *Genesis) UnmarshalJSON(input []byte) error

UnmarshalJSON unmarshals from JSON

type Input 

type Input interface {
	GetSignScript() []byte
}

type Key 

type Key struct {
	Address    Address
	PrivateKey *ecc.PrivateKey
}

type MessageEncoding 

type MessageEncoding uint32

MessageEncoding represents the wire message encoding format to be used. 

const (
	// BaseEncoding encodes all messages in the default format specified
	// for the Bitcoin wire protocol.
	BaseEncoding MessageEncoding = 1 << iota
)

type MessageError 

type MessageError struct {
	Func        string // Function name
	Description string // Human readable description of the issue
}

MessageError describes an issue with a message. An example of some potential issues are messages from the wrong bitcoin network, invalid commands, mismatched checksums, and exceeding max payloads.

This provides a mechanism for the caller to type assert the error to differentiate between general io errors such as io.EOF and issues that resulted from malformed messages.

func (*MessageError) Error 

func (e *MessageError) Error() string

Error satisfies the error interface and prints human-readable errors.

type MsgFilterAdd 

type MsgFilterAdd struct {
	Data []byte
}

MsgFilterAdd implements the Message interface and represents a qitmeer filteradd message. It is used to add a data element to an existing Bloom filter.

This message was not added until protocol version BIP0037Version.

type MsgFilterClear 

type MsgFilterClear struct{}

MsgFilterClear implements the Message interface and represents a qitmeer filterclear message which is used to reset a Bloom filter.

This message was not added until protocol version BIP0037Version and has no payload.

type MsgFilterLoad 

type MsgFilterLoad struct {
	Filter    []byte
	HashFuncs uint32
	Tweak     uint32
	Flags     BloomUpdateType
}

MsgFilterLoad implements the Message interface and represents a bitcoin filterload message which is used to reset a Bloom filter.

This message was not added until protocol version BIP0037Version.

func NewMsgFilterLoad 

func NewMsgFilterLoad(filter []byte, hashFuncs uint32, tweak uint32, flags BloomUpdateType) *MsgFilterLoad

NewMsgFilterLoad returns a new bitcoin filterload message that conforms to the Message interface. See MsgFilterLoad for details.

func (*MsgFilterLoad) QitmeerDecode 

func (msg *MsgFilterLoad) QitmeerDecode(r io.Reader, pver uint32, enc MessageEncoding) error

QitmeerDecode decodes r using the bitcoin protocol encoding into the receiver. This is part of the Message interface implementation.

func (*MsgFilterLoad) QitmeerEncode 

func (msg *MsgFilterLoad) QitmeerEncode(w io.Writer, pver uint32, enc MessageEncoding) error

QitmeerEncode encodes the receiver to w using the bitcoin protocol encoding. This is part of the Message interface implementation.

type MsgMerkleBlock 

type MsgMerkleBlock struct {
	Header       BlockHeader
	Transactions uint32
	Hashes       []*chainhash.Hash
	Flags        []byte
}

MsgMerkleBlock implements the Message interface and represents a bitcoin merkleblock message which is used to reset a Bloom filter.

This message was not added until protocol version BIP0037Version.

func (*MsgMerkleBlock) AddTxHash 

func (msg *MsgMerkleBlock) AddTxHash(hash *chainhash.Hash) error

AddTxHash adds a new transaction hash to the message.

func (*MsgMerkleBlock) MaxPayloadLength 

func (msg *MsgMerkleBlock) MaxPayloadLength(pver uint32) uint32

MaxPayloadLength returns the maximum length the payload can be for the receiver. This is part of the Message interface implementation.

type NetAddress 

type NetAddress struct {
	// Last time the address was seen.  This is, unfortunately, encoded as a
	// uint32 on the wire and therefore is limited to 2106.  This field is
	// not present in the version message (MsgVersion) nor was it
	// added until protocol version >= NetAddressTimeVersion.
	Timestamp time.Time

	// Bitfield which identifies the services supported by the address.
	Services protocol.ServiceFlag

	// IP address of the peer.
	IP net.IP

	// Port the peer is using.  This is encoded in big endian on the wire
	// which differs from most everything else.
	Port uint16
}

NetAddress defines information about a peer on the network including the time it was last seen, the services it supports, its IP address, and port.

func NewNetAddress 

func NewNetAddress(addr net.Addr, services protocol.ServiceFlag) (*NetAddress, error)

NewNetAddress returns a new NetAddress using the provided TCP address and supported services with defaults for the remaining fields.

Note that addr must be a net.TCPAddr. An ErrInvalidNetAddr is returned if it is not.

func NewNetAddressFailBack 

func NewNetAddressFailBack(addr net.Addr, services protocol.ServiceFlag) (*NetAddress, error)

NewNetAddressFailBack add more attempts to extract the IP address and port from the passed net.Addr interface and create a NetAddress structure using that information.

func NewNetAddressIPPort 

func NewNetAddressIPPort(ip net.IP, port uint16, services protocol.ServiceFlag) *NetAddress

NewNetAddressIPPort returns a new NetAddress using the provided IP, port, and supported services with defaults for the remaining fields.

func NewNetAddressTimestamp 

func NewNetAddressTimestamp(
	timestamp time.Time, services protocol.ServiceFlag, ip net.IP, port uint16) *NetAddress

NewNetAddressTimestamp returns a new NetAddress using the provided timestamp, IP, port, and supported services. The timestamp is rounded to single second precision.

func (*NetAddress) AddService 

func (na *NetAddress) AddService(service protocol.ServiceFlag)

AddService adds service as a supported service by the peer generating the message.

func (*NetAddress) HasService 

func (na *NetAddress) HasService(service protocol.ServiceFlag) bool

HasService returns whether the specified service is supported by the address.

type Output 

type Output interface {
	GetPkScript() []byte
}

type ScriptTx 

type ScriptTx interface {
	GetInput() []Input
	GetOutput() []Output
	GetVersion() uint32
	GetLockTime() uint32
	GetType() ScriptTxType
}

type ScriptTxType 

type ScriptTxType int
const (
	QitmeerScriptTx ScriptTxType = iota
	BtcScriptTx
)

type SerializedBlock 

type SerializedBlock struct {
	// contains filtered or unexported fields
}

SerializedBlock provides easier and more efficient manipulation of raw blocks. It also memorizes hashes for the block and its transactions on their first access so subsequent accesses don't have to repeat the relatively expensive hashing operations.

func NewBlock 

func NewBlock(block *Block) *SerializedBlock

NewBlock returns a new instance of the serialized block given an underlying Block. the block hash has been calculated and cached

func NewBlockDeepCopyCoinbase 

func NewBlockDeepCopyCoinbase(msgBlock *Block) *SerializedBlock

NewBlockDeepCopyCoinbase returns a new instance of a block given an underlying wire.MsgBlock, but makes a deep copy of the coinbase transaction since it's sometimes mutable.

func NewBlockFromBlockAndBytes 

func NewBlockFromBlockAndBytes(block *Block, serializedBytes []byte) *SerializedBlock

NewBlockFromBlockAndBytes returns a new instance of a block given an underlying Block and the serialized bytes for it.

func NewBlockFromBytes 

func NewBlockFromBytes(serializedBytes []byte) (*SerializedBlock, error)

NewBlockFromBytes returns a new instance of a block given the serialized bytes. See Block.

func NewBlockFromReader 

func NewBlockFromReader(r io.Reader) (*SerializedBlock, error)

NewBlockFromReader returns a new instance of a block given a Reader to deserialize the block. See Block.

func (*SerializedBlock) Block 

func (sb *SerializedBlock) Block() *Block

func (*SerializedBlock) Bytes 

func (sb *SerializedBlock) Bytes() ([]byte, error)

Bytes returns the serialized bytes for the Block. This is equivalent to calling Serialize on the underlying Block, however it caches the result so subsequent calls are more efficient.

func (*SerializedBlock) Hash 

func (sb *SerializedBlock) Hash() *hash.Hash

Hash returns the block identifier hash for the Block. This is equivalent to calling BlockHash on the underlying Block, however it caches the result so subsequent calls are more efficient.

func (*SerializedBlock) Height 

func (sb *SerializedBlock) Height() uint

func (*SerializedBlock) Order 

func (sb *SerializedBlock) Order() uint64

Order returns a casted int64 order from the block header.

This function should not be used for new code and will be removed in the future.

func (*SerializedBlock) SetHeight 

func (sb *SerializedBlock) SetHeight(height uint)

func (*SerializedBlock) SetOrder 

func (sb *SerializedBlock) SetOrder(order uint64)

func (*SerializedBlock) String 

func (sb *SerializedBlock) String() string

The stringer method makes SerializedBlock satisfy the Stringer interface. It simplifies the message printing in the trace logs.

func (*SerializedBlock) Transactions 

func (sb *SerializedBlock) Transactions() []*Tx

Transactions returns a slice of wrapped transactions for all transactions in the Block. This is nearly equivalent to accessing the raw transactions (types.Transaction) in the underlying types.Block, however it instead provides easy access to wrapped versions of them.

func (*SerializedBlock) TxLoc 

func (sb *SerializedBlock) TxLoc() ([]TxLoc, error)

TxLoc returns the offsets and lengths of each transaction in a raw block. It is used to allow fast indexing into transactions within the raw byte stream.

type Transaction 

type Transaction struct {
	Version   uint32
	TxIn      []*TxInput
	TxOut     []*TxOutput
	LockTime  uint32
	Expire    uint32
	Timestamp time.Time // When the transaction was created for extensibility

	Message    []byte //a unencrypted/encrypted message if user pay additional fee & limit the max length
	CachedHash *hash.Hash
}

func NewTransaction 

func NewTransaction() *Transaction

NewMsgTx returns a new tx message that conforms to the Message interface. The return instance has a default version of TxVersion and there are no transaction inputs or outputs. Also, the lock time is set to zero to indicate the transaction is valid immediately as opposed to some time in future.

func (*Transaction) AddTxIn 

func (t *Transaction) AddTxIn(ti *TxInput)

AddTxIn adds a transaction input to the message.

func (*Transaction) AddTxOut 

func (t *Transaction) AddTxOut(to *TxOutput)

AddTxOut adds a transaction output to the message.

func (*Transaction) CachedTxHash 

func (t *Transaction) CachedTxHash() *hash.Hash

CachedTxHash is equivalent to calling TxHash, however it caches the result so subsequent calls do not have to recalculate the hash. It can be recalculated later with RecacheTxHash.

func (*Transaction) Decode 

func (tx *Transaction) Decode(r io.Reader, pver uint32) error

func (*Transaction) Deserialize 

func (tx *Transaction) Deserialize(r io.Reader) error

Deserialize decodes a transaction from r into the receiver using a format that is suitable for long-term storage such as a database while respecting the Version field in the transaction.

func (*Transaction) Encode 

func (tx *Transaction) Encode(w io.Writer, pver uint32, serType TxSerializeType) error

func (*Transaction) GetInput 

func (t *Transaction) GetInput() []Input

func (*Transaction) GetLockTime 

func (t *Transaction) GetLockTime() uint32

func (*Transaction) GetOutput 

func (t *Transaction) GetOutput() []Output

func (*Transaction) GetType 

func (t *Transaction) GetType() ScriptTxType

func (*Transaction) GetVersion 

func (t *Transaction) GetVersion() uint32

func (*Transaction) IsCoinBase 

func (tx *Transaction) IsCoinBase() bool

func (*Transaction) RecacheTxHash 

func (t *Transaction) RecacheTxHash() *hash.Hash

RecacheTxHash is equivalent to calling TxHash, however it replaces the cached result so future calls to CachedTxHash will return this newly calculated hash.

func (*Transaction) Serialize 

func (tx *Transaction) Serialize() ([]byte, error)

serialize returns the serialization of the transaction for the provided serialization type without modifying the original transaction.

func (*Transaction) SerializeNoWitness 

func (tx *Transaction) SerializeNoWitness() ([]byte, error)

func (*Transaction) SerializeSize 

func (tx *Transaction) SerializeSize() int

SerializeSize returns the number of bytes it would take to serialize the the transaction. (full size)

func (*Transaction) SerializeSizeNoWitness 

func (tx *Transaction) SerializeSizeNoWitness() int

func (*Transaction) TxHash 

func (tx *Transaction) TxHash() hash.Hash

TxHash generates the hash for the transaction prefix. Since it does not contain any witness data, it is not malleable and therefore is stable for use in unconfirmed transaction chains.

func (*Transaction) TxHashFull 

func (tx *Transaction) TxHashFull() hash.Hash

TxHashFull generates the hash for the transaction prefix || witness. It first obtains the hashes for both the transaction prefix and witness, then concatenates them and hashes the result.

func (*Transaction) ValidTime 

func (t *Transaction) ValidTime(allowScope int64) bool

type Tx 

type Tx struct {
	Tx *Transaction // Underlying Transaction

	IsDuplicate bool // Whether duplicate tx.
	// contains filtered or unexported fields
}

Tx defines a transaction that provides easier and more efficient manipulation of raw transactions. It also memorizes the hash for the transaction on its first access so subsequent accesses don't have to repeat the relatively expensive hashing operations.

func NewTx 

func NewTx(t *Transaction) *Tx

NewTx returns a new instance of a transaction given an underlying wire.MsgTx. See Tx.

func NewTxDeep 

func NewTxDeep(msgTx *Transaction) *Tx

NewTxDeep returns a new instance of a transaction given an underlying wire.MsgTx. Until NewTx, it completely copies the data in the msgTx so that there are new memory allocations, in case you were to somewhere else modify the data assigned to these pointers.

func NewTxDeepTxIns 

func NewTxDeepTxIns(msgTx *Transaction) *Tx

NewTxDeepTxIns is used to deep copy a transaction, maintaining the old pointers to the TxOuts while replacing the old pointers to the TxIns with deep copies. This is to prevent races when the fraud proofs for the transactions are set by the miner.

func NewTxFromBytes 

func NewTxFromBytes(serializedTx []byte) (*Tx, error)

NewTxFromBytes returns a new instance of a bitcoin transaction given the serialized bytes. See Tx.

func NewTxFromReader 

func NewTxFromReader(r io.Reader) (*Tx, error)

NewTxFromReader returns a new instance of a bitcoin transaction given a Reader to deserialize the transaction. See Tx.

func (*Tx) Hash 

func (t *Tx) Hash() *hash.Hash

Hash returns the hash of the transaction. This is equivalent to calling TxHash on the underlying wire.MsgTx, however it caches the result so subsequent calls are more efficient.

func (*Tx) Index 

func (t *Tx) Index() int

func (*Tx) RefreshHash 

func (t *Tx) RefreshHash()

func (*Tx) SetIndex 

func (t *Tx) SetIndex(index int)

SetIndex sets the index of the transaction in within a block.

func (*Tx) Transaction 

func (t *Tx) Transaction() *Transaction

Transaction() returns the underlying Tx for the transaction.

type TxDesc 

type TxDesc struct {
	// Tx is the transaction associated with the entry.
	Tx *Tx

	// Added is the time when the entry was added to the source pool.
	Added time.Time

	// Height is the block height when the entry was added to the the source
	// pool.
	Height int64

	// Fee is the total fee the transaction associated with the entry pays.
	Fee int64

	// FeePerKB is the fee the transaction pays in meer per 1000 bytes.
	FeePerKB int64
}

TxDesc is a descriptor about a transaction in a transaction source along with additional metadata.

type TxInput 

type TxInput struct {
	PreviousOut TxOutPoint
	//the signature script (or witness script? or redeem script?)
	SignScript []byte
	// This number has more historical significance than relevant usage;
	// however, its most relevant purpose is to enable “locking” of payments
	// so that they cannot be redeemed until a certain time.
	Sequence uint32 //work with LockTime (disable use 0xffffffff, bitcoin historical)
	AmountIn Amount
}

func NewTxInput 

func NewTxInput(prevOut *TxOutPoint, signScript []byte) *TxInput

NewTxIn returns a new transaction input with the provided previous outpoint point and signature script with a default sequence of MaxTxInSequenceNum.

func (*TxInput) GetSignScript 

func (ti *TxInput) GetSignScript() []byte

func (*TxInput) SerializeSize 

func (ti *TxInput) SerializeSize() int

SerializeSizeWitness returns the number of bytes it would take to serialize the transaction input for a witness.

func (*TxInput) SerializeSizePrefix 

func (ti *TxInput) SerializeSizePrefix() int

SerializeSizePrefix returns the number of bytes it would take to serialize the transaction input for a prefix.

func (*TxInput) SerializeSizeWitness 

func (ti *TxInput) SerializeSizeWitness() int

SerializeSizeWitness returns the number of bytes it would take to serialize the transaction input for a witness.

type TxLoc 

type TxLoc struct {
	TxStart int
	TxLen   int
}

TxLoc holds locator data for the offset and length of where a transaction is located within a MsgBlock data buffer.

type TxOutPoint 

type TxOutPoint struct {
	Hash     hash.Hash //txid
	OutIndex uint32    //vout
}

func NewOutPoint 

func NewOutPoint(hash *hash.Hash, index uint32) *TxOutPoint

NewOutPoint returns a new transaction outpoint point with the provided hash and index.

type TxOutput 

type TxOutput struct {
	Amount   Amount
	PkScript []byte //Here, asm/type -> OP_XXX OP_RETURN
}

func NewTxOutput 

func NewTxOutput(amount Amount, pkScript []byte) *TxOutput

NewTxOutput returns a new bitcoin transaction output with the provided transaction value and public key script.

func (*TxOutput) GetPkScript 

func (to *TxOutput) GetPkScript() []byte

func (*TxOutput) SerializeSize 

func (to *TxOutput) SerializeSize() int

SerializeSize returns the number of bytes it would take to serialize the the transaction output.

type TxSerializeType 

type TxSerializeType uint16

TxSerializeType represents the serialized type of a transaction. 

const (
	// TxSerializeFull indicates a transaction be serialized with the prefix
	// and all witness data.
	TxSerializeFull TxSerializeType = iota
	// TxSerializeNoWitness indicates a transaction be serialized with only
	// the prefix.
	TxSerializeNoWitness
)

type TxType 

type TxType int

TxType indicates the type of transactions such as regular or other tx type (coinbase, stake or token). 

const (
	TxTypeRegular     TxType = iota
	TxTypeCoinbase    TxType = 0x1
	TxTypeGenesisLock TxType = 0x2 // the tx try to lock the genesis output to the stake pool

	TxTypeStakebase     TxType = 0x10 // the special tx which vote for stake_purchase and reward stake holder from the stake_reserve
	TyTypeStakeReserve  TxType = 0x11 // the tx reserve consensus-based value to a special stake_reserve address
	TxTypeStakePurchase TxType = 0x12 // the tx of stake holder who lock value into stake pool
	TxTypeStakeDispose  TxType = 0x13 // the opposite tx of stake_purchase

	TxTypeTokenRegulation TxType = 0x80 // token-regulation is reserved, not for using.
	TxTypeTokenNew        TxType = 0x81 // new coin-id, owners, up-limit etc. the token is disabled after token-new.
	TxTypeTokenRenew      TxType = 0x82 // update owners, up-limits etc. can't change coin-id. renew works only when the token is disabled.
	TxTypeTokenValidate   TxType = 0x83 // enable the token.
	TxTypeTokenInvalidate TxType = 0x84 // disable the token.
	TxTypeTokenRevoke     TxType = 0x8f // revoke the coin-id. token-revoke is reserved, not used at current stage.

	TxTypeTokenbase   TxType = 0x90 // token-base is reserved, not used at current stage.
	TxTypeTokenMint   TxType = 0x91 // token owner mint token amount by locking MEER. (must validated token)
	TxTypeTokenUnmint TxType = 0x92 // token owner unmint token amount by releasing MEER. (must validated token)

	TxTypeCrossChainExport TxType = 0x0101 // Cross chain by export tx
	TxTypeCrossChainImport TxType = 0x0102 // Cross chain by import tx
	TxTypeCrossChainVM     TxType = 0x0103 // Cross chain by vm tx
)

func DetermineTxType 

func DetermineTxType(tx *Transaction) TxType

DetermineTxType determines the type of transaction

func GetTxType 

func GetTxType(txtype string) TxType

func (TxType) String 

func (tt TxType) String() string

type UInt128 

type UInt128 big.Int

func NewUInt128 

func NewUInt128(x int64) *UInt128

func (*UInt128) UnmarshalJSON 

func (i *UInt128) UnmarshalJSON(input []byte) error

type UInt256 

type UInt256 big.Int

func NewUInt256 

func NewUInt256(x int64) *UInt256

func (*UInt256) MarshalJSON 

func (i *UInt256) MarshalJSON() ([]byte, error)

func (*UInt256) UnmarshalJSON 

func (i *UInt256) UnmarshalJSON(input []byte) error

type UInt64 

type UInt64 uint64

func (*UInt64) UnmarshalJSON 

func (i *UInt64) UnmarshalJSON(input []byte) error

type Uint 

type Uint uint

Source Files

View all Source files

Directories

Path Synopsis

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.