AccountFixture returns a randomly generated account.

AccountKeyDefaultFixture returns a randomly generated ECDSA/SHA3 account key.

AccountKeyFixture returns a randomly generated account key.

AddVersionBeacon adds blocks sequence with given VersionBeacon so this service events takes effect in Flow protocol.

AlterTransactionForCluster modifies a transaction nonce until it is assigned to the target cluster.

AreNumericallyClose returns true if the two floats are within epsilon of each other.

AssertClosesBefore asserts that the given channel closes before the duration expires.

AssertEqualBlocksLenAndOrder asserts that both a segment of blocks have the same len and blocks are in the same order.

AssertErrSubstringMatch asserts that two errors match with substring checking on the Error method (`expected` must be a substring of `actual`, to account for the actual error being wrapped).

AssertNotClosesBefore asserts that the given channel does not close before the duration expires.

AssertReturnsBefore asserts that the given function returns before the duration expires.

AsSlashable returns the input message T, wrapped as a flow.Slashable instance with a random origin ID.

BlockEventsFixture returns a block events model populated with random events of length n.

BootstrapFixture generates all the artifacts necessary to bootstrap the protocol state.

CertifyBlock returns a quorum certificate for the given block header.

ChainFixture creates a list of blocks that forms a chain.

ChainFixtureFrom creates a chain of blocks starting from a given parent block, the total number of blocks in the chain is specified by the given count.

ChunkDataPackRequestFixture creates a chunk data request with some default values, i.e., one agree execution node, one disagree execution node, and height of zero.

ChunkDataPackRequestListFixture creates and returns a list of chunk data pack requests fixtures.

ChunkDataResponseMessageListFixture creates a list of chunk data response messages each with a single-transaction collection, and random chunk ID.

ChunkDataResponseMsgFixture creates a chunk data response message with a single-transaction collection, and random chunk ID.

ChunkStatusListFixture receives an execution result, samples `n` chunks out of it and creates a chunk status for them.

ChunkStatusListToChunkLocatorFixture extracts chunk locators from a list of chunk statuses.

ClosedChannel returns a closed channel.

ClusterAssignment creates an assignment list with n clusters and with nodes evenly distributed among clusters.

ClusterBlockWithParent creates a new cluster consensus block that is valid with respect to the given parent block.

CompleteIdentitySet takes a number of identities and completes the missing roles.

CrashTest safely tests functions that crash (as the expected behavior) by checking that running the function creates an error and an expected error message.

CrashTestWithExpectedStatus checks for the test crashing with a specific exit code.

CreateNParticipantsWithMyRole creates a list of identities from given roles.

DKGBroadcastMessageFixture creates a single DKG broadcast message with random fields.

DKGMessageFixture creates a single DKG message with random fields.

EnsureEventsIndexSeq checks if values of given event index sequence are monotonically increasing.

EpochCommitFixtureByChainID returns an EpochCommit service event as a Cadence event representation and as a protocol model representation.

EpochProtocolStateEntryFixture returns a flow.MinEpochStateEntry fixture.

EpochRecoverFixture creates a valid EpochRecover with default properties for testing.

EpochRecoverFixtureByChainID returns an EpochRecover service event as a Cadence event representation and as a protocol model representation.

EpochSetupFixture creates a valid EpochSetup with default properties for testing.

EpochSetupFixtureByChainID returns an EpochSetup service event as a Cadence event representation and as a protocol model representation.

EpochStateFixture creates a fixture with correctly structured data.

EventFixture returns an event.

FailOnIrrecoverableError waits for either the done signal, or an error to be sent over the error channel.

FinalizedProtocolStateWithParticipants returns a protocol state with finalized participants.

GenerateRandomStringWithLen returns a string of random alpha characters of the provided length.

this is done by printing the state commitment in TestBootstrapLedger test with different chain ID.

GetFlowProtocolEventID returns the event ID for the event provided.

returns a deterministic math/rand PRG that can be used for deterministic randomness in tests only.

GossipSubMessageFixture returns a gossip sub message fixture for the specified topic.

GossipSubMessageFixtures returns a list of gossipsub message fixtures.

HeadersFromMap creates a storage header mock that backed by a given map.

IdentityFixture returns a node identity.

IdentityListFixture returns a list of node identity objects.

IdentityWithNetworkingKeyFixture returns a node identity and networking private key.

InsertAndFinalize inserts, then finalizes, the input block.

InterfafceToCdcValues decodes jsoncdc encoded values from interface -> cadence value.

LibP2PResourceLimitOverrideFixture returns a random resource limit override for testing.

Logger returns a zerolog use -vv flag to print debugging logs for tests.

go:noinline.

MatchEpochExtension matches an epoch extension argument passed to a mocked component.

NetworkCodec returns cbor codec.

NetworkingPrivKeyFixture returns random ECDSAP256 private key.

NetworkTopology returns the default topology for testing purposes.

NewClusterStateChecker returns a state checker for the given state.

NewEpochBuilder returns a new EpochBuilder which will build epochs using the given states.

NewProtectedMap returns a new ProtectedMap with the given types.

NewTestTime returns new TestTime.

NoopTxScript returns a Cadence script for a no-op transaction.

P2PRPCFixture returns a pubsub RPC fixture.

P2PRPCGraftFixture returns a control message rpc Graft fixture.

P2PRPCGraftFixtures returns n number of control message rpc Graft fixtures.

