github.com/onflow/flow-go@v0.33.17/utils/unittest/service_events_fixtures.go (about)

     1  package unittest
     2  
     3  import (
     4  	"crypto/rand"
     5  	"encoding/hex"
     6  
     7  	"github.com/onflow/cadence"
     8  	"github.com/onflow/cadence/encoding/ccf"
     9  	"github.com/onflow/cadence/runtime/common"
    10  
    11  	"github.com/onflow/flow-go/crypto"
    12  	"github.com/onflow/flow-go/fvm/systemcontracts"
    13  	"github.com/onflow/flow-go/model/flow"
    14  )
    15  
    16  // This file contains service event fixtures for testing purposes.
    17  
    18  func EpochSetupRandomSourceFixture() []byte {
    19  	source := make([]byte, flow.EpochSetupRandomSourceLength)
    20  	_, err := rand.Read(source)
    21  	if err != nil {
    22  		panic(err)
    23  	}
    24  	return source
    25  }
    26  
    27  // EpochSetupFixtureByChainID returns an EpochSetup service event as a Cadence event
    28  // representation and as a protocol model representation.
    29  func EpochSetupFixtureByChainID(chain flow.ChainID) (flow.Event, *flow.EpochSetup) {
    30  	events := systemcontracts.ServiceEventsForChain(chain)
    31  
    32  	event := EventFixture(events.EpochSetup.EventType(), 1, 1, IdentifierFixture(), 0)
    33  	randomSource := EpochSetupRandomSourceFixture()
    34  	event.Payload = EpochSetupFixtureCCF(randomSource)
    35  
    36  	expected := &flow.EpochSetup{
    37  		Counter:            1,
    38  		FirstView:          100,
    39  		FinalView:          200,
    40  		DKGPhase1FinalView: 150,
    41  		DKGPhase2FinalView: 160,
    42  		DKGPhase3FinalView: 170,
    43  		RandomSource:       randomSource,
    44  		Assignments: flow.AssignmentList{
    45  			{
    46  				flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000001"),
    47  				flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000002"),
    48  			},
    49  			{
    50  				flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000003"),
    51  				flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000004"),
    52  			},
    53  		},
    54  		Participants: flow.IdentityList{
    55  			{
    56  				Role:          flow.RoleCollection,
    57  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000001"),
    58  				Address:       "1.flow.com",
    59  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
    60  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
    61  				Weight:        100,
    62  			},
    63  			{
    64  				Role:          flow.RoleCollection,
    65  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000002"),
    66  				Address:       "2.flow.com",
    67  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
    68  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
    69  				Weight:        100,
    70  			},
    71  			{
    72  				Role:          flow.RoleCollection,
    73  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000003"),
    74  				Address:       "3.flow.com",
    75  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
    76  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
    77  				Weight:        100,
    78  			},
    79  			{
    80  				Role:          flow.RoleCollection,
    81  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000004"),
    82  				Address:       "4.flow.com",
    83  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
    84  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
    85  				Weight:        100,
    86  			},
    87  			{
    88  				Role:          flow.RoleConsensus,
    89  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000011"),
    90  				Address:       "11.flow.com",
    91  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "cfdfe8e4362c8f79d11772cb7277ab16e5033a63e8dd5d34caf1b041b77e5b2d63c2072260949ccf8907486e4cfc733c8c42ca0e4e208f30470b0d950856cd47"),
    92  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "8207559cd7136af378bba53a8f0196dee3849a3ab02897c1995c3e3f6ca0c4a776c3ae869d1ddbb473090054be2400ad06d7910aa2c5d1780220fdf3765a3c1764bce10c6fe66a5a2be51a422e878518bd750424bb56b8a0ecf0f8ad2057e83f"),
    93  				Weight:        100,
    94  			},
    95  			{
    96  				Role:          flow.RoleExecution,
    97  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000021"),
    98  				Address:       "21.flow.com",
    99  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "d64318ba0dbf68f3788fc81c41d507c5822bf53154530673127c66f50fe4469ccf1a054a868a9f88506a8999f2386d86fcd2b901779718cba4fb53c2da258f9e"),
   100  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "880b162b7ec138b36af401d07868cb08d25746d905395edbb4625bdf105d4bb2b2f4b0f4ae273a296a6efefa7ce9ccb914e39947ce0e83745125cab05d62516076ff0173ed472d3791ccef937597c9ea12381d76f547a092a4981d77ff3fba83"),
   101  				Weight:        100,
   102  			},
   103  			{
   104  				Role:          flow.RoleVerification,
   105  				NodeID:        flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000031"),
   106  				Address:       "31.flow.com",
   107  				NetworkPubKey: MustDecodePublicKeyHex(crypto.ECDSAP256, "697241208dcc9142b6f53064adc8ff1c95760c68beb2ba083c1d005d40181fd7a1b113274e0163c053a3addd47cd528ec6a1f190cf465aac87c415feaae011ae"),
   108  				StakingPubKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "b1f97d0a06020eca97352e1adde72270ee713c7daf58da7e74bf72235321048b4841bdfc28227964bf18e371e266e32107d238358848bcc5d0977a0db4bda0b4c33d3874ff991e595e0f537c7b87b4ddce92038ebc7b295c9ea20a1492302aa7"),
   109  				Weight:        100,
   110  			},
   111  		},
   112  	}
   113  
   114  	return event, expected
   115  }
   116  
   117  // EpochCommitFixture returns an EpochCommit service event as a Cadence event
   118  // representation and as a protocol model representation.
   119  func EpochCommitFixtureByChainID(chain flow.ChainID) (flow.Event, *flow.EpochCommit) {
   120  
   121  	events := systemcontracts.ServiceEventsForChain(chain)
   122  
   123  	event := EventFixture(events.EpochCommit.EventType(), 1, 1, IdentifierFixture(), 0)
   124  	event.Payload = EpochCommitFixtureCCF
   125  
   126  	expected := &flow.EpochCommit{
   127  		Counter: 1,
   128  		ClusterQCs: []flow.ClusterQCVoteData{
   129  			{
   130  				VoterIDs: []flow.Identifier{
   131  					flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000001"),
   132  					flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000002"),
   133  				},
   134  				SigData: MustDecodeSignatureHex("b072ed22ed305acd44818a6c836e09b4e844eebde6a4fdbf5cec983e2872b86c8b0f6c34c0777bf52e385ab7c45dc55d"),
   135  			},
   136  			{
   137  				VoterIDs: []flow.Identifier{
   138  					flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000003"),
   139  					flow.MustHexStringToIdentifier("0000000000000000000000000000000000000000000000000000000000000004"),
   140  				},
   141  				SigData: MustDecodeSignatureHex("899e266a543e1b3a564f68b22f7be571f2e944ec30fadc4b39e2d5f526ba044c0f3cb2648f8334fc216fa3360a0418b2"),
   142  			},
   143  		},
   144  		DKGGroupKey: MustDecodePublicKeyHex(crypto.BLSBLS12381, "8c588266db5f5cda629e83f8aa04ae9413593fac19e4865d06d291c9d14fbdd9bdb86a7a12f9ef8590c79cb635e3163315d193087e9336092987150d0cd2b14ac6365f7dc93eec573752108b8c12368abb65f0652d9f644e5aed611c37926950"),
   145  		DKGParticipantKeys: []crypto.PublicKey{
   146  			MustDecodePublicKeyHex(crypto.BLSBLS12381, "87a339e4e5c74f089da20a33f515d8c8f4464ab53ede5a74aa2432cd1ae66d522da0c122249ee176cd747ddc83ca81090498389384201614caf51eac392c1c0a916dfdcfbbdf7363f9552b6468434add3d3f6dc91a92bbe3ee368b59b7828488"),
   147  		},
   148  	}
   149  
   150  	return event, expected
   151  }
   152  
   153  // VersionBeaconFixtureByChainID returns a VersionTable service event as a Cadence event
   154  // representation and as a protocol model representation.
   155  func VersionBeaconFixtureByChainID(chain flow.ChainID) (flow.Event, *flow.VersionBeacon) {
   156  
   157  	events := systemcontracts.ServiceEventsForChain(chain)
   158  
   159  	event := EventFixture(events.VersionBeacon.EventType(), 1, 1, IdentifierFixture(), 0)
   160  	event.Payload = VersionBeaconFixtureCCF
   161  
   162  	expected := &flow.VersionBeacon{
   163  		VersionBoundaries: []flow.VersionBoundary{
   164  			{
   165  				BlockHeight: 44,
   166  				Version:     "2.13.7-test",
   167  			},
   168  		},
   169  		Sequence: 5,
   170  	}
   171  
   172  	return event, expected
   173  }
   174  
   175  func createEpochSetupEvent(randomSource []byte) cadence.Event {
   176  	randomSourceHex := hex.EncodeToString(randomSource)
   177  
   178  	return cadence.NewEvent([]cadence.Value{
   179  		// counter
   180  		cadence.NewUInt64(1),
   181  
   182  		// nodeInfo
   183  		createEpochNodes(),
   184  
   185  		// firstView
   186  		cadence.NewUInt64(100),
   187  
   188  		// finalView
   189  		cadence.NewUInt64(200),
   190  
   191  		// collectorClusters
   192  		createEpochCollectors(),
   193  
   194  		// randomSource
   195  		cadence.String(randomSourceHex),
   196  
   197  		// DKGPhase1FinalView
   198  		cadence.UInt64(150),
   199  
   200  		// DKGPhase2FinalView
   201  		cadence.UInt64(160),
   202  
   203  		// DKGPhase3FinalView
   204  		cadence.UInt64(170),
   205  	}).WithType(newFlowEpochEpochSetupEventType())
   206  }
   207  
   208  func createEpochNodes() cadence.Array {
   209  
   210  	nodeInfoType := newFlowIDTableStakingNodeInfoStructType()
   211  
   212  	nodeInfo1 := cadence.NewStruct([]cadence.Value{
   213  		// id
   214  		cadence.String("0000000000000000000000000000000000000000000000000000000000000001"),
   215  
   216  		// role
   217  		cadence.UInt8(1),
   218  
   219  		// networkingAddress
   220  		cadence.String("1.flow.com"),
   221  
   222  		// networkingKey
   223  		cadence.String("378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
   224  
   225  		// stakingKey
   226  		cadence.String("af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
   227  
   228  		// tokensStaked
   229  		ufix64FromString("0.00000000"),
   230  
   231  		// tokensCommitted
   232  		ufix64FromString("1350000.00000000"),
   233  
   234  		// tokensUnstaking
   235  		ufix64FromString("0.00000000"),
   236  
   237  		// tokensUnstaked
   238  		ufix64FromString("0.00000000"),
   239  
   240  		// tokensRewarded
   241  		ufix64FromString("0.00000000"),
   242  
   243  		// delegators
   244  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   245  
   246  		// delegatorIDCounter
   247  		cadence.UInt32(0),
   248  
   249  		// tokensRequestedToUnstake
   250  		ufix64FromString("0.00000000"),
   251  
   252  		// initialWeight
   253  		cadence.UInt64(100),
   254  	}).WithType(nodeInfoType)
   255  
   256  	nodeInfo2 := cadence.NewStruct([]cadence.Value{
   257  		// id
   258  		cadence.String("0000000000000000000000000000000000000000000000000000000000000002"),
   259  
   260  		// role
   261  		cadence.UInt8(1),
   262  
   263  		// networkingAddress
   264  		cadence.String("2.flow.com"),
   265  
   266  		// networkingKey
   267  		cadence.String("378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
   268  
   269  		// stakingKey
   270  		cadence.String("af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
   271  
   272  		// tokensStaked
   273  		ufix64FromString("0.00000000"),
   274  
   275  		// tokensCommitted
   276  		ufix64FromString("1350000.00000000"),
   277  
   278  		// tokensUnstaking
   279  		ufix64FromString("0.00000000"),
   280  
   281  		// tokensUnstaked
   282  		ufix64FromString("0.00000000"),
   283  
   284  		// tokensRewarded
   285  		ufix64FromString("0.00000000"),
   286  
   287  		// delegators
   288  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   289  
   290  		// delegatorIDCounter
   291  		cadence.UInt32(0),
   292  
   293  		// tokensRequestedToUnstake
   294  		ufix64FromString("0.00000000"),
   295  
   296  		// initialWeight
   297  		cadence.UInt64(100),
   298  	}).WithType(nodeInfoType)
   299  
   300  	nodeInfo3 := cadence.NewStruct([]cadence.Value{
   301  		// id
   302  		cadence.String("0000000000000000000000000000000000000000000000000000000000000003"),
   303  
   304  		// role
   305  		cadence.UInt8(1),
   306  
   307  		// networkingAddress
   308  		cadence.String("3.flow.com"),
   309  
   310  		// networkingKey
   311  		cadence.String("378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
   312  
   313  		// stakingKey
   314  		cadence.String("af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
   315  
   316  		// tokensStaked
   317  		ufix64FromString("0.00000000"),
   318  
   319  		// tokensCommitted
   320  		ufix64FromString("1350000.00000000"),
   321  
   322  		// tokensUnstaking
   323  		ufix64FromString("0.00000000"),
   324  
   325  		// tokensUnstaked
   326  		ufix64FromString("0.00000000"),
   327  
   328  		// tokensRewarded
   329  		ufix64FromString("0.00000000"),
   330  
   331  		// delegators
   332  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   333  
   334  		// delegatorIDCounter
   335  		cadence.UInt32(0),
   336  
   337  		// tokensRequestedToUnstake
   338  		ufix64FromString("0.00000000"),
   339  
   340  		// initialWeight
   341  		cadence.UInt64(100),
   342  	}).WithType(nodeInfoType)
   343  
   344  	nodeInfo4 := cadence.NewStruct([]cadence.Value{
   345  		// id
   346  		cadence.String("0000000000000000000000000000000000000000000000000000000000000004"),
   347  
   348  		// role
   349  		cadence.UInt8(1),
   350  
   351  		// networkingAddress
   352  		cadence.String("4.flow.com"),
   353  
   354  		// networkingKey
   355  		cadence.String("378dbf45d85c614feb10d8bd4f78f4b6ef8eec7d987b937e123255444657fb3da031f232a507e323df3a6f6b8f50339c51d188e80c0e7a92420945cc6ca893fc"),
   356  
   357  		// stakingKey
   358  		cadence.String("af4aade26d76bb2ab15dcc89adcef82a51f6f04b3cb5f4555214b40ec89813c7a5f95776ea4fe449de48166d0bbc59b919b7eabebaac9614cf6f9461fac257765415f4d8ef1376a2365ec9960121888ea5383d88a140c24c29962b0a14e4e4e7"),
   359  
   360  		// tokensStaked
   361  		ufix64FromString("0.00000000"),
   362  
   363  		// tokensCommitted
   364  		ufix64FromString("1350000.00000000"),
   365  
   366  		// tokensUnstaking
   367  		ufix64FromString("0.00000000"),
   368  
   369  		// tokensUnstaked
   370  		ufix64FromString("0.00000000"),
   371  
   372  		// tokensRewarded
   373  		ufix64FromString("0.00000000"),
   374  
   375  		// delegators
   376  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   377  
   378  		// delegatorIDCounter
   379  		cadence.UInt32(0),
   380  
   381  		// tokensRequestedToUnstake
   382  		ufix64FromString("0.00000000"),
   383  
   384  		// initialWeight
   385  		cadence.UInt64(100),
   386  	}).WithType(nodeInfoType)
   387  
   388  	nodeInfo5 := cadence.NewStruct([]cadence.Value{
   389  		// id
   390  		cadence.String("0000000000000000000000000000000000000000000000000000000000000011"),
   391  
   392  		// role
   393  		cadence.UInt8(2),
   394  
   395  		// networkingAddress
   396  		cadence.String("11.flow.com"),
   397  
   398  		// networkingKey
   399  		cadence.String("cfdfe8e4362c8f79d11772cb7277ab16e5033a63e8dd5d34caf1b041b77e5b2d63c2072260949ccf8907486e4cfc733c8c42ca0e4e208f30470b0d950856cd47"),
   400  
   401  		// stakingKey
   402  		cadence.String("8207559cd7136af378bba53a8f0196dee3849a3ab02897c1995c3e3f6ca0c4a776c3ae869d1ddbb473090054be2400ad06d7910aa2c5d1780220fdf3765a3c1764bce10c6fe66a5a2be51a422e878518bd750424bb56b8a0ecf0f8ad2057e83f"),
   403  
   404  		// tokensStaked
   405  		ufix64FromString("0.00000000"),
   406  
   407  		// tokensCommitted
   408  		ufix64FromString("1350000.00000000"),
   409  
   410  		// tokensUnstaking
   411  		ufix64FromString("0.00000000"),
   412  
   413  		// tokensUnstaked
   414  		ufix64FromString("0.00000000"),
   415  
   416  		// tokensRewarded
   417  		ufix64FromString("0.00000000"),
   418  
   419  		// delegators
   420  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   421  
   422  		// delegatorIDCounter
   423  		cadence.UInt32(0),
   424  
   425  		// tokensRequestedToUnstake
   426  		ufix64FromString("0.00000000"),
   427  
   428  		// initialWeight
   429  		cadence.UInt64(100),
   430  	}).WithType(nodeInfoType)
   431  
   432  	nodeInfo6 := cadence.NewStruct([]cadence.Value{
   433  		// id
   434  		cadence.String("0000000000000000000000000000000000000000000000000000000000000021"),
   435  
   436  		// role
   437  		cadence.UInt8(3),
   438  
   439  		// networkingAddress
   440  		cadence.String("21.flow.com"),
   441  
   442  		// networkingKey
   443  		cadence.String("d64318ba0dbf68f3788fc81c41d507c5822bf53154530673127c66f50fe4469ccf1a054a868a9f88506a8999f2386d86fcd2b901779718cba4fb53c2da258f9e"),
   444  
   445  		// stakingKey
   446  		cadence.String("880b162b7ec138b36af401d07868cb08d25746d905395edbb4625bdf105d4bb2b2f4b0f4ae273a296a6efefa7ce9ccb914e39947ce0e83745125cab05d62516076ff0173ed472d3791ccef937597c9ea12381d76f547a092a4981d77ff3fba83"),
   447  
   448  		// tokensStaked
   449  		ufix64FromString("0.00000000"),
   450  
   451  		// tokensCommitted
   452  		ufix64FromString("1350000.00000000"),
   453  
   454  		// tokensUnstaking
   455  		ufix64FromString("0.00000000"),
   456  
   457  		// tokensUnstaked
   458  		ufix64FromString("0.00000000"),
   459  
   460  		// tokensRewarded
   461  		ufix64FromString("0.00000000"),
   462  
   463  		// delegators
   464  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   465  
   466  		// delegatorIDCounter
   467  		cadence.UInt32(0),
   468  
   469  		// tokensRequestedToUnstake
   470  		ufix64FromString("0.00000000"),
   471  
   472  		// initialWeight
   473  		cadence.UInt64(100),
   474  	}).WithType(nodeInfoType)
   475  
   476  	nodeInfo7 := cadence.NewStruct([]cadence.Value{
   477  		// id
   478  		cadence.String("0000000000000000000000000000000000000000000000000000000000000031"),
   479  
   480  		// role
   481  		cadence.UInt8(4),
   482  
   483  		// networkingAddress
   484  		cadence.String("31.flow.com"),
   485  
   486  		// networkingKey
   487  		cadence.String("697241208dcc9142b6f53064adc8ff1c95760c68beb2ba083c1d005d40181fd7a1b113274e0163c053a3addd47cd528ec6a1f190cf465aac87c415feaae011ae"),
   488  
   489  		// stakingKey
   490  		cadence.String("b1f97d0a06020eca97352e1adde72270ee713c7daf58da7e74bf72235321048b4841bdfc28227964bf18e371e266e32107d238358848bcc5d0977a0db4bda0b4c33d3874ff991e595e0f537c7b87b4ddce92038ebc7b295c9ea20a1492302aa7"),
   491  
   492  		// tokensStaked
   493  		ufix64FromString("0.00000000"),
   494  
   495  		// tokensCommitted
   496  		ufix64FromString("1350000.00000000"),
   497  
   498  		// tokensUnstaking
   499  		ufix64FromString("0.00000000"),
   500  
   501  		// tokensUnstaked
   502  		ufix64FromString("0.00000000"),
   503  
   504  		// tokensRewarded
   505  		ufix64FromString("0.00000000"),
   506  
   507  		// delegators
   508  		cadence.NewArray([]cadence.Value{}).WithType(cadence.NewVariableSizedArrayType(cadence.NewUInt32Type())),
   509  
   510  		// delegatorIDCounter
   511  		cadence.UInt32(0),
   512  
   513  		// tokensRequestedToUnstake
   514  		ufix64FromString("0.00000000"),
   515  
   516  		// initialWeight
   517  		cadence.UInt64(100),
   518  	}).WithType(nodeInfoType)
   519  
   520  	return cadence.NewArray([]cadence.Value{
   521  		nodeInfo1,
   522  		nodeInfo2,
   523  		nodeInfo3,
   524  		nodeInfo4,
   525  		nodeInfo5,
   526  		nodeInfo6,
   527  		nodeInfo7,
   528  	}).WithType(cadence.NewVariableSizedArrayType(nodeInfoType))
   529  }
   530  
   531  func createEpochCollectors() cadence.Array {
   532  
   533  	clusterType := newFlowClusterQCClusterStructType()
   534  
   535  	voteType := newFlowClusterQCVoteStructType()
   536  
   537  	cluster1 := cadence.NewStruct([]cadence.Value{
   538  		// index
   539  		cadence.NewUInt16(0),
   540  
   541  		// nodeWeights
   542  		cadence.NewDictionary([]cadence.KeyValuePair{
   543  			{
   544  				Key:   cadence.String("0000000000000000000000000000000000000000000000000000000000000001"),
   545  				Value: cadence.UInt64(100),
   546  			},
   547  			{
   548  				Key:   cadence.String("0000000000000000000000000000000000000000000000000000000000000002"),
   549  				Value: cadence.UInt64(100),
   550  			},
   551  		}).WithType(cadence.NewMeteredDictionaryType(nil, cadence.StringType{}, cadence.UInt64Type{})),
   552  
   553  		// totalWeight
   554  		cadence.NewUInt64(100),
   555  
   556  		// generatedVotes
   557  		cadence.NewDictionary(nil).WithType(cadence.NewDictionaryType(cadence.StringType{}, voteType)),
   558  
   559  		// uniqueVoteMessageTotalWeights
   560  		cadence.NewDictionary(nil).WithType(cadence.NewDictionaryType(cadence.StringType{}, cadence.UInt64Type{})),
   561  	}).WithType(clusterType)
   562  
   563  	cluster2 := cadence.NewStruct([]cadence.Value{
   564  		// index
   565  		cadence.NewUInt16(1),
   566  
   567  		// nodeWeights
   568  		cadence.NewDictionary([]cadence.KeyValuePair{
   569  			{
   570  				Key:   cadence.String("0000000000000000000000000000000000000000000000000000000000000003"),
   571  				Value: cadence.UInt64(100),
   572  			},
   573  			{
   574  				Key:   cadence.String("0000000000000000000000000000000000000000000000000000000000000004"),
   575  				Value: cadence.UInt64(100),
   576  			},
   577  		}).WithType(cadence.NewMeteredDictionaryType(nil, cadence.StringType{}, cadence.UInt64Type{})),
   578  
   579  		// totalWeight
   580  		cadence.NewUInt64(0),
   581  
   582  		// generatedVotes
   583  		cadence.NewDictionary(nil).WithType(cadence.NewDictionaryType(cadence.StringType{}, voteType)),
   584  
   585  		// uniqueVoteMessageTotalWeights
   586  		cadence.NewDictionary(nil).WithType(cadence.NewDictionaryType(cadence.StringType{}, cadence.UInt64Type{})),
   587  	}).WithType(clusterType)
   588  
   589  	return cadence.NewArray([]cadence.Value{
   590  		cluster1,
   591  		cluster2,
   592  	}).WithType(cadence.NewVariableSizedArrayType(clusterType))
   593  }
   594  
   595  func createEpochCommittedEvent() cadence.Event {
   596  
   597  	clusterQCType := newFlowClusterQCClusterQCStructType()
   598  
   599  	cluster1 := cadence.NewStruct([]cadence.Value{
   600  		// index
   601  		cadence.UInt16(0),
   602  
   603  		// voteSignatures
   604  		cadence.NewArray([]cadence.Value{
   605  			cadence.String("a39cd1e1bf7e2fb0609b7388ce5215a6a4c01eef2aee86e1a007faa28a6b2a3dc876e11bb97cdb26c3846231d2d01e4d"),
   606  			cadence.String("91673ad9c717d396c9a0953617733c128049ac1a639653d4002ab245b121df1939430e313bcbfd06948f6a281f6bf853"),
   607  		}).WithType(cadence.NewVariableSizedArrayType(cadence.StringType{})),
   608  
   609  		// voteMessage
   610  		cadence.String("irrelevant_for_these_purposes"),
   611  
   612  		// voterIDs
   613  		cadence.NewArray([]cadence.Value{
   614  			cadence.String("0000000000000000000000000000000000000000000000000000000000000001"),
   615  			cadence.String("0000000000000000000000000000000000000000000000000000000000000002"),
   616  		}).WithType(cadence.NewVariableSizedArrayType(cadence.StringType{})),
   617  	}).WithType(clusterQCType)
   618  
   619  	cluster2 := cadence.NewStruct([]cadence.Value{
   620  		// index
   621  		cadence.UInt16(1),
   622  
   623  		// voteSignatures
   624  		cadence.NewArray([]cadence.Value{
   625  			cadence.String("b2bff159971852ed63e72c37991e62c94822e52d4fdcd7bf29aaf9fb178b1c5b4ce20dd9594e029f3574cb29533b857a"),
   626  			cadence.String("9931562f0248c9195758da3de4fb92f24fa734cbc20c0cb80280163560e0e0348f843ac89ecbd3732e335940c1e8dccb"),
   627  		}).WithType(cadence.NewVariableSizedArrayType(cadence.StringType{})),
   628  
   629  		// voteMessage
   630  		cadence.String("irrelevant_for_these_purposes"),
   631  
   632  		// voterIDs
   633  		cadence.NewArray([]cadence.Value{
   634  			cadence.String("0000000000000000000000000000000000000000000000000000000000000003"),
   635  			cadence.String("0000000000000000000000000000000000000000000000000000000000000004"),
   636  		}).WithType(cadence.NewVariableSizedArrayType(cadence.StringType{})),
   637  	}).WithType(clusterQCType)
   638  
   639  	return cadence.NewEvent([]cadence.Value{
   640  		// counter
   641  		cadence.NewUInt64(1),
   642  
   643  		// clusterQCs
   644  		cadence.NewArray([]cadence.Value{
   645  			cluster1,
   646  			cluster2,
   647  		}).WithType(cadence.NewVariableSizedArrayType(clusterQCType)),
   648  
   649  		// dkgPubKeys
   650  		cadence.NewArray([]cadence.Value{
   651  			cadence.String("8c588266db5f5cda629e83f8aa04ae9413593fac19e4865d06d291c9d14fbdd9bdb86a7a12f9ef8590c79cb635e3163315d193087e9336092987150d0cd2b14ac6365f7dc93eec573752108b8c12368abb65f0652d9f644e5aed611c37926950"),
   652  			cadence.String("87a339e4e5c74f089da20a33f515d8c8f4464ab53ede5a74aa2432cd1ae66d522da0c122249ee176cd747ddc83ca81090498389384201614caf51eac392c1c0a916dfdcfbbdf7363f9552b6468434add3d3f6dc91a92bbe3ee368b59b7828488"),
   653  		}).WithType(cadence.NewVariableSizedArrayType(cadence.StringType{})),
   654  	}).WithType(newFlowEpochEpochCommittedEventType())
   655  }
   656  
   657  func createVersionBeaconEvent() cadence.Event {
   658  	versionBoundaryType := NewNodeVersionBeaconVersionBoundaryStructType()
   659  
   660  	semverType := NewNodeVersionBeaconSemverStructType()
   661  
   662  	semver := cadence.NewStruct([]cadence.Value{
   663  		// major
   664  		cadence.UInt8(2),
   665  
   666  		// minor
   667  		cadence.UInt8(13),
   668  
   669  		// patch
   670  		cadence.UInt8(7),
   671  
   672  		// preRelease
   673  		cadence.NewOptional(cadence.String("test")),
   674  	}).WithType(semverType)
   675  
   676  	versionBoundary := cadence.NewStruct([]cadence.Value{
   677  		// blockHeight
   678  		cadence.UInt64(44),
   679  
   680  		// version
   681  		semver,
   682  	}).WithType(versionBoundaryType)
   683  
   684  	return cadence.NewEvent([]cadence.Value{
   685  		// versionBoundaries
   686  		cadence.NewArray([]cadence.Value{
   687  			versionBoundary,
   688  		}).WithType(cadence.NewVariableSizedArrayType(versionBoundaryType)),
   689  
   690  		// sequence
   691  		cadence.UInt64(5),
   692  	}).WithType(NewNodeVersionBeaconVersionBeaconEventType())
   693  }
   694  
   695  func newFlowClusterQCVoteStructType() cadence.Type {
   696  
   697  	// A.01cf0e2f2f715450.FlowClusterQC.Vote
   698  
   699  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   700  	location := common.NewAddressLocation(nil, address, "FlowClusterQC")
   701  
   702  	return &cadence.StructType{
   703  		Location:            location,
   704  		QualifiedIdentifier: "FlowClusterQC.Vote",
   705  		Fields: []cadence.Field{
   706  			{
   707  				Identifier: "nodeID",
   708  				Type:       cadence.StringType{},
   709  			},
   710  			{
   711  				Identifier: "signature",
   712  				Type:       cadence.NewOptionalType(cadence.StringType{}),
   713  			},
   714  			{
   715  				Identifier: "message",
   716  				Type:       cadence.NewOptionalType(cadence.StringType{}),
   717  			},
   718  			{
   719  				Identifier: "clusterIndex",
   720  				Type:       cadence.UInt16Type{},
   721  			},
   722  			{
   723  				Identifier: "weight",
   724  				Type:       cadence.UInt64Type{},
   725  			},
   726  		},
   727  	}
   728  }
   729  
   730  func newFlowClusterQCClusterStructType() *cadence.StructType {
   731  
   732  	// A.01cf0e2f2f715450.FlowClusterQC.Cluster
   733  
   734  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   735  	location := common.NewAddressLocation(nil, address, "FlowClusterQC")
   736  
   737  	return &cadence.StructType{
   738  		Location:            location,
   739  		QualifiedIdentifier: "FlowClusterQC.Cluster",
   740  		Fields: []cadence.Field{
   741  			{
   742  				Identifier: "index",
   743  				Type:       cadence.UInt16Type{},
   744  			},
   745  			{
   746  				Identifier: "nodeWeights",
   747  				Type:       cadence.NewDictionaryType(cadence.StringType{}, cadence.UInt64Type{}),
   748  			},
   749  			{
   750  				Identifier: "totalWeight",
   751  				Type:       cadence.UInt64Type{},
   752  			},
   753  			{
   754  				Identifier: "generatedVotes",
   755  				Type:       cadence.NewDictionaryType(cadence.StringType{}, newFlowClusterQCVoteStructType()),
   756  			},
   757  			{
   758  				Identifier: "uniqueVoteMessageTotalWeights",
   759  				Type:       cadence.NewDictionaryType(cadence.StringType{}, cadence.UInt64Type{}),
   760  			},
   761  		},
   762  	}
   763  }
   764  
   765  func newFlowIDTableStakingNodeInfoStructType() *cadence.StructType {
   766  
   767  	// A.01cf0e2f2f715450.FlowIDTableStaking.NodeInfo
   768  
   769  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   770  	location := common.NewAddressLocation(nil, address, "FlowIDTableStaking")
   771  
   772  	return &cadence.StructType{
   773  		Location:            location,
   774  		QualifiedIdentifier: "FlowIDTableStaking.NodeInfo",
   775  		Fields: []cadence.Field{
   776  			{
   777  				Identifier: "id",
   778  				Type:       cadence.StringType{},
   779  			},
   780  			{
   781  				Identifier: "role",
   782  				Type:       cadence.UInt8Type{},
   783  			},
   784  			{
   785  				Identifier: "networkingAddress",
   786  				Type:       cadence.StringType{},
   787  			},
   788  			{
   789  				Identifier: "networkingKey",
   790  				Type:       cadence.StringType{},
   791  			},
   792  			{
   793  				Identifier: "stakingKey",
   794  				Type:       cadence.StringType{},
   795  			},
   796  			{
   797  				Identifier: "tokensStaked",
   798  				Type:       cadence.UFix64Type{},
   799  			},
   800  			{
   801  				Identifier: "tokensCommitted",
   802  				Type:       cadence.UFix64Type{},
   803  			},
   804  			{
   805  				Identifier: "tokensUnstaking",
   806  				Type:       cadence.UFix64Type{},
   807  			},
   808  			{
   809  				Identifier: "tokensUnstaked",
   810  				Type:       cadence.UFix64Type{},
   811  			},
   812  			{
   813  				Identifier: "tokensRewarded",
   814  				Type:       cadence.UFix64Type{},
   815  			},
   816  			{
   817  				Identifier: "delegators",
   818  				Type:       cadence.NewVariableSizedArrayType(cadence.NewUInt32Type()),
   819  			},
   820  			{
   821  				Identifier: "delegatorIDCounter",
   822  				Type:       cadence.UInt32Type{},
   823  			},
   824  			{
   825  				Identifier: "tokensRequestedToUnstake",
   826  				Type:       cadence.UFix64Type{},
   827  			},
   828  			{
   829  				Identifier: "initialWeight",
   830  				Type:       cadence.UInt64Type{},
   831  			},
   832  		},
   833  	}
   834  }
   835  
   836  func newFlowEpochEpochSetupEventType() *cadence.EventType {
   837  
   838  	// A.01cf0e2f2f715450.FlowEpoch.EpochSetup
   839  
   840  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   841  	location := common.NewAddressLocation(nil, address, "FlowEpoch")
   842  
   843  	return &cadence.EventType{
   844  		Location:            location,
   845  		QualifiedIdentifier: "FlowEpoch.EpochSetup",
   846  		Fields: []cadence.Field{
   847  			{
   848  				Identifier: "counter",
   849  				Type:       cadence.UInt64Type{},
   850  			},
   851  			{
   852  				Identifier: "nodeInfo",
   853  				Type:       cadence.NewVariableSizedArrayType(newFlowIDTableStakingNodeInfoStructType()),
   854  			},
   855  			{
   856  				Identifier: "firstView",
   857  				Type:       cadence.UInt64Type{},
   858  			},
   859  			{
   860  				Identifier: "finalView",
   861  				Type:       cadence.UInt64Type{},
   862  			},
   863  			{
   864  				Identifier: "collectorClusters",
   865  				Type:       cadence.NewVariableSizedArrayType(newFlowClusterQCClusterStructType()),
   866  			},
   867  			{
   868  				Identifier: "randomSource",
   869  				Type:       cadence.StringType{},
   870  			},
   871  			{
   872  				Identifier: "DKGPhase1FinalView",
   873  				Type:       cadence.UInt64Type{},
   874  			},
   875  			{
   876  				Identifier: "DKGPhase2FinalView",
   877  				Type:       cadence.UInt64Type{},
   878  			},
   879  			{
   880  				Identifier: "DKGPhase3FinalView",
   881  				Type:       cadence.UInt64Type{},
   882  			},
   883  		},
   884  	}
   885  }
   886  
   887  func newFlowEpochEpochCommittedEventType() *cadence.EventType {
   888  
   889  	// A.01cf0e2f2f715450.FlowEpoch.EpochCommitted
   890  
   891  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   892  	location := common.NewAddressLocation(nil, address, "FlowEpoch")
   893  
   894  	return &cadence.EventType{
   895  		Location:            location,
   896  		QualifiedIdentifier: "FlowEpoch.EpochCommitted",
   897  		Fields: []cadence.Field{
   898  			{
   899  				Identifier: "counter",
   900  				Type:       cadence.UInt64Type{},
   901  			},
   902  			{
   903  				Identifier: "clusterQCs",
   904  				Type:       cadence.NewVariableSizedArrayType(newFlowClusterQCClusterQCStructType()),
   905  			},
   906  			{
   907  				Identifier: "dkgPubKeys",
   908  				Type:       cadence.NewVariableSizedArrayType(cadence.StringType{}),
   909  			},
   910  		},
   911  	}
   912  }
   913  
   914  func newFlowClusterQCClusterQCStructType() *cadence.StructType {
   915  
   916  	// A.01cf0e2f2f715450.FlowClusterQC.ClusterQC"
   917  
   918  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   919  	location := common.NewAddressLocation(nil, address, "FlowClusterQC")
   920  
   921  	return &cadence.StructType{
   922  		Location:            location,
   923  		QualifiedIdentifier: "FlowClusterQC.ClusterQC",
   924  		Fields: []cadence.Field{
   925  			{
   926  				Identifier: "index",
   927  				Type:       cadence.UInt16Type{},
   928  			},
   929  			{
   930  				Identifier: "voteSignatures",
   931  				Type:       cadence.NewVariableSizedArrayType(cadence.StringType{}),
   932  			},
   933  			{
   934  				Identifier: "voteMessage",
   935  				Type:       cadence.StringType{},
   936  			},
   937  			{
   938  				Identifier: "voterIDs",
   939  				Type:       cadence.NewVariableSizedArrayType(cadence.StringType{}),
   940  			},
   941  		},
   942  	}
   943  }
   944  
   945  func NewNodeVersionBeaconVersionBeaconEventType() *cadence.EventType {
   946  
   947  	// A.01cf0e2f2f715450.NodeVersionBeacon.VersionBeacon
   948  
   949  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   950  	location := common.NewAddressLocation(nil, address, "NodeVersionBeacon")
   951  
   952  	return &cadence.EventType{
   953  		Location:            location,
   954  		QualifiedIdentifier: "NodeVersionBeacon.VersionBeacon",
   955  		Fields: []cadence.Field{
   956  			{
   957  				Identifier: "versionBoundaries",
   958  				Type:       cadence.NewVariableSizedArrayType(NewNodeVersionBeaconVersionBoundaryStructType()),
   959  			},
   960  			{
   961  				Identifier: "sequence",
   962  				Type:       cadence.UInt64Type{},
   963  			},
   964  		},
   965  	}
   966  }
   967  
   968  func NewNodeVersionBeaconVersionBoundaryStructType() *cadence.StructType {
   969  
   970  	// A.01cf0e2f2f715450.NodeVersionBeacon.VersionBoundary
   971  
   972  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   973  	location := common.NewAddressLocation(nil, address, "NodeVersionBeacon")
   974  
   975  	return &cadence.StructType{
   976  		Location:            location,
   977  		QualifiedIdentifier: "NodeVersionBeacon.VersionBoundary",
   978  		Fields: []cadence.Field{
   979  			{
   980  				Identifier: "blockHeight",
   981  				Type:       cadence.UInt64Type{},
   982  			},
   983  			{
   984  				Identifier: "version",
   985  				Type:       NewNodeVersionBeaconSemverStructType(),
   986  			},
   987  		},
   988  	}
   989  }
   990  
   991  func NewNodeVersionBeaconSemverStructType() *cadence.StructType {
   992  
   993  	// A.01cf0e2f2f715450.NodeVersionBeacon.Semver
   994  
   995  	address, _ := common.HexToAddress("01cf0e2f2f715450")
   996  	location := common.NewAddressLocation(nil, address, "NodeVersionBeacon")
   997  
   998  	return &cadence.StructType{
   999  		Location:            location,
  1000  		QualifiedIdentifier: "NodeVersionBeacon.Semver",
  1001  		Fields: []cadence.Field{
  1002  			{
  1003  				Identifier: "major",
  1004  				Type:       cadence.UInt8Type{},
  1005  			},
  1006  			{
  1007  				Identifier: "minor",
  1008  				Type:       cadence.UInt8Type{},
  1009  			},
  1010  			{
  1011  				Identifier: "patch",
  1012  				Type:       cadence.UInt8Type{},
  1013  			},
  1014  			{
  1015  				Identifier: "preRelease",
  1016  				Type:       cadence.NewOptionalType(cadence.StringType{}),
  1017  			},
  1018  		},
  1019  	}
  1020  }
  1021  
  1022  func ufix64FromString(s string) cadence.UFix64 {
  1023  	f, err := cadence.NewUFix64(s)
  1024  	if err != nil {
  1025  		panic(err)
  1026  	}
  1027  	return f
  1028  }
  1029  
  1030  func EpochSetupFixtureCCF(randomSource []byte) []byte {
  1031  	b, err := ccf.Encode(createEpochSetupEvent(randomSource))
  1032  	if err != nil {
  1033  		panic(err)
  1034  	}
  1035  	_, err = ccf.Decode(nil, b)
  1036  	if err != nil {
  1037  		panic(err)
  1038  	}
  1039  	return b
  1040  }
  1041  
  1042  func EpochSetupCCFWithNonHexRandomSource() []byte {
  1043  	// randomSource of correct length but made of non hex characters
  1044  	randomSource := "ZZ"
  1045  	for len(randomSource) != 2*flow.EpochSetupRandomSourceLength {
  1046  		randomSource = randomSource + "aa"
  1047  	}
  1048  
  1049  	event := cadence.NewEvent([]cadence.Value{
  1050  		// counter
  1051  		cadence.NewUInt64(1),
  1052  
  1053  		// nodeInfo
  1054  		createEpochNodes(),
  1055  
  1056  		// firstView
  1057  		cadence.NewUInt64(100),
  1058  
  1059  		// finalView
  1060  		cadence.NewUInt64(200),
  1061  
  1062  		// collectorClusters
  1063  		createEpochCollectors(),
  1064  
  1065  		// randomSource
  1066  		cadence.String(randomSource),
  1067  
  1068  		// DKGPhase1FinalView
  1069  		cadence.UInt64(150),
  1070  
  1071  		// DKGPhase2FinalView
  1072  		cadence.UInt64(160),
  1073  
  1074  		// DKGPhase3FinalView
  1075  		cadence.UInt64(170),
  1076  	}).WithType(newFlowEpochEpochSetupEventType())
  1077  
  1078  	b, err := ccf.Encode(event)
  1079  	if err != nil {
  1080  		panic(err)
  1081  	}
  1082  	_, err = ccf.Decode(nil, b)
  1083  	if err != nil {
  1084  		panic(err)
  1085  	}
  1086  	return b
  1087  }
  1088  
  1089  var EpochCommitFixtureCCF = func() []byte {
  1090  	b, err := ccf.Encode(createEpochCommittedEvent())
  1091  	if err != nil {
  1092  		panic(err)
  1093  	}
  1094  	_, err = ccf.Decode(nil, b)
  1095  	if err != nil {
  1096  		panic(err)
  1097  	}
  1098  	return b
  1099  }()
  1100  
  1101  var VersionBeaconFixtureCCF = func() []byte {
  1102  	b, err := ccf.Encode(createVersionBeaconEvent())
  1103  	if err != nil {
  1104  		panic(err)
  1105  	}
  1106  	_, err = ccf.Decode(nil, b)
  1107  	if err != nil {
  1108  		panic(err)
  1109  	}
  1110  	return b
  1111  }()