Name change

cardano-api/src/Cardano/Api/Typed.hs

@@ -406,8 +406,8 @@ module Cardano.Api.Typed (
     secondsToNominalDiffTime,
 
     -- Testing purposes
-    AssetsBundle(..),
-    AssetIdBundle(..),
+    ValueNestedAsset(..),
+    ValueNestedRep(..),
     flatten,
     unflatten
   ) where

cardano-api/src/Cardano/Api/Value.hs

@@ -37,8 +37,8 @@ module Cardano.Api.Value
   , toShelleyLovelace
 
     -- * Intermediate Value representation
-  , AssetsBundle(..)
-  , AssetIdBundle(..)
+  , ValueNestedAsset(..)
+  , ValueNestedRep(..)
 
     -- * Exported for testing purposes
   , flatten
@@ -134,12 +134,12 @@ instance Monoid Value where
 instance ToJSON Value where
   toJSON = toJSON . unflatten
 
-unflatten :: Value -> AssetsBundle
+unflatten :: Value -> ValueNestedRep
 unflatten v@(Value flatMap) =
     -- unflatten all the non-ada assets, and add ada separately
-    AssetsBundle $
+    ValueNestedRep $
         [ AdaAsset q | let q = selectAsset v AdaAssetId, q /= 0 ]
-     ++ [ AssetIdBundle pId qs | (pId, qs) <- Map.toList nonAdaAssets ]
+     ++ [ ValueNestedAsset pId qs | (pId, qs) <- Map.toList nonAdaAssets ]
   where
     nonAdaAssets :: Map PolicyId (Map AssetName Quantity)
     nonAdaAssets =
@@ -150,32 +150,33 @@ unflatten v@(Value flatMap) =
 instance FromJSON Value where
   parseJSON jv = flatten <$> parseJSON jv
 
