Cryptokitties, what are they?

What are they worth?

Turns out over 12 million dollars!

Ethereum Market Cap

• Second highest cryptocurrency market cap
• Doesn’t include the sum of the value of tokens

Kitty Monitor

• Monitor the sales in real time with the kitty-monitor
• Backed by purescript-web3

Solidity

• Javascript like syntax
• Special blockchain, crypto and signature-recovery primitives
• Types for EVM primitives such as uint48
• Interface through ABI

contract GreedyStorage is owned {
  uint public m; // automatically generate "getter" m()
  event Overidden(address overrider)
  function increase (uint n) onlyOwner returns (uint) {
     m = m + n;
     return m;
  }
  function override (uint n) payable {
    require(msg.value > 100000);  // this is the price
    m = n;
    Overidden(msg.sender);
  }
}

edit on remix

The selector is how we speficy the function to execute

selector :: FunctionSignature -> ByteString
selector = take 8 $ sha3

> selector "increase(uint256)"
> "30f3f0db"

so for GreedyStorage we get

{
    "increase(uint256)" : "30f3f0db",
    "m()"               : "5a2ee019",
    "override(uint256)" : "94d9e61c"
}

Typesafety (on-chain)

• Work underway for strongly typed languages targeting EVM
• Typesafe EVM language wouldn’t necessarily have prevented infamous bugs. We’d need session types or similar.
• Fundamental problem is call-out from turingcomplete executable to turing complete executable. Type level information not preserved on EVM.

Typesafety (off-chain)

Prevent catastrophes

• Encoding errors
• Improper value transfer
• Function/argument mismatch

Subtle changes leading to broken application code

contract A {
  uint n;
  function A (uint _arg) {
    n = _arg;
  }
}

contract A {
  int n;
  function A (uint _arg) {
    n = _arg;
  }
}

Auto-generated FFI

• Ethereum smart contracts expose an interface
• Example: ERC20 standard

Auto-generated FFI

