Integrate Cardano into signer

Author: gemcoder21

Cargo.lock

@@ -24,7 +24,7 @@ impl AlgorandTransaction {
             input,
             Operation::Payment {
                 destination: AlgorandAddress::from_str(&input.destination_address).invalid_input("invalid Algorand address")?,
-                amount: input.value.parse::<u64>().invalid_input("invalid Algorand amount")?,
+                amount: input.value_as_u64()?,
             },
         )
     }
@@ -34,7 +34,7 @@ impl AlgorandTransaction {
             input,
             Operation::AssetTransfer {
                 destination: AlgorandAddress::from_str(&input.destination_address).invalid_input("invalid Algorand address")?,
-                amount: input.value.parse::<u64>().invalid_input("invalid Algorand amount")?,
+                amount: input.value_as_u64()?,
                 asset_id: get_asset_id(input)?,
             },
         )

crates/gem_algorand/src/models/signing/transaction.rs

@@ -6,21 +6,52 @@ publish = false
 
 [features]
 default = []
-rpc = ["dep:chain_traits", "dep:gem_client"]
-reqwest = ["gem_client/reqwest"]
+rpc = [
+    "dep:async-trait",
+    "dep:bech32",
+    "dep:chain_traits",
+    "dep:chrono",
+    "dep:futures",
+    "dep:gem_client",
+    "dep:hex",
+    "dep:num-bigint",
+    "dep:num-traits",
+    "dep:serde_json",
+]
+signer = [
+    "dep:bech32",
+    "dep:curve25519-dalek",
+    "dep:gem_hash",
+    "dep:hex",
+    "dep:num-traits",
+    "dep:sha2",
+    "dep:zeroize",
+]
+reqwest = ["dep:gem_client", "gem_client/reqwest"]
 chain_integration_tests = ["rpc", "reqwest", "settings/testkit"]
 
 [dependencies]
 primitives = { path = "../primitives" }
+num-bigint = { workspace = true, optional = true }
+serde_serializers = { path = "../serde_serializers" }
+bech32 = { workspace = true, optional = true }
+gem_hash = { path = "../gem_hash", optional = true }
+futures = { workspace = true, optional = true }
+hex = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
-chrono = { workspace = true, features = ["serde"] }
-async-trait = { workspace = true }
+serde_json = { workspace = true, optional = true }
+chrono = { workspace = true, features = ["serde"], optional = true }
+async-trait = { workspace = true, optional = true }
 chain_traits = { path = "../chain_traits", optional = true }
 gem_client = { path = "../gem_client", optional = true }
-num-bigint = { workspace = true }
+num-traits = { workspace = true, optional = true }
+curve25519-dalek = { workspace = true, optional = true }
+sha2 = { workspace = true, optional = true }
+zeroize = { workspace = true, optional = true }
 
 [dev-dependencies]
+gem_client = { path = "../gem_client", features = ["testkit"] }
+primitives = { path = "../primitives", features = ["testkit"] }
 tokio = { workspace = true, features = ["macros"] }
 reqwest = { workspace = true }
 settings = { path = "../settings", features = ["testkit"] }

crates/gem_cardano/Cargo.toml

