Network.Haskoin.Crypto

This package provides the elliptic curve cryptography required for creating and validating bitcoin transactions. It also provides SHA-256 and RIPEMD-160 hashing functions; as well as mnemonic keys from BIP-0039.

Elliptic Curve Keys

Public Keys

type PubKey = PubKeyI Generic

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.

type PubKeyC = PubKeyI Compressed

type PubKeyU = PubKeyI Uncompressed

makePubKey :: PubKey -> PubKey

makePubKeyG :: Bool -> PubKey -> PubKey

makePubKeyC :: PubKey -> PubKeyC

makePubKeyU :: PubKey -> PubKeyU

toPubKeyG :: PubKeyI c -> PubKey

eitherPubKey :: PubKeyI c -> Either PubKeyU PubKeyC

maybePubKeyC :: PubKeyI c -> Maybe PubKeyC

maybePubKeyU :: PubKeyI c -> Maybe PubKeyU

derivePubKey :: PrvKeyI c -> PubKeyI c

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

pubKeyAddr :: Serialize (PubKeyI c) => PubKeyI c -> Address

Computes an Address from a public key

tweakPubKeyC :: PubKeyC -> Hash256 -> Maybe PubKeyC

Tweak a compressed public key

Private Keys

type PrvKey = PrvKeyI Generic

type PrvKeyC = PrvKeyI Compressed

type PrvKeyU = PrvKeyI Uncompressed

makePrvKey :: SecKey -> PrvKey

makePrvKeyG :: Bool -> SecKey -> PrvKey

makePrvKeyC :: SecKey -> PrvKeyC

makePrvKeyU :: SecKey -> PrvKeyU

toPrvKeyG :: PrvKeyI c -> PrvKey

eitherPrvKey :: PrvKeyI c -> Either PrvKeyU PrvKeyC

maybePrvKeyC :: PrvKeyI c -> Maybe PrvKeyC

maybePrvKeyU :: PrvKeyI c -> Maybe PrvKeyU

encodePrvKey :: PrvKeyI c -> ByteString

Serialize private key as 32-byte big-endian ByteString

decodePrvKey :: (SecKey -> PrvKeyI c) -> ByteString -> Maybe (PrvKeyI c)

Deserialize private key as 32-byte big-endian ByteString

prvKeyPutMonad :: PrvKeyI c -> Put

prvKeyGetMonad :: (SecKey -> PrvKeyI c) -> Get (PrvKeyI c)

fromWif :: ByteString -> Maybe PrvKey

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

toWif :: PrvKeyI c -> ByteString

Encodes a private key into WIF format

tweakPrvKeyC :: PrvKeyC -> Hash256 -> Maybe PrvKeyC

Tweak a private key

ECDSA

SecretT Monad

The SecretT monad is a monadic wrapper around HMAC DRBG (deterministic random byte generator) using SHA-256. The specification is defined in http://csrc.nist.gov/publications/nistpubs/800-90A/SP800-90A.pdf. The SecretT monad is used to generate random private keys.

type SecretT m = StateT (SecretState m) m

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.

withSource :: Monad m => (Int -> m ByteString) -> SecretT m a -> m a

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

getEntropy :: Int -> IO ByteString

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.

genPrvKey :: Monad m => SecretT m PrvKey

Produce a new PrvKey randomly from the SecretT monad.

Signatures

Elliptic curve cryptography standards are defined in http://www.secg.org/sec1-v2.pdf

data Signature

Data type representing an ECDSA signature.

Instances

Eq Signature

Methods

(==) :: Signature -> Signature -> Bool

(/=) :: Signature -> Signature -> Bool

Read Signature

Methods

readsPrec :: Int -> ReadS Signature

readList :: ReadS [Signature]

readPrec :: ReadPrec Signature

readListPrec :: ReadPrec [Signature]

Show Signature

Methods

showsPrec :: Int -> Signature -> ShowS

show :: Signature -> String

showList :: [Signature] -> ShowS

Serialize Signature

Methods

put :: Putter Signature

get :: Get Signature

NFData Signature

Methods

rnf :: Signature -> ()

signMsg :: Hash256 -> PrvKeyI c -> Signature

Sign a message

verifySig :: Hash256 -> Signature -> PubKeyI c -> Bool

