access-list getter

Author: Hallmane

src/hypermap.rs

@@ -619,4 +619,54 @@ impl Hypermap {
                 .collect::<Vec<_>>(),
         )
     }
+
+    /// Gets the list of delegate addresses stored via the standard Hypermap access control pattern.
+    /// This involves reading the `~access-list` note for the given `entry_path` to find the
+    /// namehash of the permissions note, then reading that permissions note to get the
+    /// ABI-encoded `Vec<Address>` of delegates.
+    ///
+    /// # Arguments
+    /// * `entry_path` - The base hypermap path (e.g., "myname.hypr") for which to find delegates.
+    ///
+    /// # Returns
+    /// A `Result<Vec<Address>, EthError>` containing the list of delegate addresses if found
+    /// and decoded successfully, or an error otherwise.
+    pub fn get_access_list_delegates(&self, entry_path: &str) -> Result<Vec<Address>, EthError> {
+        // 1. Construct the path to the ~access-list note
+        let access_list_path = format!("~access-list.{}", entry_path);
+
+        // 2. Get the ~access-list note data (expecting a B256 namehash)
+        let (_tba, _owner, access_list_data_opt) = self.get(&access_list_path)?;
+
+        let access_list_data = access_list_data_opt.ok_or_else(|| {
+            // Note not found or has no data - considered a malformed/unexpected response
+            EthError::RpcMalformedResponse
+        })?;
+
+        // 3. Decode the data as the permissions note hash (B256)
+        // We expect the raw bytes stored in the note to be exactly 32 bytes.
+        if access_list_data.len() != 32 {
+            // Invalid data length - malformed response
+            return Err(EthError::RpcMalformedResponse);
+        }
+        let perms_note_hash = B256::from_slice(access_list_data.as_ref());
+        let perms_note_hash_str = format!("0x{}", hex::encode(perms_note_hash));
+
+        // 4. Get the permissions note using the hash
+        let (_perms_tba, _perms_owner, perms_data_opt) =
+            self.get_hash(&perms_note_hash_str)?;
+
+        let perms_data = perms_data_opt.ok_or_else(|| {
+            // Permissions note not found or has no data - malformed/unexpected response
+            EthError::RpcMalformedResponse
+        })?;
+
+        // 5. Decode the permissions data as Vec<Address>
+        let delegates = Vec::<Address>::abi_decode(&perms_data, true).map_err(|_e| {
+            // Failed to decode Vec<Address> - malformed response
+            EthError::RpcMalformedResponse
+        })?;
+
+        Ok(delegates)
+    }
 }

src/wallet.rs

@@ -2152,3 +2152,52 @@ pub fn get_token_details(
         formatted_balance,
     })
 }
+
+//
+// CALLDATA CREATION HELPERS
+//
+
+/// Creates the ABI-encoded calldata for an ERC20 `transfer` call.
+///
+/// # Arguments
+/// * `recipient` - The address to transfer tokens to.
+/// * `amount` - The amount of tokens to transfer (in the token's smallest unit, e.g., wei for ETH-like).
+///
+/// # Returns
+/// A `Vec<u8>` containing the ABI-encoded calldata.
+pub fn create_erc20_transfer_calldata(
+    recipient: EthAddress,
+    amount: U256,
+) -> Vec<u8> {
+    let call = IERC20::transferCall { to: recipient, value: amount };
+    call.abi_encode()
+}
+
+/// Creates the ABI-encoded calldata for a Hypermap `note` call.
+/// Performs validation on the note key format.
+///
+/// # Arguments
+/// * `note_key` - The note key (e.g., "~my-note"). Must start with '~'.
+/// * `data` - The byte data to store in the note.
+///
+/// # Returns
+/// A `Result<Vec<u8>, WalletError>` containing the ABI-encoded calldata on success,
+/// or a `WalletError::NameResolutionError` if the note key format is invalid.
+pub fn create_hypermap_note_calldata(
+    note_key: &str,
+    data: Vec<u8>,
+) -> Result<Vec<u8>, WalletError> {
+    // Validate the note key format
+    if !hypermap::valid_note(note_key) {
+        return Err(WalletError::NameResolutionError(format!(
+            "Invalid note key format: '{}'. Must start with '~' and follow naming rules.",
+            note_key
+        )));
+    }
+
+    let call = hypermap::contract::noteCall {
+        note: Bytes::from(note_key.as_bytes().to_vec()),
+        data: Bytes::from(data),
+    };
+    Ok(call.abi_encode())
+}