## Uses of Class
net.i2p.data.Hash

Packages that use Hash
net.i2p.crypto
net.i2p.data
net.i2p.data.i2cp
net.i2p.data.i2np
net.i2p.router
net.i2p.router.client
net.i2p.router.message
net.i2p.router.networkdb
net.i2p.router.networkdb.kademlia
net.i2p.router.peermanager
net.i2p.router.transport
net.i2p.router.transport.ntcp
net.i2p.router.transport.tcp: Implements the transport for communicating with other routers via TCP/IP.
net.i2p.router.transport.udp
net.i2p.router.tunnel
net.i2p.router.tunnel.pool

Uses of Hash in net.i2p.crypto

Methods in net.i2p.crypto that return Hash
`Hash` `HMACGenerator.calculate(SessionKey key, byte[] data)` Calculate the HMAC of the data with the given key
`Hash` `SHA256Generator.calculateHash(byte[] source)` Calculate the SHA-256 has of the source
`Hash` `SHA256Generator.calculateHash(byte[] source, int start, int len)`
`static Hash` `DSAEngine.calculateHash(byte[] source, int offset, int len)`
`Hash` `DSAEngine.calculateHash(java.io.InputStream in)`

Methods in net.i2p.crypto with parameters of type Hash
`Signature` `DSAEngine.sign(Hash hash, SigningPrivateKey signingKey)`
`boolean` `DSAEngine.verifySignature(Signature signature, Hash hash, SigningPublicKey verifyingKey)`

Uses of Hash in net.i2p.data

Fields in net.i2p.data declared as Hash
`static Hash` `Hash.FAKE_HASH`

Methods in net.i2p.data that return Hash
`Hash` `RouterIdentity.calculateHash()`
`Hash` `Destination.calculateHash()`
`Hash` `DataStructureImpl.calculateHash()`
`Hash` `DataStructure.calculateHash()` Calculate the SHA256 value of this object (useful for a few scenarios)
`Hash` `Lease.getGateway()` Retrieve the router at which the destination can be contacted
`Hash` `RouterIdentity.getHash()`
`Hash` `RouterInfo.getRoutingKey()` Get the routing key for the structure using the current modifier in the RoutingKeyGenerator.
`Hash` `LeaseSet.getRoutingKey()` Get the routing key for the structure using the current modifier in the RoutingKeyGenerator.
`Hash` `RoutingKeyGenerator.getRoutingKey(Hash origKey)` Generate a modified (yet consistent) hash from the origKey by generating the SHA256 of the targetKey with the current modData appended to it, *then* This makes Sybil's job a lot harder, as she needs to essentially take over the whole keyspace.

Methods in net.i2p.data with parameters of type Hash
`byte[]` `Hash.cachedXor(Hash key)` Calculate the xor with the current object and the specified hash, caching values where possible.
`Hash` `RoutingKeyGenerator.getRoutingKey(Hash origKey)` Generate a modified (yet consistent) hash from the origKey by generating the SHA256 of the targetKey with the current modData appended to it, *then* This makes Sybil's job a lot harder, as she needs to essentially take over the whole keyspace.
`void` `Lease.setGateway(Hash ident)` Configure the router at which the destination can be contacted
`void` `RouterInfo.setRoutingKey(Hash key)`
`void` `LeaseSet.setRoutingKey(Hash key)`

Uses of Hash in net.i2p.data.i2cp

Methods in net.i2p.data.i2cp that return Hash
`Hash` `RequestLeaseSetMessage.getRouter(int endpoint)`

Methods in net.i2p.data.i2cp with parameters of type Hash
`void` `RequestLeaseSetMessage.addEndpoint(Hash router, TunnelId tunnel)`

Uses of Hash in net.i2p.data.i2np

Methods in net.i2p.data.i2np that return Hash
`Hash` `DeliveryInstructions.getDestination()`
`Hash` `DatabaseLookupMessage.getFrom()` Contains the router who requested this lookup
`Hash` `DatabaseSearchReplyMessage.getFromHash()`
`Hash` `DatabaseStoreMessage.getKey()` Defines the key in the network database being stored
`Hash` `TunnelVerificationStructure.getMessageHash()`
`Hash` `TunnelCreateMessage.getNextRouter()`
`Hash` `DatabaseSearchReplyMessage.getReply(int index)`
`Hash` `TunnelCreateMessage.getReplyGateway()`
`Hash` `DatabaseStoreMessage.getReplyGateway()`
`Hash` `DeliveryInstructions.getRouter()`
`Hash` `DatabaseSearchReplyMessage.getSearchKey()` Defines the key being searched for
`Hash` `DatabaseLookupMessage.getSearchKey()` Defines the key being searched for
`Hash` `BuildRequestRecord.readNextIdentity()` Read the next hop from the record.

Methods in net.i2p.data.i2np with parameters of type Hash
`void` `DatabaseSearchReplyMessage.addReply(Hash peer)`
`void` `BuildRequestRecord.createRecord(I2PAppContext ctx, long receiveTunnelId, Hash peer, long nextTunnelId, Hash nextHop, long nextMsgId, SessionKey layerKey, SessionKey ivKey, SessionKey replyKey, byte[] iv, boolean isInGateway, boolean isOutEndpoint)` Populate this instance with data.
`boolean` `BuildRequestRecord.decryptRecord(I2PAppContext ctx, PrivateKey ourKey, Hash ourIdent, ByteArray encryptedRecord)` Decrypt the data from the specified record, writing the decrypted record into this instance's buffer (but not overwriting the array contained within the old buffer)
`void` `BuildRequestRecord.encryptRecord(I2PAppContext ctx, PublicKey toKey, Hash toPeer, byte[] out, int outOffset)` Encrypt the record to the specified peer.
`boolean` `BuildRequestRecord.readOurIdentityMatches(Hash ourIdentity)` true if the identity they expect us to be is who we are
`void` `DeliveryInstructions.setDestination(Hash dest)`
`void` `DatabaseLookupMessage.setFrom(Hash from)`
`void` `DatabaseSearchReplyMessage.setFromHash(Hash from)`
`void` `DatabaseStoreMessage.setKey(Hash key)`
`void` `TunnelVerificationStructure.setMessageHash(Hash hash)`
`void` `TunnelCreateMessage.setNextRouter(Hash routerIdentityHash)`
`void` `TunnelCreateMessage.setReplyGateway(Hash peer)`
`void` `DatabaseStoreMessage.setReplyGateway(Hash peer)`
`void` `DeliveryInstructions.setRouter(Hash router)`
`void` `DatabaseSearchReplyMessage.setSearchKey(Hash key)`
`void` `DatabaseLookupMessage.setSearchKey(Hash key)`

