diff --git a/agreement/abstractions.go b/agreement/abstractions.go
index 44aafa4fd8..25c920e02e 100644
--- a/agreement/abstractions.go
+++ b/agreement/abstractions.go
@@ -59,7 +59,7 @@ type ValidatedBlock interface {
//
// Calls to Seed() or to Digest() on the copy's Block must
// reflect the value of the new seed.
- WithSeed(committee.Seed) ValidatedBlock
+ WithSeed(committee.Seed, basics.Address) ValidatedBlock
// Block returns the underlying block that has been validated.
Block() bookkeeping.Block
diff --git a/agreement/agreementtest/simulate_test.go b/agreement/agreementtest/simulate_test.go
index 53c42411ed..335a781ef0 100644
--- a/agreement/agreementtest/simulate_test.go
+++ b/agreement/agreementtest/simulate_test.go
@@ -79,8 +79,9 @@ func (b testValidatedBlock) Block() bookkeeping.Block {
return b.Inside
}
-func (b testValidatedBlock) WithSeed(s committee.Seed) agreement.ValidatedBlock {
+func (b testValidatedBlock) WithSeed(s committee.Seed, proposer basics.Address) agreement.ValidatedBlock {
b.Inside.BlockHeader.Seed = s
+ b.Inside.BlockHeader.Proposer = proposer
return b
}
diff --git a/agreement/common_test.go b/agreement/common_test.go
index 0c11d9553d..1b4f8d17ba 100644
--- a/agreement/common_test.go
+++ b/agreement/common_test.go
@@ -165,8 +165,9 @@ func (b testValidatedBlock) Block() bookkeeping.Block {
return b.Inside
}
-func (b testValidatedBlock) WithSeed(s committee.Seed) ValidatedBlock {
+func (b testValidatedBlock) WithSeed(s committee.Seed, proposer basics.Address) ValidatedBlock {
b.Inside.BlockHeader.Seed = s
+ b.Inside.BlockHeader.Proposer = proposer
return b
}
diff --git a/agreement/fuzzer/ledger_test.go b/agreement/fuzzer/ledger_test.go
index a62caee4d9..e1f90d5d2a 100644
--- a/agreement/fuzzer/ledger_test.go
+++ b/agreement/fuzzer/ledger_test.go
@@ -93,8 +93,9 @@ func (b testValidatedBlock) Block() bookkeeping.Block {
return b.Inside
}
-func (b testValidatedBlock) WithSeed(s committee.Seed) agreement.ValidatedBlock {
+func (b testValidatedBlock) WithSeed(s committee.Seed, proposer basics.Address) agreement.ValidatedBlock {
b.Inside.BlockHeader.Seed = s
+ b.Inside.BlockHeader.Proposer = proposer
return b
}
diff --git a/agreement/msgp_gen.go b/agreement/msgp_gen.go
index 5a5efa7ddc..066715af6d 100644
--- a/agreement/msgp_gen.go
+++ b/agreement/msgp_gen.go
@@ -4221,123 +4221,131 @@ func PlayerMaxSize() (s int) {
func (z *proposal) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0004Len := uint32(29)
- var zb0004Mask uint64 /* 38 bits */
+ zb0004Len := uint32(31)
+ var zb0004Mask uint64 /* 40 bits */
if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel == 0 {
zb0004Len--
zb0004Mask |= 0x40
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x80
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "" {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0 {
zb0004Len--
zb0004Mask |= 0x200
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "" {
zb0004Len--
zb0004Mask |= 0x400
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x800
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x1000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x2000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x4000
}
- if (*z).unauthenticatedProposal.OriginalPeriod == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
zb0004Len--
zb0004Mask |= 0x8000
}
- if (*z).unauthenticatedProposal.OriginalProposer.MsgIsZero() {
+ if (*z).unauthenticatedProposal.OriginalPeriod == 0 {
zb0004Len--
zb0004Mask |= 0x10000
}
- if len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
+ if (*z).unauthenticatedProposal.OriginalProposer.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x20000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero() {
+ if len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
zb0004Len--
zb0004Mask |= 0x40000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x80000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x200000
+ }
+ if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0 {
zb0004Len--
zb0004Mask |= 0x400000
}
+ if (*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x1000000
+ }
if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x800000
+ zb0004Mask |= 0x2000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x1000000
+ zb0004Mask |= 0x4000000
}
if (*z).unauthenticatedProposal.SeedProof.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x2000000
+ zb0004Mask |= 0x8000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.Seed.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x4000000
+ zb0004Mask |= 0x10000000
}
if len((*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking) == 0 {
zb0004Len--
- zb0004Mask |= 0x8000000
+ zb0004Mask |= 0x20000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter == 0 {
zb0004Len--
- zb0004Mask |= 0x10000000
+ zb0004Mask |= 0x40000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp == 0 {
zb0004Len--
- zb0004Mask |= 0x20000000
+ zb0004Mask |= 0x80000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x40000000
+ zb0004Mask |= 0x100000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x80000000
+ zb0004Mask |= 0x200000000
}
if (*z).unauthenticatedProposal.Block.Payset.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x100000000
+ zb0004Mask |= 0x400000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x200000000
+ zb0004Mask |= 0x800000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x400000000
+ zb0004Mask |= 0x1000000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove == false {
zb0004Len--
- zb0004Mask |= 0x800000000
+ zb0004Mask |= 0x2000000000
}
// variable map header, size zb0004Len
o = msgp.AppendMapHeader(o, zb0004Len)
@@ -4348,56 +4356,61 @@ func (z *proposal) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel)
}
if (zb0004Mask & 0x80) == 0 { // if not empty
+ // string "fc"
+ o = append(o, 0xa2, 0x66, 0x63)
+ o = (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x100) == 0 { // if not empty
// string "fees"
o = append(o, 0xa4, 0x66, 0x65, 0x65, 0x73)
o = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MarshalMsg(o)
}
- if (zb0004Mask & 0x100) == 0 { // if not empty
+ if (zb0004Mask & 0x200) == 0 { // if not empty
// string "frac"
o = append(o, 0xa4, 0x66, 0x72, 0x61, 0x63)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue)
}
- if (zb0004Mask & 0x200) == 0 { // if not empty
+ if (zb0004Mask & 0x400) == 0 { // if not empty
// string "gen"
o = append(o, 0xa3, 0x67, 0x65, 0x6e)
o = msgp.AppendString(o, (*z).unauthenticatedProposal.Block.BlockHeader.GenesisID)
}
- if (zb0004Mask & 0x400) == 0 { // if not empty
+ if (zb0004Mask & 0x800) == 0 { // if not empty
// string "gh"
o = append(o, 0xa2, 0x67, 0x68)
o = (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MarshalMsg(o)
}
- if (zb0004Mask & 0x800) == 0 { // if not empty
+ if (zb0004Mask & 0x1000) == 0 { // if not empty
// string "nextbefore"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000) == 0 { // if not empty
// string "nextproto"
o = append(o, 0xa9, 0x6e, 0x65, 0x78, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000) == 0 { // if not empty
// string "nextswitch"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000) == 0 { // if not empty
// string "nextyes"
o = append(o, 0xa7, 0x6e, 0x65, 0x78, 0x74, 0x79, 0x65, 0x73)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals)
}
- if (zb0004Mask & 0x8000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000) == 0 { // if not empty
// string "oper"
o = append(o, 0xa4, 0x6f, 0x70, 0x65, 0x72)
o = msgp.AppendUint64(o, uint64((*z).unauthenticatedProposal.OriginalPeriod))
}
- if (zb0004Mask & 0x10000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000) == 0 { // if not empty
// string "oprop"
o = append(o, 0xa5, 0x6f, 0x70, 0x72, 0x6f, 0x70)
o = (*z).unauthenticatedProposal.OriginalProposer.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000) == 0 { // if not empty
// string "partupdrmv"
o = append(o, 0xaa, 0x70, 0x61, 0x72, 0x74, 0x75, 0x70, 0x64, 0x72, 0x6d, 0x76)
if (*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts == nil {
@@ -4409,47 +4422,52 @@ func (z *proposal) MarshalMsg(b []byte) (o []byte) {
o = (*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts[zb0003].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x40000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000) == 0 { // if not empty
// string "prev"
o = append(o, 0xa4, 0x70, 0x72, 0x65, 0x76)
o = (*z).unauthenticatedProposal.Block.BlockHeader.Branch.MarshalMsg(o)
}
- if (zb0004Mask & 0x80000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000) == 0 { // if not empty
// string "proto"
o = append(o, 0xa5, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000) == 0 { // if not empty
+ // string "prp"
+ o = append(o, 0xa3, 0x70, 0x72, 0x70)
+ o = (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x400000) == 0 { // if not empty
// string "rate"
o = append(o, 0xa4, 0x72, 0x61, 0x74, 0x65)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate)
}
- if (zb0004Mask & 0x400000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000) == 0 { // if not empty
// string "rnd"
o = append(o, 0xa3, 0x72, 0x6e, 0x64)
o = (*z).unauthenticatedProposal.Block.BlockHeader.Round.MarshalMsg(o)
}
- if (zb0004Mask & 0x800000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000) == 0 { // if not empty
// string "rwcalr"
o = append(o, 0xa6, 0x72, 0x77, 0x63, 0x61, 0x6c, 0x72)
o = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000000) == 0 { // if not empty
// string "rwd"
o = append(o, 0xa3, 0x72, 0x77, 0x64)
o = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000000) == 0 { // if not empty
// string "sdpf"
o = append(o, 0xa4, 0x73, 0x64, 0x70, 0x66)
o = (*z).unauthenticatedProposal.SeedProof.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000000) == 0 { // if not empty
// string "seed"
o = append(o, 0xa4, 0x73, 0x65, 0x65, 0x64)
o = (*z).unauthenticatedProposal.Block.BlockHeader.Seed.MarshalMsg(o)
}
- if (zb0004Mask & 0x8000000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000000) == 0 { // if not empty
// string "spt"
o = append(o, 0xa3, 0x73, 0x70, 0x74)
if (*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking == nil {
@@ -4469,42 +4487,42 @@ func (z *proposal) MarshalMsg(b []byte) (o []byte) {
o = zb0002.MarshalMsg(o)
}
}
- if (zb0004Mask & 0x10000000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000000) == 0 { // if not empty
// string "tc"
o = append(o, 0xa2, 0x74, 0x63)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter)
}
- if (zb0004Mask & 0x20000000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000000) == 0 { // if not empty
// string "ts"
o = append(o, 0xa2, 0x74, 0x73)
o = msgp.AppendInt64(o, (*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp)
}
- if (zb0004Mask & 0x40000000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000000) == 0 { // if not empty
// string "txn"
o = append(o, 0xa3, 0x74, 0x78, 0x6e)
o = (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x80000000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000000) == 0 { // if not empty
// string "txn256"
o = append(o, 0xa6, 0x74, 0x78, 0x6e, 0x32, 0x35, 0x36)
o = (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000000) == 0 { // if not empty
+ if (zb0004Mask & 0x400000000) == 0 { // if not empty
// string "txns"
o = append(o, 0xa4, 0x74, 0x78, 0x6e, 0x73)
o = (*z).unauthenticatedProposal.Block.Payset.MarshalMsg(o)
}
- if (zb0004Mask & 0x200000000) == 0 { // if not empty
+ if (zb0004Mask & 0x800000000) == 0 { // if not empty
// string "upgradedelay"
o = append(o, 0xac, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x64, 0x65, 0x6c, 0x61, 0x79)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MarshalMsg(o)
}
- if (zb0004Mask & 0x400000000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000000) == 0 { // if not empty
// string "upgradeprop"
o = append(o, 0xab, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x70, 0x72, 0x6f, 0x70)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MarshalMsg(o)
}
- if (zb0004Mask & 0x800000000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000000) == 0 { // if not empty
// string "upgradeyes"
o = append(o, 0xaa, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x79, 0x65, 0x73)
o = msgp.AppendBool(o, (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove)
@@ -4605,6 +4623,22 @@ func (z *proposal) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Proposer")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "FeesCollected")
+ return
+ }
+ }
if zb0004 > 0 {
zb0004--
bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
@@ -4907,6 +4941,18 @@ func (z *proposal) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "GenesisHash")
return
}
+ case "prp":
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Proposer")
+ return
+ }
+ case "fc":
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "FeesCollected")
+ return
+ }
case "fees":
bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
if err != nil {
@@ -5106,7 +5152,7 @@ func (_ *proposal) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *proposal) Msgsize() (s int) {
- s = 3 + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.Round.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Branch.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Seed.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID) + 3 + (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
+ s = 3 + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.Round.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Branch.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Seed.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID) + 3 + (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.Msgsize() + 3 + (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
if (*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking != nil {
for zb0001, zb0002 := range (*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking {
_ = zb0001
@@ -5124,12 +5170,12 @@ func (z *proposal) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *proposal) MsgIsZero() bool {
- return ((*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Seed.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "") && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking) == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).unauthenticatedProposal.Block.Payset.MsgIsZero()) && ((*z).unauthenticatedProposal.SeedProof.MsgIsZero()) && ((*z).unauthenticatedProposal.OriginalPeriod == 0) && ((*z).unauthenticatedProposal.OriginalProposer.MsgIsZero())
+ return ((*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Seed.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "") && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Proposer.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking) == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).unauthenticatedProposal.Block.Payset.MsgIsZero()) && ((*z).unauthenticatedProposal.SeedProof.MsgIsZero()) && ((*z).unauthenticatedProposal.OriginalPeriod == 0) && ((*z).unauthenticatedProposal.OriginalProposer.MsgIsZero())
}
// MaxSize returns a maximum valid message size for this message type
func ProposalMaxSize() (s int) {
- s = 3 + 4 + basics.RoundMaxSize() + 5 + bookkeeping.BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
+ s = 3 + 4 + basics.RoundMaxSize() + 5 + bookkeeping.BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 4 + basics.AddressMaxSize() + 3 + basics.MicroAlgosMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
s += msgp.MapHeaderSize
// Adding size of map keys for z.unauthenticatedProposal.Block.BlockHeader.StateProofTracking
s += protocol.NumStateProofTypes * (protocol.StateProofTypeMaxSize())
@@ -8432,127 +8478,135 @@ func ThresholdEventMaxSize() (s int) {
func (z *transmittedPayload) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0004Len := uint32(30)
- var zb0004Mask uint64 /* 38 bits */
+ zb0004Len := uint32(32)
+ var zb0004Mask uint64 /* 40 bits */
if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel == 0 {
zb0004Len--
zb0004Mask |= 0x80
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x200
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "" {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0 {
zb0004Len--
zb0004Mask |= 0x400
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "" {
zb0004Len--
zb0004Mask |= 0x800
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x1000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x2000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x4000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x8000
}
- if (*z).unauthenticatedProposal.OriginalPeriod == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
zb0004Len--
zb0004Mask |= 0x10000
}
- if (*z).unauthenticatedProposal.OriginalProposer.MsgIsZero() {
+ if (*z).unauthenticatedProposal.OriginalPeriod == 0 {
zb0004Len--
zb0004Mask |= 0x20000
}
- if len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
+ if (*z).unauthenticatedProposal.OriginalProposer.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x40000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero() {
+ if len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
zb0004Len--
zb0004Mask |= 0x80000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100000
}
- if (*z).PriorVote.MsgIsZero() {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x200000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0 {
+ if (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x400000
}
- if (*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero() {
+ if (*z).PriorVote.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x800000
+ }
+ if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0 {
zb0004Len--
zb0004Mask |= 0x1000000
}
+ if (*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x4000000
+ }
if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x2000000
+ zb0004Mask |= 0x8000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x4000000
+ zb0004Mask |= 0x10000000
}
if (*z).unauthenticatedProposal.SeedProof.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x8000000
+ zb0004Mask |= 0x20000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.Seed.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x10000000
+ zb0004Mask |= 0x40000000
}
if len((*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking) == 0 {
zb0004Len--
- zb0004Mask |= 0x20000000
+ zb0004Mask |= 0x80000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter == 0 {
zb0004Len--
- zb0004Mask |= 0x40000000
+ zb0004Mask |= 0x100000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp == 0 {
zb0004Len--
- zb0004Mask |= 0x80000000
+ zb0004Mask |= 0x200000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x100000000
+ zb0004Mask |= 0x400000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x200000000
+ zb0004Mask |= 0x800000000
}
if (*z).unauthenticatedProposal.Block.Payset.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x400000000
+ zb0004Mask |= 0x1000000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x800000000
+ zb0004Mask |= 0x2000000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x1000000000
+ zb0004Mask |= 0x4000000000
}
if (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove == false {
zb0004Len--
- zb0004Mask |= 0x2000000000
+ zb0004Mask |= 0x8000000000
}
// variable map header, size zb0004Len
o = msgp.AppendMapHeader(o, zb0004Len)
@@ -8563,56 +8617,61 @@ func (z *transmittedPayload) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel)
}
if (zb0004Mask & 0x100) == 0 { // if not empty
+ // string "fc"
+ o = append(o, 0xa2, 0x66, 0x63)
+ o = (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x200) == 0 { // if not empty
// string "fees"
o = append(o, 0xa4, 0x66, 0x65, 0x65, 0x73)
o = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MarshalMsg(o)
}
- if (zb0004Mask & 0x200) == 0 { // if not empty
+ if (zb0004Mask & 0x400) == 0 { // if not empty
// string "frac"
o = append(o, 0xa4, 0x66, 0x72, 0x61, 0x63)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue)
}
- if (zb0004Mask & 0x400) == 0 { // if not empty
+ if (zb0004Mask & 0x800) == 0 { // if not empty
// string "gen"
o = append(o, 0xa3, 0x67, 0x65, 0x6e)
o = msgp.AppendString(o, (*z).unauthenticatedProposal.Block.BlockHeader.GenesisID)
}
- if (zb0004Mask & 0x800) == 0 { // if not empty
+ if (zb0004Mask & 0x1000) == 0 { // if not empty
// string "gh"
o = append(o, 0xa2, 0x67, 0x68)
o = (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000) == 0 { // if not empty
// string "nextbefore"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000) == 0 { // if not empty
// string "nextproto"
o = append(o, 0xa9, 0x6e, 0x65, 0x78, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000) == 0 { // if not empty
// string "nextswitch"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MarshalMsg(o)
}
- if (zb0004Mask & 0x8000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000) == 0 { // if not empty
// string "nextyes"
o = append(o, 0xa7, 0x6e, 0x65, 0x78, 0x74, 0x79, 0x65, 0x73)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals)
}
- if (zb0004Mask & 0x10000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000) == 0 { // if not empty
// string "oper"
o = append(o, 0xa4, 0x6f, 0x70, 0x65, 0x72)
o = msgp.AppendUint64(o, uint64((*z).unauthenticatedProposal.OriginalPeriod))
}
- if (zb0004Mask & 0x20000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000) == 0 { // if not empty
// string "oprop"
o = append(o, 0xa5, 0x6f, 0x70, 0x72, 0x6f, 0x70)
o = (*z).unauthenticatedProposal.OriginalProposer.MarshalMsg(o)
}
- if (zb0004Mask & 0x40000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000) == 0 { // if not empty
// string "partupdrmv"
o = append(o, 0xaa, 0x70, 0x61, 0x72, 0x74, 0x75, 0x70, 0x64, 0x72, 0x6d, 0x76)
if (*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts == nil {
@@ -8624,52 +8683,57 @@ func (z *transmittedPayload) MarshalMsg(b []byte) (o []byte) {
o = (*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts[zb0003].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x80000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000) == 0 { // if not empty
// string "prev"
o = append(o, 0xa4, 0x70, 0x72, 0x65, 0x76)
o = (*z).unauthenticatedProposal.Block.BlockHeader.Branch.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000) == 0 { // if not empty
// string "proto"
o = append(o, 0xa5, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x200000) == 0 { // if not empty
+ if (zb0004Mask & 0x400000) == 0 { // if not empty
+ // string "prp"
+ o = append(o, 0xa3, 0x70, 0x72, 0x70)
+ o = (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x800000) == 0 { // if not empty
// string "pv"
o = append(o, 0xa2, 0x70, 0x76)
o = (*z).PriorVote.MarshalMsg(o)
}
- if (zb0004Mask & 0x400000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000) == 0 { // if not empty
// string "rate"
o = append(o, 0xa4, 0x72, 0x61, 0x74, 0x65)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate)
}
- if (zb0004Mask & 0x1000000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000000) == 0 { // if not empty
// string "rnd"
o = append(o, 0xa3, 0x72, 0x6e, 0x64)
o = (*z).unauthenticatedProposal.Block.BlockHeader.Round.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000000) == 0 { // if not empty
// string "rwcalr"
o = append(o, 0xa6, 0x72, 0x77, 0x63, 0x61, 0x6c, 0x72)
o = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000000) == 0 { // if not empty
// string "rwd"
o = append(o, 0xa3, 0x72, 0x77, 0x64)
o = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MarshalMsg(o)
}
- if (zb0004Mask & 0x8000000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000000) == 0 { // if not empty
// string "sdpf"
o = append(o, 0xa4, 0x73, 0x64, 0x70, 0x66)
o = (*z).unauthenticatedProposal.SeedProof.MarshalMsg(o)
}
- if (zb0004Mask & 0x10000000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000000) == 0 { // if not empty
// string "seed"
o = append(o, 0xa4, 0x73, 0x65, 0x65, 0x64)
o = (*z).unauthenticatedProposal.Block.BlockHeader.Seed.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000000) == 0 { // if not empty
// string "spt"
o = append(o, 0xa3, 0x73, 0x70, 0x74)
if (*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking == nil {
@@ -8689,42 +8753,42 @@ func (z *transmittedPayload) MarshalMsg(b []byte) (o []byte) {
o = zb0002.MarshalMsg(o)
}
}
- if (zb0004Mask & 0x40000000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000000) == 0 { // if not empty
// string "tc"
o = append(o, 0xa2, 0x74, 0x63)
o = msgp.AppendUint64(o, (*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter)
}
- if (zb0004Mask & 0x80000000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000000) == 0 { // if not empty
// string "ts"
o = append(o, 0xa2, 0x74, 0x73)
o = msgp.AppendInt64(o, (*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp)
}
- if (zb0004Mask & 0x100000000) == 0 { // if not empty
+ if (zb0004Mask & 0x400000000) == 0 { // if not empty
// string "txn"
o = append(o, 0xa3, 0x74, 0x78, 0x6e)
o = (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x200000000) == 0 { // if not empty
+ if (zb0004Mask & 0x800000000) == 0 { // if not empty
// string "txn256"
o = append(o, 0xa6, 0x74, 0x78, 0x6e, 0x32, 0x35, 0x36)
o = (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x400000000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000000) == 0 { // if not empty
// string "txns"
o = append(o, 0xa4, 0x74, 0x78, 0x6e, 0x73)
o = (*z).unauthenticatedProposal.Block.Payset.MarshalMsg(o)
}
- if (zb0004Mask & 0x800000000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000000) == 0 { // if not empty
// string "upgradedelay"
o = append(o, 0xac, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x64, 0x65, 0x6c, 0x61, 0x79)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000000000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000000000) == 0 { // if not empty
// string "upgradeprop"
o = append(o, 0xab, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x70, 0x72, 0x6f, 0x70)
o = (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000000000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000000000) == 0 { // if not empty
// string "upgradeyes"
o = append(o, 0xaa, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x79, 0x65, 0x73)
o = msgp.AppendBool(o, (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove)
@@ -8825,6 +8889,22 @@ func (z *transmittedPayload) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Proposer")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "FeesCollected")
+ return
+ }
+ }
if zb0004 > 0 {
zb0004--
bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
@@ -9135,6 +9215,18 @@ func (z *transmittedPayload) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "GenesisHash")
return
}
+ case "prp":
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Proposer")
+ return
+ }
+ case "fc":
+ bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "FeesCollected")
+ return
+ }
case "fees":
bts, err = (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
if err != nil {
@@ -9340,7 +9432,7 @@ func (_ *transmittedPayload) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *transmittedPayload) Msgsize() (s int) {
- s = 3 + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.Round.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Branch.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Seed.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID) + 3 + (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
+ s = 3 + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.Round.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Branch.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.Seed.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID) + 3 + (*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.Proposer.Msgsize() + 3 + (*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.Msgsize() + 5 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
if (*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking != nil {
for zb0001, zb0002 := range (*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking {
_ = zb0001
@@ -9358,12 +9450,12 @@ func (z *transmittedPayload) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *transmittedPayload) MsgIsZero() bool {
- return ((*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Seed.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "") && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking) == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).unauthenticatedProposal.Block.Payset.MsgIsZero()) && ((*z).unauthenticatedProposal.SeedProof.MsgIsZero()) && ((*z).unauthenticatedProposal.OriginalPeriod == 0) && ((*z).unauthenticatedProposal.OriginalProposer.MsgIsZero()) && ((*z).PriorVote.MsgIsZero())
+ return ((*z).unauthenticatedProposal.Block.BlockHeader.Round.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Branch.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Seed.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.TimeStamp == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisID == "") && ((*z).unauthenticatedProposal.Block.BlockHeader.GenesisHash.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.Proposer.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.FeesCollected.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRate == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).unauthenticatedProposal.Block.BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).unauthenticatedProposal.Block.BlockHeader.TxnCounter == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.StateProofTracking) == 0) && (len((*z).unauthenticatedProposal.Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).unauthenticatedProposal.Block.Payset.MsgIsZero()) && ((*z).unauthenticatedProposal.SeedProof.MsgIsZero()) && ((*z).unauthenticatedProposal.OriginalPeriod == 0) && ((*z).unauthenticatedProposal.OriginalProposer.MsgIsZero()) && ((*z).PriorVote.MsgIsZero())
}
// MaxSize returns a maximum valid message size for this message type
func TransmittedPayloadMaxSize() (s int) {
- s = 3 + 4 + basics.RoundMaxSize() + 5 + bookkeeping.BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
+ s = 3 + 4 + basics.RoundMaxSize() + 5 + bookkeeping.BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 4 + basics.AddressMaxSize() + 3 + basics.MicroAlgosMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
s += msgp.MapHeaderSize
// Adding size of map keys for z.unauthenticatedProposal.Block.BlockHeader.StateProofTracking
s += protocol.NumStateProofTypes * (protocol.StateProofTypeMaxSize())
@@ -10068,123 +10160,131 @@ func UnauthenticatedEquivocationVoteMaxSize() (s int) {
func (z *unauthenticatedProposal) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0004Len := uint32(29)
- var zb0004Mask uint64 /* 36 bits */
+ zb0004Len := uint32(31)
+ var zb0004Mask uint64 /* 38 bits */
if (*z).Block.BlockHeader.RewardsState.RewardsLevel == 0 {
zb0004Len--
zb0004Mask |= 0x40
}
- if (*z).Block.BlockHeader.RewardsState.FeeSink.MsgIsZero() {
+ if (*z).Block.BlockHeader.FeesCollected.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x80
}
- if (*z).Block.BlockHeader.RewardsState.RewardsResidue == 0 {
+ if (*z).Block.BlockHeader.RewardsState.FeeSink.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100
}
- if (*z).Block.BlockHeader.GenesisID == "" {
+ if (*z).Block.BlockHeader.RewardsState.RewardsResidue == 0 {
zb0004Len--
zb0004Mask |= 0x200
}
- if (*z).Block.BlockHeader.GenesisHash.MsgIsZero() {
+ if (*z).Block.BlockHeader.GenesisID == "" {
zb0004Len--
zb0004Mask |= 0x400
}
- if (*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
+ if (*z).Block.BlockHeader.GenesisHash.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x800
}
- if (*z).Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
+ if (*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x1000
}
- if (*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
+ if (*z).Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x2000
}
- if (*z).Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
+ if (*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x4000
}
- if (*z).OriginalPeriod == 0 {
+ if (*z).Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
zb0004Len--
zb0004Mask |= 0x8000
}
- if (*z).OriginalProposer.MsgIsZero() {
+ if (*z).OriginalPeriod == 0 {
zb0004Len--
zb0004Mask |= 0x10000
}
- if len((*z).Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
+ if (*z).OriginalProposer.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x20000
}
- if (*z).Block.BlockHeader.Branch.MsgIsZero() {
+ if len((*z).Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
zb0004Len--
zb0004Mask |= 0x40000
}
- if (*z).Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
+ if (*z).Block.BlockHeader.Branch.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x80000
}
- if (*z).Block.BlockHeader.RewardsState.RewardsRate == 0 {
+ if (*z).Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100000
}
- if (*z).Block.BlockHeader.Round.MsgIsZero() {
+ if (*z).Block.BlockHeader.Proposer.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x200000
+ }
+ if (*z).Block.BlockHeader.RewardsState.RewardsRate == 0 {
zb0004Len--
zb0004Mask |= 0x400000
}
+ if (*z).Block.BlockHeader.Round.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x1000000
+ }
if (*z).Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x800000
+ zb0004Mask |= 0x2000000
}
if (*z).Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x1000000
+ zb0004Mask |= 0x4000000
}
if (*z).SeedProof.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x2000000
+ zb0004Mask |= 0x8000000
}
if (*z).Block.BlockHeader.Seed.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x4000000
+ zb0004Mask |= 0x10000000
}
if len((*z).Block.BlockHeader.StateProofTracking) == 0 {
zb0004Len--
- zb0004Mask |= 0x8000000
+ zb0004Mask |= 0x20000000
}
if (*z).Block.BlockHeader.TxnCounter == 0 {
zb0004Len--
- zb0004Mask |= 0x10000000
+ zb0004Mask |= 0x40000000
}
if (*z).Block.BlockHeader.TimeStamp == 0 {
zb0004Len--
- zb0004Mask |= 0x20000000
+ zb0004Mask |= 0x80000000
}
if (*z).Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x40000000
+ zb0004Mask |= 0x100000000
}
if (*z).Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x80000000
+ zb0004Mask |= 0x200000000
}
if (*z).Block.Payset.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x100000000
+ zb0004Mask |= 0x400000000
}
if (*z).Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x200000000
+ zb0004Mask |= 0x800000000
}
if (*z).Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero() {
zb0004Len--
- zb0004Mask |= 0x400000000
+ zb0004Mask |= 0x1000000000
}
if (*z).Block.BlockHeader.UpgradeVote.UpgradeApprove == false {
zb0004Len--
- zb0004Mask |= 0x800000000
+ zb0004Mask |= 0x2000000000
}
// variable map header, size zb0004Len
o = msgp.AppendMapHeader(o, zb0004Len)
@@ -10195,56 +10295,61 @@ func (z *unauthenticatedProposal) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).Block.BlockHeader.RewardsState.RewardsLevel)
}
if (zb0004Mask & 0x80) == 0 { // if not empty
+ // string "fc"
+ o = append(o, 0xa2, 0x66, 0x63)
+ o = (*z).Block.BlockHeader.FeesCollected.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x100) == 0 { // if not empty
// string "fees"
o = append(o, 0xa4, 0x66, 0x65, 0x65, 0x73)
o = (*z).Block.BlockHeader.RewardsState.FeeSink.MarshalMsg(o)
}
- if (zb0004Mask & 0x100) == 0 { // if not empty
+ if (zb0004Mask & 0x200) == 0 { // if not empty
// string "frac"
o = append(o, 0xa4, 0x66, 0x72, 0x61, 0x63)
o = msgp.AppendUint64(o, (*z).Block.BlockHeader.RewardsState.RewardsResidue)
}
- if (zb0004Mask & 0x200) == 0 { // if not empty
+ if (zb0004Mask & 0x400) == 0 { // if not empty
// string "gen"
o = append(o, 0xa3, 0x67, 0x65, 0x6e)
o = msgp.AppendString(o, (*z).Block.BlockHeader.GenesisID)
}
- if (zb0004Mask & 0x400) == 0 { // if not empty
+ if (zb0004Mask & 0x800) == 0 { // if not empty
// string "gh"
o = append(o, 0xa2, 0x67, 0x68)
o = (*z).Block.BlockHeader.GenesisHash.MarshalMsg(o)
}
- if (zb0004Mask & 0x800) == 0 { // if not empty
+ if (zb0004Mask & 0x1000) == 0 { // if not empty
// string "nextbefore"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65)
o = (*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000) == 0 { // if not empty
// string "nextproto"
o = append(o, 0xa9, 0x6e, 0x65, 0x78, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).Block.BlockHeader.UpgradeState.NextProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000) == 0 { // if not empty
// string "nextswitch"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68)
o = (*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000) == 0 { // if not empty
// string "nextyes"
o = append(o, 0xa7, 0x6e, 0x65, 0x78, 0x74, 0x79, 0x65, 0x73)
o = msgp.AppendUint64(o, (*z).Block.BlockHeader.UpgradeState.NextProtocolApprovals)
}
- if (zb0004Mask & 0x8000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000) == 0 { // if not empty
// string "oper"
o = append(o, 0xa4, 0x6f, 0x70, 0x65, 0x72)
o = msgp.AppendUint64(o, uint64((*z).OriginalPeriod))
}
- if (zb0004Mask & 0x10000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000) == 0 { // if not empty
// string "oprop"
o = append(o, 0xa5, 0x6f, 0x70, 0x72, 0x6f, 0x70)
o = (*z).OriginalProposer.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000) == 0 { // if not empty
// string "partupdrmv"
o = append(o, 0xaa, 0x70, 0x61, 0x72, 0x74, 0x75, 0x70, 0x64, 0x72, 0x6d, 0x76)
if (*z).Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts == nil {
@@ -10256,47 +10361,52 @@ func (z *unauthenticatedProposal) MarshalMsg(b []byte) (o []byte) {
o = (*z).Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts[zb0003].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x40000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000) == 0 { // if not empty
// string "prev"
o = append(o, 0xa4, 0x70, 0x72, 0x65, 0x76)
o = (*z).Block.BlockHeader.Branch.MarshalMsg(o)
}
- if (zb0004Mask & 0x80000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000) == 0 { // if not empty
// string "proto"
o = append(o, 0xa5, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).Block.BlockHeader.UpgradeState.CurrentProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000) == 0 { // if not empty
+ // string "prp"
+ o = append(o, 0xa3, 0x70, 0x72, 0x70)
+ o = (*z).Block.BlockHeader.Proposer.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x400000) == 0 { // if not empty
// string "rate"
o = append(o, 0xa4, 0x72, 0x61, 0x74, 0x65)
o = msgp.AppendUint64(o, (*z).Block.BlockHeader.RewardsState.RewardsRate)
}
- if (zb0004Mask & 0x400000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000) == 0 { // if not empty
// string "rnd"
o = append(o, 0xa3, 0x72, 0x6e, 0x64)
o = (*z).Block.BlockHeader.Round.MarshalMsg(o)
}
- if (zb0004Mask & 0x800000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000) == 0 { // if not empty
// string "rwcalr"
o = append(o, 0xa6, 0x72, 0x77, 0x63, 0x61, 0x6c, 0x72)
o = (*z).Block.BlockHeader.RewardsState.RewardsRecalculationRound.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000000) == 0 { // if not empty
// string "rwd"
o = append(o, 0xa3, 0x72, 0x77, 0x64)
o = (*z).Block.BlockHeader.RewardsState.RewardsPool.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000000) == 0 { // if not empty
// string "sdpf"
o = append(o, 0xa4, 0x73, 0x64, 0x70, 0x66)
o = (*z).SeedProof.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000000) == 0 { // if not empty
// string "seed"
o = append(o, 0xa4, 0x73, 0x65, 0x65, 0x64)
o = (*z).Block.BlockHeader.Seed.MarshalMsg(o)
}
- if (zb0004Mask & 0x8000000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000000) == 0 { // if not empty
// string "spt"
o = append(o, 0xa3, 0x73, 0x70, 0x74)
if (*z).Block.BlockHeader.StateProofTracking == nil {
@@ -10316,42 +10426,42 @@ func (z *unauthenticatedProposal) MarshalMsg(b []byte) (o []byte) {
o = zb0002.MarshalMsg(o)
}
}
- if (zb0004Mask & 0x10000000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000000) == 0 { // if not empty
// string "tc"
o = append(o, 0xa2, 0x74, 0x63)
o = msgp.AppendUint64(o, (*z).Block.BlockHeader.TxnCounter)
}
- if (zb0004Mask & 0x20000000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000000) == 0 { // if not empty
// string "ts"
o = append(o, 0xa2, 0x74, 0x73)
o = msgp.AppendInt64(o, (*z).Block.BlockHeader.TimeStamp)
}
- if (zb0004Mask & 0x40000000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000000) == 0 { // if not empty
// string "txn"
o = append(o, 0xa3, 0x74, 0x78, 0x6e)
o = (*z).Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x80000000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000000) == 0 { // if not empty
// string "txn256"
o = append(o, 0xa6, 0x74, 0x78, 0x6e, 0x32, 0x35, 0x36)
o = (*z).Block.BlockHeader.TxnCommitments.Sha256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000000) == 0 { // if not empty
+ if (zb0004Mask & 0x400000000) == 0 { // if not empty
// string "txns"
o = append(o, 0xa4, 0x74, 0x78, 0x6e, 0x73)
o = (*z).Block.Payset.MarshalMsg(o)
}
- if (zb0004Mask & 0x200000000) == 0 { // if not empty
+ if (zb0004Mask & 0x800000000) == 0 { // if not empty
// string "upgradedelay"
o = append(o, 0xac, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x64, 0x65, 0x6c, 0x61, 0x79)
o = (*z).Block.BlockHeader.UpgradeVote.UpgradeDelay.MarshalMsg(o)
}
- if (zb0004Mask & 0x400000000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000000) == 0 { // if not empty
// string "upgradeprop"
o = append(o, 0xab, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x70, 0x72, 0x6f, 0x70)
o = (*z).Block.BlockHeader.UpgradeVote.UpgradePropose.MarshalMsg(o)
}
- if (zb0004Mask & 0x800000000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000000) == 0 { // if not empty
// string "upgradeyes"
o = append(o, 0xaa, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x79, 0x65, 0x73)
o = msgp.AppendBool(o, (*z).Block.BlockHeader.UpgradeVote.UpgradeApprove)
@@ -10452,6 +10562,22 @@ func (z *unauthenticatedProposal) UnmarshalMsg(bts []byte) (o []byte, err error)
return
}
}
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).Block.BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Proposer")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).Block.BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "FeesCollected")
+ return
+ }
+ }
if zb0004 > 0 {
zb0004--
bts, err = (*z).Block.BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
@@ -10754,6 +10880,18 @@ func (z *unauthenticatedProposal) UnmarshalMsg(bts []byte) (o []byte, err error)
err = msgp.WrapError(err, "GenesisHash")
return
}
+ case "prp":
+ bts, err = (*z).Block.BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Proposer")
+ return
+ }
+ case "fc":
+ bts, err = (*z).Block.BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "FeesCollected")
+ return
+ }
case "fees":
bts, err = (*z).Block.BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
if err != nil {
@@ -10953,7 +11091,7 @@ func (_ *unauthenticatedProposal) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *unauthenticatedProposal) Msgsize() (s int) {
- s = 3 + 4 + (*z).Block.BlockHeader.Round.Msgsize() + 5 + (*z).Block.BlockHeader.Branch.Msgsize() + 5 + (*z).Block.BlockHeader.Seed.Msgsize() + 4 + (*z).Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).Block.BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).Block.BlockHeader.GenesisID) + 3 + (*z).Block.BlockHeader.GenesisHash.Msgsize() + 5 + (*z).Block.BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).Block.BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).Block.BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).Block.BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).Block.BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).Block.BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).Block.BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
+ s = 3 + 4 + (*z).Block.BlockHeader.Round.Msgsize() + 5 + (*z).Block.BlockHeader.Branch.Msgsize() + 5 + (*z).Block.BlockHeader.Seed.Msgsize() + 4 + (*z).Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).Block.BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).Block.BlockHeader.GenesisID) + 3 + (*z).Block.BlockHeader.GenesisHash.Msgsize() + 4 + (*z).Block.BlockHeader.Proposer.Msgsize() + 3 + (*z).Block.BlockHeader.FeesCollected.Msgsize() + 5 + (*z).Block.BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).Block.BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).Block.BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).Block.BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).Block.BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).Block.BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).Block.BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
if (*z).Block.BlockHeader.StateProofTracking != nil {
for zb0001, zb0002 := range (*z).Block.BlockHeader.StateProofTracking {
_ = zb0001
@@ -10971,12 +11109,12 @@ func (z *unauthenticatedProposal) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *unauthenticatedProposal) MsgIsZero() bool {
- return ((*z).Block.BlockHeader.Round.MsgIsZero()) && ((*z).Block.BlockHeader.Branch.MsgIsZero()) && ((*z).Block.BlockHeader.Seed.MsgIsZero()) && ((*z).Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).Block.BlockHeader.TimeStamp == 0) && ((*z).Block.BlockHeader.GenesisID == "") && ((*z).Block.BlockHeader.GenesisHash.MsgIsZero()) && ((*z).Block.BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).Block.BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).Block.BlockHeader.RewardsState.RewardsRate == 0) && ((*z).Block.BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).Block.BlockHeader.TxnCounter == 0) && (len((*z).Block.BlockHeader.StateProofTracking) == 0) && (len((*z).Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).Block.Payset.MsgIsZero()) && ((*z).SeedProof.MsgIsZero()) && ((*z).OriginalPeriod == 0) && ((*z).OriginalProposer.MsgIsZero())
+ return ((*z).Block.BlockHeader.Round.MsgIsZero()) && ((*z).Block.BlockHeader.Branch.MsgIsZero()) && ((*z).Block.BlockHeader.Seed.MsgIsZero()) && ((*z).Block.BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).Block.BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).Block.BlockHeader.TimeStamp == 0) && ((*z).Block.BlockHeader.GenesisID == "") && ((*z).Block.BlockHeader.GenesisHash.MsgIsZero()) && ((*z).Block.BlockHeader.Proposer.MsgIsZero()) && ((*z).Block.BlockHeader.FeesCollected.MsgIsZero()) && ((*z).Block.BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).Block.BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).Block.BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).Block.BlockHeader.RewardsState.RewardsRate == 0) && ((*z).Block.BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).Block.BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).Block.BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).Block.BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).Block.BlockHeader.TxnCounter == 0) && (len((*z).Block.BlockHeader.StateProofTracking) == 0) && (len((*z).Block.BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).Block.Payset.MsgIsZero()) && ((*z).SeedProof.MsgIsZero()) && ((*z).OriginalPeriod == 0) && ((*z).OriginalProposer.MsgIsZero())
}
// MaxSize returns a maximum valid message size for this message type
func UnauthenticatedProposalMaxSize() (s int) {
- s = 3 + 4 + basics.RoundMaxSize() + 5 + bookkeeping.BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
+ s = 3 + 4 + basics.RoundMaxSize() + 5 + bookkeeping.BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 4 + basics.AddressMaxSize() + 3 + basics.MicroAlgosMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
s += msgp.MapHeaderSize
// Adding size of map keys for z.Block.BlockHeader.StateProofTracking
s += protocol.NumStateProofTypes * (protocol.StateProofTypeMaxSize())
diff --git a/agreement/proposal.go b/agreement/proposal.go
index bf021f2cfe..0d8442a065 100644
--- a/agreement/proposal.go
+++ b/agreement/proposal.go
@@ -251,7 +251,7 @@ func proposalForBlock(address basics.Address, vrf *crypto.VRFSecrets, ve Validat
return proposal{}, proposalValue{}, fmt.Errorf("proposalForBlock: could not derive new seed: %v", err)
}
- ve = ve.WithSeed(newSeed)
+ ve = ve.WithSeed(newSeed, address)
proposal := makeProposal(ve, seedProof, period, address)
value := proposalValue{
OriginalPeriod: period,
diff --git a/config/consensus.go b/config/consensus.go
index 190e5ce16a..cd758c1628 100644
--- a/config/consensus.go
+++ b/config/consensus.go
@@ -522,6 +522,13 @@ type ConsensusParams struct {
// arrival times or is set to a static value. Even if this flag disables the
// dynamic filter, it will be calculated and logged (but not used).
DynamicFilterTimeout bool
+
+ // EnableMining means that the proposer should be included in the BlockHeader.
+ EnableMining bool
+
+ // MiningPercent specifies the percent of fees paid in a block that go to
+ // the proposer instead of the FeeSink.
+ MiningPercent uint64
}
// PaysetCommitType enumerates possible ways for the block header to commit to
@@ -1373,6 +1380,9 @@ func initConsensusProtocols() {
// by reducing round time. Hence, it is commented out for now.
// vFuture.DynamicFilterTimeout = true
+ vFuture.EnableMining = true
+ vFuture.MiningPercent = 75
+
Consensus[protocol.ConsensusFuture] = vFuture
// vAlphaX versions are an separate series of consensus parameters and versions for alphanet
diff --git a/daemon/algod/api/server/v2/handlers.go b/daemon/algod/api/server/v2/handlers.go
index 1a013b8477..2ffb11ef56 100644
--- a/daemon/algod/api/server/v2/handlers.go
+++ b/daemon/algod/api/server/v2/handlers.go
@@ -1349,10 +1349,7 @@ func (v2 *Handlers) getPendingTransactions(ctx echo.Context, max *uint64, format
}
// MatchAddress uses this to check FeeSink, we don't care about that here.
- spec := transactions.SpecialAddresses{
- FeeSink: basics.Address{},
- RewardsPool: basics.Address{},
- }
+ spec := transactions.SpecialAddresses{}
txnLimit := uint64(math.MaxUint64)
if max != nil && *max != 0 {
diff --git a/daemon/algod/api/server/v2/test/handlers_resources_test.go b/daemon/algod/api/server/v2/test/handlers_resources_test.go
index 1de86ddc19..fc764c2fa7 100644
--- a/daemon/algod/api/server/v2/test/handlers_resources_test.go
+++ b/daemon/algod/api/server/v2/test/handlers_resources_test.go
@@ -19,11 +19,12 @@ package test
import (
"encoding/json"
"fmt"
- "github.com/algorand/go-algorand/data/transactions/logic"
"net/http"
"net/http/httptest"
"testing"
+ "github.com/algorand/go-algorand/data/transactions/logic"
+
"github.com/labstack/echo/v4"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
diff --git a/data/basics/fraction.go b/data/basics/fraction.go
new file mode 100644
index 0000000000..271da85265
--- /dev/null
+++ b/data/basics/fraction.go
@@ -0,0 +1,69 @@
+// Copyright (C) 2019-2023 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see .
+
+package basics
+
+import (
+ "fmt"
+)
+
+// Fraction represents the mathematical notion of rational number, but is much
+// simpler than `big.Rat`. It only supports numerators and denominators of
+// uint64.
+type Fraction struct {
+ Numerator uint64
+ Denominator uint64
+}
+
+// NewFraction creates the obvious Fraction, and checks that is not improper,
+// nor dives by zero.
+func NewFraction(numerator uint64, denominator uint64) Fraction {
+ if denominator == 0 {
+ panic("/0")
+ }
+ if numerator > denominator {
+ panic("improper fraction")
+ }
+ return Fraction{numerator, denominator}
+}
+
+// NewPercent creates a fraction reflecting the given percentage.
+func NewPercent(pct uint64) Fraction {
+ return NewFraction(pct, 100)
+}
+
+// String returns a string representation of Fraction
+func (frac Fraction) String() string {
+ return fmt.Sprintf("%d/%d", frac.Numerator, frac.Denominator)
+}
+
+// Divvy separates a quantity into two parts according to the fraction. The first
+// value is floor(q * frac), the second is q - first.
+func (frac Fraction) Divvy(q uint64) (uint64, uint64) {
+ // can't overflow on proper fractions
+ first, o := Muldiv(q, frac.Numerator, frac.Denominator)
+ if o {
+ panic("overflow")
+ }
+ second := q - first
+ return first, second
+}
+
+// DivvyAlgos is Divvy, but operates on MicroAlgos
+func (frac Fraction) DivvyAlgos(q MicroAlgos) (MicroAlgos, MicroAlgos) {
+ first, second := frac.Divvy(q.Raw)
+ return MicroAlgos{first}, MicroAlgos{second}
+}
diff --git a/data/basics/fraction_test.go b/data/basics/fraction_test.go
new file mode 100644
index 0000000000..9fad8dfa19
--- /dev/null
+++ b/data/basics/fraction_test.go
@@ -0,0 +1,76 @@
+// Copyright (C) 2019-2023 Algorand, Inc.
+// This file is part of go-algorand
+//
+// go-algorand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// go-algorand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with go-algorand. If not, see .
+
+package basics
+
+import (
+ "math"
+ "testing"
+
+ "github.com/algorand/go-algorand/test/partitiontest"
+ "github.com/stretchr/testify/require"
+)
+
+func TestFraction(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ t.Parallel()
+
+ third := Fraction{1, 3}
+ a, b := third.Divvy(6)
+ require.EqualValues(t, a, 2)
+ require.EqualValues(t, b, 4)
+
+ a, b = third.Divvy(10)
+ require.EqualValues(t, a, 3)
+ require.EqualValues(t, b, 7)
+}
+
+func TestFractionAvoidsOverflow(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ t.Parallel()
+
+ biggestEven := math.MaxUint64 - uint64(1)
+
+ half := Fraction{biggestEven / 2, biggestEven} // should operate as 1/2 even on large numbers
+ a, b := half.Divvy(6)
+ require.EqualValues(t, a, 3)
+ require.EqualValues(t, b, 3)
+
+ a, b = half.Divvy(biggestEven)
+ require.EqualValues(t, a, biggestEven/2)
+ require.EqualValues(t, b, biggestEven/2)
+
+ // ensure that overflow is avoided even if reduction isn't possible
+ uhalf := Fraction{biggestEven / 2, math.MaxUint64} // should be just under half
+ a, b = uhalf.Divvy(6)
+ require.EqualValues(t, a, 2)
+ require.EqualValues(t, b, 4)
+
+ a, b = uhalf.Divvy(biggestEven)
+ require.EqualValues(t, a, biggestEven/2-1)
+ require.EqualValues(t, b, biggestEven/2+1)
+
+ // and just to be super careful, ensure that there's also no reduction
+ // between q and the denominator by using a q that is relatively prime to
+ // math.MaxUint64
+
+ // prove 23 is relatively prime to math.MaxUint64
+ require.Positive(t, math.MaxUint64%23)
+
+ a, b = uhalf.Divvy(23)
+ require.EqualValues(t, a, 11)
+ require.EqualValues(t, b, 12)
+}
diff --git a/data/bookkeeping/block.go b/data/bookkeeping/block.go
index 39842aa758..c84380d86f 100644
--- a/data/bookkeeping/block.go
+++ b/data/bookkeeping/block.go
@@ -58,6 +58,16 @@ type (
// Genesis hash to which this block belongs.
GenesisHash crypto.Digest `codec:"gh"`
+ // Proposer is the proposer of this block. Like the Seed, algod adds
+ // this after the block is built, so that the same block can be prepared
+ // for multiple Players in the same node. Therefore, it can not be used
+ // to influence block evaluation. Populated if proto.EnableMining
+ Proposer basics.Address `codec:"prp"`
+
+ // FeesCollected is the sum of all fees paid by transactions in this
+ // block. Populated if proto.EnableMining.
+ FeesCollected basics.MicroAlgos `codec:"fc"`
+
// Rewards.
//
// When a block is applied, some amount of rewards are accrued to
@@ -275,9 +285,13 @@ func (block Block) GenesisHash() crypto.Digest {
}
// WithSeed returns a copy of the Block with the seed set to s.
-func (block Block) WithSeed(s committee.Seed) Block {
+func (block Block) WithSeed(s committee.Seed, proposer basics.Address) Block {
c := block
c.BlockHeader.Seed = s
+ if !c.BlockHeader.Proposer.IsZero() {
+ panic("Attempt to re-set the proposer.")
+ }
+ c.BlockHeader.Proposer = proposer
return c
}
diff --git a/data/bookkeeping/msgp_gen.go b/data/bookkeeping/msgp_gen.go
index 6ccafb53ad..010fada0f2 100644
--- a/data/bookkeeping/msgp_gen.go
+++ b/data/bookkeeping/msgp_gen.go
@@ -131,112 +131,120 @@ import (
func (z *Block) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0004Len := uint32(26)
- var zb0004Mask uint32 /* 31 bits */
+ zb0004Len := uint32(28)
+ var zb0004Mask uint64 /* 33 bits */
if (*z).BlockHeader.RewardsState.RewardsLevel == 0 {
zb0004Len--
zb0004Mask |= 0x20
}
- if (*z).BlockHeader.RewardsState.FeeSink.MsgIsZero() {
+ if (*z).BlockHeader.FeesCollected.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x40
}
- if (*z).BlockHeader.RewardsState.RewardsResidue == 0 {
+ if (*z).BlockHeader.RewardsState.FeeSink.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x80
}
- if (*z).BlockHeader.GenesisID == "" {
+ if (*z).BlockHeader.RewardsState.RewardsResidue == 0 {
zb0004Len--
zb0004Mask |= 0x100
}
- if (*z).BlockHeader.GenesisHash.MsgIsZero() {
+ if (*z).BlockHeader.GenesisID == "" {
zb0004Len--
zb0004Mask |= 0x200
}
- if (*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
+ if (*z).BlockHeader.GenesisHash.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x400
}
- if (*z).BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
+ if (*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x800
}
- if (*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
+ if (*z).BlockHeader.UpgradeState.NextProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x1000
}
- if (*z).BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
+ if (*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x2000
}
- if len((*z).BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
+ if (*z).BlockHeader.UpgradeState.NextProtocolApprovals == 0 {
zb0004Len--
zb0004Mask |= 0x4000
}
- if (*z).BlockHeader.Branch.MsgIsZero() {
+ if len((*z).BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
zb0004Len--
zb0004Mask |= 0x8000
}
- if (*z).BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
+ if (*z).BlockHeader.Branch.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x10000
}
- if (*z).BlockHeader.RewardsState.RewardsRate == 0 {
+ if (*z).BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x20000
}
- if (*z).BlockHeader.Round.MsgIsZero() {
+ if (*z).BlockHeader.Proposer.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x40000
}
- if (*z).BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero() {
+ if (*z).BlockHeader.RewardsState.RewardsRate == 0 {
zb0004Len--
zb0004Mask |= 0x80000
}
- if (*z).BlockHeader.RewardsState.RewardsPool.MsgIsZero() {
+ if (*z).BlockHeader.Round.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100000
}
- if (*z).BlockHeader.Seed.MsgIsZero() {
+ if (*z).BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x200000
}
- if len((*z).BlockHeader.StateProofTracking) == 0 {
+ if (*z).BlockHeader.RewardsState.RewardsPool.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x400000
}
- if (*z).BlockHeader.TxnCounter == 0 {
+ if (*z).BlockHeader.Seed.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x800000
}
- if (*z).BlockHeader.TimeStamp == 0 {
+ if len((*z).BlockHeader.StateProofTracking) == 0 {
zb0004Len--
zb0004Mask |= 0x1000000
}
- if (*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
+ if (*z).BlockHeader.TxnCounter == 0 {
zb0004Len--
zb0004Mask |= 0x2000000
}
- if (*z).BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero() {
+ if (*z).BlockHeader.TimeStamp == 0 {
zb0004Len--
zb0004Mask |= 0x4000000
}
- if (*z).Payset.MsgIsZero() {
+ if (*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x8000000
}
- if (*z).BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero() {
+ if (*z).BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x10000000
}
- if (*z).BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero() {
+ if (*z).Payset.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x20000000
}
- if (*z).BlockHeader.UpgradeVote.UpgradeApprove == false {
+ if (*z).BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x40000000
}
+ if (*z).BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x80000000
+ }
+ if (*z).BlockHeader.UpgradeVote.UpgradeApprove == false {
+ zb0004Len--
+ zb0004Mask |= 0x100000000
+ }
// variable map header, size zb0004Len
o = msgp.AppendMapHeader(o, zb0004Len)
if zb0004Len != 0 {
@@ -246,46 +254,51 @@ func (z *Block) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).BlockHeader.RewardsState.RewardsLevel)
}
if (zb0004Mask & 0x40) == 0 { // if not empty
+ // string "fc"
+ o = append(o, 0xa2, 0x66, 0x63)
+ o = (*z).BlockHeader.FeesCollected.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x80) == 0 { // if not empty
// string "fees"
o = append(o, 0xa4, 0x66, 0x65, 0x65, 0x73)
o = (*z).BlockHeader.RewardsState.FeeSink.MarshalMsg(o)
}
- if (zb0004Mask & 0x80) == 0 { // if not empty
+ if (zb0004Mask & 0x100) == 0 { // if not empty
// string "frac"
o = append(o, 0xa4, 0x66, 0x72, 0x61, 0x63)
o = msgp.AppendUint64(o, (*z).BlockHeader.RewardsState.RewardsResidue)
}
- if (zb0004Mask & 0x100) == 0 { // if not empty
+ if (zb0004Mask & 0x200) == 0 { // if not empty
// string "gen"
o = append(o, 0xa3, 0x67, 0x65, 0x6e)
o = msgp.AppendString(o, (*z).BlockHeader.GenesisID)
}
- if (zb0004Mask & 0x200) == 0 { // if not empty
+ if (zb0004Mask & 0x400) == 0 { // if not empty
// string "gh"
o = append(o, 0xa2, 0x67, 0x68)
o = (*z).BlockHeader.GenesisHash.MarshalMsg(o)
}
- if (zb0004Mask & 0x400) == 0 { // if not empty
+ if (zb0004Mask & 0x800) == 0 { // if not empty
// string "nextbefore"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65)
o = (*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.MarshalMsg(o)
}
- if (zb0004Mask & 0x800) == 0 { // if not empty
+ if (zb0004Mask & 0x1000) == 0 { // if not empty
// string "nextproto"
o = append(o, 0xa9, 0x6e, 0x65, 0x78, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).BlockHeader.UpgradeState.NextProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000) == 0 { // if not empty
// string "nextswitch"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68)
o = (*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000) == 0 { // if not empty
// string "nextyes"
o = append(o, 0xa7, 0x6e, 0x65, 0x78, 0x74, 0x79, 0x65, 0x73)
o = msgp.AppendUint64(o, (*z).BlockHeader.UpgradeState.NextProtocolApprovals)
}
- if (zb0004Mask & 0x4000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000) == 0 { // if not empty
// string "partupdrmv"
o = append(o, 0xaa, 0x70, 0x61, 0x72, 0x74, 0x75, 0x70, 0x64, 0x72, 0x6d, 0x76)
if (*z).BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts == nil {
@@ -297,42 +310,47 @@ func (z *Block) MarshalMsg(b []byte) (o []byte) {
o = (*z).BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts[zb0003].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x8000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000) == 0 { // if not empty
// string "prev"
o = append(o, 0xa4, 0x70, 0x72, 0x65, 0x76)
o = (*z).BlockHeader.Branch.MarshalMsg(o)
}
- if (zb0004Mask & 0x10000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000) == 0 { // if not empty
// string "proto"
o = append(o, 0xa5, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).BlockHeader.UpgradeState.CurrentProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000) == 0 { // if not empty
+ // string "prp"
+ o = append(o, 0xa3, 0x70, 0x72, 0x70)
+ o = (*z).BlockHeader.Proposer.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x80000) == 0 { // if not empty
// string "rate"
o = append(o, 0xa4, 0x72, 0x61, 0x74, 0x65)
o = msgp.AppendUint64(o, (*z).BlockHeader.RewardsState.RewardsRate)
}
- if (zb0004Mask & 0x40000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000) == 0 { // if not empty
// string "rnd"
o = append(o, 0xa3, 0x72, 0x6e, 0x64)
o = (*z).BlockHeader.Round.MarshalMsg(o)
}
- if (zb0004Mask & 0x80000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000) == 0 { // if not empty
// string "rwcalr"
o = append(o, 0xa6, 0x72, 0x77, 0x63, 0x61, 0x6c, 0x72)
o = (*z).BlockHeader.RewardsState.RewardsRecalculationRound.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000) == 0 { // if not empty
+ if (zb0004Mask & 0x400000) == 0 { // if not empty
// string "rwd"
o = append(o, 0xa3, 0x72, 0x77, 0x64)
o = (*z).BlockHeader.RewardsState.RewardsPool.MarshalMsg(o)
}
- if (zb0004Mask & 0x200000) == 0 { // if not empty
+ if (zb0004Mask & 0x800000) == 0 { // if not empty
// string "seed"
o = append(o, 0xa4, 0x73, 0x65, 0x65, 0x64)
o = (*z).BlockHeader.Seed.MarshalMsg(o)
}
- if (zb0004Mask & 0x400000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000) == 0 { // if not empty
// string "spt"
o = append(o, 0xa3, 0x73, 0x70, 0x74)
if (*z).BlockHeader.StateProofTracking == nil {
@@ -352,42 +370,42 @@ func (z *Block) MarshalMsg(b []byte) (o []byte) {
o = zb0002.MarshalMsg(o)
}
}
- if (zb0004Mask & 0x800000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000) == 0 { // if not empty
// string "tc"
o = append(o, 0xa2, 0x74, 0x63)
o = msgp.AppendUint64(o, (*z).BlockHeader.TxnCounter)
}
- if (zb0004Mask & 0x1000000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000000) == 0 { // if not empty
// string "ts"
o = append(o, 0xa2, 0x74, 0x73)
o = msgp.AppendInt64(o, (*z).BlockHeader.TimeStamp)
}
- if (zb0004Mask & 0x2000000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000000) == 0 { // if not empty
// string "txn"
o = append(o, 0xa3, 0x74, 0x78, 0x6e)
o = (*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000000) == 0 { // if not empty
// string "txn256"
o = append(o, 0xa6, 0x74, 0x78, 0x6e, 0x32, 0x35, 0x36)
o = (*z).BlockHeader.TxnCommitments.Sha256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x8000000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000000) == 0 { // if not empty
// string "txns"
o = append(o, 0xa4, 0x74, 0x78, 0x6e, 0x73)
o = (*z).Payset.MarshalMsg(o)
}
- if (zb0004Mask & 0x10000000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000000) == 0 { // if not empty
// string "upgradedelay"
o = append(o, 0xac, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x64, 0x65, 0x6c, 0x61, 0x79)
o = (*z).BlockHeader.UpgradeVote.UpgradeDelay.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000000) == 0 { // if not empty
// string "upgradeprop"
o = append(o, 0xab, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x70, 0x72, 0x6f, 0x70)
o = (*z).BlockHeader.UpgradeVote.UpgradePropose.MarshalMsg(o)
}
- if (zb0004Mask & 0x40000000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000000) == 0 { // if not empty
// string "upgradeyes"
o = append(o, 0xaa, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x79, 0x65, 0x73)
o = msgp.AppendBool(o, (*z).BlockHeader.UpgradeVote.UpgradeApprove)
@@ -488,6 +506,22 @@ func (z *Block) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Proposer")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "FeesCollected")
+ return
+ }
+ }
if zb0004 > 0 {
zb0004--
bts, err = (*z).BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
@@ -762,6 +796,18 @@ func (z *Block) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "GenesisHash")
return
}
+ case "prp":
+ bts, err = (*z).BlockHeader.Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Proposer")
+ return
+ }
+ case "fc":
+ bts, err = (*z).BlockHeader.FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "FeesCollected")
+ return
+ }
case "fees":
bts, err = (*z).BlockHeader.RewardsState.FeeSink.UnmarshalMsg(bts)
if err != nil {
@@ -939,7 +985,7 @@ func (_ *Block) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Block) Msgsize() (s int) {
- s = 3 + 4 + (*z).BlockHeader.Round.Msgsize() + 5 + (*z).BlockHeader.Branch.Msgsize() + 5 + (*z).BlockHeader.Seed.Msgsize() + 4 + (*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).BlockHeader.GenesisID) + 3 + (*z).BlockHeader.GenesisHash.Msgsize() + 5 + (*z).BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
+ s = 3 + 4 + (*z).BlockHeader.Round.Msgsize() + 5 + (*z).BlockHeader.Branch.Msgsize() + 5 + (*z).BlockHeader.Seed.Msgsize() + 4 + (*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).BlockHeader.TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).BlockHeader.GenesisID) + 3 + (*z).BlockHeader.GenesisHash.Msgsize() + 4 + (*z).BlockHeader.Proposer.Msgsize() + 3 + (*z).BlockHeader.FeesCollected.Msgsize() + 5 + (*z).BlockHeader.RewardsState.FeeSink.Msgsize() + 4 + (*z).BlockHeader.RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).BlockHeader.RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).BlockHeader.UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).BlockHeader.UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).BlockHeader.UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).BlockHeader.UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
if (*z).BlockHeader.StateProofTracking != nil {
for zb0001, zb0002 := range (*z).BlockHeader.StateProofTracking {
_ = zb0001
@@ -957,12 +1003,12 @@ func (z *Block) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *Block) MsgIsZero() bool {
- return ((*z).BlockHeader.Round.MsgIsZero()) && ((*z).BlockHeader.Branch.MsgIsZero()) && ((*z).BlockHeader.Seed.MsgIsZero()) && ((*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).BlockHeader.TimeStamp == 0) && ((*z).BlockHeader.GenesisID == "") && ((*z).BlockHeader.GenesisHash.MsgIsZero()) && ((*z).BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).BlockHeader.RewardsState.RewardsRate == 0) && ((*z).BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).BlockHeader.TxnCounter == 0) && (len((*z).BlockHeader.StateProofTracking) == 0) && (len((*z).BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).Payset.MsgIsZero())
+ return ((*z).BlockHeader.Round.MsgIsZero()) && ((*z).BlockHeader.Branch.MsgIsZero()) && ((*z).BlockHeader.Seed.MsgIsZero()) && ((*z).BlockHeader.TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).BlockHeader.TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).BlockHeader.TimeStamp == 0) && ((*z).BlockHeader.GenesisID == "") && ((*z).BlockHeader.GenesisHash.MsgIsZero()) && ((*z).BlockHeader.Proposer.MsgIsZero()) && ((*z).BlockHeader.FeesCollected.MsgIsZero()) && ((*z).BlockHeader.RewardsState.FeeSink.MsgIsZero()) && ((*z).BlockHeader.RewardsState.RewardsPool.MsgIsZero()) && ((*z).BlockHeader.RewardsState.RewardsLevel == 0) && ((*z).BlockHeader.RewardsState.RewardsRate == 0) && ((*z).BlockHeader.RewardsState.RewardsResidue == 0) && ((*z).BlockHeader.RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.NextProtocol.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.NextProtocolApprovals == 0) && ((*z).BlockHeader.UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).BlockHeader.UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).BlockHeader.UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).BlockHeader.UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).BlockHeader.UpgradeVote.UpgradeApprove == false) && ((*z).BlockHeader.TxnCounter == 0) && (len((*z).BlockHeader.StateProofTracking) == 0) && (len((*z).BlockHeader.ParticipationUpdates.ExpiredParticipationAccounts) == 0) && ((*z).Payset.MsgIsZero())
}
// MaxSize returns a maximum valid message size for this message type
func BlockMaxSize() (s int) {
- s = 3 + 4 + basics.RoundMaxSize() + 5 + BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
+ s = 3 + 4 + basics.RoundMaxSize() + 5 + BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 4 + basics.AddressMaxSize() + 3 + basics.MicroAlgosMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
s += msgp.MapHeaderSize
// Adding size of map keys for z.BlockHeader.StateProofTracking
s += protocol.NumStateProofTypes * (protocol.StateProofTypeMaxSize())
@@ -1014,108 +1060,116 @@ func BlockHashMaxSize() int {
func (z *BlockHeader) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
// omitempty: check for empty values
- zb0004Len := uint32(25)
- var zb0004Mask uint32 /* 30 bits */
+ zb0004Len := uint32(27)
+ var zb0004Mask uint32 /* 32 bits */
if (*z).RewardsState.RewardsLevel == 0 {
zb0004Len--
zb0004Mask |= 0x20
}
- if (*z).RewardsState.FeeSink.MsgIsZero() {
+ if (*z).FeesCollected.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x40
}
- if (*z).RewardsState.RewardsResidue == 0 {
+ if (*z).RewardsState.FeeSink.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x80
}
- if (*z).GenesisID == "" {
+ if (*z).RewardsState.RewardsResidue == 0 {
zb0004Len--
zb0004Mask |= 0x100
}
- if (*z).GenesisHash.MsgIsZero() {
+ if (*z).GenesisID == "" {
zb0004Len--
zb0004Mask |= 0x200
}
- if (*z).UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
+ if (*z).GenesisHash.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x400
}
- if (*z).UpgradeState.NextProtocol.MsgIsZero() {
+ if (*z).UpgradeState.NextProtocolVoteBefore.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x800
}
- if (*z).UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
+ if (*z).UpgradeState.NextProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x1000
}
- if (*z).UpgradeState.NextProtocolApprovals == 0 {
+ if (*z).UpgradeState.NextProtocolSwitchOn.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x2000
}
- if len((*z).ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
+ if (*z).UpgradeState.NextProtocolApprovals == 0 {
zb0004Len--
zb0004Mask |= 0x4000
}
- if (*z).Branch.MsgIsZero() {
+ if len((*z).ParticipationUpdates.ExpiredParticipationAccounts) == 0 {
zb0004Len--
zb0004Mask |= 0x8000
}
- if (*z).UpgradeState.CurrentProtocol.MsgIsZero() {
+ if (*z).Branch.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x10000
}
- if (*z).RewardsState.RewardsRate == 0 {
+ if (*z).UpgradeState.CurrentProtocol.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x20000
}
- if (*z).Round.MsgIsZero() {
+ if (*z).Proposer.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x40000
}
- if (*z).RewardsState.RewardsRecalculationRound.MsgIsZero() {
+ if (*z).RewardsState.RewardsRate == 0 {
zb0004Len--
zb0004Mask |= 0x80000
}
- if (*z).RewardsState.RewardsPool.MsgIsZero() {
+ if (*z).Round.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x100000
}
- if (*z).Seed.MsgIsZero() {
+ if (*z).RewardsState.RewardsRecalculationRound.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x200000
}
- if len((*z).StateProofTracking) == 0 {
+ if (*z).RewardsState.RewardsPool.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x400000
}
- if (*z).TxnCounter == 0 {
+ if (*z).Seed.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x800000
}
- if (*z).TimeStamp == 0 {
+ if len((*z).StateProofTracking) == 0 {
zb0004Len--
zb0004Mask |= 0x1000000
}
- if (*z).TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
+ if (*z).TxnCounter == 0 {
zb0004Len--
zb0004Mask |= 0x2000000
}
- if (*z).TxnCommitments.Sha256Commitment.MsgIsZero() {
+ if (*z).TimeStamp == 0 {
zb0004Len--
zb0004Mask |= 0x4000000
}
- if (*z).UpgradeVote.UpgradeDelay.MsgIsZero() {
+ if (*z).TxnCommitments.NativeSha512_256Commitment.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x8000000
}
- if (*z).UpgradeVote.UpgradePropose.MsgIsZero() {
+ if (*z).TxnCommitments.Sha256Commitment.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x10000000
}
- if (*z).UpgradeVote.UpgradeApprove == false {
+ if (*z).UpgradeVote.UpgradeDelay.MsgIsZero() {
zb0004Len--
zb0004Mask |= 0x20000000
}
+ if (*z).UpgradeVote.UpgradePropose.MsgIsZero() {
+ zb0004Len--
+ zb0004Mask |= 0x40000000
+ }
+ if (*z).UpgradeVote.UpgradeApprove == false {
+ zb0004Len--
+ zb0004Mask |= 0x80000000
+ }
// variable map header, size zb0004Len
o = msgp.AppendMapHeader(o, zb0004Len)
if zb0004Len != 0 {
@@ -1125,46 +1179,51 @@ func (z *BlockHeader) MarshalMsg(b []byte) (o []byte) {
o = msgp.AppendUint64(o, (*z).RewardsState.RewardsLevel)
}
if (zb0004Mask & 0x40) == 0 { // if not empty
+ // string "fc"
+ o = append(o, 0xa2, 0x66, 0x63)
+ o = (*z).FeesCollected.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x80) == 0 { // if not empty
// string "fees"
o = append(o, 0xa4, 0x66, 0x65, 0x65, 0x73)
o = (*z).RewardsState.FeeSink.MarshalMsg(o)
}
- if (zb0004Mask & 0x80) == 0 { // if not empty
+ if (zb0004Mask & 0x100) == 0 { // if not empty
// string "frac"
o = append(o, 0xa4, 0x66, 0x72, 0x61, 0x63)
o = msgp.AppendUint64(o, (*z).RewardsState.RewardsResidue)
}
- if (zb0004Mask & 0x100) == 0 { // if not empty
+ if (zb0004Mask & 0x200) == 0 { // if not empty
// string "gen"
o = append(o, 0xa3, 0x67, 0x65, 0x6e)
o = msgp.AppendString(o, (*z).GenesisID)
}
- if (zb0004Mask & 0x200) == 0 { // if not empty
+ if (zb0004Mask & 0x400) == 0 { // if not empty
// string "gh"
o = append(o, 0xa2, 0x67, 0x68)
o = (*z).GenesisHash.MarshalMsg(o)
}
- if (zb0004Mask & 0x400) == 0 { // if not empty
+ if (zb0004Mask & 0x800) == 0 { // if not empty
// string "nextbefore"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65)
o = (*z).UpgradeState.NextProtocolVoteBefore.MarshalMsg(o)
}
- if (zb0004Mask & 0x800) == 0 { // if not empty
+ if (zb0004Mask & 0x1000) == 0 { // if not empty
// string "nextproto"
o = append(o, 0xa9, 0x6e, 0x65, 0x78, 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).UpgradeState.NextProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x1000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000) == 0 { // if not empty
// string "nextswitch"
o = append(o, 0xaa, 0x6e, 0x65, 0x78, 0x74, 0x73, 0x77, 0x69, 0x74, 0x63, 0x68)
o = (*z).UpgradeState.NextProtocolSwitchOn.MarshalMsg(o)
}
- if (zb0004Mask & 0x2000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000) == 0 { // if not empty
// string "nextyes"
o = append(o, 0xa7, 0x6e, 0x65, 0x78, 0x74, 0x79, 0x65, 0x73)
o = msgp.AppendUint64(o, (*z).UpgradeState.NextProtocolApprovals)
}
- if (zb0004Mask & 0x4000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000) == 0 { // if not empty
// string "partupdrmv"
o = append(o, 0xaa, 0x70, 0x61, 0x72, 0x74, 0x75, 0x70, 0x64, 0x72, 0x6d, 0x76)
if (*z).ParticipationUpdates.ExpiredParticipationAccounts == nil {
@@ -1176,42 +1235,47 @@ func (z *BlockHeader) MarshalMsg(b []byte) (o []byte) {
o = (*z).ParticipationUpdates.ExpiredParticipationAccounts[zb0003].MarshalMsg(o)
}
}
- if (zb0004Mask & 0x8000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000) == 0 { // if not empty
// string "prev"
o = append(o, 0xa4, 0x70, 0x72, 0x65, 0x76)
o = (*z).Branch.MarshalMsg(o)
}
- if (zb0004Mask & 0x10000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000) == 0 { // if not empty
// string "proto"
o = append(o, 0xa5, 0x70, 0x72, 0x6f, 0x74, 0x6f)
o = (*z).UpgradeState.CurrentProtocol.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000) == 0 { // if not empty
+ // string "prp"
+ o = append(o, 0xa3, 0x70, 0x72, 0x70)
+ o = (*z).Proposer.MarshalMsg(o)
+ }
+ if (zb0004Mask & 0x80000) == 0 { // if not empty
// string "rate"
o = append(o, 0xa4, 0x72, 0x61, 0x74, 0x65)
o = msgp.AppendUint64(o, (*z).RewardsState.RewardsRate)
}
- if (zb0004Mask & 0x40000) == 0 { // if not empty
+ if (zb0004Mask & 0x100000) == 0 { // if not empty
// string "rnd"
o = append(o, 0xa3, 0x72, 0x6e, 0x64)
o = (*z).Round.MarshalMsg(o)
}
- if (zb0004Mask & 0x80000) == 0 { // if not empty
+ if (zb0004Mask & 0x200000) == 0 { // if not empty
// string "rwcalr"
o = append(o, 0xa6, 0x72, 0x77, 0x63, 0x61, 0x6c, 0x72)
o = (*z).RewardsState.RewardsRecalculationRound.MarshalMsg(o)
}
- if (zb0004Mask & 0x100000) == 0 { // if not empty
+ if (zb0004Mask & 0x400000) == 0 { // if not empty
// string "rwd"
o = append(o, 0xa3, 0x72, 0x77, 0x64)
o = (*z).RewardsState.RewardsPool.MarshalMsg(o)
}
- if (zb0004Mask & 0x200000) == 0 { // if not empty
+ if (zb0004Mask & 0x800000) == 0 { // if not empty
// string "seed"
o = append(o, 0xa4, 0x73, 0x65, 0x65, 0x64)
o = (*z).Seed.MarshalMsg(o)
}
- if (zb0004Mask & 0x400000) == 0 { // if not empty
+ if (zb0004Mask & 0x1000000) == 0 { // if not empty
// string "spt"
o = append(o, 0xa3, 0x73, 0x70, 0x74)
if (*z).StateProofTracking == nil {
@@ -1231,37 +1295,37 @@ func (z *BlockHeader) MarshalMsg(b []byte) (o []byte) {
o = zb0002.MarshalMsg(o)
}
}
- if (zb0004Mask & 0x800000) == 0 { // if not empty
+ if (zb0004Mask & 0x2000000) == 0 { // if not empty
// string "tc"
o = append(o, 0xa2, 0x74, 0x63)
o = msgp.AppendUint64(o, (*z).TxnCounter)
}
- if (zb0004Mask & 0x1000000) == 0 { // if not empty
+ if (zb0004Mask & 0x4000000) == 0 { // if not empty
// string "ts"
o = append(o, 0xa2, 0x74, 0x73)
o = msgp.AppendInt64(o, (*z).TimeStamp)
}
- if (zb0004Mask & 0x2000000) == 0 { // if not empty
+ if (zb0004Mask & 0x8000000) == 0 { // if not empty
// string "txn"
o = append(o, 0xa3, 0x74, 0x78, 0x6e)
o = (*z).TxnCommitments.NativeSha512_256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x4000000) == 0 { // if not empty
+ if (zb0004Mask & 0x10000000) == 0 { // if not empty
// string "txn256"
o = append(o, 0xa6, 0x74, 0x78, 0x6e, 0x32, 0x35, 0x36)
o = (*z).TxnCommitments.Sha256Commitment.MarshalMsg(o)
}
- if (zb0004Mask & 0x8000000) == 0 { // if not empty
+ if (zb0004Mask & 0x20000000) == 0 { // if not empty
// string "upgradedelay"
o = append(o, 0xac, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x64, 0x65, 0x6c, 0x61, 0x79)
o = (*z).UpgradeVote.UpgradeDelay.MarshalMsg(o)
}
- if (zb0004Mask & 0x10000000) == 0 { // if not empty
+ if (zb0004Mask & 0x40000000) == 0 { // if not empty
// string "upgradeprop"
o = append(o, 0xab, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x70, 0x72, 0x6f, 0x70)
o = (*z).UpgradeVote.UpgradePropose.MarshalMsg(o)
}
- if (zb0004Mask & 0x20000000) == 0 { // if not empty
+ if (zb0004Mask & 0x80000000) == 0 { // if not empty
// string "upgradeyes"
o = append(o, 0xaa, 0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x79, 0x65, 0x73)
o = msgp.AppendBool(o, (*z).UpgradeVote.UpgradeApprove)
@@ -1362,6 +1426,22 @@ func (z *BlockHeader) UnmarshalMsg(bts []byte) (o []byte, err error) {
return
}
}
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "Proposer")
+ return
+ }
+ }
+ if zb0004 > 0 {
+ zb0004--
+ bts, err = (*z).FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "struct-from-array", "FeesCollected")
+ return
+ }
+ }
if zb0004 > 0 {
zb0004--
bts, err = (*z).RewardsState.FeeSink.UnmarshalMsg(bts)
@@ -1628,6 +1708,18 @@ func (z *BlockHeader) UnmarshalMsg(bts []byte) (o []byte, err error) {
err = msgp.WrapError(err, "GenesisHash")
return
}
+ case "prp":
+ bts, err = (*z).Proposer.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "Proposer")
+ return
+ }
+ case "fc":
+ bts, err = (*z).FeesCollected.UnmarshalMsg(bts)
+ if err != nil {
+ err = msgp.WrapError(err, "FeesCollected")
+ return
+ }
case "fees":
bts, err = (*z).RewardsState.FeeSink.UnmarshalMsg(bts)
if err != nil {
@@ -1799,7 +1891,7 @@ func (_ *BlockHeader) CanUnmarshalMsg(z interface{}) bool {
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BlockHeader) Msgsize() (s int) {
- s = 3 + 4 + (*z).Round.Msgsize() + 5 + (*z).Branch.Msgsize() + 5 + (*z).Seed.Msgsize() + 4 + (*z).TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).GenesisID) + 3 + (*z).GenesisHash.Msgsize() + 5 + (*z).RewardsState.FeeSink.Msgsize() + 4 + (*z).RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
+ s = 3 + 4 + (*z).Round.Msgsize() + 5 + (*z).Branch.Msgsize() + 5 + (*z).Seed.Msgsize() + 4 + (*z).TxnCommitments.NativeSha512_256Commitment.Msgsize() + 7 + (*z).TxnCommitments.Sha256Commitment.Msgsize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + len((*z).GenesisID) + 3 + (*z).GenesisHash.Msgsize() + 4 + (*z).Proposer.Msgsize() + 3 + (*z).FeesCollected.Msgsize() + 5 + (*z).RewardsState.FeeSink.Msgsize() + 4 + (*z).RewardsState.RewardsPool.Msgsize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + (*z).RewardsState.RewardsRecalculationRound.Msgsize() + 6 + (*z).UpgradeState.CurrentProtocol.Msgsize() + 10 + (*z).UpgradeState.NextProtocol.Msgsize() + 8 + msgp.Uint64Size + 11 + (*z).UpgradeState.NextProtocolVoteBefore.Msgsize() + 11 + (*z).UpgradeState.NextProtocolSwitchOn.Msgsize() + 12 + (*z).UpgradeVote.UpgradePropose.Msgsize() + 13 + (*z).UpgradeVote.UpgradeDelay.Msgsize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4 + msgp.MapHeaderSize
if (*z).StateProofTracking != nil {
for zb0001, zb0002 := range (*z).StateProofTracking {
_ = zb0001
@@ -1816,12 +1908,12 @@ func (z *BlockHeader) Msgsize() (s int) {
// MsgIsZero returns whether this is a zero value
func (z *BlockHeader) MsgIsZero() bool {
- return ((*z).Round.MsgIsZero()) && ((*z).Branch.MsgIsZero()) && ((*z).Seed.MsgIsZero()) && ((*z).TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).TimeStamp == 0) && ((*z).GenesisID == "") && ((*z).GenesisHash.MsgIsZero()) && ((*z).RewardsState.FeeSink.MsgIsZero()) && ((*z).RewardsState.RewardsPool.MsgIsZero()) && ((*z).RewardsState.RewardsLevel == 0) && ((*z).RewardsState.RewardsRate == 0) && ((*z).RewardsState.RewardsResidue == 0) && ((*z).RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).UpgradeState.NextProtocol.MsgIsZero()) && ((*z).UpgradeState.NextProtocolApprovals == 0) && ((*z).UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).UpgradeVote.UpgradeApprove == false) && ((*z).TxnCounter == 0) && (len((*z).StateProofTracking) == 0) && (len((*z).ParticipationUpdates.ExpiredParticipationAccounts) == 0)
+ return ((*z).Round.MsgIsZero()) && ((*z).Branch.MsgIsZero()) && ((*z).Seed.MsgIsZero()) && ((*z).TxnCommitments.NativeSha512_256Commitment.MsgIsZero()) && ((*z).TxnCommitments.Sha256Commitment.MsgIsZero()) && ((*z).TimeStamp == 0) && ((*z).GenesisID == "") && ((*z).GenesisHash.MsgIsZero()) && ((*z).Proposer.MsgIsZero()) && ((*z).FeesCollected.MsgIsZero()) && ((*z).RewardsState.FeeSink.MsgIsZero()) && ((*z).RewardsState.RewardsPool.MsgIsZero()) && ((*z).RewardsState.RewardsLevel == 0) && ((*z).RewardsState.RewardsRate == 0) && ((*z).RewardsState.RewardsResidue == 0) && ((*z).RewardsState.RewardsRecalculationRound.MsgIsZero()) && ((*z).UpgradeState.CurrentProtocol.MsgIsZero()) && ((*z).UpgradeState.NextProtocol.MsgIsZero()) && ((*z).UpgradeState.NextProtocolApprovals == 0) && ((*z).UpgradeState.NextProtocolVoteBefore.MsgIsZero()) && ((*z).UpgradeState.NextProtocolSwitchOn.MsgIsZero()) && ((*z).UpgradeVote.UpgradePropose.MsgIsZero()) && ((*z).UpgradeVote.UpgradeDelay.MsgIsZero()) && ((*z).UpgradeVote.UpgradeApprove == false) && ((*z).TxnCounter == 0) && (len((*z).StateProofTracking) == 0) && (len((*z).ParticipationUpdates.ExpiredParticipationAccounts) == 0)
}
// MaxSize returns a maximum valid message size for this message type
func BlockHeaderMaxSize() (s int) {
- s = 3 + 4 + basics.RoundMaxSize() + 5 + BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
+ s = 3 + 4 + basics.RoundMaxSize() + 5 + BlockHashMaxSize() + 5 + committee.SeedMaxSize() + 4 + crypto.DigestMaxSize() + 7 + crypto.DigestMaxSize() + 3 + msgp.Int64Size + 4 + msgp.StringPrefixSize + config.MaxGenesisIDLen + 3 + crypto.DigestMaxSize() + 4 + basics.AddressMaxSize() + 3 + basics.MicroAlgosMaxSize() + 5 + basics.AddressMaxSize() + 4 + basics.AddressMaxSize() + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 5 + msgp.Uint64Size + 7 + basics.RoundMaxSize() + 6 + protocol.ConsensusVersionMaxSize() + 10 + protocol.ConsensusVersionMaxSize() + 8 + msgp.Uint64Size + 11 + basics.RoundMaxSize() + 11 + basics.RoundMaxSize() + 12 + protocol.ConsensusVersionMaxSize() + 13 + basics.RoundMaxSize() + 11 + msgp.BoolSize + 3 + msgp.Uint64Size + 4
s += msgp.MapHeaderSize
// Adding size of map keys for z.StateProofTracking
s += protocol.NumStateProofTypes * (protocol.StateProofTypeMaxSize())
diff --git a/data/datatest/impls.go b/data/datatest/impls.go
index fefcb054da..8e14885c96 100644
--- a/data/datatest/impls.go
+++ b/data/datatest/impls.go
@@ -65,8 +65,8 @@ func (i entryFactoryImpl) AssembleBlock(round basics.Round) (agreement.Validated
}
// WithSeed implements the agreement.ValidatedBlock interface.
-func (ve validatedBlock) WithSeed(s committee.Seed) agreement.ValidatedBlock {
- newblock := ve.blk.WithSeed(s)
+func (ve validatedBlock) WithSeed(s committee.Seed, proposer basics.Address) agreement.ValidatedBlock {
+ newblock := ve.blk.WithSeed(s, proposer)
return validatedBlock{blk: &newblock}
}
diff --git a/data/transactions/logic/TEAL_opcodes_v10.md b/data/transactions/logic/TEAL_opcodes_v10.md
index 31beb6c388..dc1d34691a 100644
--- a/data/transactions/logic/TEAL_opcodes_v10.md
+++ b/data/transactions/logic/TEAL_opcodes_v10.md
@@ -1635,10 +1635,12 @@ Standards
Fields
-| Index | Name | Type | Notes |
-| - | ------ | -- | --------- |
-| 0 | BlkSeed | []byte | |
-| 1 | BlkTimestamp | uint64 | |
+| Index | Name | Type | In | Notes |
+| - | ------ | -- | - | --------- |
+| 0 | BlkSeed | []byte | | |
+| 1 | BlkTimestamp | uint64 | | |
+| 2 | BlkProposer | address | v10 | |
+| 3 | BlkFeesCollected | uint64 | v10 | |
## ec_add
diff --git a/data/transactions/logic/eval.go b/data/transactions/logic/eval.go
index 871aa0399a..4790beffc5 100644
--- a/data/transactions/logic/eval.go
+++ b/data/transactions/logic/eval.go
@@ -5891,17 +5891,20 @@ func opBlock(cx *EvalContext) error {
switch fs.field {
case BlkSeed:
cx.Stack[last].Bytes = hdr.Seed[:]
- return nil
case BlkTimestamp:
cx.Stack[last].Bytes = nil
if hdr.TimeStamp < 0 {
return fmt.Errorf("block(%d) timestamp %d < 0", round, hdr.TimeStamp)
}
cx.Stack[last].Uint = uint64(hdr.TimeStamp)
- return nil
+ case BlkProposer:
+ cx.Stack[last].Bytes = hdr.Proposer[:]
+ case BlkFeesCollected:
+ cx.Stack[last].Uint = hdr.FeesCollected.Raw
default:
return fmt.Errorf("invalid block field %d", fs.field)
}
+ return nil
}
// pcDetails return PC and disassembled instructions at PC up to 2 opcodes back
diff --git a/data/transactions/logic/fields.go b/data/transactions/logic/fields.go
index bb5c2179e9..c99b03fbbf 100644
--- a/data/transactions/logic/fields.go
+++ b/data/transactions/logic/fields.go
@@ -961,6 +961,10 @@ const (
BlkSeed BlockField = iota
// BlkTimestamp is the Block's timestamp, seconds from epoch
BlkTimestamp
+ // BlkProposer is the Block's proposer, or ZeroAddress, pre EnableMining
+ BlkProposer
+ // BlkFeesCollected is the sum of fees for the block, or 0, pre EnableMining
+ BlkFeesCollected
invalidBlockField // compile-time constant for number of fields
)
@@ -975,6 +979,8 @@ type blockFieldSpec struct {
var blockFieldSpecs = [...]blockFieldSpec{
{BlkSeed, StackBytes, randomnessVersion},
{BlkTimestamp, StackUint64, randomnessVersion},
+ {BlkProposer, StackAddress, 10},
+ {BlkFeesCollected, StackUint64, 10},
}
func blockFieldSpecByField(r BlockField) (blockFieldSpec, bool) {
diff --git a/data/transactions/logic/fields_string.go b/data/transactions/logic/fields_string.go
index 7d3c2b42f2..2bf79d7a82 100644
--- a/data/transactions/logic/fields_string.go
+++ b/data/transactions/logic/fields_string.go
@@ -351,12 +351,14 @@ func _() {
var x [1]struct{}
_ = x[BlkSeed-0]
_ = x[BlkTimestamp-1]
- _ = x[invalidBlockField-2]
+ _ = x[BlkProposer-2]
+ _ = x[BlkFeesCollected-3]
+ _ = x[invalidBlockField-4]
}
-const _BlockField_name = "BlkSeedBlkTimestampinvalidBlockField"
+const _BlockField_name = "BlkSeedBlkTimestampBlkProposerBlkFeesCollectedinvalidBlockField"
-var _BlockField_index = [...]uint8{0, 7, 19, 36}
+var _BlockField_index = [...]uint8{0, 7, 19, 30, 46, 63}
func (i BlockField) String() string {
if i < 0 || i >= BlockField(len(_BlockField_index)-1) {
diff --git a/data/transactions/logic/langspec_v10.json b/data/transactions/logic/langspec_v10.json
index de938ffb72..405fd11e68 100644
--- a/data/transactions/logic/langspec_v10.json
+++ b/data/transactions/logic/langspec_v10.json
@@ -4605,10 +4605,14 @@
"Size": 2,
"ArgEnum": [
"BlkSeed",
- "BlkTimestamp"
+ "BlkTimestamp",
+ "BlkProposer",
+ "BlkFeesCollected"
],
"ArgEnumTypes": [
"[]byte",
+ "uint64",
+ "address",
"uint64"
],
"DocCost": "1",
diff --git a/data/transactions/logic/teal.tmLanguage.json b/data/transactions/logic/teal.tmLanguage.json
index f63c91778a..3a8c32087d 100644
--- a/data/transactions/logic/teal.tmLanguage.json
+++ b/data/transactions/logic/teal.tmLanguage.json
@@ -112,7 +112,7 @@
},
{
"name": "variable.parameter.teal",
- "match": "\\b(unknown|pay|keyreg|acfg|axfer|afrz|appl|NoOp|OptIn|CloseOut|ClearState|UpdateApplication|DeleteApplication|Secp256k1|Secp256r1|Sender|Fee|FirstValid|FirstValidTime|LastValid|Note|Lease|Receiver|Amount|CloseRemainderTo|VotePK|SelectionPK|VoteFirst|VoteLast|VoteKeyDilution|Type|TypeEnum|XferAsset|AssetAmount|AssetSender|AssetReceiver|AssetCloseTo|GroupIndex|TxID|ApplicationID|OnCompletion|NumAppArgs|NumAccounts|ApprovalProgram|ClearStateProgram|RekeyTo|ConfigAsset|ConfigAssetTotal|ConfigAssetDecimals|ConfigAssetDefaultFrozen|ConfigAssetUnitName|ConfigAssetName|ConfigAssetURL|ConfigAssetMetadataHash|ConfigAssetManager|ConfigAssetReserve|ConfigAssetFreeze|ConfigAssetClawback|FreezeAsset|FreezeAssetAccount|FreezeAssetFrozen|NumAssets|NumApplications|GlobalNumUint|GlobalNumByteSlice|LocalNumUint|LocalNumByteSlice|ExtraProgramPages|Nonparticipation|NumLogs|CreatedAssetID|CreatedApplicationID|LastLog|StateProofPK|NumApprovalProgramPages|NumClearStateProgramPages|MinTxnFee|MinBalance|MaxTxnLife|ZeroAddress|GroupSize|LogicSigVersion|Round|LatestTimestamp|CurrentApplicationID|CreatorAddress|CurrentApplicationAddress|GroupID|OpcodeBudget|CallerApplicationID|CallerApplicationAddress|AssetCreateMinBalance|AssetOptInMinBalance|ApplicationArgs|Accounts|Assets|Applications|Logs|ApprovalProgramPages|ClearStateProgramPages|URLEncoding|StdEncoding|JSONString|JSONUint64|JSONObject|AssetBalance|AssetFrozen|AssetTotal|AssetDecimals|AssetDefaultFrozen|AssetUnitName|AssetName|AssetURL|AssetMetadataHash|AssetManager|AssetReserve|AssetFreeze|AssetClawback|AssetCreator|AppApprovalProgram|AppClearStateProgram|AppGlobalNumUint|AppGlobalNumByteSlice|AppLocalNumUint|AppLocalNumByteSlice|AppExtraProgramPages|AppCreator|AppAddress|AcctBalance|AcctMinBalance|AcctAuthAddr|AcctTotalNumUint|AcctTotalNumByteSlice|AcctTotalExtraAppPages|AcctTotalAppsCreated|AcctTotalAppsOptedIn|AcctTotalAssetsCreated|AcctTotalAssets|AcctTotalBoxes|AcctTotalBoxBytes|VrfAlgorand|BlkSeed|BlkTimestamp|BN254g1|BN254g2|BLS12_381g1|BLS12_381g2)\\b"
+ "match": "\\b(unknown|pay|keyreg|acfg|axfer|afrz|appl|NoOp|OptIn|CloseOut|ClearState|UpdateApplication|DeleteApplication|Secp256k1|Secp256r1|Sender|Fee|FirstValid|FirstValidTime|LastValid|Note|Lease|Receiver|Amount|CloseRemainderTo|VotePK|SelectionPK|VoteFirst|VoteLast|VoteKeyDilution|Type|TypeEnum|XferAsset|AssetAmount|AssetSender|AssetReceiver|AssetCloseTo|GroupIndex|TxID|ApplicationID|OnCompletion|NumAppArgs|NumAccounts|ApprovalProgram|ClearStateProgram|RekeyTo|ConfigAsset|ConfigAssetTotal|ConfigAssetDecimals|ConfigAssetDefaultFrozen|ConfigAssetUnitName|ConfigAssetName|ConfigAssetURL|ConfigAssetMetadataHash|ConfigAssetManager|ConfigAssetReserve|ConfigAssetFreeze|ConfigAssetClawback|FreezeAsset|FreezeAssetAccount|FreezeAssetFrozen|NumAssets|NumApplications|GlobalNumUint|GlobalNumByteSlice|LocalNumUint|LocalNumByteSlice|ExtraProgramPages|Nonparticipation|NumLogs|CreatedAssetID|CreatedApplicationID|LastLog|StateProofPK|NumApprovalProgramPages|NumClearStateProgramPages|MinTxnFee|MinBalance|MaxTxnLife|ZeroAddress|GroupSize|LogicSigVersion|Round|LatestTimestamp|CurrentApplicationID|CreatorAddress|CurrentApplicationAddress|GroupID|OpcodeBudget|CallerApplicationID|CallerApplicationAddress|AssetCreateMinBalance|AssetOptInMinBalance|ApplicationArgs|Accounts|Assets|Applications|Logs|ApprovalProgramPages|ClearStateProgramPages|URLEncoding|StdEncoding|JSONString|JSONUint64|JSONObject|AssetBalance|AssetFrozen|AssetTotal|AssetDecimals|AssetDefaultFrozen|AssetUnitName|AssetName|AssetURL|AssetMetadataHash|AssetManager|AssetReserve|AssetFreeze|AssetClawback|AssetCreator|AppApprovalProgram|AppClearStateProgram|AppGlobalNumUint|AppGlobalNumByteSlice|AppLocalNumUint|AppLocalNumByteSlice|AppExtraProgramPages|AppCreator|AppAddress|AcctBalance|AcctMinBalance|AcctAuthAddr|AcctTotalNumUint|AcctTotalNumByteSlice|AcctTotalExtraAppPages|AcctTotalAppsCreated|AcctTotalAppsOptedIn|AcctTotalAssetsCreated|AcctTotalAssets|AcctTotalBoxes|AcctTotalBoxBytes|VrfAlgorand|BlkSeed|BlkTimestamp|BlkProposer|BlkFeesCollected|BN254g1|BN254g2|BLS12_381g1|BLS12_381g2)\\b"
}
]
},
diff --git a/data/transactions/payment.go b/data/transactions/payment.go
index fee9c395ee..62f3e8ca6a 100644
--- a/data/transactions/payment.go
+++ b/data/transactions/payment.go
@@ -42,8 +42,11 @@ func (payment PaymentTxnFields) checkSpender(header Header, spec SpecialAddresse
return fmt.Errorf("transaction cannot close account to its sender %v", header.Sender)
}
- // the FeeSink account may only spend to the IncentivePool
+ // the FeeSink account may only spend to the IncentivePool (not at all, if EnableMining)
if header.Sender == spec.FeeSink {
+ if proto.EnableMining {
+ return fmt.Errorf("cannot spend from fee sink address %v", header.Sender)
+ }
if payment.Receiver != spec.RewardsPool {
return fmt.Errorf("cannot spend from fee sink's address %v to non incentive pool address %v", header.Sender, payment.Receiver)
}
diff --git a/data/transactions/transaction_test.go b/data/transactions/transaction_test.go
index 0f3cf18258..77d8feabb2 100644
--- a/data/transactions/transaction_test.go
+++ b/data/transactions/transaction_test.go
@@ -101,13 +101,13 @@ func TestGoOnlineGoNonparticipatingContradiction(t *testing.T) {
tx.KeyregTxnFields = KeyregTxnFields{
VotePK: v.OneTimeSignatureVerifier,
SelectionPK: vrf.PK,
+ VoteKeyDilution: 1,
Nonparticipation: true,
}
// this tx tries to both register keys to go online, and mark an account as non-participating.
// it is not well-formed.
- feeSink := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
- err = tx.WellFormed(SpecialAddresses{FeeSink: feeSink}, config.Consensus[protocol.ConsensusCurrentVersion])
- require.Error(t, err)
+ err = tx.WellFormed(SpecialAddresses{}, config.Consensus[protocol.ConsensusCurrentVersion])
+ require.ErrorContains(t, err, "go online, but vote last is set to zero")
}
func TestGoNonparticipatingWellFormed(t *testing.T) {
@@ -125,19 +125,17 @@ func TestGoNonparticipatingWellFormed(t *testing.T) {
}
// this tx is well-formed
- feeSink := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
- err = tx.WellFormed(SpecialAddresses{FeeSink: feeSink}, curProto)
+ err = tx.WellFormed(SpecialAddresses{}, curProto)
require.NoError(t, err)
// but it should stop being well-formed if the protocol does not support it
curProto.SupportBecomeNonParticipatingTransactions = false
- err = tx.WellFormed(SpecialAddresses{FeeSink: feeSink}, curProto)
- require.Error(t, err)
+ err = tx.WellFormed(SpecialAddresses{}, curProto)
+ require.ErrorContains(t, err, "mark an account as nonparticipating, but")
}
func TestAppCallCreateWellFormed(t *testing.T) {
partitiontest.PartitionTest(t)
- feeSink := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
curProto := config.Consensus[protocol.ConsensusCurrentVersion]
futureProto := config.Consensus[protocol.ConsensusFuture]
addr1, err := basics.UnmarshalChecksumAddress("NDQCJNNY5WWWFLP4GFZ7MEF2QJSMZYK6OWIV2AQ7OMAVLEFCGGRHFPKJJA")
@@ -253,7 +251,7 @@ func TestAppCallCreateWellFormed(t *testing.T) {
}
for i, usecase := range usecases {
t.Run(fmt.Sprintf("i=%d", i), func(t *testing.T) {
- err := usecase.tx.WellFormed(SpecialAddresses{FeeSink: feeSink}, usecase.proto)
+ err := usecase.tx.WellFormed(SpecialAddresses{}, usecase.proto)
if usecase.expectedError != "" {
require.Error(t, err)
require.Contains(t, err.Error(), usecase.expectedError)
@@ -267,8 +265,6 @@ func TestAppCallCreateWellFormed(t *testing.T) {
func TestWellFormedErrors(t *testing.T) {
partitiontest.PartitionTest(t)
- feeSink := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
- specialAddr := SpecialAddresses{FeeSink: feeSink}
curProto := config.Consensus[protocol.ConsensusCurrentVersion]
futureProto := config.Consensus[protocol.ConsensusFuture]
protoV27 := config.Consensus[protocol.ConsensusV27]
@@ -595,7 +591,7 @@ func TestWellFormedErrors(t *testing.T) {
},
}
for _, usecase := range usecases {
- err := usecase.tx.WellFormed(specialAddr, usecase.proto)
+ err := usecase.tx.WellFormed(SpecialAddresses{}, usecase.proto)
require.Equal(t, usecase.expectedError, err)
}
}
@@ -632,14 +628,12 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
tx := generateDummyGoNonparticpatingTransaction(addr)
curProto := config.Consensus[protocol.ConsensusCurrentVersion]
- feeSink := basics.Address{0x7, 0xda, 0xcb, 0x4b, 0x6d, 0x9e, 0xd1, 0x41, 0xb1, 0x75, 0x76, 0xbd, 0x45, 0x9a, 0xe6, 0x42, 0x1d, 0x48, 0x6d, 0xa3, 0xd4, 0xef, 0x22, 0x47, 0xc4, 0x9, 0xa3, 0x96, 0xb8, 0x2e, 0xa2, 0x21}
- spec := SpecialAddresses{FeeSink: feeSink}
if !curProto.SupportBecomeNonParticipatingTransactions {
t.Skipf("Skipping rest of test because current protocol version %v does not support become-nonparticipating transactions", protocol.ConsensusCurrentVersion)
}
// this tx is well-formed
- err = tx.WellFormed(spec, curProto)
+ err = tx.WellFormed(SpecialAddresses{}, curProto)
require.NoError(t, err)
type keyRegTestCase struct {
@@ -677,7 +671,7 @@ func TestWellFormedKeyRegistrationTx(t *testing.T) {
curProto.EnableKeyregCoherencyCheck = testCase.enableKeyregCoherencyCheck
curProto.EnableStateProofKeyregCheck = testCase.enableStateProofKeyregCheck
curProto.MaxKeyregValidPeriod = maxValidPeriod // TODO: remove this when MaxKeyregValidPeriod is in CurrentVersion
- return tx.WellFormed(spec, curProto)
+ return tx.WellFormed(SpecialAddresses{}, curProto)
}
if *generateFlag == true {
diff --git a/ledger/apply/asset_test.go b/ledger/apply/asset_test.go
index 802c692c82..c096f8aca8 100644
--- a/ledger/apply/asset_test.go
+++ b/ledger/apply/asset_test.go
@@ -90,7 +90,7 @@ func TestAssetTransfer(t *testing.T) {
}
var ad transactions.ApplyData
- err := AssetTransfer(tx.AssetTransferTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, &ad)
+ err := AssetTransfer(tx.AssetTransferTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, &ad)
require.NoError(t, err)
if config.Consensus[protocol.ConsensusCurrentVersion].EnableAssetCloseAmount {
diff --git a/ledger/apply/keyreg_test.go b/ledger/apply/keyreg_test.go
index 7589b9fb1f..bb04e23f90 100644
--- a/ledger/apply/keyreg_test.go
+++ b/ledger/apply/keyreg_test.go
@@ -136,20 +136,20 @@ func TestKeyregApply(t *testing.T) {
// Going from offline to online should be okay
mockBal.addrs[src] = basics.AccountData{Status: basics.Offline}
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
// Going from online to nonparticipatory should be okay, if the protocol supports that
if mockBal.ConsensusParams().SupportBecomeNonParticipatingTransactions {
tx.KeyregTxnFields = transactions.KeyregTxnFields{}
tx.KeyregTxnFields.Nonparticipation = true
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
// Nonparticipatory accounts should not be able to change status
mockBal.addrs[src] = basics.AccountData{Status: basics.NotParticipating}
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
- require.Error(t, err)
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
+ require.ErrorContains(t, err, "cannot change online/offline status of non-participating account")
}
mockBal.version = "future"
@@ -171,25 +171,25 @@ func TestKeyregApply(t *testing.T) {
},
}
mockBal.addrs[src] = basics.AccountData{Status: basics.Offline}
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(999))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(999))
require.NoError(t, err)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1000))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(1000))
require.Equal(t, errKeyregGoingOnlineExpiredParticipationKey, err)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1001))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(1001))
require.Equal(t, errKeyregGoingOnlineExpiredParticipationKey, err)
tx.KeyregTxnFields.VoteFirst = basics.Round(1100)
tx.KeyregTxnFields.VoteLast = basics.Round(1200)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1098))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(1098))
require.Equal(t, errKeyregGoingOnlineFirstVotingInFuture, err)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1099))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(1099))
require.NoError(t, err)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1100))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(1100))
require.NoError(t, err)
testStateProofPKBeingStored(t, tx, mockBal)
@@ -197,7 +197,7 @@ func TestKeyregApply(t *testing.T) {
}
func testStateProofPKBeingStored(t *testing.T, tx transactions.Transaction, mockBal *keyregTestBalances) {
- err := Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(1100))
+ err := Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(1100))
require.NoError(t, err) // expects no error with empty keyRegistration attempt
rec, err := mockBal.Get(tx.Header.Sender, false)
@@ -215,7 +215,7 @@ func TestStateProofPKKeyReg(t *testing.T) {
tx := createTestTxn(t, src, secretParticipation, vrfSecrets)
mockBal := makeMockBalances(protocol.ConsensusV30)
- err := Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err := Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
acct, err := mockBal.Get(tx.Src(), false)
@@ -223,7 +223,7 @@ func TestStateProofPKKeyReg(t *testing.T) {
require.True(t, acct.StateProofID.IsEmpty())
mockBal = makeMockBalances(protocol.ConsensusCurrentVersion)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
acct, err = mockBal.Get(tx.Src(), false)
@@ -232,7 +232,7 @@ func TestStateProofPKKeyReg(t *testing.T) {
// go offline in current consensus version: StateProofID should be empty
emptyKeyreg := transactions.KeyregTxnFields{}
- err = Keyreg(emptyKeyreg, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err = Keyreg(emptyKeyreg, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
acct, err = mockBal.Get(tx.Src(), false)
@@ -241,7 +241,7 @@ func TestStateProofPKKeyReg(t *testing.T) {
// run same test using vFuture
mockBal = makeMockBalances(protocol.ConsensusFuture)
- err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err = Keyreg(tx.KeyregTxnFields, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
acct, err = mockBal.Get(tx.Src(), false)
@@ -249,7 +249,7 @@ func TestStateProofPKKeyReg(t *testing.T) {
require.False(t, acct.StateProofID.IsEmpty())
// go offline in vFuture: StateProofID should be empty
- err = Keyreg(emptyKeyreg, tx.Header, mockBal, transactions.SpecialAddresses{FeeSink: feeSink}, nil, basics.Round(0))
+ err = Keyreg(emptyKeyreg, tx.Header, mockBal, transactions.SpecialAddresses{}, nil, basics.Round(0))
require.NoError(t, err)
acct, err = mockBal.Get(tx.Src(), false)
diff --git a/ledger/apply/payment_test.go b/ledger/apply/payment_test.go
index db82869e23..59b28ad899 100644
--- a/ledger/apply/payment_test.go
+++ b/ledger/apply/payment_test.go
@@ -104,7 +104,7 @@ func TestPaymentApply(t *testing.T) {
},
}
var ad transactions.ApplyData
- err := Payment(tx.PaymentTxnFields, tx.Header, mockBalV0, transactions.SpecialAddresses{FeeSink: feeSink}, &ad)
+ err := Payment(tx.PaymentTxnFields, tx.Header, mockBalV0, transactions.SpecialAddresses{}, &ad)
require.NoError(t, err)
}
diff --git a/ledger/apptxn_test.go b/ledger/apptxn_test.go
index 982c9f01b2..cbdcb1791f 100644
--- a/ledger/apptxn_test.go
+++ b/ledger/apptxn_test.go
@@ -58,6 +58,10 @@ func TestPayAction(t *testing.T) {
itxn_submit
`))
+ // We're going to test some mining effects here too, so that we have an inner transaction example.
+ // Do a block with no txns, so the fee sink balance as we start the next block is stable
+ dl.fullBlock()
+
payout1 := txntest.Txn{
Type: "appl",
Sender: addrs[1],
@@ -65,7 +69,40 @@ func TestPayAction(t *testing.T) {
Accounts: []basics.Address{addrs[1]}, // pay self
}
- dl.fullBlock(&payout1)
+ proposer := addrs[7]
+ presink := micros(dl.t, dl.generator, genBalances.FeeSink)
+ preprop := micros(dl.t, dl.generator, proposer)
+ dl.beginBlock()
+ dl.txns(&payout1)
+ vb := dl.endBlock(proposer)
+ // First MiningPct > 0
+ if ver >= 39 {
+ require.True(t, dl.generator.GenesisProto().EnableMining)
+ require.EqualValues(t, proposer, vb.Block().BlockHeader.Proposer)
+ require.EqualValues(t, 2000, vb.Block().BlockHeader.FeesCollected.Raw)
+ } else {
+ require.False(t, dl.generator.GenesisProto().EnableMining)
+ require.Zero(t, vb.Block().BlockHeader.Proposer)
+ require.Zero(t, vb.Block().BlockHeader.FeesCollected)
+ }
+
+ postsink := micros(dl.t, dl.generator, genBalances.FeeSink)
+ postprop := micros(dl.t, dl.generator, proposer)
+
+ // Mining checks
+ require.EqualValues(t, 0, postprop-preprop) // mining not moved yet
+ require.EqualValues(t, 2000, postsink-presink)
+
+ dl.fullBlock()
+ postsink = micros(dl.t, dl.generator, genBalances.FeeSink)
+ postprop = micros(dl.t, dl.generator, proposer)
+ // First MiningPct > 0
+ if ver >= 39 {
+ require.EqualValues(t, 500, postsink-presink) // based on 75% in config/consensus.go
+ require.EqualValues(t, 1500, postprop-preprop)
+ } else {
+ require.EqualValues(t, 2000, postsink-presink) // no mining yet
+ }
ad0 := micros(dl.t, dl.generator, addrs[0])
ad1 := micros(dl.t, dl.generator, addrs[1])
@@ -90,7 +127,7 @@ func TestPayAction(t *testing.T) {
ApplicationID: ai,
Accounts: []basics.Address{addrs[2]}, // pay other
}
- vb := dl.fullBlock(&payout2)
+ vb = dl.fullBlock(&payout2)
// confirm that modifiedAccounts can see account in inner txn
deltas := vb.Delta()
diff --git a/ledger/double_test.go b/ledger/double_test.go
index 16d38e7681..419a8da55f 100644
--- a/ledger/double_test.go
+++ b/ledger/double_test.go
@@ -48,6 +48,9 @@ type DoubleLedger struct {
validator *Ledger
eval *eval.BlockEvaluator
+
+ // proposer is the default proposer unless one is supplied to endBlock.
+ proposer basics.Address
}
func (dl DoubleLedger) Close() {
@@ -59,7 +62,7 @@ func (dl DoubleLedger) Close() {
func NewDoubleLedger(t testing.TB, balances bookkeeping.GenesisBalances, cv protocol.ConsensusVersion, cfg config.Local, opts ...simpleLedgerOption) DoubleLedger {
g := newSimpleLedgerWithConsensusVersion(t, balances, cv, cfg, opts...)
v := newSimpleLedgerFull(t, balances, cv, g.GenesisHash(), cfg, opts...)
- return DoubleLedger{t, g, v, nil}
+ return DoubleLedger{t, g, v, nil, balances.FeeSink} // FeeSink as proposer will make old code work as expected
}
func (dl *DoubleLedger) beginBlock() *eval.BlockEvaluator {
@@ -134,8 +137,12 @@ func (dl *DoubleLedger) fullBlock(txs ...*txntest.Txn) *ledgercore.ValidatedBloc
return dl.endBlock()
}
-func (dl *DoubleLedger) endBlock() *ledgercore.ValidatedBlock {
- vb := endBlock(dl.t, dl.generator, dl.eval)
+func (dl *DoubleLedger) endBlock(proposer ...basics.Address) *ledgercore.ValidatedBlock {
+ prp := dl.proposer
+ if len(proposer) > 0 {
+ prp = proposer[0]
+ }
+ vb := endBlock(dl.t, dl.generator, dl.eval, prp)
if dl.validator != nil { // Allows setting to nil while debugging, to simplify
checkBlock(dl.t, dl.validator, vb)
}
@@ -195,7 +202,7 @@ func checkBlock(t testing.TB, checkLedger *Ledger, vb *ledgercore.ValidatedBlock
require.NoError(t, err, "%+v", reconstituted.Payset)
}
check.SetGenerateForTesting(true)
- cb := endBlock(t, checkLedger, check)
+ cb := endBlock(t, checkLedger, check, vb.Block().Proposer)
check.SetGenerateForTesting(false)
require.Equal(t, vb.Block(), cb.Block())
diff --git a/ledger/eval/applications.go b/ledger/eval/applications.go
index 5419bc9525..36d0734ec2 100644
--- a/ledger/eval/applications.go
+++ b/ledger/eval/applications.go
@@ -290,8 +290,7 @@ func (cs *roundCowState) DelBox(appIdx basics.AppIndex, key string, appAddr basi
func (cs *roundCowState) Perform(gi int, ep *logic.EvalParams) error {
txn := &ep.TxnGroup[gi]
- // move fee to pool
- err := cs.Move(txn.Txn.Sender, ep.Specials.FeeSink, txn.Txn.Fee, &txn.ApplyData.SenderRewards, nil)
+ err := cs.takeFee(&txn.Txn, &txn.ApplyData.SenderRewards, ep)
if err != nil {
return err
}
diff --git a/ledger/eval/cow.go b/ledger/eval/cow.go
index d797a4a560..1d48d8abf7 100644
--- a/ledger/eval/cow.go
+++ b/ledger/eval/cow.go
@@ -93,6 +93,8 @@ type roundCowState struct {
// prevTotals contains the accounts totals for the previous round. It's being used to calculate the totals for the new round
// so that we could perform the validation test on these to ensure the block evaluator generate a valid changeset.
prevTotals ledgercore.AccountTotals
+
+ feesCollected basics.MicroAlgos
}
var childPool = sync.Pool{
@@ -293,6 +295,8 @@ func (cb *roundCowState) commitToParent() {
cb.commitParent.mods.Txids[txid] = ledgercore.IncludedTransactions{LastValid: incTxn.LastValid, Intra: commitParentBaseIdx + incTxn.Intra}
}
cb.commitParent.txnCount += cb.txnCount
+ // no overflow because of 10B algo cap
+ cb.commitParent.feesCollected, _ = basics.OAddA(cb.commitParent.feesCollected, cb.feesCollected)
for txl, expires := range cb.mods.Txleases {
cb.commitParent.mods.AddTxLease(txl, expires)
@@ -336,6 +340,7 @@ func (cb *roundCowState) reset() {
cb.compatibilityMode = false
maps.Clear(cb.compatibilityGetKeyCache)
cb.prevTotals = ledgercore.AccountTotals{}
+ cb.feesCollected = basics.MicroAlgos{}
}
// recycle resets the roundcowstate and returns it to the sync.Pool
diff --git a/ledger/eval/cow_test.go b/ledger/eval/cow_test.go
index 225b037997..eb4bc5e38b 100644
--- a/ledger/eval/cow_test.go
+++ b/ledger/eval/cow_test.go
@@ -281,6 +281,7 @@ func TestCowChildReflect(t *testing.T) {
"compatibilityMode": {},
"compatibilityGetKeyCache": {},
"prevTotals": {},
+ "feesCollected": {},
}
cow := roundCowState{}
@@ -288,7 +289,7 @@ func TestCowChildReflect(t *testing.T) {
st := v.Type()
for i := 0; i < v.NumField(); i++ {
reflectedCowName := st.Field(i).Name
- require.Containsf(t, cowFieldNames, reflectedCowName, "new field:\"%v\" added to roundCowState, please update roundCowState.reset() to handle it before fixing the test", reflectedCowName)
+ require.Containsf(t, cowFieldNames, reflectedCowName, "new field:\"%v\" added to roundCowState, please update roundCowState.reset() to handle it before fixing this test", reflectedCowName)
}
}
diff --git a/ledger/eval/eval.go b/ledger/eval/eval.go
index 5fc72ff54e..2e7e83f09b 100644
--- a/ledger/eval/eval.go
+++ b/ledger/eval/eval.go
@@ -783,6 +783,13 @@ func StartEvaluator(l LedgerForEvaluator, hdr bookkeeping.BlockHeader, evalOpts
return nil, fmt.Errorf("overflowed subtracting rewards for block %v", hdr.Round)
}
+ miningIncentive, _ := basics.NewPercent(proto.MiningPercent).DivvyAlgos(prevHeader.FeesCollected)
+ err = eval.state.Move(prevHeader.FeeSink, prevHeader.Proposer, miningIncentive, nil, nil)
+ if err != nil {
+ // This should be impossible. The fees were just collected, and the FeeSink cannot be emptied.
+ return nil, fmt.Errorf("unable to Move mining incentive")
+ }
+
if eval.Tracer != nil {
eval.Tracer.BeforeBlock(&eval.block.BlockHeader)
}
@@ -1160,12 +1167,27 @@ func (eval *BlockEvaluator) transaction(txn transactions.SignedTxn, evalParams *
return nil
}
+func (cs *roundCowState) takeFee(tx *transactions.Transaction, senderRewards *basics.MicroAlgos, ep *logic.EvalParams) error {
+ err := cs.Move(tx.Sender, ep.Specials.FeeSink, tx.Fee, senderRewards, nil)
+ if err != nil {
+ return err
+ }
+ // transactions from FeeSink should be exceedingly rare. But we can't count
+ // them in feesCollected because there are no net algos added to the Sink
+ if tx.Sender == ep.Specials.FeeSink {
+ return nil
+ }
+ // overflow impossible, since these sum the fees actually paid. 10B algo limit
+ cs.feesCollected, _ = basics.OAddA(cs.feesCollected, tx.Fee)
+ return nil
+
+}
+
// applyTransaction changes the balances according to this transaction.
func (eval *BlockEvaluator) applyTransaction(tx transactions.Transaction, cow *roundCowState, evalParams *logic.EvalParams, gi int, ctr uint64) (ad transactions.ApplyData, err error) {
params := cow.ConsensusParams()
- // move fee to pool
- err = cow.Move(tx.Sender, eval.specials.FeeSink, tx.Fee, &ad.SenderRewards, nil)
+ err = cow.takeFee(&tx, &ad.SenderRewards, evalParams)
if err != nil {
return
}
@@ -1267,6 +1289,10 @@ func (eval *BlockEvaluator) endOfBlock() error {
eval.block.TxnCounter = 0
}
+ if eval.proto.EnableMining {
+ eval.block.FeesCollected = eval.state.feesCollected
+ }
+
eval.generateExpiredOnlineAccountsList()
if eval.proto.StateProofInterval > 0 {
@@ -1311,6 +1337,14 @@ func (eval *BlockEvaluator) endOfBlock() error {
return fmt.Errorf("txn count wrong: %d != %d", eval.block.TxnCounter, expectedTxnCount)
}
+ var expectedFeesCollected basics.MicroAlgos
+ if eval.proto.EnableMining {
+ expectedFeesCollected = eval.state.feesCollected
+ }
+ if eval.block.FeesCollected != expectedFeesCollected {
+ return fmt.Errorf("fees collected wrong: %v != %v", eval.block.FeesCollected, expectedFeesCollected)
+ }
+
expectedVoters, expectedVotersWeight, err2 := eval.stateProofVotersAndTotal()
if err2 != nil {
return err2
diff --git a/ledger/eval/prefetcher/prefetcher_alignment_test.go b/ledger/eval/prefetcher/prefetcher_alignment_test.go
index 81ce168d43..c64ae6d3db 100644
--- a/ledger/eval/prefetcher/prefetcher_alignment_test.go
+++ b/ledger/eval/prefetcher/prefetcher_alignment_test.go
@@ -58,6 +58,10 @@ func rewardsPool() basics.Address {
return makeAddress(101)
}
+func proposer() basics.Address {
+ return basics.Address{}
+}
+
func genesisBlock() (bookkeeping.Block, error) {
block, err := bookkeeping.MakeGenesisBlock(
proto,
@@ -261,6 +265,18 @@ type ledgerData struct {
Creators map[creatable]struct{}
}
+// pretend adds the `before` addresses to the Accounts. It "pretends" that the
+// addresses were prefetched, so we can get agreement with what was actually
+// requested. We do this to include two addresses that are going to end up
+// requested *before* prefetch is even attempted. So there's no point in
+// PrefetchAccounts being modified to return them, they have been "prefetched"
+// simply by accessing them.
+func (ld *ledgerData) pretend(before ...basics.Address) {
+ for _, a := range before {
+ ld.Accounts[a] = struct{}{}
+ }
+}
+
func prefetch(t *testing.T, l prefetcher.Ledger, txn transactions.Transaction) ledgerData {
group := makeGroupFromTxn(txn)
@@ -361,7 +377,7 @@ func TestEvaluatorPrefetcherAlignmentPayment(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -393,7 +409,7 @@ func TestEvaluatorPrefetcherAlignmentCreateAsset(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
// Only one (non-existing) asset is requested. Ignore it.
require.Len(t, requested.Assets, 1)
require.Len(t, requested.Assets[makeAddress(1)], 1)
@@ -449,7 +465,7 @@ func TestEvaluatorPrefetcherAlignmentReconfigAsset(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -504,7 +520,7 @@ func TestEvaluatorPrefetcherAlignmentAssetOptIn(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -570,7 +586,7 @@ func TestEvaluatorPrefetcherAlignmentAssetOptInCloseTo(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -641,7 +657,7 @@ func TestEvaluatorPrefetcherAlignmentAssetTransfer(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
// zero transfer of any asset
@@ -660,7 +676,7 @@ func TestEvaluatorPrefetcherAlignmentAssetTransfer(t *testing.T) {
requested, prefetched = run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -741,7 +757,7 @@ func TestEvaluatorPrefetcherAlignmentAssetClawback(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -811,7 +827,7 @@ func TestEvaluatorPrefetcherAlignmentAssetFreeze(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -858,7 +874,7 @@ func TestEvaluatorPrefetcherAlignmentKeyreg(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -895,7 +911,7 @@ func TestEvaluatorPrefetcherAlignmentCreateApplication(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
// Only one (non-existing) asset is requested. Ignore it.
require.Len(t, requested.Apps, 1)
require.Len(t, requested.Apps[makeAddress(1)], 1)
@@ -953,7 +969,7 @@ func TestEvaluatorPrefetcherAlignmentDeleteApplication(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -1011,7 +1027,7 @@ func TestEvaluatorPrefetcherAlignmentApplicationOptIn(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -1075,7 +1091,7 @@ func TestEvaluatorPrefetcherAlignmentApplicationCloseOut(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -1139,7 +1155,7 @@ func TestEvaluatorPrefetcherAlignmentApplicationClearState(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
@@ -1203,7 +1219,7 @@ func TestEvaluatorPrefetcherAlignmentApplicationCallAccountsDeclaration(t *testi
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
// Foreign accounts are not loaded, ensure they are not prefetched
require.NotContains(t, prefetched.Accounts, makeAddress(5))
require.NotContains(t, prefetched.Accounts, makeAddress(3))
@@ -1271,7 +1287,7 @@ func TestEvaluatorPrefetcherAlignmentApplicationCallForeignAppsDeclaration(t *te
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
// Foreign apps are not loaded, ensure they are not prefetched
require.NotContains(t, prefetched.Creators, creatable{cindex: 6, ctype: basics.AppCreatable})
require.NotContains(t, prefetched.Creators, creatable{cindex: 8, ctype: basics.AppCreatable})
@@ -1338,7 +1354,7 @@ func TestEvaluatorPrefetcherAlignmentApplicationCallForeignAssetsDeclaration(t *
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
// Foreign apps are not loaded, ensure they are not prefetched
require.NotContains(t, prefetched.Creators, creatable{cindex: 6, ctype: basics.AssetCreatable})
require.NotContains(t, prefetched.Creators, creatable{cindex: 8, ctype: basics.AssetCreatable})
@@ -1385,6 +1401,6 @@ func TestEvaluatorPrefetcherAlignmentStateProof(t *testing.T) {
requested, prefetched := run(t, l, txn)
- prefetched.Accounts[rewardsPool()] = struct{}{}
+ prefetched.pretend(rewardsPool(), proposer())
require.Equal(t, requested, prefetched)
}
diff --git a/ledger/eval_simple_test.go b/ledger/eval_simple_test.go
index 606ee4931d..86269cabd5 100644
--- a/ledger/eval_simple_test.go
+++ b/ledger/eval_simple_test.go
@@ -211,6 +211,67 @@ func TestBlockEvaluator(t *testing.T) {
require.Equal(t, bal2new.MicroAlgos.Raw, bal2.MicroAlgos.Raw-minFee.Raw)
}
+// TestMiningFees ensures that the proper portion of tx fees go to the proposer,
+// starting in v39.
+func TestMiningFees(t *testing.T) {
+ partitiontest.PartitionTest(t)
+ t.Parallel()
+
+ genBalances, addrs, _ := ledgertesting.NewTestGenesis()
+ // Mining begins in v39. Start checking in v38 to test that is unchanged.
+ ledgertesting.TestConsensusRange(t, 38, 0, func(t *testing.T, ver int, cv protocol.ConsensusVersion, cfg config.Local) {
+ dl := NewDoubleLedger(t, genBalances, cv, cfg)
+ defer dl.Close()
+
+ dl.fullBlock()
+
+ pay := txntest.Txn{
+ Type: "pay",
+ Sender: addrs[1],
+ Receiver: addrs[2],
+ Amount: 100000,
+ }
+
+ proposer := addrs[7]
+ presink := micros(dl.t, dl.generator, genBalances.FeeSink)
+ preprop := micros(dl.t, dl.generator, proposer)
+ dl.beginBlock()
+ dl.txns(&pay, pay.Args("again"))
+ vb := dl.endBlock(proposer)
+
+ if ver >= 39 {
+ require.True(t, dl.generator.GenesisProto().EnableMining) // version sanity check
+ // new fields are in the header
+ require.EqualValues(t, proposer, vb.Block().BlockHeader.Proposer)
+ require.EqualValues(t, 2000, vb.Block().BlockHeader.FeesCollected.Raw)
+ } else {
+ require.False(t, dl.generator.GenesisProto().EnableMining)
+ // new fields are not in the header
+ require.Zero(t, vb.Block().BlockHeader.Proposer)
+ require.Zero(t, vb.Block().BlockHeader.FeesCollected)
+ }
+
+ postsink := micros(dl.t, dl.generator, genBalances.FeeSink)
+ postprop := micros(dl.t, dl.generator, proposer)
+
+ // At the end of the block, all fees are still in the sink.
+ require.EqualValues(t, 2000, postsink-presink)
+ require.EqualValues(t, 0, postprop-preprop)
+
+ // Do the next block, which moves part of the fees to proposer
+ dl.fullBlock()
+ postsink = micros(dl.t, dl.generator, genBalances.FeeSink)
+ postprop = micros(dl.t, dl.generator, proposer)
+
+ if ver >= 39 {
+ require.EqualValues(t, 500, postsink-presink) // based on 75% in config/consensus.go
+ require.EqualValues(t, 1500, postprop-preprop)
+ } else {
+ require.EqualValues(t, 2000, postsink-presink) // no mining yet
+ }
+ })
+}
+
// TestHoldingGet tests some of the corner cases for the asset_holding_get
// opcode: the asset doesn't exist, the account doesn't exist, account not opted
// in, vs it has none of the asset. This is tested here, even though it should
diff --git a/ledger/ledger_test.go b/ledger/ledger_test.go
index a25e92f87e..8dffc34088 100644
--- a/ledger/ledger_test.go
+++ b/ledger/ledger_test.go
@@ -174,6 +174,9 @@ func (l *Ledger) appendUnvalidatedSignedTx(t *testing.T, initAccounts map[basics
if proto.TxnCounter {
blk.TxnCounter = blk.TxnCounter + 1
}
+ if proto.EnableMining {
+ blk.FeesCollected = stx.Txn.Fee
+ }
blk.Payset = append(blk.Payset, txib)
blk.TxnCommitments, err = blk.PaysetCommit()
require.NoError(t, err)
diff --git a/ledger/ledgercore/validatedBlock.go b/ledger/ledgercore/validatedBlock.go
index 84d09e2a9a..ced5265635 100644
--- a/ledger/ledgercore/validatedBlock.go
+++ b/ledger/ledgercore/validatedBlock.go
@@ -17,6 +17,7 @@
package ledgercore
import (
+ "github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/bookkeeping"
"github.com/algorand/go-algorand/data/committee"
)
@@ -39,11 +40,15 @@ func (vb ValidatedBlock) Delta() StateDelta {
return vb.delta
}
-// WithSeed returns a copy of the ValidatedBlock with a modified seed.
-func (vb ValidatedBlock) WithSeed(s committee.Seed) ValidatedBlock {
+// WithSeed returns a copy of the ValidatedBlock with a modified seed and associated proposer
+func (vb ValidatedBlock) WithSeed(s committee.Seed, proposer basics.Address) ValidatedBlock {
newblock := vb.blk
newblock.BlockHeader.Seed = s
+ if vb.blk.ConsensusProtocol().EnableMining {
+ newblock.BlockHeader.Proposer = proposer
+ }
+
return ValidatedBlock{
blk: newblock,
delta: vb.delta,
diff --git a/ledger/simple_test.go b/ledger/simple_test.go
index 1f4c612902..efe81bfc87 100644
--- a/ledger/simple_test.go
+++ b/ledger/simple_test.go
@@ -26,6 +26,7 @@ import (
"github.com/algorand/go-algorand/crypto"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/bookkeeping"
+ "github.com/algorand/go-algorand/data/committee"
"github.com/algorand/go-algorand/data/transactions"
"github.com/algorand/go-algorand/data/txntest"
"github.com/algorand/go-algorand/ledger/eval"
@@ -136,11 +137,20 @@ func txgroup(t testing.TB, ledger *Ledger, eval *eval.BlockEvaluator, txns ...*t
return eval.TransactionGroup(transactions.WrapSignedTxnsWithAD(txgroup))
}
-// endBlock completes the block being created, returns the ValidatedBlock for inspection
-func endBlock(t testing.TB, ledger *Ledger, eval *eval.BlockEvaluator) *ledgercore.ValidatedBlock {
- validatedBlock, err := eval.GenerateBlock()
+// endBlock completes the block being created, returns the ValidatedBlock for
+// inspection. Proposer is optional - if unset, blocks will be finished with
+// ZeroAddress proposer.
+func endBlock(t testing.TB, ledger *Ledger, eval *eval.BlockEvaluator, proposer ...basics.Address) *ledgercore.ValidatedBlock {
+ vb, err := eval.GenerateBlock()
require.NoError(t, err)
- err = ledger.AddValidatedBlock(*validatedBlock, agreement.Certificate{})
+
+ var prp basics.Address
+ if len(proposer) > 0 {
+ prp = proposer[0]
+ }
+ *vb = vb.WithSeed(committee.Seed{}, prp)
+
+ err = ledger.AddValidatedBlock(*vb, agreement.Certificate{})
require.NoError(t, err)
// `rndBQ` gives the latest known block round added to the ledger
// we should wait until `rndBQ` block to be committed to blockQueue,
@@ -152,7 +162,7 @@ func endBlock(t testing.TB, ledger *Ledger, eval *eval.BlockEvaluator) *ledgerco
// then we return the result and continue the execution.
rndBQ := ledger.Latest()
ledger.WaitForCommit(rndBQ)
- return validatedBlock
+ return vb
}
// main wraps up some TEAL source in a header and footer so that it is
diff --git a/node/node.go b/node/node.go
index 4c18ad1d51..63815f08eb 100644
--- a/node/node.go
+++ b/node/node.go
@@ -1271,8 +1271,8 @@ type validatedBlock struct {
}
// WithSeed satisfies the agreement.ValidatedBlock interface.
-func (vb validatedBlock) WithSeed(s committee.Seed) agreement.ValidatedBlock {
- lvb := vb.vb.WithSeed(s)
+func (vb validatedBlock) WithSeed(s committee.Seed, proposer basics.Address) agreement.ValidatedBlock {
+ lvb := vb.vb.WithSeed(s, proposer)
return validatedBlock{vb: &lvb}
}
diff --git a/test/scripts/e2e_client_runner.py b/test/scripts/e2e_client_runner.py
index 7b425ef925..15a877e043 100755
--- a/test/scripts/e2e_client_runner.py
+++ b/test/scripts/e2e_client_runner.py
@@ -114,7 +114,7 @@ def _script_thread_inner(runset, scriptname, timeout):
params = algod.suggested_params()
round = params.first
max_init_wait_rounds = 5
- txn = algosdk.transaction.PaymentTxn(sender=maxpubaddr, fee=params.min_fee, first=round, last=round+max_init_wait_rounds, gh=params.gh, receiver=addr, amt=1000000000000, flat_fee=True)
+ txn = algosdk.transaction.PaymentTxn(sender=maxpubaddr, fee=params.min_fee, first=round, last=round+max_init_wait_rounds, gh=params.gh, receiver=addr, amt=1_000_000_000_000, flat_fee=True)
stxn = kmd.sign_transaction(pubw, '', txn)
txid = algod.send_transaction(stxn)
ptxinfo = None
diff --git a/test/scripts/e2e_subs/goal/goal.py b/test/scripts/e2e_subs/goal/goal.py
index d36241fd78..605f732eb7 100755
--- a/test/scripts/e2e_subs/goal/goal.py
+++ b/test/scripts/e2e_subs/goal/goal.py
@@ -229,19 +229,19 @@ def finish(self, tx, send):
def keyreg(self, sender, votekey=None, selkey=None, votefst=None,
votelst=None, votekd=None,
send=None, **kwargs):
- params = self.algod.suggested_params()
+ params = self.params(kwargs.pop("lifetime", 1000))
tx = txn.KeyregTxn(sender, params,
votekey, selkey, votefst, votelst, votekd,
**kwargs)
return self.finish(tx, send)
def pay(self, sender, receiver, amt: int, send=None, **kwargs):
- params = self.algod.suggested_params()
+ params = self.params(kwargs.pop("lifetime", 1000))
tx = txn.PaymentTxn(sender, params, receiver, amt, **kwargs)
return self.finish(tx, send)
def acfg(self, sender, send=None, **kwargs):
- params = self.algod.suggested_params()
+ params = self.params(kwargs.pop("lifetime", 1000))
tx = txn.AssetConfigTxn(
sender, params, **kwargs, strict_empty_address_check=False
)
@@ -252,7 +252,7 @@ def asset_create(self, sender, **kwargs):
return self.acfg(sender, **kwargs)
def axfer(self, sender, receiver, amt: int, index: int, send=None, **kwargs):
- params = self.algod.suggested_params()
+ params = self.params(kwargs.pop("lifetime", 1000))
tx = txn.AssetTransferTxn(
sender, params, receiver, amt, index, **kwargs
)
@@ -263,7 +263,7 @@ def asset_optin(self, sender, index: int, **kwargs):
return self.axfer(sender, sender, 0, index, **kwargs)
def afrz(self, sender, index: int, target, frozen, send=None, **kwargs):
- params = self.algod.suggested_params()
+ params = self.params(kwargs.pop("lifetime", 1000))
tx = txn.AssetFreezeTxn(sender, params, index, target, frozen, **kwargs)
return self.finish(tx, send)
@@ -274,9 +274,15 @@ def coerce_schema(self, values):
return values
return txn.StateSchema(num_uints=values[0], num_byte_slices=values[1])
+
+ def params(self, lifetime):
+ params = self.algod.suggested_params()
+ params.last = params.first + lifetime
+ return params
+
def appl(self, sender, index: int, on_complete=txn.OnComplete.NoOpOC,
send=None, **kwargs):
- params = self.algod.suggested_params()
+ params = self.params(kwargs.pop("lifetime", 1000))
local_schema = self.coerce_schema(kwargs.pop("local_schema", None))
global_schema = self.coerce_schema(kwargs.pop("global_schema", None))
tx = txn.ApplicationCallTxn(
diff --git a/test/scripts/e2e_subs/mining.py b/test/scripts/e2e_subs/mining.py
new file mode 100755
index 0000000000..79b23e9fd2
--- /dev/null
+++ b/test/scripts/e2e_subs/mining.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+
+import base64
+import os
+import sys
+from goal import Goal
+import algosdk.encoding as enc
+
+from datetime import datetime
+
+stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+print(f"{os.path.basename(sys.argv[0])} start {stamp}")
+
+goal = Goal(sys.argv[1], autosend=True)
+
+joe = goal.new_account()
+
+_, err = goal.pay(goal.account, joe, amt=500_000)
+assert not err, err
+
+# Turn off rewards for precise balance checking
+_, err = goal.keyreg(joe, nonpart=True)
+assert not err, err
+
+get_proposer = """
+#pragma version 10
+ txn ApplicationArgs 0; btoi
+ block BlkProposer; global ZeroAddress; !=; assert
+
+ txn ApplicationArgs 0; btoi
+ block BlkProposer; log
+
+ txn ApplicationArgs 0; btoi
+ block BlkFeesCollected; itob; log
+
+ int 1
+"""
+
+
+
+# During construction, the app examines an arbitrary round, a little before the latest.
+examined = max(goal.params(1).first-5, 1)
+txinfo, err = goal.app_create(joe, goal.assemble(get_proposer), app_args=[examined], lifetime=50)
+assert not err, err
+getter = txinfo['application-index']
+assert getter
+
+# There should be two logs, the proposer of the examined round, and the fees from that round
+rnd = txinfo['confirmed-round']
+# Look at the block of the creation. We know fees collected is non-zero
+block = goal.algod.block_info(rnd)['block']
+assert "fc" in block
+assert block["fc"] > 0 # We don't test exact, because other tests are running
+assert "prp" in block
+assert block["prp"] != "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ"
+
+create_proposer = block["prp"]
+immediately_after = goal.balance(create_proposer)
+assert immediately_after > 10000000 # Our proposers in e2e tests have pretty much all the money
+
+# Compare the examined block's header to what the AVM saw (and logged)
+block = goal.algod.block_info(examined)['block']
+print("creation", txinfo['logs'], block)
+assert base64.b64decode(txinfo['logs'][0]) == enc.decode_address(block['prp'])
+assert base64.b64decode(txinfo['logs'][1]) == block.get('fc',0).to_bytes(8, "big")
+
+# Now have the app examine the round the app was constructed, so we
+# can check the log and know there should be a fee.
+goal.wait_for_block(rnd+1) # because fv is set to current latest (rnd), so it `block rnd` wouldn't work
+txinfo, err = goal.app_call(joe, getter, app_args=[rnd], lifetime=10)
+assert not err, err
+
+block = goal.algod.block_info(rnd)['block']
+# note we use block['fc'], not block.get('fc', 0)
+print("call", txinfo['logs'], block)
+assert base64.b64decode(txinfo['logs'][0]) == enc.decode_address(block['prp'])
+assert base64.b64decode(txinfo['logs'][1]) == block['fc'].to_bytes(8, "big")
+
+# Now let's confirm the proposer got paid. It's somewhat tricky,
+# because in our e2e tests, we have only two proposers, and their
+# balances may be changing all the time, because e2e_client_runner is
+# taking out 1M algos at a time to run parallel subtests. We'll work
+# with the balance mod 1M, so we can see the small fees being added to
+# it, even if the blance has dropped by 1M.
+after_mining_credit = goal.balance(create_proposer)
+assertion = str(after_mining_credit)+" > "+str(immediately_after)
+print("credit", assertion)
+M = 1_000_000
+assert after_mining_credit % M > immediately_after % M, assertion
+
+stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+print(f"{os.path.basename(sys.argv[0])} OK {stamp}")