dominant-strategies / go-quai Goto Github PK

// ExternalBlock represents an external block with transactions destined for a specific context.
type ExternalBlock struct {
	header       *Header
	externalTxs  Transactions
	originLocation byte
	
	// caches
	hash atomic.Value
	size atomic.Value

	// Td is used by package core to store the total difficulty
	// of the chain up to and including the block.
	td *big.Int

	// These fields are used by package eth to track
	// inter-peer block relay.
	ReceivedAt   time.Time
	ReceivedFrom interface{}
}

if header.Time < parent.Time {
		return errOlderBlockTime
}

type Header struct {
    ParentHash  []common.Hash    `json:"parentHash"       gencodec:"required"`
    UncleHash   []common.Hash    `json:"sha3Uncles"       gencodec:"required"`
    Coinbase    []common.Address `json:"miner"            gencodec:"required"`
    Root        []common.Hash    `json:"stateRoot"        gencodec:"required"`
    TxHash      []common.Hash    `json:"transactionsRoot" gencodec:"required"`
    ReceiptHash []common.Hash    `json:"receiptsRoot"     gencodec:"required"`
    Bloom       []Bloom          `json:"logsBloom"        gencodec:"required"`
    Difficulty  []*big.Int       `json:"difficulty"       gencodec:"required"`
    Number      []*big.Int       `json:"number"           gencodec:"required"`
    GasLimit    uint64         `json:"gasLimit"         gencodec:"required"`
    GasUsed     uint64         `json:"gasUsed"          gencodec:"required"`
    Time        uint64         `json:"timestamp"        gencodec:"required"`
    Extra       []byte         `json:"extraData"        gencodec:"required"`
    MixDigest   common.Hash    `json:"mixHash"`
    Nonce       BlockNonce     `json:"nonce"`

    // BaseFee was added by EIP-1559 and is ignored in legacy headers.
    BaseFee *big.Int `json:"baseFeePerGas" rlp:"optional"`

    // New
    // Map the current Region / Zone 
    MapContext  []byte

    Location    []byte
}

// ExternalTx is the data of EIP-2930 access list transactions.
type ExternalTx struct {
    ChainID         *big.Int        // destination chain ID
    Nonce           uint64          // nonce of sender account
    GasPrice        *big.Int        // wei per gas
    Gas             uint64          // gas limit
    FromAddress     *common.Address `rlp:"nil"` // nil means contract creation
    FromLocation    byte            // origin location in bytes for tx 
    ToAddress       *common.Address `rlp:"nil"` // nil means contract creation
    ToLocation      byte            // destination location in bytes for tx
    Value           *big.Int        // wei amount
    V, R, S         *big.Int        // signature values
}

type Genesis struct {
	Config     *params.ChainConfig `json:"config"`
	Nonce      uint64              `json:"nonce"`
	Timestamp  uint64              `json:"timestamp"`
	ExtraData  [][]byte            `json:"extraData"`
	GasLimit   []uint64            `json:"gasLimit"   gencodec:"required"`
	Difficulty []*big.Int          `json:"difficulty" gencodec:"required"`
	Mixhash    []common.Hash       `json:"mixHash"`
	Coinbase   []common.Address    `json:"coinbase"`
	Alloc      []GenesisAlloc      `json:"alloc"      gencodec:"required"`
	SealRlp    []byte              `json:"sealRlp"`

	// These fields are used for consensus tests. Please don't use them
	// in actual genesis blocks.
	Number     []uint64      `json:"number"`
	GasUsed    []uint64      `json:"gasUsed"`
	ParentHash []common.Hash `json:"parentHash"`
	BaseFee    []*big.Int    `json:"baseFee"`
}

func init() {
	bytePrefixList[9000] = byte(0)
	bytePrefixList[9100] = byte(10)
	bytePrefixList[9101] = byte(26)
	bytePrefixList[9102] = byte(42)
	bytePrefixList[9103] = byte(58)
	bytePrefixList[9200] = byte(11)
	bytePrefixList[9201] = byte(27)
	bytePrefixList[9202] = byte(43)
	bytePrefixList[9203] = byte(59)
	bytePrefixList[9300] = byte(12)
	bytePrefixList[9301] = byte(28)
	bytePrefixList[9302] = byte(44)
	bytePrefixList[9303] = byte(60)
}

// ChainIDByte returns the byte lookup based off a configs chainID
func (c *ChainConfig) ChainIDByte() byte {
	lookup := bytePrefixList[c.ChainID.Int64()]
	return lookup
}

// ChainIDByte returns the byte lookup based off a configs chainID
func LookupChainByte(index *big.Int) byte {
	lookup := bytePrefixList[index.Int64()]
	return lookup
}

// ValidChainID takes in a chain ID and checks against the valid list
func ValidChainID(id *big.Int) bool {
	for _, valid := range validChains {
		if id.Cmp(valid) == 0 {
			return true
		}
	}
	return false
}

// RPCMarshalHeader converts the given header to the RPC output .
func RPCMarshalHeader(head *types.Header) map[string]interface{} {
	result := map[string]interface{}{
		"number":           head.Number,
		"hash":             head.Hash(),
		"parentHash":       head.ParentHash,
		"nonce":            head.Nonce,
		"mixHash":          head.MixDigest,
		"sha3Uncles":       head.UncleHash,
		"logsBloom":        head.Bloom,
		"stateRoot":        head.Root,
		"miner":            head.Coinbase,
		"difficulty":       head.Difficulty,
		"extraData":        head.Extra,
		"size":             hexutil.Uint64(head.Size()),
		"gasLimit":         head.GasLimit,
		"gasUsed":          head.GasUsed,
		"timestamp":        head.Time,
		"transactionsRoot": head.TxHash,
		"receiptsRoot":     head.ReceiptHash,
	}

	if head.BaseFee != nil {
		result["baseFeePerGas"] = head.BaseFee
	}

	return result
}