Network.Web3

Any communication with node wrapped with Web3 monad

Web3 runner for default Http provider

EOA params lens

Call execution block lens

Transaction gas limit lens

Transaction gas price lens

Transaction timeout lens

Transaction recipient lens

Transaction value lens

withParam is very similar to withStateT function, it's used to set parameters of transaction locally and revert params after out of scope.

 withAccount () $
   withParam (to .~ tokenAddress) $
     transfer alice 42
 

Run one block at a time.

A Typed-level sized List equivalent to [a]

Simplest Byte Array

Account is needed for sending transactions to blockchain

Typically account is provided by node. In this case node manage accounts: encrypt and decrypt private keys, manipulate files etc. In other case web3 can derive account from private key and send to node already signed transactions.

Local EOA params

Unlockable node managed account params

Event callback control response

Babbage unit type

Ether unit type

Finney unit type

KEther unit type

Lovelace unit type

Shannon unit type

Szabo unit type

Ethereum value unit

Wei unit type

Ethereum account address

Sized byte array with fixed length in bytes

Signed integer with fixed length in bits.

Unsigned integer with fixed length in bits.

Decode datatype from SCALE format.

Generic driven version of decode

Encode datatype to SCALE format.

Generic driven version of encode

Create Call type from text-encoded module and function.

Create a mortal Era with biggest lifetime period.

Note: The assumption is runtime has BlockHashCount = 2400. This is common for Polkadot runtimes.

Create signed extra from general data.

Sign extrinsic and send it using node RPC call.

Query data from blockchain via getStorage RPC call.

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.

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.

Call function of module using standard substrate extrionsic.

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.

Default Polkadot compatible extrinsic type.

Default Polkadot signed extra.

Account balances.

The user account identifier type for the runtime.

The type for looking up accounts. We don't expect more than 4 billion of them.

General account information.

The user account balance, u128 type.

Block numbers is up to 2^32.

The type for runtime hashes.

Transaction nonce value.

Time moment is 64bit.

A multi-format address wrapper for on-chain accounts.

Multiple signatures support type.