MCPcopy Create free account

hub / github.com/tendermint/tendermint / functions

Functions9,600 in github.com/tendermint/tendermint

↓ 2 callersMethodnextRequestID
Private methods
rpc/jsonrpc/client/ws_client.go:232
↓ 2 callersMethodnextRequestID
()
rpc/jsonrpc/client/http_json_client.go:283
↓ 2 callersMethodnoBlock
(e error)
light/provider/http/http.go:287
↓ 2 callersMethodnoResponse
()
light/provider/http/http.go:277
↓ 2 callersMethodnodeInfo
()
internal/p2p/peer_test.go:225
↓ 2 callersMethodofferSnapshot
offerSnapshot offers a snapshot to the app. It returns various errors depending on the app's response, or nil if the snapshot was accepted.
internal/statesync/syncer.go:382
↓ 2 callersFunctiononlyValidatorIsUs
(state sm.State, pubKey crypto.PubKey)
node/setup.go:191
↓ 2 callersMethodopenConnection
(ctx context.Context, conn Connection)
internal/p2p/router.go:601
↓ 2 callersFunctionparseBytesize
(chopSize string)
internal/libs/autofile/cmd/logjack.go:98
↓ 2 callersMethodparseCond
parseCond parses a conditional expression: tag OP value.
libs/pubsub/query/syntax/parser.go:144
↓ 2 callersMethodparseRPCError
parseRPCError process the error and return the corresponding error to the light clent NOTE: When an error is sent over the wire it gets "flattened" he
light/provider/http/http.go:300
↓ 2 callersFunctionparseTx
parseTx parses a tx in 'key=value' format into a key and value.
test/e2e/app/app.go:302
↓ 2 callersFunctionparseValueFromEventKey
(key []byte)
internal/state/indexer/block/kv/util.go:70
↓ 2 callersFunctionparseValueFromKey
parseValueFromKey parses an event key and extracts out the value, returning an error if one arises. This will also involve ensuring that the key has t
internal/state/indexer/tx/kv/kv.go:535
↓ 2 callersFunctionpercentageOfNum
(p, n int)
internal/p2p/pex/addrbook.go:431
↓ 2 callersFunctionpersistentArgs
Generates new Args array based off of previous call args to maintain flag persistence
abci/cmd/abci-cli/abci-cli.go:266
↓ 2 callersMethodpickOldest
----------------------------------------------------------
internal/p2p/pex/addrbook.go:630
↓ 2 callersMethodpoolRoutine
poolRoutine handles messages from the poolReactor telling the reactor what to do. NOTE: Don't sleep in the FOR_LOOP or otherwise slow it down!
internal/blocksync/v0/reactor.go:443
↓ 2 callersFunctionprefixForCondition
a small utility function for getting a keys prefix based on a condition and a height
internal/state/indexer/tx/kv/kv.go:578
↓ 2 callersFunctionprefixToBytes
(prefix int64)
internal/evidence/pool.go:613
↓ 2 callersFunctionprimaryKey
########################## Keys ############################# The indexer has two types of kv stores: 1. txhash - result (primary key) 2. event -
internal/state/indexer/tx/kv/kv.go:505
↓ 2 callersMethodprocess
process starts a block process where we listen for Envelopes to enqueue. If there is sufficient capacity, it will be enqueued into the priority queue,
internal/p2p/pqueue.go:164
↓ 2 callersMethodproportionalValue
Calculates the current score for good/bad experiences
internal/p2p/trust/metric.go:337
↓ 2 callersFunctionprovidersFromAddresses
(addrs []string, chainID string)
light/setup.go:70
↓ 2 callersMethodprunablePeers
(peerTimout time.Duration, minRecvRate int64, now time.Time)
internal/blocksync/v2/scheduler.go:348
↓ 2 callersMethodprunePeers
prunePeers removes low-scored peers from the peer store if it contains more than MaxPeers peers. The caller must hold the mutex lock.
internal/p2p/peermanager.go:419
↓ 2 callersMethodpush
(pqEnv *pqEnvelope)
internal/p2p/pqueue.go:282
↓ 2 callersFunctionrandBlockID
()
types/evidence.go:712
↓ 2 callersFunctionrandConsensusNetWithPeers
nPeers = nValidators + nNotValidator
internal/consensus/common_test.go:806
↓ 2 callersFunctionrandomGenesisDoc
()
types/genesis_test.go:155
↓ 2 callersFunctionrandomMoniker
()
cmd/tendermint/commands/testnet.go:300
↓ 2 callersFunctionrandomNodeID
(t *testing.T)
internal/p2p/pex/reactor_test.go:820
↓ 2 callersMethodrandomPickAddresses
(bucketType byte, num int)
internal/p2p/pex/addrbook.go:702
↓ 2 callersMethodreceiveRoutine
----------------------------------------- the main go routines receiveRoutine handles messages which may cause state transitions. it's argument (n) is
internal/consensus/state.go:772
↓ 2 callersMethodreconnect
reconnect tries to redial up to maxReconnectAttempts with exponential backoff.
rpc/jsonrpc/client/ws_client.go:256
↓ 2 callersMethodreconstructLastCommit
Reconstruct LastCommit from SeenCommit, which we saved along with the block, (which happens even before saving the state)
internal/consensus/state.go:616
↓ 2 callersMethodredoSubscriptionsAfter
After being reconnected, it is necessary to redo subscription to server otherwise no data will be automatically received.
rpc/client/http/ws.go:195
↓ 2 callersFunctionregisterFlagsRootCmd
(cmd *cobra.Command)
cmd/tendermint/commands/root.go:24
↓ 2 callersMethodremoveAddress
(addr *p2p.NetAddress)
internal/p2p/pex/addrbook.go:804
↓ 2 callersMethodremoveEvidenceFromList
( blockEvidenceMap map[string]struct{})
internal/evidence/pool.go:493
↓ 2 callersMethodremoveExpiredPendingEvidence
()
internal/evidence/pool.go:423
↓ 2 callersMethodremoveFromAllBuckets
(ka *knownAddress)
internal/p2p/pex/addrbook.go:614
↓ 2 callersMethodremovePeer
removePeer removes a peer. The caller must hold the mutex lock.
internal/statesync/snapshots.go:264
↓ 2 callersFunctionremoveProtocolIfDefined
(addr string)
types/netaddress.go:316
↓ 2 callersMethodremoveTimedoutPeers
()
internal/blocksync/v0/pool.go:146
↓ 2 callersMethodremoveTxByKey
removeTxByKey removes the specified transaction key from the mempool. The caller must hold txmp.mtx excluxively.
internal/mempool/v1/mempool.go:255
↓ 2 callersMethodreplayBlocks
( state sm.State, proxyApp proxy.AppConns, appBlockHeight, storeBlockHeight int64, mutateState bool)
internal/consensus/replay.go:438
↓ 2 callersMethodreplayReset
go back count steps by resetting the state and running (pb.count - count) steps
internal/consensus/replay_file.go:128
↓ 2 callersMethodrequestRoutine
()
internal/blocksync/v0/reactor.go:398
↓ 2 callersMethodrequestersLen
()
internal/blocksync/v0/pool.go:414
↓ 2 callersMethodreset
reset clears the current sample state in preparation for the next sample.
internal/libs/flowrate/flowrate.go:250
↓ 2 callersFunctionresetAll
resetAllCmd removes address book files plus all data, and resets the privValidator data.
cmd/tendermint/commands/reset.go:80
↓ 2 callersFunctionresetFilePV
(privValKeyFile, privValStateFile string, logger log.Logger, keyType string)
cmd/tendermint/commands/reset.go:163
↓ 2 callersFunctionresetState
resetState removes address book files plus all databases.
cmd/tendermint/commands/reset.go:101
↓ 2 callersMethodresetTimeout
()
internal/blocksync/v0/pool.go:503
↓ 2 callersMethodretryDelay
retryDelay calculates a dial retry delay using exponential backoff, based on retry settings in PeerManagerOptions. If retries are disabled (i.e. MinRe
internal/p2p/peermanager.go:1265
↓ 2 callersMethodreverseBatchDelete
reverseBatchDelete runs a reverse iterator (from end to start) filling up a batch until either (a) the iterator reaches the start or (b) the iterator
internal/state/store.go:377
↓ 2 callersMethodroutePeer
routePeer routes inbound and outbound messages between a peer and the reactor channels. It will close the given connection and send queue when done, o
internal/p2p/router.go:854
↓ 2 callersFunctionrpcClient
rpcClient sets up a new RPC client
internal/statesync/stateprovider.go:199
↓ 2 callersFunctionrunClientTests
(t *testing.T, client abciclient.Client)
abci/example/kvstore/kvstore_test.go:316
↓ 2 callersFunctionrunInTransaction
runInTransaction executes query in a fresh database transaction. If query reports an error, the transaction is rolled back and the error from query is
internal/state/indexer/sink/psql/psql.go:63
↓ 2 callersMethodrunWithPeerMutex
(fn func() error)
internal/p2p/router.go:845
↓ 2 callersFunctionsafeAdd
---------------------------------------- safe addition/subtraction/multiplication
types/validator_set.go:873
↓ 2 callersFunctionsafeMul
(a, b int64)
types/validator_set.go:913
↓ 2 callersMethodsave
save saves the state to disk. It does not take out a lock since it is called internally by Commit which does lock.
test/e2e/app/state.go:77
↓ 2 callersMethodsaveConsensusParamsInfo
saveConsensusParamsInfo persists the consensus params for the next block to disk. It should be called from s.Save(), right before the state itself is
internal/state/store.go:649
↓ 2 callersMethodsaveSigned
Persist height/round/step and signature
privval/file.go:401
↓ 2 callersMethodscheduleRound0
enterNewRound(height, 0) at cs.StartTime.
internal/consensus/state.go:589
↓ 2 callersFunctionsecondaryKey
The event/secondary key
internal/state/indexer/tx/kv/kv.go:518
↓ 2 callersMethodselectPeer
(height int64)
internal/blocksync/v2/scheduler.go:484
↓ 2 callersMethodsendEvidence
sendEvidence sends evidence to a provider on a best effort basis.
light/detector.go:206
↓ 2 callersMethodsendStatusResponse
(base, height int64, peer p2p.Peer)
internal/blocksync/v2/io.go:21
↓ 2 callersFunctionserializeSig
Serialize signature to R || S. R, S are padded to 32 bytes respectively.
crypto/secp256k1/secp256k1.go:230
↓ 2 callersFunctionserverRPCConfig
(r *config.RPCConfig)
internal/inspect/rpc/rpc.go:130
↓ 2 callersMethodsetHasVote
(height int64, round int32, voteType tmproto.SignedMsgType, index int32)
internal/consensus/peer_state.go:371
↓ 2 callersMethodsetLogger
(logger log.Logger)
internal/blocksync/v2/routine.go:51
↓ 2 callersMethodsetPeerRange
(peerID types.NodeID, base int64, height int64)
internal/blocksync/v2/scheduler.go:300
↓ 2 callersMethodsetRecvLastMsgAt
(t time.Time)
internal/p2p/conn/connection.go:235
↓ 2 callersFunctionsetupSingle
(t *testing.T)
internal/p2p/pex/reactor_test.go:288
↓ 2 callersFunctionsignChallenge
(challenge *[32]byte, locPrivKey crypto.PrivKey)
internal/p2p/conn/secret_connection.go:391
↓ 2 callersMethodsignHeader
signHeader properly signs the header with all keys from first to last exclusive.
light/helpers_test.go:77
↓ 2 callersFunctionsignatureFromBytes
Read Signature struct from R || S. Caller needs to ensure that len(sigStr) == 64.
crypto/secp256k1/secp256k1.go:221
↓ 2 callersMethodsize
* Private methods */ size returns the number of entries in the store without acquiring the mutex
internal/p2p/trust/store.go:145
↓ 2 callersFunctionskipTypes
(dAtA []byte)
proto/tendermint/mempool/types.pb.go:479
↓ 2 callersFunctionsort32
(foo, bar *[32]byte)
internal/p2p/conn/secret_connection.go:380
↓ 2 callersMethodsorterFactory
(candidates []*snapshot)
internal/statesync/snapshots.go:200
↓ 2 callersMethodstartForReplay
()
internal/consensus/replay_file.go:168
↓ 2 callersFunctionstartListenerEndpointAsync
(t *testing.T, sle *SignerListenerEndpoint, endpointIsOpenCh chan struct{})
privval/signer_listener_endpoint_test.go:178
↓ 2 callersMethodstartReadWriteRoutines
()
rpc/jsonrpc/client/ws_client.go:295
↓ 2 callersMethodstartSync
startSync begins a block sync, signaled by r.events being non-nil. If state is non-nil, the scheduler and processor is updated with this state on star
internal/blocksync/v2/reactor.go:151
↓ 2 callersFunctionstatusesAreEqual
statusesAreEqual returns true if s1 is equal to s2. Equality here means general equality of fields except for the duration and rates, which can drift
internal/libs/flowrate/io_test.go:165
↓ 2 callersMethodstopServices
stopServices stops the BaseService and timers and closes the quitSendRoutine. if the quitSendRoutine was already closed, it returns true, otherwise it
internal/p2p/conn/connection.go:250
↓ 2 callersMethodsubscribe
(ctx context.Context, clientID string, query Query, outCapacity int)
libs/pubsub/pubsub.go:197
↓ 2 callersFunctiontempWALWithData
(data []byte)
internal/consensus/replay_test.go:667
↓ 2 callersFunctiontestAddrBookAddressSelection
(t *testing.T, bookSize int)
internal/p2p/pex/addrbook_test.go:468
↓ 2 callersFunctiontestBatchedJSONRPCCalls
(ctx context.Context, t *testing.T, c *rpchttp.HTTP)
rpc/client/rpc_test.go:778
↓ 2 callersFunctiontestClient
(t *testing.T, app abciclient.Client, tx []byte, key, value string)
abci/example/kvstore/kvstore_test.go:328
↓ 2 callersFunctiontestCreatePrivateAddrs
(t *testing.T, numAddrs int)
internal/p2p/pex/addrbook_test.go:384
↓ 2 callersFunctiontestFreeAddr
testFreeAddr claims a free port so we don't block on listener being ready.
node/node_test.go:211
↓ 2 callersFunctiontestNodeInfo
---------------------------------------------------------------- rand node info
internal/p2p/test_util.go:230
← previousnext →2,501–2,600 of 9,600, ranked by callers