fix pointer address decoder to follow cardano ledger logic

Author: lisicky

rust/src/protocol_types/address.rs

@@ -3,41 +3,6 @@ use crate::*;
 use bech32::ToBase32;
 use ed25519_bip32::XPub;
 
-// returns (Number represented, bytes read) if valid encoding
-// or None if decoding prematurely finished
-pub(crate) fn variable_nat_decode(bytes: &[u8], fallback_to_max: bool) -> Option<(u64, usize)> {
-    let mut output = 0u128;
-    let mut bytes_read = 0;
-    for byte in bytes {
-        if output < u64::MAX.into() || !fallback_to_max {
-            output = (output << 7) | (byte & 0x7F) as u128;
-        }
-        //Since Conway era forbids pointer addresses, technically such large numbers would not make sense on mainnet
-        if output > u64::MAX.into(){
-            if !fallback_to_max {
-                return None;
-            }
-            output = u64::MAX.into();
-        }
-        bytes_read += 1;
-        if (byte & 0x80) == 0 {
-            return Some((output as u64, bytes_read));
-        }
-    }
-    None
-}
-
-pub(crate) fn variable_nat_encode(mut num: u64) -> Vec<u8> {
-    let mut output = vec![num as u8 & 0x7F];
-    num /= 128;
-    while num > 0 {
-        output.push((num & 0x7F) as u8 | 0x80);
-        num /= 128;
-    }
-    output.reverse();
-    output
-}
-
 #[wasm_bindgen]
 #[derive(Debug, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum AddressKind {
