wip

Author: klkvr

crates/cheatcodes/assets/cheatcodes.json

@@ -1873,6 +1873,19 @@ interface Vm {
         pure
         returns (bytes32[] memory);
 
+    /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.
+    #[cheatcode(group = Json)]
+    function parseJsonType(string calldata json, string calldata typeDescription) external pure returns (bytes memory);
+    /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.
+    #[cheatcode(group = Json)]
+    function parseJsonType(string calldata json, string calldata key, string calldata typeDescription) external pure returns (bytes memory);
+    /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.
+    #[cheatcode(group = Json)]
+    function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)
+        external
+        pure
+        returns (bytes memory);
+
     /// Returns an array of all the keys in a JSON object.
     #[cheatcode(group = Json)]
     function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);

crates/cheatcodes/spec/src/vm.rs

@@ -286,6 +286,7 @@ macro_rules! impl_from {
 
 impl_from!(
     alloy_sol_types::Error,
+    alloy_dyn_abi::Error,
     alloy_primitives::SignatureError,
     FsPathError,
     hex::FromHexError,

crates/cheatcodes/src/error.rs

@@ -1,11 +1,10 @@
 //! Implementations of [`Json`](spec::Group::Json) cheatcodes.
 
 use crate::{string, Cheatcode, Cheatcodes, Result, Vm::*};
-use alloy_dyn_abi::{DynSolType, DynSolValue, Resolver};
+use alloy_dyn_abi::{parser::RootType, DynSolType, DynSolValue, Resolver, Specifier};
 use alloy_primitives::{hex, Address, B256, I256};
 use alloy_sol_types::SolValue;
 use foundry_common::fs;
-use foundry_compilers::resolver::parse;
 use foundry_config::fs_permissions::FsAccessKind;
 use serde_json::{Map, Value};
 use std::{borrow::Cow, collections::BTreeMap, fmt::Write};
@@ -136,6 +135,28 @@ impl Cheatcode for parseJsonBytes32ArrayCall {
     }
 }
 
+impl Cheatcode for parseJsonType_0Call {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { json, typeDescription } = self;
+        parse_json_coerce(json, "$", &resolve_type(&typeDescription)?).map(|v| v.abi_encode())
+    }
+}
+
+impl Cheatcode for parseJsonType_1Call {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { json, key, typeDescription } = self;
+        parse_json_coerce(json, key, &resolve_type(&typeDescription)?).map(|v| v.abi_encode())
+    }
+}
+
+impl Cheatcode for parseJsonTypeArrayCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { json, key, typeDescription } = self;
+        let ty = resolve_type(&typeDescription)?;
+        parse_json_coerce(json, key, &DynSolType::Array(Box::new(ty))).map(|v| v.abi_encode())
+    }
+}
+
 impl Cheatcode for parseJsonKeysCall {
     fn apply(&self, _state: &mut Cheatcodes) -> Result {
         let Self { json, key } = self;
@@ -344,7 +365,7 @@ pub(super) fn parse_json_array(array: &[Value], ty: &DynSolType) -> Result<DynSo
 }
 
 pub(super) fn parse_json_map(map: &Map<String, Value>, ty: &DynSolType) -> Result<DynSolValue> {
-    let Some((name, fields, types)) = ty.as_custom_struct() else {
+    let Some((_, fields, types)) = ty.as_custom_struct() else {
         bail!("expected struct type");
     };
 
@@ -550,6 +571,15 @@ where
     s
 }
 
+fn resolve_type(type_description: &str) -> Result<DynSolType> {
+    if let Ok(ty) = DynSolType::parse(type_description) {
+        return Ok(ty);
+    };
+
+    let struct_schema: StructSchema = serde_json::from_str(type_description)?;
+    Ok(struct_schema.resolve()?)
+}
+
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
 struct StructSchema {
     resolver: Resolver,