Compute SHA-512.

Compute SHA-256.

Compute RIPEMD-160.

Compute SHA1

Compute two rounds of SHA-256.

Computes a 32 bit checksum.

Computes HMAC over SHA-512.

Computes HMAC over SHA-256.

Split a Hash512 into a pair of Hash256.

Join a pair of Hash256 into a Hash512.

Data type representing a Bitcoin address

Transforms an Address into a base58 encoded String

Decodes an Address from a base58 encoded String. This function can fail if the String is not properly encoded as base58 or the checksum fails.

Encode a ByteString to a base 58 representation.

Decode a base58-encoded ByteString. This can fail if the input ByteString contains invalid base58 characters such as 0, O, l, I.

Computes a checksum for the input ByteString and encodes the input and the checksum to a base58 representation.

Decode a base58-encoded string that contains a checksum. This function returns Nothing if the input string contains invalid base58 characters or if the checksum fails.

Elliptic curve public key type. Two constructors are provided for creating compressed and uncompressed public keys from a Point. The use of compressed keys is preferred as it produces shorter keys without compromising security. Uncompressed keys are supported for backwards compatibility.

Derives a public key from a private key. This function will preserve information on key compression (PrvKey becomes PubKey and PrvKeyU becomes PubKeyU)

Computes an Address from a public key

Tweak a compressed public key

Elliptic curve private key type. Two constructors are provided for creating compressed or uncompressed private keys. Compression information is stored in private key WIF formats and needs to be preserved to generate the correct addresses from the corresponding public key.

Serialize private key as 32-byte big-endian ByteString

Deserialize private key as 32-byte big-endian ByteString

Decodes a private key from a WIF encoded ByteString. This function can fail if the input string does not decode correctly as a base 58 string or if the checksum fails. http://en.bitcoin.it/wiki/Wallet_import_format

Encodes a private key into WIF format

Tweak a private key

Data type representing an extended BIP32 public key.

Data type representing an extended BIP32 private key. An extended key is a node in a tree of key derivations. It has a depth in the tree, a parent node and an index to differentiate it from other siblings.

A derivation exception is thrown in the very unlikely event that a derivation is invalid.

Build a BIP32 compatible extended private key from a bytestring. This will produce a root node (depth=0 and parent=0).

Derive an extended public key from an extended private key. This function will preserve the depth, parent, index and chaincode fields of the extended private keys.

Compute a private, soft child key derivation. A private soft derivation will allow the equivalent extended public key to derive the public key for this child. Given a parent key m and a derivation index i, this function will compute m/i/.

Soft derivations allow for more flexibility such as read-only wallets. However, care must be taken not the leak both the parent extended public key and one of the extended child private keys as this would compromise the extended parent private key.

Compute a public, soft child key derivation. Given a parent key M and a derivation index i, this function will compute M/i/.

Compute a hard child key derivation. Hard derivations can only be computed for private keys. Hard derivations do not allow the parent public key to derive the child public keys. However, they are safer as a breach of the parent public key and child private keys does not lead to a breach of the parent private key. Given a parent key m and a derivation index i, this function will compute m/i'/.

Returns True if the extended private key was derived through a hard derivation.

Returns True if the extended public key was derived through a hard derivation.

Returns the derivation index of this extended private key without the hard bit set.

Returns the derivation index of this extended public key without the hard bit set.

Computes the key identifier of an extended public key.

Computes the key identifier of an extended private key.

Computes the key fingerprint of an extended public key.

Computes the key fingerprint of an extended private key.

Computer the Address of an extended public key.

Exports an extended public key to the BIP32 key export format (base 58).

Exports an extended private key to the BIP32 key export format (base 58).

Decodes a BIP32 encoded extended public key. This function will fail if invalid base 58 characters are detected or if the checksum fails.

Decodes a BIP32 encoded extended private key. This function will fail if invalid base 58 characters are detected or if the checksum fails.

Export an extended private key to WIF (Wallet Import Format).

