Merge pull request #133 from kinode-dao/develop

develop 0.10.2

Author: dr-frmr

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "kinode_process_lib"
 authors = ["Sybil Technologies AG"]
-version = "0.10.1"
+version = "0.10.2"
 edition = "2021"
 description = "A library for writing Kinode processes in Rust."
 homepage = "https://kinode.org"
@@ -27,6 +27,7 @@ mime_guess = "2.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.120"
 rand = "0.8"
+regex = "1.11.1"
 rmp-serde = "1.1.2"
 thiserror = "1.0"
 tracing = { version = "0.1", optional = true }

Cargo.toml

@@ -10,6 +10,8 @@ pub use alloy::rpc::types::{
 pub use alloy_primitives::{Address, BlockHash, BlockNumber, Bytes, TxHash, U128, U256, U64, U8};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, HashSet};
+use std::error::Error;
+use std::fmt;
 
 /// Subscription kind. Pulled directly from alloy (https://github.com/alloy-rs/alloy).
 /// Why? Because alloy is not yet 1.0 and the types in this interface must be stable.
@@ -130,6 +132,24 @@ pub enum EthError {
     RpcMalformedResponse,
 }
 
+impl fmt::Display for EthError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            EthError::RpcError(e) => write!(f, "RPC error: {:?}", e),
+            EthError::MalformedRequest => write!(f, "Malformed request"),
+            EthError::NoRpcForChain => write!(f, "No RPC provider for chain"),
+            EthError::SubscriptionClosed(id) => write!(f, "Subscription {} closed", id),
+            EthError::InvalidMethod(m) => write!(f, "Invalid method: {}", m),
+            EthError::InvalidParams => write!(f, "Invalid parameters"),
+            EthError::PermissionDenied => write!(f, "Permission denied"),
+            EthError::RpcTimeout => write!(f, "RPC request timed out"),
+            EthError::RpcMalformedResponse => write!(f, "RPC returned malformed response"),
+        }
+    }
+}
+
+impl Error for EthError {}
+
 /// The action type used for configuring eth:distro:sys. Only processes which have the "root"
 /// [`crate::Capability`] from eth:distro:sys can successfully send this action.
 #[derive(Clone, Debug, Serialize, Deserialize)]

src/eth.rs

@@ -1,6 +1,6 @@
 use crate::vfs::{FileType, VfsAction, VfsRequest, VfsResponse};
 use crate::{
-    get_blob, last_blob, Address, LazyLoadBlob as KiBlob, Message, Request as KiRequest,
+    get_blob, last_blob, LazyLoadBlob as KiBlob, Message, Request as KiRequest,
     Response as KiResponse,
 };
 pub use http::StatusCode;
