From 60d7c52c268208614b95926088780241fc6f8086 Mon Sep 17 00:00:00 2001 From: alessandrokonrad Date: Fri, 9 Sep 2022 18:50:07 +0200 Subject: [PATCH] added some structs; added ToPlutusData --- Cargo.lock | 1 + crates/cli/Cargo.toml | 1 + crates/cli/src/utils.rs | 221 ++++++++++++++++++++++++++++------------ 3 files changed, 158 insertions(+), 65 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d453dad5..923a49aa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -11,6 +11,7 @@ dependencies = [ "hex", "pallas-addresses", "pallas-codec", + "pallas-crypto", "pallas-primitives", "pallas-traverse", "serde", diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 469ce34d..f8439e17 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -17,6 +17,7 @@ hex = "0.4.3" pallas-primitives = "0.13.2" pallas-codec = "0.13.2" pallas-traverse = "0.13.2" +pallas-crypto = "0.13.2" serde = { version = "1.0.144", features = ["derive"] } serde_json = "1.0.85" uplc = { path = '../uplc', version = "0.0.12" } diff --git a/crates/cli/src/utils.rs b/crates/cli/src/utils.rs index 6abc5085..a532e0e2 100644 --- a/crates/cli/src/utils.rs +++ b/crates/cli/src/utils.rs @@ -1,6 +1,12 @@ -use pallas_addresses::Address; +use pallas_addresses::{Address, PaymentKeyHash}; use pallas_codec::utils::{KeyValuePairs, MaybeIndefArray}; -use pallas_primitives::babbage::{BigInt, Constr}; +use pallas_crypto::hash::Hash; +use pallas_primitives::babbage::{ + BigInt, Certificate, Constr, DatumHash, PolicyId, PostAlonzoTransactionOutput, Redeemer, + StakeCredential, TransactionInput, Value, Withdrawals, +}; +use pallas_traverse::OutputRef; +use std::str::FromStr; use uplc::PlutusData; use crate::args::ResolvedInput; @@ -9,33 +15,14 @@ pub fn get_tx_in_info(resolved_inputs: &[ResolvedInput]) -> anyhow::Result 0, - 1 => 1, - _ => unreachable!(), - }; - let stake_tag = match address.typeid() { - 0 | 1 => Some(0), - 2 | 3 => Some(1), - _ => None, - }; - - let (payment_part, stake_part) = match address { - Address::Shelley(s) => (s.payment().to_vec(), s.delegation().to_vec()), - _ => unreachable!(), - }; - let lovelace = resolved_input.output.value.0; let mut assets = resolved_input.output.value.1.clone(); @@ -50,45 +37,7 @@ pub fn get_tx_in_info(resolved_inputs: &[ResolvedInput]) -> anyhow::Result vec![ - // StakingCredential - PlutusData::Constr(Constr { - tag: 0, - any_constructor: None, - fields: MaybeIndefArray::Indef(vec![ - // StakingHash - PlutusData::Constr(Constr { - tag: stake_tag, - any_constructor: None, - fields: MaybeIndefArray::Indef(vec![ - PlutusData::BoundedBytes(stake_part.into()), - ]), - }), - ]), - }), - ], - None => vec![], - }), - }), - ]), - }), + address.to_plutus_data(), // txOutValue PlutusData::Map(KeyValuePairs::Def( assets @@ -125,3 +74,145 @@ pub fn get_tx_in_info(resolved_inputs: &[ResolvedInput]) -> anyhow::Result posix time range + +type Slot = u64; +type PosixTime = u64; // in milliseconds + +type SlotRange = (Slot, Slot); +type PosixTimeRange = (PosixTime, PosixTime); + +struct SlotConfig { + slot_length: u64, + zero_time: PosixTime, +} + +fn slot_to_begin_posix_time(slot: Slot, sc: &SlotConfig) -> PosixTime { + let ms_after_begin = slot * sc.slot_length; + sc.zero_time + ms_after_begin +} + +fn slot_range_to_posix_time_range(slot_range: SlotRange, sc: &SlotConfig) -> PosixTimeRange { + ( + slot_to_begin_posix_time(slot_range.0, sc), + slot_to_begin_posix_time(slot_range.1, sc), + ) +} + +// --------------- + +pub trait ToPlutusData { + fn to_plutus_data(&self) -> PlutusData; +} + +impl ToPlutusData for Address { + fn to_plutus_data(&self) -> PlutusData { + //TOD: Byron address and reward address + + let payment_tag = match self.typeid() % 2 { + 0 => 0, + 1 => 1, + _ => unreachable!(), + }; + let stake_tag = match self.typeid() { + 0 | 1 => Some(0), + 2 | 3 => Some(1), + _ => None, + }; + + let (payment_part, stake_part) = match self { + Address::Shelley(s) => (s.payment().to_vec(), s.delegation().to_vec()), + _ => unreachable!(), + }; + + PlutusData::Constr(Constr { + tag: 0, + any_constructor: None, + fields: MaybeIndefArray::Indef(vec![ + // addressCredential + PlutusData::Constr(Constr { + tag: payment_tag, + any_constructor: None, + fields: MaybeIndefArray::Indef(vec![PlutusData::BoundedBytes( + payment_part.into(), + )]), + }), + // addressStakingCredential + PlutusData::Constr(Constr { + tag: if stake_tag.is_some() { 0 } else { 1 }, + any_constructor: None, + fields: MaybeIndefArray::Indef(match stake_tag { + Some(stake_tag) => vec![ + // StakingCredential + PlutusData::Constr(Constr { + tag: 0, + any_constructor: None, + fields: MaybeIndefArray::Indef(vec![ + // StakingHash + PlutusData::Constr(Constr { + tag: stake_tag, + any_constructor: None, + fields: MaybeIndefArray::Indef(vec![ + PlutusData::BoundedBytes(stake_part.into()), + ]), + }), + ]), + }), + ], + None => vec![], + }), + }), + ]), + }) + } +} + +impl ToPlutusData for TransactionInput { + fn to_plutus_data(&self) -> PlutusData { + PlutusData::Constr(Constr { + tag: 0, + any_constructor: None, + fields: MaybeIndefArray::Indef(vec![ + PlutusData::BoundedBytes(hex::decode(self.transaction_id.clone()).unwrap().into()), + PlutusData::BigInt(BigInt::Int(self.index.into())), + ]), + }) + } +} + +// impl ToPlutusData for LegacyTransactionOutput { +// fn to_plutus_data(&self) -> PlutusData {} +// } + +// impl ToPlutusData for PostAlonzoTransactionOutput { +// fn to_plutus_data(&self) -> PlutusData {} +// } + +pub struct TxInInfo { + out_ref: OutputRef, + resolved: PostAlonzoTransactionOutput, +} + +// Plutus V2 +pub enum ScriptPurpose { + Minting(PolicyId), + Spending(OutputRef), + Reward(StakeCredential), + Certifying(Certificate), +} + +pub struct TxInfo { + inputs: Vec, + reference_inputs: Vec, + outputs: Vec, + fee: Value, + mint: Value, + dcert: Vec, + wdrl: Withdrawals, + valid_range: PosixTimeRange, + signatories: Vec, + redeemers: KeyValuePairs, + data: KeyValuePairs, + id: Hash<32>, +}