Cyclic list of all private soft child key derivations of a parent key starting from an offset index.

Cyclic list of all public soft child key derivations of a parent key starting from an offset index.

Cyclic list of all hard child key derivations of a parent key starting from an offset index.

Derive an address from a public key and an index. The derivation type is a public, soft derivation.

Cyclic list of all addresses derived from a public key starting from an offset index. The derivation types are public, soft derivations.

Derive a multisig address from a list of public keys, the number of required signatures (m) and a derivation index. The derivation type is a public, soft derivation.

Cyclic list of all multisig addresses derived from a list of public keys, a number of required signatures (m) and starting from an offset index. The derivation type is a public, soft derivation.

Data type representing a derivation path. Two constructors are provided for specifying soft or hard derivations. The path 01'/2 for example can be expressed as Deriv : 0 :| 1 : 2. The HardOrGeneric and GenericOrSoft type classes are used to constrain the valid values for the phantom type t. If you mix hard (:|) and soft (:/) paths, the only valid type for t is Generic. Otherwise, t can be Hard if you only have hard derivation or Soft if you only have soft derivations.

Using this type is as easy as writing the required derivation like in these example: Deriv : 0 : 1 :/ 2 :: SoftPath Deriv :| 0 :| 1 :| 2 :: HardPath Deriv :| 0 : 1 : 2 :: DerivPath

Derive a private key from a derivation path

Derive a public key from a soft derivation path

Append two derivation paths together. The result will be a mixed derivation path.

Parse derivation path string for extended key. Forms: “m0'2”, “M23/4”.

Apply a parsed path to an extended key to derive the new key defined in the path. If the path starts with m/, a private key will be returned and if the path starts with M/, a public key will be returned. Private derivations on a public key, and public derivations with a hard segment, return an error value.

Derive an address from a given parent path.

Cyclic list of all addresses derived from a given parent path and starting from the given offset index.

Derive a multisig address from a given parent path. The number of required signatures (m in m of n) is also needed.

Cyclic list of all multisig addresses derived from a given parent path and starting from the given offset index. The number of required signatures (m in m of n) is also needed.

StateT monad stack tracking the internal state of HMAC DRBG pseudo random number generator using SHA-256. The SecretT monad is run with the withSource function by providing it a source of entropy.

Data type representing an ECDSA signature.

Run a SecretT monad by providing it a source of entropy. You can use getEntropy or provide your own entropy source function.

Get a specific number of bytes of cryptographically secure random data using the system-specific facilities.

Use RDRAND if available and XOR with '/dev/urandom' on *nix and CryptAPI when on Windows. In short, this entropy is considered cryptographically secure but not true entropy.

Sign a message

Verify an ECDSA signature

Produce a new PrvKey randomly from the SecretT monad.

Provide intial entropy as a ByteString of length multiple of 4 bytes. Output a mnemonic sentence.

Revert toMnemonic. Do not use this to generate seeds. Instead use mnemonicToSeed. This outputs the original entropy used to generate a mnemonic.

Get a 512-bit seed from a mnemonic sentence. Will calculate checksum. Passphrase can be used to protect the mnemonic. Use an empty string as passphrase if none is required.

Obtain Int bits from beginning of ByteString. Resulting ByteString will be smallest required to hold that many bits, padded with zeroes to the right.

Provides information on known nodes in the bitcoin network. An Addr type is sent inside a Message as a response to a GetAddr message.

Network address with a timestamp

Data type describing signed messages that can be sent between bitcoin nodes to display important notifications to end users about the health of the network.

The GetData type is used to retrieve information on a specific object (Block or Tx) identified by the objects hash. The payload of a GetData request is a list of InvVector which represent all the hashes for which a node wants to request information. The response to a GetBlock message wille be either a Block or a Tx message depending on the type of the object referenced by the hash. Usually, GetData messages are sent after a node receives an Inv message to obtain information on unknown object hashes.

Inv messages are used by nodes to advertise their knowledge of new objects by publishing a list of hashes. Inv messages can be sent unsolicited or in response to a GetBlocks message.

