{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric  #-}
{-# LANGUAGE TypeFamilies   #-}

-- |
-- Module      :  Network.Polkadot.Extrinsic.SignedExtension.System
-- Copyright   :  Aleksandr Krupenkin 2016-2024
-- License     :  Apache-2.0
--
-- Maintainer  :  mail@akru.me
-- Stability   :  experimental
-- Portability :  portable
--
-- A frame system signed extensions.
--

module Network.Polkadot.Extrinsic.SignedExtension.System where

import           Codec.Scale                                (Compact, Decode,
                                                             Encode, Generic)
import           Data.BigNum                                (h256)
import           Data.Maybe                                 (fromJust)
import           Data.Word                                  (Word32)
import qualified GHC.Generics                               as GHC (Generic)

import           Network.Polkadot.Extrinsic.Era             (Era, birth)
import           Network.Polkadot.Extrinsic.SignedExtension (SignedExtension (..))
import           Network.Polkadot.Primitives                (Hash, Index)
import           Network.Polkadot.Rpc.Chain                 (getBlockHash,
                                                             getHeader)
import           Network.Polkadot.Rpc.State                 (getRuntimeVersion)
import           Network.Polkadot.Rpc.Types                 (RuntimeVersion (..),
                                                             headerNumber,
                                                             unBlockNumber)

-- | Ensure the runtime version registered in the transaction is the same as at present.
data CheckSpecVersion = CheckSpecVersion
    deriving (CheckSpecVersion -> CheckSpecVersion -> Bool
(CheckSpecVersion -> CheckSpecVersion -> Bool)
-> (CheckSpecVersion -> CheckSpecVersion -> Bool)
-> Eq CheckSpecVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckSpecVersion -> CheckSpecVersion -> Bool
== :: CheckSpecVersion -> CheckSpecVersion -> Bool
$c/= :: CheckSpecVersion -> CheckSpecVersion -> Bool
/= :: CheckSpecVersion -> CheckSpecVersion -> Bool
Eq, Int -> CheckSpecVersion -> ShowS
[CheckSpecVersion] -> ShowS
CheckSpecVersion -> String
(Int -> CheckSpecVersion -> ShowS)
-> (CheckSpecVersion -> String)
-> ([CheckSpecVersion] -> ShowS)
-> Show CheckSpecVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckSpecVersion -> ShowS
showsPrec :: Int -> CheckSpecVersion -> ShowS
$cshow :: CheckSpecVersion -> String
show :: CheckSpecVersion -> String
$cshowList :: [CheckSpecVersion] -> ShowS
showList :: [CheckSpecVersion] -> ShowS
Show, All SListI (Code CheckSpecVersion)
All SListI (Code CheckSpecVersion) =>
(CheckSpecVersion -> Rep CheckSpecVersion)
-> (Rep CheckSpecVersion -> CheckSpecVersion)
-> Generic CheckSpecVersion
Rep CheckSpecVersion -> CheckSpecVersion
CheckSpecVersion -> Rep CheckSpecVersion
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
$cfrom :: CheckSpecVersion -> Rep CheckSpecVersion
from :: CheckSpecVersion -> Rep CheckSpecVersion
$cto :: Rep CheckSpecVersion -> CheckSpecVersion
to :: Rep CheckSpecVersion -> CheckSpecVersion
Generic, (forall x. CheckSpecVersion -> Rep CheckSpecVersion x)
-> (forall x. Rep CheckSpecVersion x -> CheckSpecVersion)
-> Generic CheckSpecVersion
forall x. Rep CheckSpecVersion x -> CheckSpecVersion
forall x. CheckSpecVersion -> Rep CheckSpecVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CheckSpecVersion -> Rep CheckSpecVersion x
from :: forall x. CheckSpecVersion -> Rep CheckSpecVersion x
$cto :: forall x. Rep CheckSpecVersion x -> CheckSpecVersion
to :: forall x. Rep CheckSpecVersion x -> CheckSpecVersion
GHC.Generic, Putter CheckSpecVersion
Putter CheckSpecVersion -> Encode CheckSpecVersion
forall a. Putter a -> Encode a
$cput :: Putter CheckSpecVersion
put :: Putter CheckSpecVersion
Encode, Get CheckSpecVersion
Get CheckSpecVersion -> Decode CheckSpecVersion
forall a. Get a -> Decode a
$cget :: Get CheckSpecVersion
get :: Get CheckSpecVersion
Decode)

instance SignedExtension CheckSpecVersion where
    type AdditionalSigned CheckSpecVersion = Word32
    additional_signed :: forall (m :: * -> *).
JsonRpc m =>
CheckSpecVersion -> m (AdditionalSigned CheckSpecVersion)
additional_signed CheckSpecVersion
_ = RuntimeVersion -> Word32
runtimeSpecVersion (RuntimeVersion -> Word32) -> m RuntimeVersion -> m Word32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe HexString -> m RuntimeVersion
forall (m :: * -> *).
JsonRpc m =>
Maybe HexString -> m RuntimeVersion
getRuntimeVersion Maybe HexString
forall a. Maybe a
Nothing

data CheckTxVersion = CheckTxVersion
    deriving (CheckTxVersion -> CheckTxVersion -> Bool
(CheckTxVersion -> CheckTxVersion -> Bool)
-> (CheckTxVersion -> CheckTxVersion -> Bool) -> Eq CheckTxVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckTxVersion -> CheckTxVersion -> Bool
== :: CheckTxVersion -> CheckTxVersion -> Bool
$c/= :: CheckTxVersion -> CheckTxVersion -> Bool
/= :: CheckTxVersion -> CheckTxVersion -> Bool
Eq, Int -> CheckTxVersion -> ShowS
[CheckTxVersion] -> ShowS
CheckTxVersion -> String
(Int -> CheckTxVersion -> ShowS)
-> (CheckTxVersion -> String)
-> ([CheckTxVersion] -> ShowS)
-> Show CheckTxVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckTxVersion -> ShowS
showsPrec :: Int -> CheckTxVersion -> ShowS
$cshow :: CheckTxVersion -> String
show :: CheckTxVersion -> String
$cshowList :: [CheckTxVersion] -> ShowS
showList :: [CheckTxVersion] -> ShowS
Show, All SListI (Code CheckTxVersion)
All SListI (Code CheckTxVersion) =>
(CheckTxVersion -> Rep CheckTxVersion)
-> (Rep CheckTxVersion -> CheckTxVersion) -> Generic CheckTxVersion
Rep CheckTxVersion -> CheckTxVersion
CheckTxVersion -> Rep CheckTxVersion
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
$cfrom :: CheckTxVersion -> Rep CheckTxVersion
from :: CheckTxVersion -> Rep CheckTxVersion
$cto :: Rep CheckTxVersion -> CheckTxVersion
to :: Rep CheckTxVersion -> CheckTxVersion
Generic, (forall x. CheckTxVersion -> Rep CheckTxVersion x)
-> (forall x. Rep CheckTxVersion x -> CheckTxVersion)
-> Generic CheckTxVersion
forall x. Rep CheckTxVersion x -> CheckTxVersion
forall x. CheckTxVersion -> Rep CheckTxVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CheckTxVersion -> Rep CheckTxVersion x
from :: forall x. CheckTxVersion -> Rep CheckTxVersion x
$cto :: forall x. Rep CheckTxVersion x -> CheckTxVersion
to :: forall x. Rep CheckTxVersion x -> CheckTxVersion
GHC.Generic, Putter CheckTxVersion
Putter CheckTxVersion -> Encode CheckTxVersion
forall a. Putter a -> Encode a
$cput :: Putter CheckTxVersion
put :: Putter CheckTxVersion
Encode, Get CheckTxVersion
Get CheckTxVersion -> Decode CheckTxVersion
forall a. Get a -> Decode a
$cget :: Get CheckTxVersion
get :: Get CheckTxVersion
Decode)

instance SignedExtension CheckTxVersion where
    type AdditionalSigned CheckTxVersion = Word32
    additional_signed :: forall (m :: * -> *).
JsonRpc m =>
CheckTxVersion -> m (AdditionalSigned CheckTxVersion)
additional_signed CheckTxVersion
_ = RuntimeVersion -> Word32
runtimeTransactionVersion (RuntimeVersion -> Word32) -> m RuntimeVersion -> m Word32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe HexString -> m RuntimeVersion
forall (m :: * -> *).
JsonRpc m =>
Maybe HexString -> m RuntimeVersion
getRuntimeVersion Maybe HexString
forall a. Maybe a
Nothing

data CheckGenesis = CheckGenesis
    deriving (CheckGenesis -> CheckGenesis -> Bool
(CheckGenesis -> CheckGenesis -> Bool)
-> (CheckGenesis -> CheckGenesis -> Bool) -> Eq CheckGenesis
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckGenesis -> CheckGenesis -> Bool
== :: CheckGenesis -> CheckGenesis -> Bool
$c/= :: CheckGenesis -> CheckGenesis -> Bool
/= :: CheckGenesis -> CheckGenesis -> Bool
Eq, Int -> CheckGenesis -> ShowS
[CheckGenesis] -> ShowS
CheckGenesis -> String
(Int -> CheckGenesis -> ShowS)
-> (CheckGenesis -> String)
-> ([CheckGenesis] -> ShowS)
-> Show CheckGenesis
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckGenesis -> ShowS
showsPrec :: Int -> CheckGenesis -> ShowS
$cshow :: CheckGenesis -> String
show :: CheckGenesis -> String
$cshowList :: [CheckGenesis] -> ShowS
showList :: [CheckGenesis] -> ShowS
Show, All SListI (Code CheckGenesis)
All SListI (Code CheckGenesis) =>
(CheckGenesis -> Rep CheckGenesis)
-> (Rep CheckGenesis -> CheckGenesis) -> Generic CheckGenesis
Rep CheckGenesis -> CheckGenesis
CheckGenesis -> Rep CheckGenesis
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
$cfrom :: CheckGenesis -> Rep CheckGenesis
from :: CheckGenesis -> Rep CheckGenesis
$cto :: Rep CheckGenesis -> CheckGenesis
to :: Rep CheckGenesis -> CheckGenesis
Generic, (forall x. CheckGenesis -> Rep CheckGenesis x)
-> (forall x. Rep CheckGenesis x -> CheckGenesis)
-> Generic CheckGenesis
forall x. Rep CheckGenesis x -> CheckGenesis
forall x. CheckGenesis -> Rep CheckGenesis x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CheckGenesis -> Rep CheckGenesis x
from :: forall x. CheckGenesis -> Rep CheckGenesis x
$cto :: forall x. Rep CheckGenesis x -> CheckGenesis
to :: forall x. Rep CheckGenesis x -> CheckGenesis
GHC.Generic, Putter CheckGenesis
Putter CheckGenesis -> Encode CheckGenesis
forall a. Putter a -> Encode a
$cput :: Putter CheckGenesis
put :: Putter CheckGenesis
Encode, Get CheckGenesis
Get CheckGenesis -> Decode CheckGenesis
forall a. Get a -> Decode a
$cget :: Get CheckGenesis
get :: Get CheckGenesis
Decode)

instance SignedExtension CheckGenesis where
    type AdditionalSigned CheckGenesis = Hash
    additional_signed :: forall (m :: * -> *).
JsonRpc m =>
CheckGenesis -> m (AdditionalSigned CheckGenesis)
additional_signed CheckGenesis
_ = do
        -- chain must have genesis block, fromJust is safe
        (Maybe Hash -> Hash
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Hash -> Hash)
-> (Maybe HexString -> Maybe Hash) -> Maybe HexString -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexString -> Maybe Hash
forall a. ByteArrayAccess a => a -> Maybe Hash
h256 (HexString -> Maybe Hash) -> Maybe HexString -> Maybe Hash
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<)) (Maybe HexString -> Hash) -> m (Maybe HexString) -> m Hash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int -> m (Maybe HexString)
forall (m :: * -> *). JsonRpc m => Maybe Int -> m (Maybe HexString)
getBlockHash (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0)

