Add script to extract methods (#475)

Signed-off-by: Alberto Molina <[email protected]>
Signed-off-by: Miguel_LZPF <[email protected]>
Co-authored-by: Miguel_LZPF <[email protected]>

Author: AlbertoMolinaIoBuilders

.gitignore

@@ -132,3 +132,6 @@ asset-tokenization-studio.iml
 
 # IntelliJ Idea
 /.idea/
+
+# Extracted methods from contracts
+contracts/extracted-methods.txt

contracts/.gitignore

@@ -28,6 +28,7 @@ node_modules
 coverage
 coverage.json
 gas-report.txt
+extracted-methods.txt
 
 #Hardhat files
 cache

contracts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/asset-tokenization-contracts",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "main": "./build/typechain-types/index.js",
   "module": "./build/typechain-types/index.js",
   "files": [
@@ -87,7 +87,8 @@
     "slither": "npm run slither:summary && npm run slither:storageLayout && npm run slither:inheritance && npm run slither:analysis",
     "prettierCheck": "prettier --check",
     "prepack": "npm run compile:force",
-    "doc": "npx hardhat dodoc"
+    "doc": "npx hardhat dodoc",
+    "extractMethods": "npx -y tsx scripts/extractMethods.ts"
   },
   "keywords": [],
   "author": "",

contracts/scripts/constants.ts

@@ -221,6 +221,11 @@ export const EQUITY_CONFIG_ID =
 export const BOND_CONFIG_ID =
     '0x0000000000000000000000000000000000000000000000000000000000000002'
 
+// Extract Methods // TODO: Use OUTPUT_FILE as input parameter (CONTRACTS_DIR?)
+export const CONTRACTS_DIR = 'contracts'
+export const OUTPUT_FILE = 'extracted-methods.txt'
+export const REGEX_SELECTOR = /function\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)/g
+
 // * Roles
 export const DEFAULT_ADMIN_ROLE =
     '0x0000000000000000000000000000000000000000000000000000000000000000'

contracts/scripts/extractMethods.ts