Constructors in net.i2p.data.i2np with parameters of type Hash
`TunnelVerificationStructure(Hash messageHash, Signature authSig)`

Uses of Hash in net.i2p.router

Methods in net.i2p.router that return Hash
`Hash` `TunnelPoolSettings.getDestination()` what destination is this a tunnel for (or null if none)
`Hash` `TunnelInfo.getDestination()` if this is a client tunnel, what destination is it for?
`Hash` `ClientMessage.getDestinationHash()` Retrieve the destination to which this message is directed.
`Hash` `MessageReceptionInfo.getFromPeer()` Hash of the RouterIdentity of the peer that sent the message
`Hash` `TunnelInfo.getPeer(int hop)` retrieve the peer at the given hop.
`Hash` `RouterContext.routerHash()` convenience method for querying the router's ident
`Hash` `DummyPeerManagerFacade.selectRandomByCapability(char capability)`
`Hash` `PeerManagerFacade.selectRandomByCapability(char capability)`

Methods in net.i2p.router with parameters of type Hash
`boolean` `RouterThrottleImpl.acceptNetDbLookupRequest(Hash key)`
`boolean` `RouterThrottle.acceptNetDbLookupRequest(Hash key)` Should we accept the netDb lookup message, replying either with the value or some closer peers, or should we simply drop it due to overload?
`boolean` `RouterDoSThrottle.acceptNetDbLookupRequest(Hash key)`
`int` `InNetMessagePool.add(I2NPMessage messageBody, RouterIdentity fromRouter, Hash fromRouterHash)` Add a new message to the pool, returning the number of messages in the pool so that the comm system can throttle inbound messages.
`void` `ProfileManager.commErrorOccurred(Hash peer)` Note that there was some sort of communication error talking with the peer
`Job` `HandlerJobBuilder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)` Create a new job to handle the received message.
`void` `ProfileManager.dbLookupFailed(Hash peer)` Note that the peer was unable to reply to a db lookup - either with data or with a lookupReply redirecting the user elsewhere
`void` `ProfileManager.dbLookupReceived(Hash peer)` Note that the local router received a db lookup from the given peer

`void`

`ProfileManager.dbLookupReply(Hash peer, int newPeers, int oldPeers, int invalid, int duplicate, long responseTimeMs)`
Note that the peer replied to a db lookup with a redirect to other routers, where the list of redirected users included newPeers routers that the local router didn't know about, oldPeers routers that the local router already knew about, the given invalid routers that were invalid in some way, and the duplicate number of routers that we explicitly asked them not to send us, but they did anyway

`void` `ProfileManager.dbLookupSuccessful(Hash peer, long responseTimeMs)` Note that the peer was able to return the valid data for a db lookup
`void` `ProfileManager.dbStoreFailed(Hash peer)` Note that we were unable to confirm a successful send of db data to the peer, at least not within our timeout period
`void` `ProfileManager.dbStoreReceived(Hash peer, boolean wasNewKey)` Note that the local router received an unprompted db store from the given peer
`void` `ProfileManager.dbStoreSent(Hash peer, long responseTimeMs)` Note that we've confirmed a successful send of db data to the peer (though we haven't necessarily requested it again from them, so they /might/ be lying)
`void` `MessageHistory.droppedInboundMessage(long messageId, Hash from, java.lang.String info)`
`void` `MessageHistory.droppedOtherMessage(I2NPMessage message, Hash from)` We received another message we weren't waiting for and don't know how to handle
`void` `MessageHistory.droppedTunnelMessage(TunnelId id, long msgId, java.util.Date expiration, Hash from)` We don't know about the given tunnel, so we are dropping a message sent to us by the given router
`void` `DummyNetworkDatabaseFacade.fail(Hash dbEntry)`
`abstract void` `NetworkDatabaseFacade.fail(Hash dbEntry)`
`java.util.Set` `DummyNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, java.util.Set peersToIgnore)`
`abstract java.util.Set` `NetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, java.util.Set peersToIgnore)` Return the RouterInfo structures for the routers closest to the given key.
`TunnelPoolSettings` `DummyTunnelManagerFacade.getInboundSettings(Hash client)`
`TunnelPoolSettings` `TunnelManagerFacade.getInboundSettings(Hash client)`
`LeaseSetKeys` `KeyManager.getKeys(Hash dest)`
`TunnelPoolSettings` `DummyTunnelManagerFacade.getOutboundSettings(Hash client)`
`TunnelPoolSettings` `TunnelManagerFacade.getOutboundSettings(Hash client)`
`void` `ProfileManager.heardAbout(Hash peer)` Note that the local router received a reference to the given peer, either through an explicit dbStore or in a dbLookupReply
`boolean` `CommSystemFacade.isBacklogged(Hash dest)`
`boolean` `DummyTunnelManagerFacade.isInUse(Hash peer)`
`boolean` `TunnelManagerFacade.isInUse(Hash peer)` True if the peer currently part of a tunnel
`boolean` `DummyClientManagerFacade.isLocal(Hash destHash)`
`abstract boolean` `ClientManagerFacade.isLocal(Hash destHash)` Determine if the destination hash specified is managed locally.
`boolean` `Shitlist.isShitlisted(Hash peer)`
`boolean` `Shitlist.isShitlisted(Hash peer, java.lang.String transport)`
`boolean` `DummyTunnelManagerFacade.isValidTunnel(Hash client, TunnelInfo tunnel)`
`boolean` `TunnelManagerFacade.isValidTunnel(Hash client, TunnelInfo tunnel)` Is a tunnel a valid member of the pool?
`void` `DummyNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`abstract void` `NetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`LeaseSet` `DummyNetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)`
`abstract LeaseSet` `NetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)`
`void` `DummyNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`abstract void` `NetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`RouterInfo` `DummyNetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)`
`abstract RouterInfo` `NetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)`
`void` `ProfileManager.messageFailed(Hash peer)` Note that the router failed to send a message to the peer over any transport
`void` `ProfileManager.messageFailed(Hash peer, java.lang.String transport)` Note that the router failed to send a message to the peer over the transport specified
`void` `ProfileManager.messageReceived(Hash peer, java.lang.String style, long msToReceive, int bytesRead)` Note that the router received a message from the given peer on the specified transport.
`void` `ProfileManager.messageSent(Hash peer, java.lang.String transport, long msToSend, long bytesSent)` Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
`void` `MessageHistory.receiveMessage(java.lang.String messageType, long messageId, long expiration, Hash from, boolean isValid)` We just received a message from the peer
`void` `MessageHistory.receiveTunnelCreate(TunnelId createTunnel, Hash nextPeer, java.util.Date expire, boolean ok, Hash sourceRoutePeer)` The local router has received a request to join the createTunnel with the next hop being nextPeer, and we should send our decision to join it through sourceRoutePeer
`void` `DummyPeerManagerFacade.removeCapabilities(Hash peer)`
`void` `PeerManagerFacade.removeCapabilities(Hash peer)`
`void` `DummyClientManagerFacade.requestLeaseSet(Hash dest, LeaseSet set)`
`abstract void` `ClientManagerFacade.requestLeaseSet(Hash dest, LeaseSet set)`

