Merge pull request #4414 from onetechnical/relbeta3.9.1v3.9.1-beta

16 files changed, 394 insertions, 267 deletions

diff --git a/buildnumber.dat b/buildnumber.dat
index 573541ac9..d00491fd7 100644
--- a/buildnumber.dat
+++ b/buildnumber.dat
@@ -1 +1 @@
-0
+1
diff --git a/catchup/catchpointService.go b/catchup/catchpointService.go
index 5d01fa960..99031a0c1 100644
--- a/catchup/catchpointService.go
+++ b/catchup/catchpointService.go
@@ -19,10 +19,11 @@ package catchup
 import (
 	"context"
 	"fmt"
-	"github.com/algorand/go-algorand/stateproof"
 	"sync"
 	"time"
 
+	"github.com/algorand/go-algorand/stateproof"
+
 	"github.com/algorand/go-deadlock"
 
 	"github.com/algorand/go-algorand/config"
@@ -473,8 +474,10 @@ func lookbackForStateproofsSupport(topBlock *bookkeeping.Block) uint64 {
 		return 0
 	}
 	lowestStateProofRound := stateproof.GetOldestExpectedStateProof(&topBlock.BlockHeader)
-	// in order to be able to confirm lowestStateProofRound we need to have round number: (lowestStateProofRound - stateproofInterval)
+	// in order to be able to confirm/build lowestStateProofRound we would need to reconstruct
+	// the corresponding voterForRound which is (lowestStateProofRound - stateproofInterval - VotersLookback)
 	lowestStateProofRound = lowestStateProofRound.SubSaturate(basics.Round(proto.StateProofInterval))
+	lowestStateProofRound = lowestStateProofRound.SubSaturate(basics.Round(proto.StateProofVotersLookback))
 	return uint64(topBlock.Round().SubSaturate(lowestStateProofRound))
 }
 
