config

Documentation

Index

• Variables
• type Config
  • func GetConfig(b []byte) (*Config, error)
• type Internal
  • func (c *Internal) CreateChain(chainID ids.ID, tx *txs.CreateChainTx)
• type Network

Variables

var Default = Config{
	Network:                       DefaultNetwork,
	BlockCacheSize:                64 * units.MiB,
	TxCacheSize:                   128 * units.MiB,
	TransformedSubnetTxCacheSize:  4 * units.MiB,
	RewardUTXOsCacheSize:          2048,
	ChainCacheSize:                2048,
	ChainDBCacheSize:              2048,
	BlockIDCacheSize:              8192,
	FxOwnerCacheSize:              4 * units.MiB,
	SubnetToL1ConversionCacheSize: 4 * units.MiB,
	L1WeightsCacheSize:            16 * units.KiB,
	L1InactiveValidatorsCacheSize: 256 * units.KiB,
	L1SubnetIDNodeIDCacheSize:     16 * units.KiB,
	ChecksumsEnabled:              false,
	MempoolPruneFrequency:         30 * time.Minute,
}

var DefaultNetwork = Network{
	MaxValidatorSetStaleness:                    time.Minute,
	TargetGossipSize:                            20 * units.KiB,
	PushGossipPercentStake:                      .9,
	PushGossipNumValidators:                     100,
	PushGossipNumPeers:                          0,
	PushRegossipNumValidators:                   10,
	PushRegossipNumPeers:                        0,
	PushGossipDiscardedCacheSize:                16384,
	PushGossipMaxRegossipFrequency:              30 * time.Second,
	PushGossipFrequency:                         500 * time.Millisecond,
	PullGossipPollSize:                          1,
	PullGossipFrequency:                         1500 * time.Millisecond,
	PullGossipThrottlingPeriod:                  10 * time.Second,
	PullGossipThrottlingLimit:                   2,
	ExpectedBloomFilterElements:                 8 * 1024,
	ExpectedBloomFilterFalsePositiveProbability: .01,
	MaxBloomFilterFalsePositiveProbability:      .05,
}

Types

type Config

type Config struct {
	Network                       Network       `json:"network"`
	BlockCacheSize                int           `json:"block-cache-size"`
	TxCacheSize                   int           `json:"tx-cache-size"`
	TransformedSubnetTxCacheSize  int           `json:"transformed-subnet-tx-cache-size"`
	RewardUTXOsCacheSize          int           `json:"reward-utxos-cache-size"`
	ChainCacheSize                int           `json:"chain-cache-size"`
	ChainDBCacheSize              int           `json:"chain-db-cache-size"`
	BlockIDCacheSize              int           `json:"block-id-cache-size"`
	FxOwnerCacheSize              int           `json:"fx-owner-cache-size"`
	SubnetToL1ConversionCacheSize int           `json:"subnet-to-l1-conversion-cache-size"`
	L1WeightsCacheSize            int           `json:"l1-weights-cache-size"`
	L1InactiveValidatorsCacheSize int           `json:"l1-inactive-validators-cache-size"`
	L1SubnetIDNodeIDCacheSize     int           `json:"l1-subnet-id-node-id-cache-size"`
	ChecksumsEnabled              bool          `json:"checksums-enabled"`
	MempoolPruneFrequency         time.Duration `json:"mempool-prune-frequency"`
}

Config contains all of the user-configurable parameters of the PlatformVM.

func GetConfig

func GetConfig(b []byte) (*Config, error)

GetConfig returns a Config from the provided json encoded bytes. If a configuration is not provided in the bytes, the default value is set. If empty bytes are provided, the default config is returned.

type Internal

type Internal struct {
	// The node's chain manager
	Chains chains.Manager

	// Node's validator set maps subnetID -> validators of the subnet
	//
	// Invariant: The primary network's validator set should have been added to
	//            the manager before calling VM.Initialize.
	// Invariant: The primary network's validator set should be empty before
	//            calling VM.Initialize.
	Validators validators.Manager

	// Static fees are active before Etna
	CreateAssetTxFee uint64 // Override for CreateSubnet and CreateChain before AP3
	StaticFeeConfig  txfee.StaticConfig

	// Dynamic fees are active after Etna
	DynamicFeeConfig gas.Config

	// ACP-77 validator fees are active after Etna
	ValidatorFeeConfig validatorfee.Config

	// Provides access to the uptime manager as a thread safe data structure
	UptimeLockedCalculator uptime.LockedCalculator

	// True if the node is being run with staking enabled
	SybilProtectionEnabled bool

	// If true, only the P-chain will be instantiated on the primary network.
	PartialSyncPrimaryNetwork bool

	// Set of subnets that this node is validating
	TrackedSubnets set.Set[ids.ID]

	// The minimum amount of tokens one must bond to be a validator
	MinValidatorStake uint64

	// The maximum amount of tokens that can be bonded on a validator
	MaxValidatorStake uint64

	// Minimum stake, in nAVAX, that can be delegated on the primary network
	MinDelegatorStake uint64

	// Minimum fee that can be charged for delegation
	MinDelegationFee uint32

	// UptimePercentage is the minimum uptime required to be rewarded for staking
	UptimePercentage float64

	// Minimum amount of time to allow a staker to stake
	MinStakeDuration time.Duration

	// Maximum amount of time to allow a staker to stake
	MaxStakeDuration time.Duration

	// Config for the minting function
	RewardConfig reward.Config

	// All network upgrade timestamps
	UpgradeConfig upgrade.Config

	// UseCurrentHeight forces [GetMinimumHeight] to return the current height
	// of the P-Chain instead of the oldest block in the [recentlyAccepted]
	// window.
	//
	// This config is particularly useful for triggering proposervm activation
	// on recently created subnets (without this, users need to wait for
	// [recentlyAcceptedWindowTTL] to pass for activation to occur).
	UseCurrentHeight bool
}