Verify an ECDSA signature

isCanonicalHalfOrder :: Signature -> Bool

decodeDerSig :: ByteString -> Maybe Signature

decodeStrictSig :: ByteString -> Maybe Signature

Hash functions

data CheckSum32

Instances

Eq CheckSum32

Methods

(==) :: CheckSum32 -> CheckSum32 -> Bool

(/=) :: CheckSum32 -> CheckSum32 -> Bool

Ord CheckSum32

Methods

compare :: CheckSum32 -> CheckSum32 -> Ordering

(<) :: CheckSum32 -> CheckSum32 -> Bool

(<=) :: CheckSum32 -> CheckSum32 -> Bool

(>) :: CheckSum32 -> CheckSum32 -> Bool

(>=) :: CheckSum32 -> CheckSum32 -> Bool

max :: CheckSum32 -> CheckSum32 -> CheckSum32

min :: CheckSum32 -> CheckSum32 -> CheckSum32

Read CheckSum32

Methods

readsPrec :: Int -> ReadS CheckSum32

readList :: ReadS [CheckSum32]

readPrec :: ReadPrec CheckSum32

readListPrec :: ReadPrec [CheckSum32]

Show CheckSum32

Methods

showsPrec :: Int -> CheckSum32 -> ShowS

show :: CheckSum32 -> String

showList :: [CheckSum32] -> ShowS

IsString CheckSum32

Methods

fromString :: String -> CheckSum32

Serialize CheckSum32

Methods

put :: Putter CheckSum32

get :: Get CheckSum32

NFData CheckSum32

Methods

rnf :: CheckSum32 -> ()

data Hash512

Instances

Eq Hash512

Methods

(==) :: Hash512 -> Hash512 -> Bool

(/=) :: Hash512 -> Hash512 -> Bool

Ord Hash512

Methods

compare :: Hash512 -> Hash512 -> Ordering

(<) :: Hash512 -> Hash512 -> Bool

(<=) :: Hash512 -> Hash512 -> Bool

(>) :: Hash512 -> Hash512 -> Bool

(>=) :: Hash512 -> Hash512 -> Bool

max :: Hash512 -> Hash512 -> Hash512

min :: Hash512 -> Hash512 -> Hash512

Read Hash512

Methods

readsPrec :: Int -> ReadS Hash512

readList :: ReadS [Hash512]

readPrec :: ReadPrec Hash512

readListPrec :: ReadPrec [Hash512]

Show Hash512

Methods

showsPrec :: Int -> Hash512 -> ShowS

show :: Hash512 -> String

showList :: [Hash512] -> ShowS

IsString Hash512

Methods

fromString :: String -> Hash512

Serialize Hash512

Methods

put :: Putter Hash512

get :: Get Hash512

NFData Hash512

Methods

rnf :: Hash512 -> ()

data Hash256

Instances

Eq Hash256

Methods

(==) :: Hash256 -> Hash256 -> Bool

(/=) :: Hash256 -> Hash256 -> Bool

Ord Hash256

Methods

compare :: Hash256 -> Hash256 -> Ordering

(<) :: Hash256 -> Hash256 -> Bool

(<=) :: Hash256 -> Hash256 -> Bool

(>) :: Hash256 -> Hash256 -> Bool

(>=) :: Hash256 -> Hash256 -> Bool

max :: Hash256 -> Hash256 -> Hash256

min :: Hash256 -> Hash256 -> Hash256

Read Hash256

Methods

readsPrec :: Int -> ReadS Hash256

readList :: ReadS [Hash256]

readPrec :: ReadPrec Hash256

readListPrec :: ReadPrec [Hash256]

Show Hash256

Methods

showsPrec :: Int -> Hash256 -> ShowS

show :: Hash256 -> String

showList :: [Hash256] -> ShowS

IsString Hash256

Methods

fromString :: String -> Hash256

Serialize Hash256

Methods

put :: Putter Hash256

get :: Get Hash256

NFData Hash256

Methods

rnf :: Hash256 -> ()

data Hash160

Instances

Eq Hash160

Methods

(==) :: Hash160 -> Hash160 -> Bool

(/=) :: Hash160 -> Hash160 -> Bool

Ord Hash160

Methods

