dagconfig

README

DAG Configuration

Package dagconfig defines DAG configuration parameters for the standard Karlsend networks and provides the ability for callers to define their own custom Karlsend networks.

Sample Use

package main

import (
	"flag"
	"fmt"
	"log"

	"github.com/karlsen-network/karlsend/util"
	"github.com/karlsen-network/karlsend/domain/dagconfig"
)

var testnet = flag.Bool("testnet", false, "operate on the testnet Karlsen network")

// By default (without --testnet), use mainnet.
var dagParams = &dagconfig.MainnetParams

func main() {
	flag.Parse()

	// Modify active network parameters if operating on testnet.
	if *testnet {
		dagParams = &dagconfig.TestnetParams
	}

	// later...

	// Create and print new payment address, specific to the active network.
	pubKey := make([]byte, 32)
	addr, err := util.NewAddressPubKey(pubKey, dagParams)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(addr)
}

Documentation

Overview

Package dagconfig defines DAG configuration parameters.

In addition to the main Karlsen network, which is intended for the transfer of monetary value, there also exists the following standard networks:

• testnet
• simnet
• devnet

These networks are incompatible with each other (each sharing a different genesis block) and software should handle errors where input intended for one network is used on an application instance running on a different network.

For library packages, dagconfig provides the ability to lookup DAG parameters and encoding magics when passed a *Params.

For main packages, a (typically global) var may be assigned the address of one of the standard Param vars for use as the application's "active" network. When a network parameter is needed, it may then be looked up through this variable (either directly, or hidden in a library call).

package main

import (
	"flag"
	"fmt"
	"log"

	"github.com/karlsen-network/karlsend/v2/util"
	"github.com/karlsen-network/karlsend/v2/domain/dagconfig"
)

var testnet = flag.Bool("testnet", false, "operate on the testnet Karlsen network")

// By default (without --testnet), use mainnet.
var dagParams = &dagconfig.MainnetParams

func main() {
	flag.Parse()

	// Modify active network parameters if operating on testnet.
	if *testnet {
		dagParams = &dagconfig.TestnetParams
	}

	// later...

	// Create and print new payment address, specific to the active network.
	pubKey := make([]byte, 32)
	addr, err := util.NewAddressPubKey(pubKey, dagParams)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(addr)
}

If an application does not use one of the standard Karlsen networks, a new Params struct may be created which defines the parameters for the non- standard network. As a general rule of thumb, all network parameters should be unique to the network, but parameter collisions can still occur.

Index

• Variables
• func Register(params *Params) error
• type KType
• type Params
  • func (p *Params) FinalityDepth() uint64
  • func (p *Params) NormalizeRPCServerAddress(addr string) (string, error)
  • func (p *Params) PruningDepth() uint64

Variables