@@ -0,0 +1,142 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from 'fs'
+import { join, extname } from 'path'
+import { CONTRACTS_DIR, OUTPUT_FILE, REGEX_SELECTOR } from '@scripts'
+
+function getSolidityFiles(dir: string): string[] {
+    const entries = readdirSync(dir)
+    let files: string[] = []
+
+    for (const entry of entries) {
+        const fullPath = join(dir, entry)
+        const stats = statSync(fullPath)
+
+        if (stats.isDirectory()) {
+            files = files.concat(getSolidityFiles(fullPath))
+        } else if (extname(entry) === '.sol') {
+            files.push(fullPath)
+        }
+    }
+
+    return files
+}
+
+function extractFunctions(content: string) {
+    const regex =
+        /function\s+([a-zA-Z0-9_]+)\s*\(([^)]*)\)\s+(public|external)((?:\s+\w+)*)\s*(returns\s*\(.*?\))?/g
+
+    const normalFns = new Set<string>()
+    const viewFns = new Set<string>()
+    const pureFns = new Set<string>()
+
+    const normalFnsSelector = new Set<string>()
+    const viewFnsSelector = new Set<string>()
+    const pureFnsSelector = new Set<string>()
+
+    let match: RegExpExecArray | null
+
+    while ((match = regex.exec(content)) !== null) {
+        const [
+            fullMatch,
+            name,
+            args,
+            visibility,
+            modifiers = '',
+            returns = '',
+        ] = match
+
+        const normalized =
+            `function ${name}(${args.trim()}) ${visibility}${modifiers}${returns ? ' ' + returns.trim() : ''}`
+                .replace(/\s+/g, ' ')
+                .trim()
+
+        const lower = modifiers.toLowerCase()
+        const selector = REGEX_SELECTOR.exec(fullMatch)
+
+        if (selector === null) continue
+
+        const [fullMatchSelector] = selector
+
+        if (lower.includes('pure')) {
+            if (pureFnsSelector.has(fullMatchSelector)) continue
+            pureFnsSelector.add(fullMatchSelector)
+            pureFns.add(normalized)
+        } else if (lower.includes('view')) {
+            if (viewFnsSelector.has(fullMatchSelector)) continue
+            viewFnsSelector.add(fullMatchSelector)
+            viewFns.add(normalized)
+        } else {
+            if (normalFnsSelector.has(fullMatchSelector)) continue
+            normalFnsSelector.add(fullMatchSelector)
+            normalFns.add(normalized)
+        }
+    }
+
+    return { normalFns, viewFns, pureFns }
+}
+
+export function main() {
+    const files = getSolidityFiles(CONTRACTS_DIR)
+
+    const normalSet = new Set<string>()
+    const viewSet = new Set<string>()
+    const pureSet = new Set<string>()
+
+    const normalSetSelectors = new Set<string>()
+    const viewSetSelectors = new Set<string>()
+    const pureSetSelectors = new Set<string>()
+
+    for (const file of files) {
+        const content = readFileSync(file, 'utf8')
+        const { normalFns, viewFns, pureFns } = extractFunctions(content)
+
+        normalFns.forEach((fn) => {
+            const selector = REGEX_SELECTOR.exec(fn)
+
+            if (selector === null) return
+
+            const [fullMatchSelector] = selector
+
+            if (normalSetSelectors.has(fullMatchSelector)) return
+            normalSetSelectors.add(fullMatchSelector)
+            normalSet.add(fn)
+        })
+
+        viewFns.forEach((fn) => {
+            const selector = REGEX_SELECTOR.exec(fn)
+
+            if (selector === null) return
+
+            const [fullMatchSelector] = selector
+
+            if (viewSetSelectors.has(fullMatchSelector)) return
+            viewSetSelectors.add(fullMatchSelector)
+            viewSet.add(fn)
+        })
+
+        pureFns.forEach((fn) => {
+            const selector = REGEX_SELECTOR.exec(fn)
+
+            if (selector === null) return
+
+            const [fullMatchSelector] = selector
+
+            if (pureSetSelectors.has(fullMatchSelector)) return
+            pureSetSelectors.add(fullMatchSelector)
+            pureSet.add(fn)
+        })
+    }
+
+    const output = [
+        '====== ✅ Non-view/pure external/public methods ======\n',
+        ...Array.from(normalSet).sort(),
+        '\n====== 👁️ View functions ======\n',
+        ...Array.from(viewSet).sort(),
+        '\n====== 🧪 Pure functions ======\n',
+        ...Array.from(pureSet).sort(),
+    ]
+
+    writeFileSync(OUTPUT_FILE, output.join('\n'), 'utf8')
+    console.log(`✅ Methods extracted to ${OUTPUT_FILE}`)
+}
+
+main()

contracts/scripts/index.ts

@@ -278,3 +278,6 @@ export * from './resolverDiamondCut'
 
 // * Factory
 export * from './factory'
+
+// * Extract methods
+export * from './extractMethods'

contracts/tasks/utils.ts

@@ -322,3 +322,23 @@ task('createVC', 'Prints the VC for a given issuer and holder')
         const vcString = JSON.stringify(vc)
         console.log(`The VC for the holder is: '${vcString}'`)
     })
+
+task(
+    'extract-methods',
+    'Extracts all public and external function signatures from contracts'
+).setAction(async () => {
+    try {
+        const { main } = await import('@scripts')
+        // Redirect output so it is not logged
+        const originalConsoleLog = console.log
+        console.log = () => {}
+        try {
+            main() // ! Called when importing the script directly
+        } finally {
+            console.log = originalConsoleLog
+        }
+    } catch (error) {
+        console.error('❌ An error occurred while extracting methods:')
+        console.error(error)
+    }
+})

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-asset-tokenization",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "license": "Apache-2.0",
   "description": "asset tokenization",
   "scripts": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/asset-tokenization-sdk",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "description": "Testing to MASTER",
   "main": "./build/cjs/src/index.js",
   "module": "./build/esm/src/index.js",