Struct cardano_serialization_lib::Transaction

source ·

pub struct Transaction { /* private fields */ }

Implementations§

source §

impl Transaction

source

pub fn to_bytes(&self) -> Vec<u8>

Examples found in repository ?

src/fees.rs (line 31)

30
31
32

pub fn min_fee(tx: &Transaction, linear_fee: &LinearFee) -> Result<Coin, JsError> {
    min_fee_for_size(tx.to_bytes().len(), linear_fee)
}

More examples

Hide additional examples

src/tx_builder.rs (line 1781)

    fn build_and_size(&self) -> Result<(TransactionBody, usize), JsError> {
        let fee = self
            .fee
            .ok_or_else(|| JsError::from_str("Fee not specified"))?;
        let built = TransactionBody {
            inputs: self.inputs.inputs(),
            outputs: self.outputs.clone(),
            fee,
            ttl: self.ttl,
            certs: self.certs.clone(),
            withdrawals: self.withdrawals.clone(),
            update: None,
            auxiliary_data_hash: match &self.auxiliary_data {
                None => None,
                Some(x) => Some(utils::hash_auxiliary_data(x)),
            },
            validity_start_interval: self.validity_start_interval,
            mint: match &self.mint {
                None => None,
                Some(mint_builder) => Some(mint_builder.build()),
            },
            script_data_hash: self.script_data_hash.clone(),
            collateral: self.collateral.inputs_option(),
            required_signers: self.required_signers.to_option(),
            network_id: None,
            collateral_return: self.collateral_return.clone(),
            total_collateral: self.total_collateral.clone(),
            reference_inputs: self.get_reference_inputs().to_option(),
        };
        // we must build a tx with fake data (of correct size) to check the final Transaction size
        let full_tx = fake_full_tx(self, built)?;
        let full_tx_size = full_tx.to_bytes().len();
        return Ok((full_tx.body, full_tx_size));
    }

source §

pub fn new(
 body: &TransactionBody,
 witness_set: &TransactionWitnessSet,
 auxiliary_data: Option<AuxiliaryData>
) -> Self

Examples found in repository ?

src/tx_builder/batch_tools/proposals.rs (lines 192-196)

    pub(crate) fn create_tx(&self, asset_groups: &AssetCategorizer, utxos: &TransactionUnspentOutputs)
                            -> Result<Transaction, JsError> {
        let mut outputs = Vec::new();
        for proposal in &self.tx_output_proposals {
            outputs.push(proposal.create_output(asset_groups, &self.used_utoxs)?);
        }

        let mut inputs = Vec::new();
        for utxo in &self.used_utoxs {
            inputs.push(utxos.0[utxo.0].input.clone());
        }

        let body = TransactionBody::new(
            &TransactionInputs(inputs),
            &TransactionOutputs(outputs),
            &self.fee,
            None,
        );
        let tx = Transaction::new(
            &body,
            &self.witnesses_calculator.create_mock_witnesses_set(),
            None,
        );

        Ok(tx)
    }