github.com/

Package btcec implements support for the elliptic curves needed for bitcoin.

Package backoff implements backoff algorithms for retrying operations.

Package xxhash implements the 64-bit variant of xxHash (XXH64) as described at http://cyan4973.github.io/xxHash/.

Package generic contains the generic marker types.

ignore is a library which returns a new ignorer object which can test against various paths.

Package pubsub implements a simple multi-topic pub-sub library.

Package badger implements an embeddable, simple and fast key-value database, written in pure Go.

Package humanize converts boring ugly numbers to human-friendly strings and back.

Package atomicfile provides the ability to write a file with an eventual rename on Close (using os.Rename).

Package noise implements the Noise Protocol Framework.

Package gojay implements encoding and decoding of JSON as defined in RFC 7159.

Package gogoproto provides extensions for protocol buffers to achieve: - fast marshalling and unmarshalling.

Package proto converts data structures to and from the wire format of protocol buffers.

Package descriptor provides functions for obtaining protocol buffer descriptors for generated Go types.

Package proto provides functionality for handling protocol buffer messages.

Package snappy implements the Snappy compression format.

Package routing provides a very basic but mostly functional implementation of a routing table for IPv4/IPv6 addresses.

Package uuid generates and inspects UUIDs.

Package websocket implements the WebSocket protocol defined in RFC 6455.

Package errwrap implements methods to formalize error wrapping in Go.

Package lru provides three different LRU caches of varying sophistication.

goupnp is an implementation of a client for various UPnP services.

Client for UPnP Device Control Protocol Internet Gateway Device v1.

Client for UPnP Device Control Protocol Internet Gateway Device v2.

Package bitswap implements the IPFS exchange interface with the BitSwap bilateral exchange protocol.

Package wantlist implements an object for bitswap that contains the keys that a given peer wants.

Package blocks contains the lowest level of IPLD data structures.

package blockservice implements a BlockService interface that provides a single GetBlock/AddBlock interface that seamlessly retrieves data either locally or from a remote peer through the exchange.

