did:ethr spec compliance

Cargo.toml

@@ -255,6 +255,11 @@ serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 json-syntax.workspace = true
 ssi-dids = { workspace = true, features = ["example"] }
+did-ethr.workspace = true
+ssi-dids-core.workspace = true
+hex.workspace = true
+reqwest = { version = "0.12", features = ["json"] }
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
 
 [package.metadata.docs.rs]
 all-features = true

crates/crypto/src/hashes/keccak.rs

@@ -1,5 +1,10 @@
 use keccak_hash::keccak;
 
+/// Compute the keccak256 hash of arbitrary bytes.
+pub fn keccak256(data: &[u8]) -> [u8; 32] {
+    keccak(data).to_fixed_bytes()
+}
+
 pub fn bytes_to_lowerhex(bytes: &[u8]) -> String {
     use std::fmt::Write;
     bytes.iter().fold("0x".to_owned(), |mut s, byte| {

crates/dids/core/src/document.rs

@@ -170,10 +170,19 @@ pub enum InvalidData {
 }
 
 /// Document metadata.
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Metadata {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub deactivated: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub version_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub updated: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub next_version_id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub next_update: Option<String>,
 }
 
 #[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq, Eq)]

crates/dids/methods/ethr/Cargo.toml

@@ -15,11 +15,17 @@ documentation = "https://docs.rs/did-ethr/"
 ssi-dids-core.workspace = true
 ssi-caips = { workspace = true, features = ["eip"] }
 ssi-jwk.workspace = true
+ssi-core.workspace = true
 iref.workspace = true
 static-iref.workspace = true
 thiserror.workspace = true
 hex.workspace = true
 serde_json.workspace = true
+ssi-crypto = { workspace = true, features = ["keccak"] }
+ssi-multicodec.workspace = true
+multibase.workspace = true
+chrono.workspace = true
+indexmap.workspace = true
 
 [dev-dependencies]
 tokio = { version = "1.0", features = ["macros"] }

crates/dids/methods/ethr/src/abi.rs

@@ -0,0 +1,65 @@
+use chrono::{DateTime, Utc};
+use ssi_crypto::hashes::keccak;
+
+// --- ERC-1056 ABI selectors ---
+
+/// `changed(address)` — selector 0xf96d0f9f
+pub(crate) const CHANGED_SELECTOR: [u8; 4] = [0xf9, 0x6d, 0x0f, 0x9f];
+
+/// `identityOwner(address)` — selector 0x8733d4e8
+pub(crate) const IDENTITY_OWNER_SELECTOR: [u8; 4] = [0x87, 0x33, 0xd4, 0xe8];
+
+/// Encode a 20-byte address as a 32-byte ABI-padded word
+pub(crate) fn abi_encode_address(addr: &[u8; 20]) -> [u8; 32] {
+    let mut word = [0u8; 32];
+    word[12..].copy_from_slice(addr);
+    word
+}
+
+/// Build calldata: 4-byte selector + 32-byte padded address
+pub(crate) fn encode_call(selector: [u8; 4], addr: &[u8; 20]) -> Vec<u8> {
+    let mut data = Vec::with_capacity(36);
+    data.extend_from_slice(&selector);
+    data.extend_from_slice(&abi_encode_address(addr));
+    data
+}
+
+/// Decode a 32-byte uint256 return value.
+/// Returns an error if the value overflows u64 (high 24 bytes non-zero).
+pub(crate) fn decode_uint256(data: &[u8]) -> Result<u64, &'static str> {
+    if data.len() < 32 {
+        return Err("uint256 data too short");
+    }
+    if data[..24].iter().any(|&b| b != 0) {
+        return Err("uint256 overflows u64");
+    }
+    let mut bytes = [0u8; 8];
+    bytes.copy_from_slice(&data[24..32]);
+    Ok(u64::from_be_bytes(bytes))
+}
+
+/// Decode a 32-byte ABI-encoded address return value
+pub(crate) fn decode_address(data: &[u8]) -> [u8; 20] {
+    if data.len() < 32 {
+        return [0u8; 20];
+    }
+    let mut addr = [0u8; 20];
+    addr.copy_from_slice(&data[12..32]);
+    addr
+}
+
+/// Convert raw 20 bytes to an EIP-55 checksummed hex address string
+pub(crate) fn format_address_eip55(addr: &[u8; 20]) -> String {
+    let lowercase = format!("0x{}", hex::encode(addr));
+    keccak::eip55_checksum_addr(&lowercase).unwrap_or(lowercase)
+}
+
+/// Format a Unix timestamp (seconds since epoch) as ISO 8601 UTC string
+pub(crate) fn format_timestamp_iso8601(unix_secs: u64) -> String {
+    let secs = i64::try_from(unix_secs).ok();
+    secs.and_then(|s| DateTime::<Utc>::from_timestamp(s, 0))
+        .map(|dt| dt.format("%Y-%m-%dT%H:%M:%SZ").to_string())
+        .unwrap_or_else(|| "1970-01-01T00:00:00Z".to_string())
+}
+
+pub(crate) use keccak::keccak256;