@@ -809,11 +809,11 @@ impl HttpServer {
     /// An error will be returned if the file does not exist.
     pub fn serve_file(
         &mut self,
-        our: &Address,
         file_path: &str,
         paths: Vec<&str>,
         config: HttpBindingConfig,
     ) -> Result<(), HttpServerError> {
+        let our = crate::our();
         let _res = KiRequest::to(("our", "vfs", "distro", "sys"))
             .body(
                 serde_json::to_vec(&VfsRequest {
@@ -887,11 +887,11 @@ impl HttpServer {
     /// An error will be returned if the file does not exist.
     pub fn serve_ui(
         &mut self,
-        our: &Address,
         directory: &str,
         roots: Vec<&str>,
         config: HttpBindingConfig,
     ) -> Result<(), HttpServerError> {
+        let our = crate::our();
         let initial_path = format!("{}/pkg/{}", our.package_id(), directory);
 
         let mut queue = std::collections::VecDeque::new();

src/http/server.rs

@@ -5,7 +5,10 @@ use alloy::rpc::types::request::{TransactionInput, TransactionRequest};
 use alloy::{hex, primitives::keccak256};
 use alloy_primitives::{Address, Bytes, FixedBytes, B256};
 use alloy_sol_types::{SolCall, SolEvent, SolValue};
+use contract::tokenCall;
 use serde::{Deserialize, Serialize};
+use std::error::Error;
+use std::fmt;
 use std::str::FromStr;
 
 /// kimap deployment address on optimism
@@ -210,12 +213,19 @@ pub mod contract {
 
         function supportsInterface(bytes4 interfaceId) external view returns (bool);
 
-        /// Retrieves the address of the ERC-6551 implementation of the
-        /// zeroth entry. This is set once at initialization.
+        /// Gets the token identifier that owns this token-bound account (TBA).
+        /// This is a core function of the ERC-6551 standard that returns the
+        /// identifying information about the NFT that owns this account.
+        /// The return values are constant and cannot change over time.
         ///
         /// Returns:
-        /// - implementation: The address of the ERC-6551 implementation.
-        function get6551Implementation() external view returns (address);
+        /// - chainId: The EIP-155 chain ID where the owning NFT exists
+        /// - tokenContract: The contract address of the owning NFT
+        /// - tokenId: The token ID of the owning NFT
+        function token()
+            external
+            view
+            returns (uint256 chainId, address tokenContract, uint256 tokenId);
     }
 }
 
@@ -259,6 +269,21 @@ pub enum DecodeLogError {
     UnresolvedParent(String),
 }
 
+impl fmt::Display for DecodeLogError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DecodeLogError::UnexpectedTopic(topic) => write!(f, "Unexpected topic: {:?}", topic),
+            DecodeLogError::InvalidName(name) => write!(f, "Invalid name: {}", name),
+            DecodeLogError::DecodeError(err) => write!(f, "Decode error: {}", err),
+            DecodeLogError::UnresolvedParent(parent) => {
+                write!(f, "Could not resolve parent: {}", parent)
+            }
+        }
+    }
+}
+
+impl Error for DecodeLogError {}
+
 /// Canonical function to determine if a kimap entry is valid. This should
 /// be used whenever reading a new kimap entry from a mints query, because
 /// while most frontends will enforce these rules, it is possible to post
@@ -514,6 +539,28 @@ impl Kimap {
         Ok((res.tba, res.owner, note_data))
     }
 
+    /// Gets a namehash from an existing TBA address.
+    ///
+    /// # Parameters
+    /// - `tba`: The TBA to get the namehash of.
+    /// # Returns
+    /// A `Result<String, EthError>` representing the namehash of the TBA.
+    pub fn get_namehash_from_tba(&self, tba: Address) -> Result<String, EthError> {
+        let token_call = tokenCall {}.abi_encode();
+
+        let tx_req = TransactionRequest::default()
+            .input(TransactionInput::new(token_call.into()))
+            .to(tba);
+
+        let res_bytes = self.provider.call(tx_req, None)?;
+
+        let res = tokenCall::abi_decode_returns(&res_bytes, false)
+            .map_err(|_| EthError::RpcMalformedResponse)?;
+
+        let namehash: FixedBytes<32> = res.tokenId.into();
+        Ok(format!("0x{}", hex::encode(namehash)))
+    }
+
     /// Create a filter for all mint events.
     pub fn mint_filter(&self) -> crate::eth::Filter {
         crate::eth::Filter::new()

src/kimap.rs

@@ -1,14 +1,13 @@
-pub use tracing::{debug, error, info, warn, Level};
-use tracing_error::ErrorLayer;
-use tracing_subscriber::{
-    fmt, layer::SubscriberExt, prelude::*, util::SubscriberInitExt, EnvFilter,
-};
-
 use crate::{
     print_to_terminal,
     vfs::{create_drive, open_file, File},
     Address, Request,
 };
+pub use tracing::{debug, error, info, warn, Level};
+use tracing_error::ErrorLayer;
+use tracing_subscriber::{
+    fmt, layer::SubscriberExt, prelude::*, util::SubscriberInitExt, EnvFilter,
+};
 
 pub struct RemoteLogSettings {
     pub target: Address,
@@ -25,10 +24,12 @@ pub struct RemoteWriterMaker {
 
 pub struct FileWriter {
     pub file: File,
+    pub max_size: u64,
 }
 
 pub struct FileWriterMaker {
     pub file: File,
+    pub max_size: u64,
 }
 
 pub struct TerminalWriter {
@@ -65,6 +66,28 @@ impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for RemoteWriterMaker {
 impl std::io::Write for FileWriter {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         // TODO: use non-blocking call instead? (.append() `send_and_await()`s)
+        let metadata = self
+            .file
+            .metadata()
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+
+        if metadata.len > self.max_size {
+            // Get current contents
+            let contents = self
+                .file
+                .read()
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+
+            // Take second half of file
+            let half_len = contents.len() / 2;
+            let new_contents = &contents[half_len..];
+
+            // Truncate and write back second half
+            self.file
+                .write(new_contents)
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+        }
+
         self.file
             .append(buf)
             .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
@@ -82,6 +105,7 @@ impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for FileWriterMaker {
     fn make_writer(&'a self) -> Self::Writer {
         FileWriter {
             file: File::new(self.file.path.clone(), self.file.timeout),
+            max_size: self.max_size,
         }
     }
 }
@@ -114,17 +138,21 @@ impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for TerminalWriterMaker {
 /// Logs will be printed to terminal as appropriate depending on given level.
 /// Logs will be logged into the logging file as appropriate depending on the given level.
 ///
+/// If `max_log_file_size` is provided, the log file will be rotated when it reaches
+/// the given size. The default size is 1MB.
+///
 /// The logging file lives in the node's `vfs/` directory, specifically at
 /// `node/vfs/package:publisher.os/log/process.log`, where `node` is your node's home
 /// directory, `package` is the package name, `publisher.os` is the publisher of the
 /// package, and `process` is the process name of the process doing the logging.
 pub fn init_logging(
-    our: &Address,
     file_level: Level,
     terminal_level: Level,
     remote: Option<RemoteLogSettings>,
     terminal_levels_mapping: Option<(u8, u8, u8, u8)>,
+    max_log_file_size: Option<u64>,
 ) -> anyhow::Result<()> {
+    let our = crate::our();
     let log_dir_path = create_drive(our.package_id(), "log", None)?;
     let log_file_path = format!("{log_dir_path}/{}.log", our.process());
     let log_file = open_file(&log_file_path, true, None)?;
@@ -142,7 +170,10 @@ pub fn init_logging(
     let debug_filter = tracing_subscriber::filter::filter_fn(|metadata: &tracing::Metadata<'_>| {
         metadata.level() == &Level::DEBUG
     });
-    let file_writer_maker = FileWriterMaker { file: log_file };
+    let file_writer_maker = FileWriterMaker {
+        file: log_file,
+        max_size: max_log_file_size.unwrap_or(1024 * 1024),
+    };
     let (error, warn, info, debug) = terminal_levels_mapping.unwrap_or_else(|| (0, 1, 2, 3));
     let error_terminal_writer_maker = TerminalWriterMaker { level: error };
     let warn_terminal_writer_maker = TerminalWriterMaker { level: warn };

src/logging.rs

@@ -128,7 +128,7 @@ pub enum IndexerRequests {
 #[derive(Clone, Debug, Serialize, Deserialize, Hash, Eq, PartialEq)]
 pub struct NamehashToNameRequest {
     pub hash: String,
-    pub block: Option<u64>,
+    pub block: u64,
 }
 
 /// Response from `kns-indexer:kns-indexer:sys`.
@@ -226,7 +226,7 @@ where
         .body(
             serde_json::to_vec(&IndexerRequests::NamehashToName(NamehashToNameRequest {
                 hash: namehash.into(),
-                block,
+                block: block.unwrap_or(0),
             }))
             .unwrap(),
         )

src/net.rs

@@ -83,7 +83,8 @@ impl Message {
     }
     /// Check if a `Message` was sent by a local process.
     /// Returns `false` if the `source` node is not our local node.
-    pub fn is_local(&self, our: &Address) -> bool {
+    pub fn is_local(&self) -> bool {
+        let our = crate::our();
         match self {
             Message::Request { source, .. } => source.node == our.node,
             Message::Response { source, .. } => source.node == our.node,

src/types/message.rs

@@ -129,28 +129,18 @@ impl<'de> Deserialize<'de> for PackageId {
 
 impl std::str::FromStr for PackageId {
     type Err = ProcessIdParseError;
-    /// Attempt to parse a `PackageId` from a string. The string must
-    /// contain exactly two segments, where segments are non-empty strings
-    /// separated by a colon (`:`). The segments cannot themselves contain colons.
+    /// Attempts to parse a `PackageId` from a string. The string must match the pattern
+    /// of two segments containing only lowercase letters, numbers and hyphens, separated by a colon.
     fn from_str(input: &str) -> Result<Self, Self::Err> {
-        let segments: Vec<&str> = input.split(':').collect();
-        if segments.len() < 2 {
-            return Err(ProcessIdParseError::MissingField);
-        } else if segments.len() > 2 {
-            return Err(ProcessIdParseError::TooManyColons);
-        }
-        let package_name = segments[0].to_string();
-        if package_name.is_empty() {
-            return Err(ProcessIdParseError::MissingField);
-        }
-        let publisher_node = segments[1].to_string();
-        if publisher_node.is_empty() {
-            return Err(ProcessIdParseError::MissingField);
+        let re = regex::Regex::new(r"^[a-z0-9-]+:[a-z0-9-]+$").unwrap();
+        if !re.is_match(input) {
+            return Err(ProcessIdParseError::InvalidCharacter);
         }
 
+        let segments: Vec<&str> = input.split(':').collect();
         Ok(PackageId {
-            package_name,
-            publisher_node,
+            package_name: segments[0].to_string(),
+            publisher_node: segments[1].to_string(),
         })
     }
 }