cardano_sdk/builder/

tx.rs

use crate::{chain::*, crypto::key::SignatureVerification};
use cryptoxide::hashing::blake2b_256;
use std::sync::Arc;

/// The static parts of building a transaction
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TransactionSettings {
    pub ttl: Option<u64>,
    pub certs: Option<Certificates>,
    pub withdrawals: Option<Withdrawals>,
    // TODO pub update: Option<AnyCbor>,
    pub metadata: Option<Metadata>,
    pub validity_start_interval: Option<u64>,
    pub mint: Option<Mint>,
    pub script_data_hash: Option<ScriptDataHash>,
    pub collateral: Option<TransactionInputs>,
    pub required_signers: Option<Ed25519KeyHashes>,
    pub network_id: Option<u8>,
    pub collateral_return: Option<TransactionOutput>,
    pub total_collateral: Option<Coin>,
    pub reference_inputs: Option<TransactionInputs>,
}

impl TransactionSettings {
    pub fn build() -> TransactionSettingsBuilder {
        TransactionSettingsBuilder(Default::default())
    }
}

pub struct TransactionSettingsBuilder(TransactionSettings);

macro_rules! builder_field_opt {
    ($obj:ident, $field:ident, $ty:ident, $set:ident, $clear:ident, $get:ident, ) => {
        impl $obj {
            pub fn $set(mut self, value: $ty) -> Self {
                self.0.$field = Some(value);
                self
            }

            pub fn $clear(mut self) -> Self {
                self.0.$field = None;
                self
            }

            pub fn $get(&self) -> &Option<$ty> {
                &self.0.$field
            }
        }
    };
}

impl TransactionSettingsBuilder {
    pub fn finalize(self) -> TransactionSettings {
        self.0
    }
}

builder_field_opt!(
    TransactionSettingsBuilder,
    ttl,
    u64,
    ttl,
    ttl_clear,
    ttl_get,
);
builder_field_opt!(
    TransactionSettingsBuilder,
    mint,
    Mint,
    mint,
    mint_clear,
    mint_get,
);
builder_field_opt!(
    TransactionSettingsBuilder,
    metadata,
    Metadata,
    metadata,
    metadata_clear,
    metadata_get,
);
builder_field_opt!(
    TransactionSettingsBuilder,
    network_id,
    u8,
    network,
    network_clear,
    network_get,
);
builder_field_opt!(
    TransactionSettingsBuilder,
    validity_start_interval,
    u64,
    validity_start_interval,
    validity_start_interval_clear,
    validity_start_interval_get,
);

pub struct TransactionBuilder {
    inputs: Vec<TransactionInput>,
    outputs: Vec<TransactionOutput>,
    fee: Coin,
    settings: Arc<TransactionSettings>,
}

pub struct TransactionSigner {
    builder: TransactionBuilder,
    pub tx_body_hash: TxHash,
    key_witnesses: Vec<VkeyWitness>,
    native_scripts: Vec<NativeScript>,
}

macro_rules! builder_field_copy {
    ($obj:ident, $field:ident, $ty:ident, $set:ident, $get:ident, ) => {
        impl $obj {
            pub fn $set(mut self, value: $ty) -> Self {
                self.$field = value;
                self
            }

            pub fn $get(&self) -> $ty {
                self.$field
            }
        }
    };
}

macro_rules! builder_field_vec {
    ($obj:ident, $field:ident, $ty:ident, $add:ident, $remove_at:ident, ) => {
        impl $obj {
            pub fn $add(mut self, value: $ty) -> Self {
                self.$field.push(value);
                self
            }

            pub fn $remove_at(mut self, index: usize) -> Self {
                self.$field.remove(index);
                self
            }
        }
    };
}

builder_field_vec!(
    TransactionBuilder,
    inputs,
    TransactionInput,
    inputs_add,
    inputs_remove_at,
);