newtype CheckEra = CheckEra Era
    deriving (CheckEra -> CheckEra -> Bool
(CheckEra -> CheckEra -> Bool)
-> (CheckEra -> CheckEra -> Bool) -> Eq CheckEra
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckEra -> CheckEra -> Bool
== :: CheckEra -> CheckEra -> Bool
$c/= :: CheckEra -> CheckEra -> Bool
/= :: CheckEra -> CheckEra -> Bool
Eq, Int -> CheckEra -> ShowS
[CheckEra] -> ShowS
CheckEra -> String
(Int -> CheckEra -> ShowS)
-> (CheckEra -> String) -> ([CheckEra] -> ShowS) -> Show CheckEra
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckEra -> ShowS
showsPrec :: Int -> CheckEra -> ShowS
$cshow :: CheckEra -> String
show :: CheckEra -> String
$cshowList :: [CheckEra] -> ShowS
showList :: [CheckEra] -> ShowS
Show, All SListI (Code CheckEra)
All SListI (Code CheckEra) =>
(CheckEra -> Rep CheckEra)
-> (Rep CheckEra -> CheckEra) -> Generic CheckEra
Rep CheckEra -> CheckEra
CheckEra -> Rep CheckEra
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
$cfrom :: CheckEra -> Rep CheckEra
from :: CheckEra -> Rep CheckEra
$cto :: Rep CheckEra -> CheckEra
to :: Rep CheckEra -> CheckEra
Generic, (forall x. CheckEra -> Rep CheckEra x)
-> (forall x. Rep CheckEra x -> CheckEra) -> Generic CheckEra
forall x. Rep CheckEra x -> CheckEra
forall x. CheckEra -> Rep CheckEra x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CheckEra -> Rep CheckEra x
from :: forall x. CheckEra -> Rep CheckEra x
$cto :: forall x. Rep CheckEra x -> CheckEra
to :: forall x. Rep CheckEra x -> CheckEra
GHC.Generic, Putter CheckEra
Putter CheckEra -> Encode CheckEra
forall a. Putter a -> Encode a
$cput :: Putter CheckEra
put :: Putter CheckEra
Encode, Get CheckEra
Get CheckEra -> Decode CheckEra
forall a. Get a -> Decode a
$cget :: Get CheckEra
get :: Get CheckEra
Decode)

