rename kns -> hns & kimap -> hypermap

Author: nick1udwig

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "hyperware_process_lib"
 authors = ["Sybil Technologies AG"]
-version = "1.0.2"
+version = "1.0.3"
 edition = "2021"
 description = "A library for writing Hyperware processes in Rust."
 homepage = "https://hyperware.ai"

Cargo.toml

@@ -9,7 +9,7 @@ interface standard {
     /// JSON is passed over Wasm boundary as a string.
     type json = string;
 
-    /// In types passed from kernel, node-id will be a valid Kimap entry.
+    /// In types passed from kernel, node-id will be a valid Hypermap entry.
     type node-id = string;
 
     /// Context, like a message body, is a protocol-defined serialized byte

hyperware-wit/hyperware.wit

@@ -188,7 +188,7 @@ pub enum EthConfigAction {
 pub enum EthConfigResponse {
     Ok,
     /// Response from a GetProviders request.
-    /// Note the [`crate::net::KnsUpdate`] will only have the correct `name` field.
+    /// Note the [`crate::net::HnsUpdate`] will only have the correct `name` field.
     /// The rest of the Update is not saved in this module.
     Providers(SavedConfigs),
     /// Response from a GetAccessSettings request.
@@ -240,7 +240,7 @@ impl From<Authorization> for AlloyAuthorization {
 #[derive(Clone, Debug, Serialize, Hash, Eq, PartialEq)]
 pub enum NodeOrRpcUrl {
     Node {
-        kns_update: crate::net::KnsUpdate,
+        hns_update: crate::net::HnsUpdate,
         use_as_provider: bool, // false for just-routers inside saved config
     },
     RpcUrl {
@@ -252,7 +252,7 @@ pub enum NodeOrRpcUrl {
 impl std::cmp::PartialEq<str> for NodeOrRpcUrl {
     fn eq(&self, other: &str) -> bool {
         match self {
-            NodeOrRpcUrl::Node { kns_update, .. } => kns_update.name == other,
+            NodeOrRpcUrl::Node { hns_update, .. } => hns_update.name == other,
             NodeOrRpcUrl::RpcUrl { url, .. } => url == other,
         }
     }
@@ -276,7 +276,7 @@ impl<'de> Deserialize<'de> for NodeOrRpcUrl {
         #[derive(Deserialize)]
         enum Helper {
             Node {
-                kns_update: crate::net::KnsUpdate,
+                hns_update: crate::net::HnsUpdate,
                 use_as_provider: bool,
             },
             RpcUrl(RpcUrlHelper),
@@ -286,10 +286,10 @@ impl<'de> Deserialize<'de> for NodeOrRpcUrl {
 
         Ok(match helper {
             Helper::Node {
-                kns_update,
+                hns_update,
                 use_as_provider,
             } => NodeOrRpcUrl::Node {
-                kns_update,
+                hns_update,
                 use_as_provider,
             },
             Helper::RpcUrl(url_helper) => match url_helper {
@@ -675,14 +675,14 @@ impl Provider {
         self.send_request_and_parse_response::<Bytes>(action)
     }
 
-    /// Returns a Kimap instance with the default address using this provider.
-    pub fn kimap(&self) -> crate::kimap::Kimap {
-        crate::kimap::Kimap::default(self.request_timeout)
+    /// Returns a Hypermap instance with the default address using this provider.
+    pub fn hypermap(&self) -> crate::hypermap::Hypermap {
+        crate::hypermap::Hypermap::default(self.request_timeout)
     }
 
-    /// Returns a Kimap instance with a custom address using this provider.
-    pub fn kimap_with_address(self, address: Address) -> crate::kimap::Kimap {
-        crate::kimap::Kimap::new(self, address)
+    /// Returns a Hypermap instance with a custom address using this provider.
+    pub fn hypermap_with_address(self, address: Address) -> crate::hypermap::Hypermap {
+        crate::hypermap::Hypermap::new(self, address)
     }
 
     /// Sends a raw transaction to the network.

src/eth.rs

@@ -597,7 +597,7 @@ impl HttpServer {
     /// Instead of binding at just a path, this function tells the HTTP server to
     /// generate a *subdomain* with our package ID (with non-ascii-alphanumeric
     /// characters converted to `-`, although will not be needed if package ID is
-    /// a genuine kimap entry) and bind at that subdomain.
+    /// a genuine hypermap entry) and bind at that subdomain.
     pub fn secure_bind_http_path<T>(&mut self, path: T) -> Result<(), HttpServerError>
     where
         T: Into<String>,
@@ -639,7 +639,7 @@ impl HttpServer {
     /// Instead of binding at just a path, this function tells the HTTP server to
     /// generate a *subdomain* with our package ID (with non-ascii-alphanumeric
     /// characters converted to `-`, although will not be needed if package ID is
-    /// a genuine kimap entry) and bind at that subdomain.
+    /// a genuine hypermap entry) and bind at that subdomain.
     pub fn secure_bind_ws_path<T>(&mut self, path: T) -> Result<(), HttpServerError>
     where
         T: Into<String>,

src/http/server.rs

@@ -1,5 +1,5 @@
 use crate::eth::{EthError, Provider};
-use crate::kimap::contract::getCall;
+use crate::hypermap::contract::getCall;
 use crate::net;
 use alloy::rpc::types::request::{TransactionInput, TransactionRequest};
 use alloy::{hex, primitives::keccak256};
@@ -11,17 +11,17 @@ use std::error::Error;
 use std::fmt;
 use std::str::FromStr;
 
-/// kimap deployment address on base
-pub const KIMAP_ADDRESS: &'static str = "0x000000000033e5CCbC52Ec7BDa87dB768f9aA93F";
+/// hypermap deployment address on base
+pub const HYPERMAP_ADDRESS: &'static str = "0x000000000033e5CCbC52Ec7BDa87dB768f9aA93F";
 /// base chain id
-pub const KIMAP_CHAIN_ID: u64 = 8453;
-/// first block (minus one) of kimap deployment on base
-pub const KIMAP_FIRST_BLOCK: u64 = 25_346_377;
-/// the root hash of kimap, empty bytes32
-pub const KIMAP_ROOT_HASH: &'static str =
+pub const HYPERMAP_CHAIN_ID: u64 = 8453;
+/// first block (minus one) of hypermap deployment on base
+pub const HYPERMAP_FIRST_BLOCK: u64 = 25_346_377;
+/// the root hash of hypermap, empty bytes32
+pub const HYPERMAP_ROOT_HASH: &'static str =
     "0x0000000000000000000000000000000000000000000000000000000000000000";
 
-/// Sol structures for Kimap requests
+/// Sol structures for Hypermap requests
 pub mod contract {
     use alloy_sol_macro::sol;
 
@@ -229,33 +229,33 @@ pub mod contract {
     }
 }
 
-/// A mint log from the kimap, converted to a 'resolved' format using
-/// namespace data saved in the kns-indexer.
+/// A mint log from the hypermap, converted to a 'resolved' format using
+/// namespace data saved in the hns-indexer.
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Mint {
     pub name: String,
     pub parent_path: String,
 }
 
-/// A note log from the kimap, converted to a 'resolved' format using
-/// namespace data saved in the kns-indexer
+/// A note log from the hypermap, converted to a 'resolved' format using
+/// namespace data saved in the hns-indexer
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Note {
     pub note: String,
     pub parent_path: String,
     pub data: Bytes,
 }
 
-/// A fact log from the kimap, converted to a 'resolved' format using
-/// namespace data saved in the kns-indexer
+/// A fact log from the hypermap, converted to a 'resolved' format using
+/// namespace data saved in the hns-indexer
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Fact {
     pub fact: String,
     pub parent_path: String,
     pub data: Bytes,
 }
 
-/// Errors that can occur when decoding a log from the kimap using
+/// Errors that can occur when decoding a log from the hypermap using
 /// [`decode_mint_log()`] or [`decode_note_log()`].
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub enum DecodeLogError {
@@ -265,7 +265,7 @@ pub enum DecodeLogError {
     InvalidName(String),
     /// An error occurred while decoding the log.
     DecodeError(String),
-    /// The parent name could not be resolved with `kns-indexer`.
+    /// The parent name could not be resolved with `hns-indexer`.
     UnresolvedParent(String),
 }
 
@@ -284,10 +284,10 @@ impl fmt::Display for DecodeLogError {
 
 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
+/// Canonical function to determine if a hypermap entry is valid. This should
+/// be used whenever reading a new hypermap entry from a mints query, because
 /// while most frontends will enforce these rules, it is possible to post
-/// invalid names to the kimap contract.
+/// invalid names to the hypermap contract.
 ///
 /// This checks a **single name**, not the full path-name. A full path-name
 /// is comprised of valid names separated by `.`
@@ -332,7 +332,7 @@ pub fn valid_fact(fact: &str) -> bool {
             .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-')
 }
 
-/// Produce a namehash from a kimap name.
+/// Produce a namehash from a hypermap name.
 pub fn namehash(name: &str) -> String {
     let mut node = B256::default();
 
@@ -346,7 +346,7 @@ pub fn namehash(name: &str) -> String {
     format!("0x{}", hex::encode(node))
 }
 
-/// Decode a mint log from the kimap into a 'resolved' format.
+/// Decode a mint log from the hypermap into a 'resolved' format.
 ///
 /// Uses [`valid_name()`] to check if the name is valid.
 pub fn decode_mint_log(log: &crate::eth::Log) -> Result<Mint, DecodeLogError> {
@@ -365,7 +365,7 @@ pub fn decode_mint_log(log: &crate::eth::Log) -> Result<Mint, DecodeLogError> {
     }
 }
 
-/// Decode a note log from the kimap into a 'resolved' format.
+/// Decode a note log from the hypermap into a 'resolved' format.
 ///
 /// Uses [`valid_name()`] to check if the name is valid.
 pub fn decode_note_log(log: &crate::eth::Log) -> Result<Note, DecodeLogError> {
@@ -408,14 +408,14 @@ pub fn decode_fact_log(log: &crate::eth::Log) -> Result<Fact, DecodeLogError> {
     }
 }
 
-/// Given a [`crate::eth::Log`] (which must be a log from kimap), resolve the parent name
+/// Given a [`crate::eth::Log`] (which must be a log from hypermap), resolve the parent name
 /// of the new entry or note.
 pub fn resolve_parent(log: &crate::eth::Log, timeout: Option<u64>) -> Option<String> {
     let parent_hash = log.topics()[1].to_string();
     net::get_name(&parent_hash, log.block_number, timeout)
 }
 
-/// Given a [`crate::eth::Log`] (which must be a log from kimap), resolve the full name
+/// Given a [`crate::eth::Log`] (which must be a log from hypermap), resolve the full name
 /// of the new entry or note.
 ///
 /// Uses [`valid_name()`] to check if the name is valid.
@@ -448,38 +448,38 @@ pub fn resolve_full_name(log: &crate::eth::Log, timeout: Option<u64>) -> Option<
     Some(format!("{name}.{parent_name}"))
 }
 
-/// Helper struct for reading from the kimap.
+/// Helper struct for reading from the hypermap.
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Kimap {
+pub struct Hypermap {
     pub provider: Provider,
     address: Address,
 }
 
-impl Kimap {
-    /// Creates a new Kimap instance with a specified address.
+impl Hypermap {
+    /// Creates a new Hypermap instance with a specified address.
     ///
     /// # Arguments
     /// * `provider` - A reference to the Provider.
-    /// * `address` - The address of the Kimap contract.
+    /// * `address` - The address of the Hypermap contract.
     pub fn new(provider: Provider, address: Address) -> Self {
         Self { provider, address }
     }
 
-    /// Creates a new Kimap instance with the default address and chain ID.
+    /// Creates a new Hypermap instance with the default address and chain ID.
     pub fn default(timeout: u64) -> Self {
-        let provider = Provider::new(KIMAP_CHAIN_ID, timeout);
-        Self::new(provider, Address::from_str(KIMAP_ADDRESS).unwrap())
+        let provider = Provider::new(HYPERMAP_CHAIN_ID, timeout);
+        Self::new(provider, Address::from_str(HYPERMAP_ADDRESS).unwrap())
     }
 
-    /// Returns the in-use Kimap contract address.
+    /// Returns the in-use Hypermap contract address.
     pub fn address(&self) -> &Address {
         &self.address
     }
 
-    /// Gets an entry from the Kimap by its string-formatted name.
+    /// Gets an entry from the Hypermap by its string-formatted name.
     ///
     /// # Parameters
-    /// - `path`: The name-path to get from the Kimap.
+    /// - `path`: The name-path to get from the Hypermap.
     /// # Returns
     /// A `Result<(Address, Address, Option<Bytes>), EthError>` representing the TBA, owner,
     /// and value if the entry exists and is a note.
@@ -508,10 +508,10 @@ impl Kimap {
         Ok((res.tba, res.owner, note_data))
     }
 
-    /// Gets an entry from the Kimap by its hash.
+    /// Gets an entry from the Hypermap by its hash.
     ///
     /// # Parameters
-    /// - `entryhash`: The entry to get from the Kimap.
+    /// - `entryhash`: The entry to get from the Hypermap.
     /// # Returns
     /// A `Result<(Address, Address, Option<Bytes>), EthError>` representing the TBA, owner,
     /// and value if the entry exists and is a note.
@@ -587,7 +587,7 @@ impl Kimap {
     ///
     /// Example:
     /// ```rust
-    /// let filter = kimap.notes_filter(&["~note1", "~note2"]);
+    /// let filter = hypermap.notes_filter(&["~note1", "~note2"]);
     /// ```
     pub fn notes_filter(&self, notes: &[&str]) -> crate::eth::Filter {
         self.note_filter().topic3(
@@ -603,7 +603,7 @@ impl Kimap {
     ///
     /// Example:
     /// ```rust
-    /// let filter = kimap.facts_filter(&["!fact1", "!fact2"]);
+    /// let filter = hypermap.facts_filter(&["!fact1", "!fact2"]);
     /// ```
     pub fn facts_filter(&self, facts: &[&str]) -> crate::eth::Filter {
         self.fact_filter().topic3(

src/kimap.rs renamed to src/hypermap.rs

@@ -289,7 +289,7 @@ pub struct Erc721Metadata {
 ///
 /// Fields:
 /// - `package_name`: The unique name of the package, used in the [`crate::PackageId`], e.g. `package_name:publisher`.
-/// - `publisher`: The KNS identity of the package publisher used in the [`crate::PackageId`], e.g. `package_name:publisher`
+/// - `publisher`: The HNS identity of the package publisher used in the [`crate::PackageId`], e.g. `package_name:publisher`
 /// - `current_version`: A string representing the current version of the package, e.g. `1.0.0`.
 /// - `mirrors`: A list of NodeIds where the package can be found, providing redundancy.
 /// - `code_hashes`: A map from version names to their respective SHA-256 hashes.

src/kernel_types.rs

@@ -39,8 +39,8 @@ pub mod http;
 /// be incompatible with WIT types in some cases, leading to annoying errors.
 /// Use only to interact with the kernel or runtime in certain ways.
 pub mod kernel_types;
-/// Interact with kimap, the onchain namespace
-pub mod kimap;
+/// Interact with hypermap, the onchain namespace
+pub mod hypermap;
 /// Interact with the key_value module
 ///
 /// Your process must have the [`Capability`] to message and receive messages from