MCPcopy Create free account

hub / github.com/tendermint/tendermint / functions

Functions9,600 in github.com/tendermint/tendermint

↓ 2 callersFunctiontestPeerConn
( transport *MConnTransport, rawConn net.Conn, outbound, persistent bool, )
internal/p2p/test_util.go:216
↓ 2 callersFunctiontestProposerFreq
test a proposer appears as frequently as expected
internal/state/state_test.go:402
↓ 2 callersFunctiontestRootCmd
prepare new rootCmd
cmd/tendermint/commands/root_test.go:38
↓ 2 callersFunctiontestSetup
(rootDir string, args []string, env map[string]string)
cmd/tendermint/commands/root_test.go:50
↓ 2 callersFunctiontestStream
(t *testing.T, app types.Application)
abci/example/example_test.go:47
↓ 2 callersFunctiontestTxEventsSent
(t *testing.T, broadcastMethod string)
rpc/client/event_test.go:106
↓ 2 callersFunctiontestUnixAddr
testUnixAddr will attempt to obtain a platform-independent temporary file name for a Unix socket
privval/socket_listeners_test.go:31
↓ 2 callersFunctiontestWithHTTPClient
(t *testing.T, cl client.HTTPClient)
rpc/jsonrpc/jsonrpc_test.go:187
↓ 2 callersMethodtoByteSlices
()
types/results.go:32
↓ 2 callersMethodto_safe
Converts 'bad' characters in a string to underscores so they can be used as Ansible groups
networks/remote/ansible/inventory/digital_ocean.py:526
↓ 2 callersMethodtouchPeer
(peerID types.NodeID, time time.Time)
internal/blocksync/v2/scheduler.go:225
↓ 2 callersMethodtriggerConnect
()
privval/signer_listener_endpoint.go:163
↓ 2 callersMethodtryFinalizeCommit
If we have the block AND +2/3 commits for it, finalize.
internal/consensus/state.go:1612
↓ 2 callersFunctiontxAsUint64
(tx []byte)
internal/consensus/mempool_test.go:260
↓ 2 callersFunctionunmarshalResponseBytes
( responseBytes []byte, expectedID rpctypes.JSONRPCIntID, result interface{}, )
rpc/jsonrpc/client/decode.go:12
↓ 2 callersMethodunpause
Wakes the trust metric up if it is currently paused This method needs to be called with the mutex locked
internal/p2p/trust/metric.go:311
↓ 2 callersMethodupdatePrivValidatorPubKey
updatePrivValidatorPubKey get's the private validator public key and memoizes it. This func returns an error if the private validator is not respondin
internal/consensus/state.go:2333
↓ 2 callersFunctionupdateState
updateState returns a new State updated according to the header and responses.
internal/state/execution.go:441
↓ 2 callersMethodupdateTrustedLightBlock
(l *types.LightBlock)
light/client.go:843
↓ 2 callersMethodupdateWithChangeSet
Main function used by UpdateWithChangeSet() and NewValidatorSet(). If 'allowDeletes' is false then delete operations (identified by validators with vo
types/validator_set.go:587
↓ 2 callersMethodvalidateEndpoint
validateEndpoint validates an endpoint.
internal/p2p/transport_mconn.go:202
↓ 2 callersFunctionvalidateResponseID
(id interface{})
rpc/jsonrpc/client/decode.go:117
↓ 2 callersMethodvalidatorUpdates
validatorUpdates generates a validator set update.
test/e2e/app/app.go:275
↓ 2 callersMethodverify
verify verifies the evidence fully by checking: - It has not already been committed - it is sufficiently recent (MaxAge) - it is from a key who was a
internal/evidence/verify.go:24
↓ 2 callersMethodverifyApp
verifyApp verifies the sync, checking the app hash, last block height and app version
internal/statesync/syncer.go:564
↓ 2 callersFunctionverifyBasicValsAndCommit
(vals *ValidatorSet, commit *Commit, height int64, blockID BlockID)
types/validation.go:334
↓ 2 callersFunctionverifyBlock
(t *testing.T, height int64)
internal/state/indexer/sink/psql/psql_test.go:297
↓ 2 callersFunctionverifyNewHeaderAndVals
NOTE: This function assumes that untrustedHeader is after trustedHeader. Do not use for backwards verification.
light/verifier.go:230
↓ 2 callersMethodvoteStrings
()
types/vote_set.go:553
↓ 2 callersMethodvoteTime
voteTime ensures monotonicity of the time a validator votes on. It ensures that for a prior block with a BFT-timestamp of T, any vote from this valida
internal/consensus/state.go:2281
↓ 2 callersMethodwaitForEnoughPeers
(ctx context.Context, numPeers int)
internal/statesync/reactor.go:1021
↓ 2 callersMethodwaitForTxns
(t *testing.T, txs types.Txs, ids ...types.NodeID)
internal/mempool/v0/reactor_test.go:121
↓ 2 callersFunctionwriteFileRandReseed
()
internal/libs/tempfile/tempfile.go:38
↓ 2 callersFunctionzipDir
zipDir zips all the contents found in src, including both files and directories, into a destination file dest. It returns an error upon failure. It as
cmd/tendermint/commands/debug/io.go:18
↓ 1 callersMethodABCI
()
types/evidence.go:24
↓ 1 callersMethodABCIInfo
(ctx context.Context)
rpc/client/mock/abci.go:27
↓ 1 callersMethodABCIInfo
(ctx context.Context)
rpc/client/mock/abci.go:103
↓ 1 callersMethodABCIInfo
(ctx context.Context)
rpc/client/mock/abci.go:177
↓ 1 callersMethodABCIQueryWithOptions
ABCIQueryWithOptions returns an error if opts.Prove is false. ABCIQueryWithOptions returns the result for the given height (opts.Height). If no height
light/rpc/client.go:132
↓ 1 callersMethodABCIQueryWithOptions
( ctx context.Context, path string, data bytes.HexBytes, opts rpcclient.ABCIQueryOptions)
rpc/client/http/http.go:231
↓ 1 callersMethodABCIQueryWithOptions
( ctx context.Context, path string, data bytes.HexBytes, opts rpcclient.ABCIQueryOptions)
rpc/client/local/local.go:87
↓ 1 callersMethodABCIQueryWithOptions
( ctx context.Context, path string, data bytes.HexBytes, opts client.ABCIQueryOptions)
rpc/client/mock/client.go:90
↓ 1 callersFunctionABCIResponsesResultsHash
------------------------------------------------------------------------ ABCIResponsesResultsHash returns the root hash of a Merkle tree of ResponseDe
internal/state/store.go:405
↓ 1 callersMethodAddEvent
(event string)
libs/events/events.go:224
↓ 1 callersMethodAddListener
(listenerID string, cb EventCallback)
libs/events/events.go:177
↓ 1 callersFunctionAddNodeFlags
AddNodeFlags exposes some common configuration options on the command-line These are exposed for convenience of commands embedding a tendermint node
cmd/tendermint/commands/run_node.go:24
↓ 1 callersFunctionAddPeerToSwitchPeerSet
------------------------------------------------
internal/p2p/test_util.go:22
↓ 1 callersMethodAddPeerTrustMetric
AddPeerTrustMetric takes an existing trust metric and associates it with a peer key. The caller is expected to call Start on the TrustMetric being add
internal/p2p/trust/store.go:94
↓ 1 callersMethodAddPortMapping
( protocol string, externalPort, internalPort int, description string, timeout int)
internal/p2p/upnp/upnp.go:30
↓ 1 callersMethodAddPrivatePeerIDs
([]string)
internal/rpc/core/env.go:57
↓ 1 callersMethodAddProposalBlockPart
AddProposalBlockPart inputs a part of the proposal block.
internal/consensus/state.go:533
↓ 1 callersMethodAddUnsafe
AddUnsafeRoutes adds unsafe routes.
internal/rpc/core/routes.go:59
↓ 1 callersMethodAddressRPC
Address returns an RPC endpoint address for the node.
test/e2e/pkg/testnet.go:464
↓ 1 callersMethodApplyHasVoteMessage
ApplyHasVoteMessage updates the peer state for the new vote.
internal/consensus/peer_state.go:480
↓ 1 callersMethodApplyNewRoundStepMessage
ApplyNewRoundStepMessage updates the peer state for the new round.
internal/consensus/peer_state.go:387
↓ 1 callersMethodApplyNewValidBlockMessage
ApplyNewValidBlockMessage updates the peer state for the new valid block.
internal/consensus/peer_state.go:446
↓ 1 callersMethodApplyProposalPOLMessage
ApplyProposalPOLMessage updates the peer state for the new proposal POL.
internal/consensus/peer_state.go:463
↓ 1 callersMethodApplySnapshotChunkAsync
NOTE: call is synchronous, use ctx to break early if needed
abci/client/grpc_client.go:302
↓ 1 callersMethodAreSecurityOptionsPresent
()
config/config.go:432
↓ 1 callersMethodBackfill
Backfill sequentially fetches, verifies and stores light blocks in reverse order. It does not stop verifying blocks until reaching a block with a heig
internal/statesync/reactor.go:349
↓ 1 callersMethodBase
()
internal/consensus/replay_test.go:1191
↓ 1 callersMethodBeginBlock
Track the block hash and header information
abci/example/kvstore/persistent_kvstore.go:123
↓ 1 callersMethodBeginBlockAsync
NOTE: call is synchronous, use ctx to break early if needed
abci/client/grpc_client.go:249
↓ 1 callersFunctionBenchmark
Benchmark is a simple function for fetching, calculating and printing the following metrics: 1. Average block production time 2. Block interval standa
test/e2e/runner/benchmark.go:24
↓ 1 callersMethodBlockID
BlockID returns the Commit's BlockID if CommitSig indicates signing, otherwise - empty BlockID.
types/block.go:661
↓ 1 callersMethodBlockPartsSent
BlockPartsSent returns the number of useful block parts the peer has sent us.
internal/consensus/peer_state.go:353
↓ 1 callersMethodBlockResults
BlockResults gets ABCIResults at a given height. If no height is provided, it will fetch results for the latest block. Results are for the height of
internal/rpc/core/blocks.go:199
↓ 1 callersMethodBroadcastTxAsync
(ctx context.Context, tx types.Tx)
rpc/client/mock/abci.go:136
↓ 1 callersMethodBroadcastTxAsync
(ctx context.Context, tx types.Tx)
rpc/client/mock/abci.go:221
↓ 1 callersMethodBroadcastTxCommit
NOTE: Caller should call a.App.Commit() separately, this function does not actually wait for a commit. TODO: Make it wait for a commit and set res.Hei
rpc/client/mock/abci.go:52
↓ 1 callersMethodBroadcastTxCommit
(ctx context.Context, tx types.Tx)
rpc/client/mock/abci.go:210
↓ 1 callersMethodBroadcastTxSync
(ctx context.Context, tx types.Tx)
rpc/client/mock/abci.go:144
↓ 1 callersMethodBroadcastTxSync
(ctx context.Context, tx types.Tx)
rpc/client/mock/abci.go:232
↓ 1 callersFunctionBufferCapacity
BufferCapacity allows you to specify capacity for the internal server's queue. Since the server, given Y subscribers, could only process X messages, t
libs/pubsub/pubsub.go:153
↓ 1 callersMethodBytes
Bytes returns the proto-encoded evidence as a byte array.
types/evidence.go:96
↓ 1 callersMethodBytes
Bytes returns the proto-encoded evidence as a byte array
types/evidence.go:265
↓ 1 callersMethodBytes
Bytes serializes the State using protobuf. It panics if either casting to protobuf or serialization fails.
internal/state/state.go:137
↓ 1 callersFunctionCRandHex
CRandHex returns a hex encoded string that's floor(numDigits/2) * 2 long. Note: CRandHex(24) gives 96 bits of randomness that are usually strong enou
crypto/random.go:28
↓ 1 callersMethodCallWithArrayParams
CallWithArrayParams enqueues a call request onto the Send queue. Params are in a form of array (e.g. []interface{}{"abcd"}). Requests are JSON encoded
rpc/jsonrpc/client/ws_client.go:222
↓ 1 callersFunctionCanonical
Canonical returns UTC time with no monotonic component. Stripping the monotonic component is for time equality. See https://github.com/tendermint/tend
libs/time/time.go:15
↓ 1 callersFunctionCanonicalizePartSetHeader
CanonicalizeVote transforms the given PartSetHeader to a CanonicalPartSetHeader.
types/canonical.go:37
↓ 1 callersMethodChainID
ChainID returns the chain ID the light client was configured with. Safe for concurrent use by multiple goroutines.
light/client.go:804
↓ 1 callersMethodChan
()
internal/consensus/ticker.go:20
↓ 1 callersMethodCheckTx
CheckTx implements ABCI.
test/e2e/app/app.go:137
↓ 1 callersMethodCheckTxAsync
NOTE: call is synchronous, use ctx to break early if needed
abci/client/grpc_client.go:209
↓ 1 callersMethodCleanup
(func())
internal/state/mocks/evidence_pool.go:74
↓ 1 callersMethodCleanup
(func())
internal/p2p/mocks/transport.go:125
↓ 1 callersMethodCleanup
(func())
internal/p2p/mocks/connection.go:214
↓ 1 callersMethodCleanup
(func())
internal/proxy/mocks/app_conn_snapshot.go:126
↓ 1 callersMethodCleanup
(func())
internal/proxy/mocks/app_conn_mempool.go:124
↓ 1 callersMethodCleanup
(func())
internal/proxy/mocks/app_conn_consensus.go:156
↓ 1 callersMethodCleanup
(func())
light/rpc/mocks/light_client.go:105
↓ 1 callersMethodClientCertificateFile
ClientCertificateFile returns the full path to the priv_validator_key.json file
config/config.go:413
↓ 1 callersMethodClientKeyFile
ClientKeyFile returns the full path to the priv_validator_key.json file
config/config.go:408
↓ 1 callersMethodClose
Close closes the channel. Future sends on Out and Error will panic. The In channel remains open to avoid having to synchronize Router senders, which s
internal/p2p/router.go:98
↓ 1 callersMethodClose
Close closes the connection.
internal/p2p/transport.go:116
↓ 1 callersMethodClose
Close closes the peer updates subscription.
internal/p2p/peermanager.go:98
↓ 1 callersMethodClose
Close implements Connection.
internal/p2p/transport_memory.go:367
↓ 1 callersMethodClose
Close shuts down the closing goroutine, SIGHUP handler and closes the AutoFile.
internal/libs/autofile/autofile.go:93
↓ 1 callersMethodClose
Close closes the underlying writer if it implements the io.Closer interface.
internal/libs/flowrate/io.go:127
← previousnext →2,601–2,700 of 9,600, ranked by callers