refactor: split contract_interface.rs into logical modules

Split the 1992-line contract_interface.rs into 12 focused modules:
- error.rs: ContractError type
- state.rs: State, StateDelta, StateSummary
- key.rs: ContractInstanceId, ContractKey
- code.rs: ContractCode
- update.rs: Update-related types (UpdateModification, RelatedContracts, etc.)
- contract.rs: Contract type
- wrapped.rs: WrappedState, WrappedContract
- trait_def.rs: ContractInterface trait
- wasm_interface.rs: WASM FFI boundary (pub(crate))
- encoding.rs: Typed contract helpers (pub)
- tests.rs: Unit tests
- mod.rs: Re-exports maintaining public API

Benefits:
- Improved code navigation and maintainability
- Clearer separation of concerns
- Easier to understand dependencies between types
- No breaking changes - all public APIs preserved via re-exports

All tests pass. No functional changes.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: sanity

rust/src/contract_interface.rs

@@ -0,0 +1,157 @@
+//! Contract executable code representation.
+//!
+//! This module provides the `ContractCode` type which represents the executable
+//! WASM bytecode for a contract, along with its hash.
+
+use std::borrow::Cow;
+use std::fs::File;
+use std::io::Read;
+use std::path::Path;
+
+use blake3::{traits::digest::Digest, Hasher as Blake3};
+use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
+
+use crate::code_hash::CodeHash;
+
+use super::key::internal_fmt_key;
+use super::CONTRACT_KEY_SIZE;
+
+/// The executable contract.
+///
+/// It is the part of the executable belonging to the full specification
+/// and does not include any other metadata (like the parameters).
+#[serde_as]
+#[derive(Serialize, Deserialize, Clone)]
+#[cfg_attr(
+    any(feature = "testing", all(test, any(unix, windows))),
+    derive(arbitrary::Arbitrary)
+)]
+pub struct ContractCode<'a> {
+    // TODO: conver this to Arc<[u8]> instead
+    #[serde_as(as = "serde_with::Bytes")]
+    #[serde(borrow)]
+    pub(crate) data: Cow<'a, [u8]>,
+    // todo: skip serializing and instead compute it
+    pub(crate) code_hash: CodeHash,
+}
+
+impl ContractCode<'static> {
+    /// Loads the contract raw wasm module, without any version.
+    pub fn load_raw(path: &Path) -> Result<Self, std::io::Error> {
+        let contract_data = Self::load_bytes(path)?;
+        Ok(ContractCode::from(contract_data))
+    }
+
+    pub(crate) fn load_bytes(path: &Path) -> Result<Vec<u8>, std::io::Error> {
+        let mut contract_file = File::open(path)?;
+        let mut contract_data = if let Ok(md) = contract_file.metadata() {
+            Vec::with_capacity(md.len() as usize)
+        } else {
+            Vec::new()
+        };
+        contract_file.read_to_end(&mut contract_data)?;
+        Ok(contract_data)
+    }
+}
+
+impl ContractCode<'_> {
+    /// Contract code hash.
+    pub fn hash(&self) -> &CodeHash {
+        &self.code_hash
+    }
+
+    /// Returns the `Base58` string representation of the contract key.
+    pub fn hash_str(&self) -> String {
+        Self::encode_hash(&self.code_hash.0)
+    }
+
+    /// Reference to contract code.
+    pub fn data(&self) -> &[u8] {
+        &self.data
+    }
+
+    /// Extracts the owned contract code data as a `Vec<u8>`.
+    pub fn into_bytes(self) -> Vec<u8> {
+        self.data.to_vec()
+    }
+
+    /// Returns the `Base58` string representation of a hash.
+    pub fn encode_hash(hash: &[u8; CONTRACT_KEY_SIZE]) -> String {
+        bs58::encode(hash)
+            .with_alphabet(bs58::Alphabet::BITCOIN)
+            .into_string()
+    }
+
+    /// Copies the data if not owned and returns an owned version of self.
+    pub fn into_owned(self) -> ContractCode<'static> {
+        ContractCode {
+            data: self.data.into_owned().into(),
+            code_hash: self.code_hash,
+        }
+    }
+
+    fn gen_hash(data: &[u8]) -> CodeHash {
+        let mut hasher = Blake3::new();
+        hasher.update(data);
+        let key_arr = hasher.finalize();
+        debug_assert_eq!(key_arr[..].len(), CONTRACT_KEY_SIZE);
+        let mut key = [0; CONTRACT_KEY_SIZE];
+        key.copy_from_slice(&key_arr);
+        CodeHash(key)
+    }
+}
+
+impl From<Vec<u8>> for ContractCode<'static> {
+    fn from(data: Vec<u8>) -> Self {
+        let key = ContractCode::gen_hash(&data);
+        ContractCode {
+            data: Cow::from(data),
+            code_hash: key,
+        }
+    }
+}
+
+impl<'a> From<&'a [u8]> for ContractCode<'a> {
+    fn from(data: &'a [u8]) -> ContractCode<'a> {
+        let hash = ContractCode::gen_hash(data);
+        ContractCode {
+            data: Cow::from(data),
+            code_hash: hash,
+        }
+    }
+}
+
+impl PartialEq for ContractCode<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.code_hash == other.code_hash
+    }
+}
+
+impl Eq for ContractCode<'_> {}
+
+impl std::fmt::Display for ContractCode<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Contract( key: ")?;
+        internal_fmt_key(&self.code_hash.0, f)?;
+        let data: String = if self.data.len() > 8 {
+            self.data[..4]
+                .iter()
+                .map(|b| char::from(*b))
+                .chain("...".chars())
+                .chain(self.data[4..].iter().map(|b| char::from(*b)))
+                .collect()
+        } else {
+            self.data.iter().copied().map(char::from).collect()
+        };
+        write!(f, ", data: [{data}])")
+    }
+}
+
+impl std::fmt::Debug for ContractCode<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ContractCode")
+            .field("hash", &self.code_hash);
+        Ok(())
+    }
+}

