forks/

Package sql provides a generic interface around SQL (or SQL-like) databases.

Package driver defines interfaces to be implemented by database drivers as used by package sql.

Package wmi provides a WQL interface for WMI on Windows.

The gosymbols command prints type information for package-level symbols.

Package areflect provides utilities to help with reflection.

json2test reformats 'go test -json' output as text as if the -json flag were not passed to go test.

The occlient tool is a client for the gRPC service for getting and setting the OpenConfig configuration and state of a network device.

The ocprometheus implements a Prometheus exporter for OpenConfig telemetry data.

The ocredis tool is a client for the OpenConfig gRPC interface that subscribes to state and pushes it to Redis, using Redis' support for hash maps and for publishing events that can be subscribed to.

The octsdb tool pushes OpenConfig telemetry to OpenTSDB.

test2influxdb writes results from 'go test -json' to an influxdb database.

Package dscp provides helper functions to apply DSCP / ECN / CoS flags to sockets.

Package lanz implements a LANZ client that will listen to notofications from LANZ streaming server and will decode them and send them as a protobuf over a channel to a receiver.

Package monitor provides an embedded HTTP server to expose metrics for monitoring

Package monotime provides a fast monotonic clock source.

Package netns provides a utility function that allows a user to perform actions in a different network namespace

Package client provides helper functions for OpenConfig CLI tools.

Package path contains methods for dealing with key.Paths.

Package value defines an interface for user-defined types with value semantics to implement in order to be compatible with the rest of the Arista Go infrastructure.

Package goes provides an API to access Elasticsearch.

Package memcache provides a client for the memcached cache server.

Package couchbase provides a smart client for go.

Package cbdatasource streams data from a Couchbase cluster.

Tool receives raw events from go-couchbase UPR client.

Package trace provides a ring buffer utility to trace events.

Package couchbaseutil offers some convenience functions for apps that use couchbase.

Package gomemcached is binary protocol packet formats and constants.

Package memcached provides a memcached binary protocol client.

Package mcdebug provides memcached client op statistics via expvar.

Package memcached provides useful functions for building your own memcached server.

Package mapset implements a simple and generic set collection.

Package dwarfbuilder provides a way to build DWARF sections with arbitrary contents.

Package frame contains data structures and related functions for parsing and searching through Dwarf .debug_frame data.

Package proc is a low-level package that provides methods to manipulate the process we are debugging.

Package terminal implements functions for responding to user input and dispatching to appropriate backend commands.

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

Package english provides utilities to generate more user-friendly English output.

Package ethereum defines interfaces for interacting with Ethereum.

Package accounts implements high level Ethereum account management.

Package abi implements the Ethereum ABI (Application Binary Interface).

Package bind generates Ethereum contract Go bindings.

Package keystore implements encrypted storage of secp256k1 private keys.

Package usbwallet implements support for USB hardware wallets.

Package trezor contains the wire protocol wrapper in Go.

bootnode runs a bootstrap node for the Ethereum Discovery Protocol.

signer is a utility that can be used so sign transactions and arbitrary data.

evm executes EVM code snippets.

faucet is a Ether faucet backed by a light client.

geth is the official command-line client for Ethereum.

p2psim provides a command-line client for a simulation HTTP API.

puppeth is a command to assemble and maintain private networks.

rlpdump is a pretty-printer for RLP data.

Package utils contains internal helper functions for go-ethereum commands.

Package common contains various helper functions.

Package bitutil implements fast bitwise operations.

Package compiler wraps the Solidity compiler executable (solc).

Package hexutil implements hex encoding with 0x prefix.

Package math provides integer math utilities.

Package mclock is a wrapper for a monotonic clock source

Package consensus implements different Ethereum consensus engines.

Package clique implements the proof-of-authority consensus engine.

Package ethash implements the ethash proof-of-work consensus engine.

Package chequebook package wraps the 'chequebook' Ethereum smart contract.

Package core implements the Ethereum consensus protocol.