compare :: Hash160 -> Hash160 -> Ordering

(<) :: Hash160 -> Hash160 -> Bool

(<=) :: Hash160 -> Hash160 -> Bool

(>) :: Hash160 -> Hash160 -> Bool

(>=) :: Hash160 -> Hash160 -> Bool

max :: Hash160 -> Hash160 -> Hash160

min :: Hash160 -> Hash160 -> Hash160

Read Hash160

Methods

readsPrec :: Int -> ReadS Hash160

readList :: ReadS [Hash160]

readPrec :: ReadPrec Hash160

readListPrec :: ReadPrec [Hash160]

Show Hash160

Methods

showsPrec :: Int -> Hash160 -> ShowS

show :: Hash160 -> String

showList :: [Hash160] -> ShowS

IsString Hash160

Methods

fromString :: String -> Hash160

Serialize Hash160

Methods

put :: Putter Hash160

get :: Get Hash160

NFData Hash160

Methods

rnf :: Hash160 -> ()

bsToCheckSum32 :: ByteString -> Maybe CheckSum32

bsToHash512 :: ByteString -> Maybe Hash512

bsToHash256 :: ByteString -> Maybe Hash256

bsToHash160 :: ByteString -> Maybe Hash160

checkSum32 :: ByteString -> CheckSum32

Computes a 32 bit checksum.

hash512 :: ByteString -> Hash512

Compute SHA-512.

hash256 :: ByteString -> Hash256

Compute SHA-256.

hash160 :: ByteString -> Hash160

Compute RIPEMD-160.

sha1 :: ByteString -> Hash160

Compute SHA1

doubleHash256 :: ByteString -> Hash256

Compute two rounds of SHA-256.

hmac512 :: ByteString -> ByteString -> Hash512

Computes HMAC over SHA-512.

hmac256 :: ByteString -> ByteString -> Hash256

Computes HMAC over SHA-256.

split512 :: Hash512 -> (Hash256, Hash256)

Split a Hash512 into a pair of Hash256.

join512 :: (Hash256, Hash256) -> Hash512

Join a pair of Hash256 into a Hash512.

Base58 and Addresses

data Address

Data type representing a Bitcoin address

Constructors

PubKeyAddress

Public Key Hash Address

Fields

• getAddrHash :: !Hash160

ScriptAddress

Script Hash Address

Fields

• getAddrHash :: !Hash160

Instances

Eq Address

Methods

(==) :: Address -> Address -> Bool

(/=) :: Address -> Address -> Bool

Ord Address

Methods

compare :: Address -> Address -> Ordering

(<) :: Address -> Address -> Bool

(<=) :: Address -> Address -> Bool

(>) :: Address -> Address -> Bool

(>=) :: Address -> Address -> Bool

max :: Address -> Address -> Address

min :: Address -> Address -> Address

Read Address

Methods

readsPrec :: Int -> ReadS Address

readList :: ReadS [Address]

readPrec :: ReadPrec Address

readListPrec :: ReadPrec [Address]

Show Address

Methods

showsPrec :: Int -> Address -> ShowS

show :: Address -> String

showList :: [Address] -> ShowS

IsString Address

Methods

fromString :: String -> Address

ToJSON Address

Methods

toJSON :: Address -> Value

toEncoding :: Address -> Encoding

toJSONList :: [Address] -> Value

toEncodingList :: [Address] -> Encoding

FromJSON Address

Methods

parseJSON :: Value -> Parser Address

parseJSONList :: Value -> Parser [Address]

Serialize Address

Methods

put :: Putter Address

get :: Get Address

NFData Address

Methods

rnf :: Address -> ()

base58ToAddr :: ByteString -> Maybe 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.

addrToBase58 :: Address -> ByteString

Transforms an Address into a base58 encoded String

encodeBase58 :: ByteString -> ByteString

Encode a ByteString to a base 58 representation.

decodeBase58 :: ByteString -> Maybe ByteString

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

encodeBase58Check :: ByteString -> ByteString

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

decodeBase58Check :: ByteString -> Maybe ByteString

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.

Mnemonic keys (BIP-0039)

type Entropy = ByteString

type Mnemonic = ByteString

type Passphrase = ByteString

type Seed = ByteString

