diff --git a/packages/nextjs/app/debug/_components/contract/ContractReadMethods.tsx b/packages/nextjs/app/debug/_components/contract/ContractReadMethods.tsx
index c8d184e2a..e77bde50b 100644
--- a/packages/nextjs/app/debug/_components/contract/ContractReadMethods.tsx
+++ b/packages/nextjs/app/debug/_components/contract/ContractReadMethods.tsx
@@ -5,6 +5,7 @@ import {
   ContractName,
   GenericContract,
   InheritedFunctions,
+  getFunctionsByStateMutability,
 } from "~~/utils/scaffold-stark/contract";
 import { ReadOnlyFunctionForm } from "./ReadOnlyFunctionForm";
 
@@ -17,36 +18,19 @@ export const ContractReadMethods = ({
     return null;
   }
 
-  const functionsToDisplay = ((deployedContractData.abi || []) as Abi)
-    .reduce((acc, part) => {
-      if (part.type === "function") {
-        acc.push(part);
-      } else if (part.type === "interface" && Array.isArray(part.items)) {
-        part.items.forEach((item) => {
-          if (item.type === "function") {
-            acc.push(item);
-          }
-        });
-      }
-      return acc;
-    }, [] as AbiFunction[])
+  const functionsToDisplay = getFunctionsByStateMutability(
+    (deployedContractData.abi || []) as Abi,
+    "view",
+  )
     .filter((fn) => {
-      const isQueryableWithParams =
-        fn.state_mutability === "view" && fn.inputs.length > 0;
+      const isQueryableWithParams = fn.inputs.length > 0;
       return isQueryableWithParams;
     })
     .map((fn) => {
       return {
         fn,
-        //   inheritedFrom: (
-        //     (deployedContractData as GenericContract)
-        //       ?.inheritedFunctions as InheritedFunctions
-        //   )?.[fn.name],
       };
     });
-  //     .sort((a, b) =>
-  //       b.inheritedFrom ? b.inheritedFrom.localeCompare(a.inheritedFrom) : 1
-  //     );
   if (!functionsToDisplay.length) {
     return <>No read methods</>;
   }
@@ -58,7 +42,6 @@ export const ContractReadMethods = ({
           contractAddress={deployedContractData.address}
           abiFunction={fn}
           key={fn.name}
-          //   inheritedFrom={inheritedFrom}
         />
       ))}
     </>
diff --git a/packages/nextjs/app/debug/_components/contract/ContractVariables.tsx b/packages/nextjs/app/debug/_components/contract/ContractVariables.tsx
index 3c2013b30..f3fc73465 100644
--- a/packages/nextjs/app/debug/_components/contract/ContractVariables.tsx
+++ b/packages/nextjs/app/debug/_components/contract/ContractVariables.tsx
@@ -5,6 +5,7 @@ import {
   ContractName,
   GenericContract,
   InheritedFunctions,
+  getFunctionsByStateMutability,
 } from "~~/utils/scaffold-stark/contract";
 import { DisplayVariable } from "./DisplayVariable";
 