@@ -375,9 +340,7 @@ impl Address {
                     0b0100_0000 | ((ptr.payment.kind() as u8) << 4) | (ptr.network & 0xF);
                 buf.push(header);
                 buf.extend(ptr.payment.to_raw_bytes());
-                buf.extend(variable_nat_encode(ptr.stake.slot.into()));
-                buf.extend(variable_nat_encode(ptr.stake.tx_index.into()));
-                buf.extend(variable_nat_encode(ptr.stake.cert_index.into()));
+                buf.extend(ptr.stake.to_bytes());
             }
             AddrType::Enterprise(enterprise) => {
                 let header: u8 = 0b0110_0000
@@ -479,7 +442,7 @@ impl Address {
                         let mut byte_index = 1;
                         let payment_cred = read_addr_cred(4, 1);
                         byte_index += HASH_LEN;
-                        match Self::decode_pointer(&data[byte_index..]) {
+                        match Pointer::from_bytes(&data[byte_index..]) {
                             Ok((pointer, offset)) => {
                                 byte_index += offset;
                                 if byte_index < data.len() && !ignore_leftover_bytes {
@@ -547,35 +510,6 @@ impl Address {
         .map_err(|e| e.annotate("Address"))
     }
 
-    fn decode_pointer(data: &[u8]) -> Result<(Pointer, usize), DeserializeError> {
-        let mut offset = 0;
-        let (slot, slot_bytes) = variable_nat_decode(&data, true).ok_or(DeserializeError::new(
-            "Address.Pointer.slot",
-            DeserializeFailure::VariableLenNatDecodeFailed,
-        ))?;
-        offset += slot_bytes;
-        let (tx_index, tx_bytes) =
-            variable_nat_decode(&data[offset..], true).ok_or(DeserializeError::new(
-                "Address.Pointer.tx_index",
-                DeserializeFailure::VariableLenNatDecodeFailed,
-            ))?;
-        offset += tx_bytes;
-        let (cert_index, cert_bytes) =
-            variable_nat_decode(&data[offset..], true).ok_or(DeserializeError::new(
-                "Address.Pointer.cert_index",
-                DeserializeFailure::VariableLenNatDecodeFailed,
-            ))?;
-        offset += cert_bytes;
-        Ok((
-            Pointer::new_pointer(
-                &slot.into(),
-                &tx_index.into(),
-                &cert_index.into(),
-            ),
-            offset,
-        ))
-    }
-
     pub fn to_bech32(&self, prefix: Option<String>) -> Result<String, JsError> {
         let final_prefix = match prefix {
             Some(prefix) => prefix,
@@ -817,64 +751,6 @@ impl Deserialize for RewardAddress {
     }
 }
 
-#[wasm_bindgen]
-#[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)]
-pub struct Pointer {
-    pub(crate) slot: BigNum,
-    pub(crate) tx_index: BigNum,
-    pub(crate) cert_index: BigNum,
-}
-
-#[wasm_bindgen]
-impl Pointer {
-    /// !!! DEPRECATED !!!
-    /// This constructor uses outdated slot number format for the ttl value, tx_index and cert_index.
-    /// Use `.new_pointer` instead
-    #[deprecated(
-        since = "10.1.0",
-        note = "Underlying value capacity of ttl (BigNum u64) bigger then Slot32. Use new_pointer instead."
-    )]
-    pub fn new(slot: Slot32, tx_index: TransactionIndex, cert_index: CertificateIndex) -> Self {
-        Self {
-            slot: slot.into(),
-            tx_index: tx_index.into(),
-            cert_index: cert_index.into(),
-        }
-    }
-
-    pub fn new_pointer(slot: &SlotBigNum, tx_index: &BigNum, cert_index: &BigNum) -> Self {
-        Self {
-            slot: slot.clone(),
-            tx_index: tx_index.clone(),
-            cert_index: cert_index.clone(),
-        }
-    }
-
-    pub fn slot(&self) -> Result<u32, JsError> {
-        self.slot.clone().try_into()
-    }
-
-    pub fn tx_index(&self) -> Result<u32, JsError> {
-        self.tx_index.clone().try_into()
-    }
-
-    pub fn cert_index(&self) -> Result<u32, JsError> {
-        self.cert_index.clone().try_into()
-    }
-
-    pub fn slot_bignum(&self) -> BigNum {
-        self.slot.clone()
-    }
-
-    pub fn tx_index_bignum(&self) -> BigNum {
-        self.tx_index.clone()
-    }
-
-    pub fn cert_index_bignum(&self) -> BigNum {
-        self.cert_index.clone()
-    }
-}
-
 #[wasm_bindgen]
 #[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)]
 pub struct PointerAddress {

rust/src/protocol_types/mod.rs

@@ -58,3 +58,6 @@ pub use script_ref::*;
 
 mod block;
 pub use block::*;
+
+mod pointer;
+pub use pointer::*;

rust/src/protocol_types/numeric/big_num.rs

@@ -159,6 +159,12 @@ impl From<u32> for BigNum {
     }
 }
 
+impl From<u16> for BigNum {
+    fn from(value: u16) -> Self {
+        return BigNum(value.into());
+    }
+}
+
 impl From<u8> for BigNum {
     fn from(value: u8) -> Self {
         return BigNum(value.into());

rust/src/protocol_types/pointer.rs

@@ -0,0 +1,178 @@
+use crate::wasm_bindgen;
+use crate::BigNum;
+use crate::DeserializeError;
+use crate::DeserializeFailure;
+use crate::JsError;
+use crate::{CertificateIndex, Slot32, SlotBigNum, TransactionIndex};
+
+use std::convert::TryInto;
+use std::io::{Cursor, Read};
+
+#[wasm_bindgen]
+#[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Pointer {
+    pub(crate) slot: BigNum,
+    pub(crate) tx_index: BigNum,
+    pub(crate) cert_index: BigNum,
+}
+
+#[wasm_bindgen]
+impl Pointer {
+    /// !!! DEPRECATED !!!
+    /// This constructor uses outdated slot number format for the ttl value, tx_index and cert_index.
+    /// Use `.new_pointer` instead
+    #[deprecated(
+        since = "10.1.0",
+        note = "Underlying value capacity of ttl (BigNum u64) bigger then Slot32. Use new_pointer instead."
+    )]
+    pub fn new(slot: Slot32, tx_index: TransactionIndex, cert_index: CertificateIndex) -> Self {
+        Self {
+            slot: slot.into(),
+            tx_index: tx_index.into(),
+            cert_index: cert_index.into(),
+        }
+    }
+
+    pub fn new_pointer(slot: &SlotBigNum, tx_index: &BigNum, cert_index: &BigNum) -> Self {
+        Self {
+            slot: slot.clone(),
+            tx_index: tx_index.clone(),
+            cert_index: cert_index.clone(),
+        }
+    }
+
+    pub fn slot(&self) -> Result<u32, JsError> {
+        self.slot.clone().try_into()
+    }
+
+    pub fn tx_index(&self) -> Result<u32, JsError> {
+        self.tx_index.clone().try_into()
+    }
+
+    pub fn cert_index(&self) -> Result<u32, JsError> {
+        self.cert_index.clone().try_into()
+    }
+
+    pub fn slot_bignum(&self) -> BigNum {
+        self.slot.clone()
+    }
+
+    pub fn tx_index_bignum(&self) -> BigNum {
+        self.tx_index.clone()
+    }
+
+    pub fn cert_index_bignum(&self) -> BigNum {
+        self.cert_index.clone()
+    }
+
+    pub(crate) fn from_bytes(data: &[u8]) -> Result<(Pointer, usize), DeserializeError> {
+        let (pointer, offset) = decode_pointer(data)?;
+        Ok((pointer, offset))
+    }
+
+    pub(crate) fn to_bytes(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        buf.extend_from_slice(&encode_variable_length(self.slot.into()));
+        buf.extend_from_slice(&encode_variable_length(self.tx_index.into()));
+        buf.extend_from_slice(&encode_variable_length(self.cert_index.into()));
+        buf
+    }
+}
+
+
+fn decode_pointer(data: &[u8]) -> Result<(Pointer, usize), DeserializeError> {
+    let mut cursor = Cursor::new(data);
+    let mut offset = 0;
+    let slot_no_64 = decode_variable_length_u64(&mut cursor, "SlotNo")?;
+    let tx_ix_64 = decode_variable_length_u64(&mut cursor, "TxIx")?;
+    let cert_ix_64 = decode_variable_length_u64(&mut cursor, "CertIx")?;
+
+    offset += cursor.position() as usize;
+
+    Ok((
+        analyze_and_convert(slot_no_64, tx_ix_64, cert_ix_64),
+        offset,
+    ))
+}
+
+fn analyze_and_convert(slot_no: u64, tx_ix: u64, cert_ix: u64) -> Pointer {
+    let needs_normalization =
+        slot_no > u32::MAX as u64 || tx_ix > u16::MAX as u64 || cert_ix > u16::MAX as u64;
+
+    // Normalization is (0,0,0). Ha-ha-ha. 
+    if needs_normalization {
+            Pointer {
+                slot: 0u64.into(),
+                tx_index: 0u64.into(),
+                cert_index: 0u64.into(),
+            }
+    } else {
+        Pointer {
+            slot: slot_no.into(),
+            tx_index: tx_ix.into(),
+            cert_index: cert_ix.into(),
+        }
+    }
+}
+
+/// Decodes variable-length u64 exactly like Haskell decodeVariableLengthWord64
+/// Non-recursive implementation that mimics: fix (decode7BitVarLength name buf) 0
+///
+/// Haskell code equivalent:
+/// decode7BitVarLength name buf cont !acc = do
+///   guardLength name 1 buf
+///   offset <- state (\off -> (off, off + 1))
+///   let b8 = bufUnsafeIndex buf offset
+///   if b8 `testBit` 7
+///     then cont (acc `shiftL` 7 .|. fromIntegral (b8 `clearBit` 7))
+///     else pure (acc `shiftL` 7 .|. fromIntegral b8)
+pub(crate) fn decode_variable_length_u64(
+    cursor: &mut Cursor<&[u8]>,
+    name: &'static str,
+) -> Result<u64, DeserializeError> {
+    let mut acc = 0u64;
+    
+    loop {
+        // Equivalent of guardLength name 1 buf
+        if cursor.position() >= cursor.get_ref().len() as u64 {
+            return Err(DeserializeError::new(name, DeserializeFailure::VariableLenNatDecodeFailed));
+        }
+
+        // Equivalent of: offset <- state (\off -> (off, off + 1))
+        let mut byte = [0u8; 1];
+        cursor
+            .read_exact(&mut byte)
+            .map_err(|e| DeserializeError::new(name, DeserializeFailure::IoError(e.to_string())))?;
+        let b8 = byte[0];
+
+        // Equivalent of: acc `shiftL` 7 .|. fromIntegral (b8 `clearBit` 7)
+        acc = (acc << 7)  | ((b8 & 0x7F) as u64);
+
+        // Equivalent of: if b8 `testBit` 7
+        if (b8 & 0x80) == 0 {
+            // else pure (acc `shiftL` 7 .|. fromIntegral b8)
+            return Ok(acc);
+        }
+    }
+}
+
+pub(crate) fn encode_variable_length(value: u64) -> Vec<u8> {
+    let mut tmp = value;
+    if tmp == 0 {
+        return vec![0];
+    }
+
+    let mut bytes = Vec::new();
+    while tmp > 0 {
+        bytes.push((tmp & 0x7F) as u8);
+        tmp >>= 7;
+    }
+
+    bytes.reverse();
+
+    for i in 0..bytes.len() - 1 {
+        bytes[i] |= 0x80;
+    }
+
+    bytes
+}