@@ -497,6 +500,7 @@ func (cs *CatchpointCatchupService) processStageBlocksDownload() (err error) {
 	if lookback < lookbackForStateProofSupport {
 		lookback = lookbackForStateProofSupport
 	}
+
 	// in case the effective lookback is going before our rounds count, trim it there.
 	// ( a catchpoint is generated starting round MaxBalLookback, and this is a possible in any round in the range of MaxBalLookback..MaxTxnLife)
 	if lookback >= uint64(topBlock.Round()) {
@@ -586,9 +590,12 @@ func (cs *CatchpointCatchupService) processStageBlocksDownload() (err error) {
 			return cs.abort(fmt.Errorf("processStageBlocksDownload: downloaded block content does not match downloaded block header"))
 		}
 
-		cs.updateBlockRetrievalStatistics(0, 1)
-		peerRank := cs.blocksDownloadPeerSelector.peerDownloadDurationToRank(psp, blockDownloadDuration)
-		cs.blocksDownloadPeerSelector.rankPeer(psp, peerRank)
+		if psp != nil {
+			// the block might have been retrieved from the local ledger, nothing to rank
+			cs.updateBlockRetrievalStatistics(0, 1)
+			peerRank := cs.blocksDownloadPeerSelector.peerDownloadDurationToRank(psp, blockDownloadDuration)
+			cs.blocksDownloadPeerSelector.rankPeer(psp, peerRank)
+		}
 
 		// all good, persist and move on.
 		err = cs.ledgerAccessor.StoreBlock(cs.ctx, blk)
diff --git a/catchup/service_test.go b/catchup/service_test.go
index 679ee3239..676a283ba 100644
--- a/catchup/service_test.go
+++ b/catchup/service_test.go
@@ -988,7 +988,7 @@ func TestDownloadBlocksToSupportStateProofs(t *testing.T) {
 
 	lookback := lookbackForStateproofsSupport(&topBlk)
 	oldestRound := topBlk.BlockHeader.Round.SubSaturate(basics.Round(lookback))
-	assert.Equal(t, uint64(oldestRound), 512-config.Consensus[protocol.ConsensusFuture].StateProofInterval)
+	assert.Equal(t, uint64(oldestRound), 512-config.Consensus[protocol.ConsensusFuture].StateProofInterval-config.Consensus[protocol.ConsensusFuture].StateProofVotersLookback)
 
 	// the network has made progress and now it is on round 8000. in this case we would not download blocks to cover 512.
 	// instead, we will download blocks to confirm only the recovery period lookback.
@@ -1002,7 +1002,9 @@ func TestDownloadBlocksToSupportStateProofs(t *testing.T) {
 	lookback = lookbackForStateproofsSupport(&topBlk)
 	oldestRound = topBlk.BlockHeader.Round.SubSaturate(basics.Round(lookback))
 
-	lowestRoundToRetain := 8000 - (8000 % 256) - (config.Consensus[protocol.ConsensusCurrentVersion].StateProofInterval * (config.Consensus[protocol.ConsensusCurrentVersion].StateProofMaxRecoveryIntervals + 1))
+	lowestRoundToRetain := 8000 - (8000 % config.Consensus[protocol.ConsensusCurrentVersion].StateProofInterval) -
+		config.Consensus[protocol.ConsensusCurrentVersion].StateProofInterval*(config.Consensus[protocol.ConsensusCurrentVersion].StateProofMaxRecoveryIntervals+1) - config.Consensus[protocol.ConsensusFuture].StateProofVotersLookback
+
 	assert.Equal(t, uint64(oldestRound), lowestRoundToRetain)
 
 	topBlk = bookkeeping.Block{}
diff --git a/daemon/algod/api/algod.oas2.json b/daemon/algod/api/algod.oas2.json
index c95c0dbd1..9af8a2aef 100644
--- a/daemon/algod/api/algod.oas2.json
+++ b/daemon/algod/api/algod.oas2.json
@@ -2683,42 +2683,7 @@
       ],
       "properties": {
         "Message": {
-          "description": "Represents the message that the state proofs are attesting to.",
-          "type": "object",
-          "required": [
-            "BlockHeadersCommitment",
-            "VotersCommitment",
-            "LnProvenWeight",
-            "FirstAttestedRound",
-            "LastAttestedRound"
-          ],
-          "properties": {
-            "BlockHeadersCommitment": {
-              "description": "The vector commitment root on all light block headers within a state proof interval.",
-              "type": "string",
-              "format": "byte"
-            },
-            "VotersCommitment": {
-              "description": "The vector commitment root of the top N accounts to sign the next StateProof.",
-              "type": "string",
-              "format": "byte"
-            },
-            "LnProvenWeight": {
-              "description": "An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.",
-              "type": "integer",
-              "x-algorand-format": "uint64"
-            },
-            "FirstAttestedRound": {
-              "description": "The first round the message attests to.",
-              "type": "integer",
-              "x-algorand-format": "uint64"
-            },
-            "LastAttestedRound": {
-              "description": "The last round the message attests to.",
-              "type": "integer",
-              "x-algorand-format": "uint64"
-            }
-          }
+          "$ref": "#/definitions/StateProofMessage"
         },
         "StateProof": {
           "description": "The encoded StateProof for the message.",
@@ -2750,6 +2715,44 @@
           "format": "byte"
         }
       }
+    },
+    "StateProofMessage": {
+      "description": "Represents the message that the state proofs are attesting to.",
+      "type": "object",
+      "required": [
+        "BlockHeadersCommitment",
+        "VotersCommitment",
+        "LnProvenWeight",
+        "FirstAttestedRound",
+        "LastAttestedRound"
+      ],
+      "properties": {
+        "BlockHeadersCommitment": {
+          "description": "The vector commitment root on all light block headers within a state proof interval.",
+          "type": "string",
+          "format": "byte"
+        },
+        "VotersCommitment": {
+          "description": "The vector commitment root of the top N accounts to sign the next StateProof.",
+          "type": "string",
+          "format": "byte"
+        },
+        "LnProvenWeight": {
+          "description": "An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.",
+          "type": "integer",
+          "x-algorand-format": "uint64"
+        },
+        "FirstAttestedRound": {
+          "description": "The first round the message attests to.",
+          "type": "integer",
+          "x-algorand-format": "uint64"
+        },
+        "LastAttestedRound": {
+          "description": "The last round the message attests to.",
+          "type": "integer",
+          "x-algorand-format": "uint64"
+        }
+      }
     }
   },
   "parameters": {
diff --git a/daemon/algod/api/algod.oas3.yml b/daemon/algod/api/algod.oas3.yml
index 44d4d1b95..404da3a2e 100644
--- a/daemon/algod/api/algod.oas3.yml
+++ b/daemon/algod/api/algod.oas3.yml
@@ -1623,44 +1623,7 @@
         "description": "Represents a state proof and its corresponding message",
         "properties": {
           "Message": {
-            "description": "Represents the message that the state proofs are attesting to.",
-            "properties": {
-              "BlockHeadersCommitment": {
-                "description": "The vector commitment root on all light block headers within a state proof interval.",
-                "format": "byte",
-                "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
-                "type": "string"
-              },
-              "FirstAttestedRound": {
-                "description": "The first round the message attests to.",
-                "type": "integer",
-                "x-algorand-format": "uint64"
-              },
-              "LastAttestedRound": {
-                "description": "The last round the message attests to.",
-                "type": "integer",
-                "x-algorand-format": "uint64"
-              },
-              "LnProvenWeight": {
-                "description": "An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.",
-                "type": "integer",
-                "x-algorand-format": "uint64"
-              },
-              "VotersCommitment": {
-                "description": "The vector commitment root of the top N accounts to sign the next StateProof.",
-                "format": "byte",
-                "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
-                "type": "string"
-              }
-            },
-            "required": [
-              "BlockHeadersCommitment",
-              "FirstAttestedRound",
-              "LastAttestedRound",
-              "LnProvenWeight",
-              "VotersCommitment"
-            ],
-            "type": "object"
+            "$ref": "#/components/schemas/StateProofMessage"
           },
           "StateProof": {
             "description": "The encoded StateProof for the message.",
@@ -1675,6 +1638,46 @@
         ],
         "type": "object"
       },
+      "StateProofMessage": {
+        "description": "Represents the message that the state proofs are attesting to.",
+        "properties": {
+          "BlockHeadersCommitment": {
+            "description": "The vector commitment root on all light block headers within a state proof interval.",
+            "format": "byte",
+            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
+            "type": "string"
+          },
+          "FirstAttestedRound": {
+            "description": "The first round the message attests to.",
+            "type": "integer",
+            "x-algorand-format": "uint64"
+          },
+          "LastAttestedRound": {
+            "description": "The last round the message attests to.",
+            "type": "integer",
+            "x-algorand-format": "uint64"
+          },
+          "LnProvenWeight": {
+            "description": "An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.",
+            "type": "integer",
+            "x-algorand-format": "uint64"
+          },
+          "VotersCommitment": {
+            "description": "The vector commitment root of the top N accounts to sign the next StateProof.",
+            "format": "byte",
+            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
+            "type": "string"
+          }
+        },
+        "required": [
+          "BlockHeadersCommitment",
+          "FirstAttestedRound",
+          "LastAttestedRound",
+          "LnProvenWeight",
+          "VotersCommitment"
+        ],
+        "type": "object"
+      },
       "TealKeyValue": {
         "description": "Represents a key-value pair in an application store.",
         "properties": {
diff --git a/daemon/algod/api/algod2.oas2.json b/daemon/algod/api/algod2.oas2.json
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/daemon/algod/api/algod2.oas2.json
diff --git a/daemon/algod/api/server/v2/generated/private/routes.go b/daemon/algod/api/server/v2/generated/private/routes.go
index 2ea4c4033..921f69d94 100644
--- a/daemon/algod/api/server/v2/generated/private/routes.go
+++ b/daemon/algod/api/server/v2/generated/private/routes.go
@@ -437,36 +437,36 @@ var swaggerSpec = []string{
 	"sJlb+TtdU97U/GkfaytC2TUEKbSd3b5Xg0Bc98lXdgGre4Hzz1Sqp5NSiDwZMBcf96sYdM/AOUvPISPm",
 	"7vAxJAOVwMlXaKWs/YGX643P2i9L4JA9nhFi1PKi1BvvGmwX5OxMzh/pbfNf4axZZQuLOH1/9pHHw5+w",
 	"5Ie8I3/zw2znagoM87vjVHaQHWUCrgYqKEh6GamLP/atxoizrlurvCEqC0VMSrllzuio893X+SOkHxTr",
-	"3q79hCnlPuszFdKajlBa8gadrvDy49Ajhx290T+ZWZ+zYEqFEbWGKShbAEv0haTAKKBe17p2fPP7Kjnm",
-	"QwuONSL6qrxC0xjWWQwRYehMXtD84dVxTJQ/RHy411ziCw31uRDJFpXqdt73t3TU3IHudn9T8xM0H/wT",
-	"zB5FbZpuKGcXrAuQ+7ppWA+I5iQXzUMEOCS5xDGtEXT/JVm4CMtSQsoU6wSfX/oScLX6ghVRm0d+tutL",
-	"u9b5i9B3IGMn8IqSvGvKSWmB/K6BsDn7f3Ig3cDJjVJ5jPp6ZBHB3yD3PdltcgueJfCyjiPmPxlxP9Ys",
-	"N1hKbKVhUucORn/esgPbQoSdOAwh4Z7twYED+ob24H666tjl4TpwQysF/XWOvmdbuI1csc3axjoz+sgd",
-	"9kHoxRgfRLxomumOThCLEKw4SBBU8tv+b0TCEkuKC/LkCU7w5MnUNf3tafuzYVxPnkQFsAdzf7Re/nXz",
-	"xijml6G4PRubNhAi2tmPiuXZLsJoBfw25f0xpPVXFxr9pzww8Ku1hPaPqivNfBPHa3cTEDGRtbYmD6YK",
-	"QnlHRPG6brPo28wK0koyvcGMbW84Y79GK+F8V9vana+mzvFzt7wW51Dn/DeW+Up5OeI7Yd9yLow0jG5v",
-	"jW89vbmiRZmDOyhfP1r8HZ7943m292z/74t/7L3YS+H5i1d7e/TVc7r/6tk+PP3Hi+d7sL98+WrxNHv6",
-	"/Oni+dPnL1+8Sp893188f/nq748MHzIgW0AnPj9o8j/xFY7k8OQ4OTPANjihJaufeDNk7AuA0xRPIhSU",
-	"5ZMD/9N/9ydsloqiGd7/OnHpB5O11qU6mM8vLy9nYZf5Ck1xiRZVup77efpPa50c16HRNqUVd9RGvRpS",
-	"wE11pHCI396/OT0jhyfHs4ZgJgeTvdnebB8fzimB05JNDibP8Cc8PWvc97kjtsnB5+vpZL4GmqPnyvxR",
-	"gJYs9Z/UJV2tQM5cJXTz08XTuRea5p+dGfJ627d5WFRw/rllrc129MS6a/PPPp14e+tWvq6zUgcdRkIx",
-	"PKV9PHb+GYX2wd/nqB9Zcpx770K8ZQvgz/qKZdfdHu65xvnn5v3Ua3tec4j5EmxQPQ2eW50SpgldCIkp",
-	"tTpdmyPqc/mYaj+3W9PbcWbozPR6Xb8lG5QxOvjQUy3sQMSPhIfSUFxzZlozNWxRywrCyjo102+1b1j/",
-	"h73k1afP+9P9veu/Gdbu/nzx7HqkU/B18xTtac23Rzb8hIlwaN7Eo/R0b+8OLy0d8vBdXNyk4EGv6PPY",
-	"VZkUQyYDt1WdgUiNjB0JO53hBx7jfH7DFW81wrRCcCIPJ3xDM+LzTHDu/Yeb+5ijS9awWGKvkOvp5MVD",
-	"rv6YG5KnOcGWQQZ2f+t/5udcXHLf0tz3VVFQufHHWLWYgn8hGm8VulJokpPsgmqYfEKbbywgcYC5KE1v",
-	"wVxOTa8vzOWhmAtu0n0wl/ZA98xcnt7wgP/1V/yFnf7V2OmpZXfj2akT5Wwq49w+7thIeL1C/yuI5lRi",
-	"diPd9mpzl8N+B7r3CPXkjizmT3uP+v/vc/J87/nDQdCuUv0DbMg7ocm3aEz+i57ZccdnmyTU0YyyrEfk",
-	"lv2D0t+IbLMFQ4ValS79KCKXLBg3IPdvl/6zh71Hos9hQ2xskPcBc5FBTx66viMP+Mu+Z/2Fh3zhIdJO",
-	"/+zhpj8FecFSIGdQlEJSyfIN+ZnXyeO3V+uyLBp33T76PZ5mtJFUZLACnjiGlSxEtvGFA1sDnoM1YvcE",
-	"lfnndvVvaygbNEsd4e/1o4R9oBcbcnzUk2Bsty6n/WaDTTsaY0Qn7IK4VTPs8qIBZWwbmZuFrIQmFguZ",
-	"W9QXxvOF8dxJeBl9eGLyS1Sb8Iac7p089VVUYnWGqO5PPUbn+FOP671sdF+fiekvNj4dMhJ8sIlUXTR/",
-	"YQlfWMLdWMJ3EDmMeGodk4gQ3W0svX0GgaG4WfcNHQx08M2rnEqiYKyZ4hBHdMaJh+ASD62kRXFldTTK",
-	"CVwxG7UZ2bD71du+sLgvLO4v5LXazWjagsiNNZ1z2BS0rPUbta50Ji5t9cEoV8TC/DR3VXwxorSO2dCC",
-	"+AGajFfyk6sWkG8wjJZlRozTrAAjUtW8znT2eQxNgLcZoXlMecU4ToCsAmex5appkEumIBXcPj3a8bU5",
-	"yN5ZnTDGZH+vADmaw42DcTJtOVvcNkaKQ99Z/ur7Rq632NKRKmzsez8eo35ctPX3/JIynSyFdHmmiL5+",
-	"Zw00n7siXJ1fm4ISvS9YJSP4MQjsiP86rx9TiH7sBq/EvrqIEd+oiU4Lo71wg+s4rw+fzD5hLV63903w",
-	"0sF8jslZa6H0fHI9/dwJbAo/fqq35nN9Lbstuv50/X8DAAD//89W3bJFvAAA",
+	"3q79hCnlPuszFdKajlBa8gadrvDyY2MRGlc23HfYAV6oFAeFwz03cuD8yTFCP9ZICZYySAmt5e/Ss/0T",
+	"ozVfCrZIYQSyWaayBcNEX6gMjCjqdW2biOO5b8LA/HHBsaZG3/Sh0JSIdSlDwjHnUl7Q/OHNF1hY4BDx",
+	"4V6/iS801H9DJFtUqttFK7ylo+YOdN37m5qfoLnln2D2KGoDdkM5O2pdsN3XmcP6STQnuWgebsAhySWO",
+	"aY3G+y/JwkWklhJSplgnWP/Sl8yr1T2sINs8irRdv9y1zl+EvgMZOwVBlORdU35LC7wfGgibI/onM5WB",
+	"kxul8hj19cgigr8YjwpTQ3dcF+cta7ItZ9iJ5hAS7tmqHLixb2hV7ie9jl0ergMvnUpBf52jb+sWbiMX",
+	"dbO2sS6RPnKHPRl6McaTES+9ZrqjK8UiBOsWEgSV/Lb/G5GwxMLkgjx5ghM8eTJ1TX972v5sjvOTJ1Ex",
+	"7sGcKK33g928MYr5ZSj6z0a4DQSadvajYnm2izBaYcPNIwEYGPurC7D+U54p+NXaU/tH1RV4von7trsJ",
+	"iJjIWluTB1MFAcEjYoFdt1n0hWcFaSWZ3mDetze/sV+j9XS+qy32zuNTZwq6u0+Lc6grBzT2/Ur52/U7",
+	"YV+ELoxMjc5zjS9GvbmiRZmDOyhfP1r8HZ7943m292z/74t/7L3YS+H5i1d7e/TVc7r/6tk+PP3Hi+d7",
+	"sL98+WrxNHv6/Oni+dPnL1+8Sp893188f/nq748MHzIgW0AnPsto8j/xLY/k8OQ4OTPANjihJasfijNk",
+	"7MuI0xRPIhSU5ZMD/9N/9ydsloqiGd7/OnFJDJO11qU6mM8vLy9nYZf5Cg16iRZVup77efoPdJ0c1wHW",
+	"NjEWd9TGzhpSwE11pHCI396/OT0jhyfHs4ZgJgeTvdnebB+f3ymB05JNDibP8Cc8PWvc97kjtsnB5+vp",
+	"ZL4GmqP/y/xRgJYs9Z/UJV2tQM5cPXXz08XTuRcl5p+dMfN627d5WJpw/rll88129MTqbfPPPil5e+tW",
+	"1q+zdQcdRkIxPKV9gnb+GUXZwd/nqDVYcpx7H0W8ZQvgz/qKZdfdHu7Rx/nn5hXWa3tec4h5JGxoPg0e",
+	"bZ0SpgldCImJuTpdmyPqMwKZaj/aW9PbcWbozPR6Xb9IGxRDOvjQE7jtQMSPhIfSUFxzZlozNWxRywrC",
+	"+jw102+1b1j/h73k1afP+9P9veu/Gdbu/nzx7Hqka/F186Dtac23Rzb8hOl0aCTFo/R0b+8O7zUd8vB1",
+	"Xdyk4Fmw6CPbVZkUQ4q026rOQKRGxo60n87wA096Pr/hireaclqBPJHnF76hGfHZKjj3/sPNfczRsWtY",
+	"LLFXyPV08uIhV3/MDcnTnGDLII+7v/U/83MuLrlvae77qiio3PhjrFpMwb8zjbcKXSk07El2QTVMPqHl",
+	"OBbWOMBclKa3YC6nptcX5vJQzAU36T6YS3uge2YuT294wP/6K/7CTv9q7PTUsrvx7NSJcjYhcm6fiGwk",
+	"vN5zASuIZmZijiTd9vZzl8N+B7r3lPXkjizmT3vV+v/vc/J87/nDQdCudf0DbMg7ocm3aGL9i57Zccdn",
+	"myTU0YyyrEfklv2D0t+IbLMFQ4ValS6JKSKXLBg3IPdvl/7jib2nps9hQ2yEkfckc5FBTx66viMP+Mu+",
+	"iv2Fh3zhIdJO/+zhpj8FecFSIGdQlEJSyfIN+ZnXKei3V+uyLBq93T76PZ5mtJFUZLACnjiGlSxEtvHl",
+	"B1sDnoM1YvcElfnndg1xaygbNEsd4e/104Z9oBcbcnzUk2Bsty6n/WaDTTsaY0Qn7IK4VTPs8qIBZWwb",
+	"mZuFrIQmFguZW9QXxvOF8dxJeBl9eGLyS1Sb8Iac7p089bVYYtWKqO5PPUbn+FOP671sdF+fiekvNsod",
+	"MhJ8sOlYXTR/YQlfWMLdWMJ3EDmMeGodk4gQ3W0svX0GgQG9WfclHgx08M2rnEqiYKyZ4hBHdMaJh+AS",
+	"D62kRXFldTTKCVwxG8sY2bD71du+sLgvLO4v5LXazWjagsiNNZ1z2BS0rPUbta50Ji5tDcMoV8Ty/jR3",
+	"tYAxzrKO2dCC+AGavFnyk6s5kG8wuJRlRozTrAAjUtW8znT22RBN2LMZoXmSecU4ToCsAmexRa9pkJGm",
+	"IBXcPmDa8bU5yN5ZnTDGZH+vADmaw42DcTJtOVvcNkZKTN9Z/ur7Rq632NKRKmxEeD8eo36itPX3/JIy",
+	"nSyFdNmqiL5+Zw00n7tSXp1fm7IUvS9YayP4MQjsiP86r59kiH7sBq/EvrqIEd+oiU4Lo71wg+s4rw+f",
+	"zD5hRV+3903w0sF8jilea6H0fHI9/dwJbAo/fqq35nN9Lbstuv50/X8DAAD//50wp92LvAAA",
 }
 
 // GetSwagger returns the Swagger specification corresponding to the generated code
diff --git a/daemon/algod/api/server/v2/generated/private/types.go b/daemon/algod/api/server/v2/generated/private/types.go
index 8221e7731..1eaa4b4c8 100644
--- a/daemon/algod/api/server/v2/generated/private/types.go
+++ b/daemon/algod/api/server/v2/generated/private/types.go
@@ -460,26 +460,29 @@ type StateDelta []EvalDeltaKeyValue
 type StateProof struct {
 
 	// Represents the message that the state proofs are attesting to.
-	Message struct {
+	Message StateProofMessage `json:"Message"`
 
-		// The vector commitment root on all light block headers within a state proof interval.
-		BlockHeadersCommitment []byte `json:"BlockHeadersCommitment"`
+	// The encoded StateProof for the message.
+	StateProof []byte `json:"StateProof"`
+}
 
-		// The first round the message attests to.
-		FirstAttestedRound uint64 `json:"FirstAttestedRound"`
+// StateProofMessage defines model for StateProofMessage.
+type StateProofMessage struct {
 
-		// The last round the message attests to.
-		LastAttestedRound uint64 `json:"LastAttestedRound"`
+	// The vector commitment root on all light block headers within a state proof interval.
+	BlockHeadersCommitment []byte `json:"BlockHeadersCommitment"`
 
-		// An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.
-		LnProvenWeight uint64 `json:"LnProvenWeight"`
+	// The first round the message attests to.
+	FirstAttestedRound uint64 `json:"FirstAttestedRound"`
 
-		// The vector commitment root of the top N accounts to sign the next StateProof.
-		VotersCommitment []byte `json:"VotersCommitment"`
-	} `json:"Message"`
+	// The last round the message attests to.
+	LastAttestedRound uint64 `json:"LastAttestedRound"`
 
-	// The encoded StateProof for the message.
-	StateProof []byte `json:"StateProof"`
+	// An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.
+	LnProvenWeight uint64 `json:"LnProvenWeight"`
+
+	// The vector commitment root of the top N accounts to sign the next StateProof.
+	VotersCommitment []byte `json:"VotersCommitment"`
 }
 
 // TealKeyValue defines model for TealKeyValue.
diff --git a/daemon/algod/api/server/v2/generated/routes.go b/daemon/algod/api/server/v2/generated/routes.go
index 185fbbca1..f8fc80514 100644
--- a/daemon/algod/api/server/v2/generated/routes.go
+++ b/daemon/algod/api/server/v2/generated/routes.go
@@ -982,89 +982,89 @@ var swaggerSpec = []string{
 	"TmGzZ+XvdEV5U/OnfaytCGXXEKTQdnb7Wg0Ccd0nX9oFLK8Fzi+pVE8npRB5MmAuPupXMeiegVOWnkJG",
 	"zN3hY0gGKoGT22ilrP2B56uNz9ovS+CQ3ZkRYtTyotQb7xpsF+TsTM5v6bH51zhrVtnCIk7fn53wePgT",
 	"lvyQV+RvfphxrqbAML8rTmUH2VImYD1QQUHS80hd/F3faow467q1yhuislDEpJRL5ozudL77On+E9INi",
-	"3ePaT5hS7rM+UyGt6QilJW/Q6QovL4ceOezojf7JzPqcBVMqjKg1TEHZAliiLyQFRgH1tNa145vfV8kx",
-	"H1pwrBHRV+UVmsawzmKICENn8ozmn18dx0T5Q8SHe80lvtBQnwuRbFGpLud9f0F3mjvQ3a5vav4azQf/",
-	"CWaPojZNN5SzC9YFyH3dNKwHRHOSi+YhAhySnOOY1gh67zGZuwjLUkLKFOsEn5/7EnC1+oIVUZtHfsb1",
-	"pW3r/FXoK5CxE3hFSV415aS0QH7XQNic/S8cSDdwcqNUHqO+HllE8DfIfV9vN7kFzxJ4WccR8xdG3Mua",
-	"5QZLia00TOrcwuhPW3ZgW4iwE4chJFyzPThwQF/QHtxPV911ebgO3NBKQX+dO9+zLdxGrthmbbs6M/rI",
-	"HfZB6PkuPoh40TTTHZ0gFiFYcZAgqOT9vfdEwgJLigty9y5OcPfu1DV9f7/92TCuu3ejAthnc3+0Xv51",
-	"88Yo5tehuD0bmzYQItrZj4rl2TbCaAX8NuX9MaT1dxca/UUeGPjdWkL7R9WVZr6I47W7CYiYyFpbkwdT",
-	"BaG8O0Txum6z6NvMCtJKMr3BjG1vOGO/Ryvh/Fjb2p2vps7xc7e8FqdQ5/w3lvlKeTniR2Hfci6MNIxu",
-	"b41vPT1f06LMwR2U727N/x0e/O1htv/g3r/P/7b/aD+Fh4+e7O/TJw/pvScP7sH9vz16uA/3Fo+fzO9n",
-	"9x/enz+8//Dxoyfpg4f35g8fP/n3W4YPGZAtoBOfHzT5L3yFIzl8fZQcG2AbnNCS1U+8GTL2BcBpiicR",
-	"CsryyYH/6X/7EzZLRdEM73+duPSDyUrrUh3s7Z2fn8/CLntLNMUlWlTpas/P039a6/VRHRptU1pxR23U",
-	"qyEF3FRHCof47c3zt8fk8PXRrCGYycFkf7Y/u4cP55TAackmB5MH+BOenhXu+54jtsnBh4/Tyd4KaI6e",
-	"K/NHAVqy1H9S53S5BDlzldDNT2f397zQtPfBmSE/mlGXsVx2G+QdRPb2C4Q7lwZGytgg7lbBTeXqP07r",
-	"MqzOSsAzjL21lj3D2mpkHWVNybWjhlH5xHNbiefgt8hLMwu2rGTnUcra/+9qNDNF7JPokjgJ4zVNT8P4",
-	"ViTIf1YgNw3BOFYWlpDxJTNdFGyhlmU7ZKyRa2LP18UqrePMZp8DSq09Ag0n0rKCEJKGrxpeuZ88effh",
-	"0d8+TnYABN1TCjDB8D3N8/f21VBYo43fp+i7FMxppDwkKgLTxsKMHZptmmLMW/01rABet2lHWr/ngsP7",
-	"oW1wgEX3gea5aSg4xPbgHabAISXgIbq/v39tTwfUyQU2cq4exZPEJQbqcxj7KfKumH9BYOBRsYfXuNB2",
-	"zM2Vl9sdrrfo72mGVZlBabuUe9/sUo44eogNxyf2Rvs4nTz6hvfmiBueQ3OCLYP88v4t8gs/5eKc+5ZG",
-	"mqmKgsoNyipB6fhQKv04eFvthWVu9z60/IfZle6yXoXvo2dbrrdbaogp9gsvdaromu91nVj0MLlSwbBm",
-	"Sqs7M/Jj2BsZM+Yx2izBSvLmHc1SijNmtHlfmMGXe2hgu6XCFM/oZRsYZW/u3U967x62rQ6tyj0xYFok",
-	"PgpTL8DgqhdfP6688wjKpR4ZCer1XqLq4SetxN5R+gaftt6Bwd7gbuhZ8AHxJoC3lnTadZY/Pd+1+ltw",
-	"TbTug0/Ilb9xYe0lzQ2dBMvt5LjZclY3QtxfRoirY87sW2ZYwXFMrMMy7XsffPWxaxDlXPW1HYS4UNMN",
-	"+gbVsW53OMWdmS0lFra5HDtw8WNbxTOsCXcjmH1qwaxfTDEGRlMi78sJYwjDqqm2eJEHxFqPI1yoKuQ3",
-	"Kn39hZE1KG4ZSLcLWpfgjT0hynHiT8Yz/5TCk0Pajdj0lxabbMj2iODUqnTq4vuHZSfQLqXLpiZH8gEU",
-	"hhXb0adECemiXEvJhGR6MyWMkwzM2UOPoZBY1EXLiqfW0G+nAI7/fXn4X5hh8PLwv8h3ZH9ai2CY8x6Z",
-	"3sZwtmWgH0H3Q5XV95vDWhwYlYW+GgHjuEZSkEQQol4LX6wUkVbQ9XdDKFtbv2JMPCvoejIqiUy/HWnx",
-	"qkJTJ3myT0VYsocTdPr7h/XakbOKwJqmOt8QivfPxqZ4qGreVBptixtalEk4QDSab2RG/25XLM/8osG7",
-	"kZJA+D7WOHzHnaqMLXS47E98JG+7YNJDRhSCy0l5N7v7ze5uXywlpTBnmmHJqeY+8XdVC8jm9SYH7kBe",
-	"woz8t6gw2MU+Tgqxcuk4A+Zw+DmdABrk7+b4NGyNnbt3uwu/e9ftOVNkAefIQSnHhl103L37JxBZ13WV",
-	"akq44AnHtzPPgAQRcjdy61cttz7af/DNruYtyDOWAjmGohSSSpZvyC+8Lut3NbG85jkVDwotjvKfXkJU",
-	"I0UH4vuVfNdd3zTTjWTYyo8NTAj1E8dOV542byQZXR7LsfkSN2rqXScY+Ge9KnY/pj3HyiwmpAcenO83",
-	"R892kcu/EUfozmVBI/dafG8+9Q0Qjad583niaXZjpg/3H34+CMJdeCU0+QHNZZ+YpX9S20GcrAJmc2GP",
-	"SuMxCVmLyzcfZSrmhE5dKXesLb4hdT6o4SeWEdrHnPpcw8ywK7/4iu3zW83CUbrsoveGL9zwhSvxhS5B",
-	"NRwB8z7V3gd0FYTsoHckMW/tT+RiDPwtUhTe4SLIAnS6cvmwnbSYCFvx1YWHecrYGzzX7P9DoCPFLcMy",
-	"Xfg2zI5530GqIjq9QEaI72dfQc98ZgvM3q8rR/unptCdw/zrC/XDC+55GqZ8zLlPmzW7eCEonzaT99N0",
-	"EC3X4TO8QfDFENxjas9dkqk9Xm4Rf4aodP9IQkJeiSYr2xVO/jOaPT7ljfypF/RKcLB+aSOxWlq8cUHW",
-	"4gK+VodI8Qng1vHoHsCPiw57WEfC8sC9ugrbkDARL2y5Rbhobmwt6gCJaC3KOeSCL9XXeWePbXMcL5Ht",
-	"rkt+xut6/vWE9qdYooILX93MFS1RjKdgX/PwD98VTCkXxvOFBfpPaWz9nNZRLBhaV4zwcQrRGrGKZZ36",
-	"ikFBjyHW0opn+KDXLPu4ncUEPrELchfGA+4SGnFpWQKVl2cr253ux50Zj56F0WCtEpV1sZUIKAZFF4xX",
-	"+LfJjjoTphWKBVlRtSKLiltA6zdv7eFzoVpiMa1dQubOFYsDcsLvErWij+7d//3+o8f+z/uPHg9ofWYe",
-	"V+Wgr/c1A5nPdphdlL8/b3BDW2GpkXfwubfyYjs0nbBsHa1H19ScDs+F87Agn7ilSEk3g2Usyy01s8Nh",
-	"m/rZn7/IldJsHn8C9iezPWJB6oeZjvj3tXhmKzG5UtM3tbIHQhICJmIIrSmaXWN9vH72iADWIcu6UPHn",
-	"ttk2EaP2FvPIk50L5YvKhvqLyIavBE9Q3QPuBZI2Wr6cLIg1E6eB/6R+6s6IsqoqSyF1fbrVbCcxDQad",
-	"2KGUNki4TghLqU5XVbn3Af+DpUw+NkVD7EuOe9azMyaHvbUtrjVmz47ZlLtrV89x3iaxIC9ZKsUhVtN0",
-	"N4baKA1F/51/2/X3sTcCo7eL4DnjkBSCxwrv/IxfX+LHaL1OjAMa6IwRWUN9u6+ztuDvgNWeZxfmdlX8",
-	"fiUK6JUsIJ3VSijruGe0OiD9N6el9WBCc0xaP+99aP3pHLCupVpVOhPnQV9Ukuy538VBE1TF21nVaZSL",
-	"Tq1PRTJQhrq+PRtKgIcYaddfI6VTgtqHg9VT/qJWlQXjWYdIUHpLxRlIVSv98ivxlf5ZTCu7ozxgGpXa",
-	"xicqdb0X8iuRgR23XdAulsXCRQauCFj/Hq5FjbjG6ply066jQ6S0Wq40qUqiRUxbaTomNLWsyz5Uora9",
-	"7GBb+QrmZ0BoLoFmGzIH4ETMzaLbL+QQqvAdHa/yOIEq/kBBA1cpRQpKQZaEr1qPgVaXVkMFSY/gCQFH",
-	"gOtZiBJkQeUlgbWSxTiguhNaXoNb+yud8NCHerfpxzawO3m4jVQC8RcYWjxEUebgbB4RFO6IE1TJ2Sfe",
-	"Pz/JZbevKvHh5MgTG/brMSvw/uOUCwWp4Jkafghn27HF4tjBWpRZQXBSou/RmoEH5PEXVGn3bnfrvYCg",
-	"CLeZYuTlnqGyqGbkX+uiqL2xU8MvuapU86S5VdEgi62Bw3pkrlewrudCO7gfu9YBtSCVgm0jD2EpGL9+",
-	"5Dx4ikcHVm4skd1fHKbiUqe/9VHZAqJBxBggb32rALuhBXYAEHwItQwlcPfuQwPXXIgcKLemNFGW5vzp",
-	"pOJ1vyE0vbWtD/UvTds+cbkURuTrmQAV6ucO8nOLWYVxjiuqiIODFPTUqfBLl0nYh9kcxgS9VckY5Ztj",
-	"+da0Co/AlkPa1RXD4986Z53D0aHfKNENEsGWXRhacEw7/SrE7ovKs127/id02Le180C8mnWkwr1zynSy",
-	"ENK9zUYXGmREtezUBKVMK2czssYzLZwrjOAIjqG4cdwbX01RFZeGZUHwqcBm9/uRv2aqH4TcKdSwHQ1A",
-	"mSYV18zXczHnrZYxvz799UZ6vpGeb6TnG+n5Rnq+kZ5vpOcb6flTS89fJneIJInn0z50JJYWTibfpIR/",
-	"Y7Ee0UYCMdUpCUZEN+d4NKZYA81xQSzHy7UUajA5EZ8QUqKSKZDUTMc4KXNqpCFYa18ih8ypgscPwxfl",
-	"l5IW7hEhw2tMgwf3ydufDn0g08oF3LTb3vbPmCu9yeGOy72oX/nwSRjADQZdDgb12k/qAs6sML9gORBl",
-	"cPUcWz+DM8iNJG9jJIjRRfra0THQ/KnDzRblqPWOgxnt/bSlkzm0FbQMnoXDtVJFKAa9dZ5hWNBcDb/D",
-	"YMcraBkrMlTzaas2IWv4XmSbDrmbXdvDDWwTehPOxDiVm0icYo+8e6ShhWE+jrD6et/Haw+66xNtn8y2",
-	"UVj83VIVPZRjVB6NNqs3rDeUjXhcdOgk+ghRN8RqUgO4S5SBoWe/J+SN7fdFbyuCELkj1nDmr8bn233I",
-	"3TENbGsEKsd6vtVUVY/46OnFsz/1D13ji6yO4taJabQEnjjeksxFtklanKl9wWRMUaWgmG+/ZELWiIep",
-	"vlfMl/Er6MvcEM+CxY2x25Ae1onjrQOM18aR7sZ2a2zhiI7zBhj/1Nx3iEOGIBDHemK6c7eG6gX5WTPN",
-	"5oan3fC04DR2LnvGXQhzl4nMLsfT5EZWfJidPbev0ysSHtLb6o5hWYjRtW5Z7jOYV8ulfZK9a4XGWp44",
-	"XvNQ8Ofmcna5uzK4ixGHHbwugHHV3M3ucH3GEUTi3haSLKWoyju2sjLfoIGzKCnfeKeG0fyLKrc4tPnm",
-	"18tDbQBx7D1Mb1wbtsu99ua3wPrkbtH27xYt5Jwq9y4iZKTimL4YSzNYd57q3I7x4zVvOPDoQ57+5fre",
-	"6ty8u3B/v8suqLB25JQgE73m9kC1DpNLZ7And3ZT5OWvcSO8thXMBxhsPzS/YQjbLwYZsCy8GTolP/3V",
-	"0Oanb+h5WED0uoTG3bX1FeCdWGuvkfqoRoyUgmYpVWjU4KDPhTz9xLKkXh9FrMgIJta57iemGZ1ktlWo",
-	"xHF3EinbuaBeK6/mmMQsvizXIAlpko4OXdmQFjZuDLt/FsPu9/7wKUKJpOfdw2l9OHgmd2BT9FyveZRL",
-	"7ZX2nYyh+OUwq9u2vNZIjN7w7YCM4JUK61CGvCSUpDlDd7PgSssq1SecokMrWFi/ZHTtphsWpZ76JnGf",
-	"asTl6YY64UaoWpDazRUVqRYQcWD/AOAlNlUtl6B0hxMvAE64a8U4qTjTOFfBUikSmwxkrmvD0We2ZUE3",
-	"ZEFz9Mj+AVKQuVEiwtqp6B5SmuW5iw4x0xCxOOFUkxwM03/JjEBnhvMehDriydJdjYV4HrB7JDuJW2d/",
-	"tF8x1dYt33sB0FlhP/sUuemXeco+Ydkg5EfPXF3zo2dYqraJC+nB/tmCBQrGkyiRmRvfxVd1aYvcNjKe",
-	"J6A7TYSJ2/UTboRpLQgyeqovRw5dp27vLNrT0aGa1kZ0fL9+re9iNbWWIjEqI12a35dMr6o5Pibva23t",
-	"LUVdd2svo1AIjt+yPVqyPVVCund2b4t8cAV+RSLs6ubm/hMlEQV0YE5LvfH4flN37wfu5Wt4Rubrfjtm",
-	"a8DpzUstNy+13LzlcfNSy83u3rzUcvOOyc07Jn/Vd0xmoxKiK9C39WUB3TNtUiIhtTPXDDxs1nqDoO+V",
-	"ZHpGyPHK8H9q7gA4A0lzklJlBSNu454LLEuoqjQFyA5OeNKCxBYjNBPfbv5r1dyTan//AZD9O90+1m4R",
-	"cN5+XxRV8RO6msh35GRyMumNJKEQZ+AqkmPzrMLwF9tr67D/qx73Z9nbuoJurHFlRcsSzLWmqsWCpcyi",
-	"PBdGGViKTrQ2F/gFpAHOlkcjTNvHXxCfGOXuYmKoqz0UE7r79/sFnq4+7Bax+qxlD/+8AvYYn+pv2PXx",
-	"wNGxewzxhmV8DpbxxZnGn6gO/E3J969sQaEjtfWmy1UK8/jHzCN2Jy8jWXOy4c04AqSVZHqDNxwt2e+n",
-	"YP7/zvBxBfLMX36VzCcHk5XW5cHeHr66thJK703M1dR8U52P5n6gSzuCu1xKyc7wxYZ3H/9/AAAA//9I",
-	"ljPEDCwBAA==",
+	"3ePaT5hS7rM+UyGt6QilJW/Q6QovLxuL0G5lw32HLeCFSnFQONxzIwfOF44RelkjJVjKICW0lr9Nz/ZP",
+	"jNZ8KdgihRHIZpnKFgwTfaEyMKKop7VtIo7nvgkD88cFx5oafdOHQlMi1qUMCcecS3lG889vvsDCAoeI",
+	"D/f6TXyhof4bItmiUl0uWuEF3WnuQNe9vqn5azS3/CeYPYragN1Qzo5aF2z3deawfhLNSS6ahxtwSHKO",
+	"Y1qj8b3HZO4iUksJKVOsE6x/7kvm1eoeVpBtHkUa1y+3rfNXoa9Axk5BECV51ZTf0gLvhwbC5oh+YaYy",
+	"cHKjVB6jvh5ZRPAX41FhauiW6+K0ZU225Qw70RxCwjVblQM39gWtyv2k112Xh+vAS6dS0F/nzrd1C7eR",
+	"i7pZ264ukT5yhz0Zer6LJyNees10R1eKRQjWLSQIKnl/7z2RsMDC5ILcvYsT3L07dU3f329/Nsf57t2o",
+	"GPfZnCit94PdvDGK+XUo+s9GuA0Emnb2o2J5to0wWmHDzSMBGBj7uwuw/iLPFPxu7an9o+oKPF/Efdvd",
+	"BERMZK2tyYOpgoDgHWKBXbdZ9IVnBWklmd5g3rc3v7Hfo/V0fqwt9s7jU2cKurtPi1OoKwc09v1K+dv1",
+	"R2FfhC6MTI3Oc40vRj1f06LMwR2U727N/x0e/O1htv/g3r/P/7b/aD+Fh4+e7O/TJw/pvScP7sH9vz16",
+	"uA/3Fo+fzO9n9x/enz+8//Dxoyfpg4f35g8fP/n3W4YPGZAtoBOfZTT5L3zLIzl8fZQcG2AbnNCS1Q/F",
+	"GTL2ZcRpiicRCsryyYH/6X/7EzZLRdEM73+duCSGyUrrUh3s7Z2fn8/CLntLNOglWlTpas/P03+g6/VR",
+	"HWBtE2NxR23srCEF3FRHCof47c3zt8fk8PXRrCGYycFkf7Y/u4fP75TAackmB5MH+BOenhXu+54jtsnB",
+	"h4/Tyd4KaI7+L/NHAVqy1H9S53S5BDlz9dTNT2f397wosffBGTM/mlGXsYx4GyoexAf3y4w7xwjG29hQ",
+	"8FbZTuWqSE7rYq7O1sAzjOC19kHD2mpkHWVN4bajhlH59HVbz+fgt8h7NQu2rGTnacs6isBVemaK2IfV",
+	"JXEqzWuanoZRskiQ/6xAbhqCcawsLETjC2+6WNpCLct24FkjJsUewYvVa8eZzT4HlFr7FRpOpGUFISQN",
+	"XzW8cj958u7Do799nOwACDq5FGCa4nua5+/t26OwRk+BT/R3iZzTSJFJFI+njZ0aOzTbNMXIufprWEe8",
+	"btOO137PBYf3Q9vgAIvuA81z01BwiO3BO0ykQ0rAQ3R/f//aHiCoUxRs/F09iieJSwzU5zD2U+R1Mv8O",
+	"wcDTZA+vcaHtyJ0rL7c7XG/R39MMazuD0nYp977ZpRxx9DMbjk/sjfZxOnn0De/NETc8h+YEWwZZ6v1b",
+	"5Bd+ysU59y2NNFMVBZUblFWCAvShVPpx8LbaC4vl7n1oeSGzK91lvTrhR8+2XG+31BBT7Jdv6tTiNd/r",
+	"arPop3IFh2HNlFZ3ZuTHsDcyZsyGtLmGleTNa5ylFGcsMyzWBXD4ohENbLdUmCgavWwD0+7NvftJ793D",
+	"ttWhVf8nBkyLxEdh6oUpXPXi60end55SudRTJUHV30vUTvyk9dw7St/gA9k7MNgb3A09Lj4g3gTw1pJO",
+	"u1rzp+e7Vn8LronWffAJufI3Lqy9pLmhk2C5nUw5WxTrRoj7ywhxdeSafREN60COiXVY7H3vg69hdg2i",
+	"nKvhtoMQF2q6Qd+gxtbtDqe4M7MFycI2l2MHLgptq3iGleVuBLNPLZj1SzLGwGgK7X05YQxhWDU1Gy/y",
+	"DFnriYUL1Zb8RqWvvzCyBsUtA+l2QesSvLEnRDlO/Ml45p9SeHJIuxGb/tJikw38HhGcWvVSXZbAsOwE",
+	"2iWG2QTnSFaBwuBkO/qUKCFdrGwpmZBMb6aEcZKBOXvoMRQSS8NoWfHUGvrtFMDxvy8P/wvzFF4e/hf5",
+	"juxPaxEMM+cj09tI0LYM9CPofsCz+n5zWIsDo7LQVyNgHNdIClIRQtRr4UueItIKuv5uCGVr61eMiWcF",
+	"XU9GJZHptyMtXlVo6qRg9qkIC/9wgk5//zxfO/5WEVjTVOcbQvH+2dhEEVXNm3qlbXFDizIJB4jGuI3M",
+	"6F//imWrXzQEOFJYCF/ZGofvuFPbsYUOl0OKT+1tF0x6yIhCcDkp72Z3v9nd7YulpBTmTDMsXNXcJ/6u",
+	"agHZvAHlwB3IbpiR/xYVBrvYJ04hVnQdZ8BMED+nE0CDLOAcH5itsXP3bnfhd++6PWeKLOAcOSjl2LCL",
+	"jrt3/wQi67qudU0JFzzh+ALnGZAgQu5Gbv2q5dZH+w++2dW8BXnGUiDHUJRCUsnyDfmF18UBryaW1zyn",
+	"4kG5xlH+00uraqToQHy/ku+665tmupEMW1m2gQmhfijZ6crT5qUlo8tjUTdfKEdNvesEA/+sV8Xux7Tn",
+	"WJnFhPTAg/P95ujZLnL5N+II3bm4aORei+/Np74BovE0bz5PPM1uzPTh/sPPB0G4C6+EJj+guewTs/RP",
+	"ajuIk1XAbC7sUWk8JiFrcVnro0zFnNCpKwiPFco3pM4qNfzEMkL7JFSfa5gZduUXX7F9fqtZOEqXXfTe",
+	"8IUbvnAlvtAlqIYjYDak2vuAroKQHfSOJGZz/YlcjIG/RYrCO1wEWYBOVy5LtJMWE2ErvkbxME8Ze8nn",
+	"mv1/CHSkRGZY7AtfmNkxezxI4EOnF8gI8f3s6/CZz2yBNQDq+tP+wSp05zD/hkP9fIN75IYpH3Puk0nN",
+	"Ll4IyqfN5P00HUTLdfgMbxB8MQT3mNpzlwhvj5dbxJ8hKt0/tZCQV6LJVXbll/+MZo9PeSN/6gW9Ehys",
+	"X9pIrJYWb1yQtbiAb94hUnyRCut4dM/ox0WHPayuYHngXl3LbUiYiJfH3CJcNDe2FnWARLSi5RxywZfq",
+	"67yzx7Y5jpfIdteFQ+PVQf96QvtTLNzAha+R5kp5KMZTsG+C+OfzCqaUC+P5wgL9pzS2fk7rKJYdrava",
+	"+DiFaKVZxbJOlcagzMUQa2nFM3zQa5Z93M5iAp/YBbkL4wF3CY24tCyBysuzle1O9+POjEfPwmiwVqHL",
+	"ugRJBBSDogvGK/zbZEedCdMKxYKsqFqRRcUtoPXLufbwuVAtsZjWLiFz54rFATnhd4la0Uf37v9+/9Fj",
+	"/+f9R48HtD4zj6ty0Nf7moHMZzvMLsrfnze4oa2w1Mg7+NxbebEdmk5Yto5WtWsqV4fnwnlYkE/cUqSk",
+	"m8FimOWWytvhsE0V7s9f+klpNo8/JPuT2R6xIPXzTkf8+1o8s/WJXMHqm4rbAyEJARMxhNaU3q6xPl6F",
+	"e0QA65BlXe74c9tsm4hRe4t55MnOhfJFZUP9RWTDV4InqO4B9wJJGy1fThbEyovTwH9SP5hnRFlVlaWQ",
+	"uj7daraTmAaDTuxQShskXCeEpVSnq6rc+4D/wVImH5uiIfY9yD3r2RmTw97aFtcas2fHbIrAtavnOG+T",
+	"WJCXLJXiEGtyuhtDbZSGohe/5br+PvbSYPR2ETxnHJJC8FjhnZ/x60v8GK36iXFAA50xImuob/eN1xb8",
+	"HbDa8+zC3K6K369EAb2SBaSzWgllHfeMVgek/+a0tJ5daI5J6+e9D60/nQPWtVSrSmfiPOiLSpI997s4",
+	"aILKnTurOo1y0amAqUgGylDXt2dDCfAQI+36a6R0SlCfdbB6yl/UqrJgPOsQCUpvqTgDqWqlX34lvtI/",
+	"i2lld5QHTKNS2/hEpa73Qn4lMrDjtgvaxbJYuMjAFQHr38O1qBHXWD1Tbtp1dIiUVsuVJlVJtIhpK03H",
+	"hKaWddnnTtS29yFsK18H/QwIzSXQbEPmAJyIuVl0+50dQhW+xuNVHidQxZ85aOAqpUhBKciS8G3sMdDq",
+	"0mqoIOkRPCHgCHA9C1GCLKi8JLBWshgHVHdCy2twa3+lEx76UO82/dgGdicPt5FKIP4CQ4uHKMocnM0j",
+	"gsIdcYIqOfvE++cnuez2VSU+vxx5qMN+PWYF3n+ccqEgFTxTw8/pbDu2WDI6WIsyKwhOSvRVWzPwgDz+",
+	"girtXv9uvToQlKY2U4y8/zNUFtWM/GtdFLU3dmr4JVeVah5GtyoaZLE1cFiPzPUK1vVcaAf3Y9c6oBak",
+	"UrBt5CEsBePXT6UHD/rowMqNhaP7i8NUXOr0tz4qW0A0iBgD5K1vFWA3tMAOAILPqZahBO5ej2jgmguR",
+	"A+XWlCbK0pw/nVS87jeEpre29aH+pWnbJy6Xwoh8PROgQv3cQX5uMaswznFFFXFwkIKeOhV+6TIJ+zCb",
+	"w5igtyoZo3xzLN+aVuER2HJIu7piePxb56xzODr0GyW6QSLYsgtDC45pp1+F2H1RebZr1/+EDvu2dh6I",
+	"V7OOVLh3TplOFkK6F97oQoOMqJadmqCUaeVsRtZ4poVzhREcwTEUN457KawpquLSsCwIPhXY7H4/8tdM",
+	"9YOQO4UatqMBKNOk4pr5ei7mvNUy5tenv95IzzfS8430fCM930jPN9LzjfR8Iz1/aun5y+QOkSTxfNqH",
+	"jsTSwsnkm5TwbyzWI9pIIKY6JcGI6OYcj8YUa6A5LojleLmWQg0mJ+ITQkpUMgWSmukYJ2VOjTQEa+1L",
+	"5JA5VfD4Yfgu/VLSwj0iZHiNafDgPnn706EPZFq5gJt229v+MXSlNznccbkX9SsfPgkDuMGgy8GgXvtJ",
+	"XcCZFeYXLAeiDK6eY+tncAa5keRtjAQxukhfOzoGmj91uNmiHLXecTCjvZ+2dDKHtoKWwWNpuFaqCMWg",
+	"t84zDAuaq+F3GOx4BS1jRYZqPm3VJmQN34ts0yF3s2t7uIFtQm/CmRinchOJU+yRd480tDDMxxFWX+/7",
+	"eO1Bd32i7ZPZNgqLv36qoodyjMqj0Wb1hvWGshGPiw6dRB8h6oZYTWoAd4kyMPTs94S8sf2+6G1FECJ3",
+	"xBrO/NX4fLvPwTumgW2NQOVYz7eaquoRHz29ePan/rlsfNfVUdw6MY2WwBPHW5K5yDZJizO1L5iMKaoU",
+	"FPPtl0zIGvEw1feK+TJ+BX2ZG+JZsLgxdhvSwzpxvHWA8do40t3Ybo0tHNFx3gDjn5r7DnHIEATiWE9M",
+	"d+7WUL0gP2um2dzwtBueFpzGzmXPuAth7jKR2eV4mtzIig+zs+f2jXtFwkN6W90xLAsxutYty30G82q5",
+	"tA+7d63QWMsTx2uez/3cXM4ud1cGdzHisIPXBTCumrvZHa7POIJI3NtCkqUUVXnHVlbmGzRwFiXlG+/U",
+	"MJp/UeUWhzbf/Hp5qA0gjr2H6Y1rw3a51978Flif3C3a/t2ihZxT5d5FhIxUHNMXY2kG685Tndsxfrzm",
+	"DQcefcjTv3/fW52bdxfu73fZBRXWjpwSZKLX3B6o1mFy6Qz25M5uirz8NW6E17aC+QCD7YfmNwxh+8Ug",
+	"A5aFN0On5Ke/Gtr89A09DwuIXpfQuLu2vgK8E2vtNVIf1YiRUtAspQqNGhz0uZCnn1iW1OujiBUZwcQ6",
+	"1/3ENKOTzLYKlTjuTiJlOxfUa+XVHJOYxZflGiQhTdLRoSsb0sLGjWH3z2LY/d4fPkUokfS8ezitDwfP",
+	"5A5sip7rNY9yqb3SvpMxFL8cZnXbltcaidEbvh2QEbxSYR3KkJeEkjRn6G4WXGlZpfqEU3RoBQvrl4yu",
+	"3XTDotRT3yTuU424PN1QJ9wIVQtSu7miItUCIg7sHwC8xKaq5RKU7nDiBcAJd60YJxVnGucqWCpFYpOB",
+	"zHVtOPrMtizohixojh7ZP0AKMjdKRFg7Fd1DSrM8d9EhZhoiFiecapKDYfovmRHozHDeg1BHPFm6q7EQ",
+	"zwN2j2Qncevsj/Yrptq65XsvADor7GefIjf9Mk/ZJywbhPzomatrfvQMS9U2cSE92D9bsEDBeBIlMnPj",
+	"u/iqLm2R20bG8wR0p4kwcbt+wo0wrQVBRk/15cih69TtnUV7OjpU09qIju/Xr/VdrKbWUiRGZaRL8/uS",
+	"6VU1x8fkfa2tvaWo627tZRQKwfFbtkdLtqdKSPfO7m2RD67Ar0iEXd3c3H+iJKKADsxpqTce32/q7v3A",
+	"vXwNz8h83W/HbA04vXmp5eallpu3PG5earnZ3ZuXWm7eMbl5x+Sv+o7JbFRCdAX6tr4soHumTUokpHbm",
+	"moGHzVpvEPS9kkzPCDleGf5PzR0AZyBpTlKqrGDEbdxzgWUJVZWmANnBCU9akNhihGbi281/rZp7Uu3v",
+	"PwCyf6fbx9otAs7b74uiKn5CVxP5jpxMTia9kSQU4gxcRXJsnlUY/mJ7bR32f9Xj/ix7W1fQjTWurGhZ",
+	"grnWVLVYsJRZlOfCKANL0YnW5gK/gDTA2fJohGn7+AviE6PcXUwMdbWHYkJ3/36/wNPVh90iVp+17OGf",
+	"V8Ae41P9Dbs+Hjg6do8h3rCMz8EyvjjT+BPVgb8p+f6VLSh0pLbedLlKYR7/mHnE7uRlJGtONrwZR4C0",
+	"kkxv8IajJfv9FMz/3xk+rkCe+cuvkvnkYLLSujzY28NX11ZC6b2JuZqab6rz0dwPdGlHcJdLKdkZvtjw",
+	"7uP/DwAA///T+v88UiwBAA==",
 }
 
 // GetSwagger returns the Swagger specification corresponding to the generated code
diff --git a/daemon/algod/api/server/v2/generated/types.go b/daemon/algod/api/server/v2/generated/types.go
index db3bd074e..c3d71a7aa 100644
--- a/daemon/algod/api/server/v2/generated/types.go
+++ b/daemon/algod/api/server/v2/generated/types.go
@@ -460,26 +460,29 @@ type StateDelta []EvalDeltaKeyValue
 type StateProof struct {
 
 	// Represents the message that the state proofs are attesting to.
-	Message struct {
+	Message StateProofMessage `json:"Message"`
 
-		// The vector commitment root on all light block headers within a state proof interval.
-		BlockHeadersCommitment []byte `json:"BlockHeadersCommitment"`
+	// The encoded StateProof for the message.
+	StateProof []byte `json:"StateProof"`
+}
 
-		// The first round the message attests to.
-		FirstAttestedRound uint64 `json:"FirstAttestedRound"`
+// StateProofMessage defines model for StateProofMessage.
+type StateProofMessage struct {
 
-		// The last round the message attests to.
-		LastAttestedRound uint64 `json:"LastAttestedRound"`
+	// The vector commitment root on all light block headers within a state proof interval.
+	BlockHeadersCommitment []byte `json:"BlockHeadersCommitment"`
 
-		// An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.
-		LnProvenWeight uint64 `json:"LnProvenWeight"`
+	// The first round the message attests to.
+	FirstAttestedRound uint64 `json:"FirstAttestedRound"`
 
-		// The vector commitment root of the top N accounts to sign the next StateProof.
-		VotersCommitment []byte `json:"VotersCommitment"`
-	} `json:"Message"`
+	// The last round the message attests to.
+	LastAttestedRound uint64 `json:"LastAttestedRound"`
 
-	// The encoded StateProof for the message.
-	StateProof []byte `json:"StateProof"`
+	// An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.
+	LnProvenWeight uint64 `json:"LnProvenWeight"`
+
+	// The vector commitment root of the top N accounts to sign the next StateProof.
+	VotersCommitment []byte `json:"VotersCommitment"`
 }
 
 // TealKeyValue defines model for TealKeyValue.
diff --git a/test/e2e-go/cli/goal/expect/catchpointCatchupWebProxy/webproxy.go b/test/e2e-go/cli/goal/expect/catchpointCatchupWebProxy/webproxy.go
index 335d5bafb..8c574c4b1 100644
--- a/test/e2e-go/cli/goal/expect/catchpointCatchupWebProxy/webproxy.go
+++ b/test/e2e-go/cli/goal/expect/catchpointCatchupWebProxy/webproxy.go
@@ -28,6 +28,7 @@ import (
 
 	"github.com/algorand/go-deadlock"
 
+	"github.com/algorand/go-algorand/logging"
 	"github.com/algorand/go-algorand/test/framework/fixtures"
 )
 
@@ -49,14 +50,15 @@ func main() {
 		return
 	}
 	var mu deadlock.Mutex
-	wp, err := fixtures.MakeWebProxy(*webProxyDestination, func(response http.ResponseWriter, request *http.Request, next http.HandlerFunc) {
+	log := logging.Base()
+	wp, err := fixtures.MakeWebProxy(*webProxyDestination, log, func(response http.ResponseWriter, request *http.Request, next http.HandlerFunc) {
 		mu.Lock()
 		time.Sleep(time.Duration(*webProxyRequestDelay) * time.Millisecond)
 		mu.Unlock()
 		// prevent requests for block #2 to go through.
 		if strings.HasSuffix(request.URL.String(), "/block/2") {
-			response.Write([]byte("webProxy prevents block 2 from serving"))
 			response.WriteHeader(http.StatusBadRequest)
+			response.Write([]byte("webProxy prevents block 2 from serving"))
 			return
 		}
 		if *webProxyLogFile != "" {
diff --git a/test/e2e-go/features/catchup/catchpointCatchup_test.go b/test/e2e-go/features/catchup/catchpointCatchup_test.go
index 98efc0b26..e5eba0e97 100644
--- a/test/e2e-go/features/catchup/catchpointCatchup_test.go
+++ b/test/e2e-go/features/catchup/catchpointCatchup_test.go
@@ -18,7 +18,6 @@ package catchup
 
 import (
 	"fmt"
-	generatedV2 "github.com/algorand/go-algorand/daemon/algod/api/server/v2/generated"
 	"net/http"
 	"os/exec"
 	"path/filepath"
@@ -32,6 +31,9 @@ import (
 
 	"github.com/algorand/go-algorand/config"
 	algodclient "github.com/algorand/go-algorand/daemon/algod/api/client"
+	generatedV2 "github.com/algorand/go-algorand/daemon/algod/api/server/v2/generated"
+	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/ledger/ledgercore"
 	"github.com/algorand/go-algorand/logging"
 	"github.com/algorand/go-algorand/nodecontrol"
 	"github.com/algorand/go-algorand/protocol"
@@ -116,11 +118,11 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 
 	// Overview of this test:
 	// Start a two-node network (primary has 100%, secondary has 0%)
-	// Nodes are having a consensus allowing balances history of 32 rounds and transaction history of 33 rounds.
-	// Let it run for 37 rounds.
-	// create a web proxy, and connect it to the primary node, blocking all requests for round #1. ( and allowing everything else )
-	// start a secondary node, and instuct it to catchpoint catchup from the proxy. ( which would be for round 36 )
-	// wait until the clone node cought up, skipping the "impossible" hole of round #1.
+	// Nodes are having a consensus allowing balances history of 8 rounds and transaction history of 13 rounds.
+	// Let it run for 21 rounds.
+	// create a web proxy, and connect it to the primary node, blocking all requests for round #2. ( and allowing everything else )
+	// start a secondary node, and instuct it to catchpoint catchup from the proxy. ( which would be for round 20 )
+	// wait until the clone node cought up, skipping the "impossible" hole of round #2.
 
 	consensus := make(config.ConsensusProtocols)
 	const consensusCatchpointCatchupTestProtocol = protocol.ConsensusVersion("catchpointtestingprotocol")
@@ -129,9 +131,9 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 	// MaxBalLookback  =  2 x SeedRefreshInterval x SeedLookback
 	// ref. https://github.com/algorandfoundation/specs/blob/master/dev/abft.md
 	catchpointCatchupProtocol.SeedLookback = 2
-	catchpointCatchupProtocol.SeedRefreshInterval = 8
-	catchpointCatchupProtocol.MaxBalLookback = 2 * catchpointCatchupProtocol.SeedLookback * catchpointCatchupProtocol.SeedRefreshInterval // 32
-	catchpointCatchupProtocol.MaxTxnLife = 33
+	catchpointCatchupProtocol.SeedRefreshInterval = 2
+	catchpointCatchupProtocol.MaxBalLookback = 2 * catchpointCatchupProtocol.SeedLookback * catchpointCatchupProtocol.SeedRefreshInterval // 8
+	catchpointCatchupProtocol.MaxTxnLife = 13
 	catchpointCatchupProtocol.CatchpointLookback = catchpointCatchupProtocol.MaxBalLookback
 	catchpointCatchupProtocol.EnableOnlineAccountCatchpoints = true
 
@@ -161,13 +163,16 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 	// prepare it's configuration file to set it to generate a catchpoint every 4 rounds.
 	cfg, err := config.LoadConfigFromDisk(primaryNode.GetDataDir())
 	a.NoError(err)
-	cfg.CatchpointInterval = 4
+	const catchpointInterval = 4
+	cfg.CatchpointInterval = catchpointInterval
 	cfg.MaxAcctLookback = 2
 	cfg.SaveToDisk(primaryNode.GetDataDir())
 	cfg.Archival = false
+	cfg.CatchpointInterval = 0
 	cfg.NetAddress = ""
 	cfg.EnableLedgerService = false
 	cfg.EnableBlockService = false
+	cfg.BaseLoggerDebugLevel = uint32(logging.Debug)
 	cfg.SaveToDisk(secondNode.GetDataDir())
 
 	// start the primary node
@@ -180,10 +185,15 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 		ExitErrorCallback: errorsCollector.nodeExitWithError,
 	})
 	a.NoError(err)
+	defer primaryNode.StopAlgod()
 
 	// Let the network make some progress
 	currentRound := uint64(1)
-	const targetRound = uint64(37)
+	expectedBlocksToDownload := catchpointCatchupProtocol.MaxTxnLife + catchpointCatchupProtocol.DeeperBlockHeaderHistory
+	const restrictedBlock = 2 // block number that is rejected to be downloaded to ensure fast catchup and not regular catchup is running
+	// calculate the target round: this is the next round after catchpoint that is greater than expectedBlocksToDownload before the restrictedBlock block number
+	targetCatchpointRound := (basics.Round(expectedBlocksToDownload+restrictedBlock)/catchpointInterval + 1) * catchpointInterval
+	targetRound := uint64(targetCatchpointRound) + 1 // 21
 	primaryNodeRestClient := fixture.GetAlgodClientForController(primaryNode)
 	primaryNodeRestClient.SetAPIVersionAffinity(algodclient.APIVersionV2)
 	log.Infof("Building ledger history..")
@@ -194,16 +204,17 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 			break
 		}
 		currentRound++
-
 	}
 	log.Infof("done building!\n")
+
 	primaryListeningAddress, err := primaryNode.GetListeningAddress()
 	a.NoError(err)
 
-	wp, err := fixtures.MakeWebProxy(primaryListeningAddress, func(response http.ResponseWriter, request *http.Request, next http.HandlerFunc) {
+	wp, err := fixtures.MakeWebProxy(primaryListeningAddress, log, func(response http.ResponseWriter, request *http.Request, next http.HandlerFunc) {
 		// prevent requests for block #2 to go through.
 		if request.URL.String() == "/v1/test-v1/block/2" {
 			response.WriteHeader(http.StatusBadRequest)
+			response.Write([]byte("webProxy prevents block 2 from serving"))
 			return
 		}
 		next(response, request)
@@ -222,6 +233,7 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 		ExitErrorCallback: errorsCollector.nodeExitWithError,
 	})
 	a.NoError(err)
+	defer secondNode.StopAlgod()
 
 	// wait until node is caught up.
 	secondNodeRestClient := fixture.GetAlgodClientForController(secondNode)
@@ -240,10 +252,32 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 	}
 	log.Infof(" - done catching up!\n")
 
-	status, err := awaitCatchpointCreation(primaryNodeRestClient, &fixture, 3)
-	a.NoError(err)
+	// ensure the catchpoint is created for targetCatchpointRound
+	var status generatedV2.NodeStatusResponse
+	timer := time.NewTimer(10 * time.Second)
+outer:
+	for {
+		status, err = primaryNodeRestClient.Status()
+		a.NoError(err)
 
-	log.Infof("primary node latest catchpoint - %s!\n", status.LastCatchpoint)
+		var round basics.Round
+		if status.LastCatchpoint != nil && len(*status.LastCatchpoint) > 0 {
+			round, _, err = ledgercore.ParseCatchpointLabel(*status.LastCatchpoint)
+			a.NoError(err)
+			if round >= targetCatchpointRound {
+				break
+			}
+		}
+		select {
+		case <-timer.C:
+			a.Failf("timeout waiting a catchpoint", "target: %d, got %d", targetCatchpointRound, round)
+			break outer
+		default:
+			time.Sleep(250 * time.Millisecond)
+		}
+	}
+
+	log.Infof("primary node latest catchpoint - %s!\n", *status.LastCatchpoint)
 	_, err = secondNodeRestClient.Catchup(*status.LastCatchpoint)
 	a.NoError(err)
 
@@ -260,9 +294,6 @@ func TestBasicCatchpointCatchup(t *testing.T) {
 		currentRound++
 	}
 	log.Infof("done catching up!\n")
-
-	secondNode.StopAlgod()
-	primaryNode.StopAlgod()
 }
 
 func TestCatchpointLabelGeneration(t *testing.T) {
@@ -295,9 +326,9 @@ func TestCatchpointLabelGeneration(t *testing.T) {
 			// MaxBalLookback  =  2 x SeedRefreshInterval x SeedLookback
 			// ref. https://github.com/algorandfoundation/specs/blob/master/dev/abft.md
 			catchpointCatchupProtocol.SeedLookback = 2
-			catchpointCatchupProtocol.SeedRefreshInterval = 8
-			catchpointCatchupProtocol.MaxBalLookback = 2 * catchpointCatchupProtocol.SeedLookback * catchpointCatchupProtocol.SeedRefreshInterval // 32
-			catchpointCatchupProtocol.MaxTxnLife = 33
+			catchpointCatchupProtocol.SeedRefreshInterval = 2
+			catchpointCatchupProtocol.MaxBalLookback = 2 * catchpointCatchupProtocol.SeedLookback * catchpointCatchupProtocol.SeedRefreshInterval // 8
+			catchpointCatchupProtocol.MaxTxnLife = 13
 			catchpointCatchupProtocol.CatchpointLookback = catchpointCatchupProtocol.MaxBalLookback
 			catchpointCatchupProtocol.EnableOnlineAccountCatchpoints = true
 
@@ -338,10 +369,11 @@ func TestCatchpointLabelGeneration(t *testing.T) {
 				ExitErrorCallback: errorsCollector.nodeExitWithError,
 			})
 			a.NoError(err)
+			defer primaryNode.StopAlgod()
 
 			// Let the network make some progress
 			currentRound := uint64(1)
-			targetRound := uint64(41)
+			targetRound := uint64(21)
 			primaryNodeRestClient := fixture.GetAlgodClientForController(primaryNode)
 			primaryNodeRestClient.SetAPIVersionAffinity(algodclient.APIVersionV2)
 			log.Infof("Building ledger history..")
@@ -364,7 +396,6 @@ func TestCatchpointLabelGeneration(t *testing.T) {
 			} else {
 				a.Empty(*primaryNodeStatus.LastCatchpoint)
 			}
-			primaryNode.StopAlgod()
 		})
 	}
 }
diff --git a/test/e2e-go/features/stateproofs/stateproofs_test.go b/test/e2e-go/features/stateproofs/stateproofs_test.go
index 5ad6f4998..8fdcfe31f 100644
--- a/test/e2e-go/features/stateproofs/stateproofs_test.go
+++ b/test/e2e-go/features/stateproofs/stateproofs_test.go
@@ -21,6 +21,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"runtime"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -111,7 +112,11 @@ func TestStateProofs(t *testing.T) {
 
 	var fixture fixtures.RestClientFixture
 	fixture.SetConsensus(configurableConsensus)
-	fixture.Setup(t, filepath.Join("nettemplates", "StateProof.json"))
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		fixture.Setup(t, filepath.Join("nettemplates", "StateProofSmall.json"))
+	} else {
+		fixture.Setup(t, filepath.Join("nettemplates", "StateProof.json"))
+	}
 	defer fixture.Shutdown()
 
 	verifyStateProofsCreation(t, &fixture, consensusParams)
@@ -219,27 +224,33 @@ func TestStateProofOverlappingKeys(t *testing.T) {
 	configurableConsensus[consensusVersion] = consensusParams
 
 	var fixture fixtures.RestClientFixture
+	pNodes := 5
 	fixture.SetConsensus(configurableConsensus)
-	fixture.Setup(t, filepath.Join("nettemplates", "StateProof.json"))
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		fixture.Setup(t, filepath.Join("nettemplates", "StateProofSmall.json"))
+		pNodes = 2
+	} else {
+		fixture.Setup(t, filepath.Join("nettemplates", "StateProof.json"))
+	}
 	defer fixture.Shutdown()
 
 	// Get node libgoal clients in order to update their participation keys
-	var libgoalNodeClients [5]libgoal.Client
-	for i := 0; i < 5; i++ {
+	libgoalNodeClients := make([]libgoal.Client, pNodes, pNodes)
+	for i := 0; i < pNodes; i++ {
 		nodeName := fmt.Sprintf("Node%d", i)
 		c := fixture.GetLibGoalClientForNamedNode(nodeName)
 		libgoalNodeClients[i] = c
 	}
 
 	// Get account address of each participating node
-	var accounts [5]string
+	accounts := make([]string, pNodes, pNodes)
 	for i, c := range libgoalNodeClients {
 		parts, err := c.GetParticipationKeys() // should have 1 participation per node
 		r.NoError(err)
 		accounts[i] = parts[0].Address
 	}
 
-	var participations [5]account.Participation
+	participations := make([]account.Participation, pNodes, pNodes)
 	var lastStateProofBlock bookkeeping.Block
 	var lastStateProofMessage stateproofmsg.Message
 	libgoalClient := fixture.LibGoalClient
@@ -251,14 +262,14 @@ func TestStateProofOverlappingKeys(t *testing.T) {
 	for rnd := uint64(1); rnd <= consensusParams.StateProofInterval*(expectedNumberOfStateProofs+1); rnd++ {
 		if rnd == voteLastValid-64 { // allow some buffer period before the voting keys are expired (for the keyreg to take effect)
 			// Generate participation keys (for the same accounts)
-			for i := 0; i < 5; i++ {
+			for i := 0; i < pNodes; i++ {
 				// Overlapping stateproof keys (the key for round 0 is valid up to 256)
 				_, part, err := installParticipationKey(t, libgoalNodeClients[i], accounts[i], 0, 200)
 				r.NoError(err)
 				participations[i] = part
 			}
 			// Register overlapping participation keys
-			for i := 0; i < 5; i++ {
+			for i := 0; i < pNodes; i++ {
 				registerParticipationAndWait(t, libgoalNodeClients[i], participations[i])
 			}
 		}
@@ -315,7 +326,11 @@ func TestStateProofMessageCommitmentVerification(t *testing.T) {
 
 	var fixture fixtures.RestClientFixture
 	fixture.SetConsensus(configurableConsensus)
-	fixture.Setup(t, filepath.Join("nettemplates", "StateProof.json"))
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		fixture.Setup(t, filepath.Join("nettemplates", "StateProofSmall.json"))
+	} else {
+		fixture.Setup(t, filepath.Join("nettemplates", "StateProof.json"))
+	}
 	defer fixture.Shutdown()
 
 	libgoalClient := fixture.LibGoalClient
@@ -439,6 +454,10 @@ func TestRecoverFromLaggingStateProofChain(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	defer fixtures.ShutdownSynchronizedTest(t)
 
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		t.Skip("This test is difficult for ARM")
+	}
+
 	r := require.New(fixtures.SynchronizedTest(t))
 
 	configurableConsensus := make(config.ConsensusProtocols)
@@ -533,6 +552,10 @@ func TestUnableToRecoverFromLaggingStateProofChain(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	defer fixtures.ShutdownSynchronizedTest(t)
 
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		t.Skip("This test is difficult for ARM")
+	}
+
 	r := require.New(fixtures.SynchronizedTest(t))
 
 	configurableConsensus := make(config.ConsensusProtocols)
@@ -649,6 +672,10 @@ func TestAttestorsChangeTest(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	defer fixtures.ShutdownSynchronizedTest(t)
 
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		t.Skip("This test is difficult for ARM")
+	}
+
 	a := require.New(fixtures.SynchronizedTest(t))
 
 	consensusParams := getDefaultStateProofConsensusParams()
@@ -765,7 +792,11 @@ func TestTotalWeightChanges(t *testing.T) {
 
 	var fixture fixtures.RestClientFixture
 	fixture.SetConsensus(configurableConsensus)
-	fixture.Setup(t, filepath.Join("nettemplates", "RichAccountStateProof.json"))
+	if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" {
+		fixture.Setup(t, filepath.Join("nettemplates", "RichAccountStateProofSmall.json"))
+	} else {
+		fixture.Setup(t, filepath.Join("nettemplates", "RichAccountStateProof.json"))
+	}
 	defer fixture.Shutdown()
 
 	var lastStateProofBlock bookkeeping.Block
diff --git a/test/framework/fixtures/webProxyFixture.go b/test/framework/fixtures/webProxyFixture.go
index 94cee4ce7..0b9e12d93 100644
--- a/test/framework/fixtures/webProxyFixture.go
+++ b/test/framework/fixtures/webProxyFixture.go
@@ -17,10 +17,11 @@
 package fixtures
 
 import (
-	"fmt"
 	"net"
 	"net/http"
 	"strings"
+
+	"github.com/algorand/go-algorand/logging"
 )
 
 // WebProxyInterceptFunc expose the web proxy intercept function
@@ -32,16 +33,16 @@ type WebProxy struct {
 	listener    net.Listener
 	destination string
 	intercept   WebProxyInterceptFunc
+	log         logging.Logger
 }
 
 // MakeWebProxy creates an instance of the web proxy
-func MakeWebProxy(destination string, intercept WebProxyInterceptFunc) (wp *WebProxy, err error) {
-	if strings.HasPrefix(destination, "http://") {
-		destination = destination[7:]
-	}
+func MakeWebProxy(destination string, log logging.Logger, intercept WebProxyInterceptFunc) (wp *WebProxy, err error) {
+	destination = strings.TrimPrefix(destination, "http://")
 	wp = &WebProxy{
 		destination: destination,
 		intercept:   intercept,
+		log:         log,
 	}
 	wp.server = &http.Server{
 		Handler: wp,
@@ -63,6 +64,7 @@ func (wp *WebProxy) GetListenAddress() string {
 
 // Close release the web proxy resources
 func (wp *WebProxy) Close() {
+	wp.log.Debugln("webproxy: quiting")
 	// we can't use shutdown, since we have tunneled websocket, which is a hijacked connection
 	// that http.Server doens't know how to handle.
 	wp.server.Close()
@@ -70,7 +72,7 @@ func (wp *WebProxy) Close() {
 
 // ServeHTTP serves a single HTTP request
 func (wp *WebProxy) ServeHTTP(response http.ResponseWriter, request *http.Request) {
-	//fmt.Printf("incoming request for %v\n", request.URL)
+	wp.log.Debugf("webproxy: incoming request for %v", request.URL)
 	if wp.intercept == nil {
 		wp.Passthrough(response, request)
 		return
@@ -86,7 +88,7 @@ func (wp *WebProxy) Passthrough(response http.ResponseWriter, request *http.Requ
 	clientRequestURL.Host = wp.destination
 	clientRequest, err := http.NewRequest(request.Method, clientRequestURL.String(), request.Body)
 	if err != nil {
-		fmt.Printf("Passthrough request assembly error %v (%#v)\n", err, clientRequestURL)
+		wp.log.Debugf("Passthrough request assembly error %v (%#v)", err, clientRequestURL)
 		response.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -99,7 +101,7 @@ func (wp *WebProxy) Passthrough(response http.ResponseWriter, request *http.Requ
 	}
 	clientResponse, err := client.Do(clientRequest)
 	if err != nil {
-		fmt.Printf("Passthrough request error %v (%v)\n", err, request.URL.String())
+		wp.log.Debugf("Passthrough request error %v (%v)", err, request.URL.String())
 		response.WriteHeader(http.StatusInternalServerError)
 		return
 	}
diff --git a/test/testdata/nettemplates/RichAccountStateProofSmall.json b/test/testdata/nettemplates/RichAccountStateProofSmall.json
new file mode 100644
index 000000000..bd2fd8ee5
--- /dev/null
+++ b/test/testdata/nettemplates/RichAccountStateProofSmall.json
@@ -0,0 +1,20 @@
+{
+    "Genesis": {
+        "NetworkName": "tbd",
+        "ConsensusProtocol": "test-fast-stateproofs",
+        "LastPartKeyRound": 100,
+        "Wallets": [
+            { "Name": "richWallet", "Stake": 99, "Online": true },
+            { "Name": "poorWallet", "Stake": 1, "Online": true }
+        ]
+    },
+    "Nodes": [
+        {
+            "Name": "Relay0",
+            "IsRelay": true,
+            "Wallets": []
+        },
+        { "Name": "richNode", "Wallets": [ { "Name": "richWallet", "ParticipationOnly": false } ] },
+        { "Name": "poorNode", "Wallets": [ { "Name": "poorWallet", "ParticipationOnly": false } ] }
+    ]
+}
diff --git a/test/testdata/nettemplates/StateProofSmall.json b/test/testdata/nettemplates/StateProofSmall.json
new file mode 100644
index 000000000..cfe7d6936
--- /dev/null
+++ b/test/testdata/nettemplates/StateProofSmall.json
@@ -0,0 +1,20 @@
+{
+    "Genesis": {
+        "NetworkName": "tbd",
+        "ConsensusProtocol": "test-fast-stateproofs",
+        "LastPartKeyRound": 100,
+        "Wallets": [
+            { "Name": "Wallet0", "Stake": 50, "Online": true },
+            { "Name": "Wallet1", "Stake": 50, "Online": true }
+        ]
+    },
+    "Nodes": [
+        {
+            "Name": "Relay0",
+            "IsRelay": true,
+            "Wallets": []
+        },
+        { "Name": "Node0", "Wallets": [ { "Name": "Wallet0", "ParticipationOnly": false } ] },
+        { "Name": "Node1", "Wallets": [ { "Name": "Wallet1", "ParticipationOnly": false } ] }
+    ]
+}