Not needed, but was handy for observing commit. Removing it makes on-chain validations easier / less error prone.
serializedUtxo = case utxo of
Nothing ->
Nothing
Just (i, o) ->
Just
( Commit.SerializedTxOutRef (toBuiltin $ serialize' $ Api.toLedgerTxIn i)
, Commit.SerializedTxOut (toBuiltin $ serialize' $ Api.toLedgerTxOut o)
)
Just (_i, o) ->
Just $ Commit.SerializedTxOut (toBuiltin $ serialize' $ Api.toLedgerTxOut o)
-- | Create a transaction collecting all "committed" utxo and opening a Head,
-- i.e. driving the Head script state.
convertParty = Party . partyToVerKey
-- | Identify a commit tx by looking for an output which pays to v_commit.
--
-- To reconstruct a commit from a commit transaction we need to:
--
-- - Find out which 'initials' is being committed
-- - Find the redeemer corresponding to that 'initial' which contain the
-- output-reference of the commit
-- - Find the outputs which pays to the commit validator
-- - Extract the datum of that output, which contains the output of the commit
-- - Reconstruct the committed UTXO from both values (output ref and output).
observeCommitTx ::
NetworkId ->
-- TODO: This type may be too large for this function, we only probably need
-- just the TxIn.
[TxIn] ->
CardanoTx ->
Maybe (OnChainTx CardanoTx, (TxIn, TxOut CtxUTxO Era, ScriptData))
observeCommitTx networkId (getTxBody -> txBody) = do
observeCommitTx networkId initials (getTxBody -> txBody) = do
let ins = filterTxIn (`elem` initials) txBody
(commitIn, commitOut) <- findTxOutByAddress commitAddress txBody
dat <- getDatum commitOut
(party, _, committedUtxo) <- fromData @(DatumType Commit.Commit) $ toPlutusData dat
convertedUtxo <- convertUtxo committedUtxo
(party, _, serializedTxOut) <- fromData @(DatumType Commit.Commit) $ toPlutusData dat
convertedTxOut <- convertTxOut serializedTxOut
let onChainTx = OnCommitTx (convertParty party) convertedUtxo
pure (onChainTx, (commitIn, toCtxUTxOTxOut commitOut, dat))
where
convertUtxo :: Maybe (Commit.SerializedTxOutRef, Commit.SerializedTxOut) -> Maybe Utxo
convertUtxo = \case
convertTxOut :: Maybe Commit.SerializedTxOut -> Maybe (TxOut CtxTx Era)
convertTxOut = \case
Nothing -> Just mempty
Just (Commit.SerializedTxOutRef inBytes, Commit.SerializedTxOut outBytes) ->
Just (Commit.SerializedTxOut outBytes) ->
-- XXX(SN): these errors might be more severe and we could throw an
-- exception here?
eitherToMaybe $ do
txIn <- fromLedgerTxIn <$> decodeFull' (fromBuiltin inBytes)
txOut <- fromLedgerTxOut <$> decodeFull' (fromBuiltin outBytes)
pure $ singletonUtxo (txIn, txOut)
eitherToMaybe $ decodeFull' (fromBuiltin outBytes)
commitAddress = mkScriptAddress @PlutusScriptV1 networkId commitScript
Maybe (OnChainTx CardanoTx, OnChainHeadState)
observeCommit networkId tx = \case
Initial{threadOutput, initials, commits} -> do
(onChainTx, commitTriple) <- observeCommitTx networkId tx
(onChainTx, commitTriple) <- observeCommitTx networkId initials tx
-- NOTE(SN): A commit tx has been observed and thus we can remove all it's
-- inputs from our tracked initials
let commitIns = inputs tx
inputs (Tx (ShelleyTxBody _ body _ _ _ _) _) =
fromLedgerTxIn <$> toList (Ledger.Alonzo.inputs body)
-- | Filter txins of a transaction given the predicate.
filterTxIn :: (TxIn -> Bool) -> TxBody Era -> [TxIn]
filterTxIn fn (TxBody body) =
filter fn (fst <$> txIns body)
-- ** TxOut
-- XXX(SN): replace with Cardano.Api.TxBody.lovelaceToTxOutValue when available
data Commit
newtype SerializedTxOutRef = SerializedTxOutRef BuiltinByteString
PlutusTx.unstableMakeIsData ''SerializedTxOutRef
newtype SerializedTxOut = SerializedTxOut BuiltinByteString
PlutusTx.unstableMakeIsData ''SerializedTxOut
-- Ideally, since the TxOutRef is already present in the redeemer for the
-- initial validator, the off-chain code could get it from there.
instance Scripts.ValidatorTypes Commit where
type DatumType Commit = (Party, ValidatorHash, Maybe (SerializedTxOutRef, SerializedTxOut))
type DatumType Commit = (Party, ValidatorHash, Maybe SerializedTxOut)
type RedeemerType Commit = ()
validator :: DatumType Commit -> RedeemerType Commit -> ScriptContext -> Bool
lookupCommit h = do
d <- getDatum <$> findDatum h txInfo
case fromBuiltinData @(DatumType Commit) d of
Just (_p, _, Just (_, o)) ->
Just (_p, _, Just o) ->
Just o
Just (_p, _, Nothing) ->
Nothing
import Ledger hiding (validatorHash)
import PlutusTx.Prelude
import Hydra.Contract.Commit (SerializedTxOut (SerializedTxOut), SerializedTxOutRef)
import Hydra.Contract.Commit (SerializedTxOut (..))
import qualified Hydra.Contract.Commit as Commit
import Hydra.Contract.Encoding (encodeTxOut)
import Hydra.Data.Party (Party)
case getDatum <$> findDatum dh txInfo of
Nothing -> traceError "Invalid datum hash with no datum"
(Just da) ->
case fromBuiltinData @(Party, ValidatorHash, Maybe (SerializedTxOutRef, SerializedTxOut)) da of
case fromBuiltinData @(Party, ValidatorHash, Maybe SerializedTxOut) da of
Just (_party, _headScriptHash, Nothing) ->
traceIfFalse "committed UTXO is not in output datum" $ isNothing committedRef
Just (_party, _headScriptHash, Just (_serialisedTxOutRef, serialisedTxOut)) ->
Just (_party, _headScriptHash, Just serialisedTxOut) ->
case txInInfoResolved <$> committedTxOut of
Nothing -> traceError "unexpected UTXO in output datum"
Just txOut ->
maybe mempty (txOutValue . txInInfoResolved) $ findOwnInput context
committedValue =
maybe mempty (txOutValue . txInInfoResolved) $ committedTxOut
maybe mempty (txOutValue . txInInfoResolved) committedTxOut
committedTxOut = do
ref <- committedRef
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.