toMnemonic :: Entropy -> Either String Mnemonic

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

mnemonicToSeed :: Passphrase -> Mnemonic -> Either String Seed

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.

Extended Keys

type KeyIndex = Word32

type ChainCode = Hash256

Extended Private Keys

data XPrvKey

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.

Constructors

XPrvKey

Fields

• xPrvDepth :: !Word8

  Depth in the tree of key derivations.

• xPrvParent :: !Word32

  Fingerprint of the parent key.

• xPrvIndex :: !KeyIndex

  Key derivation index.

• xPrvChain :: !ChainCode

  Chain code.

• xPrvKey :: !PrvKeyC

  The private key of this extended key node.

Instances

Eq XPrvKey

Methods

(==) :: XPrvKey -> XPrvKey -> Bool

(/=) :: XPrvKey -> XPrvKey -> Bool

Ord XPrvKey

Methods

compare :: XPrvKey -> XPrvKey -> Ordering

(<) :: XPrvKey -> XPrvKey -> Bool

(<=) :: XPrvKey -> XPrvKey -> Bool

(>) :: XPrvKey -> XPrvKey -> Bool

(>=) :: XPrvKey -> XPrvKey -> Bool

max :: XPrvKey -> XPrvKey -> XPrvKey

min :: XPrvKey -> XPrvKey -> XPrvKey

Read XPrvKey

Methods

readsPrec :: Int -> ReadS XPrvKey

readList :: ReadS [XPrvKey]

readPrec :: ReadPrec XPrvKey

readListPrec :: ReadPrec [XPrvKey]

Show XPrvKey

Methods

showsPrec :: Int -> XPrvKey -> ShowS

show :: XPrvKey -> String

showList :: [XPrvKey] -> ShowS

IsString XPrvKey

Methods

fromString :: String -> XPrvKey

ToJSON XPrvKey

Methods

toJSON :: XPrvKey -> Value

toEncoding :: XPrvKey -> Encoding

toJSONList :: [XPrvKey] -> Value

toEncodingList :: [XPrvKey] -> Encoding

FromJSON XPrvKey

Methods

parseJSON :: Value -> Parser XPrvKey

parseJSONList :: Value -> Parser [XPrvKey]

Serialize XPrvKey

Methods

put :: Putter XPrvKey

get :: Get XPrvKey

NFData XPrvKey

Methods

rnf :: XPrvKey -> ()

makeXPrvKey :: ByteString -> XPrvKey

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

xPrvIsHard :: XPrvKey -> Bool

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

xPrvChild :: XPrvKey -> KeyIndex

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

xPrvID :: XPrvKey -> Hash160

Computes the key identifier of an extended private key.

xPrvFP :: XPrvKey -> Word32

Computes the key fingerprint of an extended private key.

xPrvExport :: XPrvKey -> ByteString

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

xPrvImport :: ByteString -> Maybe XPrvKey

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

xPrvWif :: XPrvKey -> ByteString

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

Extended Public Keys

data XPubKey

Data type representing an extended BIP32 public key.

Constructors

XPubKey

Fields

• xPubDepth :: !Word8

  Depth in the tree of key derivations.

• xPubParent :: !Word32

  Fingerprint of the parent key.

• xPubIndex :: !KeyIndex

  Key derivation index.

• xPubChain :: !ChainCode

  Chain code.

• xPubKey :: !PubKeyC

  The public key of this extended key node.

Instances

Eq XPubKey

Methods

(==) :: XPubKey -> XPubKey -> Bool

(/=) :: XPubKey -> XPubKey -> Bool

Ord XPubKey

Methods

compare :: XPubKey -> XPubKey -> Ordering

(<) :: XPubKey -> XPubKey -> Bool

(<=) :: XPubKey -> XPubKey -> Bool

(>) :: XPubKey -> XPubKey -> Bool

(>=) :: XPubKey -> XPubKey -> Bool

max :: XPubKey -> XPubKey -> XPubKey

min :: XPubKey -> XPubKey -> XPubKey

Read XPubKey

Methods

readsPrec :: Int -> ReadS XPubKey

readList :: ReadS [XPubKey]

readPrec :: ReadPrec XPubKey

readListPrec :: ReadPrec [XPubKey]

Show XPubKey

Methods

