{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}

module Cardano.Chain.Common.Compact (
  CompactAddress,
  toCompactAddress,
  fromCompactAddress,
  unsafeGetCompactAddress,
) where

import Cardano.Chain.Common.Address (Address (..))
import Cardano.HeapWords (HeapWords)
import Cardano.Ledger.Binary (
  DecCBOR (..),
  EncCBOR (..),
  FromCBOR (..),
  ToCBOR (..),
  byronProtVer,
  decodeFull',
  fromByronCBOR,
  serialize',
  toByronCBOR,
 )
import Cardano.Prelude
import Data.ByteString.Short (ShortByteString)
import qualified Data.ByteString.Short as BSS (fromShort, toShort)
import NoThunks.Class (NoThunks (..))

--------------------------------------------------------------------------------
-- Compact Address
--------------------------------------------------------------------------------

-- | A compact in-memory representation for an 'Address'.
--
-- Convert using 'toCompactAddress' and 'fromCompactAddress'.
newtype CompactAddress = CompactAddress ShortByteString
  deriving (CompactAddress -> CompactAddress -> Bool
(CompactAddress -> CompactAddress -> Bool)
-> (CompactAddress -> CompactAddress -> Bool) -> Eq CompactAddress
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompactAddress -> CompactAddress -> Bool
== :: CompactAddress -> CompactAddress -> Bool
$c/= :: CompactAddress -> CompactAddress -> Bool
/= :: CompactAddress -> CompactAddress -> Bool
Eq, Eq CompactAddress
Eq CompactAddress =>
(CompactAddress -> CompactAddress -> Ordering)
-> (CompactAddress -> CompactAddress -> Bool)
-> (CompactAddress -> CompactAddress -> Bool)
-> (CompactAddress -> CompactAddress -> Bool)
-> (CompactAddress -> CompactAddress -> Bool)
-> (CompactAddress -> CompactAddress -> CompactAddress)
-> (CompactAddress -> CompactAddress -> CompactAddress)
-> Ord CompactAddress
CompactAddress -> CompactAddress -> Bool
CompactAddress -> CompactAddress -> Ordering
CompactAddress -> CompactAddress -> CompactAddress
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CompactAddress -> CompactAddress -> Ordering
compare :: CompactAddress -> CompactAddress -> Ordering
$c< :: CompactAddress -> CompactAddress -> Bool
< :: CompactAddress -> CompactAddress -> Bool
$c<= :: CompactAddress -> CompactAddress -> Bool
<= :: CompactAddress -> CompactAddress -> Bool
$c> :: CompactAddress -> CompactAddress -> Bool
> :: CompactAddress -> CompactAddress -> Bool
$c>= :: CompactAddress -> CompactAddress -> Bool
>= :: CompactAddress -> CompactAddress -> Bool
$cmax :: CompactAddress -> CompactAddress -> CompactAddress
max :: CompactAddress -> CompactAddress -> CompactAddress
$cmin :: CompactAddress -> CompactAddress -> CompactAddress
min :: CompactAddress -> CompactAddress -> CompactAddress
Ord, (forall x. CompactAddress -> Rep CompactAddress x)
-> (forall x. Rep CompactAddress x -> CompactAddress)
-> Generic CompactAddress
forall x. Rep CompactAddress x -> CompactAddress
forall x. CompactAddress -> Rep CompactAddress x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CompactAddress -> Rep CompactAddress x
from :: forall x. CompactAddress -> Rep CompactAddress x
$cto :: forall x. Rep CompactAddress x -> CompactAddress
to :: forall x. Rep CompactAddress x -> CompactAddress
Generic, Int -> CompactAddress -> ShowS
[CompactAddress] -> ShowS
CompactAddress -> String
(Int -> CompactAddress -> ShowS)
-> (CompactAddress -> String)
-> ([CompactAddress] -> ShowS)
-> Show CompactAddress
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompactAddress -> ShowS
showsPrec :: Int -> CompactAddress -> ShowS
$cshow :: CompactAddress -> String
show :: CompactAddress -> String
$cshowList :: [CompactAddress] -> ShowS
showList :: [CompactAddress] -> ShowS
Show)
  deriving newtype (CompactAddress -> Int
(CompactAddress -> Int) -> HeapWords CompactAddress
forall a. (a -> Int) -> HeapWords a
$cheapWords :: CompactAddress -> Int
heapWords :: CompactAddress -> Int
HeapWords, Context -> CompactAddress -> IO (Maybe ThunkInfo)
Proxy CompactAddress -> String
(Context -> CompactAddress -> IO (Maybe ThunkInfo))
-> (Context -> CompactAddress -> IO (Maybe ThunkInfo))
-> (Proxy CompactAddress -> String)
-> NoThunks CompactAddress
forall a.
(Context -> a -> IO (Maybe ThunkInfo))
-> (Context -> a -> IO (Maybe ThunkInfo))
-> (Proxy a -> String)
-> NoThunks a
$cnoThunks :: Context -> CompactAddress -> IO (Maybe ThunkInfo)
noThunks :: Context -> CompactAddress -> IO (Maybe ThunkInfo)
$cwNoThunks :: Context -> CompactAddress -> IO (Maybe ThunkInfo)
wNoThunks :: Context -> CompactAddress -> IO (Maybe ThunkInfo)
$cshowTypeOf :: Proxy CompactAddress -> String
showTypeOf :: Proxy CompactAddress -> String
NoThunks)
  deriving anyclass (CompactAddress -> ()
(CompactAddress -> ()) -> NFData CompactAddress
forall a. (a -> ()) -> NFData a
$crnf :: CompactAddress -> ()
rnf :: CompactAddress -> ()
NFData)