`void`

`MessageHistory.requestTunnelCreate(TunnelId createTunnel, TunnelId outTunnel, Hash peerRequested, Hash nextPeer, TunnelId replyTunnel, Hash replyThrough)`
We are requesting that the peerRequested create the tunnel specified with the given nextPeer, and we are sending that request to them through outTunnel with a request that the reply is sent back to us through replyTunnel on the given replyThrough router.

`TunnelInfo` `DummyTunnelManagerFacade.selectInboundTunnel(Hash destination)`
`TunnelInfo` `TunnelManagerFacade.selectInboundTunnel(Hash destination)` pick an inbound tunnel bound to the given destination
`TunnelInfo` `DummyTunnelManagerFacade.selectOutboundTunnel(Hash destination)`
`TunnelInfo` `TunnelManagerFacade.selectOutboundTunnel(Hash destination)` pick an outbound tunnel bound to the given destination
`void` `MessageHistory.sendMessage(java.lang.String messageType, long messageId, long expiration, Hash peer, boolean sentOk, java.lang.String info)` We just sent a message to the peer
`void` `DummyPeerManagerFacade.setCapabilities(Hash peer, java.lang.String caps)`
`void` `PeerManagerFacade.setCapabilities(Hash peer, java.lang.String caps)`
`void` `TunnelPoolSettings.setDestination(Hash dest)`
`void` `ClientMessage.setDestinationHash(Hash dest)`
`void` `MessageReceptionInfo.setFromPeer(Hash routerIdentityHash)`
`void` `DummyTunnelManagerFacade.setInboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `TunnelManagerFacade.setInboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `DummyTunnelManagerFacade.setOutboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `TunnelManagerFacade.setOutboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `MessageHistory.shitlist(Hash peer, java.lang.String reason)` We shitlisted the peer
`boolean` `Shitlist.shitlistRouter(Hash peer)`
`boolean` `Shitlist.shitlistRouter(Hash peer, java.lang.String reason)`
`boolean` `Shitlist.shitlistRouter(Hash peer, java.lang.String reason, java.lang.String transport)`
`boolean` `ClientManagerFacade.shouldPublishLeaseSet(Hash destinationHash)` Does the client specified want their leaseSet published?
`LeaseSet` `DummyNetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)`
`abstract LeaseSet` `NetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)` return the leaseSet if another leaseSet already existed at that key
`RouterInfo` `DummyNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)`
`abstract RouterInfo` `NetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)` return the routerInfo if another router already existed at that key
`void` `ProfileManager.tunnelDataPushed(Hash peer, long rtt, int size)` Note that we were able to push some data through a tunnel that the peer is participating in (detected after rtt).
`void` `ProfileManager.tunnelDataPushed1m(Hash peer, int size)` Note that the peer is participating in a tunnel that pushed the given amount of data over the last minute.
`void` `MessageHistory.tunnelDispatched(long messageId, long tunnelId, long toTunnel, Hash toPeer, java.lang.String type)`
`void` `ProfileManager.tunnelFailed(Hash peer)` Note that the peer participated in a tunnel that failed.
`void` `ProfileManager.tunnelJoined(Hash peer, long responseTimeMs)` Note that the router agreed to participate in a tunnel
`void` `ProfileManager.tunnelLifetimePushed(Hash peer, long lifetime, long size)` Note that we were able to push the given amount of data through a tunnel that the peer is participating in
`void` `MessageHistory.tunnelParticipantRejected(Hash peer, java.lang.String msg)`
`void` `ProfileManager.tunnelRejected(Hash peer, long responseTimeMs, int severity)` Note that a router explicitly rejected joining a tunnel
`void` `MessageHistory.tunnelRejected(Hash peer, TunnelId tunnel, Hash replyThrough, java.lang.String reason)` The peer did not accept the tunnel join for the given reason
`void` `MessageHistory.tunnelRequestTimedOut(Hash peer, TunnelId tunnel)` The peer did not accept the tunnel join for the given reason (this may be because of a timeout or an explicit refusal).
`void` `ProfileManager.tunnelTestSucceeded(Hash peer, long responseTimeMs)` Note that a tunnel that the router is participating in was successfully tested with the given round trip latency
`void` `MessageHistory.unshitlist(Hash peer)` We unshitlisted the peer
`void` `Shitlist.unshitlistRouter(Hash peer)`
`void` `Shitlist.unshitlistRouter(Hash peer, java.lang.String transport)`

