Load foundry compiled projects

eslint.config.mjs

@@ -6,4 +6,4 @@ import tseslint from 'typescript-eslint';
 export default tseslint.config(
   eslint.configs.recommended,
   tseslint.configs.recommended,
-);
+);

package.json

@@ -39,7 +39,9 @@
     "onCommand:ethcode.contract.call",
     "onCommand:ethcode.transaction.gas.set",
     "onCommand:ethcode.transaction.gas.prices",
-    "onCommand:ethcode.rental.create"
+    "onCommand:ethcode.rental.create",
+    "onCommand:ethcode.foundry.load",
+    "onCommand:ethcode.hardhat.load"
   ],
   "main": "./extension/build/extension.js",
   "extensionDependencies": [
@@ -157,6 +159,14 @@
       {
         "command": "ethcode.createERC4907Contract",
         "title": "Ethcode: Create ERC4907 Contract"
+      },
+      {
+        "command": "ethcode.foundry.load",
+        "title": "Ethcode: Load Foundry Contracts"
+      },
+      {
+        "command": "ethcode.hardhat.load",
+        "title": "Ethcode: Load Hardhat Contracts"
       }
     ],
     "keybindings": [

src/extension.ts

@@ -18,13 +18,18 @@ import {
 import {
   createERC4907Contract,
   parseBatchCompiledJSON,
+  parseFoundryCompiledJSON,
+  parseHardhatCompiledJSON,
   parseCompiledJSONPayload,
-  selectContract
+  selectContract,
+  parseFoundryConfig
 } from './utils'
+import { isFoundryProject, isHardhatProject } from './utils/functions'
 import { provider, status, wallet, contract } from './api'
 import { events } from './api/events'
 import { event } from './api/api'
 import { type API } from './types'
+import * as toml from 'toml'
 
 export async function activate (context: ExtensionContext): Promise<API | undefined> {
   const disposables = [
@@ -154,6 +159,24 @@ export async function activate (context: ExtensionContext): Promise<API | undefi
     // Activate
     commands.registerCommand('ethcode.activate', async () => {
       logger.success('Welcome to Ethcode!')
+    }),
+
+    // Load Foundry contracts
+    commands.registerCommand('ethcode.foundry.load', async () => {
+      try {
+        await parseFoundryCompiledJSON(context)
+      } catch (error) {
+        logger.error(`Error loading Foundry contracts: ${error}`)
+      }
+    }),
+
+    // Load Hardhat contracts
+    commands.registerCommand('ethcode.hardhat.load', async () => {
+      try {
+        await parseHardhatCompiledJSON(context)
+      } catch (error) {
+        logger.error(`Error loading Hardhat contracts: ${error}`)
+      }
     })
   ]
 
@@ -235,25 +258,61 @@ export async function activate (context: ExtensionContext): Promise<API | undefi
     await window.showErrorMessage('No folder selected please open one.')
     return
   }
-  const watcher = workspace.createFileSystemWatcher(
-    new RelativePattern(path_[0].uri.fsPath, '{artifacts, build, out, cache}/**/*.json')
-  )
 
-  watcher.onDidCreate(async (uri) => {
+  // Create dynamic file watcher based on project type
+  const createDynamicWatcher = async () => {
+    const watchPatterns: string[] = []
+
+    try {
+      // Check for Foundry project using centralized parser
+      const foundryConfig = await parseFoundryConfig()
+      if (foundryConfig) {
+        const { outDir } = foundryConfig
+        watchPatterns.push(`${outDir}/**/*.json`)
+        logger.log(`Foundry project detected, watching: ${outDir}/**/*.json`)
+      }
+
+      // Check for Hardhat project
+      if (isHardhatProject(path_[0].uri.fsPath)) {
+        watchPatterns.push('artifacts/**/*.json')
+        logger.log('Hardhat project detected, watching: artifacts/**/*.json')
+      }
+
+      // Fallback patterns for other frameworks
+      if (watchPatterns.length === 0) {
+        watchPatterns.push('{artifacts, build, out, cache, out-*/**/*.json}')
+        logger.log('No specific framework detected, using fallback patterns')
+      }
+
+    } catch (error) {
+      logger.error(`Error setting up file watcher: ${error}`)
+      // Fallback to original pattern
+      watchPatterns.push('{artifacts, build, out, cache, out-*/**/*.json}')
+    }
+
+    // Create watcher with dynamic patterns
+    return workspace.createFileSystemWatcher(
+      new RelativePattern(path_[0].uri.fsPath, watchPatterns.join(','))
+    )
+  }
+
+  const watcher = await createDynamicWatcher()
+
+  watcher.onDidCreate(async (uri: any) => {
     await parseBatchCompiledJSON(context)
     const contracts = context.workspaceState.get('contracts') as string[]
     if (contracts === undefined || contracts.length === 0) return []
     event.contracts.fire(Object.keys(contracts))
   })
 
-  watcher.onDidChange(async (uri) => {
+  watcher.onDidChange(async (uri: any) => {
     await parseBatchCompiledJSON(context)
     const contracts = context.workspaceState.get('contracts') as string[]
     if (contracts === undefined || contracts.length === 0) return []
     event.contracts.fire(Object.keys(contracts))
   })
 
-  watcher.onDidDelete(async (uri) => {
+  watcher.onDidDelete(async (uri: any) => {
     const contracts = context.workspaceState.get('contracts') as string[]
     if (contracts === undefined || contracts.length === 0) return []
     event.contracts.fire(Object.keys(contracts))

src/types/output.ts

@@ -1,4 +1,5 @@
 import { type AbiItem } from './types'
+import { logger } from '../lib'
 
 export interface HardHatCompiledOutput {
   contractName: string
@@ -18,6 +19,40 @@ export interface RemixCompiledOutput {
   abi: readonly AbiItem[]
 }
 
+export interface FoundryCompiledOutput {
+  abi: readonly AbiItem[]
+  bytecode: {
+    object: string
+    sourceMap: string
+    linkReferences: Record<string, Record<string, Array<{ start: number, length: number }>>>
+  }
+  deployedBytecode: {
+    object: string
+    sourceMap: string
+    linkReferences: Record<string, Record<string, Array<{ start: number, length: number }>>>
+  }
+  metadata: string
+  ir: string
+  irOptimized: string
+  storageLayout: any
+  evm: {
+    assembly: string
+    bytecode: {
+      object: string
+      sourceMap: string
+      linkReferences: Record<string, Record<string, Array<{ start: number, length: number }>>>
+    }
+    deployedBytecode: {
+      object: string
+      sourceMap: string
+      linkReferences: Record<string, Record<string, Array<{ start: number, length: number }>>>
+    }
+    methodIdentifiers: Record<string, string>
+    gasEstimates: any
+  }
+  ewasm: any
+}
+
 interface GasEstimate {
   confidence: number
   maxFeePerGas: number
@@ -34,17 +69,22 @@ export interface GasEstimateOutput {
 export interface CompiledJSONOutput {
   name?: string // contract name
   path?: string // local path of the contract
-  contractType: number // 0: null, 1: hardhat output, 2: remix output
+  contractType: number // 0: null, 1: hardhat output, 2: remix output, 3: foundry output
   hardhatOutput?: HardHatCompiledOutput
   remixOutput?: RemixCompiledOutput
+  foundryOutput?: FoundryCompiledOutput
 }
 
 export const getAbi = (output: CompiledJSONOutput): any => {
   if (output.contractType === 0) return []
 
   if (output.contractType === 1) return output.hardhatOutput?.abi
 
-  return output.remixOutput?.abi
+  if (output.contractType === 2) return output.remixOutput?.abi
+
+  if (output.contractType === 3) return output.foundryOutput?.abi
+
+  return []
 }
 
 export const getByteCode = (
@@ -59,21 +99,43 @@ export const getByteCode = (
     return bytecode.startsWith('0x') ? bytecode : `0x${bytecode}`
   }
 
-  // Remix format
-  const bytecode = output.remixOutput?.data.bytecode.object
-  if (!bytecode) {
-    console.log('Remix bytecode is undefined or null')
-    return undefined
+  if (output.contractType === 2) {
+    // Remix format
+    const bytecode = output.remixOutput?.data.bytecode.object
+    if (!bytecode) {
+      logger.log('Remix bytecode is undefined or null')
+      return undefined
+    }
+
+    logger.log(`Original Remix bytecode: ${bytecode.substring(0, 20)}...`)
+    logger.log(`Bytecode starts with 0x: ${bytecode.startsWith('0x')}`)
+
+    // Ensure 0x prefix for Remix format
+    const result = bytecode.startsWith('0x') ? bytecode : `0x${bytecode}`
+    logger.log(`Final bytecode: ${result.substring(0, 20)}...`)
+
+    return result
   }
-
-  console.log(`Original Remix bytecode: ${bytecode.substring(0, 20)}...`)
-  console.log(`Bytecode starts with 0x: ${bytecode.startsWith('0x')}`)
-
-  // Ensure 0x prefix for Remix format
-  const result = bytecode.startsWith('0x') ? bytecode : `0x${bytecode}`
-  console.log(`Final bytecode: ${result.substring(0, 20)}...`)
-
-  return result
+
+  if (output.contractType === 3) {
+    // Foundry format
+    const bytecode = output.foundryOutput?.bytecode.object
+    if (!bytecode) {
+      logger.log('Foundry bytecode is undefined or null')
+      return undefined
+    }
+
+    logger.log(`Original Foundry bytecode: ${bytecode.substring(0, 20)}...`)
+    logger.log(`Bytecode starts with 0x: ${bytecode.startsWith('0x')}`)
+
+    // Ensure 0x prefix for Foundry format
+    const result = bytecode.startsWith('0x') ? bytecode : `0x${bytecode}`
+    logger.log(`Final Foundry bytecode: ${result.substring(0, 20)}...`)
+
+    return result
+  }
+
+  return undefined
 }
 
 export interface BytecodeObject {