{-# LANGUAGE DataKinds #-}

{- |
Module      : Singular.Registry.Ledger
Description : Cardano ledger type re-exports
License     : Apache-2.0

Central type vocabulary for the cage transaction
builders. Re-exports ledger types (Conway era) and
defines domain types that bridge the gap between
cardano-ledger representations and the Aiken
on-chain validator layout.
-}
module Singular.Registry.Ledger
    ( -- * Ledger re-exports
      ConwayEra
    , Addr
    , TxId
    , TxIn
    , TxOut
    , Coin (..)
    , MaryValue
    , PolicyID (..)
    , AssetName (..)
    , SlotNo (..)
    , ScriptHash (..)
    , KeyHash
    , KeyRole (..)
    , ExUnits (..)
    , PParams
    , ConwayTxBody

      -- * Token identification
    , TokenId (..)

      -- * Merkle Patricia Forestry
    , Root (..)

      -- * Token state
    , TokenState (..)
    ) where

import Data.ByteString (ByteString)

import Cardano.Ledger.Address (Addr)
import Cardano.Ledger.Alonzo.Core (TopTx, TxBody)
import Cardano.Ledger.Api.Tx.Out (TxOut)
import Cardano.Ledger.Coin (Coin (..))
import Cardano.Ledger.Conway (ConwayEra)
import Cardano.Ledger.Core (PParams)
import Cardano.Ledger.Hashes (ScriptHash (..))
import Cardano.Ledger.Keys (KeyHash, KeyRole (..))
import Cardano.Ledger.Mary.Value
    ( AssetName (..)
    , MaryValue
    , PolicyID (..)
    )
import Cardano.Ledger.Plutus.ExUnits (ExUnits (..))
import Cardano.Ledger.Slot (SlotNo (..))
import Cardano.Ledger.TxIn (TxId, TxIn)

-- | Conway-era top-level transaction body.
type ConwayTxBody = TxBody TopTx ConwayEra

{- | Unique identifier for a token managed by the
cage. Corresponds to the on-chain asset name
derived from SHA2-256(txId ++ index).
-}
newtype TokenId = TokenId
    { TokenId -> AssetName
unTokenId :: AssetName
    }
    deriving (TokenId -> TokenId -> Bool
(TokenId -> TokenId -> Bool)
-> (TokenId -> TokenId -> Bool) -> Eq TokenId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TokenId -> TokenId -> Bool
== :: TokenId -> TokenId -> Bool
$c/= :: TokenId -> TokenId -> Bool
/= :: TokenId -> TokenId -> Bool
Eq, Eq TokenId
Eq TokenId =>
(TokenId -> TokenId -> Ordering)
-> (TokenId -> TokenId -> Bool)
-> (TokenId -> TokenId -> Bool)
-> (TokenId -> TokenId -> Bool)
-> (TokenId -> TokenId -> Bool)
-> (TokenId -> TokenId -> TokenId)
-> (TokenId -> TokenId -> TokenId)
-> Ord TokenId
TokenId -> TokenId -> Bool
TokenId -> TokenId -> Ordering
TokenId -> TokenId -> TokenId
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 :: TokenId -> TokenId -> Ordering
compare :: TokenId -> TokenId -> Ordering
$c< :: TokenId -> TokenId -> Bool
< :: TokenId -> TokenId -> Bool
$c<= :: TokenId -> TokenId -> Bool
<= :: TokenId -> TokenId -> Bool
$c> :: TokenId -> TokenId -> Bool
> :: TokenId -> TokenId -> Bool
$c>= :: TokenId -> TokenId -> Bool
>= :: TokenId -> TokenId -> Bool
$cmax :: TokenId -> TokenId -> TokenId
max :: TokenId -> TokenId -> TokenId
$cmin :: TokenId -> TokenId -> TokenId
min :: TokenId -> TokenId -> TokenId
Ord, Int -> TokenId -> ShowS
[TokenId] -> ShowS
TokenId -> String
(Int -> TokenId -> ShowS)
-> (TokenId -> String) -> ([TokenId] -> ShowS) -> Show TokenId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TokenId -> ShowS
showsPrec :: Int -> TokenId -> ShowS
$cshow :: TokenId -> String
show :: TokenId -> String
$cshowList :: [TokenId] -> ShowS
showList :: [TokenId] -> ShowS
Show)

{- | MPF root hash representing the current state
of a trie (32 bytes Blake2b-256).
-}
newtype Root = Root
    { Root -> ByteString
unRoot :: ByteString
    }
    deriving (Root -> Root -> Bool
(Root -> Root -> Bool) -> (Root -> Root -> Bool) -> Eq Root
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Root -> Root -> Bool
== :: Root -> Root -> Bool
$c/= :: Root -> Root -> Bool
/= :: Root -> Root -> Bool
Eq, Int -> Root -> ShowS
[Root] -> ShowS
Root -> String
(Int -> Root -> ShowS)
-> (Root -> String) -> ([Root] -> ShowS) -> Show Root
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Root -> ShowS
showsPrec :: Int -> Root -> ShowS
$cshow :: Root -> String
show :: Root -> String
$cshowList :: [Root] -> ShowS
showList :: [Root] -> ShowS
Show)

-- #183: the `Operation` domain type and the `Request` record that
-- carried it are gone with the wire they described. Nothing read them —
-- the encoders work on `Singular.Registry.Types.OnChainRequest`, whose
-- request states an edge index and a deposit.

-- | Current on-chain state of a token.
data TokenState = TokenState
    { TokenState -> KeyHash Payment
owner :: !(KeyHash Payment)
    -- ^ Owner's payment key hash
    , TokenState -> Root
root :: !Root
    -- ^ Current root hash of the token's trie
    , TokenState -> Coin
tip :: !Coin
    -- ^ Maximum fee charged per request
    , TokenState -> Integer
processTime :: !Integer
    -- ^ Duration (ms) of the oracle processing window
    , TokenState -> Integer
retractTime :: !Integer
    -- ^ Duration (ms) of the requester retract window
    }
    deriving (TokenState -> TokenState -> Bool
(TokenState -> TokenState -> Bool)
-> (TokenState -> TokenState -> Bool) -> Eq TokenState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TokenState -> TokenState -> Bool
== :: TokenState -> TokenState -> Bool
$c/= :: TokenState -> TokenState -> Bool
/= :: TokenState -> TokenState -> Bool
Eq, Int -> TokenState -> ShowS
[TokenState] -> ShowS
TokenState -> String
(Int -> TokenState -> ShowS)
-> (TokenState -> String)
-> ([TokenState] -> ShowS)
-> Show TokenState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TokenState -> ShowS
showsPrec :: Int -> TokenState -> ShowS
$cshow :: TokenState -> String
show :: TokenState -> String
$cshowList :: [TokenState] -> ShowS
showList :: [TokenState] -> ShowS
Show)