showsPrec :: Int -> XPubKey -> ShowS

show :: XPubKey -> String

showList :: [XPubKey] -> ShowS

IsString XPubKey

Methods

fromString :: String -> XPubKey

ToJSON XPubKey

Methods

toJSON :: XPubKey -> Value

toEncoding :: XPubKey -> Encoding

toJSONList :: [XPubKey] -> Value

toEncodingList :: [XPubKey] -> Encoding

FromJSON XPubKey

Methods

parseJSON :: Value -> Parser XPubKey

parseJSONList :: Value -> Parser [XPubKey]

Serialize XPubKey

Methods

put :: Putter XPubKey

get :: Get XPubKey

NFData XPubKey

Methods

rnf :: XPubKey -> ()

deriveXPubKey :: XPrvKey -> XPubKey

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.

xPubIsHard :: XPubKey -> Bool

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

xPubChild :: XPubKey -> KeyIndex

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

xPubID :: XPubKey -> Hash160

Computes the key identifier of an extended public key.

xPubFP :: XPubKey -> Word32

Computes the key fingerprint of an extended public key.

xPubAddr :: XPubKey -> Address

Computer the Address of an extended public key.

xPubExport :: XPubKey -> ByteString

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

xPubImport :: ByteString -> Maybe XPubKey

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

Child key derivations

prvSubKey

Arguments

:: XPrvKey

Extended parent private key

-> KeyIndex

Child derivation index

-> XPrvKey

Extended child private key

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.

pubSubKey

Arguments

:: XPubKey

Extended Parent public key

-> KeyIndex

Child derivation index

-> XPubKey

Extended child public key

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

hardSubKey

Arguments

:: XPrvKey

Extended Parent private key

-> KeyIndex

Child derivation index

-> XPrvKey

Extended child private key

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

prvSubKeys :: XPrvKey -> KeyIndex -> [(XPrvKey, KeyIndex)]

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

pubSubKeys :: XPubKey -> KeyIndex -> [(XPubKey, KeyIndex)]

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

hardSubKeys :: XPrvKey -> KeyIndex -> [(XPrvKey, KeyIndex)]

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

Address derivations

deriveAddr :: XPubKey -> KeyIndex -> (Address, PubKeyC)

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

deriveAddrs :: XPubKey -> KeyIndex -> [(Address, PubKeyC, KeyIndex)]

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

deriveMSAddr :: [XPubKey] -> Int -> KeyIndex -> (Address, RedeemScript)

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.

deriveMSAddrs :: [XPubKey] -> Int -> KeyIndex -> [(Address, RedeemScript, KeyIndex)]

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.

Derivation paths

data DerivPathI t where

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

Constructors

(:|) :: HardOrGeneric t => !(DerivPathI t) -> !KeyIndex -> DerivPathI t

(:/) :: GenericOrSoft t => !(DerivPathI t) -> !KeyIndex -> DerivPathI t

Deriv :: DerivPathI t

Instances

Read SoftPath

Methods

readsPrec :: Int -> ReadS SoftPath

readList :: ReadS [SoftPath]

readPrec :: ReadPrec SoftPath

readListPrec :: ReadPrec [SoftPath]

Read DerivPath

Methods

readsPrec :: Int -> ReadS DerivPath

readList :: ReadS [DerivPath]

readPrec :: ReadPrec DerivPath

readListPrec :: ReadPrec [DerivPath]

Read HardPath

Methods

readsPrec :: Int -> ReadS HardPath

readList :: ReadS [HardPath]

readPrec :: ReadPrec HardPath

readListPrec :: ReadPrec [HardPath]

Show SoftPath

Methods

showsPrec :: Int -> SoftPath -> ShowS

show :: SoftPath -> String

showList :: [SoftPath] -> ShowS

Show DerivPath

Methods

showsPrec :: Int -> DerivPath -> ShowS

show :: DerivPath -> String

showList :: [DerivPath] -> ShowS

Show HardPath

Methods

showsPrec :: Int -> HardPath -> ShowS

show :: HardPath -> String

showList :: [HardPath] -> ShowS

IsString SoftPath

Methods

fromString :: String -> SoftPath

IsString DerivPath

Methods

fromString :: String -> DerivPath

IsString HardPath