instance SignedExtension CheckEra where
    type AdditionalSigned CheckEra = Hash
    additional_signed :: forall (m :: * -> *).
JsonRpc m =>
CheckEra -> m (AdditionalSigned CheckEra)
additional_signed (CheckEra Era
era) = do
        -- chain must have top header, fromJust is safe here
        Integer
current <- (BlockNumber -> Integer
unBlockNumber (BlockNumber -> Integer)
-> (Maybe Header -> BlockNumber) -> Maybe Header -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Header -> BlockNumber
headerNumber (Header -> BlockNumber)
-> (Maybe Header -> Header) -> Maybe Header -> BlockNumber
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Header -> Header
forall a. HasCallStack => Maybe a -> a
fromJust) (Maybe Header -> Integer) -> m (Maybe Header) -> m Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe HexString -> m (Maybe Header)
forall (m :: * -> *).
JsonRpc m =>
Maybe HexString -> m (Maybe Header)
getHeader Maybe HexString
forall a. Maybe a
Nothing
        (Maybe Hash -> Hash
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Hash -> Hash)
-> (Maybe HexString -> Maybe Hash) -> Maybe HexString -> Hash
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HexString -> Maybe Hash
forall a. ByteArrayAccess a => a -> Maybe Hash
h256 (HexString -> Maybe Hash) -> Maybe HexString -> Maybe Hash
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<)) (Maybe HexString -> Hash) -> m (Maybe HexString) -> m Hash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int -> m (Maybe HexString)
forall (m :: * -> *). JsonRpc m => Maybe Int -> m (Maybe HexString)
getBlockHash (Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Era -> Integer -> Int
forall a b. (Integral a, Integral b) => Era -> a -> b
birth Era
era Integer
current)

