Sulkta-OSS/pallas
3
0
Fork 0
Code Issues 1 Pull requests 4 Projects Releases Packages Wiki Activity Actions

feat(interop): add ledger context for utxorpc mapping logic (#450)

Browse source 
Co-authored-by: Aleksandar Djuric <aleksandardjuric@alethea.io>
This commit is contained in:
aleksandar 2024-05-14 06:19:04 -04:00 • committed by GitHub
parent 1a927ee1a0
commit 5a299ce049
2 changed files with 486 additions and 435 deletions
Download patch file Download diff file Expand all files Collapse all files

1
pallas-utxorpc/Cargo.toml
View file

@ -14,6 +14,7 @@ authors = ["Santiago Carmuega <santiago@carmuega.me>"]
pallas-traverse = { version = "=0.25.0", path = "../pallas-traverse" } pallas-traverse = { version = "=0.25.0", path = "../pallas-traverse" }
pallas-primitives = { version = "=0.25.0", path = "../pallas-primitives" } pallas-primitives = { version = "=0.25.0", path = "../pallas-primitives" }
pallas-codec = { version = "=0.25.0", path = "../pallas-codec" } pallas-codec = { version = "=0.25.0", path = "../pallas-codec" }
pallas-crypto = { version = "=0.25.0", path = "../pallas-crypto" }
utxorpc-spec = { version = "0.5.0" } utxorpc-spec = { version = "0.5.0" }
# utxorpc-spec = { path = "../../../utxorpc/spec/gen/rust" } # utxorpc-spec = { path = "../../../utxorpc/spec/gen/rust" }

250
pallas-utxorpc/src/lib.rs
View file

@ -1,6 +1,7 @@
use std::ops::Deref; use std::ops::Deref;
use pallas_codec::utils::KeyValuePairs; use pallas_codec::utils::KeyValuePairs;
use pallas_crypto::hash::Hash;
use pallas_primitives::{alonzo, babbage, conway}; use pallas_primitives::{alonzo, babbage, conway};
use pallas_traverse as trv; use pallas_traverse as trv;
@ -10,7 +11,16 @@ pub use utxorpc_spec::utxorpc::v1alpha as spec;
use utxorpc_spec::utxorpc::v1alpha::cardano as u5c; use utxorpc_spec::utxorpc::v1alpha::cardano as u5c;
pub fn map_purpose(x: &conway::RedeemerTag) -> u5c::RedeemerPurpose { pub trait Context {
fn get_spent_tx_output<'a>(tx_hash: Hash<32>, index: u32) -> Option<trv::MultiEraOutput<'a>>;
}
pub struct Mapper<C: Context> {
context: Option<C>,
}
impl<C: Context> Mapper<C> {
pub fn map_purpose(&self, x: &conway::RedeemerTag) -> u5c::RedeemerPurpose {
match x { match x {
conway::RedeemerTag::Spend => u5c::RedeemerPurpose::Spend, conway::RedeemerTag::Spend => u5c::RedeemerPurpose::Spend,
conway::RedeemerTag::Mint => u5c::RedeemerPurpose::Mint, conway::RedeemerTag::Mint => u5c::RedeemerPurpose::Mint,
@ -19,39 +29,57 @@ pub fn map_purpose(x: &conway::RedeemerTag) -> u5c::RedeemerPurpose {
conway::RedeemerTag::Vote => todo!(), conway::RedeemerTag::Vote => todo!(),
conway::RedeemerTag::Propose => todo!(), conway::RedeemerTag::Propose => todo!(),
} }
}
pub fn map_redeemer(x: &trv::MultiEraRedeemer) -> u5c::Redeemer {
u5c::Redeemer {
purpose: map_purpose(&x.tag()).into(),
datum: map_plutus_datum(x.data()).into(),
} }
}
pub fn map_tx_input(i: &trv::MultiEraInput, tx: &trv::MultiEraTx) -> u5c::TxInput { pub fn map_redeemer(&self, x: &trv::MultiEraRedeemer) -> u5c::Redeemer {
u5c::Redeemer {
purpose: self.map_purpose(&x.tag()).into(),
datum: self.map_plutus_datum(x.data()).into(),
}
}
pub fn map_tx_input(&self, i: &trv::MultiEraInput, tx: &trv::MultiEraTx) -> u5c::TxInput {
let redeemers = tx.redeemers(); let redeemers = tx.redeemers();
let redeemer = redeemers.iter().find(|r| (r.index() as u64) == i.index()); let redeemer = redeemers.iter().find(|r| (r.index() as u64) == i.index());
let as_output = match &self.context {
Some(_) => {
let tx_output = C::get_spent_tx_output(i.hash().clone(), i.index() as u32);
match tx_output {
Some(output) => Some(self.map_tx_output(&output)),
None => panic!(
"Failed to fetch transaction output for hash: {:?}, index: {}",
i.hash(),
i.index()
),
}
}
None => None,
};
u5c::TxInput { u5c::TxInput {
tx_hash: i.hash().to_vec().into(), tx_hash: i.hash().to_vec().into(),
output_index: i.index() as u32, output_index: i.index() as u32,
redeemer: redeemer.map(map_redeemer), redeemer: redeemer.map(|x| self.map_redeemer(x)),
// TODO: map output data from some context as_output,
as_output: None, }
} }
}
pub fn map_tx_output(x: &trv::MultiEraOutput) -> u5c::TxOutput { pub fn map_tx_output(&self, x: &trv::MultiEraOutput) -> u5c::TxOutput {
u5c::TxOutput { u5c::TxOutput {
address: x.address().map(|a| a.to_vec()).unwrap_or_default().into(), address: x.address().map(|a| a.to_vec()).unwrap_or_default().into(),
coin: x.lovelace_amount(), coin: x.lovelace_amount(),
// TODO: this is wrong, we're crating a new item for each asset even if they share // TODO: this is wrong, we're crating a new item for each asset even if they share
// the same policy id. We need to adjust Pallas' interface to make this mapping more // the same policy id. We need to adjust Pallas' interface to make this mapping more
// ergonomic. // ergonomic.
assets: x.non_ada_assets().iter().map(map_policy_assets).collect(), assets: x
.non_ada_assets()
.iter()
.map(|x| self.map_policy_assets(x))
.collect(),
datum: match x.datum() { datum: match x.datum() {
Some(babbage::PseudoDatumOption::Data(x)) => map_plutus_datum(&x.0).into(), Some(babbage::PseudoDatumOption::Data(x)) => self.map_plutus_datum(&x.0).into(),
_ => None, _ => None,
}, },
datum_hash: match x.datum() { datum_hash: match x.datum() {
@ -61,7 +89,7 @@ pub fn map_tx_output(x: &trv::MultiEraOutput) -> u5c::TxOutput {
}, },
script: match x.script_ref() { script: match x.script_ref() {
Some(conway::PseudoScript::NativeScript(x)) => u5c::Script { Some(conway::PseudoScript::NativeScript(x)) => u5c::Script {
script: u5c::script::Script::Native(map_native_script(&x)).into(), script: u5c::script::Script::Native(self.map_native_script(&x)).into(), /* */
} }
.into(), .into(),
Some(conway::PseudoScript::PlutusV1Script(x)) => u5c::Script { Some(conway::PseudoScript::PlutusV1Script(x)) => u5c::Script {
@ -76,9 +104,9 @@ pub fn map_tx_output(x: &trv::MultiEraOutput) -> u5c::TxOutput {
None => None, None => None,
}, },
} }
} }
pub fn map_stake_credential(x: &babbage::StakeCredential) -> u5c::StakeCredential { pub fn map_stake_credential(&self, x: &babbage::StakeCredential) -> u5c::StakeCredential {
let inner = match x { let inner = match x {
babbage::StakeCredential::AddrKeyhash(x) => { babbage::StakeCredential::AddrKeyhash(x) => {
u5c::stake_credential::StakeCredential::AddrKeyHash(x.to_vec().into()) u5c::stake_credential::StakeCredential::AddrKeyHash(x.to_vec().into())
@ -91,9 +119,9 @@ pub fn map_stake_credential(x: &babbage::StakeCredential) -> u5c::StakeCredentia
u5c::StakeCredential { u5c::StakeCredential {
stake_credential: inner.into(), stake_credential: inner.into(),
} }
} }
pub fn map_relay(x: &alonzo::Relay) -> u5c::Relay { pub fn map_relay(&self, x: &alonzo::Relay) -> u5c::Relay {
match x { match x {
babbage::Relay::SingleHostAddr(port, v4, v6) => u5c::Relay { babbage::Relay::SingleHostAddr(port, v4, v6) => u5c::Relay {
// ip_v4: v4.map(|x| x.to_vec().into()).into().unwrap_or_default(), // ip_v4: v4.map(|x| x.to_vec().into()).into().unwrap_or_default(),
@ -115,19 +143,19 @@ pub fn map_relay(x: &alonzo::Relay) -> u5c::Relay {
port: Default::default(), port: Default::default(),
}, },
} }
} }
pub fn map_cert(x: &trv::MultiEraCert) -> u5c::Certificate { pub fn map_cert(&self, x: &trv::MultiEraCert) -> u5c::Certificate {
let inner = match x.as_alonzo().unwrap() { let inner = match x.as_alonzo().unwrap() {
babbage::Certificate::StakeRegistration(a) => { babbage::Certificate::StakeRegistration(a) => {
u5c::certificate::Certificate::StakeRegistration(map_stake_credential(a)) u5c::certificate::Certificate::StakeRegistration(self.map_stake_credential(a))
} }
babbage::Certificate::StakeDeregistration(a) => { babbage::Certificate::StakeDeregistration(a) => {
u5c::certificate::Certificate::StakeDeregistration(map_stake_credential(a)) u5c::certificate::Certificate::StakeDeregistration(self.map_stake_credential(a))
} }
babbage::Certificate::StakeDelegation(a, b) => { babbage::Certificate::StakeDelegation(a, b) => {
u5c::certificate::Certificate::StakeDelegation(u5c::StakeDelegationCert { u5c::certificate::Certificate::StakeDelegation(u5c::StakeDelegationCert {
stake_credential: map_stake_credential(a).into(), stake_credential: self.map_stake_credential(a).into(),
pool_keyhash: b.to_vec().into(), pool_keyhash: b.to_vec().into(),
}) })
} }
@ -153,7 +181,7 @@ pub fn map_cert(x: &trv::MultiEraCert) -> u5c::Certificate {
.into(), .into(),
reward_account: reward_account.to_vec().into(), reward_account: reward_account.to_vec().into(),
pool_owners: pool_owners.iter().map(|x| x.to_vec().into()).collect(), pool_owners: pool_owners.iter().map(|x| x.to_vec().into()).collect(),
relays: relays.iter().map(map_relay).collect(), relays: relays.iter().map(|x| self.map_relay(x)).collect(),
pool_metadata: pool_metadata pool_metadata: pool_metadata
.clone() .clone()
.map(|x| u5c::PoolMetadata { .map(|x| u5c::PoolMetadata {
@ -178,14 +206,18 @@ pub fn map_cert(x: &trv::MultiEraCert) -> u5c::Certificate {
babbage::Certificate::MoveInstantaneousRewardsCert(a) => { babbage::Certificate::MoveInstantaneousRewardsCert(a) => {
u5c::certificate::Certificate::MirCert(u5c::MirCert { u5c::certificate::Certificate::MirCert(u5c::MirCert {
from: match &a.source { from: match &a.source {
babbage::InstantaneousRewardSource::Reserves => u5c::MirSource::Reserves.into(), babbage::InstantaneousRewardSource::Reserves => {
babbage::InstantaneousRewardSource::Treasury => u5c::MirSource::Treasury.into(), u5c::MirSource::Reserves.into()
}
babbage::InstantaneousRewardSource::Treasury => {
u5c::MirSource::Treasury.into()
}
}, },
to: match &a.target { to: match &a.target {
babbage::InstantaneousRewardTarget::StakeCredentials(x) => x babbage::InstantaneousRewardTarget::StakeCredentials(x) => x
.iter() .iter()
.map(|(k, v)| u5c::MirTarget { .map(|(k, v)| u5c::MirTarget {
stake_credential: map_stake_credential(k).into(), stake_credential: self.map_stake_credential(k).into(),
delta_coin: *v, delta_coin: *v,
}) })
.collect(), .collect(),
@ -202,56 +234,56 @@ pub fn map_cert(x: &trv::MultiEraCert) -> u5c::Certificate {
u5c::Certificate { u5c::Certificate {
certificate: inner.into(), certificate: inner.into(),
} }
} }
pub fn map_withdrawals(x: &(&[u8], u64)) -> u5c::Withdrawal { pub fn map_withdrawals(&self, x: &(&[u8], u64)) -> u5c::Withdrawal {
u5c::Withdrawal { u5c::Withdrawal {
reward_account: Vec::from(x.0).into(), reward_account: Vec::from(x.0).into(),
coin: x.1, coin: x.1,
} }
} }
pub fn map_asset(x: &trv::MultiEraAsset) -> u5c::Asset { pub fn map_asset(&self, x: &trv::MultiEraAsset) -> u5c::Asset {
u5c::Asset { u5c::Asset {
name: x.name().to_vec().into(), name: x.name().to_vec().into(),
output_coin: x.output_coin().unwrap_or_default(), output_coin: x.output_coin().unwrap_or_default(),
mint_coin: x.mint_coin().unwrap_or_default(), mint_coin: x.mint_coin().unwrap_or_default(),
} }
} }
pub fn map_policy_assets(x: &trv::MultiEraPolicyAssets) -> u5c::Multiasset { pub fn map_policy_assets(&self, x: &trv::MultiEraPolicyAssets) -> u5c::Multiasset {
u5c::Multiasset { u5c::Multiasset {
policy_id: x.policy().to_vec().into(), policy_id: x.policy().to_vec().into(),
assets: x.assets().iter().map(map_asset).collect(), assets: x.assets().iter().map(|x| self.map_asset(x)).collect(),
}
} }
}
pub fn map_vkey_witness(x: &alonzo::VKeyWitness) -> u5c::VKeyWitness { pub fn map_vkey_witness(&self, x: &alonzo::VKeyWitness) -> u5c::VKeyWitness {
u5c::VKeyWitness { u5c::VKeyWitness {
vkey: x.vkey.to_vec().into(), vkey: x.vkey.to_vec().into(),
signature: x.signature.to_vec().into(), signature: x.signature.to_vec().into(),
} }
} }
pub fn map_native_script(x: &alonzo::NativeScript) -> u5c::NativeScript { pub fn map_native_script(&self, x: &alonzo::NativeScript) -> u5c::NativeScript {
let inner = match x { let inner = match x {
babbage::NativeScript::ScriptPubkey(x) => { babbage::NativeScript::ScriptPubkey(x) => {
u5c::native_script::NativeScript::ScriptPubkey(x.to_vec().into()) u5c::native_script::NativeScript::ScriptPubkey(x.to_vec().into())
} }
babbage::NativeScript::ScriptAll(x) => { babbage::NativeScript::ScriptAll(x) => {
u5c::native_script::NativeScript::ScriptAll(u5c::NativeScriptList { u5c::native_script::NativeScript::ScriptAll(u5c::NativeScriptList {
items: x.iter().map(map_native_script).collect(), items: x.iter().map(|x| self.map_native_script(x)).collect(),
}) })
} }
babbage::NativeScript::ScriptAny(x) => { babbage::NativeScript::ScriptAny(x) => {
u5c::native_script::NativeScript::ScriptAll(u5c::NativeScriptList { u5c::native_script::NativeScript::ScriptAll(u5c::NativeScriptList {
items: x.iter().map(map_native_script).collect(), items: x.iter().map(|x| self.map_native_script(x)).collect(),
}) })
} }
babbage::NativeScript::ScriptNOfK(n, k) => { babbage::NativeScript::ScriptNOfK(n, k) => {
u5c::native_script::NativeScript::ScriptNOfK(u5c::ScriptNOfK { u5c::native_script::NativeScript::ScriptNOfK(u5c::ScriptNOfK {
k: *n, k: *n,
scripts: k.iter().map(map_native_script).collect(), scripts: k.iter().map(|x| self.map_native_script(x)).collect(),
}) })
} }
babbage::NativeScript::InvalidBefore(s) => { babbage::NativeScript::InvalidBefore(s) => {
@ -265,13 +297,13 @@ pub fn map_native_script(x: &alonzo::NativeScript) -> u5c::NativeScript {
u5c::NativeScript { u5c::NativeScript {
native_script: inner.into(), native_script: inner.into(),
} }
} }
fn collect_all_scripts(tx: &trv::MultiEraTx) -> Vec<u5c::Script> { fn collect_all_scripts(&self, tx: &trv::MultiEraTx) -> Vec<u5c::Script> {
let ns = tx let ns = tx
.native_scripts() .native_scripts()
.iter() .iter()
.map(|x| map_native_script(x.deref())) .map(|x| self.map_native_script(x.deref()))
.map(|x| u5c::Script { .map(|x| u5c::Script {
script: u5c::script::Script::Native(x).into(), script: u5c::script::Script::Native(x).into(),
}); });
@ -293,37 +325,38 @@ fn collect_all_scripts(tx: &trv::MultiEraTx) -> Vec<u5c::Script> {
}); });
ns.chain(p1).chain(p2).collect() ns.chain(p1).chain(p2).collect()
} }
pub fn map_plutus_constr(x: &alonzo::Constr<alonzo::PlutusData>) -> u5c::Constr { pub fn map_plutus_constr(&self, x: &alonzo::Constr<alonzo::PlutusData>) -> u5c::Constr {
u5c::Constr { u5c::Constr {
tag: x.tag as u32, tag: x.tag as u32,
any_constructor: x.any_constructor.unwrap_or_default(), any_constructor: x.any_constructor.unwrap_or_default(),
fields: x.fields.iter().map(map_plutus_datum).collect(), fields: x.fields.iter().map(|x| self.map_plutus_datum(x)).collect(),
}
} }
}
pub fn map_plutus_map( pub fn map_plutus_map(
&self,
x: &KeyValuePairs<alonzo::PlutusData, alonzo::PlutusData>, x: &KeyValuePairs<alonzo::PlutusData, alonzo::PlutusData>,
) -> u5c::PlutusDataMap { ) -> u5c::PlutusDataMap {
u5c::PlutusDataMap { u5c::PlutusDataMap {
pairs: x pairs: x
.iter() .iter()
.map(|(k, v)| u5c::PlutusDataPair { .map(|(k, v)| u5c::PlutusDataPair {
key: map_plutus_datum(k).into(), key: self.map_plutus_datum(k).into(),
value: map_plutus_datum(v).into(), value: self.map_plutus_datum(v).into(),
}) })
.collect(), .collect(),
} }
}
pub fn map_plutus_array(x: &[alonzo::PlutusData]) -> u5c::PlutusDataArray {
u5c::PlutusDataArray {
items: x.iter().map(map_plutus_datum).collect(),
} }
}
pub fn map_plutus_bigint(x: &alonzo::BigInt) -> u5c::BigInt { pub fn map_plutus_array(&self, x: &[alonzo::PlutusData]) -> u5c::PlutusDataArray {
u5c::PlutusDataArray {
items: x.iter().map(|x| self.map_plutus_datum(x)).collect(),
}
}
pub fn map_plutus_bigint(&self, x: &alonzo::BigInt) -> u5c::BigInt {
let inner = match x { let inner = match x {
babbage::BigInt::Int(x) => u5c::big_int::BigInt::Int(i128::from(x.0) as i64), babbage::BigInt::Int(x) => u5c::big_int::BigInt::Int(i128::from(x.0) as i64),
babbage::BigInt::BigUInt(x) => { babbage::BigInt::BigUInt(x) => {
@ -337,17 +370,21 @@ pub fn map_plutus_bigint(x: &alonzo::BigInt) -> u5c::BigInt {
u5c::BigInt { u5c::BigInt {
big_int: inner.into(), big_int: inner.into(),
} }
} }
pub fn map_plutus_datum(x: &alonzo::PlutusData) -> u5c::PlutusData { pub fn map_plutus_datum(&self, x: &alonzo::PlutusData) -> u5c::PlutusData {
let inner = match x { let inner = match x {
babbage::PlutusData::Constr(x) => { babbage::PlutusData::Constr(x) => {
u5c::plutus_data::PlutusData::Constr(map_plutus_constr(x)) u5c::plutus_data::PlutusData::Constr(self.map_plutus_constr(x))
}
babbage::PlutusData::Map(x) => {
u5c::plutus_data::PlutusData::Map(self.map_plutus_map(x))
}
babbage::PlutusData::Array(x) => {
u5c::plutus_data::PlutusData::Array(self.map_plutus_array(x))
} }
babbage::PlutusData::Map(x) => u5c::plutus_data::PlutusData::Map(map_plutus_map(x)),
babbage::PlutusData::Array(x) => u5c::plutus_data::PlutusData::Array(map_plutus_array(x)),
babbage::PlutusData::BigInt(x) => { babbage::PlutusData::BigInt(x) => {
u5c::plutus_data::PlutusData::BigInt(map_plutus_bigint(x)) u5c::plutus_data::PlutusData::BigInt(self.map_plutus_bigint(x))
} }
babbage::PlutusData::BoundedBytes(x) => { babbage::PlutusData::BoundedBytes(x) => {
u5c::plutus_data::PlutusData::BoundedBytes(x.to_vec().into()) u5c::plutus_data::PlutusData::BoundedBytes(x.to_vec().into())
@ -357,9 +394,9 @@ pub fn map_plutus_datum(x: &alonzo::PlutusData) -> u5c::PlutusData {
u5c::PlutusData { u5c::PlutusData {
plutus_data: inner.into(), plutus_data: inner.into(),
} }
} }
pub fn map_metadatum(x: &alonzo::Metadatum) -> u5c::Metadatum { pub fn map_metadatum(&self, x: &alonzo::Metadatum) -> u5c::Metadatum {
let inner = match x { let inner = match x {
babbage::Metadatum::Int(x) => u5c::metadatum::Metadatum::Int(i128::from(x.0) as i64), babbage::Metadatum::Int(x) => u5c::metadatum::Metadatum::Int(i128::from(x.0) as i64),
babbage::Metadatum::Bytes(x) => { babbage::Metadatum::Bytes(x) => {
@ -367,14 +404,14 @@ pub fn map_metadatum(x: &alonzo::Metadatum) -> u5c::Metadatum {
} }
babbage::Metadatum::Text(x) => u5c::metadatum::Metadatum::Text(x.clone()), babbage::Metadatum::Text(x) => u5c::metadatum::Metadatum::Text(x.clone()),
babbage::Metadatum::Array(x) => u5c::metadatum::Metadatum::Array(u5c::MetadatumArray { babbage::Metadatum::Array(x) => u5c::metadatum::Metadatum::Array(u5c::MetadatumArray {
items: x.iter().map(map_metadatum).collect(), items: x.iter().map(|x| self.map_metadatum(x)).collect(),
}), }),
babbage::Metadatum::Map(x) => u5c::metadatum::Metadatum::Map(u5c::MetadatumMap { babbage::Metadatum::Map(x) => u5c::metadatum::Metadatum::Map(u5c::MetadatumMap {
pairs: x pairs: x
.iter() .iter()
.map(|(k, v)| u5c::MetadatumPair { .map(|(k, v)| u5c::MetadatumPair {
key: map_metadatum(k).into(), key: self.map_metadatum(k).into(),
value: map_metadatum(v).into(), value: self.map_metadatum(v).into(),
}) })
.collect(), .collect(),
}), }),
@ -383,20 +420,20 @@ pub fn map_metadatum(x: &alonzo::Metadatum) -> u5c::Metadatum {
u5c::Metadatum { u5c::Metadatum {
metadatum: inner.into(), metadatum: inner.into(),
} }
} }
pub fn map_metadata(label: u64, datum: &alonzo::Metadatum) -> u5c::Metadata { pub fn map_metadata(&self, label: u64, datum: &alonzo::Metadatum) -> u5c::Metadata {
u5c::Metadata { u5c::Metadata {
label, label,
value: map_metadatum(datum).into(), value: self.map_metadatum(datum).into(),
}
} }
}
fn collect_all_aux_scripts(tx: &trv::MultiEraTx) -> Vec<u5c::Script> { fn collect_all_aux_scripts(&self, tx: &trv::MultiEraTx) -> Vec<u5c::Script> {
let ns = tx let ns = tx
.aux_native_scripts() .aux_native_scripts()
.iter() .iter()
.map(map_native_script) .map(|x| self.map_native_script(x))
.map(|x| u5c::Script { .map(|x| u5c::Script {
script: u5c::script::Script::Native(x).into(), script: u5c::script::Script::Native(x).into(),
}); });
@ -412,33 +449,45 @@ fn collect_all_aux_scripts(tx: &trv::MultiEraTx) -> Vec<u5c::Script> {
// TODO: check why we don't have plutus v2 aux script, is that a possibility? // TODO: check why we don't have plutus v2 aux script, is that a possibility?
ns.chain(p1).collect() ns.chain(p1).collect()
} }
pub fn map_tx(tx: &trv::MultiEraTx) -> u5c::Tx { pub fn map_tx(&self, tx: &trv::MultiEraTx) -> u5c::Tx {
u5c::Tx { u5c::Tx {
hash: tx.hash().to_vec().into(), hash: tx.hash().to_vec().into(),
inputs: tx.inputs().iter().map(|i| map_tx_input(i, tx)).collect(), inputs: tx
outputs: tx.outputs().iter().map(map_tx_output).collect(), .inputs()
certificates: tx.certs().iter().map(map_cert).collect(), .iter()
.map(|i| self.map_tx_input(i, tx))
.collect(),
outputs: tx.outputs().iter().map(|x| self.map_tx_output(x)).collect(),
certificates: tx.certs().iter().map(|x| self.map_cert(x)).collect(),
withdrawals: tx withdrawals: tx
.withdrawals() .withdrawals()
.collect::<Vec<_>>() .collect::<Vec<_>>()
.iter() .iter()
.map(map_withdrawals) .map(|x| self.map_withdrawals(x))
.collect(),
mint: tx
.mints()
.iter()
.map(|x| self.map_policy_assets(x))
.collect(), .collect(),
mint: tx.mints().iter().map(map_policy_assets).collect(),
reference_inputs: tx reference_inputs: tx
.reference_inputs() .reference_inputs()
.iter() .iter()
.map(|x| map_tx_input(x, tx)) .map(|x| self.map_tx_input(x, tx))
.collect(), .collect(),
witnesses: u5c::WitnessSet { witnesses: u5c::WitnessSet {
vkeywitness: tx.vkey_witnesses().iter().map(map_vkey_witness).collect(), vkeywitness: tx
script: collect_all_scripts(tx), .vkey_witnesses()
.iter()
.map(|x| self.map_vkey_witness(x))
.collect(),
script: self.collect_all_scripts(tx),
plutus_datums: tx plutus_datums: tx
.plutus_data() .plutus_data()
.iter() .iter()
.map(|x| map_plutus_datum(x.deref())) .map(|x| self.map_plutus_datum(x.deref()))
.collect(), .collect(),
} }
.into(), .into(),
@ -446,9 +495,9 @@ pub fn map_tx(tx: &trv::MultiEraTx) -> u5c::Tx {
collateral: tx collateral: tx
.collateral() .collateral()
.iter() .iter()
.map(|x| map_tx_input(x, tx)) .map(|x| self.map_tx_input(x, tx))
.collect(), .collect(),
collateral_return: tx.collateral_return().map(|x| map_tx_output(&x)), collateral_return: tx.collateral_return().map(|x| self.map_tx_output(&x)),
total_collateral: tx.total_collateral().unwrap_or_default(), total_collateral: tx.total_collateral().unwrap_or_default(),
} }
.into(), .into(),
@ -464,15 +513,15 @@ pub fn map_tx(tx: &trv::MultiEraTx) -> u5c::Tx {
.metadata() .metadata()
.collect::<Vec<_>>() .collect::<Vec<_>>()
.into_iter() .into_iter()
.map(|(l, d)| map_metadata(l, d)) .map(|(l, d)| self.map_metadata(l, d))
.collect(), .collect(),
scripts: collect_all_aux_scripts(tx), scripts: self.collect_all_aux_scripts(tx),
} }
.into(), .into(),
} }
} }
pub fn map_block(block: &trv::MultiEraBlock) -> u5c::Block { pub fn map_block(&self, block: &trv::MultiEraBlock) -> u5c::Block {
u5c::Block { u5c::Block {
header: u5c::BlockHeader { header: u5c::BlockHeader {
slot: block.slot(), slot: block.slot(),
@ -481,13 +530,14 @@ pub fn map_block(block: &trv::MultiEraBlock) -> u5c::Block {
} }
.into(), .into(),
body: u5c::BlockBody { body: u5c::BlockBody {
tx: block.txs().iter().map(map_tx).collect(), tx: block.txs().iter().map(|x| self.map_tx(x)).collect(),
} }
.into(), .into(),
} }
} }
pub fn map_block_cbor(raw: &[u8]) -> u5c::Block { pub fn map_block_cbor(&self, raw: &[u8]) -> u5c::Block {
let block = trv::MultiEraBlock::decode(raw).unwrap(); let block = trv::MultiEraBlock::decode(raw).unwrap();
map_block(&block) self.map_block(&block)
}
} }