var DevnetParams = Params{
	K:           defaultGHOSTDAGK,
	Name:        "karlsen-devnet",
	Net:         appmessage.Devnet,
	RPCPort:     "42610",
	DefaultPort: "42611",
	DNSSeeds:    []string{},

	GenesisBlock:                    &devnetGenesisBlock,
	GenesisHash:                     devnetGenesisHash,
	PowMax:                          devnetPowMax,
	BlockCoinbaseMaturity:           100,
	SubsidyGenesisReward:            defaultSubsidyGenesisReward,
	PreDeflationaryPhaseBaseSubsidy: defaultPreDeflationaryPhaseBaseSubsidy,
	DeflationaryPhaseBaseSubsidy:    defaultDeflationaryPhaseBaseSubsidy,
	TargetTimePerBlock:              defaultTargetTimePerBlock,
	FinalityDuration:                defaultFinalityDuration,
	DifficultyAdjustmentWindowSize:  defaultDifficultyAdjustmentWindowSize,
	MinDifficultyWindowLen:          10,
	TimestampDeviationTolerance:     defaultTimestampDeviationTolerance,

	RuleChangeActivationThreshold: 1512,
	MinerConfirmationWindow:       2016,

	RelayNonStdTxs: false,

	AcceptUnroutable: true,

	Prefix: util.Bech32PrefixKarlsenDev,

	PrivateKeyID: 0xef,

	EnableNonNativeSubnetworks: false,

	DisableDifficultyAdjustment: false,

	MaxCoinbasePayloadLength:                defaultMaxCoinbasePayloadLength,
	MaxBlockMass:                            defaultMaxBlockMass,
	MaxBlockParents:                         defaultMaxBlockParents,
	MassPerTxByte:                           defaultMassPerTxByte,
	MassPerScriptPubKeyByte:                 defaultMassPerScriptPubKeyByte,
	MassPerSigOp:                            defaultMassPerSigOp,
	MergeSetSizeLimit:                       defaultMergeSetSizeLimit,
	CoinbasePayloadScriptPublicKeyMaxLength: defaultCoinbasePayloadScriptPublicKeyMaxLength,
	PruningProofM:                           defaultPruningProofM,
	DeflationaryPhaseDaaScore:               defaultDeflationaryPhaseDaaScore,

	MaxBlockLevel: 250,
	MergeDepth:    defaultMergeDepth,
	HFDAAScore:    3600,
}

DevnetParams defines the network parameters for the development Karlsen network.

var ErrDuplicateNet = errors.New("duplicate Karlsen network")

ErrDuplicateNet describes an error where the parameters for a Karlsen network could not be set due to the network already being a standard network or previously-registered into this package.

var MainnetParams = Params{
	K:           defaultGHOSTDAGK,
	Name:        "karlsen-mainnet",
	Net:         appmessage.Mainnet,
	RPCPort:     "42110",
	DefaultPort: "42111",
	DNSSeeds: []string{

		"mainnet-dnsseed-1.karlsencoin.com",
		"mainnet-dnsseed-2.karlsencoin.com",
		"mainnet-dnsseed-3.karlsencoin.com",
		"mainnet-dnsseed-4.karlsencoin.com",
		"mainnet-dnsseed-5.karlsencoin.com",
	},

	GenesisBlock:                    &genesisBlock,
	GenesisHash:                     genesisHash,
	PowMax:                          mainPowMax,
	BlockCoinbaseMaturity:           100,
	SubsidyGenesisReward:            defaultSubsidyGenesisReward,
	PreDeflationaryPhaseBaseSubsidy: defaultPreDeflationaryPhaseBaseSubsidy,
	DeflationaryPhaseBaseSubsidy:    defaultDeflationaryPhaseBaseSubsidy,
	TargetTimePerBlock:              defaultTargetTimePerBlock,
	FinalityDuration:                defaultFinalityDuration,
	DifficultyAdjustmentWindowSize:  defaultDifficultyAdjustmentWindowSize,
	MinDifficultyWindowLen:          10,
	TimestampDeviationTolerance:     defaultTimestampDeviationTolerance,

	RuleChangeActivationThreshold: 1916,
	MinerConfirmationWindow:       2016,

	RelayNonStdTxs: false,

	AcceptUnroutable: false,

	Prefix: util.Bech32PrefixKarlsen,

	PrivateKeyID: 0x80,

	EnableNonNativeSubnetworks: false,

	DisableDifficultyAdjustment: false,

	MaxCoinbasePayloadLength:                defaultMaxCoinbasePayloadLength,
	MaxBlockMass:                            defaultMaxBlockMass,
	MaxBlockParents:                         defaultMaxBlockParents,
	MassPerTxByte:                           defaultMassPerTxByte,
	MassPerScriptPubKeyByte:                 defaultMassPerScriptPubKeyByte,
	MassPerSigOp:                            defaultMassPerSigOp,
	MergeSetSizeLimit:                       defaultMergeSetSizeLimit,
	CoinbasePayloadScriptPublicKeyMaxLength: defaultCoinbasePayloadScriptPublicKeyMaxLength,
	PruningProofM:                           defaultPruningProofM,
	DeflationaryPhaseDaaScore:               defaultDeflationaryPhaseDaaScore,

	DisallowDirectBlocksOnTopOfGenesis: false,

	MaxBlockLevel: 225,
	MergeDepth:    defaultMergeDepth,
	HFDAAScore:    26962009,
}