Invectory vectors represent hashes identifying objects such as a Block or a Tx. They are sent inside messages to notify other peers about new data or data they have requested.

Data type identifying the type of an inventory vector.

Data type describing a bitcoin network address. Addresses are stored in IPv6. IPv4 addresses are mapped to IPv6 using IPv4 mapped IPv6 addresses: http://en.wikipedia.org/wiki/IPv6#IPv4-mapped_IPv6_addresses. Sometimes, timestamps are sent together with the NetworkAddress such as in the Addr data type.

A NotFound message is returned as a response to a GetData message whe one of the requested objects could not be retrieved. This could happen, for example, if a tranasaction was requested and was not available in the memory pool of the receiving node.

A Ping message is sent to bitcoin peers to check if a TCP/IP connection is still valid.

A Pong message is sent as a response to a ping message.

The reject message is sent when messages are rejected by a peer.

Convenience function to build a Reject message

Data type representing a variable length integer. The VarInt type usually precedes an array or a string that can vary in length.

Data type for variable length strings. Variable length strings are serialized as a VarInt followed by a bytestring.

When a bitcoin node creates an outgoing connection to another node, the first message it will send is a Version message. The other node will similarly respond with it's own Version message.

A MessageCommand is included in a MessageHeader in order to identify the type of message present in the payload. This allows the message de-serialization code to know how to decode a particular message payload. Every valid Message constructor has a corresponding MessageCommand constructor.

The Message type is used to identify all the valid messages that can be sent between bitcoin peers. Only values of type Message will be accepted by other bitcoin peers as bitcoin protocol messages need to be correctly serialized with message headers. Serializing a Message value will include the MessageHeader with the correct checksum value automatically. No need to add the MessageHeader separately.

Data type representing the header of a Message. All messages sent between nodes contain a message header.

The bloom flags are used to tell the remote peer how to auto-update the provided bloom filter.

A bloom filter is a probabilistic data structure that SPV clients send to other peers to filter the set of transactions received from them. Bloom filters are probabilistic and have a false positive rate. Some transactions that pass the filter may not be relevant to the receiving peer. By controlling the false positive rate, SPV nodes can trade off bandwidth versus privacy.

Set a new bloom filter on the peer connection.

Add the given data element to the connections current filter without requiring a completely new one to be set.

Build a bloom filter that will provide the given false positive rate when the given number of elements have been inserted.

Insert arbitrary data into a bloom filter. Returns the new bloom filter containing the new data.

Tests if some arbitrary data matches the filter. This can be either because the data was inserted into the filter or because it is a false positive.

Tests if a given bloom filter is valid.

Returns True if the filter is empty (all bytes set to 0x00)

Returns True if the filter is full (all bytes set to 0xff)

Data type representing all of the operators allowed inside a Script.

Data type representing a transaction script. Scripts are defined as lists of script operators ScriptOp. Scripts are used to:

• Define the spending conditions in the output of a transaction
• Provide the spending signatures in the input of a transaction

Data type representing the type of an OP_PUSHDATA opcode.

Check whether opcode is only data.

Optimally encode data using one of the 4 types of data pushing opcodes

Data type describing standard transaction output scripts. Output scripts provide the conditions that must be fulfilled for someone to spend the output coins.

Data type describing standard transaction input scripts. Input scripts provide the signing data required to unlock the coins of the output they are trying to spend.

Computes a script address from a script output. This address can be used in a pay to script hash output.

Computes the recipient address of a script. This function fails if the script could not be decoded as a pay to public key hash or pay to script hash.

Computes the sender address of a script. This function fails if the script could not be decoded as a spend public key hash or script hash input.

Similar to encodeInput but encodes to a ByteString

Decodes a ScriptInput from a Script. This function fails if the script can not be parsed as a standard script input.

Similar to decodeInput but decodes from a ByteString

Computes a Script from a ScriptOutput. The Script is a list of ScriptOp can can be used to build a Tx.