Methods

fromString :: String -> HardPath

FromJSON SoftPath

Methods

parseJSON :: Value -> Parser SoftPath

parseJSONList :: Value -> Parser [SoftPath]

FromJSON DerivPath

Methods

parseJSON :: Value -> Parser DerivPath

parseJSONList :: Value -> Parser [DerivPath]

FromJSON HardPath

Methods

parseJSON :: Value -> Parser HardPath

parseJSONList :: Value -> Parser [HardPath]

Eq (DerivPathI t)

Methods

(==) :: DerivPathI t -> DerivPathI t -> Bool

(/=) :: DerivPathI t -> DerivPathI t -> Bool

ToJSON (DerivPathI t)

Methods

toJSON :: DerivPathI t -> Value

toEncoding :: DerivPathI t -> Encoding

toJSONList :: [DerivPathI t] -> Value

toEncodingList :: [DerivPathI t] -> Encoding

NFData (DerivPathI t)

Methods

rnf :: DerivPathI t -> ()

type DerivPath = DerivPathI Generic

type HardPath = DerivPathI Hard

type SoftPath = DerivPathI Soft

derivePath :: DerivPathI t -> XPrvKey -> XPrvKey

Derive a private key from a derivation path

derivePubPath :: SoftPath -> XPubKey -> XPubKey

Derive a public key from a soft derivation path

toHard :: DerivPathI t -> Maybe HardPath

toSoft :: DerivPathI t -> Maybe SoftPath

toGeneric :: DerivPathI t -> DerivPath

(++/) :: DerivPathI t1 -> DerivPathI t2 -> DerivPath

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

pathToStr :: DerivPathI t -> String

Derivation path parsing

data XKey

Constructors

XPrv

Fields

• getXPrvKey :: !XPrvKey

XPub

Fields

• getXPubKey :: !XPubKey

Instances

Eq XKey

Methods

(==) :: XKey -> XKey -> Bool

(/=) :: XKey -> XKey -> Bool

Show XKey

Methods

showsPrec :: Int -> XKey -> ShowS

show :: XKey -> String

showList :: [XKey] -> ShowS

data ParsedPath

Constructors

ParsedPrv

Fields

• getParsedPath :: !DerivPath

ParsedPub

Fields

• getParsedPath :: !DerivPath

ParsedEmpty

Fields

• getParsedPath :: !DerivPath

Instances

Eq ParsedPath

Methods

(==) :: ParsedPath -> ParsedPath -> Bool

(/=) :: ParsedPath -> ParsedPath -> Bool

Read ParsedPath

Methods

readsPrec :: Int -> ReadS ParsedPath

readList :: ReadS [ParsedPath]

readPrec :: ReadPrec ParsedPath

readListPrec :: ReadPrec [ParsedPath]

Show ParsedPath

Methods

showsPrec :: Int -> ParsedPath -> ShowS

show :: ParsedPath -> String

showList :: [ParsedPath] -> ShowS

IsString ParsedPath

Methods

fromString :: String -> ParsedPath

ToJSON ParsedPath

Methods

toJSON :: ParsedPath -> Value

toEncoding :: ParsedPath -> Encoding

toJSONList :: [ParsedPath] -> Value

toEncodingList :: [ParsedPath] -> Encoding

FromJSON ParsedPath

Methods

parseJSON :: Value -> Parser ParsedPath

parseJSONList :: Value -> Parser [ParsedPath]

parsePath :: String -> Maybe ParsedPath

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

parseHard :: String -> Maybe HardPath

parseSoft :: String -> Maybe SoftPath

applyPath :: ParsedPath -> XKey -> Either String XKey

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.

Custom path address derivations

derivePathAddr :: XPubKey -> SoftPath -> KeyIndex -> (Address, PubKeyC)

Derive an address from a given parent path.

derivePathAddrs :: XPubKey -> SoftPath -> KeyIndex -> [(Address, PubKeyC, KeyIndex)]

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

derivePathMSAddr :: [XPubKey] -> SoftPath -> Int -> KeyIndex -> (Address, RedeemScript)

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

derivePathMSAddrs :: [XPubKey] -> SoftPath -> Int -> KeyIndex -> [(Address, RedeemScript, KeyIndex)]

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.