MainnetParams defines the network parameters for the main Karlsen network.

var SimnetParams = Params{
	K:           defaultGHOSTDAGK,
	Name:        "karlsen-simnet",
	Net:         appmessage.Simnet,
	RPCPort:     "42510",
	DefaultPort: "42511",
	DNSSeeds:    []string{},

	GenesisBlock:                    &simnetGenesisBlock,
	GenesisHash:                     simnetGenesisHash,
	PowMax:                          simnetPowMax,
	BlockCoinbaseMaturity:           100,
	SubsidyGenesisReward:            defaultSubsidyGenesisReward,
	PreDeflationaryPhaseBaseSubsidy: defaultPreDeflationaryPhaseBaseSubsidy,
	DeflationaryPhaseBaseSubsidy:    defaultDeflationaryPhaseBaseSubsidy,
	TargetTimePerBlock:              time.Millisecond,
	FinalityDuration:                time.Minute,
	DifficultyAdjustmentWindowSize:  defaultDifficultyAdjustmentWindowSize,
	MinDifficultyWindowLen:          10,
	TimestampDeviationTolerance:     defaultTimestampDeviationTolerance,

	RuleChangeActivationThreshold: 75,
	MinerConfirmationWindow:       100,

	RelayNonStdTxs: false,

	AcceptUnroutable: false,

	PrivateKeyID: 0x64,

	Prefix: util.Bech32PrefixKarlsenSim,

	EnableNonNativeSubnetworks: false,

	DisableDifficultyAdjustment: true,

	MaxCoinbasePayloadLength:                defaultMaxCoinbasePayloadLength,
	MaxBlockMass:                            defaultMaxBlockMass,
	MaxBlockParents:                         defaultMaxBlockParents,
	MassPerTxByte:                           defaultMassPerTxByte,
	MassPerScriptPubKeyByte:                 defaultMassPerScriptPubKeyByte,
	MassPerSigOp:                            defaultMassPerSigOp,
	MergeSetSizeLimit:                       defaultMergeSetSizeLimit,
	CoinbasePayloadScriptPublicKeyMaxLength: defaultCoinbasePayloadScriptPublicKeyMaxLength,
	PruningProofM:                           defaultPruningProofM,
	DeflationaryPhaseDaaScore:               defaultDeflationaryPhaseDaaScore,

	MaxBlockLevel: 250,
	MergeDepth:    defaultMergeDepth,
	HFDAAScore:    3600,
}

SimnetParams defines the network parameters for the simulation test Karlsen network. This network is similar to the normal test network except it is intended for private use within a group of individuals doing simulation testing. The functionality is intended to differ in that the only nodes which are specifically specified are used to create the network rather than following normal discovery rules. This is important as otherwise it would just turn into another public testnet.

