Remove `Cardano.Prelude` references from shelley
Replace types with their original definitions Define simple functions in place
Replace types with their original definitions Define simple functions in place
EncodeMint (..),
Val (..),
)
import Cardano.Prelude (cborError)
import Control.DeepSeq (NFData (..), deepseq, rwhnf)
import Control.Monad (forM_)
import Control.Monad.ST (runST)
import Data.Coders
( Decode (..),
Encode (..),
cborError,
decode,
decodeMap,
encode,
import Cardano.Ledger.Shelley.UTxO
import Cardano.Ledger.TxIn (TxId (..), TxIn (..))
import qualified Cardano.Ledger.Val as Val
import Cardano.Prelude (forceElemsToWHNF)
import Cardano.Slotting.EpochInfo
import Cardano.Slotting.Slot (EpochSize (..))
import Cardano.Slotting.Time (SystemStart (SystemStart))
import Data.Text (Text)
import qualified Data.Text as Text
import Data.Time (NominalDiffTime, UTCTime (..))
import Data.Unit.Strict (forceElemsToWHNF)
import Data.Word (Word32, Word64)
import GHC.Generics (Generic)
import GHC.Natural (Natural)
import Cardano.Ledger.UnifiedMap (Trip (..), Triple, UMap (..), UnifiedMap, View (..), ViewMap)
import Cardano.Ledger.Val ((<+>), (<->), (<×>))
import qualified Cardano.Ledger.Val as Val
import Cardano.Prelude (rightToMaybe)
import Control.DeepSeq (NFData)
import Control.Monad.State.Strict (evalStateT)
import Control.Monad.Trans
-- Stake pools that do not produce any blocks get no rewards,
-- but some information is still needed from non-block-producing
-- pools for the ranking algorithm used by the wallets.
blockProducingPoolInfo = VMap.toMap $ VMap.mapMaybe rightToMaybe allPoolInfo
blockProducingPoolInfo = VMap.toMap $ VMap.mapMaybe (either (const Nothing) Just) allPoolInfo
getSigma = unStakeShare . poolRelativeStake
makeLikelihoods = \case
hashAnnotated,
)
import Cardano.Ledger.Serialization (mapFromCBOR, mapToCBOR)
import Cardano.Prelude (cborError)
import Codec.CBOR.Decoding (Decoder)
import qualified Codec.CBOR.Decoding as CBOR
import qualified Codec.CBOR.Encoding as CBOR
import Control.DeepSeq (NFData (rnf), deepseq)
import Data.ByteString (ByteString)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS
import Data.Coders (cborError)
import Data.Map.Strict (Map)
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import Cardano.Ledger.BaseTypes (Network (..))
import Cardano.Ledger.Crypto (Crypto)
import Cardano.Ledger.Keys (KeyHash (..))
import Cardano.Prelude (readEither)
import Control.DeepSeq (NFData)
import Data.Aeson
import qualified Data.ByteString as Long (ByteString, empty)
import qualified Data.Sequence.Strict as SS
import qualified Data.Text as Text
import NoThunks.Class (NoThunks (..))
import Text.Read (readEither)
instance FromJSON IPv4 where
parseJSON =
nesBcur,
)
import Cardano.Ledger.Shelley.TxBody (TransTxBody, TransTxId)
import Cardano.Prelude (NFData (rnf))
import Cardano.Protocol.TPraos.API
( ChainDepState (..),
ChainTransitionError,
import Cardano.Protocol.TPraos.Rules.Prtcl (PrtclState (..))
import Cardano.Protocol.TPraos.Rules.Tickn (TicknState (..))
import Cardano.Slotting.Slot (withOriginToMaybe)
import Control.DeepSeq (NFData (rnf))
import Control.Monad.Except ()
import Control.State.Transition (STS (State))
import qualified Control.State.Transition.Trace.Generator.QuickCheck as QC
cardano-ledger-byron,
cardano-ledger-byron-test,
cardano-ledger-core,
cardano-prelude-test,
cardano-prelude,
cardano-ledger-pretty,
cardano-protocol-tpraos,
cardano-slotting,
cardano-ledger-byron,
cardano-ledger-core,
cardano-ledger-pretty,
cardano-prelude,
cardano-protocol-tpraos,
cardano-slotting,
cborg,
cardano-crypto-praos,
cardano-data,
cardano-ledger-core,
cardano-prelude,
cardano-protocol-tpraos,
cardano-slotting,
containers,
)
import Cardano.Ledger.TxIn (TxId (..), TxIn (..), mkTxInPartial)
import Cardano.Ledger.Val ((<->))
import Cardano.Prelude
( ByteString,
)
import Data.ByteString (ByteString)
import qualified Data.Map.Strict as Map
import Data.Maybe (fromJust)
import qualified Data.Sequence.Strict as StrictSeq
import qualified Data.Set as Set
import qualified Hedgehog.Gen
import qualified Hedgehog.Range
import qualified Test.Cardano.Chain.Common.Gen as Byron
import qualified Test.Cardano.Crypto.Gen as Byron
import qualified Test.Cardano.Ledger.Shelley.ConcreteCryptoTypes as Original
import Test.Cardano.Ledger.Shelley.Generator.ShelleyEraGen ()
import Test.Cardano.Ledger.Shelley.Orphans ()
import Test.Cardano.Ledger.Shelley.Utils (testSTS)
import Test.Cardano.Prelude (genBytes)
import Test.QuickCheck (Gen)
import Test.QuickCheck.Hedgehog (hedgehog)
import Test.Tasty (TestTree)
DSIGN.SignedDSIGN
. fromJust
. DSIGN.rawDeserialiseSigDSIGN
<$> hedgehog (genBytes . fromIntegral $ DSIGN.sizeSigDSIGN ([] @a))
<$> hedgehog (Hedgehog.Gen.bytes . Hedgehog.Range.singleton . fromIntegral $ DSIGN.sizeSigDSIGN ([] @a))
genBootstrapAddress :: Gen (BootstrapAddress crypto)
genBootstrapAddress = BootstrapAddress . snd <$> genByronVKeyAddr
import Cardano.Ledger.UnifiedMap (ViewMap)
import Cardano.Ledger.Val ((<+>), (<->))
import qualified Cardano.Ledger.Val as Val (coin)
import Cardano.Prelude (HasField (..))
import Cardano.Protocol.TPraos.API (GetLedgerView)
import Cardano.Protocol.TPraos.BHeader
( BHeader (..),
import qualified Data.UMap as UM
import qualified Data.VMap as VMap
import Data.Word (Word64)
import GHC.Records (HasField (..))
import Test.Cardano.Ledger.Shelley.Generator.Block (tickChainState)
import Test.Cardano.Ledger.Shelley.Generator.Core (GenEnv)
import Test.Cardano.Ledger.Shelley.Generator.EraGen (EraGen (..))
ToCBORGroup (..),
groupRecord,
)
import Cardano.Prelude
( Exception,
ExitCode (..),
forM_,
throwIO,
)
import Codec.CBOR.Read (deserialiseFromBytes)
import Codec.CBOR.Term (decodeTerm)
import Control.Exception hiding (throwIO)
import qualified Data.ByteString.Base16.Lazy as Base16
import qualified Data.ByteString.Lazy as BSL
import Data.ByteString.Lazy.Char8 as Char8 (lines, unpack)
import Data.Foldable (forM_)
import Data.Typeable
import GHC.Stack
import System.Exit (ExitCode (..))
import qualified System.IO as Sys
import System.Process.ByteString.Lazy (readProcessWithExitCode)
import Test.Tasty (TestTree)
import Test.Tasty.HUnit (assertFailure, testCase)
import UnliftIO (throwIO)
import UnliftIO.Temporary (withTempFile)
-- Round trip test for a type t with instances:
( BootstrapAddress (..),
)
import Data.Maybe (fromJust)
import qualified Hedgehog.Gen
import qualified Hedgehog.Range
import qualified Test.Cardano.Chain.Common.Gen as Byron
import Test.Cardano.Prelude (genBytes)
import Test.QuickCheck (Gen)
import Test.QuickCheck.Hedgehog (hedgehog)
DSIGN.SignedDSIGN
. fromJust
. DSIGN.rawDeserialiseSigDSIGN
<$> hedgehog (genBytes . fromIntegral $ DSIGN.sizeSigDSIGN ([] @a))
<$> hedgehog (Hedgehog.Gen.bytes . Hedgehog.Range.singleton . fromIntegral $ DSIGN.sizeSigDSIGN ([] @a))
genBootstrapAddress :: Gen (BootstrapAddress crypto)
genBootstrapAddress = BootstrapAddress <$> hedgehog Byron.genAddress
import Cardano.Ledger.Shelley.PParams
import Cardano.Ledger.Shelley.Scripts
import Cardano.Ledger.Shelley.TxBody
import Cardano.Prelude (Natural, Word32, Word64, Word8)
import Cardano.Slotting.Slot (EpochNo (..), EpochSize (..))
import Data.Fixed
import Data.IP (IPv4, IPv6, fromHostAddress, fromHostAddress6)
import qualified Data.Set as Set
import Data.Time.Clock (NominalDiffTime, UTCTime)
import Data.Time.Clock.POSIX (posixSecondsToUTCTime)
import GHC.Word (Word32, Word64, Word8)
import Hedgehog (Gen)
import qualified Hedgehog.Gen as Gen
import Hedgehog.Internal.Gen ()
import Hedgehog.Range (Range)
import qualified Hedgehog.Range as Range
import Numeric.Natural
import Test.Cardano.Ledger.Shelley.Utils (mkHash, unsafeBoundRational)
genShelleyGenesis :: Era era => Gen (ShelleyGenesis era)
toCBOR,
)
import Cardano.Ledger.Serialization (ToCBORGroup (..))
import Cardano.Prelude (LByteString)
import Codec.CBOR.Encoding (Encoding (..), Tokens (..))
import Codec.CBOR.Term (decodeTerm)
import Control.Exception (throwIO)
import Control.Monad (unless)
import qualified Data.ByteString.Lazy as BSL (ByteString)
import Data.String (fromString)
import GHC.Stack
import Test.Tasty (TestTree)
roundTrip ::
(HasCallStack, Show a, Eq a) =>
(a -> Encoding) ->
(LByteString -> Either DecoderError a) ->
(BSL.ByteString -> Either DecoderError a) ->
a ->
Assertion
roundTrip encode decode x =
checkEncoding ::
(HasCallStack, Show a, Eq a) =>
(a -> Encoding) ->
(LByteString -> Either DecoderError a) ->
(BSL.ByteString -> Either DecoderError a) ->
String ->
a ->
ToTokens ->
import Cardano.Ledger.Shelley.PParams (PParamsUpdate)
import Cardano.Ledger.Shelley.Tx (Tx, TxOut, WitnessSet)
import Cardano.Ledger.Slot (EpochNo, EpochSize (..), SlotNo)
import Cardano.Prelude (Coercible, asks)
import Cardano.Protocol.TPraos.API (GetLedgerView)
import Cardano.Protocol.TPraos.BHeader (BHBody (..), BHeader, bhbody)
import Cardano.Protocol.TPraos.OCert (KESPeriod (..))
fixedEpochInfo,
)
import Cardano.Slotting.Time (SystemStart (..), mkSlotLength)
import Control.Monad.Reader.Class (asks)
import Control.Monad.Trans.Reader (runReaderT)
import Control.State.Transition.Extended hiding (Assertion)
import Control.State.Transition.Trace
(.-),
(.->),
)
import Data.Coerce (coerce)
import Data.Coerce (Coercible, coerce)
import Data.Default.Class (Default)
import Data.Functor.Identity (runIdentity)
import Data.Maybe (fromMaybe)
module Test.TestScenario where
import Cardano.Prelude hiding (Option)
import Data.Proxy (Proxy (..))
import Test.Tasty (TestTree, defaultMainWithIngredients, includingOptions)
import Test.Tasty.Ingredients (Ingredient (..), composeReporters)
import Test.Tasty.Ingredients.Basic (consoleTestReporter, listingTests)
lookupOption,
safeRead,
)
import Prelude hiding (show)
data TestScenario
= ContinuousIntegration
logScenario :: Ingredient
logScenario = TestReporter [] $ \options _ -> Just $ \_ -> do
let scenario = lookupOption @TestScenario options
putTextLn $ "\nRunning in scenario: " <> show scenario
putStrLn $ "\nRunning in scenario: " <> show scenario
pure (const (pure True))
mainWithTestScenario :: TestTree -> IO ()
import Cardano.Ledger.Shelley.TxBody (PoolParams (..), RewardAcnt (..))
import Cardano.Ledger.Slot (epochInfoSize)
import Cardano.Ledger.Val (invert, (<+>), (<->))
import Cardano.Prelude (rightToMaybe)
import Cardano.Slotting.Slot (EpochSize (..))
import Control.Monad (replicateM)
import Control.Monad.Trans.Reader (asks, runReader)
(Coin totalStake)
(Coin activeStake)
pool
poolRewardInfo = VMap.toMap $ VMap.mapMaybe (rightToMaybe . mkPoolRewardInfo') poolParams
poolRewardInfo = VMap.toMap $ VMap.mapMaybe (either (const Nothing) Just . mkPoolRewardInfo') poolParams
pp_pv = _protocolVersion pp
free =
FreeVars
import Cardano.Ledger.Shelley.UTxO (UTxO (UTxO), makeWitnessVKey)
import Cardano.Ledger.Slot (BlockNo (..), EpochNo (..), SlotNo (..))
import Cardano.Ledger.TxIn (TxId, TxIn (..))
import Cardano.Prelude (LByteString)
import Cardano.Protocol.TPraos.BHeader
( BHBody (..),
BHeader (..),
import Data.ByteString (ByteString)
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString.Char8 as BS (pack)
import qualified Data.ByteString.Lazy as BSL (ByteString)
import Data.Coerce (coerce)
import Data.Default.Class (def)
import Data.IP (toIPv4)
decodeMultiSigMap :: Decoder s (Annotator MultiSigMap)
decodeMultiSigMap = decodeMapTraverse (pure <$> fromCBOR) fromCBOR
deserializeMultiSigMap :: LByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap :: BSL.ByteString -> Either DecoderError MultiSigMap
deserializeMultiSigMap = decodeAnnotator "Map ScriptHash MultiSig" decodeMultiSigMap
checkEncodingCBORCBORGroup ::
Includes direct 1:1 wrappers for misc builders (#197) and tx_builder (#210)
Wrappers around custom-written code written earlier for the rust crate.
Previous work on the builders/etc updates rust but introduced things caused the WASM to no longer compile. This updates the WASM bindings as well. Includes genesis module that wasn't pushed before.