@@ -19,37 +20,19 @@ export const ContractVariables = ({
     return null;
   }
 
-  const functionsToDisplay = ((deployedContractData.abi || []) as Abi)
-    .reduce((acc, part) => {
-      if (part.type === "function") {
-        acc.push(part);
-      } else if (part.type === "interface" && Array.isArray(part.items)) {
-        part.items.forEach((item) => {
-          if (item.type === "function") {
-            acc.push(item);
-          }
-        });
-      }
-      return acc;
-    }, [] as AbiFunction[])
+  const functionsToDisplay = getFunctionsByStateMutability(
+    (deployedContractData.abi || []) as Abi,
+    "view",
+  )
     .filter((fn) => {
-      const isQueryableWithNoParams =
-        fn.state_mutability === "view" && fn.inputs.length === 0;
-      return isQueryableWithNoParams;
+      const isQueryableWithParams = fn.inputs.length === 0;
+      return isQueryableWithParams;
     })
     .map((fn) => {
       return {
         fn,
-        // inheritedFrom: (
-        //   (deployedContractData as GenericContract)
-        //     ?.inheritedFunctions as InheritedFunctions
-        // )?.[fn.name],
       };
     });
-  // .sort((a, b) =>
-  //   b.inheritedFrom ? b.inheritedFrom.localeCompare(a.inheritedFrom) : 1
-  // );
-
   if (!functionsToDisplay.length) {
     return <>No contract variables</>;
   }
diff --git a/packages/nextjs/app/debug/_components/contract/ContractWriteMethods.tsx b/packages/nextjs/app/debug/_components/contract/ContractWriteMethods.tsx
index aa076d5be..f124110e6 100644
--- a/packages/nextjs/app/debug/_components/contract/ContractWriteMethods.tsx
+++ b/packages/nextjs/app/debug/_components/contract/ContractWriteMethods.tsx
@@ -6,6 +6,7 @@ import {
   ContractName,
   GenericContract,
   InheritedFunctions,
+  getFunctionsByStateMutability,
 } from "~~/utils/scaffold-stark/contract";
 
 export const ContractWriteMethods = ({
@@ -19,35 +20,14 @@ export const ContractWriteMethods = ({
     return null;
   }
 
-  const functionsToDisplay = ((deployedContractData.abi || []) as Abi)
-    .reduce((acc, part) => {
-      if (part.type === "function") {
-        acc.push(part);
-      } else if (part.type === "interface" && Array.isArray(part.items)) {
-        part.items.forEach((item) => {
-          if (item.type === "function") {
-            acc.push(item);
-          }
-        });
-      }
-      return acc;
-    }, [] as AbiFunction[])
-    .filter((fn) => {
-      const isWriteableFunction = fn.state_mutability == "external";
-      return isWriteableFunction;
-    })
-    .map((fn) => {
-      return {
-        fn,
-        // inheritedFrom: (
-        //   (deployedContractData as GenericContract)
-        //     ?.inheritedFunctions as InheritedFunctions
-        // )?.[fn.name],
-      };
-    });
-  // .sort((a, b) =>
-  //   b.inheritedFrom ? b.inheritedFrom.localeCompare(a.inheritedFrom) : 1
-  // );
+  const functionsToDisplay = getFunctionsByStateMutability(
+    (deployedContractData.abi || []) as Abi,
+    "external",
+  ).map((fn) => {
+    return {
+      fn,
+    };
+  });
 
   if (!functionsToDisplay.length) {
     return <>No write methods</>;
diff --git a/packages/nextjs/app/debug/_components/contract/DisplayVariable.tsx b/packages/nextjs/app/debug/_components/contract/DisplayVariable.tsx
index 0e2a04d66..43d338324 100644
--- a/packages/nextjs/app/debug/_components/contract/DisplayVariable.tsx
+++ b/packages/nextjs/app/debug/_components/contract/DisplayVariable.tsx
@@ -27,6 +27,7 @@ export const DisplayVariable = ({
 }: DisplayVariableProps) => {
   const {
     data: result,
+    isLoading,
     isFetching,
     refetch,
   } = useContractRead({
@@ -52,7 +53,7 @@ export const DisplayVariable = ({
           className="btn btn-ghost btn-xs"
           onClick={async () => await refetch()}
         >
-          {isFetching ? (
+          {!isLoading && isFetching ? (
             <span className="loading loading-spinner loading-xs"></span>
           ) : (
             <ArrowPathIcon
diff --git a/packages/nextjs/app/debug/_components/contract/ReadOnlyFunctionForm.tsx b/packages/nextjs/app/debug/_components/contract/ReadOnlyFunctionForm.tsx
index cc6d167ee..18510850a 100644
--- a/packages/nextjs/app/debug/_components/contract/ReadOnlyFunctionForm.tsx
+++ b/packages/nextjs/app/debug/_components/contract/ReadOnlyFunctionForm.tsx
@@ -32,13 +32,13 @@ export const ReadOnlyFunctionForm = ({
   const [form, setForm] = useState<Record<string, any>>(() =>
     getInitialFormState(abiFunction),
   );
-  const [result, setResult] = useState<unknown>();
+  const [inputValue, setInputValue] = useState<any>();
 
-  const { isLoading, isFetching, refetch } = useContractRead({
+  const { isLoading, isFetching, data } = useContractRead({
     address: contractAddress,
     functionName: abiFunction.name,
     abi: [...abi],
-    args: getParsedContractFunctionArgs(form),
+    args: inputValue,
     enabled: false, // TODO : notify when failed - add error
     blockIdentifier: "pending" as BlockNumber,
   });
@@ -49,7 +49,7 @@ export const ReadOnlyFunctionForm = ({
       <ContractInput
         key={key}
         setForm={(updatedFormValue) => {
-          setResult(undefined);
+          setInputValue(undefined);
           setForm(updatedFormValue);
         }}
         form={form}
@@ -68,11 +68,11 @@ export const ReadOnlyFunctionForm = ({
       {inputElements}
       <div className="flex justify-between gap-2 flex-wrap">
         <div className="flex-grow w-4/5">
-          {result !== null && result !== undefined && (
+          {data !== null && data !== undefined && (
             <div className="bg-secondary rounded-3xl text-sm px-4 py-1.5 break-words">
               <p className="font-bold m-0 mb-1">Result:</p>
               <pre className="whitespace-pre-wrap break-words">
-                {displayTxResult(result, false, abiFunction?.outputs)}
+                {displayTxResult(data, false, abiFunction?.outputs)}
               </pre>
             </div>
           )}
@@ -80,8 +80,7 @@ export const ReadOnlyFunctionForm = ({
         <button
           className="btn btn-secondary btn-sm"
           onClick={async () => {
-            const { data } = await refetch();
-            setResult(data);
+            setInputValue(getParsedContractFunctionArgs(form));
           }}
           disabled={!isLoading && isFetching}
         >
diff --git a/packages/nextjs/app/debug/_components/contract/utilsContract.tsx b/packages/nextjs/app/debug/_components/contract/utilsContract.tsx
index 34e9a1e2c..71e6bbbeb 100644
--- a/packages/nextjs/app/debug/_components/contract/utilsContract.tsx
+++ b/packages/nextjs/app/debug/_components/contract/utilsContract.tsx
@@ -1,4 +1,8 @@
-import { AbiFunction, AbiParameter } from "~~/utils/scaffold-stark/contract";
+import {
+  AbiFunction,
+  AbiParameter,
+  parseParamWithType,
+} from "~~/utils/scaffold-stark/contract";
 import { uint256 } from "starknet";
 import { byteArray } from "starknet-dev";
 /**
@@ -35,12 +39,7 @@ const getInitialFormState = (abiFunction: AbiFunction) => {
 // Recursive function to deeply parse JSON strings, correctly handling nested arrays and encoded JSON strings
 const deepParseValues = (value: any, keyAndType?: any): any => {
   if (keyAndType) {
-    if (keyAndType.includes("core::integer::u256")) {
-      return uint256.bnToUint256(value);
-    }
-    if (keyAndType.includes("core::byte_array::ByteArray")) {
-      return byteArray.byteArrayFromString(value);
-    }
+    return parseParamWithType(keyAndType, value);
   }
   if (typeof value === "string") {
     if (isJsonString(value)) {
diff --git a/packages/nextjs/contracts/deployedContracts.ts b/packages/nextjs/contracts/deployedContracts.ts
index 5052ea1d6..25751cee0 100644
--- a/packages/nextjs/contracts/deployedContracts.ts
+++ b/packages/nextjs/contracts/deployedContracts.ts
@@ -3,536 +3,6 @@
  * You should not edit it manually or your changes might be overwritten.
  */
 
-const deployedContracts = {
-  devnet: {
-    Challenge0: {
-      address:
-        "0x029de5578255560287ebdad126340555672f25ff9799e2e61e6c861fa2035cec",
-      abi: [
-        {
-          type: "impl",
-          name: "WrappedIERC721MetadataImpl",
-          interface_name:
-            "openzeppelin::token::erc721::interface::IERC721Metadata",
-        },
-        {
-          type: "struct",
-          name: "core::byte_array::ByteArray",
-          members: [
-            {
-              name: "data",
-              type: "core::array::Array::<core::bytes_31::bytes31>",
-            },
-            {
-              name: "pending_word",
-              type: "core::felt252",
-            },
-            {
-              name: "pending_word_len",
-              type: "core::integer::u32",
-            },
-          ],
-        },
-        {
-          type: "struct",
-          name: "core::integer::u256",
-          members: [
-            {
-              name: "low",
-              type: "core::integer::u128",
-            },
-            {
-              name: "high",
-              type: "core::integer::u128",
-            },
-          ],
-        },
-        {
-          type: "interface",
-          name: "openzeppelin::token::erc721::interface::IERC721Metadata",
-          items: [
-            {
-              type: "function",
-              name: "name",
-              inputs: [],
-              outputs: [
-                {
-                  type: "core::byte_array::ByteArray",
-                },
-              ],
-              state_mutability: "view",
-            },
-            {
-              type: "function",
-              name: "symbol",
-              inputs: [],
-              outputs: [
-                {
-                  type: "core::byte_array::ByteArray",
-                },
-              ],
-              state_mutability: "view",
-            },
-            {
-              type: "function",
-              name: "token_uri",
-              inputs: [
-                {
-                  name: "token_id",
-                  type: "core::integer::u256",
-                },
-              ],
-              outputs: [
-                {
-                  type: "core::byte_array::ByteArray",
-                },
-              ],
-              state_mutability: "view",
-            },
-          ],
-        },
-        {
-          type: "impl",
-          name: "Challenge0Impl",
-          interface_name: "contracts::challenge0::IChallenge0",
-        },
-        {
-          type: "interface",
-          name: "contracts::challenge0::IChallenge0",
-          items: [
-            {
-              type: "function",
-              name: "mint_item",
-              inputs: [
-                {
-                  name: "recipient",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "uri",
-                  type: "core::byte_array::ByteArray",
-                },
-              ],
-              outputs: [
-                {
-                  type: "core::integer::u256",
-                },
-              ],
-              state_mutability: "external",
-            },
-            {
-              type: "function",
-              name: "token_id_counter",
-              inputs: [],
-              outputs: [
-                {
-                  type: "core::integer::u256",
-                },
-              ],
-              state_mutability: "view",
-            },
-          ],
-        },
-        {
-          type: "impl",
-          name: "ERC721Impl",
-          interface_name: "openzeppelin::token::erc721::interface::IERC721",
-        },
-        {
-          type: "struct",
-          name: "core::array::Span::<core::felt252>",
-          members: [
-            {
-              name: "snapshot",
-              type: "@core::array::Array::<core::felt252>",
-            },
-          ],
-        },
-        {
-          type: "enum",
-          name: "core::bool",
-          variants: [
-            {
-              name: "False",
-              type: "()",
-            },
-            {
-              name: "True",
-              type: "()",
-            },
-          ],
-        },
-        {
-          type: "interface",
-          name: "openzeppelin::token::erc721::interface::IERC721",
-          items: [
-            {
-              type: "function",
-              name: "balance_of",
-              inputs: [
-                {
-                  name: "account",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-              ],
-              outputs: [
-                {
-                  type: "core::integer::u256",
-                },
-              ],
-              state_mutability: "view",
-            },
-            {
-              type: "function",
-              name: "owner_of",
-              inputs: [
-                {
-                  name: "token_id",
-                  type: "core::integer::u256",
-                },
-              ],
-              outputs: [
-                {
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-              ],
-              state_mutability: "view",
-            },
-            {
-              type: "function",
-              name: "safe_transfer_from",
-              inputs: [
-                {
-                  name: "from",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "to",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "token_id",
-                  type: "core::integer::u256",
-                },
-                {
-                  name: "data",
-                  type: "core::array::Span::<core::felt252>",
-                },
-              ],
-              outputs: [],
-              state_mutability: "external",
-            },
-            {
-              type: "function",
-              name: "transfer_from",
-              inputs: [
-                {
-                  name: "from",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "to",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "token_id",
-                  type: "core::integer::u256",
-                },
-              ],
-              outputs: [],
-              state_mutability: "external",
-            },
-            {
-              type: "function",
-              name: "approve",
-              inputs: [
-                {
-                  name: "to",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "token_id",
-                  type: "core::integer::u256",
-                },
-              ],
-              outputs: [],
-              state_mutability: "external",
-            },
-            {
-              type: "function",
-              name: "set_approval_for_all",
-              inputs: [
-                {
-                  name: "operator",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "approved",
-                  type: "core::bool",
-                },
-              ],
-              outputs: [],
-              state_mutability: "external",
-            },
-            {
-              type: "function",
-              name: "get_approved",
-              inputs: [
-                {
-                  name: "token_id",
-                  type: "core::integer::u256",
-                },
-              ],
-              outputs: [
-                {
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-              ],
-              state_mutability: "view",
-            },
-            {
-              type: "function",
-              name: "is_approved_for_all",
-              inputs: [
-                {
-                  name: "owner",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-                {
-                  name: "operator",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-              ],
-              outputs: [
-                {
-                  type: "core::bool",
-                },
-              ],
-              state_mutability: "view",
-            },
-          ],
-        },
-        {
-          type: "impl",
-          name: "OwnableImpl",
-          interface_name: "openzeppelin::access::ownable::interface::IOwnable",
-        },
-        {
-          type: "interface",
-          name: "openzeppelin::access::ownable::interface::IOwnable",
-          items: [
-            {
-              type: "function",
-              name: "owner",
-              inputs: [],
-              outputs: [
-                {
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-              ],
-              state_mutability: "view",
-            },
-            {
-              type: "function",
-              name: "transfer_ownership",
-              inputs: [
-                {
-                  name: "new_owner",
-                  type: "core::starknet::contract_address::ContractAddress",
-                },
-              ],
-              outputs: [],
-              state_mutability: "external",
-            },
-            {
-              type: "function",
-              name: "renounce_ownership",
-              inputs: [],
-              outputs: [],
-              state_mutability: "external",
-            },
-          ],
-        },
-        {
-          type: "constructor",
-          name: "constructor",
-          inputs: [
-            {
-              name: "owner",
-              type: "core::starknet::contract_address::ContractAddress",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::token::erc721::erc721::ERC721Component::Transfer",
-          kind: "struct",
-          members: [
-            {
-              name: "from",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "to",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "token_id",
-              type: "core::integer::u256",
-              kind: "key",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::token::erc721::erc721::ERC721Component::Approval",
-          kind: "struct",
-          members: [
-            {
-              name: "owner",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "approved",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "token_id",
-              type: "core::integer::u256",
-              kind: "key",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::token::erc721::erc721::ERC721Component::ApprovalForAll",
-          kind: "struct",
-          members: [
-            {
-              name: "owner",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "operator",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "approved",
-              type: "core::bool",
-              kind: "data",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::token::erc721::erc721::ERC721Component::Event",
-          kind: "enum",
-          variants: [
-            {
-              name: "Transfer",
-              type: "openzeppelin::token::erc721::erc721::ERC721Component::Transfer",
-              kind: "nested",
-            },
-            {
-              name: "Approval",
-              type: "openzeppelin::token::erc721::erc721::ERC721Component::Approval",
-              kind: "nested",
-            },
-            {
-              name: "ApprovalForAll",
-              type: "openzeppelin::token::erc721::erc721::ERC721Component::ApprovalForAll",
-              kind: "nested",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::introspection::src5::SRC5Component::Event",
-          kind: "enum",
-          variants: [],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::access::ownable::ownable::OwnableComponent::OwnershipTransferred",
-          kind: "struct",
-          members: [
-            {
-              name: "previous_owner",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "new_owner",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::access::ownable::ownable::OwnableComponent::OwnershipTransferStarted",
-          kind: "struct",
-          members: [
-            {
-              name: "previous_owner",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-            {
-              name: "new_owner",
-              type: "core::starknet::contract_address::ContractAddress",
-              kind: "key",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "openzeppelin::access::ownable::ownable::OwnableComponent::Event",
-          kind: "enum",
-          variants: [
-            {
-              name: "OwnershipTransferred",
-              type: "openzeppelin::access::ownable::ownable::OwnableComponent::OwnershipTransferred",
-              kind: "nested",
-            },
-            {
-              name: "OwnershipTransferStarted",
-              type: "openzeppelin::access::ownable::ownable::OwnableComponent::OwnershipTransferStarted",
-              kind: "nested",
-            },
-          ],
-        },
-        {
-          type: "event",
-          name: "contracts::challenge0::Challenge0::Event",
-          kind: "enum",
-          variants: [
-            {
-              name: "ERC721Event",
-              type: "openzeppelin::token::erc721::erc721::ERC721Component::Event",
-              kind: "flat",
-            },
-            {
-              name: "SRC5Event",
-              type: "openzeppelin::introspection::src5::SRC5Component::Event",
-              kind: "flat",
-            },
-            {
-              name: "OwnableEvent",
-              type: "openzeppelin::access::ownable::ownable::OwnableComponent::Event",
-              kind: "flat",
-            },
-          ],
-        },
-      ],
-    },
-  },
-} as const;
+const deployedContracts = {} as const;
 
 export default deployedContracts;
diff --git a/packages/nextjs/hooks/scaffold-stark/useAutoConnect.ts b/packages/nextjs/hooks/scaffold-stark/useAutoConnect.ts
index 2d80ddc4d..5ed81d7e8 100644
--- a/packages/nextjs/hooks/scaffold-stark/useAutoConnect.ts
+++ b/packages/nextjs/hooks/scaffold-stark/useAutoConnect.ts
@@ -19,5 +19,5 @@ export const useAutoConnect = (): void => {
         connect({ connector });
       }
     }
-  }, [wagmiWalletValue, connectors, connect]);
+  }, []);
 };
diff --git a/packages/nextjs/hooks/scaffold-stark/useScaffoldContractWrite.ts b/packages/nextjs/hooks/scaffold-stark/useScaffoldContractWrite.ts
index eac9c48da..7557e629f 100644
--- a/packages/nextjs/hooks/scaffold-stark/useScaffoldContractWrite.ts
+++ b/packages/nextjs/hooks/scaffold-stark/useScaffoldContractWrite.ts
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { useTargetNetwork } from "./useTargetNetwork";
 import {
   useDeployedContractInfo,
@@ -10,6 +10,8 @@ import {
   ContractName,
   ExtractAbiFunctionNamesScaffold,
   UseScaffoldWriteConfig,
+  getFunctionsByStateMutability,
+  parseFunctionParams,
 } from "~~/utils/scaffold-stark/contract";
 import { useContractWrite, useNetwork } from "@starknet-react/core";
 import { notification } from "~~/utils/scaffold-stark";
@@ -34,13 +36,32 @@ export const useScaffoldContractWrite = <
   const { chain } = useNetwork();
   const writeTx = useTransactor();
   const { targetNetwork } = useTargetNetwork();
+
+  // Memoize the ABI function retrieval
+  const abiFunction = useMemo(
+    () =>
+      getFunctionsByStateMutability(
+        deployedContractData?.abi || [],
+        "external",
+      ).find((fn) => fn.name === functionName),
+    [deployedContractData?.abi, functionName],
+  );
+
+  // Memoize parsing function parameters
+  const parsedParams = useMemo(() => {
+    if (args && abiFunction) {
+      return parseFunctionParams(abiFunction, args as any[]);
+    }
+    return [];
+  }, [args, abiFunction]);
+
   const wagmiContractWrite = useContractWrite({
     calls: deployedContractData
       ? [
           {
             contractAddress: deployedContractData?.address,
             entrypoint: functionName,
-            calldata: args as any[],
+            calldata: parsedParams,
           },
         ]
       : [],
@@ -68,20 +89,18 @@ export const useScaffoldContractWrite = <
       console.error("You are on the wrong network");
       return;
     }
-    const newCalls =
-      newArgs && deployedContractData
-        ? [
-            {
-              contractAddress: deployedContractData.address,
-              entrypoint: functionName,
-              calldata: newArgs as any[],
-            },
-          ]
-        : {
-            contractAddress: deployedContractData.address,
-            entrypoint: functionName,
-            calldata: args as any[],
-          };
+
+    let newParsedParams =
+      newArgs && abiFunction
+        ? parseFunctionParams(abiFunction, newArgs as any[])
+        : parsedParams;
+    const newCalls = [
+      {
+        contractAddress: deployedContractData.address,
+        entrypoint: functionName,
+        calldata: newParsedParams,
+      },
+    ];
 
     if (wagmiContractWrite.writeAsync) {
       try {
diff --git a/packages/nextjs/hooks/scaffold-stark/useTransactor.tsx b/packages/nextjs/hooks/scaffold-stark/useTransactor.tsx
index b7a6de373..85640f5a6 100644
--- a/packages/nextjs/hooks/scaffold-stark/useTransactor.tsx
+++ b/packages/nextjs/hooks/scaffold-stark/useTransactor.tsx
@@ -106,8 +106,6 @@ export const useTransactor = (
         />,
       );
 
-      const transactionReceipt =
-        await publicClient.waitForTransaction(transactionHash);
       notification.remove(notificationId);
 
       notification.success(
diff --git a/packages/nextjs/utils/scaffold-stark/contract.ts b/packages/nextjs/utils/scaffold-stark/contract.ts
index 93953f7f4..b24cf165b 100644
--- a/packages/nextjs/utils/scaffold-stark/contract.ts
+++ b/packages/nextjs/utils/scaffold-stark/contract.ts
@@ -13,6 +13,8 @@ import {
   UseContractWriteProps,
 } from "@starknet-react/core";
 import { Address } from "@starknet-react/chains";
+import { uint256 } from "starknet";
+import { byteArray } from "starknet-dev";
 
 type ConfiguredChainId =
   (typeof scaffoldConfig)["targetNetworks"][0]["network"];
@@ -290,3 +292,51 @@ export type AbiFunctionOutputs<
 > = ExtractAbiFunctionScaffold<TAbi, TFunctionName>["outputs"];
 
 /// export all the types from kanabi
+
+export function getFunctionsByStateMutability(
+  abi: Abi,
+  stateMutability: AbiStateMutability,
+): AbiFunction[] {
+  return abi
+    .reduce((acc, part) => {
+      if (part.type === "function") {
+        acc.push(part);
+      } else if (part.type === "interface" && Array.isArray(part.items)) {
+        part.items.forEach((item) => {
+          if (item.type === "function") {
+            acc.push(item);
+          }
+        });
+      }
+      return acc;
+    }, [] as AbiFunction[])
+    .filter((fn) => {
+      const isWriteableFunction = fn.state_mutability == stateMutability;
+      return isWriteableFunction;
+    });
+}
+
+export function parseParamWithType(paramType: string, param: any) {
+  if (paramType.includes("core::integer::u256")) {
+    return uint256.bnToUint256(param);
+  } else if (paramType.includes("core::byte_array::ByteArray")) {
+    return byteArray.byteArrayFromString(param);
+  } else {
+    return param;
+  }
+}
+
+export function parseFunctionParams(abiFunction: AbiFunction, inputs: any[]) {
+  let parsedInputs: any[] = [];
+
+  //check inputs length
+  if (abiFunction.inputs.length !== inputs.length) {
+    return inputs;
+  }
+
+  inputs.forEach((input, idx) => {
+    const paramType = abiFunction.inputs[idx].type;
+    parsedInputs.push(parseParamWithType(paramType, input));
+  });
+  return parsedInputs;
+}
diff --git a/packages/snfoundry/contracts/Scarb.toml b/packages/snfoundry/contracts/Scarb.toml
index 2c315c769..d851aaaec 100644
--- a/packages/snfoundry/contracts/Scarb.toml
+++ b/packages/snfoundry/contracts/Scarb.toml
@@ -12,3 +12,7 @@ openzeppelin = { git = "https://github.com/OpenZeppelin/cairo-contracts.git", ta
 
 [[target.starknet-contract]]
 casm = true
+
+
+[tool.fmt]
+sort-module-level-items = true
diff --git a/packages/snfoundry/contracts/src/challenge1.cairo b/packages/snfoundry/contracts/src/challenge1.cairo
index 3b367d74e..2675d0b35 100644
--- a/packages/snfoundry/contracts/src/challenge1.cairo
+++ b/packages/snfoundry/contracts/src/challenge1.cairo
@@ -1,39 +1,138 @@
+use starknet::ContractAddress;
+#[starknet::interface]
+pub trait IChallenge1<T> {
+    fn execute(ref self: T);
+    fn stake(ref self: T, amount: u256);
+    fn withdraw(ref self: T);
+    fn balances(self: @T, account: ContractAddress) -> u256;
+    fn completed(self: @T) -> bool;
+    fn deadline(self: @T) -> u64;
+    fn example_external_contract(self: @T) -> ContractAddress;
+    fn open_for_withdraw(self: @T) -> bool;
+    fn threshold(self: @T) -> u256;
+    fn total_balance(self: @T) -> u256;
+    fn time_left(self: @T) -> u64;
+}
+
 #[starknet::contract]
 mod Challenge1 {
-    use openzeppelin::token::erc20::ERC20Component;
-    use starknet::ContractAddress;
-
-    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
-
-    // ERC20Mixin
-    #[abi(embed_v0)]
-    impl ERC20MixinImpl = ERC20Component::ERC20MixinImpl<ContractState>;
-    impl InternalImpl = ERC20Component::InternalImpl<ContractState>;
+    use contracts::exampleExternalContract::{
+        IExampleExternalContractDispatcher, IExampleExternalContractDispatcherTrait
+    };
+    use super::{ContractAddress, IChallenge1};
+    use starknet::{get_block_timestamp, get_caller_address, get_contract_address};
+    use openzeppelin::token::erc20::interface::{IERC20CamelDispatcher, IERC20CamelDispatcherTrait};
 
+    pub const THRESHOLD: u256 = 100000000000000000; // ONE_ETH_IN_WEI: 10 ^ 18;
     #[storage]
     struct Storage {
-        #[substorage(v0)]
-        erc20: ERC20Component::Storage
-    }
-
-    #[event]
-    #[derive(Drop, starknet::Event)]
-    enum Event {
-        #[flat]
-        ERC20Event: ERC20Component::Event
+        token: IERC20CamelDispatcher,
+        balances: LegacyMap<ContractAddress, u256>,
+        deadline: u64,
+        open_for_withdraw: bool,
+        external_contract_address: ContractAddress,
     }
 
-    /// Sets the token `name` and `symbol`.
-    /// Mints `fixed_supply` tokens to `recipient`.
     #[constructor]
     fn constructor(
         ref self: ContractState,
-        name: ByteArray,
-        symbol: ByteArray,
-        fixed_supply: u256,
-        recipient: ContractAddress
+        external_contract_address: ContractAddress,
+        eth_contract_address: ContractAddress
     ) {
-        self.erc20.initializer(name, symbol);
-        self.erc20._mint(recipient, fixed_supply);
+        self.token.write(IERC20CamelDispatcher { contract_address: eth_contract_address });
+        self.deadline.write(get_block_timestamp() + 100); // 45 seconds
+        self.external_contract_address.write(external_contract_address);
+    }
+
+    #[abi(embed_v0)]
+    impl Challenge1Impl of IChallenge1<ContractState> {
+        fn stake(ref self: ContractState, amount: u256) {
+            // ToDo in UI: Sender should approve to transfer the amount to the staker contract
+            self._not_completed();
+            assert(get_block_timestamp() < self.deadline.read(), 'Staking period has ended');
+            let sender = get_caller_address();
+            let sender_current_amount = self.balances.read(sender);
+            self.token.read().transferFrom(sender, get_contract_address(), amount);
+            self.balances.write(sender, sender_current_amount + amount);
+        }
+
+        // Function to execute the transfer or allow withdrawals after the deadline
+        fn execute(ref self: ContractState) {
+            self._not_completed();
+            assert(get_block_timestamp() >= self.deadline.read(), 'Staking period has not ended');
+            let staked_amount = self.token.read().balanceOf(get_contract_address());
+            if (staked_amount >= THRESHOLD) {
+                self._complete_transfer(staked_amount);
+            } else {
+                self.open_for_withdraw.write(true);
+            }
+        }
+
+        fn withdraw(ref self: ContractState) {
+            // Todo in UI: Staker contract should approve to transfer back the sender_amount to the sender
+            assert(self.open_for_withdraw.read(), 'Withdrawal not allowed');
+            let sender = get_caller_address();
+            let sender_amount = self.balances.read(sender);
+            assert(sender_amount > 0, 'No balance to withdraw');
+            self.token.read().transferFrom(get_contract_address(), sender, sender_amount);
+            self.balances.write(sender, 0);
+        }
+
+        fn balances(self: @ContractState, account: ContractAddress) -> u256 {
+            self.balances.read(account)
+        }
+
+        fn total_balance(self: @ContractState) -> u256 {
+            self.balances.read(get_contract_address())
+        }
+
+        fn deadline(self: @ContractState) -> u64 {
+            self.deadline.read()
+        }
+
+        fn threshold(self: @ContractState) -> u256 {
+            THRESHOLD
+        }
+
+        fn open_for_withdraw(self: @ContractState) -> bool {
+            self.open_for_withdraw.read()
+        }
+
+        fn example_external_contract(self: @ContractState) -> ContractAddress {
+            self.external_contract_address.read()
+        }
+
+        fn completed(self: @ContractState) -> bool {
+            let external_contract = IExampleExternalContractDispatcher {
+                contract_address: self.external_contract_address.read()
+            };
+            external_contract.completed()
+        }
+
+        fn time_left(self: @ContractState) -> u64 {
+            let current_time = get_block_timestamp();
+            let deadline = self.deadline.read();
+            if current_time < deadline {
+                deadline - current_time
+            } else {
+                0
+            }
+        }
+    }
+
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        fn _complete_transfer(ref self: ContractState, amount: u256) {
+            let external_contract_address = self.external_contract_address.read();
+            let external_contract_dispatcher = IExampleExternalContractDispatcher {
+                contract_address: external_contract_address
+            };
+            // Todo in UI: Staker contract should approve to transfer the staked_amount to the external contract
+            self.token.read().transfer(external_contract_address, amount);
+            external_contract_dispatcher.complete(amount);
+        }
+        fn _not_completed(ref self: ContractState) {
+            assert(!self.completed(), 'Action already completed');
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/packages/snfoundry/contracts/src/exampleExternalContract.cairo b/packages/snfoundry/contracts/src/exampleExternalContract.cairo
new file mode 100644
index 000000000..edc5b4987
--- /dev/null
+++ b/packages/snfoundry/contracts/src/exampleExternalContract.cairo
@@ -0,0 +1,25 @@
+#[starknet::interface]
+pub trait IExampleExternalContract<T> {
+    fn complete(ref self: T, amount: u256);
+    fn completed(ref self: T) -> bool;
+}
+
+#[starknet::contract]
+mod ExampleExternalContract {
+    #[storage]
+    struct Storage {
+        completed: bool,
+        balance: u256,
+    }
+
+    #[abi(embed_v0)]
+    impl ExampleExternalContractImpl of super::IExampleExternalContract<ContractState> {
+        fn complete(ref self: ContractState, amount: u256) {
+            self.completed.write(true);
+            self.balance.write(self.balance.read() + amount);
+        }
+        fn completed(ref self: ContractState) -> bool {
+            self.completed.read()
+        }
+    }
+}
diff --git a/packages/snfoundry/contracts/src/lib.cairo b/packages/snfoundry/contracts/src/lib.cairo
index 4290cbfd6..5cdce453e 100644
--- a/packages/snfoundry/contracts/src/lib.cairo
+++ b/packages/snfoundry/contracts/src/lib.cairo
@@ -3,8 +3,11 @@ mod simpleStorage;
 mod vote;
 mod challenge0;
 mod challenge1;
-mod challenge2;
+mod presetERC1155;
 mod challenge3;
+mod presetERC20;
+mod exampleExternalContract;
+mod transferETH;
 
 use starknet::ContractAddress;
 
diff --git a/packages/snfoundry/contracts/src/challenge2.cairo b/packages/snfoundry/contracts/src/presetERC1155.cairo
similarity index 70%
rename from packages/snfoundry/contracts/src/challenge2.cairo
rename to packages/snfoundry/contracts/src/presetERC1155.cairo
index 050ae7c83..e67b7fdbc 100644
--- a/packages/snfoundry/contracts/src/challenge2.cairo
+++ b/packages/snfoundry/contracts/src/presetERC1155.cairo
@@ -1,5 +1,6 @@
 #[starknet::contract]
-mod Challenge2 {
+mod PresetERC1155 {
+    use core::num::traits::zero::Zero;
     use openzeppelin::introspection::src5::SRC5Component;
     use openzeppelin::token::erc1155::ERC1155Component;
     use starknet::ContractAddress;
@@ -13,8 +14,7 @@ mod Challenge2 {
     #[abi(embed_v0)]
     impl ERC1155MetadataURIImpl =
         ERC1155Component::ERC1155MetadataURIImpl<ContractState>;
-    #[abi(embed_v0)]
-    impl ERC1155Camel = ERC1155Component::ERC1155CamelImpl<ContractState>;
+
     impl ERC1155InternalImpl = ERC1155Component::InternalImpl<ContractState>;
 
     // SRC5
@@ -47,8 +47,19 @@ mod Challenge2 {
         values: Span<u256>
     ) {
         self.erc1155.initializer(base_uri);
-        self
-            .erc1155
-            .batch_mint_with_acceptance_check(recipient, token_ids, values, array![].span());
+        self.batch_mint(recipient, token_ids, values); //unsafe_batch_mint()
+    }
+
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        fn batch_mint(
+            ref self: ContractState,
+            recipient: ContractAddress,
+            token_ids: Span<u256>,
+            values: Span<u256>
+        ) {
+            assert(recipient.is_non_zero(), ERC1155Component::Errors::INVALID_RECEIVER);
+            self.erc1155.update(Zero::zero(), recipient, token_ids, values);
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/packages/snfoundry/contracts/src/presetERC20.cairo b/packages/snfoundry/contracts/src/presetERC20.cairo
new file mode 100644
index 000000000..cd05528b8
--- /dev/null
+++ b/packages/snfoundry/contracts/src/presetERC20.cairo
@@ -0,0 +1,39 @@
+#[starknet::contract]
+mod PresertERC20 {
+    use openzeppelin::token::erc20::ERC20Component;
+    use starknet::ContractAddress;
+
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+
+    // ERC20Mixin
+    #[abi(embed_v0)]
+    impl ERC20MixinImpl = ERC20Component::ERC20MixinImpl<ContractState>;
+    impl InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event
+    }
+
+    /// Sets the token `name` and `symbol`.
+    /// Mints `fixed_supply` tokens to `recipient`.
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        name: ByteArray,
+        symbol: ByteArray,
+        fixed_supply: u256,
+        recipient: ContractAddress
+    ) {
+        self.erc20.initializer(name, symbol);
+        self.erc20._mint(recipient, fixed_supply);
+    }
+}
diff --git a/packages/snfoundry/contracts/src/transferETH.cairo b/packages/snfoundry/contracts/src/transferETH.cairo
new file mode 100644
index 000000000..4d9539b38
--- /dev/null
+++ b/packages/snfoundry/contracts/src/transferETH.cairo
@@ -0,0 +1,71 @@
+use starknet::ContractAddress;
+#[starknet::interface]
+trait ITransferETH<T> {
+    fn read_balance_contract(self: @T) -> u256;
+    fn read_balance_account(self: @T, account: ContractAddress) -> u256;
+    fn caller_and_contract(self: @T) -> (ContractAddress, ContractAddress);
+    fn transfer_to_contract(ref self: T, amount: u256);
+    fn approve(ref self: T, spender: ContractAddress, amount: u256) -> bool;
+    fn allowance(self: @T, owner: ContractAddress, spender: ContractAddress) -> u256;
+}
+
+#[starknet::contract]
+mod TransferETH {
+    use openzeppelin::token::erc20::interface::{IERC20CamelDispatcher, IERC20CamelDispatcherTrait};
+    use starknet::{get_caller_address, get_contract_address, ContractAddress};
+    #[storage]
+    struct Storage {
+        token: IERC20CamelDispatcher,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState //, external_contract_address: ContractAddress
+    ) {
+        self
+            .token
+            .write(
+                IERC20CamelDispatcher {
+                    contract_address: 0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7
+                        .try_into()
+                        .unwrap()
+                }
+            );
+    }
+
+    #[abi(embed_v0)]
+    impl TransferETHImpl of super::ITransferETH<ContractState> {
+        fn read_balance_contract(self: @ContractState) -> u256 {
+            self.token.read().balanceOf(get_contract_address())
+        }
+        fn read_balance_account(self: @ContractState, account: ContractAddress) -> u256 {
+            self.token.read().balanceOf(account)
+        }
+
+        fn caller_and_contract(self: @ContractState) -> (ContractAddress, ContractAddress) {
+            (get_caller_address(), get_contract_address())
+        }
+
+        fn approve(ref self: ContractState, spender: ContractAddress, amount: u256) -> bool {
+            //self.token.read().approve(spender, amount)
+            let dispatcher = IERC20CamelDispatcher {
+                contract_address: 0x64b48806902a367c8598f4f95c305e8c1a1acba5f082d294a43793113115691
+                    .try_into()
+                    .unwrap()
+            };
+            dispatcher.approve(spender, amount)
+        }
+
+        fn allowance(
+            self: @ContractState, owner: ContractAddress, spender: ContractAddress
+        ) -> u256 {
+            self.token.read().allowance(owner, spender)
+        }
+
+        fn transfer_to_contract(ref self: ContractState, amount: u256) {
+            let caller = 0x64b48806902a367c8598f4f95c305e8c1a1acba5f082d294a43793113115691
+                .try_into()
+                .unwrap();
+            self.token.read().transferFrom(caller, get_contract_address(), amount);
+        }
+    }
+}
diff --git a/packages/snfoundry/scripts_js/deploy.js b/packages/snfoundry/scripts_js/deploy.js
index 384be09f5..77a204d39 100644
--- a/packages/snfoundry/scripts_js/deploy.js
+++ b/packages/snfoundry/scripts_js/deploy.js
@@ -13,35 +13,45 @@ const deployScript = async () => {
   //   "SimpleStorage"
   // );
 
-  await deployContract(
-    {
-      owner:
-        "0x4b3f4ba8c00a02b66142a4b1dd41a4dfab4f92650922a3280977b0f03c75ee1",
-    }, // last account in devnet accounts
-    "Challenge0"
-  );
-
   // await deployContract(
   //   {
-  //     name: 1,
-  //     symbol: 2,
+  //     owner:
+  //       "0x4b3f4ba8c00a02b66142a4b1dd41a4dfab4f92650922a3280977b0f03c75ee1",
+  //   }, // last account in devnet accounts
+  //   "Challenge0"
+  // );
+
+  const values = {
+      classHash: helloStarknetClassHash,
+      abi: helloStarknetAbi,
+      address: ContractAddress,
+    } = await deployContract(null, "ExampleExternalContract");
+  await deployContract({ external_contract_address: values.address, eth_contract_address: "0x49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7" }
+    , "Challenge1");
+  
+
+  //await deployContract(null, "TransferETH");
+  //   await deployContract(
+  //   {
+  //     name: "Marquis",
+  //     symbol: "MRQ",
   //     fixed_supply: 10,
   //     recipient:
   //       "0x06072Bb27d275a0bC1deBf1753649b8721CF845B681A48443Ac46baF45769f8E",
   //   },
-  //   "Challenge1"
+  //   "PresetERC20"
   // );
 
-  // await deployContract(
-  //   {
-  //     base_uri: CallData.byteArrayFromString("https://example.com/"),
-  //     // recipient:
-  //     //   "0x06072Bb27d275a0bC1deBf1753649b8721CF845B681A48443Ac46baF45769f8E",
-  //     // token_ids: 2,
-  //     // values: 100,
-  //   },
-  //   "Challenge2"
-  // );
+  await deployContract(
+    {
+      base_uri: "https://example.com/",
+      recipient:
+        "0x64b48806902a367c8598f4f95c305e8c1a1acba5f082d294a43793113115691",
+      token_ids: [2],
+      values: [100],
+    },
+    "PresetERC1155"
+  );
 
   // await deployContract(
   //   {