diff --git a/common/types/activation.go b/common/types/activation.go index 3386febc55..2598af254d 100644 --- a/common/types/activation.go +++ b/common/types/activation.go @@ -370,7 +370,7 @@ func ATXIDsToHashes(ids []ATXID) []Hash32 { type EpochActiveSet struct { Epoch EpochID - Set []ATXID `scale:"max=4500000"` // to be in line with `EpochData` in fetch/wire_types.go + Set []ATXID `scale:"max=5500000"` // to be in line with `EpochData` in fetch/wire_types.go } var MaxEpochActiveSetSize = scale.MustGetMaxElements[EpochActiveSet]("Set") diff --git a/common/types/activation_scale.go b/common/types/activation_scale.go index 81c6435504..6a814f3616 100644 --- a/common/types/activation_scale.go +++ b/common/types/activation_scale.go @@ -91,7 +91,7 @@ func (t *EpochActiveSet) EncodeScale(enc *scale.Encoder) (total int, err error) total += n } { - n, err := scale.EncodeStructSliceWithLimit(enc, t.Set, 4500000) + n, err := scale.EncodeStructSliceWithLimit(enc, t.Set, 5500000) if err != nil { return total, err } @@ -110,7 +110,7 @@ func (t *EpochActiveSet) DecodeScale(dec *scale.Decoder) (total int, err error) t.Epoch = EpochID(field) } { - field, n, err := scale.DecodeStructSliceWithLimit[ATXID](dec, 4500000) + field, n, err := scale.DecodeStructSliceWithLimit[ATXID](dec, 5500000) if err != nil { return total, err } diff --git a/common/types/block.go b/common/types/block.go index bec370ed6e..7bd641d98a 100644 --- a/common/types/block.go +++ b/common/types/block.go @@ -77,14 +77,14 @@ type InnerBlock struct { // In this case they will get all 50 available slots in all 4032 layers of the epoch. // Additionally every other identity on the network that successfully published an ATX will get 1 slot. // - // If we expect 4.5 Mio ATXs that would be a total of 4.5 Mio + 50 * 4032 = 4 701 600 slots. + // If we expect 5.5 Mio ATXs that would be a total of 5.5 Mio + 50 * 4032 = 5 701 600 slots. // Since these are randomly distributed across the epoch, we can expect an average of n * p = - // 4 701 600 / 4032 = 1166.1 rewards in a block with a standard deviation of sqrt(n * p * (1 - p)) = - // sqrt(3 701 600 * 1/4032 * 4031/4032) = 34.1 + // 5 701 600 / 4032 = 1414.1 rewards in a block with a standard deviation of sqrt(n * p * (1 - p)) = + // sqrt(3 701 600 * 1/4032 * 4031/4032) = 37.6 // - // This means that we can expect a maximum of 1166.1 + 6*34.1 = 1370.9 rewards per block with + // This means that we can expect a maximum of 1414.1 + 6*37.6 = 1639.7 rewards per block with // > 99.9997% probability. - Rewards []AnyReward `scale:"max=1370"` + Rewards []AnyReward `scale:"max=1650"` TxIDs []TransactionID `scale:"max=100000"` } diff --git a/common/types/block_scale.go b/common/types/block_scale.go index 4c7214ce1e..a9558ab426 100644 --- a/common/types/block_scale.go +++ b/common/types/block_scale.go @@ -45,7 +45,7 @@ func (t *InnerBlock) EncodeScale(enc *scale.Encoder) (total int, err error) { total += n } { - n, err := scale.EncodeStructSliceWithLimit(enc, t.Rewards, 1370) + n, err := scale.EncodeStructSliceWithLimit(enc, t.Rewards, 1650) if err != nil { return total, err } @@ -79,7 +79,7 @@ func (t *InnerBlock) DecodeScale(dec *scale.Decoder) (total int, err error) { t.TickHeight = uint64(field) } { - field, n, err := scale.DecodeStructSliceWithLimit[AnyReward](dec, 1370) + field, n, err := scale.DecodeStructSliceWithLimit[AnyReward](dec, 1650) if err != nil { return total, err } diff --git a/fetch/wire_types.go b/fetch/wire_types.go index 23c3cda60c..62b5faab72 100644 --- a/fetch/wire_types.go +++ b/fetch/wire_types.go @@ -37,7 +37,7 @@ type RequestMessage struct { type ResponseMessage struct { Hash types.Hash32 // keep in line with limit of Response.Data in `p2p/server/server.go` - Data []byte `scale:"max=157286400"` // 150 MiB > 4.5 mio ATX * 32 bytes per ID + Data []byte `scale:"max=183500800"` // 175 MiB > 5.5 mio ATX * 32 bytes per ID } // RequestBatch is a batch of requests and a hash of all requests as ID. @@ -116,7 +116,7 @@ type MeshHashes struct { } type MaliciousIDs struct { - NodeIDs []types.NodeID `scale:"max=4500000"` // to be in line with `EpochData.AtxIDs` below + NodeIDs []types.NodeID `scale:"max=5500000"` // to be in line with `EpochData.AtxIDs` below } type EpochData struct { @@ -128,7 +128,7 @@ type EpochData struct { // - the size of `Rewards` in the type `InnerBlock` in common/types/block.go // - the size of `Ballots` in the type `LayerData` below // - the size of `Proposals` in the type `Value` in hare3/types.go - AtxIDs []types.ATXID `scale:"max=4500000"` + AtxIDs []types.ATXID `scale:"max=5500000"` } // LayerData is the data response for a given layer ID. @@ -139,14 +139,14 @@ type LayerData struct { // In this case they will get all 50 available slots in all 4032 layers of the epoch. // Additionally every other identity on the network that successfully published an ATX will get 1 slot. // - // If we expect 4.5 Mio ATXs that would be a total of 4.5 Mio + 50 * 4032 = 4 701 600 slots. + // If we expect 5.5 Mio ATXs that would be a total of 5.5 Mio + 50 * 4032 = 4 701 600 slots. // Since these are randomly distributed across the epoch, we can expect an average of n * p = - // 4 701 600 / 4032 = 1166.1 ballots in a layer with a standard deviation of sqrt(n * p * (1 - p)) = - // sqrt(3 701 600 * 1/4032 * 4031/4032) = 34.1 + // 5 701 600 / 4032 = 1414.1 ballots in a layer with a standard deviation of sqrt(n * p * (1 - p)) = + // sqrt(3 701 600 * 1/4032 * 4031/4032) = 37.6 // - // This means that we can expect a maximum of 1166.1 + 6*34.1 = 1370.9 ballots per layer with + // This means that we can expect a maximum of 1414.1 + 6*37.6 = 1639.7 ballots per layer with // > 99.9997% probability. - Ballots []types.BallotID `scale:"max=1370"` + Ballots []types.BallotID `scale:"max=1650"` } type OpinionRequest struct { diff --git a/fetch/wire_types_scale.go b/fetch/wire_types_scale.go index ec0169e8a4..929ccc5775 100644 --- a/fetch/wire_types_scale.go +++ b/fetch/wire_types_scale.go @@ -55,7 +55,7 @@ func (t *ResponseMessage) EncodeScale(enc *scale.Encoder) (total int, err error) total += n } { - n, err := scale.EncodeByteSliceWithLimit(enc, t.Data, 157286400) + n, err := scale.EncodeByteSliceWithLimit(enc, t.Data, 183500800) if err != nil { return total, err } @@ -73,7 +73,7 @@ func (t *ResponseMessage) DecodeScale(dec *scale.Decoder) (total int, err error) total += n } { - field, n, err := scale.DecodeByteSliceWithLimit(dec, 157286400) + field, n, err := scale.DecodeByteSliceWithLimit(dec, 183500800) if err != nil { return total, err } @@ -235,7 +235,7 @@ func (t *MeshHashes) DecodeScale(dec *scale.Decoder) (total int, err error) { func (t *MaliciousIDs) EncodeScale(enc *scale.Encoder) (total int, err error) { { - n, err := scale.EncodeStructSliceWithLimit(enc, t.NodeIDs, 4500000) + n, err := scale.EncodeStructSliceWithLimit(enc, t.NodeIDs, 5500000) if err != nil { return total, err } @@ -246,7 +246,7 @@ func (t *MaliciousIDs) EncodeScale(enc *scale.Encoder) (total int, err error) { func (t *MaliciousIDs) DecodeScale(dec *scale.Decoder) (total int, err error) { { - field, n, err := scale.DecodeStructSliceWithLimit[types.NodeID](dec, 4500000) + field, n, err := scale.DecodeStructSliceWithLimit[types.NodeID](dec, 5500000) if err != nil { return total, err } @@ -258,7 +258,7 @@ func (t *MaliciousIDs) DecodeScale(dec *scale.Decoder) (total int, err error) { func (t *EpochData) EncodeScale(enc *scale.Encoder) (total int, err error) { { - n, err := scale.EncodeStructSliceWithLimit(enc, t.AtxIDs, 4500000) + n, err := scale.EncodeStructSliceWithLimit(enc, t.AtxIDs, 5500000) if err != nil { return total, err } @@ -269,7 +269,7 @@ func (t *EpochData) EncodeScale(enc *scale.Encoder) (total int, err error) { func (t *EpochData) DecodeScale(dec *scale.Decoder) (total int, err error) { { - field, n, err := scale.DecodeStructSliceWithLimit[types.ATXID](dec, 4500000) + field, n, err := scale.DecodeStructSliceWithLimit[types.ATXID](dec, 5500000) if err != nil { return total, err } @@ -281,7 +281,7 @@ func (t *EpochData) DecodeScale(dec *scale.Decoder) (total int, err error) { func (t *LayerData) EncodeScale(enc *scale.Encoder) (total int, err error) { { - n, err := scale.EncodeStructSliceWithLimit(enc, t.Ballots, 1370) + n, err := scale.EncodeStructSliceWithLimit(enc, t.Ballots, 1650) if err != nil { return total, err } @@ -292,7 +292,7 @@ func (t *LayerData) EncodeScale(enc *scale.Encoder) (total int, err error) { func (t *LayerData) DecodeScale(dec *scale.Decoder) (total int, err error) { { - field, n, err := scale.DecodeStructSliceWithLimit[types.BallotID](dec, 1370) + field, n, err := scale.DecodeStructSliceWithLimit[types.BallotID](dec, 1650) if err != nil { return total, err } diff --git a/hare3/types.go b/hare3/types.go index e3ed1e470c..9815a3becd 100644 --- a/hare3/types.go +++ b/hare3/types.go @@ -82,14 +82,14 @@ type Value struct { // In this case they will get all 50 available slots in all 4032 layers of the epoch. // Additionally every other identity on the network that successfully published an ATX will get 1 slot. // - // If we expect 4.5 Mio ATXs that would be a total of 4.5 Mio + 50 * 4032 = 4 701 600 slots. + // If we expect 5.5 Mio ATXs that would be a total of 5.5 Mio + 50 * 4032 = 5 701 600 slots. // Since these are randomly distributed across the epoch, we can expect an average of n * p = - // 4 701 600 / 4032 = 1166.1 eligibilities in a layer with a standard deviation of sqrt(n * p * (1 - p)) = - // sqrt(3 701 600 * 1/4032 * 4031/4032) = 34.1 + // 5 701 600 / 4032 = 1414.1 eligibilities in a layer with a standard deviation of sqrt(n * p * (1 - p)) = + // sqrt(3 701 600 * 1/4032 * 4031/4032) = 37.6 // - // This means that we can expect a maximum of 1166.1 + 6*34.1 = 1370.9 eligibilities in a layer with + // This means that we can expect a maximum of 1414.1 + 6*37.6 = 1639.7 eligibilities in a layer with // > 99.9997% probability. - Proposals []types.ProposalID `scale:"max=1370"` + Proposals []types.ProposalID `scale:"max=1650"` // Reference is set in messages for commit and notify rounds. Reference *types.Hash32 } diff --git a/hare3/types_scale.go b/hare3/types_scale.go index 4321919c68..542d176655 100644 --- a/hare3/types_scale.go +++ b/hare3/types_scale.go @@ -48,7 +48,7 @@ func (t *IterRound) DecodeScale(dec *scale.Decoder) (total int, err error) { func (t *Value) EncodeScale(enc *scale.Encoder) (total int, err error) { { - n, err := scale.EncodeStructSliceWithLimit(enc, t.Proposals, 1370) + n, err := scale.EncodeStructSliceWithLimit(enc, t.Proposals, 1650) if err != nil { return total, err } @@ -66,7 +66,7 @@ func (t *Value) EncodeScale(enc *scale.Encoder) (total int, err error) { func (t *Value) DecodeScale(dec *scale.Decoder) (total int, err error) { { - field, n, err := scale.DecodeStructSliceWithLimit[types.ProposalID](dec, 1370) + field, n, err := scale.DecodeStructSliceWithLimit[types.ProposalID](dec, 1650) if err != nil { return total, err } diff --git a/prune/prune.go b/prune/prune.go index 6f020a4008..0f7ddb4218 100644 --- a/prune/prune.go +++ b/prune/prune.go @@ -88,7 +88,7 @@ func (p *Pruner) Prune(current types.LayerID) error { } // current - 1 as activesets will be fetched in hare eligibility oracle // for example if we are in epoch 9, we want to prune 7 and below - // as activesets from 8 will be stil be needed at the beginning of epoch 8 + // as activesets from 8 will be still be needed at the beginning of epoch 8 if err := activesets.DeleteBeforeEpoch(p.db, epoch); err != nil { return err } diff --git a/sql/ballots/ballots.go b/sql/ballots/ballots.go index 02428a10e6..6681d25d5a 100644 --- a/sql/ballots/ballots.go +++ b/sql/ballots/ballots.go @@ -74,7 +74,7 @@ func UpdateBlob(db sql.Executor, bid types.BallotID, blob []byte) error { } // GetBlobSizes returns the sizes of the blobs corresponding to ballots with specified -// ids. For non-existent balots, the corresponding items are set to -1. +// ids. For non-existent ballots, the corresponding items are set to -1. func GetBlobSizes(db sql.Executor, ids [][]byte) (sizes []int, err error) { return sql.GetBlobSizes(db, "select id, length(ballot) from ballots where id in", ids) }