* Same logic for Shelley, ShelleyMA and Alonzo is now in new `filterOutputsAttrsTooBig`, which has improved performance * Also optimize `vKeyLocked`
import Cardano.Ledger.Address
( Addr (..),
RewardAcnt,
bootstrapAddressAttrsSize,
getNetwork,
getRwdNetwork,
)
systemStart,
)
import Cardano.Ledger.Coin
import Cardano.Ledger.CompactAddress
( CompactAddr,
isBootstrapCompactAddr,
isPayCredScriptCompactAddr,
)
import qualified Cardano.Ledger.Core as Core
import Cardano.Ledger.Credential (Credential (..))
import qualified Cardano.Ledger.Crypto as CC
import Cardano.Ledger.Era (Era (..), ValidateScript (..))
import qualified Cardano.Ledger.Era as Era
import Cardano.Ledger.Rules.ValidationMode ((?!#))
import Cardano.Ledger.Shelley.Constraints
( UsesPParams,
)
import Cardano.Ledger.Shelley.Constraints (UsesPParams)
import qualified Cardano.Ledger.Shelley.LedgerState as Shelley
import qualified Cardano.Ledger.Shelley.Rules.Utxo as Shelley
import Cardano.Ledger.Shelley.Tx (TxIn)
isKeyHashAddr (Addr _ (KeyHashObj _) _) = True
isKeyHashAddr _ = False
-- | This is equivalent to `isKeyHashAddr`, but for compacted version of an address.
isKeyHashCompactAddr :: CompactAddr crypto -> Bool
isKeyHashCompactAddr cAddr =
isBootstrapCompactAddr cAddr || not (isPayCredScriptCompactAddr cAddr)
vKeyLocked :: Era era => Core.TxOut era -> Bool
vKeyLocked txout = isKeyHashAddr (getTxOutAddr txout)
vKeyLocked txOut =
case getTxOutEitherAddr txOut of
Left addr -> isKeyHashAddr addr
Right cAddr -> isKeyHashCompactAddr cAddr
-- | feesOK is a predicate with several parts. Some parts only apply in special circumstances.
-- 1) The fee paid is >= the minimum fee
null outputsTooBig ?! OutputTooBigUTxO outputsTooBig
{- ∀ ( _ ↦ (a,_)) ∈ txoutstxb, a ∈ Addrbootstrap → bootstrapAttrsSize a ≤ 64 -}
-- Bootstrap (i.e. Byron) addresses have variable sized attributes in them.
-- It is important to limit their overall size.
let outputsAttrsTooBig =
filter
( \out -> case getTxOutAddr out of
AddrBootstrap addr -> bootstrapAddressAttrsSize addr > 64
_ -> False
)
(SplitMap.elems outputs)
let outputsAttrsTooBig = Shelley.filterOutputsAttrsTooBig outputs
null outputsAttrsTooBig ?!# OutputBootAddrAttrsTooBig outputsAttrsTooBig
{- ∀(_ ↦ (a,_)) ∈ txouts txb, netId a = NetworkId -}
import Cardano.Binary (ToCBOR (toCBOR), serializeEncoding')
import Cardano.Ledger.Address (Addr (..))
import Cardano.Ledger.Alonzo (AlonzoEra)
import Cardano.Ledger.Alonzo.Rules.Utxo (vKeyLocked)
import Cardano.Ledger.Alonzo.Data as Alonzo (AuxiliaryData (..), Data (..), DataHash)
import Cardano.Ledger.Alonzo.Language (Language (..))
import Cardano.Ledger.Alonzo.PParams (PParams' (..))
-- ============================================================
isKeyHashAddr :: Addr crypto -> Bool
isKeyHashAddr (AddrBootstrap _) = True
isKeyHashAddr (Addr _ (KeyHashObj _) _) = True
isKeyHashAddr _ = False
-- | We are choosing new TxOut to pay fees, We want only Key locked addresss with Ada only values.
vKeyLocked :: Mock c => Core.TxOut (AlonzoEra c) -> Bool
vKeyLocked txout =
isKeyHashAddr (getTxOutAddr txout) && adaOnly (getField @"value" txout)
vKeyLockedAdaOnly :: Mock c => Core.TxOut (AlonzoEra c) -> Bool
vKeyLockedAdaOnly txout = vKeyLocked txout && adaOnly (getField @"value" txout)
phase2scripts3Arg :: forall c. Mock c => [TwoPhase3ArgInfo (AlonzoEra c)]
phase2scripts3Arg =
okAsCollateral utxo inputx =
case SplitMap.lookup inputx (unUTxO utxo) of
Nothing -> False
Just outputx -> vKeyLocked outputx
Just outputx -> vKeyLockedAdaOnly outputx
genAlonzoTxBody ::
forall c.
(isNativeScript @(AlonzoEra c) script)
|| (phase2scripts3ArgSucceeds script && phase2scripts2ArgSucceeds script)
genEraGoodTxOut = vKeyLocked
genEraGoodTxOut = vKeyLockedAdaOnly
genEraScriptCost pp script =
if isPlutusScript script
instance Mock c => Arbitrary (UtxoPredicateFailure (AlonzoEra c)) where
arbitrary =
oneof
[ (BadInputsUTxO) <$> arbitrary,
[ BadInputsUTxO <$> arbitrary,
OutsideValidityIntervalUTxO <$> arbitrary <*> arbitrary,
MaxTxSizeUTxO <$> arbitrary <*> arbitrary,
pure InputSetEmptyUTxO,
FeeTooSmallUTxO <$> arbitrary <*> arbitrary,
(ValueNotConservedUTxO) <$> arbitrary <*> arbitrary,
(OutputTooSmallUTxO) <$> arbitrary,
(UtxosFailure) <$> arbitrary,
(WrongNetwork) <$> arbitrary <*> arbitrary,
(WrongNetworkWithdrawal) <$> arbitrary <*> arbitrary,
(OutputBootAddrAttrsTooBig) <$> arbitrary,
ValueNotConservedUTxO <$> arbitrary <*> arbitrary,
OutputTooSmallUTxO <$> arbitrary,
UtxosFailure <$> arbitrary,
WrongNetwork <$> arbitrary <*> arbitrary,
WrongNetworkWithdrawal <$> arbitrary <*> arbitrary,
OutputBootAddrAttrsTooBig <$> arbitrary,
pure TriesToForgeADA,
(OutputTooBigUTxO) <$> arbitrary,
OutputTooBigUTxO <$> arbitrary,
InsufficientCollateral <$> arbitrary <*> arbitrary,
ScriptsNotPaidUTxO <$> arbitrary,
ExUnitsTooBigUTxO <$> arbitrary <*> arbitrary,
module Cardano.Ledger.ShelleyMA.Rules.Utxo where
import Cardano.Binary (FromCBOR (..), ToCBOR (..), encodeListLen, serialize)
import Cardano.Ledger.Address
( Addr (AddrBootstrap),
bootstrapAddressAttrsSize,
getNetwork,
)
import Cardano.Ledger.Address (Addr, getNetwork)
import Cardano.Ledger.BaseTypes
( Network,
ShelleyBase,
(SplitMap.elems outputs)
null outputsTooBig ?! OutputTooBigUTxO outputsTooBig
-- Bootstrap (i.e. Byron) addresses have variable sized attributes in them.
-- It is important to limit their overall size.
let outputsAttrsTooBig =
filter
( \out -> case getTxOutAddr out of
AddrBootstrap addr -> bootstrapAddressAttrsSize addr > 64
_ -> False
)
(SplitMap.elems outputs)
let outputsAttrsTooBig = Shelley.filterOutputsAttrsTooBig outputs
null outputsAttrsTooBig ?! OutputBootAddrAttrsTooBig outputsAttrsTooBig
let maxTxSize_ = fromIntegral (getField @"_maxTxSize" pp)
UtxoEvent (..),
PredicateFailure,
updateUTxOState,
filterOutputsAttrsTooBig,
)
where
)
import Cardano.Ledger.Coin (Coin (..))
import qualified Cardano.Ledger.Core as Core
import Cardano.Ledger.Era (Era (..))
import Cardano.Ledger.Era (Era (..), getTxOutBootstrapAddress)
import Cardano.Ledger.Keys (GenDelegs, KeyHash, KeyRole (..))
import Cardano.Ledger.Serialization
( decodeList,
(SplitMap.elems outputs)
null outputsTooSmall ?! OutputTooSmallUTxO outputsTooSmall
-- Bootstrap (i.e. Byron) addresses have variable sized attributes in them.
-- It is important to limit their overall size.
let outputsAttrsTooBig =
filter
( \x -> case getTxOutAddr x of
AddrBootstrap addr -> bootstrapAddressAttrsSize addr > 64
_ -> False
)
(SplitMap.elems outputs)
let outputsAttrsTooBig = filterOutputsAttrsTooBig outputs
null outputsAttrsTooBig ?! OutputBootAddrAttrsTooBig outputsAttrsTooBig
let maxTxSize_ = fromIntegral (getField @"_maxTxSize" pp)
let depositChange = totalDeposits' <-> refunded
pure $! updateUTxOState u txb depositChange ppup'
-- | Bootstrap (i.e. Byron) addresses have variable sized attributes in them.
-- It is important to limit their overall size.
--
-- > ∀ ( _ ↦ (a,_)) ∈ txoutstxb, a ∈ Addrbootstrap → bootstrapAttrsSize a ≤ 64
filterOutputsAttrsTooBig ::
Era era => SplitMap.SplitMap k (Core.TxOut era) -> [Core.TxOut era]
filterOutputsAttrsTooBig outputs =
filter
( \txOut ->
case getTxOutBootstrapAddress txOut of
Just addr -> bootstrapAddressAttrsSize addr > 64
_ -> False
)
(SplitMap.elems outputs)
updateUTxOState ::
(Era era, HasField "inputs" (Core.TxBody era) (Set (TxIn (Crypto era)))) =>
UTxOState era ->
decompactAddr,
CompactAddr (..),
substring,
isPayCredScriptCompactAddr,
isBootstrapCompactAddr,
)
where
True -> getScriptHash
False -> getKeyHash
-- | Efficiently check whether compated adddress is an address with a credential
-- that is a payment script.
isPayCredScriptCompactAddr :: CompactAddr crypto -> Bool
isPayCredScriptCompactAddr (UnsafeCompactAddr bytes) =
testBit (SBS.index bytes 0) payCredIsScript
-- | Efficiently check whether compated adddress is a Byron address.
isBootstrapCompactAddr :: CompactAddr crypto -> Bool
isBootstrapCompactAddr (UnsafeCompactAddr bytes) = testBit (SBS.index bytes 0) byron
Other small changes include: * Added a trace event `TDBInitialisingFromLMDBDone`. * Initialisation from an existing LMDB database does not rely on the default `LMDBLimits` anymore, and is passed a limits argument instead. TODO: We should decide whether we want to hardcode these limits to a a substantially large one, or possibly we could link these limits to a versioning number?
add cwbtc
attempt implementation
Other small changes include: * Added a trace event `TDBInitialisingFromLMDBDone`. * Initialisation from an existing LMDB database does not rely on the default `LMDBLimits` anymore, and is passed a limits argument instead. TODO: We should decide whether we want to hardcode these limits to a a substantially large one, or possibly we could link these limits to a versioning number?
![iohk-bors[bot]](https://avatars.githubusercontent.com/in/17473?v=4&s=80)
Updated crypto exchange rates chapter. I tried my best to address @rdlrt concerns. I would like to add that English is just my 3rd language, so I hope it is not too bad.
Previously, the sequence number of the database is written to disk as part of the on-disk database settings on every flush/write. Conceptually however, the settings of a database should not change on every flush or write. Instead, we make a dinstinction between on-disk database "settings" and "state", where the state can be updated in every write/flush, but the settings should generally be left untouched after database initialisation or node start-up.
Fixes #217.
This works because (a) JavaScript is ultimately single-threaded, (b) there's no execution preemption happening between a 'send' and a 'wait'.
This was using the raw Show instance of queries, which looks real bad for constructors with arity > 1 like HasTx.