Network.Polkadot

Query data from blockchain via getStorage RPC call.

General type wrapper for SCALE encodable storage index argument.

Decode datatype from SCALE format.

Generic driven version of decode

Encode datatype to SCALE format.

Generic driven version of encode

The class of representable datatypes.

The SOP approach to generic programming is based on viewing datatypes as a representation (Rep) built from the sum of products of its components. The components of a datatype are specified using the Code type family.

The isomorphism between the original Haskell datatype and its representation is witnessed by the methods of this class, from and to. So for instances of this class, the following laws should (in general) hold:

to . from === id :: a -> a
from . to === id :: Rep a -> Rep a

You typically don't define instances of this class by hand, but rather derive the class instance automatically.

Option 1: Derive via the built-in GHC-generics. For this, you need to use the DeriveGeneric extension to first derive an instance of the Generic class from module GHC.Generics. With this, you can then give an empty instance for Generic, and the default definitions will just work. The pattern looks as follows:

import qualified GHC.Generics as GHC
import Generics.SOP

...

data T = ... deriving (GHC.Generic, ...)

instance Generic T -- empty
instance HasDatatypeInfo T -- empty, if you want/need metadata

Option 2: Derive via Template Haskell. For this, you need to enable the TemplateHaskell extension. You can then use deriveGeneric from module Generics.SOP.TH to have the instance generated for you. The pattern looks as follows:

import Generics.SOP
import Generics.SOP.TH

...

data T = ...

deriveGeneric ''T -- derives HasDatatypeInfo as well

Tradeoffs: Whether to use Option 1 or 2 is mainly a matter of personal taste. The version based on Template Haskell probably has less run-time overhead.

Non-standard instances: It is possible to give Generic instances manually that deviate from the standard scheme, as long as at least

to . from === id :: a -> a

still holds.

A class for decoding datatypes from SCALE format.

If your compiler has support for the DeriveGeneric and DefaultSignatures language extensions (ghc >= 7.2.1), the get method will have default generic implementations.

To use this option, simply add a deriving Generic clause to your datatype and declare a Decode instance for it without giving a definition for get.

A class for encoding datatypes to SCALE format.

If your compiler has support for the DeriveGeneric and DefaultSignatures language extensions (ghc >= 7.2.1), the put method will have default generic implementations.

To use this option, simply add a deriving Generic clause to your datatype and declare a Encode instance for it without giving a definition for put.

A "compact" or general integer encoding is sufficient for encoding large integers (up to 2**536) and is more efficient at encoding most values than the fixed-width version.

ECDSA cryptographic pair.

Ed25519 cryptographic pair.

Multiple cryptographic type support.

Class suitable for typical cryptographic PKI key pair type.

The type which is used to encode a public key.

The type used to represent a signature. Can be created from a key pair and a message and verified with the message and a public key.

Means of signature verification.

Some type that is able to be collapsed into an account ID.

It is not possible to recreate the original value from the account ID.

Key that can be encoded to/from SS58.

See https://github.com/paritytech/substrate/wiki/External-Address-Format-(SS58)#address-type for information on the codec.