Merge pull request #48 from Emurgo/updates-gen

Added in Update type

Author: rooooooooob

rust/pkg/cardano_serialization_lib.js.flow

@@ -839,6 +839,43 @@ declare export class GenesisHash {
    */
   static from_bytes(bytes: Uint8Array): GenesisHash;
 }
+/**
+ */
+declare export class GenesisHashes {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {GenesisHashes}
+   */
+  static from_bytes(bytes: Uint8Array): GenesisHashes;
+
+  /**
+   * @returns {GenesisHashes}
+   */
+  static new(): GenesisHashes;
+
+  /**
+   * @returns {number}
+   */
+  len(): number;
+
+  /**
+   * @param {number} index
+   * @returns {GenesisHash}
+   */
+  get(index: number): GenesisHash;
+
+  /**
+   * @param {GenesisHash} elem
+   */
+  add(elem: GenesisHash): void;
+}
 /**
  */
 declare export class GenesisKeyDelegation {
@@ -1372,6 +1409,38 @@ declare export class MultisigScripts {
    */
   add(elem: MultisigScript): void;
 }
+/**
+ */
+declare export class Nonce {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {Nonce}
+   */
+  static from_bytes(bytes: Uint8Array): Nonce;
+
+  /**
+   * @returns {Nonce}
+   */
+  static new_identity(): Nonce;
+
+  /**
+   * @param {Uint8Array} hash
+   * @returns {Nonce}
+   */
+  static new_from_hash(hash: Uint8Array): Nonce;
+
+  /**
+   * @returns {Uint8Array | void}
+   */
+  get_hash(): Uint8Array | void;
+}
 /**
  */
 declare export class Pointer {
@@ -1664,6 +1733,304 @@ declare export class PrivateKey {
    */
   sign(message: Uint8Array): Ed25519Signature;
 }
+/**
+ */
+declare export class ProposedProtocolParameterUpdates {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {ProposedProtocolParameterUpdates}
+   */
+  static from_bytes(bytes: Uint8Array): ProposedProtocolParameterUpdates;
+
+  /**
+   * @returns {ProposedProtocolParameterUpdates}
+   */
+  static new(): ProposedProtocolParameterUpdates;
+
+  /**
+   * @returns {number}
+   */
+  len(): number;
+
+  /**
+   * @param {GenesisHash} key
+   * @param {ProtocolParamUpdate} value
+   * @returns {ProtocolParamUpdate | void}
+   */
+  insert(
+    key: GenesisHash,
+    value: ProtocolParamUpdate
+  ): ProtocolParamUpdate | void;
+
+  /**
+   * @param {GenesisHash} key
+   * @returns {ProtocolParamUpdate | void}
+   */
+  get(key: GenesisHash): ProtocolParamUpdate | void;
+
+  /**
+   * @returns {GenesisHashes}
+   */
+  keys(): GenesisHashes;
+}
+/**
+ */
+declare export class ProtocolParamUpdate {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {ProtocolParamUpdate}
+   */
+  static from_bytes(bytes: Uint8Array): ProtocolParamUpdate;
+
+  /**
+   * @param {BigNum} minfee_a
+   */
+  set_minfee_a(minfee_a: BigNum): void;
+
+  /**
+   * @returns {BigNum | void}
+   */
+  minfee_a(): BigNum | void;
+
+  /**
+   * @param {BigNum} minfee_b
+   */
+  set_minfee_b(minfee_b: BigNum): void;
+
+  /**
+   * @returns {BigNum | void}
+   */
+  minfee_b(): BigNum | void;
+
+  /**
+   * @param {number} max_block_body_size
+   */
+  set_max_block_body_size(max_block_body_size: number): void;
+
+  /**
+   * @returns {number | void}
+   */
+  max_block_body_size(): number | void;
+
+  /**
+   * @param {number} max_tx_size
+   */
+  set_max_tx_size(max_tx_size: number): void;
+
+  /**
+   * @returns {number | void}
+   */
+  max_tx_size(): number | void;
+
+  /**
+   * @param {number} max_block_header_size
+   */
+  set_max_block_header_size(max_block_header_size: number): void;
+
+  /**
+   * @returns {number | void}
+   */
+  max_block_header_size(): number | void;
+
+  /**
+   * @param {BigNum} key_deposit
+   */
+  set_key_deposit(key_deposit: BigNum): void;
+
+  /**
+   * @returns {BigNum | void}
+   */
+  key_deposit(): BigNum | void;
+
+  /**
+   * @param {BigNum} pool_deposit
+   */
+  set_pool_deposit(pool_deposit: BigNum): void;
+
+  /**
+   * @returns {BigNum | void}
+   */
+  pool_deposit(): BigNum | void;
+
+  /**
+   * @param {number} max_epoch
+   */
+  set_max_epoch(max_epoch: number): void;
+
+  /**
+   * @returns {number | void}
+   */
+  max_epoch(): number | void;
+
+  /**
+   * @param {number} n_opt
+   */
+  set_n_opt(n_opt: number): void;
+
+  /**
+   * @returns {number | void}
+   */
+  n_opt(): number | void;
+
+  /**
+   * @param {UnitInterval} pool_pledge_influence
+   */
+  set_pool_pledge_influence(pool_pledge_influence: UnitInterval): void;
+
+  /**
+   * @returns {UnitInterval | void}
+   */
+  pool_pledge_influence(): UnitInterval | void;
+
+  /**
+   * @param {UnitInterval} expansion_rate
+   */
+  set_expansion_rate(expansion_rate: UnitInterval): void;
+
+  /**
+   * @returns {UnitInterval | void}
+   */
+  expansion_rate(): UnitInterval | void;
+
+  /**
+   * @param {UnitInterval} treasury_growth_rate
+   */
+  set_treasury_growth_rate(treasury_growth_rate: UnitInterval): void;
+
+  /**
+   * @returns {UnitInterval | void}
+   */
+  treasury_growth_rate(): UnitInterval | void;
+
+  /**
+   * @param {UnitInterval} d
+   */
+  set_d(d: UnitInterval): void;
+
+  /**
+   * @returns {UnitInterval | void}
+   */
+  d(): UnitInterval | void;
+
+  /**
+   * @param {Nonce} extra_entropy
+   */
+  set_extra_entropy(extra_entropy: Nonce): void;
+
+  /**
+   * @returns {Nonce | void}
+   */
+  extra_entropy(): Nonce | void;
+
+  /**
+   * @param {ProtocolVersions} protocol_version
+   */
+  set_protocol_version(protocol_version: ProtocolVersions): void;
+
+  /**
+   * @returns {ProtocolVersions | void}
+   */
+  protocol_version(): ProtocolVersions | void;
+
+  /**
+   * @param {BigNum} min_utxo_value
+   */
+  set_min_utxo_value(min_utxo_value: BigNum): void;
+
+  /**
+   * @returns {BigNum | void}
+   */
+  min_utxo_value(): BigNum | void;
+
+  /**
+   * @returns {ProtocolParamUpdate}
+   */
+  static new(): ProtocolParamUpdate;
+}
+/**
+ */
+declare export class ProtocolVersion {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {ProtocolVersion}
+   */
+  static from_bytes(bytes: Uint8Array): ProtocolVersion;
+
+  /**
+   * @returns {number}
+   */
+  major(): number;
+
+  /**
+   * @returns {number}
+   */
+  minor(): number;
+
+  /**
+   * @param {number} major
+   * @param {number} minor
+   * @returns {ProtocolVersion}
+   */
+  static new(major: number, minor: number): ProtocolVersion;
+}
+/**
+ */
+declare export class ProtocolVersions {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {ProtocolVersions}
+   */
+  static from_bytes(bytes: Uint8Array): ProtocolVersions;
+
+  /**
+   * @returns {ProtocolVersions}
+   */
+  static new(): ProtocolVersions;
+
+  /**
+   * @returns {number}
+   */
+  len(): number;
+
+  /**
+   * @param {number} index
+   * @returns {ProtocolVersion}
+   */
+  get(index: number): ProtocolVersion;
+
+  /**
+   * @param {ProtocolVersion} elem
+   */
+  add(elem: ProtocolVersion): void;
+}
 /**
  * ED25519 key used as public key
  */
@@ -2247,6 +2614,16 @@ declare export class TransactionBody {
    */
   withdrawals(): Withdrawals | void;
 
+  /**
+   * @param {Update} update
+   */
+  set_update(update: Update): void;
+
+  /**
+   * @returns {Update | void}
+   */
+  update(): Update | void;
+
   /**
    * @param {MetadataHash} metadata_hash
    */
@@ -2839,6 +3216,42 @@ declare export class UnitInterval {
    */
   static new(numerator: BigNum, denominator: BigNum): UnitInterval;
 }
+/**
+ */
+declare export class Update {
+  free(): void;
+
+  /**
+   * @returns {Uint8Array}
+   */
+  to_bytes(): Uint8Array;
+
+  /**
+   * @param {Uint8Array} bytes
+   * @returns {Update}
+   */
+  static from_bytes(bytes: Uint8Array): Update;
+
+  /**
+   * @returns {ProposedProtocolParameterUpdates}
+   */
+  proposed_protocol_parameter_updates(): ProposedProtocolParameterUpdates;
+
+  /**
+   * @returns {number}
+   */
+  epoch(): number;
+
+  /**
+   * @param {ProposedProtocolParameterUpdates} proposed_protocol_parameter_updates
+   * @param {number} epoch
+   * @returns {Update}
+   */
+  static new(
+    proposed_protocol_parameter_updates: ProposedProtocolParameterUpdates,
+    epoch: number
+  ): Update;
+}
 /**
  */
 declare export class VRFKeyHash {

rust/src/crypto.rs

@@ -727,4 +727,116 @@ impl_hash_type!(TransactionHash, 32);
 impl_hash_type!(GenesisDelegateHash, 28);
 impl_hash_type!(GenesisHash, 28);
 impl_hash_type!(MetadataHash, 32);
-impl_hash_type!(VRFKeyHash, 28);
+impl_hash_type!(VRFKeyHash, 28);
+
+// Evolving nonce type (used for Update's crypto)
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Nonce {
+    hash: Option<[u8; 32]>,
+}
+
+to_from_bytes!(Nonce);
+
+// can't export consts via wasm_bindgen
+impl Nonce {
+    pub const HASH_LEN: usize = 32;
+}
+
+#[wasm_bindgen]
+impl Nonce {
+    pub fn new_identity() -> Nonce {
+        Self {
+            hash: None,
+        }
+    }
+
+    pub fn new_from_hash(hash: Vec<u8>) -> Result<Nonce, JsValue> {
+        use std::convert::TryInto;
+        match hash[..Self::HASH_LEN].try_into() {
+            Ok(bytes_correct_size) => Ok(Self {
+                hash: Some(bytes_correct_size),
+            }),
+            Err(e) => Err(JsValue::from_str(&e.to_string())),
+        }
+    }
+
+    pub fn get_hash(&self) -> Option<Vec<u8>> {
+        Some(self.hash?.to_vec())
+
+    }
+}
+
+impl cbor_event::se::Serialize for Nonce {
+    fn serialize<'se, W: std::io::Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        match &self.hash {
+            Some(hash) => {
+                serializer.write_array(cbor_event::Len::Len(2))?;
+                serializer.write_unsigned_integer(1)?;
+                serializer.write_bytes(hash)
+            },
+            None => {
+                serializer.write_array(cbor_event::Len::Len(1))?;
+                serializer.write_unsigned_integer(0)
+            },
+        }
+    }
+}
+
+impl Deserialize for Nonce {
+    fn deserialize<R: std::io::BufRead>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        use std::convert::TryInto;
+        (|| -> Result<Self, DeserializeError> {
+            let len = raw.array()?;
+            let hash = match raw.unsigned_integer()? {
+                0 => None,
+                1 => {
+                    let bytes = raw.bytes()?;
+                    if bytes.len() != Self::HASH_LEN {
+                        return Err(DeserializeFailure::CBOR(cbor_event::Error::WrongLen(Self::HASH_LEN as u64, cbor_event::Len::Len(bytes.len() as u64), "hash length")).into());
+                    }
+                    Some(bytes[..Self::HASH_LEN].try_into().unwrap())
+                },
+                _ => return Err(DeserializeFailure::NoVariantMatched.into()),
+            };
+            match len {
+                cbor_event::Len::Len(n) => {
+                    let correct_len = match n {
+                        1 => hash.is_none(),
+                        2 => hash.is_some(),
+                        _ => false,
+                    };
+                    if !correct_len {
+                        return Err(DeserializeFailure::NoVariantMatched.into());
+                    }
+                },
+                cbor_event::Len::Indefinite => match raw.special()? {
+                    CBORSpecial::Break => /* it's ok */(),
+                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
+                },
+            };
+            Ok(Self {
+                hash,
+            })
+        })().map_err(|e| e.annotate(stringify!($name)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn nonce_identity() {
+        let orig = Nonce::new_identity();
+        let deser = Nonce::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_bytes()))).unwrap();
+        assert_eq!(orig.to_bytes(), deser.to_bytes());
+    }
+
+    #[test]
+    fn nonce_hash() {
+        let orig = Nonce::new_from_hash(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]).unwrap();
+        let deser = Nonce::deserialize(&mut Deserializer::from(std::io::Cursor::new(orig.to_bytes()))).unwrap();
+        assert_eq!(orig.to_bytes(), deser.to_bytes());
+    }
+}