P2PRPCIHaveFixture returns a control message rpc iHave fixture.

P2PRPCIHaveFixtures returns n number of control message where n = len(topics) rpc iHave fixtures with m number of message ids each.

P2PRPCIWantFixture returns a control message rpc iWant fixture.

P2PRPCIWantFixtures returns n number of control message rpc iWant fixtures with m number of message ids each.

P2PRPCPruneFixture returns a control message rpc Prune fixture.

P2PRPCPruneFixtures returns n number of control message rpc Prune fixtures.

PeerIdFixture creates a random and unique peer ID (libp2p node ID).

PeerIdFixtures creates random and unique peer IDs (libp2p node IDs).

PrintHeapInfo prints heap object allocation through given logger.

PrivateKeyFixture returns a random private key with specified signature algorithm and seed length.

PrivateKeyFixtureByIdentifier returns a private key for a given node.

RandomByteSlice is a test helper that generates a cryptographically secure random byte slice of size n.

RandomStringFixture is a test helper that generates a cryptographically secure random string of size n.

ReadyDoneify sets up a generated mock to respond to Ready and Done lifecycle methods.

ReceiptAndSealForBlock returns a receipt with service events and a seal for them for a given block.

ReconnectBlocksAndReceipts re-computes each block's PayloadHash and ParentID so that all the blocks are connected.

RegisterIDFixture returns a RegisterID with a fixed key and owner.

RequireCloseBefore requires that the given channel returns before the duration expires.

RequireClosed is a test helper function that fails the test if channel `ch` is not closed.

RequireComponentsDoneBefore invokes the done method of each of the input components concurrently, and fails the test if any components shutdown takes longer than the specified duration.

RequireComponentsReadyBefore invokes the ready method of each of the input components concurrently, and fails the test if any components startup takes longer than the specified duration.

RequireConcurrentCallsReturnBefore is a test helper that runs function `f` count-many times concurrently, and requires all invocations to return within duration.

RequireNeverClosedWithin is a test helper function that fails the test if channel `ch` is closed before the determined duration.

RequireNeverReturnBefore is a test helper that tries invoking function `f` and fails the test if either: - function `f` is not invoked within 1 second.

RequireNotClosed is a test helper function that fails the test if channel `ch` is closed.

RequireNumericallyClose is a wrapper around require.Equal that allows for a small epsilon difference between two floats.

RequireReturnsBefore requires that the given function returns before the duration expires.

RootEpochProtocolStateFixture creates a fixture with correctly structured Epoch sub-state.

RootSnapshotFixture returns a snapshot representing a root chain state, for example one as returned from BootstrapFixture.

RunWithTypedBadgerDB creates a Badger DB that is passed to f and closed after f returns.

SealBlock seals a block B by building two blocks on it, the first containing a receipt for the block (BR), the second (BS) containing a seal for the block.

SeedFixture returns a random []byte with length n.

SeedFixtures returns a list of m random []byte, each having length n.

StakingPrivKeyFixture returns a random BLS12381 private keyf.

TransactionForCluster generates a transaction that will be assigned to the target cluster ID.

Uint64InRange returns a uint64 value drawn from the uniform random distribution [min,max].

VerifiableChunkDataFixture returns a complete verifiable chunk with an execution receipt referencing the block/collections.

VersionBeaconFixtureByChainID returns a VersionTable service event as a Cadence event representation and as a protocol model representation.

WithAddress sets the network address of identity fixture.

WithAllRoles can be used used to ensure an IdentityList fixtures contains all the roles required for a valid genesis block.

Same as above, but omitting a certain role for cases where we are manually setting up nodes or a particular role.

WithAllTheFixins ensures a payload contains no empty slice fields.

WithApproximateSize sets the ChunkDataResponse to be approximately bytes in size.

WithExecutionResults will add execution results to payload.

WithGrafts sets the grafts on the rpc control message.

WithIHaves sets the iHaves on the rpc control message.

WithInitialWeight sets the initial weight on an identity fixture.

WithIWants sets the iWants on the rpc control message.

WithNetworkingKey sets the networking public key of identity fixture.

WithNextEpochProtocolState creates a fixture with correctly structured data for next epoch.

WithNodeID adds a node ID with the given first byte to an identity.

WithParticipationStatus sets the epoch participation status on an identity fixture.

WithPrunes sets the prunes on the rpc control message.

WithRandomPublicKeys adds random public keys to an identity.

WithReceiptsAndNoResults will add receipt to payload only.

WithRole adds a role to an identity fixture.

WithStakingPubKey adds a staking public key to the identity.

WithValidDKG updated protocol state with correctly structured data for DKG.

Pre-calculated state commitment with root account with the above private key.

uses code that has been deprecated / disabled.

flaky.

long running.

requires the environment to be configured with GCP credentials.

resource intensive test.

not fully implemented or broken and needs to be fixed.

ClusterStateChecker is a test utility for checking cluster state.

EpochBuilder is a testing utility for building epochs into chain state.

EpochHeights is a structure caching the results of building an epoch with EpochBuilder.

LoggerHook implements the zerolog.Hook interface and can be used to capture logs for testing purposes.

MockEntity implements a bare minimum entity for sake of test.

ProtectedMap is a thread-safe map.

TestTime is a fake time used for testing.

UpdatableIDProvider implements an IdentityProvider which can be manually updated by setting the IdentityList to a new value.