builder_field_vec!(
    TransactionBuilder,
    outputs,
    TransactionOutput,
    outputs_add,
    outputs_remove_at,
);

builder_field_copy!(TransactionBuilder, fee, Coin, fee, fee_get,);

impl TransactionBuilder {
    pub fn new(settings: TransactionSettings) -> Self {
        Self {
            inputs: Vec::new(),
            outputs: Vec::new(),
            fee: Coin::ZERO,
            settings: Arc::new(settings),
        }
    }

    pub fn body(&self) -> TransactionBody {
        TransactionBody {
            inputs: TransactionInputs::from(self.inputs.clone()),
            outputs: TransactionOutputs::from(self.outputs.clone()),
            fee: self.fee,
            ttl: self.settings.ttl,
            certs: self.settings.certs.clone(),
            withdrawals: self.settings.withdrawals.clone(),
            update: None,
            metadata_hash: self.settings.metadata.as_ref().map(|m| m.hash()),
            validity_start_interval: self.settings.validity_start_interval.clone(),
            mint: self.settings.mint.clone(),
            script_data_hash: self.settings.script_data_hash.clone(),
            collateral: self.settings.collateral.clone(),
            required_signers: self.settings.required_signers.clone(),
            network_id: self.settings.network_id,
            collateral_return: self.settings.collateral_return.clone(),
            total_collateral: self.settings.total_collateral.clone(),
            reference_inputs: self.settings.reference_inputs.clone(),
        }
    }

    pub fn signer(self) -> TransactionSigner {
        TransactionSigner::new(self)
    }
}

impl TransactionSigner {
    pub fn new(builder: TransactionBuilder) -> Self {
        let tx_body_hash = builder.body().hash();
        Self {
            builder,
            tx_body_hash,
            key_witnesses: Vec::new(),
            native_scripts: Vec::new(),
        }
    }

    pub fn add_signature(mut self, witness: VkeyWitness) -> Self {
        self.key_witnesses.push(witness);
        self
    }

    pub fn add_native_script(mut self, native_script: NativeScript) -> Self {
        self.native_scripts.push(native_script);
        self
    }

    pub fn finalize(self) -> Transaction {
        let vkeys = if self.key_witnesses.len() > 0 {
            Some(VkeyWitnesses::from(self.key_witnesses))
        } else {
            None
        };
        let native_scripts = if self.native_scripts.len() > 0 {
            Some(NativeScripts::from(self.native_scripts))
        } else {
            None
        };
        Transaction {
            body: self.builder.body().serialize(),
            witness: TransactionWitness {
                vkeys,
                native_scripts,
                bootstraps: None,
                plutus_scripts: None,
                plutus_scripts_v2: None,
                plutus_data: None,
                redeemers: None,
            },
            is_valid: true,
            auxiliary_data: Nullable::from(self.builder.settings.metadata.clone()),
        }
    }
}

impl Transaction {
    pub fn hash(&self) -> TxHash {
        TxHash(blake2b_256(&self.to_bytes()))
    }

    pub fn to_bytes(&self) -> Vec<u8> {
        let mut w = cbored::Writer::new();
        w.encode(self);
        w.finalize()
    }

    // only able to verify vkeys
    pub fn verify_vkeys(&self) -> SignatureVerification {
        let tx_body_hash = self.body.hash();
        match &self.witness.vkeys {
            None => SignatureVerification::Failed,
            Some(vkeywitnesses) => {
                for vkeywitness in vkeywitnesses.iter() {
                    let VkeyWitness { vkey, signature } = &vkeywitness;
                    println!(
                        "verify vkey {} : tx-body-hash= {}, sig: {}",
                        vkey, tx_body_hash, signature
                    );
                    let mut writer = cbored::Writer::new();
                    writer.bytes(&cbored::Bytes::from_slice(&tx_body_hash.0));
                    let x = writer.finalize();

                    //match vkey.verify(signature, &tx_body_hash.0) {
                    match vkey.verify(signature, &x) {
                        SignatureVerification::Failed => return SignatureVerification::Failed,
                        SignatureVerification::Passed => {}
                    }
                }
                return SignatureVerification::Passed;
            }
        }
    }
}