newtype CheckNonce = CheckNonce (Compact Index)
    deriving (CheckNonce -> CheckNonce -> Bool
(CheckNonce -> CheckNonce -> Bool)
-> (CheckNonce -> CheckNonce -> Bool) -> Eq CheckNonce
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckNonce -> CheckNonce -> Bool
== :: CheckNonce -> CheckNonce -> Bool
$c/= :: CheckNonce -> CheckNonce -> Bool
/= :: CheckNonce -> CheckNonce -> Bool
Eq, Int -> CheckNonce -> ShowS
[CheckNonce] -> ShowS
CheckNonce -> String
(Int -> CheckNonce -> ShowS)
-> (CheckNonce -> String)
-> ([CheckNonce] -> ShowS)
-> Show CheckNonce
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckNonce -> ShowS
showsPrec :: Int -> CheckNonce -> ShowS
$cshow :: CheckNonce -> String
show :: CheckNonce -> String
$cshowList :: [CheckNonce] -> ShowS
showList :: [CheckNonce] -> ShowS
Show, All SListI (Code CheckNonce)
All SListI (Code CheckNonce) =>
(CheckNonce -> Rep CheckNonce)
-> (Rep CheckNonce -> CheckNonce) -> Generic CheckNonce
Rep CheckNonce -> CheckNonce
CheckNonce -> Rep CheckNonce
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
$cfrom :: CheckNonce -> Rep CheckNonce
from :: CheckNonce -> Rep CheckNonce
$cto :: Rep CheckNonce -> CheckNonce
to :: Rep CheckNonce -> CheckNonce
Generic, (forall x. CheckNonce -> Rep CheckNonce x)
-> (forall x. Rep CheckNonce x -> CheckNonce) -> Generic CheckNonce
forall x. Rep CheckNonce x -> CheckNonce
forall x. CheckNonce -> Rep CheckNonce x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CheckNonce -> Rep CheckNonce x
from :: forall x. CheckNonce -> Rep CheckNonce x
$cto :: forall x. Rep CheckNonce x -> CheckNonce
to :: forall x. Rep CheckNonce x -> CheckNonce
GHC.Generic, Putter CheckNonce
Putter CheckNonce -> Encode CheckNonce
forall a. Putter a -> Encode a
$cput :: Putter CheckNonce
put :: Putter CheckNonce
Encode, Get CheckNonce
Get CheckNonce -> Decode CheckNonce
forall a. Get a -> Decode a
$cget :: Get CheckNonce
get :: Get CheckNonce
Decode)