Internal contains all of the parameters for the PlatformVM that are internally set by the node.

func (*Internal) CreateChain

func (c *Internal) CreateChain(chainID ids.ID, tx *txs.CreateChainTx)

Create the blockchain described in [tx], but only if this node is a member of the subnet that validates the chain

type Network

type Network struct {
	// MaxValidatorSetStaleness limits how old of a validator set the network
	// will use for peer sampling and rate limiting.
	MaxValidatorSetStaleness time.Duration `json:"max-validator-set-staleness"`
	// TargetGossipSize is the number of bytes that will be attempted to be
	// sent when pushing transactions and when responded to transaction pull
	// requests.
	TargetGossipSize int `json:"target-gossip-size"`
	// PushGossipPercentStake is the percentage of total stake to push
	// transactions to in the first round of gossip. Nodes with higher stake are
	// preferred over nodes with less stake to minimize the number of messages
	// sent over the p2p network.
	PushGossipPercentStake float64 `json:"push-gossip-percent-stake"`
	// PushGossipNumValidators is the number of validators to push transactions
	// to in the first round of gossip.
	PushGossipNumValidators int `json:"push-gossip-num-validators"`
	// PushGossipNumPeers is the number of peers to push transactions to in the
	// first round of gossip.
	PushGossipNumPeers int `json:"push-gossip-num-peers"`
	// PushRegossipNumValidators is the number of validators to push
	// transactions to after the first round of gossip.
	PushRegossipNumValidators int `json:"push-regossip-num-validators"`
	// PushRegossipNumPeers is the number of peers to push transactions to after
	// the first round of gossip.
	PushRegossipNumPeers int `json:"push-regossip-num-peers"`
	// PushGossipDiscardedCacheSize is the number of txIDs to cache to avoid
	// pushing transactions that were recently dropped from the mempool.
	PushGossipDiscardedCacheSize int `json:"push-gossip-discarded-cache-size"`
	// PushGossipMaxRegossipFrequency is the limit for how frequently a
	// transaction will be push gossiped.
	PushGossipMaxRegossipFrequency time.Duration `json:"push-gossip-max-regossip-frequency"`
	// PushGossipFrequency is how frequently rounds of push gossip are
	// performed.
	PushGossipFrequency time.Duration `json:"push-gossip-frequency"`
	// PullGossipPollSize is the number of validators to sample when performing
	// a round of pull gossip.
	PullGossipPollSize int `json:"pull-gossip-poll-size"`
	// PullGossipFrequency is how frequently rounds of pull gossip are
	// performed.
	PullGossipFrequency time.Duration `json:"pull-gossip-frequency"`
	// PullGossipThrottlingPeriod is how large of a window the throttler should
	// use.
	PullGossipThrottlingPeriod time.Duration `json:"pull-gossip-throttling-period"`
	// PullGossipThrottlingLimit is the number of pull querys that are allowed
	// by a validator in every throttling window.
	PullGossipThrottlingLimit int `json:"pull-gossip-throttling-limit"`
	// ExpectedBloomFilterElements is the number of elements to expect when
	// creating a new bloom filter. The larger this number is, the larger the
	// bloom filter will be.
	ExpectedBloomFilterElements int `json:"expected-bloom-filter-elements"`
	// ExpectedBloomFilterFalsePositiveProbability is the expected probability
	// of a false positive after having inserted ExpectedBloomFilterElements
	// into a bloom filter. The smaller this number is, the larger the bloom
	// filter will be.
	ExpectedBloomFilterFalsePositiveProbability float64 `json:"expected-bloom-filter-false-positive-probability"`
	// MaxBloomFilterFalsePositiveProbability is used to determine when the
	// bloom filter should be refreshed. Once the expected probability of a
	// false positive exceeds this value, the bloom filter will be regenerated.
	// The smaller this number is, the more frequently that the bloom filter
	// will be regenerated.
	MaxBloomFilterFalsePositiveProbability float64 `json:"max-bloom-filter-false-positive-probability"`
}