common

type AccountDelta struct {
	Account AccountName
	Delta   int64
}

type AccountName = Name

type ActionName = Name

type Asset struct {
	Amount int64 `eos:"asset"`
	Symbol
}

type BlockIdType = crypto.Sha256

type ChainIdType = crypto.Sha256

type CheckEmpty interface {
	IsEmpty() bool
}

type CheckSum256Type = crypto.Sha256

type Compare interface {
	String() string
}

type Config struct {
	SystemAccountName    AccountName
	NullAccountName      AccountName
	ProducersAccountName AccountName

	// Active permission of producers account requires greater than 2/3 of the producers to authorize
	MajorityProducersPermissionName PermissionName
	MinorityProducersPermissionName PermissionName

	EosioAuthScope AccountName
	EosioAllScope  AccountName
	ActiveName     PermissionName
	OwnerName      PermissionName
	EosioAnyName   PermissionName
	EosioCodeName  PermissionName

	RateLimitingPrecision uint32

	BlockIntervalMs          int64
	BlockIntervalUs          int64
	BlockTimestampEpochMs    int64
	BlockTimestamoEpochNanos int64

	//chain_plugin config
	DefaultAbiSerializerMaxTimeMs uint32

	/**
	 *  The number of sequential blocks produced by a single producer
	 */
	ProducerRepetitions int
	MaxProducers        int

	FixedNetOverheadOfPackedTrx       uint32 //TODO: C++ default value 16 and is this reasonable?
	FixedOverheadSharedVectorRamBytes uint32
	OverheadPerRowPerIndexRamBytes    uint32 ///< overhead accounts for basic tracking structures in a row per index
	OverheadPerAccountRamBytes        uint32 //= 2*1024; ///< overhead accounts for basic account storage and pre-pays features like account recovery
	SetcodeRamBytesMultiplier         uint32 //= 10;     ///< multiplier on contract size to account for multiple copies and cached compilation

	HashingChecktimeBlockSize uint32 //= 10*1024;

	BillableAlignment uint64
	BillableSize      map[string]billableSize

	MaxTrackedDposConfirmations int ///<
	TransactionIdNetUsage       uint32

	Percent_100                  int
	Percent_1                    int
	IrreversibleThresholdPercent int

	AccountCpuUsageAverageWindowMs uint32
	AccountNetUsageAverageWindowMs uint32
	BlockCpuUsageAverageWindowMs   uint32
	BlockSizeAverageWindowMs       uint32

	/**************************chain_config start****************************/
	MaxBlockNetUsage               uint64 ///< the maxiumum net usage in instructions for a block
	TargetBlockNetUsagePct         uint32 ///< the target percent (1% == 100, 100%= 10,000) of maximum net usage; exceeding this triggers congestion handling
	MaxTransactionNetUsage         uint32 ///< the maximum objectively measured net usage that the chain will allow regardless of account limits
	BasePerTransactionNetUsage     uint32 ///< the base amount of net usage billed for a transaction to cover incidentals
	NetUsageLeeway                 uint32
	ContextFreeDiscountNetUsageNum uint32 ///< the numerator for the discount on net usage of context-free data
	ContextFreeDiscountNetUsageDen uint32 ///< the denominator for the discount on net usage of context-free data

	MaxBlockCpuUsage       uint32 ///< the maxiumum billable cpu usage (in microseconds) for a block
	TargetBlockCpuUsagePct uint32 ///< the target percent (1% == 100, 100%= 10,000) of maximum cpu usage; exceeding this triggers congestion handling
	MaxTransactionCpuUsage uint32 ///< the maximum billable cpu usage (in microseconds) that the chain will allow regardless of account limits
	MinTransactionCpuUsage uint32 ///< the minimum billable cpu usage (in microseconds) that the chain requires

	MaxTrxLifetime uint32
	//MaxTransactionLifetime      uint32 ///< the maximum number of seconds that an input transaction's expiration can be ahead of the time of the block in which it is first included
	DeferredTrxExpirationWindow             uint32 ///< the number of seconds after the time a deferred transaction can first execute until it expires
	MaxTrxDelay                             uint32 ///< the maximum number of seconds that can be imposed as a delay requirement by authorization checks
	MaxInlineActionSize                     uint32 ///< maximum allowed size (in bytes) of an inline action
	MaxInlineActionDepth                    uint16 ///< recursion depth limit on sending inline actions
	MaxAuthorityDepth                       uint16 ///< recursion depth limit for checking if an authority is satisfied
	MinNetUsageDeltaBetweenBaseAndMaxForTrx uint32

	ForkDbName                     string
	DBFileName                     string
	ReversibleFileName             string
	BlockFileName                  string
	DefaultBlocksDirName           string
	DefaultReversibleBlocksDirName string
	DefaultStateDirName            string
	DefaultStateSize               uint64
	DefaultStateGuardSize          uint64
	DefaultReversibleCacheSize     uint64
	DefaultReversibleGuardSize     uint64
}

type CurrencyName string

type DigestType = crypto.Sha256

type ExtendedAsset struct {
	Asset    Asset `json:"asset"`
	Contract AccountName
}

type HexBytes []byte

type IdType = int64

type KeyType = uint64

type Microseconds int64

type Name uint64

type NamePair struct {
	First  AccountName
	Second ActionName
}

type NodeIdType = crypto.Sha256

type Options struct {
	// Optimistic is a hint that the value likely exists which
	// allows for the sjson to perform a fast-track search and replace.
	Optimistic bool
	// ReplaceInPlace is a hint to replace the input json rather than
	// allocate a new json byte slice. When this field is specified
	// the input json will not longer be valid and it should not be used
	// In the case when the destination slice doesn't have enough free
	// bytes to replace the data in place, a new bytes slice will be
	// created under the hood.
	// The Optimistic flag must be set to true and the input must be a
	// byte slice in order to use this field.
	ReplaceInPlace bool
}

type Pair struct {
	First  interface{}
	Second interface{}
}

type PermissionLevel struct {
	Actor      AccountName    `json:"actor"`
	Permission PermissionName `json:"permission"`
}

type PermissionName = Name

type ScopeName = Name

type SizeT = int

type StaticVariant = Variant // use type-assert to get static_variant

type Symbol struct {
	Precision uint8
	Symbol    string
}

type SymbolCode = uint64

type TableName = Name

type TimePoint Microseconds

type TimePointSec uint32

type Timer asio.DeadlineTimer

type TransactionIdType = crypto.Sha256

type Tuple []interface{}

type Variant = interface{}

type Variants = map[string]interface{}

type Vint32 int32

type Vuint32 uint32