instance ToCBOR CompactAddress where
  toCBOR :: CompactAddress -> Encoding
toCBOR = CompactAddress -> Encoding
forall a. EncCBOR a => a -> Encoding
toByronCBOR

instance FromCBOR CompactAddress where
  fromCBOR :: forall s. Decoder s CompactAddress
fromCBOR = Decoder s CompactAddress
forall a s. DecCBOR a => Decoder s a
fromByronCBOR

instance DecCBOR CompactAddress where
  decCBOR :: forall s. Decoder s CompactAddress
decCBOR = ShortByteString -> CompactAddress
CompactAddress (ShortByteString -> CompactAddress)
-> (ByteString -> ShortByteString) -> ByteString -> CompactAddress
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. ByteString -> ShortByteString
BSS.toShort (ByteString -> CompactAddress)
-> Decoder s ByteString -> Decoder s CompactAddress
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Decoder s ByteString
forall s. Decoder s ByteString
forall a s. DecCBOR a => Decoder s a
decCBOR

instance EncCBOR CompactAddress where
  encCBOR :: CompactAddress -> Encoding
encCBOR (CompactAddress ShortByteString
sbs) = ByteString -> Encoding
forall a. EncCBOR a => a -> Encoding
encCBOR (ShortByteString -> ByteString
BSS.fromShort ShortByteString
sbs)

toCompactAddress :: Address -> CompactAddress
toCompactAddress :: Address -> CompactAddress
toCompactAddress Address
addr =
  ShortByteString -> CompactAddress
CompactAddress (ByteString -> ShortByteString
BSS.toShort (Version -> Address -> ByteString
forall a. EncCBOR a => Version -> a -> ByteString
serialize' Version
byronProtVer Address
addr))

fromCompactAddress :: CompactAddress -> Address
fromCompactAddress :: CompactAddress -> Address
fromCompactAddress (CompactAddress ShortByteString
addr) =
  case Version -> ByteString -> Either DecoderError Address
forall a.
DecCBOR a =>
Version -> ByteString -> Either DecoderError a
decodeFull' Version
byronProtVer (ShortByteString -> ByteString
BSS.fromShort ShortByteString
addr) of
    Left DecoderError
err -> Text -> Address
forall a. HasCallStack => Text -> a
panic (Text
"fromCompactAddress: impossible: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> DecoderError -> Text
forall a b. (Show a, ConvertText String b) => a -> b
show DecoderError
err)
    Right Address
decAddr -> Address
decAddr

unsafeGetCompactAddress :: CompactAddress -> ShortByteString
unsafeGetCompactAddress :: CompactAddress -> ShortByteString
unsafeGetCompactAddress (CompactAddress ShortByteString
sbs) = ShortByteString
sbs