Uses of Hash in net.i2p.router.client

Methods in net.i2p.router.client that return Hash
`Hash` `ClientConnectionRunner.getDestHash()`

Methods in net.i2p.router.client with parameters of type Hash
`boolean` `ClientManagerFacadeImpl.isLocal(Hash destHash)` Determine if the destination specified is managed locally.
`boolean` `ClientManager.isLocal(Hash destHash)`
`void` `ClientManagerFacadeImpl.requestLeaseSet(Hash dest, LeaseSet set)`
`void` `ClientManager.requestLeaseSet(Hash dest, LeaseSet ls)`
`boolean` `ClientManagerFacadeImpl.shouldPublishLeaseSet(Hash destinationHash)`
`boolean` `ClientManager.shouldPublishLeaseSet(Hash destHash)`

Uses of Hash in net.i2p.router.message

Methods in net.i2p.router.message with parameters of type Hash
`boolean` `OutboundClientMessageStatus.alreadySent(Hash gateway, TunnelId tunnelId)` have we already sent the message down this tunnel?

`(package private) static GarlicMessage`

`OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, PayloadGarlicConfig dataClove, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, java.util.Set wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)`
Allow the app to specify the data clove directly, which enables OutboundClientMessage to resend the same payload (including expiration and unique id) in different garlics (down different tunnels)

`(package private) static GarlicMessage`

`OutboundClientMessageJobHelper.createGarlicMessage(RouterContext ctx, long replyToken, long expiration, PublicKey recipientPK, Payload data, Hash from, Destination dest, TunnelInfo replyTunnel, SessionKey wrappedKey, java.util.Set wrappedTags, boolean requireAck, LeaseSet bundledReplyLeaseSet)`
Build a garlic message that will be delivered to the router on which the target is located.

`Job` `GarlicMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`void` `OutboundClientMessageStatus.sent(Hash gateway, TunnelId tunnelId)`

Constructors in net.i2p.router.message with parameters of type Hash
`BuildTestMessageJob(RouterContext ctx, RouterInfo target, Hash replyTo, Job onSendJob, Job onSendFailedJob, long timeoutMs, int priority)`
`GarlicMessageReceiver(RouterContext context, GarlicMessageReceiver.CloveReceiver receiver, Hash clientDestination)`
`HandleGarlicMessageJob(RouterContext context, GarlicMessage msg, RouterIdentity from, Hash fromHash)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, int timeoutMs, int priority)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, Job onSend, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)`
`SendMessageDirectJob(RouterContext ctx, I2NPMessage message, Hash toPeer, ReplyJob onSuccess, Job onFail, MessageSelector selector, int timeoutMs, int priority)`

Uses of Hash in net.i2p.router.networkdb

Methods in net.i2p.router.networkdb with parameters of type Hash
`Job` `DatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`Job` `DatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`

