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

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

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.

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.

Produce a new PrvKey randomly from the SecretT monad.

Data type representing an ECDSA signature.

Sign a message

Verify an ECDSA signature

Computes a 32 bit checksum.

Compute SHA-512.

Compute SHA-256.

Compute RIPEMD-160.

Compute SHA1

Compute two rounds of SHA-256.

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

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.

Transforms an Address into a base58 encoded String

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.

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

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.

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.

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

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

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

Computes the key identifier of an extended private key.

Computes the key fingerprint of an extended private key.

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

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).

Data type representing an extended BIP32 public key.

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.

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

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 fingerprint of an extended public key.

Computer the Address of an extended public key.

Exports an extended public 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.

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'/.

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.