#[cfg(test)]
mod tests {
    /*
    use super::*;
    use crate::crypto::key::Ed25519Key;
    use cbored::Decode;
    use cryptoxide::hashing::blake2b_256;
    */

    // test vectors from : https://gist.github.com/KtorZ/5a2089df0915f21aca368d12545ab230
    /*
    - inputs:
        - id: 3b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b7
          index: 42
          input_prvkey: c660e50315d76a53d80732efda7630cae8885dfb85c46378684b3c6103e1284a
          input_pubkey: f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee
        - id: 82839f8200d81858248258203b40265111d8bb3c3c608d95b3a0bf83461ace32
          index: 7
          input_prvkey: 13fe79205e16c09536acb6f0524d04069f380329d13949698c5f22c65c989eb4
          input_pubkey: 6872b0a874acfe1cace12b20ea348559a7ecc912f2fc7f674f43481df973d92c
      outputs:
        - address: 611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c
          coin: 289
        - address: 61bcd18fcffa797c16c007014e2b8553b8b9b1e94c507688726243d611
          coin: 874551452
      certificates: []
      metadata: null
      fee: 1478714
      ttl: 999
      network: 1
      result:
        83a400828258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a
        1939b3aad1c0b7182a82582082839f8200d81858248258203b40265111d8bb3c
        3c608d95b3a0bf83461ace3207018282581d611c616f1acb460668a9b2f123c8
        0372c2adad3583b9c6cd2b1deeed1c19012182581d61bcd18fcffa797c16c007
        014e2b8553b8b9b1e94c507688726243d6111a3420989c021a0016903a031903
        e7a10082825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185
        962484a4813bee5840938cd3feb731fe6749c9b2b127d3958821fc7649b337f4
        aaae105bf51ad75906aec0112fb40ecc2c2e7c00592a1ec5ac59ddf31ad60488
        6364f78dbf6da8fe0c8258206872b0a874acfe1cace12b20ea348559a7ecc912
        f2fc7f674f43481df973d92c58402a442facbde5b67d7d15581e1b59ee44b375
        0bd018f01a2fecb4bc82b558c90f946afcb9f03f18e7ffb40bd59c4793871b92
        4ab707cffdfda10dd5595e29e709f6
        */