var TestnetParams = Params{
	K:           defaultGHOSTDAGK,
	Name:        "karlsen-testnet-1",
	Net:         appmessage.Testnet,
	RPCPort:     "42210",
	DefaultPort: "42211",
	DNSSeeds: []string{
		"testnet-1-dnsseed.karlsencoin.com",
	},

	GenesisBlock:                    &testnetGenesisBlock,
	GenesisHash:                     testnetGenesisHash,
	PowMax:                          testnetPowMax,
	BlockCoinbaseMaturity:           100,
	SubsidyGenesisReward:            defaultSubsidyGenesisReward,
	PreDeflationaryPhaseBaseSubsidy: defaultPreDeflationaryPhaseBaseSubsidy,
	DeflationaryPhaseBaseSubsidy:    defaultDeflationaryPhaseBaseSubsidy,
	TargetTimePerBlock:              defaultTargetTimePerBlock,
	FinalityDuration:                defaultFinalityDuration,
	DifficultyAdjustmentWindowSize:  defaultDifficultyAdjustmentWindowSize,
	MinDifficultyWindowLen:          10,
	TimestampDeviationTolerance:     defaultTimestampDeviationTolerance,

	RuleChangeActivationThreshold: 1512,
	MinerConfirmationWindow:       2016,

	RelayNonStdTxs: false,

	AcceptUnroutable: false,

	Prefix: util.Bech32PrefixKarlsenTest,

	PrivateKeyID: 0xef,

	EnableNonNativeSubnetworks: false,

	DisableDifficultyAdjustment: false,

	MaxCoinbasePayloadLength:                defaultMaxCoinbasePayloadLength,
	MaxBlockMass:                            defaultMaxBlockMass,
	MaxBlockParents:                         defaultMaxBlockParents,
	MassPerTxByte:                           defaultMassPerTxByte,
	MassPerScriptPubKeyByte:                 defaultMassPerScriptPubKeyByte,
	MassPerSigOp:                            defaultMassPerSigOp,
	MergeSetSizeLimit:                       defaultMergeSetSizeLimit,
	CoinbasePayloadScriptPublicKeyMaxLength: defaultCoinbasePayloadScriptPublicKeyMaxLength,
	PruningProofM:                           defaultPruningProofM,
	DeflationaryPhaseDaaScore:               defaultDeflationaryPhaseDaaScore,

	MaxBlockLevel: 250,
	MergeDepth:    defaultMergeDepth,
	HFDAAScore:    43200,
}

TestnetParams defines the network parameters for the test Karlsen network.

Functions

func Register

func Register(params *Params) error

Register registers the network parameters for a Karlsen network. This may error with ErrDuplicateNet if the network is already registered (either due to a previous Register call, or the network being one of the default networks).

Network parameters should be registered into this package by a main package as early as possible. Then, library packages may lookup networks or network parameters based on inputs and work regardless of the network being standard or not.

Types

type KType

type KType uint8

KType defines the size of GHOSTDAG consensus algorithm K parameter.

type Params