@@ -0,0 +1,86 @@
+use primitives::SignerError;
+
+const MAINNET_NETWORK_ID: u8 = 1;
+const BASE_KEY_ADDRESS_TYPE: u8 = 0;
+const ENTERPRISE_KEY_ADDRESS_TYPE: u8 = 6;
+const ADDRESS_HEADER_LENGTH: usize = 1;
+const KEY_HASH_LENGTH: usize = 28;
+const ENTERPRISE_ADDRESS_LENGTH: usize = ADDRESS_HEADER_LENGTH + KEY_HASH_LENGTH;
+const BASE_ADDRESS_LENGTH: usize = ADDRESS_HEADER_LENGTH + KEY_HASH_LENGTH + KEY_HASH_LENGTH;
+
+#[derive(Debug)]
+pub(crate) struct ShelleyAddress {
+    bytes: Vec<u8>,
+}
+
+impl ShelleyAddress {
+    pub(crate) fn parse(address: &str) -> Result<Self, SignerError> {
+        let (hrp, bytes) = bech32::decode(address).map_err(|_| SignerError::invalid_input("invalid Cardano address"))?;
+        if hrp.as_str() != "addr" {
+            return SignerError::invalid_input_err("unsupported Cardano address network");
+        }
+
+        Self::from_bytes(bytes)
+    }
+
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    pub(crate) fn payment_hash(&self) -> &[u8] {
+        &self.bytes[ADDRESS_HEADER_LENGTH..ADDRESS_HEADER_LENGTH + KEY_HASH_LENGTH]
+    }
+
+    fn from_bytes(bytes: Vec<u8>) -> Result<Self, SignerError> {
+        if bytes.is_empty() {
+            return SignerError::invalid_input_err("invalid Cardano address");
+        }
+        let address = Self { bytes };
+        if address.network_id() != MAINNET_NETWORK_ID {
+            return SignerError::invalid_input_err("unsupported Cardano address network");
+        }
+        match address.address_type() {
+            BASE_KEY_ADDRESS_TYPE => {
+                if address.bytes.len() != BASE_ADDRESS_LENGTH {
+                    return SignerError::invalid_input_err("invalid Cardano base address");
+                }
+            }
+            ENTERPRISE_KEY_ADDRESS_TYPE => {
+                if address.bytes.len() != ENTERPRISE_ADDRESS_LENGTH {
+                    return SignerError::invalid_input_err("invalid Cardano enterprise address");
+                }
+            }
+            _ => return SignerError::invalid_input_err("unsupported Cardano address type"),
+        }
+        Ok(address)
+    }
+
+    fn address_type(&self) -> u8 {
+        self.bytes[0] >> 4
+    }
+
+    fn network_id(&self) -> u8 {
+        self.bytes[0] & 0x0f
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_shelley_address_decode() {
+        let address = ShelleyAddress::parse("addr1q8043m5heeaydnvtmmkyuhe6qv5havvhsf0d26q3jygsspxlyfpyk6yqkw0yhtyvtr0flekj84u64az82cufmqn65zdsylzk23").unwrap();
+        assert_eq!(
+            hex::encode(address.as_bytes()),
+            "01df58ee97ce7a46cd8bdeec4e5f3a03297eb197825ed5681191110804df22424b6880b39e4bac8c58de9fe6d23d79aaf44756389d827aa09b"
+        );
+        assert_eq!(hex::encode(address.payment_hash()), "df58ee97ce7a46cd8bdeec4e5f3a03297eb197825ed5681191110804");
+    }
+
+    #[test]
+    fn test_shelley_address_rejects_unsupported() {
+        assert!(ShelleyAddress::parse("stake1uykptcz226y5r5at5rfqqm00p9n0z0yfajz3gk3j3wm8dxg2sn0r4").is_err());
+        assert!(ShelleyAddress::parse("addr_test1qr4p6f6mm0q9kfyyd9u30umk9cc6gk0nxu25k5rsc4fp7ls7k0qqxslcwwj4gvn4yfmdyrfgwjt3ztuz4zpy4242u0m95r0n").is_err());
+    }
+}

crates/gem_cardano/src/address.rs

@@ -0,0 +1,65 @@
+pub(crate) struct CborEncoder {
+    bytes: Vec<u8>,
+}
+
+impl CborEncoder {
+    pub(crate) fn new() -> Self {
+        Self { bytes: Vec::new() }
+    }
+
+    pub(crate) fn into_bytes(self) -> Vec<u8> {
+        self.bytes
+    }
+
+    pub(crate) fn raw(&mut self, raw: &[u8]) {
+        self.bytes.extend_from_slice(raw);
+    }
+
+    pub(crate) fn unsigned(&mut self, value: u64) {
+        self.major_type(0, value);
+    }
+
+    pub(crate) fn bytes(&mut self, value: &[u8]) {
+        self.major_type(2, value.len() as u64);
+        self.bytes.extend_from_slice(value);
+    }
+
+    pub(crate) fn array(&mut self, len: usize) {
+        self.major_type(4, len as u64);
+    }
+
+    pub(crate) fn map(&mut self, len: usize) {
+        self.major_type(5, len as u64);
+    }
+
+    pub(crate) fn null(&mut self) {
+        self.bytes.push(0xf6);
+    }
+
+    pub(crate) fn true_value(&mut self) {
+        self.bytes.push(0xf5);
+    }
+
+    fn major_type(&mut self, major: u8, value: u64) {
+        let prefix = major << 5;
+        match value {
+            0..=23 => self.bytes.push(prefix | value as u8),
+            24..=0xff => {
+                self.bytes.push(prefix | 24);
+                self.bytes.push(value as u8);
+            }
+            0x100..=0xffff => {
+                self.bytes.push(prefix | 25);
+                self.bytes.extend_from_slice(&(value as u16).to_be_bytes());
+            }
+            0x1_0000..=0xffff_ffff => {
+                self.bytes.push(prefix | 26);
+                self.bytes.extend_from_slice(&(value as u32).to_be_bytes());
+            }
+            _ => {
+                self.bytes.push(prefix | 27);
+                self.bytes.extend_from_slice(&value.to_be_bytes());
+            }
+        }
+    }
+}

crates/gem_cardano/src/cbor.rs

@@ -1,6 +1,21 @@
+#[cfg(any(feature = "rpc", feature = "signer"))]
+mod address;
+#[cfg(any(feature = "rpc", feature = "signer"))]
+mod cbor;
 pub mod models;
+#[cfg(any(feature = "rpc", feature = "signer"))]
+mod planner;
+#[cfg(feature = "rpc")]
 pub mod provider;
+#[cfg(feature = "rpc")]
 pub mod rpc;
+#[cfg(any(feature = "rpc", feature = "signer"))]
+mod transaction;
 
+#[cfg(feature = "rpc")]
 pub use provider::map_transaction;
+#[cfg(feature = "rpc")]
 pub use rpc::client::CardanoClient;
+
+#[cfg(feature = "signer")]
+pub mod signer;

crates/gem_cardano/src/lib.rs

@@ -1,11 +1,14 @@
 use serde::{Deserialize, Serialize};
+use serde_serializers::deserialize_u64_from_str;
 
 use super::UInt64;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Block {
     pub number: UInt64,
+    #[serde(deserialize_with = "deserialize_u64_from_str")]
+    pub slot_no: UInt64,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]