instance SignedExtension CheckNonce where
    type AdditionalSigned CheckNonce = ()
    additional_signed :: forall (m :: * -> *).
JsonRpc m =>
CheckNonce -> m (AdditionalSigned CheckNonce)
additional_signed CheckNonce
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

data CheckWeight = CheckWeight
    deriving (CheckWeight -> CheckWeight -> Bool
(CheckWeight -> CheckWeight -> Bool)
-> (CheckWeight -> CheckWeight -> Bool) -> Eq CheckWeight
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckWeight -> CheckWeight -> Bool
== :: CheckWeight -> CheckWeight -> Bool
$c/= :: CheckWeight -> CheckWeight -> Bool
/= :: CheckWeight -> CheckWeight -> Bool
Eq, Int -> CheckWeight -> ShowS
[CheckWeight] -> ShowS
CheckWeight -> String
(Int -> CheckWeight -> ShowS)
-> (CheckWeight -> String)
-> ([CheckWeight] -> ShowS)
-> Show CheckWeight
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckWeight -> ShowS
showsPrec :: Int -> CheckWeight -> ShowS
$cshow :: CheckWeight -> String
show :: CheckWeight -> String
$cshowList :: [CheckWeight] -> ShowS
showList :: [CheckWeight] -> ShowS
Show, All SListI (Code CheckWeight)
All SListI (Code CheckWeight) =>
(CheckWeight -> Rep CheckWeight)
-> (Rep CheckWeight -> CheckWeight) -> Generic CheckWeight
Rep CheckWeight -> CheckWeight
CheckWeight -> Rep CheckWeight
forall a.
All SListI (Code a) =>
(a -> Rep a) -> (Rep a -> a) -> Generic a
$cfrom :: CheckWeight -> Rep CheckWeight
from :: CheckWeight -> Rep CheckWeight
$cto :: Rep CheckWeight -> CheckWeight
to :: Rep CheckWeight -> CheckWeight
Generic, (forall x. CheckWeight -> Rep CheckWeight x)
-> (forall x. Rep CheckWeight x -> CheckWeight)
-> Generic CheckWeight
forall x. Rep CheckWeight x -> CheckWeight
forall x. CheckWeight -> Rep CheckWeight x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CheckWeight -> Rep CheckWeight x
from :: forall x. CheckWeight -> Rep CheckWeight x
$cto :: forall x. Rep CheckWeight x -> CheckWeight
to :: forall x. Rep CheckWeight x -> CheckWeight
GHC.Generic, Putter CheckWeight
Putter CheckWeight -> Encode CheckWeight
forall a. Putter a -> Encode a
$cput :: Putter CheckWeight
put :: Putter CheckWeight
Encode, Get CheckWeight
Get CheckWeight -> Decode CheckWeight
forall a. Get a -> Decode a
$cget :: Get CheckWeight
get :: Get CheckWeight
Decode)

instance SignedExtension CheckWeight where
    type AdditionalSigned CheckWeight = ()
    additional_signed :: forall (m :: * -> *).
JsonRpc m =>
CheckWeight -> m (AdditionalSigned CheckWeight)
additional_signed CheckWeight
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()