-flatten :: AssetsBundle -> Value
-flatten (AssetsBundle bundles) =
+flatten :: ValueNestedRep -> Value
+flatten (ValueNestedRep bundles) =
     Value $
       Map.fromList
         [ (aId, q)
         | bundle   <- bundles
         , (aId, q) <- case bundle of
                         AdaAsset          q  -> [ (AdaAssetId, q) ]
-                        AssetIdBundle pId qs -> [ (AssetId pId aName, q)
+                        ValueNestedAsset pId qs -> [ (AssetId pId aName, q)
                                                 | (aName, q) <- Map.toList qs ]
         ]
 
 -- | Intermediate representation used in the JSON parsing\/rendering of 'Value'
-newtype AssetsBundle = AssetsBundle [AssetIdBundle]
-                       deriving (Eq, Ord, Show)
+newtype ValueNestedRep = ValueNestedRep [ValueNestedAsset]
+                         deriving (Eq, Ord, Show)
 
-data AssetIdBundle = AssetIdBundle PolicyId (Map AssetName Quantity)
-                   | AdaAsset Quantity
-                   deriving (Eq, Ord, Show)
+data ValueNestedAsset
+  = ValueNestedAsset PolicyId (Map AssetName Quantity)
+  | AdaAsset Quantity
+  deriving (Eq, Ord, Show)
 
-instance ToJSON AssetsBundle where
-  toJSON (AssetsBundle bundles) = object $ map toPair bundles
+instance ToJSON ValueNestedRep where
+  toJSON (ValueNestedRep bundles) = object $ map toPair bundles
     where
-     toPair :: AssetIdBundle -> (Text, Aeson.Value)
+     toPair :: ValueNestedAsset -> (Text, Aeson.Value)
      toPair (AdaAsset q) = ("lovelace", toJSON q)
-     toPair (AssetIdBundle pid assets) = (renderPolicyId pid, toJSON assets)
+     toPair (ValueNestedAsset pid assets) = (renderPolicyId pid, toJSON assets)
 
      renderPolicyId :: PolicyId -> Text
      renderPolicyId (PolicyId sh) = Text.decodeUtf8 (serialiseToRawBytesHex sh)
@@ -204,20 +205,20 @@ instance FromJSONKey AssetName where
   fromJSONKey = FromJSONKeyText
                   $ \assetName -> AssetName $ Text.encodeUtf8 assetName
 
-instance FromJSON AssetsBundle where
-  parseJSON = withObject "AssetsBundle" $ \obj ->
-                AssetsBundle
+instance FromJSON ValueNestedRep where
+  parseJSON = withObject "ValueNestedRep" $ \obj ->
+                ValueNestedRep
                   <$> sequenceA [ parsePid keyValTuple | keyValTuple <- HashMap.toList obj ]
     where
-      parsePid :: (Text, Aeson.Value) -> Parser AssetIdBundle
+      parsePid :: (Text, Aeson.Value) -> Parser ValueNestedAsset
       parsePid (pid,q) =
         case pid of
           "lovelace" ->
             AdaAsset <$> parseJSON q
           other ->
             let pIdBS = Text.encodeUtf8 other
             in case deserialiseFromRawBytesHex AsScriptHash pIdBS of
-                 Just sHash -> AssetIdBundle (PolicyId sHash) <$> (parseJSON q)
+                 Just sHash -> ValueNestedAsset (PolicyId sHash) <$> (parseJSON q)
                  Nothing -> fail $ "Failure when deserialising PolicyId: "
                                  <> Text.unpack pid
 

cardano-api/test/Test/Cardano/Api/Typed/Gen.hs

@@ -171,23 +171,23 @@ genValue =
   valueFromList <$> Gen.list (Range.constant 0 10) ((,)
                 <$> genAssetId <*> genQuantity)
 
--- We do not generate duplicate keys as "AssetsBundle" is created via
+-- We do not generate duplicate keys as "ValueNestedRep" is created via
 -- flattening a 'Map'
-genAssetsBundle :: Gen AssetsBundle
-genAssetsBundle = Gen.choice [ AssetsBundle <$> Gen.list (Range.singleton 1) genAssetIdBundleValue
-                             , AssetsBundle <$> sequenceA [genAssetIdBundle, genAdaAssetIdBundle]
+genAssetsBundle :: Gen ValueNestedRep
+genAssetsBundle = Gen.choice [ ValueNestedRep <$> Gen.list (Range.singleton 1) genAssetIdBundleValue
+                             , ValueNestedRep <$> sequenceA [genAssetIdBundle, genAdaAssetIdBundle]
                              ]
 
-genAssetIdBundle :: Gen AssetIdBundle
+genAssetIdBundle :: Gen ValueNestedAsset
 genAssetIdBundle =
-  AssetIdBundle
+  ValueNestedAsset
     <$> genPolicyId
     <*> Gen.map (Range.singleton 1) ((,) <$> genAssetName <*> genQuantity)
 
-genAdaAssetIdBundle :: Gen AssetIdBundle
+genAdaAssetIdBundle :: Gen ValueNestedAsset
 genAdaAssetIdBundle = AdaAsset <$> genQuantity
 
-genAssetIdBundleValue :: Gen AssetIdBundle
+genAssetIdBundleValue :: Gen ValueNestedAsset
 genAssetIdBundleValue =
   Gen.choice [ genAssetIdBundle
              , genAdaAssetIdBundle

cardano-api/test/Test/Cardano/Api/Typed/Value.hs

@@ -26,16 +26,16 @@ prop_roundtrip_Value_unflatten_flatten =
   property $ do v <- forAll genValue
                 flatten (unflatten v) === v
 
--- Note when going from AssetsBundle -> Value (via flatten)
+-- Note when going from ValueNestedRep -> Value (via flatten)
 -- we merge maps, which combines all common keys. Therefore
--- we must generate an AssetsBundle with no duplicate values.
+-- we must generate an ValueNestedRep with no duplicate values.
 -- Remember that Maps cannot have duplicate keys and therefore
--- we will never unflatten (Value -> AssetsBundle) to an
--- AssetsBundle with duplicate values.
+-- we will never unflatten (Value -> ValueNestedRep) to a
+-- ValueNestedRep with duplicate values.
 prop_roundtrip_Value_flatten_unflatten :: Property
 prop_roundtrip_Value_flatten_unflatten =
-  property $ do aBundle@(AssetsBundle v) <- forAll genAssetsBundle
-                let AssetsBundle roundtripped = unflatten (flatten aBundle)
+  property $ do aBundle@(ValueNestedRep v) <- forAll genAssetsBundle
+                let ValueNestedRep roundtripped = unflatten (flatten aBundle)
                 sort roundtripped === sort v
 
 -- -----------------------------------------------------------------------------