rust/src/contract_interface/code.rs

@@ -0,0 +1,104 @@
+//! Complete contract specification combining code and parameters.
+//!
+//! This module provides the `Contract` type which represents a complete
+//! contract with both executable code and runtime parameters.
+
+use std::io::{Cursor, Read};
+
+use byteorder::{LittleEndian, ReadBytesExt};
+use serde::{Deserialize, Serialize};
+
+use crate::parameters::Parameters;
+
+use super::code::ContractCode;
+use super::key::{internal_fmt_key, ContractKey};
+
+/// A complete contract specification requires a `parameters` section
+/// and a `contract` section.
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[cfg_attr(
+    any(feature = "testing", all(test, any(unix, windows))),
+    derive(arbitrary::Arbitrary)
+)]
+pub struct Contract<'a> {
+    #[serde(borrow)]
+    pub parameters: Parameters<'a>,
+    #[serde(borrow)]
+    pub data: ContractCode<'a>,
+    // todo: skip serializing and instead compute it
+    key: ContractKey,
+}
+
+impl<'a> Contract<'a> {
+    /// Returns a contract from [contract code](ContractCode) and given [parameters](Parameters).
+    pub fn new(contract: ContractCode<'a>, parameters: Parameters<'a>) -> Contract<'a> {
+        let key = ContractKey::from_params_and_code(&parameters, &contract);
+        Contract {
+            parameters,
+            data: contract,
+            key,
+        }
+    }
+
+    /// Key portion of the specification.
+    pub fn key(&self) -> &ContractKey {
+        &self.key
+    }
+
+    /// Code portion of the specification.
+    pub fn into_code(self) -> ContractCode<'a> {
+        self.data
+    }
+}
+
+impl TryFrom<Vec<u8>> for Contract<'static> {
+    type Error = std::io::Error;
+
+    fn try_from(data: Vec<u8>) -> Result<Self, Self::Error> {
+        let mut reader = Cursor::new(data);
+
+        let params_len = reader.read_u64::<LittleEndian>()?;
+        let mut params_buf = vec![0; params_len as usize];
+        reader.read_exact(&mut params_buf)?;
+        let parameters = Parameters::from(params_buf);
+
+        let contract_len = reader.read_u64::<LittleEndian>()?;
+        let mut contract_buf = vec![0; contract_len as usize];
+        reader.read_exact(&mut contract_buf)?;
+        let contract = ContractCode::from(contract_buf);
+
+        let key = ContractKey::from_params_and_code(&parameters, &contract);
+
+        Ok(Contract {
+            parameters,
+            data: contract,
+            key,
+        })
+    }
+}
+
+impl PartialEq for Contract<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.key == other.key
+    }
+}
+
+impl Eq for Contract<'_> {}
+
+impl std::fmt::Display for Contract<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ContractSpec( key: ")?;
+        internal_fmt_key(&self.key, f)?;
+        let data: String = if self.data.data.len() > 8 {
+            self.data.data[..4]
+                .iter()
+                .map(|b| char::from(*b))
+                .chain("...".chars())
+                .chain(self.data.data[4..].iter().map(|b| char::from(*b)))
+                .collect()
+        } else {
+            self.data.data.iter().copied().map(char::from).collect()
+        };
+        write!(f, ", data: [{data}])")
+    }
+}