rust/src/lib.rs

@@ -49,6 +49,7 @@ impl UnitInterval {
     }
 }
 
+type Rational = UnitInterval;
 type Epoch = u32;
 type Slot = u32;
 
@@ -174,6 +175,7 @@ pub struct TransactionBody {
     ttl: u32,
     certs: Option<Certificates>,
     withdrawals: Option<Withdrawals>,
+    update: Option<Update>,
     metadata_hash: Option<MetadataHash>,
 }
 
@@ -213,6 +215,13 @@ impl TransactionBody {
         self.withdrawals.clone()
     }
 
+    pub fn set_update(&mut self, update: &Update) {
+        self.update = Some(update.clone())
+    }
+
+    pub fn update(&self) -> Option<Update> {
+        self.update.clone()
+    }
     pub fn set_metadata_hash(&mut self, metadata_hash: &MetadataHash) {
         self.metadata_hash = Some(metadata_hash.clone())
     }
@@ -230,6 +239,7 @@ impl TransactionBody {
             ttl: ttl,
             certs: None,
             withdrawals: None,
+            update: None,
             metadata_hash: None,
         }
     }
@@ -1462,4 +1472,314 @@ impl MultisigScript {
             _ => None,
         }
     }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Update {
+    proposed_protocol_parameter_updates: ProposedProtocolParameterUpdates,
+    epoch: Epoch,
+}
+
+to_from_bytes!(Update);
+
+#[wasm_bindgen]
+impl Update {
+    pub fn proposed_protocol_parameter_updates(&self) -> ProposedProtocolParameterUpdates {
+        self.proposed_protocol_parameter_updates.clone()
+    }
+
+    pub fn epoch(&self) -> Epoch {
+        self.epoch.clone()
+    }
+
+    pub fn new(proposed_protocol_parameter_updates: &ProposedProtocolParameterUpdates, epoch: Epoch) -> Self {
+        Self {
+            proposed_protocol_parameter_updates: proposed_protocol_parameter_updates.clone(),
+            epoch: epoch.clone(),
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct GenesisHashes(Vec<GenesisHash>);
+
+to_from_bytes!(GenesisHashes);
+
+#[wasm_bindgen]
+impl GenesisHashes {
+    pub fn new() -> Self {
+        Self(Vec::new())
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn get(&self, index: usize) -> GenesisHash {
+        self.0[index].clone()
+    }
+
+    pub fn add(&mut self, elem: &GenesisHash) {
+        self.0.push(elem.clone());
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct ProposedProtocolParameterUpdates(std::collections::BTreeMap<GenesisHash, ProtocolParamUpdate>);
+
+to_from_bytes!(ProposedProtocolParameterUpdates);
+
+#[wasm_bindgen]
+impl ProposedProtocolParameterUpdates {
+    pub fn new() -> Self {
+        Self(std::collections::BTreeMap::new())
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn insert(&mut self, key: &GenesisHash, value: &ProtocolParamUpdate) -> Option<ProtocolParamUpdate> {
+        self.0.insert(key.clone(), value.clone())
+    }
+
+    pub fn get(&self, key: &GenesisHash) -> Option<ProtocolParamUpdate> {
+        self.0.get(key).map(|v| v.clone())
+    }
+
+    pub fn keys(&self) -> GenesisHashes {
+        GenesisHashes(self.0.iter().map(|(k, _v)| k.clone()).collect::<Vec<GenesisHash>>())
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct ProtocolVersion {
+    major: u32,
+    minor: u32,
+}
+
+to_from_bytes!(ProtocolVersion);
+
+#[wasm_bindgen]
+impl ProtocolVersion {
+    pub fn major(&self) -> u32 {
+        self.major
+    }
+
+    pub fn minor(&self) -> u32 {
+        self.minor
+    }
+
+    pub fn new(major: u32, minor: u32) -> Self {
+        Self {
+            major,
+            minor,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct ProtocolVersions(Vec<ProtocolVersion>);
+
+to_from_bytes!(ProtocolVersions);
+
+#[wasm_bindgen]
+impl ProtocolVersions {
+    pub fn new() -> Self {
+        Self(Vec::new())
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn get(&self, index: usize) -> ProtocolVersion {
+        self.0[index].clone()
+    }
+
+    pub fn add(&mut self, elem: &ProtocolVersion) {
+        self.0.push(elem.clone());
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct ProtocolParamUpdate {
+    minfee_a: Option<Coin>,
+    minfee_b: Option<Coin>,
+    max_block_body_size: Option<u32>,
+    max_tx_size: Option<u32>,
+    max_block_header_size: Option<u32>,
+    key_deposit: Option<Coin>,
+    pool_deposit: Option<Coin>,
+    max_epoch: Option<Epoch>,
+    // desired number of stake pools
+    n_opt: Option<u32>,
+    pool_pledge_influence: Option<Rational>,
+    expansion_rate: Option<UnitInterval>,
+    treasury_growth_rate: Option<UnitInterval>,
+    // decentralization constant
+    d: Option<UnitInterval>,
+    extra_entropy: Option<Nonce>,
+    protocol_version: Option<ProtocolVersions>,
+    min_utxo_value: Option<Coin>,
+}
+
+to_from_bytes!(ProtocolParamUpdate);
+
+#[wasm_bindgen]
+impl ProtocolParamUpdate {
+    pub fn set_minfee_a(&mut self, minfee_a: &Coin) {
+        self.minfee_a = Some(minfee_a.clone())
+    }
+
+    pub fn minfee_a(&self) -> Option<Coin> {
+        self.minfee_a.clone()
+    }
+
+    pub fn set_minfee_b(&mut self, minfee_b: &Coin) {
+        self.minfee_b = Some(minfee_b.clone())
+    }
+
+    pub fn minfee_b(&self) -> Option<Coin> {
+        self.minfee_b.clone()
+    }
+
+    pub fn set_max_block_body_size(&mut self, max_block_body_size: u32) {
+        self.max_block_body_size = Some(max_block_body_size)
+    }
+
+    pub fn max_block_body_size(&self) -> Option<u32> {
+        self.max_block_body_size.clone()
+    }
+
+    pub fn set_max_tx_size(&mut self, max_tx_size: u32) {
+        self.max_tx_size = Some(max_tx_size)
+    }
+
+    pub fn max_tx_size(&self) -> Option<u32> {
+        self.max_tx_size.clone()
+    }
+
+    pub fn set_max_block_header_size(&mut self, max_block_header_size: u32) {
+        self.max_block_header_size = Some(max_block_header_size)
+    }
+
+    pub fn max_block_header_size(&self) -> Option<u32> {
+        self.max_block_header_size.clone()
+    }
+
+    pub fn set_key_deposit(&mut self, key_deposit: &Coin) {
+        self.key_deposit = Some(key_deposit.clone())
+    }
+
+    pub fn key_deposit(&self) -> Option<Coin> {
+        self.key_deposit.clone()
+    }
+
+    pub fn set_pool_deposit(&mut self, pool_deposit: &Coin) {
+        self.pool_deposit = Some(pool_deposit.clone())
+    }
+
+    pub fn pool_deposit(&self) -> Option<Coin> {
+        self.pool_deposit.clone()
+    }
+
+    pub fn set_max_epoch(&mut self, max_epoch: Epoch) {
+        self.max_epoch = Some(max_epoch.clone())
+    }
+
+    pub fn max_epoch(&self) -> Option<Epoch> {
+        self.max_epoch.clone()
+    }
+
+    pub fn set_n_opt(&mut self, n_opt: u32) {
+        self.n_opt = Some(n_opt)
+    }
+
+    pub fn n_opt(&self) -> Option<u32> {
+        self.n_opt.clone()
+    }
+
+    pub fn set_pool_pledge_influence(&mut self, pool_pledge_influence: &Rational) {
+        self.pool_pledge_influence = Some(pool_pledge_influence.clone())
+    }
+
+    pub fn pool_pledge_influence(&self) -> Option<Rational> {
+        self.pool_pledge_influence.clone()
+    }
+
+    pub fn set_expansion_rate(&mut self, expansion_rate: &UnitInterval) {
+        self.expansion_rate = Some(expansion_rate.clone())
+    }
+
+    pub fn expansion_rate(&self) -> Option<UnitInterval> {
+        self.expansion_rate.clone()
+    }
+
+    pub fn set_treasury_growth_rate(&mut self, treasury_growth_rate: &UnitInterval) {
+        self.treasury_growth_rate = Some(treasury_growth_rate.clone())
+    }
+
+    pub fn treasury_growth_rate(&self) -> Option<UnitInterval> {
+        self.treasury_growth_rate.clone()
+    }
+
+    pub fn set_d(&mut self, d: &UnitInterval) {
+        self.d = Some(d.clone())
+    }
+
+    pub fn d(&self) -> Option<UnitInterval> {
+        self.d.clone()
+    }
+
+    pub fn set_extra_entropy(&mut self, extra_entropy: &Nonce) {
+        self.extra_entropy = Some(extra_entropy.clone())
+    }
+
+    pub fn extra_entropy(&self) -> Option<Nonce> {
+        self.extra_entropy.clone()
+    }
+
+    pub fn set_protocol_version(&mut self, protocol_version: &ProtocolVersions) {
+        self.protocol_version = Some(protocol_version.clone())
+    }
+
+    pub fn protocol_version(&self) -> Option<ProtocolVersions> {
+        self.protocol_version.clone()
+    }
+
+    pub fn set_min_utxo_value(&mut self, min_utxo_value: &Coin) {
+        self.min_utxo_value = Some(min_utxo_value.clone())
+    }
+
+    pub fn min_utxo_value(&self) -> Option<Coin> {
+        self.min_utxo_value.clone()
+    }
+
+    pub fn new() -> Self {
+        Self {
+            minfee_a: None,
+            minfee_b: None,
+            max_block_body_size: None,
+            max_tx_size: None,
+            max_block_header_size: None,
+            key_deposit: None,
+            pool_deposit: None,
+            max_epoch: None,
+            n_opt: None,
+            pool_pledge_influence: None,
+            expansion_rate: None,
+            treasury_growth_rate: None,
+            d: None,
+            extra_entropy: None,
+            protocol_version: None,
+            min_utxo_value: None,
+        }
+    }
 }

rust/src/serialization.rs

@@ -218,6 +218,10 @@ impl cbor_event::se::Serialize for TransactionBody {
             serializer.write_unsigned_integer(5)?;
             field.serialize(serializer)?;
         }
+        if let Some(field) = &self.update {
+            serializer.write_unsigned_integer(6)?;
+            field.serialize(serializer)?;
+        }
         if let Some(field) = &self.metadata_hash {
             serializer.write_unsigned_integer(7)?;
             field.serialize(serializer)?;
@@ -243,6 +247,7 @@ impl DeserializeEmbeddedGroup for TransactionBody {
         let mut ttl = None;
         let mut certs = None;
         let mut withdrawals = None;
+        let mut update = None;
         let mut metadata_hash = None;
         let mut read = 0;
         while match len { cbor_event::Len::Len(n) => read < n as usize, cbor_event::Len::Indefinite => true, } {
@@ -296,6 +301,14 @@ impl DeserializeEmbeddedGroup for TransactionBody {
                             Ok(Withdrawals::deserialize(raw)?)
                         })().map_err(|e| e.annotate("withdrawals"))?);
                     },
+                    6 =>  {
+                        if update.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
+                        }
+                        update = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Update::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("update"))?);
+                    },
                     7 =>  {
                         if metadata_hash.is_some() {
                             return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
@@ -343,6 +356,7 @@ impl DeserializeEmbeddedGroup for TransactionBody {
             ttl,
             certs,
             withdrawals,
+            update,
             metadata_hash,
         })
     }
@@ -2144,4 +2158,448 @@ impl Deserialize for MultisigScript {
     fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
         Ok(Self(MultisigScriptEnum::deserialize(raw)?))
     }
+}
+
+impl cbor_event::se::Serialize for Update {
+    fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        serializer.write_array(cbor_event::Len::Len(2))?;
+        self.proposed_protocol_parameter_updates.serialize(serializer)?;
+        self.epoch.serialize(serializer)?;
+        Ok(serializer)
+    }
+}
+
+impl Deserialize for Update {
+    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        (|| -> Result<_, DeserializeError> {
+            let len = raw.array()?;
+            let ret = Self::deserialize_as_embedded_group(raw, len);
+            match len {
+                cbor_event::Len::Len(_) => /* TODO: check finite len somewhere */(),
+                cbor_event::Len::Indefinite => match raw.special()? {
+                    CBORSpecial::Break => /* it's ok */(),
+                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
+                },
+            }
+            ret
+        })().map_err(|e| e.annotate("Update"))
+    }
+}
+
+impl DeserializeEmbeddedGroup for Update {
+    fn deserialize_as_embedded_group<R: BufRead + Seek>(raw: &mut Deserializer<R>, len: cbor_event::Len) -> Result<Self, DeserializeError> {
+        let proposed_protocol_parameter_updates = (|| -> Result<_, DeserializeError> {
+            Ok(ProposedProtocolParameterUpdates::deserialize(raw)?)
+        })().map_err(|e| e.annotate("proposed_protocol_parameter_updates"))?;
+        let epoch = (|| -> Result<_, DeserializeError> {
+            Ok(Epoch::deserialize(raw)?)
+        })().map_err(|e| e.annotate("epoch"))?;
+        Ok(Update {
+            proposed_protocol_parameter_updates,
+            epoch,
+        })
+    }
+}
+
+impl cbor_event::se::Serialize for GenesisHashes {
+    fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
+        for element in &self.0 {
+            element.serialize(serializer)?;
+        }
+        Ok(serializer)
+    }
+}
+
+impl Deserialize for GenesisHashes {
+    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        let mut arr = Vec::new();
+        (|| -> Result<_, DeserializeError> {
+            let len = raw.array()?;
+            while match len { cbor_event::Len::Len(n) => arr.len() < n as usize, cbor_event::Len::Indefinite => true, } {
+                if raw.cbor_type()? == CBORType::Special {
+                    assert_eq!(raw.special()?, CBORSpecial::Break);
+                    break;
+                }
+                arr.push(GenesisHash::deserialize(raw)?);
+            }
+            Ok(())
+        })().map_err(|e| e.annotate("Genesishashes"))?;
+        Ok(Self(arr))
+    }
+}
+
+impl cbor_event::se::Serialize for ProposedProtocolParameterUpdates {
+    fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
+        for (key, value) in &self.0 {
+            key.serialize(serializer)?;
+            value.serialize(serializer)?;
+        }
+        Ok(serializer)
+    }
+}
+
+impl Deserialize for ProposedProtocolParameterUpdates {
+    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        let mut table = std::collections::BTreeMap::new();
+        (|| -> Result<_, DeserializeError> {
+            let len = raw.map()?;
+            while match len { cbor_event::Len::Len(n) => table.len() < n as usize, cbor_event::Len::Indefinite => true, } {
+                if raw.cbor_type()? == CBORType::Special {
+                    assert_eq!(raw.special()?, CBORSpecial::Break);
+                    break;
+                }
+                let key = GenesisHash::deserialize(raw)?;
+                let value = ProtocolParamUpdate::deserialize(raw)?;
+                if table.insert(key.clone(), value).is_some() {
+                    return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
+                }
+            }
+            Ok(())
+        })().map_err(|e| e.annotate("ProposedProtocolParameterUpdates"))?;
+        Ok(Self(table))
+    }
+}
+
+impl cbor_event::se::Serialize for ProtocolVersion {
+    fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        serializer.write_array(cbor_event::Len::Len(2))?;
+        self.serialize_as_embedded_group(serializer)
+    }
+}
+
+impl SerializeEmbeddedGroup for ProtocolVersion {
+    fn serialize_as_embedded_group<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        self.major.serialize(serializer)?;
+        self.minor.serialize(serializer)?;
+        Ok(serializer)
+    }
+}
+
+impl Deserialize for ProtocolVersion {
+    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        (|| -> Result<_, DeserializeError> {
+            let len = raw.array()?;
+            let ret = Self::deserialize_as_embedded_group(raw, len);
+            match len {
+                cbor_event::Len::Len(_) => /* TODO: check finite len somewhere */(),
+                cbor_event::Len::Indefinite => match raw.special()? {
+                    CBORSpecial::Break => /* it's ok */(),
+                    _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
+                },
+            }
+            ret
+        })().map_err(|e| e.annotate("ProtocolVersion"))
+    }
+}
+
+impl DeserializeEmbeddedGroup for ProtocolVersion {
+    fn deserialize_as_embedded_group<R: BufRead + Seek>(raw: &mut Deserializer<R>, len: cbor_event::Len) -> Result<Self, DeserializeError> {
+        let major = (|| -> Result<_, DeserializeError> {
+            Ok(u32::deserialize(raw)?)
+        })().map_err(|e| e.annotate("major"))?;
+        let minor = (|| -> Result<_, DeserializeError> {
+            Ok(u32::deserialize(raw)?)
+        })().map_err(|e| e.annotate("minor"))?;
+        Ok(ProtocolVersion {
+            major,
+            minor,
+        })
+    }
+}
+
+impl cbor_event::se::Serialize for ProtocolVersions {
+    fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        serializer.write_array(cbor_event::Len::Len(self.0.len() as u64))?;
+        for element in &self.0 {
+            element.serialize_as_embedded_group(serializer)?;
+        }
+        Ok(serializer)
+    }
+}
+
+impl Deserialize for ProtocolVersions {
+    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        let mut arr = Vec::new();
+        (|| -> Result<_, DeserializeError> {
+            let len = raw.array()?;
+            while match len { cbor_event::Len::Len(n) => arr.len() < n as usize, cbor_event::Len::Indefinite => true, } {
+                if raw.cbor_type()? == CBORType::Special {
+                    assert_eq!(raw.special()?, CBORSpecial::Break);
+                    break;
+                }
+                arr.push(ProtocolVersion::deserialize_as_embedded_group(raw, len)?);
+            }
+            Ok(())
+        })().map_err(|e| e.annotate("ProtocolVersions"))?;
+        Ok(Self(arr))
+    }
+}
+
+impl cbor_event::se::Serialize for ProtocolParamUpdate {
+    fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
+        serializer.write_map(cbor_event::Len::Len(match &self.minfee_a { Some(x) => 1, None => 0 } + match &self.minfee_b { Some(x) => 1, None => 0 } + match &self.max_block_body_size { Some(x) => 1, None => 0 } + match &self.max_tx_size { Some(x) => 1, None => 0 } + match &self.max_block_header_size { Some(x) => 1, None => 0 } + match &self.key_deposit { Some(x) => 1, None => 0 } + match &self.pool_deposit { Some(x) => 1, None => 0 } + match &self.max_epoch { Some(x) => 1, None => 0 } + match &self.n_opt { Some(x) => 1, None => 0 } + match &self.pool_pledge_influence { Some(x) => 1, None => 0 } + match &self.expansion_rate { Some(x) => 1, None => 0 } + match &self.treasury_growth_rate { Some(x) => 1, None => 0 } + match &self.d { Some(x) => 1, None => 0 } + match &self.extra_entropy { Some(x) => 1, None => 0 } + match &self.protocol_version { Some(x) => 1, None => 0 } + match &self.min_utxo_value { Some(x) => 1, None => 0 }))?;
+        if let Some(field) = &self.minfee_a {
+            serializer.write_unsigned_integer(0)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.minfee_b {
+            serializer.write_unsigned_integer(1)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.max_block_body_size {
+            serializer.write_unsigned_integer(2)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.max_tx_size {
+            serializer.write_unsigned_integer(3)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.max_block_header_size {
+            serializer.write_unsigned_integer(4)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.key_deposit {
+            serializer.write_unsigned_integer(5)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.pool_deposit {
+            serializer.write_unsigned_integer(6)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.max_epoch {
+            serializer.write_unsigned_integer(7)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.n_opt {
+            serializer.write_unsigned_integer(8)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.pool_pledge_influence {
+            serializer.write_unsigned_integer(9)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.expansion_rate {
+            serializer.write_unsigned_integer(10)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.treasury_growth_rate {
+            serializer.write_unsigned_integer(11)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.d {
+            serializer.write_unsigned_integer(12)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.extra_entropy {
+            serializer.write_unsigned_integer(13)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.protocol_version {
+            serializer.write_unsigned_integer(14)?;
+            field.serialize(serializer)?;
+        }
+        if let Some(field) = &self.min_utxo_value {
+            serializer.write_unsigned_integer(15)?;
+            field.serialize(serializer)?;
+        }
+        Ok(serializer)
+    }
+}
+
+impl Deserialize for ProtocolParamUpdate {
+    fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
+        (|| -> Result<_, DeserializeError> {
+            let len = raw.map()?;
+            Self::deserialize_as_embedded_group(raw, len)
+        })().map_err(|e| e.annotate("ProtocolParamUpdate"))
+    }
+}
+
+impl DeserializeEmbeddedGroup for ProtocolParamUpdate {
+    fn deserialize_as_embedded_group<R: BufRead + Seek>(raw: &mut Deserializer<R>, len: cbor_event::Len) -> Result<Self, DeserializeError> {
+        let mut minfee_a = None;
+        let mut minfee_b = None;
+        let mut max_block_body_size = None;
+        let mut max_tx_size = None;
+        let mut max_block_header_size = None;
+        let mut key_deposit = None;
+        let mut pool_deposit = None;
+        let mut max_epoch = None;
+        let mut n_opt = None;
+        let mut pool_pledge_influence = None;
+        let mut expansion_rate = None;
+        let mut treasury_growth_rate = None;
+        let mut d = None;
+        let mut extra_entropy = None;
+        let mut protocol_version = None;
+        let mut min_utxo_value = None;
+        let mut read = 0;
+        while match len { cbor_event::Len::Len(n) => read < n as usize, cbor_event::Len::Indefinite => true, } {
+            match raw.cbor_type()? {
+                CBORType::UnsignedInteger => match raw.unsigned_integer()? {
+                    0 =>  {
+                        if minfee_a.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(0)).into());
+                        }
+                        minfee_a = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Coin::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("minfee_a"))?);
+                    },
+                    1 =>  {
+                        if minfee_b.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(1)).into());
+                        }
+                        minfee_b = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Coin::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("minfee_b"))?);
+                    },
+                    2 =>  {
+                        if max_block_body_size.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(2)).into());
+                        }
+                        max_block_body_size = Some((|| -> Result<_, DeserializeError> {
+                            Ok(u32::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("max_block_body_size"))?);
+                    },
+                    3 =>  {
+                        if max_tx_size.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(3)).into());
+                        }
+                        max_tx_size = Some((|| -> Result<_, DeserializeError> {
+                            Ok(u32::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("max_tx_size"))?);
+                    },
+                    4 =>  {
+                        if max_block_header_size.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(4)).into());
+                        }
+                        max_block_header_size = Some((|| -> Result<_, DeserializeError> {
+                            Ok(u32::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("max_block_header_size"))?);
+                    },
+                    5 =>  {
+                        if key_deposit.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(5)).into());
+                        }
+                        key_deposit = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Coin::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("key_deposit"))?);
+                    },
+                    6 =>  {
+                        if pool_deposit.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(6)).into());
+                        }
+                        pool_deposit = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Coin::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("pool_deposit"))?);
+                    },
+                    7 =>  {
+                        if max_epoch.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(7)).into());
+                        }
+                        max_epoch = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Epoch::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("max_epoch"))?);
+                    },
+                    8 =>  {
+                        if n_opt.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(8)).into());
+                        }
+                        n_opt = Some((|| -> Result<_, DeserializeError> {
+                            Ok(u32::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("n_opt"))?);
+                    },
+                    9 =>  {
+                        if pool_pledge_influence.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
+                        }
+                        pool_pledge_influence = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Rational::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("pool_pledge_influence"))?);
+                    },
+                    10 =>  {
+                        if expansion_rate.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(10)).into());
+                        }
+                        expansion_rate = Some((|| -> Result<_, DeserializeError> {
+                            Ok(UnitInterval::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("expansion_rate"))?);
+                    },
+                    11 =>  {
+                        if treasury_growth_rate.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(11)).into());
+                        }
+                        treasury_growth_rate = Some((|| -> Result<_, DeserializeError> {
+                            Ok(UnitInterval::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("treasury_growth_rate"))?);
+                    },
+                    12 =>  {
+                        if d.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(12)).into());
+                        }
+                        d = Some((|| -> Result<_, DeserializeError> {
+                            Ok(UnitInterval::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("d"))?);
+                    },
+                    13 =>  {
+                        if extra_entropy.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(13)).into());
+                        }
+                        extra_entropy = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Nonce::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("extra_entropy"))?);
+                    },
+                    14 =>  {
+                        if protocol_version.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(14)).into());
+                        }
+                        protocol_version = Some((|| -> Result<_, DeserializeError> {
+                            Ok(ProtocolVersions::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("protocol_version"))?);
+                    },
+                    15 =>  {
+                        if min_utxo_value.is_some() {
+                            return Err(DeserializeFailure::DuplicateKey(Key::Uint(15)).into());
+                        }
+                        min_utxo_value = Some((|| -> Result<_, DeserializeError> {
+                            Ok(Coin::deserialize(raw)?)
+                        })().map_err(|e| e.annotate("min_utxo_value"))?);
+                    },
+                    unknown_key => return Err(DeserializeFailure::UnknownKey(Key::Uint(unknown_key)).into()),
+                },
+                CBORType::Text => match raw.text()?.as_str() {
+                    unknown_key => return Err(DeserializeFailure::UnknownKey(Key::Str(unknown_key.to_owned())).into()),
+                },
+                CBORType::Special => match len {
+                    cbor_event::Len::Len(_) => return Err(DeserializeFailure::BreakInDefiniteLen.into()),
+                    cbor_event::Len::Indefinite => match raw.special()? {
+                        CBORSpecial::Break => break,
+                        _ => return Err(DeserializeFailure::EndingBreakMissing.into()),
+                    },
+                },
+                other_type => return Err(DeserializeFailure::UnexpectedKeyType(other_type).into()),
+            }
+            read += 1;
+        }
+        Ok(Self {
+            minfee_a,
+            minfee_b,
+            max_block_body_size,
+            max_tx_size,
+            max_block_header_size,
+            key_deposit,
+            pool_deposit,
+            max_epoch,
+            n_opt,
+            pool_pledge_influence,
+            expansion_rate,
+            treasury_growth_rate,
+            d,
+            extra_entropy,
+            protocol_version,
+            min_utxo_value,
+        })
+    }
 }

rust/src/tx_builder.rs

@@ -316,6 +316,7 @@ impl TransactionBuilder {
             ttl: ttl,
             certs: self.certs.clone(),
             withdrawals: self.withdrawals.clone(),
+            update: None,
             metadata_hash: match &self.metadata {
                 None => None,
                 Some(x) => Some(utils::hash_metadata(x)),