• Use the Application Binary Interface (ABI) as a specification

 {
    "inputs": [
      {
        "name": "from",
        "type": "address"
      },
      {
        "name": "to",
        "type": "address"
      },
      {
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "transferFrom",
    ....
  }
...

Auto-generated FFI

• Auto generate purescript or haskell code for FFI

Functional Web3 Libraries

• purescript-web3: A web3 client library for purescript. Capable of generating client libraries for smart contracts from Solidity ABIs. Integrates with services like Metamask or uPort for in-browser transaction signing. Plays very nicely with Chanterelle.
• hs-web3: A haskell web3 client library. Also capable of creating client libraries from ABIs using Template Haskell.

Library Layout

• Low level serialization and RPC layer
• • Solidity types
• • (de)serialization
• • web3 api
• User Interface and Generator Tool
• • purescript-web3 generator
• • Contract module
• • Methods and Events

Solidity Types

Sized Types

• Purescript does not as of yet have type level naturals
• Luckily we don’t need infinitely many

module Network.Ethereum.Web3.Solidity.Size where

data D0
...
data D9
data (:&) :: Type -> Type -> Type
data Z :: Type
data S :: Type -> Type

class KnownSize s
class KnownNat n
class KnownSize n <= ByteSize n
class KnownSize n <= IntSize n

type N4 = S (S (S (S Z)))

Sized Ints

• js doesn’t have unbounded integers (doesn’t even have integers!)
• need something like BigNumber

newtype UIntN n = UIntN BigNumber

uIntNFromBigNumber :: forall n . KnownSize n
                   => BigNumber
                   -> Maybe (UIntN n)

type UInt = UIntN (D2 :& D5 :& D6)

Length Indexed Vectors

newtype Vector n a = Vector (Array a)

nilVector :: forall a . Vector Z a
nilVector = Vector mempty

vCons :: forall a n . a
      -> Vector n a
      -> Vector (S n) a
vCons a (Vector as) = Vector (a : as)

infixr 6 vCons as :<

toVector :: forall a n . KnownNat n
         => Array a
         -> Maybe (Vector n a)
toVector as = if natVal (Proxy :: Proxy n) /= A.length as
                 then Nothing
                 else Just (Vector as)

bools :: Vector N3 Boolean
bools = true :< false :< true :< nilVector

Tuples

• The EVM is a stack based virtual machine with a maximum depth of 16. Limits the possible tuple sizes.

data Tuple0 = Tuple0

newtype Tuple1 a = Tuple1 a

...

data Tuple16 a b c d e f g h i j k l m n o p =
  Tuple16 a b c d e f g h i j k l m n o p

• First iteration of purescript-web3 didn’t handle these well.

Basic (De)Serialization

• All basic Solidity types implement the following type classes for the ABI encoding schema.

class ABIEncode a where
  toDataBuilder :: a -> HexString

class ABIDecode a where
  fromDataParser :: Parser String a

instance abiEncodeUint :: IntSize n => ABIEncode (UIntN n) where
  toDataBuilder a = uInt256HexBuilder <<< unUIntN $ a

instance abiDecodeUint :: IntSize n => ABIDecode (UIntN n) where
  fromDataParser = do
    a <- uInt256HexParser
    maybe (fail $ msg a) pure <<< uIntNFromBigNumber $ a
  where
    msg n = let size = sizeVal (Proxy :: Proxy n)
            in "Couldn't parse as uint" <> show size <> ":" <> show n

Tuples

• All Solidity functions accept and return tuples.
• Events are emitted as tuples, though not as straight forward to handle.
• Encoding and Decoding implemented “generically”.

Generics Primer (Advanced)

• All “basic” purescript types (i.e. of kind Type) admit a generic decomposition

data Argument a = Argument a
data Product a b = Product a b
data Constructor (s :: Symbol) a = Constructor a

from (Tuple3 Bool String (UInt D8)) ::
  Constructor "Tuple3" (Product (Argument Bool) (Product (Argument String) (Argument UInt D8)))

Generics Primer (Advanced)

• Compiler implements generic decompositions for us, so we can use them for free.
• We can inductively build up generic types to have a certain property, such as ABIEncode

instance genericEncodeBase :: ABIEncode a
                           => GenericABIEncode (Argument a)

instance genericEncodeInductive :: ( ABIEncode a
                                   , GenericABIEncode b
                                   )
               => GenericABIEncode (Product (Argument a) b)

Generics

• enables extremely local reasoning, building up more complicated expressions from smaller ones whose correctness is easier to prove.
• code utilizing “generics” is extremely reusable.

genericEncode ::
  forall a rep .
     Generic a rep
  => GenericABIEncode rep
  => a
  -> HexString
genericABIEncode = genericToDataBuilder <<< from

Web3 API

• The Web3 API is a set of RPC methods that the ethereum client knows about
• There are a lot, the type signatures serve as a sort of documentation

eth_sendTransaction :: forall p e . IsAsyncProvider p
                    => TransactionOptions
                    -> Web3 p e HexString

eth_newFilter :: forall p e . IsAsyncProvider p
              => Filter
              -> Web3 p e FilterId

eth_getFilterChanges :: forall p e . IsAsyncProvider p
                     => FilterId
                     -> Web3 p e (Array Change)

...

Web3 API

• Implementation of the client portion heavily inspired by the hs-web3 implementation.
• How easy is it to add new endpoints as they are released?

signMessage :: forall p e . IsAsyncProvider p
            => Address -- unlocked account
            -> HexString -- message to sign
            -> Web3 p e HexString -- signed message

Pretty easy!

User Interface

You will be able to use purescript-web3 without knowing how it works. This means:

1. Calling contract methods, listening for events, querying blockchain metadata, full web3 api implementation.
2. Integrating with metamask.
3. Easily generate a simple client library for every contract.

Generator - Simple Storage

Simple Storage allows us to change a uint256, query that state, and listen for updates to that state.

contract SimpleStorage {
    uint public count;
    event CountSet(uint _count);
    function setCount(uint _count) {
        count = _count;
        CountSet(_count);
    }
}

Generator - Simple Storage

Here is the client library generated which is generated from the ABI ¹

 count :: forall e 
        . TransactionOptions NoPay 
        -> ChainCursor 
        -> Web3 e (Either CallError (UIntN (D2 :& D5 :& DOne D6)))
 
 setCount :: forall e
           . TransactionOptions Wei 
           -> { _count :: (UIntN (D2 :& D5 :& DOne D6)) } 
           -> Web3 e HexString

newtype CountSet =
  CountSet { _count :: UIntN (D2 :& D5 :& D6) }

Generator - Benefits

1. Reduce boiler plate.
2. You don’t want to access the raw encoders/decoders manually when templating your transactions, laborious and potentially error prone.
3. The generator is meant to be run as an npm build step - any breaking changes to your contracts will cause compile time errors in your application.
4. Specially generated types allow for higher levels of abstraction in library.

Generator - How does it work

• All templated transaction functions are run with the sendTx method:

class TxMethod (selector :: Symbol) a where
    sendTx :: forall p e u.
              IsAsyncProvider p
      => IsSymbol selector
      => EtherUnit u
      => Maybe Address              -- Contract address
      -> Address                    -- From address
      -> u                          -- paymentValue
      -> Tagged (SProxy selector) a -- Method data
      -> Web3 p e HexString         -- 'Web3' wrapped tx hash

• call methods are similar, but with a return type

Generator - Events

• Events were difficult to find a good solution for due to the Ethereum log structure.
• All events can be handled with the event method, which similarly defined in hs-web3

event :: forall p e a i ni. IsAsyncProvider p
      => DecodeEvent i ni a
      => EventFilter a
      => Address
      -> (a -> ReaderT Change (Web3 p e) EventAction)
      -> Web3 p e (Fiber (eth :: ETH | e) Unit)

• this looks more complicated than it is.

Events - Example

• Here’s an example of the event monitor in the example app. It registers a handler and asynchronously polls a filter for the CountSet event, updating the React component’s state.
• Since the return value of the handler is always ContinueEvent, this poll never terminates.

monitorCount :: R.ComponentDidMount CountStateProps CountState (eth :: ETH | eff)
monitorCount this = void $ do
  props <- R.getProps this
  launchAff do
    void $ runWeb3 metamask $
      event config.simpleStorageAddress $ \(SimpleStorage.CountSet cs) -> do
      _ <- liftEff <<< R.transformState this $ _{currentCount= show cs._count}
      pure ContinueEvent

Local

1. Setup and ERC20 contract.
2. Deploy it with hooks for the Indexer.
3. Make a transaction.
4. Find it in the API.

Main Net

1. Submit a request to index the OmiseGo ERC20 token contract.
2. Find it in the API