Provides support for dealing with EVM assembly instructions (e.g., disassembling them).

Package bloombits implements bloom filtering on batches of data.

Package rawdb contains a collection of low level database accessors.

Package state provides a caching layer atop the Ethereum state trie.

Package types contains data types related to Ethereum consensus.

Package vm implements the Ethereum Virtual Machine.

Package runtime provides a basic execution model for executing EVM code.

Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.

Package bn256 implements a particular bilinear group at the 128-bit security level.

Package bn256 implements a particular bilinear group.

Package secp256k1 wraps the bitcoin secp256k1 C library.

Package eth implements the Ethereum protocol.

Package downloader contains the manual full chain synchronisation.

Package fetcher contains the block announcement based synchronisation.

Package filters implements an ethereum filtering system for block, transactions and log events.

Package tracers is a collection of JavaScript transaction tracers.

Package ethclient provides a client for the Ethereum RPC API.

Package ethstats implements the network stats reporting service.

Package event deals with subscriptions to real-time events.

Package graphql provides a GraphQL interface to Ethereum node data.

Package les implements the Light Ethereum Subprotocol.

Package flowcontrol implements a client side flow control mechanism Package flowcontrol implements a client side flow control mechanism

Package light implements on-demand retrieval capable state and chain objects for the Ethereum Light Client.

Package log15 provides an opinionated, simple toolkit for best-practice logging that is both human and machine readable.

Go port of Coda Hale's Metrics library <https://github.com/rcrowley/go-metrics> Coda Hale's original work: <https://github.com/codahale/metrics>

Hook go-metrics into expvar on any /debug/metrics request, load all vars from the registry into expvar, and execute regular expvar handler

Package miner implements Ethereum block creation and mining.

Package geth contains the simplified mobile APIs to go-ethereum.

Package node sets up multi-protocol Ethereum nodes.

Package p2p implements the Ethereum p2p network protocols.

Package discover implements the Node Discovery Protocol.

Package discv5 implements the RLPx v5 Topic Discovery Protocol.

Package enr implements Ethereum Node Records as defined in EIP-778.

Package nat provides access to common network port mapping protocols.

Package netutil contains extensions to the net package.

Package protocols is an extension to p2p.

Package simulations simulates p2p networks.

Package rlp implements the RLP serialization format.

Package rpc implements bi-directional JSON-RPC 2.0 on multiple transports.

Package deps contains the console JavaScript dependencies Go embedded.

A simple http server interface to Swarm

Package bmt provides a binary merkle tree implementation used for swarm chunk hash Package bmt is a simple nonconcurrent reference implementation for hashsize segment based Binary Merkle tree hash on arbitrary but fixed maximum chunksize This implementation does not take advantage of any paralellisms and uses far more memory than necessary, but it is easy to see that it is correct.

You can run this simulation using go run ./swarm/network/simulations/overlay.go

Package pot see doc.go Package pot (proximity order tree) implements a container similar to a binary tree.

Pss provides devp2p functionality for swarm nodes without the need for a direct tcp connection between them.