Constructors in net.i2p.router.networkdb with parameters of type Hash
`HandleDatabaseLookupMessageJob(RouterContext ctx, DatabaseLookupMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`HandleDatabaseStoreMessageJob(RouterContext ctx, DatabaseStoreMessage receivedMessage, RouterIdentity from, Hash fromHash)`

Uses of Hash in net.i2p.router.networkdb.kademlia

Methods in net.i2p.router.networkdb.kademlia that return Hash
`Hash` `KBucketImpl.generateRandomKey()` Generate a random key to go within this bucket
`Hash` `KBucket.generateRandomKey()` Generate a random key that would go inside this bucket
`(package private) Hash` `FloodSearchJob.getKey()`
`(package private) Hash` `FloodOnlySearchJob.getKey()`
`Hash` `KBucketImpl.getLocal()`
`Hash` `KBucket.getLocal()`
`Hash` `KBucketImpl.getRangeBeginKey()`
`Hash` `KBucketImpl.getRangeEndKey()`
`Hash` `StoreState.getTarget()`
`Hash` `SearchState.getTarget()`

Methods in net.i2p.router.networkdb.kademlia with parameters of type Hash
`void` `SelectionCollector.add(Hash entry)`
`(package private) boolean` `SearchJob.add(Hash peer)`
`boolean` `KBucketSet.add(Hash peer)` Return true if the peer is new to the bucket it goes in, or false if it was already in it
`int` `KBucketImpl.add(Hash peer)`
`int` `KBucket.add(Hash key)` Add the peer to the bucket
`void` `StoreState.addPending(Hash peer)`
`void` `SearchState.addPending(Hash peer)`
`void` `StoreState.addSkipped(Hash peer)` we aren't even going to try to contact this peer
`protected DatabaseLookupMessage` `SearchJob.buildMessage(TunnelId replyTunnelId, Hash replyGateway, long expiration)` Build the database search message
`(package private) void` `FloodfillNetworkDatabaseFacade.complete(Hash key)`
`long` `StoreState.confirmed(Hash peer)`
`long` `StoreState.confirmedExploratory(Hash peer)`
`Job` `FloodfillDatabaseStoreMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`Job` `FloodfillDatabaseLookupMessageHandler.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`long` `SearchState.dataFound(Hash peer)` how long did it take to get the reply, or -1 if we don't know
`protected void` `KademliaNetworkDatabaseFacade.dropAfterLookupFailed(Hash peer, RouterInfo info)`
`void` `KademliaNetworkDatabaseFacade.fail(Hash dbEntry)`
`java.util.Set` `KademliaNetworkDatabaseFacade.findNearestRouters(Hash key, int maxNumRouters, java.util.Set peersToIgnore)` Get the routers closest to that key in response to a remote lookup
`DataStructure` `TransientDataStore.get(Hash key)`
`DataStructure` `DataStore.get(Hash key)`
`protected java.math.BigInteger` `PeerSelector.getDistance(Hash targetKey, Hash routerInQuestion)`
`java.lang.Long` `KademliaNetworkDatabaseFacade.getLastSent(Hash key)`
`int` `KademliaNetworkDatabaseFacade.getPeerTimeout(Hash peer)`
`protected int` `SearchJob.getPerPeerTimeoutMs(Hash peer)`
`boolean` `TransientDataStore.isKnown(Hash key)`
`boolean` `DataStore.isKnown(Hash key)`
`protected void` `KademliaNetworkDatabaseFacade.lookupBeforeDropping(Hash peer, RouterInfo info)`
`protected void` `FloodfillNetworkDatabaseFacade.lookupBeforeDropping(Hash peer, RouterInfo info)`
`void` `KademliaNetworkDatabaseFacade.lookupLeaseSet(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`LeaseSet` `KademliaNetworkDatabaseFacade.lookupLeaseSetLocally(Hash key)`
`void` `KademliaNetworkDatabaseFacade.lookupRouterInfo(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs)`
`RouterInfo` `KademliaNetworkDatabaseFacade.lookupRouterInfoLocally(Hash key)`
`void` `KademliaNetworkDatabaseFacade.noteKeySent(Hash key)`
`int` `KBucketSet.pickBucket(Hash key)`
`void` `TransientDataStore.put(Hash key, DataStructure data)`
`void` `PersistentDataStore.put(Hash key, DataStructure data)`
`void` `DataStore.put(Hash key, DataStructure data)`
`DataStructure` `TransientDataStore.remove(Hash key)`
`DataStructure` `PersistentDataStore.remove(Hash key)`
`boolean` `KBucketSet.remove(Hash entry)`
`boolean` `KBucketImpl.remove(Hash peer)`
`boolean` `KBucket.remove(Hash key)` Remove the key from the bucket
`DataStructure` `DataStore.remove(Hash key)`
`void` `SearchState.removePending(Hash peer)` we didn't actually want to add this peer as part of the pending list...
`(package private) void` `SearchJob.replyFound(DatabaseSearchReplyMessage message, Hash peer)`
`long` `SearchState.replyFound(Hash peer)` how long did it take to get the reply, or -1 if we dont know
`void` `StoreState.replyTimeout(Hash peer)`
`void` `SearchState.replyTimeout(Hash peer)`
`(package private) SearchJob` `KademliaNetworkDatabaseFacade.search(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs, boolean isLease)` Begin a kademlia style search for the key specified, which can take up to timeoutMs and will fire the appropriate jobs on success or timeout (or if the kademlia search completes without any match)
`(package private) SearchJob` `FloodfillNetworkDatabaseFacade.search(Hash key, Job onFindJob, Job onFailedLookupJob, long timeoutMs, boolean isLease)` Begin a kademlia style search for the key specified, which can take up to timeoutMs and will fire the appropriate jobs on success or timeout (or if the kademlia search completes without any match)
`(package private) void` `KademliaNetworkDatabaseFacade.searchComplete(Hash key)` The search for the given key is no longer active
`(package private) void` `FloodfillNetworkDatabaseFacade.searchFull(Hash key, java.util.List onFind, java.util.List onFailed, long timeoutMs, boolean isLease)` Ok, the initial set of searches to the floodfill peers timed out, lets fall back on the wider kademlia-style searches
`java.util.List` `PeerSelector.selectMostReliablePeers(Hash key, int numClosest, java.util.Set alreadyChecked, KBucketSet kbuckets)` Search through the kbucket set to find the most reliable peers close to the given key, skipping all of the ones already checked
`java.util.List` `PeerSelector.selectNearest(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)` Generic KBucket filtering to find the hashes close to a key, regardless of other considerations.
`java.util.List` `PeerSelector.selectNearestExplicit(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)` Ignore KBucket ordering and do the XOR explicitly per key.
`java.util.List` `PeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)` Ignore KBucket ordering and do the XOR explicitly per key.
`java.util.List` `FloodfillPeerSelector.selectNearestExplicitThin(Hash key, int maxNumRouters, java.util.Set peersToIgnore, KBucketSet kbuckets)` Pick out peers with the floodfill capacity set, returning them first, but then after they're complete, sort via kademlia.
`void` `KademliaNetworkDatabaseFacade.sendStore(Hash key, DataStructure ds, Job onSuccess, Job onFailure, long sendTimeout, java.util.Set toIgnore)`
`void` `FloodfillNetworkDatabaseFacade.sendStore(Hash key, DataStructure ds, Job onSuccess, Job onFailure, long sendTimeout, java.util.Set toIgnore)`
`boolean` `KBucketImpl.shouldContain(Hash key)`
`boolean` `KBucket.shouldContain(Hash key)` whether or not the key qualifies as part of this bucket
`(package private) void` `KademliaNetworkDatabaseFacade.stopPublishing(Hash target)`
`LeaseSet` `KademliaNetworkDatabaseFacade.store(Hash key, LeaseSet leaseSet)` Store the leaseSet
`RouterInfo` `KademliaNetworkDatabaseFacade.store(Hash key, RouterInfo routerInfo)` store the routerInfo
`(package private) java.lang.String` `KademliaNetworkDatabaseFacade.validate(Hash key, LeaseSet leaseSet)` Determine whether this leaseSet will be accepted as valid and current given what we know now.
`(package private) java.lang.String` `KademliaNetworkDatabaseFacade.validate(Hash key, RouterInfo routerInfo)` Determine whether this routerInfo will be accepted as valid and current given what we know now.
`boolean` `SearchState.wasAttempted(Hash peer)`
`(package private) boolean` `SearchJob.wasAttempted(Hash peer)`

Constructors in net.i2p.router.networkdb.kademlia with parameters of type Hash
`ExploreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key)` Create a new search for the routingKey specified
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs)` Create a new search for the routingKey specified
`FloodfillStoreJob(RouterContext context, FloodfillNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs, java.util.Set toSkip)`
`FloodfillVerifyStoreJob(RouterContext ctx, Hash key, FloodfillNetworkDatabaseFacade facade)`
`FloodOnlySearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)`
`FloodSearchJob(RouterContext ctx, FloodfillNetworkDatabaseFacade facade, Hash key, Job onFind, Job onFailed, int timeoutMs, boolean isLease)`
`HandleFloodfillDatabaseLookupMessageJob(RouterContext ctx, DatabaseLookupMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`HandleFloodfillDatabaseStoreMessageJob(RouterContext ctx, DatabaseStoreMessage receivedMessage, RouterIdentity from, Hash fromHash, FloodfillNetworkDatabaseFacade facade)`
`KBucketImpl(I2PAppContext context, Hash local)`
`KBucketSet(I2PAppContext context, Hash us)`
`ReplyNotVerifiedJob(RouterContext enclosingContext, SearchReplyJob srj, Hash key)`
`ReplyVerifiedJob(RouterContext enclosingContext, SearchReplyJob srj, Hash key)`
`RepublishLeaseSetJob(RouterContext ctx, KademliaNetworkDatabaseFacade facade, Hash destHash)`
`SearchJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, Job onSuccess, Job onFailure, long timeoutMs, boolean keepStats, boolean isLease)` Create a new search for the routingKey specified
`SearchReplyJob(RouterContext enclosingContext, SearchJob job, DatabaseSearchReplyMessage message, Hash peer, long duration)`
`SearchState(RouterContext context, Hash key)`
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs)` Create a new search for the routingKey specified
`StoreJob(RouterContext context, KademliaNetworkDatabaseFacade facade, Hash key, DataStructure data, Job onSuccess, Job onFailure, long timeoutMs, java.util.Set toSkip)`
`StoreState(RouterContext ctx, Hash key, DataStructure data)`
`StoreState(RouterContext ctx, Hash key, DataStructure data, java.util.Set toSkip)`
`XORComparator(Hash target)`

Uses of Hash in net.i2p.router.peermanager

Methods in net.i2p.router.peermanager that return Hash
`Hash` `PeerProfile.getPeer()` what peer is being profiled
`(package private) Hash` `ProfileOrganizer.getUs()`
`Hash` `PeerManagerFacadeImpl.selectRandomByCapability(char capability)`
`Hash` `PeerManager.selectRandomByCapability(char capability)`

Methods in net.i2p.router.peermanager with parameters of type Hash
`void` `ProfileManagerImpl.commErrorOccurred(Hash peer)` Note that there was some sort of communication error talking with the peer
`void` `ProfileManagerImpl.dbLookupFailed(Hash peer)` Note that the peer was unable to reply to a db lookup - either with data or with a lookupReply redirecting the user elsewhere
`void` `ProfileManagerImpl.dbLookupReceived(Hash peer)` Note that the local router received a db lookup from the given peer

`void`

`ProfileManagerImpl.dbLookupReply(Hash peer, int newPeers, int oldPeers, int invalid, int duplicate, long responseTimeMs)`
Note that the peer replied to a db lookup with a redirect to other routers, where the list of redirected users included newPeers routers that the local router didn't know about, oldPeers routers that the local router already knew about, the given invalid routers that were invalid in some way, and the duplicate number of routers that we explicitly asked them not to send us, but they did anyway

`void` `ProfileManagerImpl.dbLookupSuccessful(Hash peer, long responseTimeMs)` Note that the peer was able to return the valid data for a db lookup
`void` `ProfileManagerImpl.dbStoreFailed(Hash peer)` Note that we were unable to confirm a successful send of db data to the peer, at least not within our timeout period
`void` `ProfileManagerImpl.dbStoreReceived(Hash peer, boolean wasNewKey)` Note that the local router received an unprompted db store from the given peer
`void` `ProfileManagerImpl.dbStoreSent(Hash peer, long responseTimeMs)` Note that we've confirmed a successful send of db data to the peer (though we haven't necessarily requested it again from them, so they /might/ be lying)
`void` `ProfileOrganizer.exportProfile(Hash profile, java.io.OutputStream out)`
`PeerProfile` `ProfileOrganizer.getProfile(Hash peer)` Retrieve the profile for the given peer, if one exists (else null)
`void` `ProfileManagerImpl.heardAbout(Hash peer)` Note that the local router received a reference to the given peer, either through an explicit dbStore or in a dbLookupReply
`boolean` `ProfileOrganizer.isFailing(Hash peer)`
`boolean` `ProfileOrganizer.isFast(Hash peer)`
`boolean` `ProfileOrganizer.isHighCapacity(Hash peer)`
`boolean` `ProfileOrganizer.isSelectable(Hash peer)`
`boolean` `ProfileOrganizer.isWellIntegrated(Hash peer)`
`void` `ProfileManagerImpl.messageFailed(Hash peer)` Note that the router failed to send a message to the peer over any transport
`void` `ProfileManagerImpl.messageFailed(Hash peer, java.lang.String transport)` Note that the router failed to send a message to the peer over the transport specified
`void` `ProfileManagerImpl.messageReceived(Hash peer, java.lang.String style, long msToReceive, int bytesRead)` Note that the router received a message from the given peer on the specified transport.
`void` `ProfileManagerImpl.messageSent(Hash peer, java.lang.String transport, long msToSend, long bytesSent)` Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
`boolean` `ProfileOrganizer.peerSendsBadReplies(Hash peer)` Does the given peer send us bad replies - either invalid store messages (expired, corrupt, etc) or unreachable replies (pointing towards routers that don't exist).
`(package private) void` `PersistProfilesJob.persist(Hash peer)`
`void` `PeerManagerFacadeImpl.removeCapabilities(Hash peer)`
`void` `PeerManager.removeCapabilities(Hash peer)`
`void` `PeerManagerFacadeImpl.setCapabilities(Hash peer, java.lang.String caps)`
`void` `PeerManager.setCapabilities(Hash peer, java.lang.String caps)`
`void` `PeerProfile.setPeer(Hash peer)`
`void` `ProfilePersistenceHelper.setUs(Hash routerIdentHash)`
`void` `ProfileOrganizer.setUs(Hash us)`
`(package private) void` `PeerManager.storeProfile(Hash peer)`
`void` `ProfileManagerImpl.tunnelDataPushed(Hash peer, long rtt, int size)`
`void` `ProfileManagerImpl.tunnelDataPushed1m(Hash peer, int size)`
`void` `ProfileManagerImpl.tunnelFailed(Hash peer)` Note that the peer participated in a tunnel that failed.
`void` `ProfileManagerImpl.tunnelJoined(Hash peer, long responseTimeMs)` Note that the router agreed to participate in a tunnel
`void` `ProfileManagerImpl.tunnelLifetimePushed(Hash peer, long lifetime, long size)`
`void` `ProfileManagerImpl.tunnelRejected(Hash peer, long responseTimeMs, int severity)` Note that a router explicitly rejected joining a tunnel.
`void` `ProfileManagerImpl.tunnelTestSucceeded(Hash peer, long responseTimeMs)` Note that a tunnel that the router is participating in was successfully tested with the given round trip latency

Constructors in net.i2p.router.peermanager with parameters of type Hash
`PeerProfile(RouterContext context, Hash peer)`
`PeerProfile(RouterContext context, Hash peer, boolean expand)`

Uses of Hash in net.i2p.router.transport

Methods in net.i2p.router.transport with parameters of type Hash
`boolean` `TransportManager.isBacklogged(Hash dest)`
`boolean` `TransportImpl.isBacklogged(Hash dest)`
`boolean` `Transport.isBacklogged(Hash dest)`
`boolean` `CommSystemFacadeImpl.isBacklogged(Hash dest)`
`boolean` `TransportImpl.isUnreachable(Hash peer)`
`boolean` `Transport.isUnreachable(Hash peer)`
`void` `TransportImpl.markReachable(Hash peer)` called when we establish a peer connection (outbound or inbound)
`void` `TransportImpl.markUnreachable(Hash peer)` called when we can't reach a peer
`void` `TransportManager.messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash)`
`void` `TransportEventListener.messageReceived(I2NPMessage message, RouterIdentity fromRouter, Hash fromRouterHash)`
`void` `TransportImpl.messageReceived(I2NPMessage inMsg, RouterIdentity remoteIdent, Hash remoteIdentHash, long msToReceive, int bytesReceived)` Message received from the I2NPMessageReader - send it to the listener
`void` `VMCommSystem.receive(byte[] message, Hash fromPeer)` We send messages between comms as bytes so that we strip any router-local info.

Uses of Hash in net.i2p.router.transport.ntcp

Methods in net.i2p.router.transport.ntcp with parameters of type Hash
`boolean` `NTCPTransport.isBacklogged(Hash dest)`

Uses of Hash in net.i2p.router.transport.tcp

Methods in net.i2p.router.transport.tcp that return Hash
`Hash` `TCPConnection.getAttemptedPeer()` Who we initially were trying to contact

Methods in net.i2p.router.transport.tcp with parameters of type Hash
`SessionKey` `ConnectionTagManager.getKey(Hash peer)`
`ByteArray` `ConnectionTagManager.getTag(Hash peer)` Retrieve the associated tag (but do not consume it)
`void` `ConnectionTagManager.replaceTag(Hash peer, ByteArray newTag, SessionKey key)` Update the tag associated with a peer, dropping the old one
`void` `TCPConnection.setAttemptedPeer(Hash peer)` Who we initially were trying to contact

Uses of Hash in net.i2p.router.transport.udp

Methods in net.i2p.router.transport.udp that return Hash
`Hash` `InboundMessageState.getFrom()`
`Hash` `PeerState.getRemotePeer()` The peer are we talking to.

Methods in net.i2p.router.transport.udp with parameters of type Hash
`void` `OutboundMessageFragments.acked(ACKBitfield bitfield, Hash ackedBy)`
`int` `OutboundMessageFragments.acked(long messageId, Hash ackedBy)` We received an ACK of the given messageId from the given peer, so if it is still unacked, mark it as complete.
`void` `TimedWeightedPriorityMessageQueue.choke(Hash peer)`
`void` `OutboundMessageFragments.ActiveThrottle.choke(Hash peer)`
`(package private) void` `UDPTransport.dropPeer(Hash peer, boolean shouldShitlist, java.lang.String why)`
`(package private) void` `UDPTransport.externalAddressReceived(Hash from, byte[] ourIP, int ourPort)` Someone we tried to contact gave us what they think our IP address is.
`PeerState` `UDPTransport.getPeerState(Hash remotePeer)` get the state for the peer with the given ident, or null if no state exists
`boolean` `TimedWeightedPriorityMessageQueue.isChoked(Hash peer)`
`boolean` `OutboundMessageFragments.ActiveThrottle.isChoked(Hash peer)`
`void` `UDPTransport.messageReceived(I2NPMessage inMsg, RouterIdentity remoteIdent, Hash remoteIdentHash, long msToReceive, int bytesReceived)`
`void` `PeerState.setRemotePeer(Hash peer)` The peer are we talking to.
`void` `TimedWeightedPriorityMessageQueue.unchoke(Hash peer)`
`void` `OutboundMessageFragments.ActiveThrottle.unchoke(Hash peer)`

Constructors in net.i2p.router.transport.udp with parameters of type Hash
`InboundMessageState(RouterContext ctx, long messageId, Hash from)`

Uses of Hash in net.i2p.router.tunnel

Fields in net.i2p.router.tunnel declared as Hash
`protected Hash` `TunnelGateway.Pending._toRouter`

Methods in net.i2p.router.tunnel that return Hash
`Hash` `TunnelCreatorConfig.getDestination()` if this is a client tunnel, what destination is it for?
`Hash` `InboundEndpointProcessor.getDestination()`
`Hash` `TunnelCreatorConfig.getPeer(int hop)` retrieve the peer at the given hop.
`Hash` `HopConfig.getReceiveFrom()` what is the previous peer in the tunnel (if any)?
`Hash` `HopConfig.getSendTo()` what is the next peer in the tunnel (if any)?
`Hash` `FragmentedMessage.getTargetRouter()`
`Hash` `TunnelGateway.Pending.getToRouter()` may be null

Methods in net.i2p.router.tunnel with parameters of type Hash
`void` `TunnelGatewayZeroHop.add(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)` Add a message to be sent down the tunnel (immediately forwarding it to the `InboundMessageDistributor` or `OutboundMessageDistributor`, as necessary).
`void` `TunnelGateway.add(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)` Add a message to be sent down the tunnel, either sending it now (perhaps coallesced with other pending messages) or after a brief pause (_flushFrequency).
`void` `PumpedTunnelGateway.add(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)` Add a message to be sent down the tunnel, either sending it now (perhaps coallesced with other pending messages) or after a brief pause (_flushFrequency).
`TunnelBuildMessage` `BuildMessageGenerator.createOutbound(RouterContext ctx, TunnelCreatorConfig cfg, Hash replyRouter, long replyTunnel)` return null if it is unable to find a router's public key (etc)
`void` `BuildMessageGenerator.createRecord(int recordNum, int hop, TunnelBuildMessage msg, TunnelCreatorConfig cfg, Hash replyRouter, long replyTunnel, I2PAppContext ctx, PublicKey peerKey)` Place the asymmetrically encrypted record in the specified record slot, containing the hop's configuration (as well as the reply info, if it is an outbound endpoint)
`BuildRequestRecord` `BuildMessageProcessor.decrypt(I2PAppContext ctx, TunnelBuildMessage msg, Hash ourHash, PrivateKey privKey)` Decrypt the record targetting us, encrypting all of the other records with the included reply key and IV.
`void` `TunnelParticipant.dispatch(TunnelDataMessage msg, Hash recvFrom)`
`void` `TunnelDispatcher.dispatch(TunnelDataMessage msg, Hash recvFrom)` We are participating in a tunnel (perhaps we're even the endpoint), so take the message and do what it says.
`void` `OutboundTunnelEndpoint.dispatch(TunnelDataMessage msg, Hash recvFrom)`
`void` `TunnelDispatcher.dispatchOutbound(I2NPMessage msg, TunnelId outboundTunnel, Hash targetPeer)` We are the outbound tunnel gateway (we created it), so wrap up this message with instructions to be forwarded to the targetPeer when it reaches the endpoint.
`void` `TunnelDispatcher.dispatchOutbound(I2NPMessage msg, TunnelId outboundTunnel, TunnelId targetTunnel, Hash targetPeer)` We are the outbound tunnel gateway (we created it), so wrap up this message with instructions to be forwarded to the targetTunnel on the targetPeer when it reaches the endpoint.
`void` `OutboundMessageDistributor.distribute(I2NPMessage msg, Hash target)`
`void` `InboundMessageDistributor.distribute(I2NPMessage msg, Hash target)`
`void` `OutboundMessageDistributor.distribute(I2NPMessage msg, Hash target, TunnelId tunnel)`
`void` `InboundMessageDistributor.distribute(I2NPMessage msg, Hash target, TunnelId tunnel)`
`boolean` `HopProcessor.process(byte[] orig, int offset, int length, Hash prev)` Process the data for the current hop, overwriting the original data with what should be sent to the next peer.
`boolean` `FragmentedMessage.receive(long messageId, byte[] payload, int offset, int length, boolean isLast, Hash toRouter, TunnelId toTunnel)` Receive the first fragment and related metadata.
`void` `FragmentHandler.DefragmentedReceiver.receiveComplete(I2NPMessage msg, Hash toRouter, TunnelId toTunnel)` Receive a fully formed I2NPMessage out of the tunnel
`boolean` `InboundEndpointProcessor.retrievePreprocessedData(byte[] orig, int offset, int length, Hash prev)` Undo all of the encryption done by the peers in the tunnel, recovering the preprocessed data sent by the gateway.
`void` `TunnelCreatorConfig.setPeer(int hop, Hash peer)`
`void` `HopConfig.setReceiveFrom(Hash from)`
`void` `HopConfig.setSendTo(Hash to)`

Constructors in net.i2p.router.tunnel with parameters of type Hash
`InboundMessageDistributor(RouterContext ctx, Hash client)`
`TunnelCreatorConfig(RouterContext ctx, int length, boolean isInbound, Hash destination)`
`TunnelGateway.Pending(I2NPMessage message, Hash toRouter, TunnelId toTunnel)`
`TunnelGateway.Pending(I2NPMessage message, Hash toRouter, TunnelId toTunnel, long now)`
`TunnelGateway.PendingImpl(I2NPMessage message, Hash toRouter, TunnelId toTunnel)`

Uses of Hash in net.i2p.router.tunnel.pool

Methods in net.i2p.router.tunnel.pool with parameters of type Hash
`Job` `TunnelMessageHandlerBuilder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`Job` `HandleTunnelCreateMessageJob.Builder.createJob(I2NPMessage receivedMessage, RouterIdentity from, Hash fromHash)`
`TunnelPoolSettings` `TunnelPoolManager.getInboundSettings(Hash client)`
`TunnelPoolSettings` `TunnelPoolManager.getOutboundSettings(Hash client)`
`boolean` `TunnelPoolManager.isInUse(Hash peer)`
`boolean` `TunnelPoolManager.isValidTunnel(Hash client, TunnelInfo tunnel)`
`void` `TunnelPoolManager.removeTunnels(Hash destination)`
`TunnelInfo` `TunnelPoolManager.selectInboundTunnel(Hash destination)` pick an inbound tunnel bound to the given destination
`TunnelInfo` `TunnelPoolManager.selectOutboundTunnel(Hash destination)` pick an outbound tunnel bound to the given destination
`void` `TunnelPoolManager.setInboundSettings(Hash client, TunnelPoolSettings settings)`
`void` `TunnelPoolManager.setOutboundSettings(Hash client, TunnelPoolSettings settings)`

Constructors in net.i2p.router.tunnel.pool with parameters of type Hash
`PooledTunnelCreatorConfig(RouterContext ctx, int length, boolean isInbound, Hash destination)`