type Params struct {
	// K defines the K parameter for GHOSTDAG consensus algorithm.
	// See ghostdag.go for further details.
	K externalapi.KType

	// Name defines a human-readable identifier for the network.
	Name string

	// Net defines the magic bytes used to identify the network.
	Net appmessage.KarlsenNet

	// RPCPort defines the rpc server port
	RPCPort string

	// DefaultPort defines the default peer-to-peer port for the network.
	DefaultPort string

	// DNSSeeds defines a list of DNS seeds for the network that are used
	// as one method to discover peers.
	DNSSeeds []string

	// GRPCSeeds defines a list of GRPC seeds for the network that are used
	// as one method to discover peers.
	GRPCSeeds []string

	// GenesisBlock defines the first block of the DAG.
	GenesisBlock *externalapi.DomainBlock

	// GenesisHash is the starting block hash.
	GenesisHash *externalapi.DomainHash

	// PowMax defines the highest allowed proof of work value for a block
	// as a uint256.
	PowMax *big.Int

	// BlockCoinbaseMaturity is the number of blocks required before newly mined
	// coins can be spent.
	BlockCoinbaseMaturity uint64

	// SubsidyGenesisReward SubsidyMergeSetRewardMultiplier, and
	// SubsidyPastRewardMultiplier are part of the block subsidy equation.
	// Further details: https://hashdag.medium.com/kaspa-launch-plan-9a63f4d754a6
	SubsidyGenesisReward            uint64
	PreDeflationaryPhaseBaseSubsidy uint64
	DeflationaryPhaseBaseSubsidy    uint64

	// TargetTimePerBlock is the desired amount of time to generate each
	// block.
	TargetTimePerBlock time.Duration

	// FinalityDuration is the duration of the finality window.
	FinalityDuration time.Duration

	// TimestampDeviationTolerance is the maximum offset a block timestamp
	// is allowed to be in the future before it gets delayed
	TimestampDeviationTolerance int

	// DifficultyAdjustmentWindowSize is the size of window that is inspected
	// to calculate the required difficulty of each block.
	DifficultyAdjustmentWindowSize int

	// MinDifficultyWindowLen is the minimum size of window that can be inspected
	// under this value the genesis difficulty is sent.
	MinDifficultyWindowLen int

	// These fields are related to voting on consensus rule changes as
	// defined by BIP0009.
	//
	// RuleChangeActivationThreshold is the number of blocks in a threshold
	// state retarget window for which a positive vote for a rule change
	// must be cast in order to lock in a rule change. It should typically
	// be 95% for the main network and 75% for test networks.
	//
	// MinerConfirmationWindow is the number of blocks in each threshold
	// state retarget window.
	//
	// Deployments define the specific consensus rule changes to be voted
	// on.
	RuleChangeActivationThreshold uint64
	MinerConfirmationWindow       uint64

	// Mempool parameters
	RelayNonStdTxs bool

	// AcceptUnroutable specifies whether this network accepts unroutable
	// IP addresses, such as 10.0.0.0/8
	AcceptUnroutable bool

	// Human-readable prefix for Bech32 encoded addresses
	Prefix util.Bech32Prefix

	// Address encoding magics
	PrivateKeyID byte // First byte of a WIF private key

	// EnableNonNativeSubnetworks enables non-native/coinbase transactions
	EnableNonNativeSubnetworks bool

	// DisableDifficultyAdjustment determine whether to use difficulty
	DisableDifficultyAdjustment bool

	// SkipProofOfWork indicates whether proof of work should be checked.
	SkipProofOfWork bool

	// MaxCoinbasePayloadLength is the maximum length in bytes allowed for a block's coinbase's payload
	MaxCoinbasePayloadLength uint64

	// MaxBlockMass is the maximum mass a block is allowed
	MaxBlockMass uint64

	// MaxBlockParents is the maximum number of blocks a block is allowed to point to
	MaxBlockParents externalapi.KType

	// MassPerTxByte is the number of grams that any byte
	// adds to a transaction.
	MassPerTxByte uint64

	// MassPerScriptPubKeyByte is the number of grams that any
	// scriptPubKey byte adds to a transaction.
	MassPerScriptPubKeyByte uint64

	// MassPerSigOp is the number of grams that any
	// signature operation adds to a transaction.
	MassPerSigOp uint64

	// MergeSetSizeLimit is the maximum number of blocks in a block's merge set
	MergeSetSizeLimit uint64

	// CoinbasePayloadScriptPublicKeyMaxLength is the maximum allowed script public key in the coinbase's payload
	CoinbasePayloadScriptPublicKeyMaxLength uint8

	// PruningProofM is the 'm' constant in the pruning proof. For more details see: https://github.com/karlsen-network/research/issues/3
	PruningProofM uint64

	// DeflationaryPhaseDaaScore is the DAA score after which the monetary policy switches
	// to its deflationary phase
	DeflationaryPhaseDaaScore uint64

	DisallowDirectBlocksOnTopOfGenesis bool

	// MaxBlockLevel is the maximum possible block level.
	MaxBlockLevel int

	MergeDepth uint64
	HFDAAScore uint64
}

Params defines a Karlsen network by its parameters. These parameters may be used by Karlsen applications to differentiate networks as well as addresses and keys for one network from those intended for use on another network.

func (*Params) FinalityDepth

func (p *Params) FinalityDepth() uint64

FinalityDepth returns the finality duration represented in blocks

func (*Params) NormalizeRPCServerAddress

func (p *Params) NormalizeRPCServerAddress(addr string) (string, error)

NormalizeRPCServerAddress returns addr with the current network default port appended if there is not already a port specified.

func (*Params) PruningDepth

func (p *Params) PruningDepth() uint64

PruningDepth returns the pruning duration represented in blocks