simple abstraction for implementing pss functionality the pss client library aims to simplify usage of the p2p.protocols package over pss IO is performed using the ordinary p2p.MsgReadWriter interface, which transparently communicates with a pss node via RPC using websockets as transport layer, using methods in the PssAPI class in the swarm/pss package Minimal-ish usage example (requires a running pss node with websocket RPC): import ( "context" "fmt" "os" pss "github.com/ie310mu/ie310go/forks/github.com/ethereum/go-ethereum/swarm/pss/client" "github.com/ie310mu/ie310go/forks/github.com/ethereum/go-ethereum/p2p/protocols" "github.com/ie310mu/ie310go/forks/github.com/ethereum/go-ethereum/p2p" "github.com/ie310mu/ie310go/forks/github.com/ethereum/go-ethereum/swarm/pot" "github.com/ie310mu/ie310go/forks/github.com/ethereum/go-ethereum/swarm/log" ) type FooMsg struct { Bar int } func fooHandler (msg interface{}) error { foomsg, ok := msg.(*FooMsg) if ok { log.Debug("Yay, just got a message", "msg", foomsg) } return errors.New(fmt.Sprintf("Unknown message")) } spec := &protocols.Spec{ Name: "foo", Version: 1, MaxMsgSize: 1024, Messages: []interface{}{ FooMsg{}, }, } proto := &p2p.Protocol{ Name: spec.Name, Version: spec.Version, Length: uint64(len(spec.Messages)), Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error { pp := protocols.NewPeer(p, rw, spec) return pp.Run(fooHandler) }, } func implementation() { cfg := pss.NewClientConfig() psc := pss.NewClient(context.Background(), nil, cfg) err := psc.Start() if err != nil { log.Crit("can't start pss client") os.Exit(1) } log.Debug("connected to pss node", "bzz addr", psc.BaseAddr) err = psc.RunProtocol(proto) if err != nil { log.Crit("can't start protocol on pss websocket") os.Exit(1) } addr := pot.RandomAddress() // should be a real address, of course psc.AddPssPeer(addr, spec) // use the protocol for something psc.Stop() } BUG(test): TestIncoming test times out due to deadlock issues in the swarm hive

Package shed provides a simple abstraction components to compose more complex operations on storage data organized in fields and indexes.

Package feeds defines Swarm Feeds.

Package lookup defines feed lookup algorithms and provides tools to place updates so they can be found

Package localstore provides disk storage layer for Swarm Chunk persistence.

Package mock defines types that are used by different implementations of mock storages.

Package db implements a mock store that keeps all chunk data in LevelDB database.

Package mem implements a mock store that keeps all chunk data in memory.

Package rpc implements an RPC client that connect to a centralized mock store.

Package test provides functions that are used for testing GlobalStorer implementations.

Package tests implements execution of Ethereum JSON tests.

Package trie implements Merkle Patricia Tries.

Package mailserver provides a naive, example mailserver implementation

Package whisperv5 implements the Whisper protocol (version 5).

Package fsnotify provides a platform-independent interface for file system notifications.

Package redis implements a Redis client.

Package mysql provides a MySQL driver for Go's database/sql package.

Package acme provides an implementation of the Automatic Certificate Management Environment (ACME) spec.

Package autocert provides automatic access to certificates from Let's Encrypt and any other ACME-based CA.

Package argon2 implements the key derivation function Argon2.

Package bcrypt implements Provos and Mazières's bcrypt adaptive hashing algorithm.

Package blake2b implements the BLAKE2b hash algorithm defined by RFC 7693 and the extendable output function (XOF) BLAKE2Xb.

Package blake2s implements the BLAKE2s hash algorithm defined by RFC 7693 and the extendable output function (XOF) BLAKE2Xs.

Package blowfish implements Bruce Schneier's Blowfish encryption algorithm.

Package bn256 implements a particular bilinear group.

Package cast5 implements CAST5, as defined in RFC 2144.

Package chacha20poly1305 implements the ChaCha20-Poly1305 AEAD as specified in RFC 7539, and its extended nonce variant XChaCha20-Poly1305.

Package cryptobyte contains types that help with parsing and constructing length-prefixed, binary messages, including ASN.1 DER.

Package asn1 contains supporting types for parsing and building ASN.1 messages with the cryptobyte package.

Package curve25519 provides an implementation of scalar multiplication on the elliptic curve known as curve25519.

Package ed25519 implements the Ed25519 signature algorithm.

Package hkdf implements the HMAC-based Extract-and-Expand Key Derivation Function (HKDF) as defined in RFC 5869.

Package md4 implements the MD4 hash algorithm as defined in RFC 1320.

Package auth authenticates a message using a secret key.

Package box authenticates and encrypts small messages using public-key cryptography.

Package secretbox encrypts and authenticates small messages.

Package sign signs small messages using public-key cryptography.

Package ocsp parses OCSP responses as specified in RFC 2560.

Package openpgp implements high level operations on OpenPGP messages.

Package armor implements OpenPGP ASCII Armor, see RFC 4880.

Package clearsign generates and processes OpenPGP, clear-signed data.

Package elgamal implements ElGamal encryption, suitable for OpenPGP, as specified in "A Public-Key Cryptosystem and a Signature Scheme Based on Discrete Logarithms," IEEE Transactions on Information Theory, v.

Package errors contains common error types for the OpenPGP packages.

Package packet implements parsing and serialization of OpenPGP packets, as specified in RFC 4880.

Package s2k implements the various OpenPGP string-to-key transforms as specified in RFC 4800 section 3.7.1.

Package otr implements the Off The Record protocol as specified in http://www.cypherpunks.ca/otr/Protocol-v2-3.1.0.html

Package pbkdf2 implements the key derivation function PBKDF2 as defined in RFC 2898 / PKCS #5 v2.0.

Package pkcs12 implements some of PKCS#12.

Package poly1305 implements Poly1305 one-time message authentication code as specified in https://cr.yp.to/mac/poly1305-20050329.pdf.

Package ripemd160 implements the RIPEMD-160 hash algorithm.

Package salsa20 implements the Salsa20 stream cipher as specified in https://cr.yp.to/snuffle/spec.pdf.

Package salsa provides low-level access to functions in the Salsa family.

Package scrypt implements the scrypt key derivation function as defined in Colin Percival's paper "Stronger Key Derivation via Sequential Memory-Hard Functions" (https://www.tarsnap.com/scrypt/scrypt.pdf).

Package sha3 implements the SHA-3 fixed-output-length hash functions and the SHAKE variable-output-length hash functions defined by FIPS-202.

Package ssh implements an SSH client and server.

Package agent implements the ssh-agent protocol, and provides both a client and a server.

Package knownhosts implements a parser for the OpenSSH known_hosts host key database, and provides utility functions for writing OpenSSH compliant known_hosts files.

Package terminal provides support functions for dealing with terminals, as commonly found on UNIX systems.

Package test contains integration tests for the golang.org/x/crypto/ssh package.

Package tea implements the TEA algorithm, as defined in Needham and Wheeler's 1994 technical report, “TEA, a Tiny Encryption Algorithm”.

Package twofish implements Bruce Schneier's Twofish encryption algorithm.

Package xtea implements XTEA encryption, as defined in Needham and Wheeler's 1997 technical report, "Tea extensions."

Package xts implements the XTS cipher mode as specified in IEEE P1619/D16.

Package redis is a client for the Redis database.

Package redisx contains experimental features for Redigo.

Package sqlx provides general purpose extensions to database/sql.

Package reflectx implements extensions to the standard reflect lib suitable for implementing marshalling and unmarshalling packages.

Package liner implements a simple command line editor, inspired by linenoise (https://github.com/antirez/linenoise/).

Package errors provides simple error handling primitives.

Godef prints the source location of definitions in Go programs.

Package ast declares the types used to represent syntax trees for Go packages.

A parser for Go source files.

Package printer implements printing of AST nodes.

Package scanner implements a scanner for Go source text.

The sym package provides a way to iterate over and change the symbols in Go source files.

This package defines constants representing the lexical tokens of the Go programming language and basic operations on tokens (printing, predicates).

Types infers source locations and types from Go expressions.

Package uuid provides implementation of Universally Unique Identifier (UUID).

Package ansicolor provides color console in Windows as ANSICON.

The ansicolor command colors a console text by ANSI escape sequence like wac.

This file was generated by .tools/generate_commands.py on Sat Oct 28 2017 18:15:49 -0500

Package ledis is a high performance embedded NoSQL.

Package server supplies a way to use ledis as service.

Package returns implements a Go pretty-printer (like package "go/format") that also adds zero-value return values as necessary to incomplete return statements.

Package gopkgs is a utility to get list of golang packages.

package bbolt implements a low-level key/value store in pure Go.