    /*
    #[test]
    fn vec2() {
        let result = hex::decode("83a400828258203b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b7182a82582082839f8200d81858248258203b40265111d8bb3c3c608d95b3a0bf83461ace3207018282581d611c616f1acb460668a9b2f123c80372c2adad3583b9c6cd2b1deeed1c19012182581d61bcd18fcffa797c16c007014e2b8553b8b9b1e94c507688726243d6111a3420989c021a0016903a031903e7a10082825820f9aa3fccb7fe539e471188ccc9ee65514c5961c070b06ca185962484a4813bee5840938cd3feb731fe6749c9b2b127d3958821fc7649b337f4aaae105bf51ad75906aec0112fb40ecc2c2e7c00592a1ec5ac59ddf31ad604886364f78dbf6da8fe0c8258206872b0a874acfe1cace12b20ea348559a7ecc912f2fc7f674f43481df973d92c58402a442facbde5b67d7d15581e1b59ee44b3750bd018f01a2fecb4bc82b558c90f946afcb9f03f18e7ffb40bd59c4793871b924ab707cffdfda10dd5595e29e709f6").unwrap();
        let mut reader = cbored::Reader::new(&result);
        let tx_expected = Transaction::decode(&mut reader).unwrap();
        assert!(reader.is_finished());

        let txbody_slice = {
            let mut reader2 = cbored::Reader::new(&result);
            let array = reader2.array().unwrap();
            array[0]
        };
        let txbody_hash_from_slice = blake2b_256(txbody_slice.as_ref());

        // check this the transaction re-encode to the byte stream
        assert_eq!(tx_expected.to_bytes(), result);
        assert_eq!(tx_expected.body.as_ref(), txbody_slice.as_ref());
        println!("{:?}", tx_expected);

        // check that the vkeys witnesses verification work
        assert_eq!(tx_expected.verify_vkeys(), SignatureVerification::Passed);

        let privkey1_data =
            hex::decode("c660e50315d76a53d80732efda7630cae8885dfb85c46378684b3c6103e1284a")
                .unwrap();
        let privkey2_data =
            hex::decode("13fe79205e16c09536acb6f0524d04069f380329d13949698c5f22c65c989eb4")
                .unwrap();

        let privkey1 = Ed25519Key::from_bytes(<&[u8; 32]>::try_from(&privkey1_data[..]).unwrap());
        let privkey2 = Ed25519Key::from_bytes(<&[u8; 32]>::try_from(&privkey2_data[..]).unwrap());

        assert_eq!(
            privkey1.to_public().as_bytes(),
            &[
                0xf9, 0xaa, 0x3f, 0xcc, 0xb7, 0xfe, 0x53, 0x9e, 0x47, 0x11, 0x88, 0xcc, 0xc9, 0xee,
                0x65, 0x51, 0x4c, 0x59, 0x61, 0xc0, 0x70, 0xb0, 0x6c, 0xa1, 0x85, 0x96, 0x24, 0x84,
                0xa4, 0x81, 0x3b, 0xee,
            ]
        );
        assert_eq!(
            privkey2.to_public().as_bytes(),
            &[
                0x68, 0x72, 0xb0, 0xa8, 0x74, 0xac, 0xfe, 0x1c, 0xac, 0xe1, 0x2b, 0x20, 0xea, 0x34,
                0x85, 0x59, 0xa7, 0xec, 0xc9, 0x12, 0xf2, 0xfc, 0x7f, 0x67, 0x4f, 0x43, 0x48, 0x1d,
                0xf9, 0x73, 0xd9, 0x2c,
            ]
        );

        let txid1 =
            TxHash::from_hex("3b40265111d8bb3c3c608d95b3a0bf83461ace32d79336579a1939b3aad1c0b7")
                .expect("txid1");
        let txid2 =
            TxHash::from_hex("82839f8200d81858248258203b40265111d8bb3c3c608d95b3a0bf83461ace32")
                .expect("txid2");
        let settings = {
            let mut settings = TransactionSettings::default();
            //settings.fee = Coin::u64(1478714)
            settings.ttl = Some(999);
            settings
        };
        let builder = TransactionBuilder::new(settings)
            .inputs_add(TransactionInput(txid1, TxIndex(42)))
            .inputs_add(TransactionInput(txid2, TxIndex(7)))
            .outputs_add(TransactionOutput::V1(TransactionOutputV1 {
                address: SerializedAddress::from_bytes(vec![
                    0x61, 0x1c, 0x61, 0x6f, 0x1a, 0xcb, 0x46, 0x06, 0x68, 0xa9, 0xb2, 0xf1, 0x23,
                    0xc8, 0x03, 0x72, 0xc2, 0xad, 0xad, 0x35, 0x83, 0xb9, 0xc6, 0xcd, 0x2b, 0x1d,
                    0xee, 0xed, 0x1c,
                ]),
                amount: TransactionOutputValue::OnlyCoin(Coin::u64(289)),
                data_hash: None,
            }))
            .outputs_add(TransactionOutput::V1(TransactionOutputV1 {
                address: SerializedAddress::from_bytes(vec![
                    0x61, 0xbc, 0xd1, 0x8f, 0xcf, 0xfa, 0x79, 0x7c, 0x16, 0xc0, 0x07, 0x01, 0x4e,
                    0x2b, 0x85, 0x53, 0xb8, 0xb9, 0xb1, 0xe9, 0x4c, 0x50, 0x76, 0x88, 0x72, 0x62,
                    0x43, 0xd6, 0x11,
                ]),
                amount: TransactionOutputValue::OnlyCoin(Coin::u64(874551452)),
                data_hash: None,
            }))
            .fee(Coin::u64(1478714));
        let body = builder.body();
        let body_data = body.serialize();
        let tx_body_hash = body.hash();
        assert_eq!(tx_body_hash.0, txbody_hash_from_slice);
        assert_eq!(body_data.as_ref(), tx_expected.body.as_ref());

        let t = builder
            .signer()
            .add_signature(privkey1.to_witness(&tx_body_hash))
            .add_signature(privkey2.to_witness(&tx_body_hash))
            .finalize();
        assert_eq!(
            t.verify_vkeys(),
            SignatureVerification::Passed,
            "cannot verify freshly generated signature"
        );

        let tx_data = t.to_bytes();
        assert_eq!(
            tx_data, result,
            "{:#?}\n{:#?}",
            tx_expected.witness, t.witness
        );
        //println!("{:?}", tx_expected.witness);
    }
    */