Package cid implements the Content-IDentifiers specification (https://github.com/ipld/cid) in Go.

Package autobatch provides a go-datastore implementation that automatically batches together writes by holding puts in memory until a certain threshold is met.

Package keytransform introduces a Datastore Shim that transforms keys before passing them to its child.

Package mount provides a Datastore that has other Datastores mounted at various key prefixes and is threadsafe

Package namespace introduces a namespace Datastore Shim, which basically mounts the entire child datastore under a prefix.

Package flatfs is a Datastore implementation that stores all objects in a two-level directory structure in the local file system, regardless of the hierarchy of the keys.

Package measure provides a Datastore wrapper that records metrics using github.com/ipfs/go-metrics-interface

Package filestore implements a Blockstore which is able to read certain blocks of data directly from its original location in the filesystem.

IPFS is a global, versioned, peer-to-peer filesystem

Package blockstore implements a thin wrapper over a datastore, giving a clean interface for Getting and Putting block objects.

Package chunk implements streaming block splitters.

package config implements the ipfs config file datastructures and utilities.

Package dshelp provides utilities for parsing and creating datastore keys used by go-ipfs

Package exchange defines the IPFS exchange interface

package offline implements an object that implements the exchange interface but returns nil values to every request.

Package pin implements structures and methods to keep track of which objects a user wants to keep stored locally.

Package dsindex provides secondary indexing functionality for a datastore.

Package dspinner implements structures and methods to keep track of which objects a user wants to keep stored locally.

Package ipldpinner implements structures and methods to keep track of which objects a user wants to keep stored locally.

Package pinconv converts pins between the dag-based ipldpinner and the datastore-based dspinner.

Package posinfo wraps offset information used by ipfs filestore nodes

Package pq implements a priority queue.

Package simple implements structures and methods to provide blocks, keep track of which blocks are provided, and to allow those blocks to be reprovided.

Package offline implements Routing with a client which is only able to perform offline operations.

Package util implements various utility functions used within ipfs that do not currently have a better place to live.

Package blockstoreutil provides utility functions for Blockstores.

Package core implements the IpfsNode object and related methods.

Package coreapi provides direct access to the core commands in IPFS.

package mount provides a simple abstraction around a mount point

Package namesys implements resolvers and publishers for the IPFS naming system (IPNS).

package fsrepo TODO explain the package roadmap...

Package log is the logging library used by IPFS (https://github.com/ipfs/go-ipfs).

Package log is the logging library used by IPFS & libp2p (https://github.com/ipfs/go-ipfs).

Package merkledag implements the IPFS Merkle DAG data structures.

Package path contains utilities to work with ipfs paths.

Package resolver implements utilities for resolving paths within ipfs.

Package unixfs implements a data format for files in the IPFS filesystem It is not the only format in ipfs, but it is the one that the filesystem assumes

Package hamt implements a Hash Array Mapped Trie over ipfs merkledag nodes.

Package balanced provides methods to build balanced DAGs, which are generalistic DAGs in which all leaves (nodes representing chunks of data) are at the same distance from the root.

Package trickle allows to build trickle DAGs.

Package io implements convenience objects for working with the ipfs unixfs data format.

Package mod provides DAG modification utilities to, for example, insert additional nodes in a unixfs DAG or truncate them.

Package iface defines IPFS Core API which is a set of interfaces used to interact with IPFS nodes.

go-ipld-prime is a series of go interfaces for manipulating IPLD data.

The fluent package offers helper utilities for using NodeAssembler more tersely by providing an interface that handles all errors for you, and allows use of closures for any recursive assembly so that creating trees of data results in indentation for legibility.

This package provides functional utilities for traversing and transforming IPLD nodes.

Package isdomain package allows users to check whether strings represent domain names.

Package temperrcatcher provides a TempErrCatcher object, which implements simple error-retrying functionality.

Package goprocess introduces a Process abstraction that allows simple organization, and orchestration of work.

Package periodic is part of github.com/jbenet/goprocess.

Package pool provides a sync.Pool equivalent that buckets incoming requests to one of 32 sub-pools, one for each power of 2, 0-32.

Package cidranger provides utility to store CIDR blocks and perform ip inclusion tests against it.

Package net provides utility functions for working with IPs (net.IP).

Package core provides convenient access to foundational, central go-libp2p primitives via type aliases.

Package connmgr provides connection tracking and management interfaces for libp2p.

Package crypto implements various cryptographic utilities used by libp2p.

Package discovery provides service advertisement and peer discovery interfaces for libp2p.

Package event contains the abstractions for a local event bus, along with the standard events that libp2p subsystems may emit.

Package host provides the core Host interface for libp2p.

Package introspection is EXPERIMENTAL.

Package introspection/pb contains the protobuf definitions and objects for that form the libp2p introspection protocol.

Package metrics provides metrics collection and reporting interfaces for libp2p.

Package mux provides stream multiplexing interfaces for libp2p.

Package network provides core networking abstractions for libp2p.

Package peer implements an object used to represent peers in the libp2p network.

Package peerstore provides types and interfaces for local storage of address information, metadata, and public key material about libp2p peers.

Package pnet provides interfaces for private networking in libp2p.

Package protocol provides core interfaces for protocol routing and negotiation in libp2p.

Package routing provides interfaces for peer routing and content routing in libp2p.

Package sec provides secure connection and transport interfaces for libp2p.

Package insecure provides an insecure, unencrypted implementation of the the SecureConn and SecureTransport interfaces.

Package transport provides the Transport interface, which represents the devices and network protocols used to send and receive data.

Deprecated: use github.com/libp2p/go-libp2p-core/crypto instead.

Package dht implements a distributed hash table that satisfies the ipfs routing interface.

Package dual provides an implementaiton of a split or "dual" dht, where two parallel instances are maintained for the global internet and the local LAN respectively.

package kbucket implements a kademlia 'k-bucket' routing table.

Package loggables includes a bunch of transaltor functions for commonplace/stdlib objects.

Deprecated: use github.com/libp2p/go-libp2p-core/peer instead.

Package addr provides utility functions to handle peer addresses.

The pubsub package provides facilities for the Publish/Subscribe pattern of message propagation, also known as overlay multicast.

Package secio is used to encrypt `go-libp2p-conn` connections.

The relay package contains the components necessary to implement the "autorelay" feature.

Adapted from gogo/protobuf to use multiformats/go-varint for efficient, interoperable length-prefixing.

Package nat implements NAT handling facilities

Originally found in https://github.com/google/gopacket/blob/master/routing/routing.go * Route selection modified to choose most selective route to break ties when route priority is insufficient.

Package openssl is a light wrapper around OpenSSL for Go.

Package reuseport provides Listen and Dial functions that set socket options in order to be able to reuse ports.

package sockaddrnet provides conversions between net.Addr and Sockaddr

package multistream implements a peerstream transport using go-multistream to select the underlying stream muxer

Package websocket implements a websocket based transport for go-libp2p.

Package logging defines a logging interface for quic-go.

package qtls partially implements TLS 1.2, as specified in RFC 5246, and TLS 1.3, as specified in RFC 8446.

Package dns implements a full featured interface to the Domain Name System.

Package blake2b implements BLAKE2b cryptographic hash function.

Package base32 implements base32 encoding as specified by RFC 4648.

Package base36 provides a reasonably fast implementation of a binary base36 codec.

Package multiaddr provides an implementation of the Multiaddr network address format.

Deprecated: use github.com/multiformats/go-multiaddr/net Deprecated: use github.com/multiformats/go-multiaddr/net

Package manet provides Multiaddr specific versions of common functions in stdlib's net package.

Package multihash is the Go implementation of https://github.com/multiformats/multihash, or self-describing hashes.

Package multistream implements a simple stream router for the multistream-select protocoli.

Package errors provides simple error handling primitives.

Refmt is a serialization and object-mapping library.

Package implementing the CBOR -- Concise Binary Object Notation -- http://cbor.io/ -- spec.

Package implementing the JSON -- http://json.org/ -- spec.

The `obj` package defines Marshaller and Unmarshaller types, which can be used to convert in-memory values to token streams, and token streams to unpack in-memory values.

Atlas types are used to define how to map Go values into refmt token streams.

The `shared` package defines helper types and functions used internally by all the other refmt packages; it is not user-facing.

Package containing Token struct and TokenType info.

Package spacelog is a collection of interface lego bricks designed to help you build a flexible logging system.

Package murmur3 implements Austin Appleby's non-cryptographic MurmurHash3.

Package leveldb provides implementation of LevelDB key/value database.

Package cache provides interface and implementation of a cache algorithms.

Package comparer provides interface and implementation for ordering sets of data.

Package errors provides common error types used throughout leveldb.

Package filter provides interface and implementation of probabilistic data structure.

Package iterator provides interface and implementation to traverse over contents of a database.

Package journal reads and writes sequences of journals.

Package memdb provides in-memory key/value database implementation.

Package opt provides sets of options used by LevelDB.

Package storage provides storage abstraction for LevelDB.

Package table allows read and write sorted key/value.

Package util provides utilities used throughout leveldb.

Package base32 implements base32 encoding as specified by RFC 4648.

Package chunker implements Content Defined Chunking (CDC) based on a rolling Rabin Checksum.