    /*
    #[test]
    fn random_vec() {
        let body = [
            165, 0, 129, 130, 88, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 129, 130, 88, 57, 0, 42, 21, 122, 39, 160,
            98, 31, 170, 131, 132, 74, 105, 123, 52, 124, 251, 64, 218, 211, 161, 64, 243, 68, 11,
            228, 139, 56, 52, 129, 226, 227, 96, 102, 67, 17, 159, 245, 188, 53, 46, 220, 15, 104,
            199, 116, 182, 114, 123, 35, 187, 198, 135, 130, 58, 192, 223, 26, 0, 15, 62, 88, 2,
            25, 3, 232, 3, 25, 3, 232, 7, 88, 32, 64, 89, 113, 48, 84, 146, 202, 106, 151, 62, 19,
            73, 79, 167, 143, 251, 3, 215, 69, 231, 142, 204, 155, 128, 80, 120, 62, 100, 94, 149,
            225, 163,
        ];
        let txbodyhash = TxHash([
            46, 98, 186, 242, 236, 242, 223, 12, 166, 121, 139, 80, 248, 227, 165, 198, 165, 96,
            250, 47, 74, 107, 155, 237, 0, 45, 205, 42, 174, 181, 65, 95,
        ]);
        let sk = Ed25519Key::from_bytes(&[
            198, 96, 229, 3, 21, 215, 106, 83, 216, 7, 50, 239, 218, 118, 48, 202, 232, 136, 93,
            251, 133, 196, 99, 120, 104, 75, 60, 97, 3, 225, 40, 74,
        ]);
        let expected_sig = [
            157, 212, 245, 1, 76, 138, 152, 118, 2, 149, 83, 50, 16, 187, 78, 95, 188, 111, 132,
            151, 118, 158, 62, 252, 174, 111, 33, 157, 18, 252, 18, 227, 6, 240, 72, 120, 184, 230,
            235, 157, 209, 37, 169, 207, 113, 59, 54, 49, 199, 129, 47, 233, 202, 240, 137, 77, 81,
            57, 106, 127, 203, 160, 86, 0,
        ];

        let mut r = cbored::Reader::new(&body);
        let txbody: TransactionBody = r.decode().unwrap();
        let got_hash = txbody.hash();

        assert_eq!(txbodyhash, got_hash);

        let witness = sk.to_witness(&txbodyhash);

        assert_eq!(witness.signature.as_bytes(), &expected_sig);

        assert_eq!(
            witness.vkey.verify(&witness.signature, &txbodyhash.0),
            SignatureVerification::Passed
        );
    }
    */
}