sol2uml 2.5.22 → 2.5.24

package/README.md

@@ -1,7 +1,7 @@
 # Solidity 2 UML
 
 [![npm (tag)](https://img.shields.io/npm/v/sol2uml)](https://www.npmjs.com/package/sol2uml)
-[![Twitter Follow](https://img.shields.io/twitter/follow/naddison?style=social)](https://twitter.com/naddison)
+[![X Follow](https://img.shields.io/twitter/follow/naddison?style=social)](https://x.com/naddison)
 
 A visualisation tool for [Solidity](https://solidity.readthedocs.io/) contracts featuring:
 1. [Unified Modeling Language (UML)](https://en.wikipedia.org/wiki/Unified_Modeling_Language) [class diagram](https://en.wikipedia.org/wiki/Class_diagram) generator for Solidity contracts.
@@ -22,7 +22,7 @@ See an explanation of how storage diagrams work with lots of examples [here](./e
 # Install
 
 The following installation assumes [Node.js](https://nodejs.org/en/download/) has already been installed which comes with [Node Package Manager (NPM)](https://www.npmjs.com/).
-`sol2uml` works with node 14 or above.
+`sol2uml` works with node 20 or above.
 
 To install globally so you can run `sol2uml` from anywhere
 
@@ -58,7 +58,7 @@ Options:
   -o, --outputFileName <value>                    output file name
   -i, --ignoreFilesOrFolders <names>              comma-separated list of files or folders to ignore
   -n, --network <network>                         Name or chain id of the blockchain explorer. A name like `ethereum` or `base` will map to a chain id, eg 1 or 8453. Alternatively, use an integer of the chain id. Supported names: ethereum, sepolia, holesky, hoodi, arbitrum, optimism, polygon, avalanche, base, bsc, crono, fantom, sonic, gnosis, moonbeam, celo, scroll, linea, blast, berachain, zksync (default: "ethereum", env: ETH_NETWORK)
-  -e, --explorerUrl <url>                         Override the `network` option with a custom blockchain explorer API URL. eg Polygon Mumbai testnet https://api-testnet.polygonscan.com/api (env: EXPLORER_URL)
+  -e, --explorerUrl <url>                         Override the `network` option with a custom blockchain explorer API URL. eg Polygon Amoy testnet https://api-amoy.polygonscan.com/api (env: EXPLORER_URL)
   -k, --apiKey <key>                              Blockchain explorer API key. (env: SCAN_API_KEY)
   -bc, --backColor <color>                        Canvas background color. "none" will use a transparent canvas. (default: "white")
   -sc, --shapeColor <color>                       Basic drawing color for graphics, not text (default: "black")
@@ -225,10 +225,10 @@ To generate a diagram of EtherDelta's contract from the verified source code on
 sol2uml class 0x8d12A197cB00D4747a1fe03395095ce2A5CC6819
 ```
 
-To generate a diagram of EtherDelta's contract from the verified source code on [Etherscan Ropsten](https://ropsten.etherscan.io/address/0xa19833bd291b66aB0E17b9C6d46D2Ec5fEC15190#code). The output will be a svg file `0xa19833bd291b66aB0E17b9C6d46D2Ec5fEC15190.svg` in the working folder.
+To generate a diagram of a contract on [Hoodi](https://hoodi.etherscan.io/address/0x8d62350d6DfC8A928bBF5efD2e44c66034Afa7C6#code). The output will be a svg file `0x8d62350d6DfC8A928bBF5efD2e44c66034Afa7C6.svg` in the working folder.
 
 ```bash
-sol2uml class 0xa19833bd291b66aB0E17b9C6d46D2Ec5fEC15190 -n ropsten
+sol2uml class 0x8d62350d6DfC8A928bBF5efD2e44c66034Afa7C6 -n hoodi
 ```
 
 To generate all Solidity files under some root folder and output the svg file to a specific location
@@ -354,7 +354,7 @@ npm run clean
 npm run package-lock
 npm run build
 npm run permit
-# make tx2uml globally available for local testing
+# make sol2uml globally available for local testing
 npm link
 # check all the files are included in the npm package
 npm pack --dry-run

package/lib/SlotValueCache.d.ts

@@ -1,4 +1,4 @@
-import { BigNumberish } from '@ethersproject/bignumber';
+import { BigNumberish } from 'ethers';
 /**
  * Singleton that caches a mapping of slot keys to values.
  * Assumes all data is read from the same block and contract

package/lib/SlotValueCache.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlotValueCache = void 0;
-const bignumber_1 = require("@ethersproject/bignumber");
+const ethers_1 = require("ethers");
 const debug = require('debug')('sol2uml');
 /**
  * Singleton that caches a mapping of slot keys to values.
@@ -16,8 +16,8 @@ class SlotValueCache {
     static readSlotValues(slotKeys) {
         const cachedValues = [];
         const missingKeys = [];
-        slotKeys.forEach((slotKey, i) => {
-            const key = bignumber_1.BigNumber.from(slotKey).toHexString();
+        slotKeys.forEach((slotKey) => {
+            const key = (0, ethers_1.toBeHex)(BigInt(slotKey));
             if (this.slotCache[key]) {
                 cachedValues.push(this.slotCache[key]);
             }
@@ -46,7 +46,7 @@ class SlotValueCache {
             }
         });
         return slotKeys.map((slotKey) => {
-            const key = bignumber_1.BigNumber.from(slotKey).toHexString();
+            const key = (0, ethers_1.toBeHex)(BigInt(slotKey));
             // it should find the slot value in the cache. if not it'll return undefined
             return this.slotCache[key];
         });

package/lib/associations.d.ts

@@ -1,2 +1,2 @@
 import { Association, UmlClass } from './umlClass';
-export declare const findAssociatedClass: (association: Association, sourceUmlClass: UmlClass, umlClasses: readonly UmlClass[], searchedAbsolutePaths?: string[]) => UmlClass | undefined;
+export declare const findAssociatedClass: (association: Association, sourceUmlClass: UmlClass, umlClasses: readonly UmlClass[]) => UmlClass | undefined;

package/lib/associations.js

@@ -2,34 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findAssociatedClass = void 0;
 // Find the UML class linked to the association
-const findAssociatedClass = (association, sourceUmlClass, umlClasses, searchedAbsolutePaths = []) => {
-    const umlClass = umlClasses.find((targetUmlClass) => {
-        const targetParentClass = association.parentUmlClassName &&
-            targetUmlClass.parentId !== undefined
-            ? umlClasses[targetUmlClass.parentId]
-            : undefined;
-        return isAssociated(association, sourceUmlClass, targetUmlClass, targetParentClass);
-    });
-    // If a link was found
-    if (umlClass)
-        return umlClass;
-    // // Could not find association so now need to recursively look at imports of imports
-    // // add to already recursively processed files to avoid getting stuck in circular imports
-    // searchedAbsolutePaths.push(sourceUmlClass.absolutePath)
-    // const importedType = findChainedImport(
-    //     association,
-    //     sourceUmlClass,
-    //     umlClasses,
-    //     searchedAbsolutePaths,
-    // )
-    // if (importedType) return importedType
-    // // Still could not find association so now need to recursively look for inherited types
-    // const inheritedType = findInheritedType(
-    //     association,
-    //     sourceUmlClass,
-    //     umlClasses,
-    // )
-    // if (inheritedType) return inheritedType
+const findAssociatedClass = (association, sourceUmlClass, umlClasses) => {
+    // Phase 1: Iterative BFS through import chain, trying direct match at each level
+    const { result, visitedSources } = _findViaImportChain(association, sourceUmlClass, umlClasses);
+    if (result)
+        return result;
+    // Phase 2: Try inherited types for each source visited during import chain traversal
+    const visitedClassIds = new Set();
+    for (const source of visitedSources) {
+        const inherited = _findInheritedType(association, source, umlClasses, visitedClassIds);
+        if (inherited)
+            return inherited;
+    }
     return undefined;
 };
 exports.findAssociatedClass = findAssociatedClass;
@@ -83,15 +67,91 @@ const isAssociated = (association, sourceUmlClass, targetUmlClass, targetParentU
                     importedClass.alias &&
                     importedClass.className === targetUmlClass.name))));
 };
-const findInheritedType = (association, sourceUmlClass, umlClasses) => {
-    // Get all realized associations.
+// Try to find a direct match for the association from the given source class
+const _tryDirectMatch = (association, sourceUmlClass, umlClasses) => {
+    return umlClasses.find((targetUmlClass) => {
+        const targetParentClass = association.parentUmlClassName &&
+            targetUmlClass.parentId !== undefined
+            ? umlClasses[targetUmlClass.parentId]
+            : undefined;
+        return isAssociated(association, sourceUmlClass, targetUmlClass, targetParentClass);
+    });
+};
+// Iterative BFS through import chain, trying direct match at each level.
+// Returns the matched class (if found) and the list of source classes visited.
+const _findViaImportChain = (association, sourceUmlClass, umlClasses) => {
+    const searched = new Set();
+    const visitedSources = [];
+    const visitedPaths = new Set();
+    const queue = [
+        {
+            source: sourceUmlClass,
+            targetName: association.targetUmlClassName,
+        },
+    ];
+    while (queue.length > 0) {
+        const { source, targetName } = queue.shift();
+        const key = `${source.absolutePath}::${targetName}`;
+        if (searched.has(key))
+            continue;
+        searched.add(key);
+        // Track unique visited sources for phase 2 inherited type lookup
+        if (!visitedPaths.has(source.absolutePath)) {
+            visitedPaths.add(source.absolutePath);
+            visitedSources.push(source);
+        }
+        // Build association with potentially de-aliased target name
+        const currentAssoc = {
+            ...association,
+            targetUmlClassName: targetName,
+        };
+        // Try direct match from this source
+        const match = _tryDirectMatch(currentAssoc, source, umlClasses);
+        if (match)
+            return { result: match, visitedSources };
+        // Get imports that could lead to the target
+        const imports = source.imports.filter((i) => i.classNames.length === 0 ||
+            i.classNames.some((cn) => (targetName === cn.className && !cn.alias) ||
+                targetName === cn.alias));
+        for (const importDetail of imports) {
+            const importedClass = umlClasses.find((c) => c.absolutePath === importDetail.absolutePath);
+            if (!importedClass)
+                continue;
+            // Queue with current target name to continue the chain
+            const origKey = `${importedClass.absolutePath}::${targetName}`;
+            if (!searched.has(origKey)) {
+                queue.push({ source: importedClass, targetName });
+            }
+            // Queue with de-aliased names for aliased imports
+            for (const cn of importDetail.classNames) {
+                if (cn.alias && targetName === cn.alias) {
+                    const deAliasedKey = `${importedClass.absolutePath}::${cn.className}`;
+                    if (!searched.has(deAliasedKey)) {
+                        queue.push({
+                            source: importedClass,
+                            targetName: cn.className,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { visitedSources };
+};
+// Walk the inheritance chain to find types (structs, enums) defined on parent contracts.
+// Uses visitedClassIds to prevent re-processing in diamond inheritance hierarchies.
+const _findInheritedType = (association, sourceUmlClass, umlClasses, visitedClassIds) => {
+    if (visitedClassIds.has(sourceUmlClass.id))
+        return undefined;
+    visitedClassIds.add(sourceUmlClass.id);
     const parentAssociations = sourceUmlClass.getParentContracts();
-    // For each parent association
     for (const parentAssociation of parentAssociations) {
-        const parent = (0, exports.findAssociatedClass)(parentAssociation, sourceUmlClass, umlClasses);
+        // Resolve the parent class using import chain only (no inherited types)
+        // to avoid mutual recursion between findAssociatedClass and _findInheritedType
+        const { result: parent } = _findViaImportChain(parentAssociation, sourceUmlClass, umlClasses);
         if (!parent)
             continue;
-        // For each struct on the parent
+        // Check parent's structs for the target type
         for (const structId of parent.structs) {
             const structUmlClass = umlClasses.find((c) => c.id === structId);
             if (!structUmlClass)
@@ -100,7 +160,7 @@ const findInheritedType = (association, sourceUmlClass, umlClasses) => {
                 return structUmlClass;
             }
         }
-        // For each enum on the parent
+        // Check parent's enums for the target type
         for (const enumId of parent.enums) {
             const enumUmlClass = umlClasses.find((c) => c.id === enumId);
             if (!enumUmlClass)
@@ -109,69 +169,11 @@ const findInheritedType = (association, sourceUmlClass, umlClasses) => {
                 return enumUmlClass;
             }
         }
-        // Recursively look for inherited types
-        const targetClass = findInheritedType(association, parent, umlClasses);
+        // Recursively check parent's parents
+        const targetClass = _findInheritedType(association, parent, umlClasses, visitedClassIds);
         if (targetClass)
             return targetClass;
     }
     return undefined;
 };
-// const findChainedImport = (
-//     association: Association,
-//     sourceUmlClass: UmlClass,
-//     umlClasses: readonly UmlClass[],
-//     searchedRelativePaths: string[],
-// ): UmlClass | undefined => {
-//     // Get all valid imports. That is, imports that do not explicitly import contracts or interfaces
-//     // or explicitly import the source class
-//     const imports = sourceUmlClass.imports.filter(
-//         (i) =>
-//             i.classNames.length === 0 ||
-//             i.classNames.some(
-//                 (cn) =>
-//                     (association.targetUmlClassName === cn.className &&
-//                         !cn.alias) ||
-//                     association.targetUmlClassName === cn.alias,
-//             ),
-//     )
-//     // For each import
-//     for (const importDetail of imports) {
-//         // Find a class with the same absolute path as the import so we can get the new imports
-//         const newSourceUmlClass = umlClasses.find(
-//             (c) => c.absolutePath === importDetail.absolutePath,
-//         )
-//         if (!newSourceUmlClass) {
-//             // Could not find a class in the import file so just move onto the next loop
-//             continue
-//         }
-//         // Avoid circular imports
-//         if (searchedRelativePaths.includes(newSourceUmlClass.absolutePath)) {
-//             // Have already recursively looked for imports of imports in this file
-//             continue
-//         }
-//
-//         // find class linked to the association without aliased imports
-//         const umlClass = findAssociatedClass(
-//             association,
-//             newSourceUmlClass,
-//             umlClasses,
-//             searchedRelativePaths,
-//         )
-//         if (umlClass) return umlClass
-//
-//         // find all aliased imports
-//         const aliasedImports = importDetail.classNames.filter((cn) => cn.alias)
-//         // For each aliased import
-//         for (const aliasedImport of aliasedImports) {
-//             const umlClass = findAssociatedClass(
-//                 { ...association, targetUmlClassName: aliasedImport.className },
-//                 newSourceUmlClass,
-//                 umlClasses,
-//                 searchedRelativePaths,
-//             )
-//             if (umlClass) return umlClass
-//         }
-//     }
-//     return undefined
-// }
 //# sourceMappingURL=associations.js.map

package/lib/converterAST2Classes.js

@@ -55,7 +55,7 @@ function convertAST2UmlClasses(node, relativePath, remappings, filesystem = fals
     if (node.type === 'SourceUnit') {
         node.children.forEach((childNode) => {
             if (childNode.type === 'ContractDefinition') {
-                let umlClass = new umlClass_1.UmlClass({
+                const umlClass = new umlClass_1.UmlClass({
                     name: childNode.name,
                     absolutePath: filesystem
                         ? path.resolve(relativePath) // resolve the absolute path
@@ -68,7 +68,7 @@ function convertAST2UmlClasses(node, relativePath, remappings, filesystem = fals
             }
             else if (childNode.type === 'StructDefinition') {
                 debug(`Adding file level struct ${childNode.name}`);
-                let umlClass = new umlClass_1.UmlClass({
+                const umlClass = new umlClass_1.UmlClass({
                     name: childNode.name,
                     stereotype: umlClass_1.ClassStereotype.Struct,
                     absolutePath: filesystem
@@ -82,7 +82,7 @@ function convertAST2UmlClasses(node, relativePath, remappings, filesystem = fals
             }
             else if (childNode.type === 'EnumDefinition') {
                 debug(`Adding file level enum ${childNode.name}`);
-                let umlClass = new umlClass_1.UmlClass({
+                const umlClass = new umlClass_1.UmlClass({
                     name: childNode.name,
                     stereotype: umlClass_1.ClassStereotype.Enum,
                     absolutePath: filesystem
@@ -116,7 +116,7 @@ function convertAST2UmlClasses(node, relativePath, remappings, filesystem = fals
                         debug(`Added filesystem import ${newImport.absolutePath} with class names ${newImport.classNames.map((i) => i.className)}`);
                         imports.push(newImport);
                     }
-                    catch (err) {
+                    catch {
                         debug(`Failed to resolve import ${childNode.path} from file ${relativePath}`);
                     }
                 }
@@ -626,7 +626,7 @@ function parseTypeName(typeName) {
         case 'FunctionTypeName':
             // TODO add params and return type
             return [typeName.type + '\\(\\)', umlClass_1.AttributeType.Function];
-        case 'ArrayTypeName':
+        case 'ArrayTypeName': {
             const [arrayElementType] = parseTypeName(typeName.baseTypeName);
             let length = '';
             if (Number.isInteger(typeName.length)) {
@@ -640,7 +640,8 @@ function parseTypeName(typeName) {
             }
             // TODO does not currently handle Expression types like BinaryOperation
             return [arrayElementType + '[' + length + ']', umlClass_1.AttributeType.Array];
-        case 'Mapping':
+        }
+        case 'Mapping': {
             const key = typeName.keyType?.name ||
                 typeName.keyType?.namePath;
             const [valueType] = parseTypeName(typeName.valueType);
@@ -648,6 +649,7 @@ function parseTypeName(typeName) {
                 'mapping\\(' + key + '=\\>' + valueType + '\\)',
                 umlClass_1.AttributeType.Mapping,
             ];
+        }
         default:
             throw Error(`Invalid typeName ${typeName}`);
     }
@@ -661,7 +663,7 @@ function parseParameters(params) {
     if (!params || !params) {
         return [];
     }
-    let parameters = [];
+    const parameters = [];
     for (const param of params) {
         const [type] = parseTypeName(param.typeName);
         parameters.push({

package/lib/converterClass2Dot.js

@@ -166,7 +166,7 @@ const dotOperators = (umlClass, vizGroup, operators, options) => {
         return b.stereotype - a.stereotype;
     });
     // Filter out any modifiers or events if options are flagged to hide them
-    let operatorsFiltered = operatorsSortedByStereotype.filter((o) => !((options.hideModifiers === true &&
+    const operatorsFiltered = operatorsSortedByStereotype.filter((o) => !((options.hideModifiers === true &&
         o.stereotype === umlClass_1.OperatorStereotype.Modifier) ||
         (options.hideEvents === true &&
             o.stereotype === umlClass_1.OperatorStereotype.Event)));

package/lib/converterClasses2Storage.d.ts

@@ -1,5 +1,5 @@
 import { Attribute, AttributeType, UmlClass } from './umlClass';
-import { BigNumberish } from '@ethersproject/bignumber';
+import { BigNumberish } from 'ethers';
 export declare enum StorageSectionType {
     Contract = "Contract",
     Struct = "Struct",

package/lib/converterClasses2Storage.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addDynamicVariables = exports.findDimensionLength = exports.calcSectionOffset = exports.isElementary = exports.calcStorageByteSize = exports.parseStorageSectionFromAttribute = exports.optionStorageVariables = exports.convertClasses2StorageSections = exports.StorageSectionType = void 0;
 const umlClass_1 = require("./umlClass");
 const associations_1 = require("./associations");
-const utils_1 = require("ethers/lib/utils");
 const ethers_1 = require("ethers");
 const path_1 = __importDefault(require("path"));
 const slotValues_1 = require("./slotValues");
@@ -151,8 +150,8 @@ const parseVariables = (umlClass, umlClasses, variables, storageSections, inheri
         const getValue = calcGetValue(attribute.attributeType, mapping);
         // Get the toSlot of the last storage item
         const lastVariable = variables[variables.length - 1];
-        let lastToSlot = lastVariable ? lastVariable.toSlot : 0;
-        let nextOffset = lastVariable
+        const lastToSlot = lastVariable ? lastVariable.toSlot : 0;
+        const nextOffset = lastVariable
             ? lastVariable.byteOffset + lastVariable.byteSize
             : 0;
         let fromSlot;
@@ -347,7 +346,7 @@ const parseStorageSectionFromAttribute = (attribute, umlClass, otherClasses, sto
             // Find UserDefined type can be a contract, struct or enum
             const typeClass = findTypeClass(result[1], attribute, umlClass, otherClasses);
             if (typeClass.stereotype === umlClass_1.ClassStereotype.Struct) {
-                let variables = parseVariables(typeClass, otherClasses, [], storageSections, [], true, arrayItems, noExpandVariables);
+                const variables = parseVariables(typeClass, otherClasses, [], storageSections, [], true, arrayItems, noExpandVariables);
                 const storageSection = {
                     id: storageId++,
                     name: typeClass.name,
@@ -535,7 +534,7 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
             case umlClass_1.ClassStereotype.Interface:
             case umlClass_1.ClassStereotype.Library:
                 return { size: 20, dynamic: false };
-            case umlClass_1.ClassStereotype.Struct:
+            case umlClass_1.ClassStereotype.Struct: {
                 let structByteSize = 0;
                 attributeTypeClass.attributes.forEach((structAttribute) => {
                     // If next attribute is an array, then we need to start in a new slot
@@ -569,6 +568,7 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
                     size: Math.ceil(structByteSize / 32) * 32,
                     dynamic: false,
                 };
+            }
             default:
                 return { size: 20, dynamic: false };
         }
@@ -593,7 +593,7 @@ const calcElementaryTypeSize = (type) => {
         case 'ufixed':
         case 'fixed':
             return { size: 32, dynamic: false };
-        default:
+        default: {
             const result = type.match(/[u]*(int|fixed|bytes)([0-9]+)/);
             if (result === null || !result[2]) {
                 throw Error(`Failed size elementary type "${type}"`);
@@ -606,6 +606,7 @@ const calcElementaryTypeSize = (type) => {
             // If an int
             const bitSize = parseInt(result[2]);
             return { size: bitSize / 8, dynamic: false };
+        }
     }
 };
 const isElementary = (type) => {
@@ -619,18 +620,19 @@ const isElementary = (type) => {
         case 'ufixed':
         case 'fixed':
             return true;
-        default:
+        default: {
             const result = type.match(/^[u]?(int|fixed|bytes)([0-9]+)$/);
             return result !== null;
+        }
     }
 };
 exports.isElementary = isElementary;
 const calcSectionOffset = (variable, sectionOffset = '0') => {
     if (variable.dynamic) {
-        const hexStringOf32Bytes = (0, utils_1.hexZeroPad)(ethers_1.BigNumber.from(variable.fromSlot).add(sectionOffset).toHexString(), 32);
-        return (0, utils_1.keccak256)(hexStringOf32Bytes);
+        const hexStringOf32Bytes = (0, ethers_1.zeroPadValue)((0, ethers_1.toBeHex)(BigInt(variable.fromSlot) + BigInt(sectionOffset)), 32);
+        return (0, ethers_1.keccak256)(hexStringOf32Bytes);
     }
-    return ethers_1.BigNumber.from(variable.fromSlot).add(sectionOffset).toHexString();
+    return (0, ethers_1.toBeHex)(BigInt(variable.fromSlot) + BigInt(sectionOffset));
 };
 exports.calcSectionOffset = calcSectionOffset;
 const findDimensionLength = (umlClass, dimension, otherClasses) => {
@@ -788,7 +790,7 @@ const addDynamicVariables = async (storageSection, storageSections, url, contrac
                 continue;
             }
             // Add missing dynamic array variables
-            const arrayLength = ethers_1.BigNumber.from(variable.slotValue).toNumber();
+            const arrayLength = Number(BigInt(variable.slotValue));
             if (arrayLength > 1) {
                 // Add missing array variables to the referenced dynamic array
                 addArrayVariables(arrayLength, arrayItems, referenceStorageSection.variables);

package/lib/diffContracts.d.ts

@@ -27,7 +27,7 @@ export declare const compareFlattenContracts: (addressA: string, addressB: strin
     contractNameB: string;
 }>;
 export declare const diffVerified2Local: (addressA: string, etherscanParserA: EtherscanParser, fileOrBaseFolders: string[], ignoreFilesOrFolders?: string[]) => Promise<CompareContracts>;
-export declare const diffVerifiedContracts: (addressA: string, addressB: string, etherscanParserA: EtherscanParser, etherscanParserB: EtherscanParser, options: DiffOptions) => Promise<CompareContracts>;
+export declare const diffVerifiedContracts: (addressA: string, addressB: string, etherscanParserA: EtherscanParser, etherscanParserB: EtherscanParser, _options: DiffOptions) => Promise<CompareContracts>;
 export declare const displayFileDiffSummary: (fileDiffs: DiffFiles[]) => void;
 export declare const displayFileDiffs: (fileDiffs: DiffFiles[], options?: {
     lineBuffer?: number;

package/lib/diffContracts.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.displayFileDiffs = exports.displayFileDiffSummary = exports.diffVerifiedContracts = exports.diffVerified2Local = exports.compareFlattenContracts = exports.compareVerified2Local = exports.compareVerifiedContracts = void 0;
 const clc = require('cli-color');
+const fs_1 = require("fs");
 const path_1 = require("path");
 const parserFiles_1 = require("./parserFiles");
 const writerFiles_1 = require("./writerFiles");
@@ -91,12 +92,20 @@ const diffVerified2Local = async (addressA, etherscanParserA, fileOrBaseFolders,
         let bFile;
         // for each of the base folders
         for (const baseFolder of fileOrBaseFolders) {
-            bFile = bFiles.find((bFile) => {
-                const resolvedPath = (0, path_1.resolve)(process.cwd(), baseFolder, aFile.filename);
-                return bFile === resolvedPath;
-            });
-            if (bFile) {
-                break;
+            const aFileResolvedPath = (0, path_1.resolve)(process.cwd(), baseFolder, aFile.filename);
+            try {
+                // Resolve full path including symlinks. For example,
+                // node_modules/@openzeppelin/contracts is a symlink to
+                // node_modules/.pnpm/@openzeppelin+contracts@x.y.z/node_modules/@openzeppelin/contracts
+                const aFileRealPath = (0, fs_1.realpathSync)(aFileResolvedPath);
+                bFile = bFiles.find((bFile) => bFile === aFileRealPath);
+                if (bFile) {
+                    // Found match of aFile in bFiles, break out of loop to try next aFile
+                    break;
+                }
+            }
+            catch {
+                // Do nothing, continue to next bFile in loop
             }
         }
         if (bFile) {
@@ -139,7 +148,7 @@ const diffVerified2Local = async (addressA, etherscanParserA, fileOrBaseFolders,
     };
 };
 exports.diffVerified2Local = diffVerified2Local;
-const diffVerifiedContracts = async (addressA, addressB, etherscanParserA, etherscanParserB, options) => {
+const diffVerifiedContracts = async (addressA, addressB, etherscanParserA, etherscanParserB, _options) => {
     const files = [];
     const { files: aFiles, contractName: contractNameA } = await etherscanParserA.getSourceCode(addressA);
     const { files: bFiles, contractName: contractNameB } = await etherscanParserB.getSourceCode(addressB);

package/lib/parserEtherscan.js

@@ -90,7 +90,7 @@ class EtherscanParser {
             return;
         }
         if (!apiKey) {
-            console.error(`The apiKey option must be set when getting verified source code from an Etherscan like explorer`);
+            console.error(`The -k, --apiKey option or SCAN_API_KEY env var must be set when getting verified source code from an Etherscan like explorer`);
             process.exit(1);
         }
         const chainId = (0, exports.setChainId)(network);

package/lib/parserFiles.js

@@ -128,7 +128,7 @@ const isFile = (fileName) => {
         const file = (0, fs_1.lstatSync)(fileName);
         return file.isFile();
     }
-    catch (err) {
+    catch {
         return false;
     }
 };
@@ -138,7 +138,7 @@ const isFolder = (fileName) => {
         const file = (0, fs_1.lstatSync)(fileName);
         return file.isDirectory();
     }
-    catch (err) {
+    catch {
         return false;
     }
 };

package/lib/slotValues.d.ts

@@ -1,5 +1,5 @@
-import { BigNumberish } from '@ethersproject/bignumber';
 import { StorageSection, Variable } from './converterClasses2Storage';
+import { BigNumberish } from 'ethers';
 /**
  * Adds the slot values to the variables in the storage section.
  * This can be rerun for a section as it will only get if the slot value

package/lib/slotValues.js

@@ -4,13 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.escapeString = exports.convert2String = exports.dynamicSlotSize = exports.getSlotValue = exports.getSlotValues = exports.parseValue = exports.addSlotValues = void 0;
-const bignumber_1 = require("@ethersproject/bignumber");
 const axios_1 = __importDefault(require("axios"));
 const umlClass_1 = require("./umlClass");
-const utils_1 = require("ethers/lib/utils");
-const SlotValueCache_1 = require("./SlotValueCache");
 const ethers_1 = require("ethers");
+const SlotValueCache_1 = require("./SlotValueCache");
 const debug = require('debug')('sol2uml');
+const commify = (value) => {
+    const match = value.match(/^(-?)(\d+)(\.(.*))?$/);
+    if (!match)
+        return value;
+    const neg = match[1];
+    const whole = match[2];
+    const frac = match[4] ? '.' + match[4] : '';
+    return neg + whole.replace(/\B(?=(\d{3})+(?!\d))/g, ',') + frac;
+};
 /**
  * Adds the slot values to the variables in the storage section.
  * This can be rerun for a section as it will only get if the slot value
@@ -30,7 +37,7 @@ const addSlotValues = async (url, contractAddress, storageSection, arrayItems, b
     const slots = [];
     valueVariables.forEach((variable) => {
         if (variable.offset) {
-            slots.push(bignumber_1.BigNumber.from(variable.offset));
+            slots.push(BigInt(variable.offset));
         }
         else {
             for (let i = 0; variable.fromSlot + i <= variable.toSlot; i++) {
@@ -45,12 +52,12 @@ const addSlotValues = async (url, contractAddress, storageSection, arrayItems, b
     });
     // remove duplicate slot numbers
     const uniqueFromSlots = [...new Set(slots)];
-    // Convert slot numbers to BigNumbers and offset dynamic arrays
-    let slotKeys = uniqueFromSlots.map((fromSlot) => {
+    // Convert slot numbers to BigInts and offset dynamic arrays
+    const slotKeys = uniqueFromSlots.map((fromSlot) => {
         if (storageSection.offset) {
-            return bignumber_1.BigNumber.from(storageSection.offset).add(fromSlot);
+            return BigInt(storageSection.offset) + BigInt(fromSlot);
         }
-        return bignumber_1.BigNumber.from(fromSlot);
+        return BigInt(fromSlot);
     });
     // Get the contract slot values from the node provider
     const values = await (0, exports.getSlotValues)(url, contractAddress, slotKeys, blockTag);
@@ -62,7 +69,7 @@ const addSlotValues = async (url, contractAddress, storageSection, arrayItems, b
         for (const variable of storageSection.variables) {
             if (variable.getValue &&
                 variable.offset &&
-                bignumber_1.BigNumber.from(variable.offset).eq(fromSlot)) {
+                BigInt(variable.offset) === BigInt(fromSlot)) {
                 debug(`Set slot value ${value} for section "${storageSection.name}", var type ${variable.type}, slot ${variable.offset}`);
                 variable.slotValue = value;
                 // parse variable value from slot data
@@ -80,7 +87,7 @@ const addSlotValues = async (url, contractAddress, storageSection, arrayItems, b
             }
             // if variable is past the slot that has the value
             else if (variable.toSlot &&
-                bignumber_1.BigNumber.from(variable.toSlot).gt(fromSlot)) {
+                BigInt(variable.toSlot) > BigInt(fromSlot)) {
                 break;
             }
         }
@@ -103,7 +110,7 @@ const parseValue = (variable) => {
         // dynamic arrays
         if (variable.attributeType === umlClass_1.AttributeType.Array &&
             variable.dynamic) {
-            return (0, utils_1.formatUnits)('0x' + variableValue, 0);
+            return (0, ethers_1.formatUnits)('0x' + variableValue, 0);
         }
         return undefined;
     }
@@ -118,12 +125,12 @@ const parseUserDefinedValue = (variable, variableValue) => {
     // https://blog.soliditylang.org/2021/09/27/user-defined-value-types/
     // using byteSize is crude and will be incorrect for aliases types like int160 or uint160
     if (variable.byteSize === 20) {
-        return (0, utils_1.getAddress)('0x' + variableValue);
+        return (0, ethers_1.getAddress)('0x' + variableValue);
     }
     // this will also be wrong if the alias is to a 1 byte type. eg bytes1, int8 or uint8
     if (variable.byteSize === 1) {
         // assume 1 byte is an enum so convert value to enum index number
-        const index = bignumber_1.BigNumber.from('0x' + variableValue).toNumber();
+        const index = Number(BigInt('0x' + variableValue));
         // lookup enum value if its available
         return variable?.enumValues ? variable?.enumValues[index] : undefined;
     }
@@ -142,17 +149,14 @@ const parseElementaryValue = (variable, variableValue) => {
     if (variable.type === 'string' || variable.type === 'bytes') {
         if (variable.dynamic) {
             const lastByte = variable.slotValue.slice(-2);
-            const size = bignumber_1.BigNumber.from('0x' + lastByte);
+            const size = BigInt('0x' + lastByte);
             // Check if the last bit is set by AND the size with 0x01
-            if (size.and(1).eq(1)) {
+            if ((size & 1n) === 1n) {
                 // Return the number of chars or bytes
-                return bignumber_1.BigNumber.from(variable.slotValue)
-                    .sub(1)
-                    .div(2)
-                    .toString();
+                return ((BigInt(variable.slotValue) - 1n) / 2n).toString();
             }
             // The last byte holds the length of the string or bytes in the slot
-            const valueHex = '0x' + variableValue.slice(0, size.toNumber());
+            const valueHex = '0x' + variableValue.slice(0, Number(size));
             if (variable.type === 'bytes')
                 return valueHex;
             return `\\"${(0, exports.convert2String)(valueHex)}\\"`;
@@ -162,34 +166,34 @@ const parseElementaryValue = (variable, variableValue) => {
         return `\\"${(0, exports.convert2String)('0x' + variableValue)}\\"`;
     }
     if (variable.type === 'address') {
-        return (0, utils_1.getAddress)('0x' + variableValue);
+        return (0, ethers_1.getAddress)('0x' + variableValue);
     }
     if (variable.type.match(/^uint([0-9]*)$/)) {
-        const parsedValue = (0, utils_1.formatUnits)('0x' + variableValue, 0);
-        return (0, utils_1.commify)(parsedValue);
+        const parsedValue = (0, ethers_1.formatUnits)('0x' + variableValue, 0);
+        return commify(parsedValue);
     }
     if (variable.type.match(/^bytes([0-9]+)$/)) {
         return '0x' + variableValue;
     }
     if (variable.type.match(/^int([0-9]*)/)) {
         // parse variable value as an unsigned number
-        let rawValue = bignumber_1.BigNumber.from('0x' + variableValue);
+        let rawValue = BigInt('0x' + variableValue);
         // parse the number of bits
         const result = variable.type.match(/^int([0-9]*$)/);
-        const bitSize = result[1] ? result[1] : 256;
+        const bitSize = result[1] ? Number(result[1]) : 256;
         // Convert the number of bits to the number of hex characters
-        const hexSize = bignumber_1.BigNumber.from(bitSize).div(4).toNumber();
+        const hexSize = bitSize / 4;
         // bit mask has a leading 1 and the rest 0. 0x8 = 1000 binary
-        const mask = '0x80' + '0'.repeat(hexSize - 2);
+        const mask = BigInt('0x80' + '0'.repeat(hexSize - 2));
         // is the first bit a 1?
-        const negative = rawValue.and(mask);
-        if (negative.gt(0)) {
+        const negative = rawValue & mask;
+        if (negative > 0n) {
             // Convert unsigned number to a signed negative
-            const negativeOne = '0xFF' + 'F'.repeat(hexSize - 2);
-            rawValue = bignumber_1.BigNumber.from(negativeOne).sub(rawValue).add(1).mul(-1);
+            const negativeOne = BigInt('0xFF' + 'F'.repeat(hexSize - 2));
+            rawValue = (negativeOne - rawValue + 1n) * -1n;
         }
-        const parsedValue = (0, utils_1.formatUnits)(rawValue, 0);
-        return (0, utils_1.commify)(parsedValue);
+        const parsedValue = (0, ethers_1.formatUnits)(rawValue, 0);
+        return commify(parsedValue);
     }
     // add fixed point numbers when they are supported by Solidity
     return undefined;
@@ -209,9 +213,7 @@ const getSlotValues = async (url, contractAddress, slotKeys, blockTag = 'latest'
         if (slotKeys.length === 0) {
             return [];
         }
-        const block = blockTag === 'latest'
-            ? blockTag
-            : (0, utils_1.hexValue)(bignumber_1.BigNumber.from(blockTag));
+        const block = blockTag === 'latest' ? blockTag : (0, ethers_1.toQuantity)(BigInt(blockTag));
         // get cached values and missing slot keys from the cache
         const { cachedValues, missingKeys } = SlotValueCache_1.SlotValueCache.readSlotValues(slotKeys);
         // If all values are in the cache then just return the cached values
@@ -219,7 +221,7 @@ const getSlotValues = async (url, contractAddress, slotKeys, blockTag = 'latest'
             return cachedValues;
         }
         // Check we are pointing to the correct chain by checking the contract has code
-        const provider = new ethers_1.ethers.providers.JsonRpcProvider(url);
+        const provider = new ethers_1.JsonRpcProvider(url);
         const code = await provider.getCode(contractAddress, block);
         if (!code || code === '0x') {
             const msg = `Address ${contractAddress} has no code. Check your "-u, --url" option or "NODE_URL" environment variable is pointing to the correct node.\nurl: ${url}`;
@@ -242,7 +244,7 @@ const getSlotValues = async (url, contractAddress, slotKeys, blockTag = 'latest'
             throw Error(`Requested ${missingKeys.length} storage slot values but only got ${response.data.length}`);
         }
         const responseData = response.data;
-        const sortedResponses = responseData.sort((a, b) => bignumber_1.BigNumber.from(a.id).gt(b.id) ? 1 : -1);
+        const sortedResponses = responseData.sort((a, b) => Number(a.id) - Number(b.id));
         const missingValues = sortedResponses.map((data) => {
             if (data.error) {
                 throw Error(`json rpc call with id ${data.id} failed to get storage values: ${data.error?.message}`);
@@ -284,11 +286,11 @@ const dynamicSlotSize = (variable) => {
         if (!variable?.slotValue)
             throw Error(`Missing slot value.`);
         const last4bits = '0x' + variable.slotValue.slice(-1);
-        const last4bitsNum = bignumber_1.BigNumber.from(last4bits).toNumber();
+        const last4bitsNum = Number(BigInt(last4bits));
         // If the last 4 bits is an even number then it's not a dynamic slot
         if (last4bitsNum % 2 === 0)
             return 0;
-        const sizeRaw = bignumber_1.BigNumber.from(variable.slotValue).toNumber();
+        const sizeRaw = Number(BigInt(variable.slotValue));
         // Adjust the size to bytes
         return (sizeRaw - 1) / 2;
     }
@@ -302,7 +304,7 @@ const convert2String = (bytes) => {
         '0x0000000000000000000000000000000000000000000000000000000000000000') {
         return '';
     }
-    const rawString = (0, utils_1.toUtf8String)(bytes);
+    const rawString = (0, ethers_1.toUtf8String)(bytes);
     return (0, exports.escapeString)(rawString);
 };
 exports.convert2String = convert2String;

package/lib/sol2uml.js

@@ -171,7 +171,7 @@ WARNING: sol2uml does not use the Solidity compiler so may differ with solc. A k
                 }
                 storageAddress = fileFolderAddress;
             }
-            let block = await (0, block_1.getBlock)(combinedOptions);
+            const block = await (0, block_1.getBlock)(combinedOptions);
             // Get slot values for each storage section
             for (const storageSection of storageSections) {
                 await (0, slotValues_1.addSlotValues)(combinedOptions.url, storageAddress, storageSection, arrayItems, block);

package/lib/squashClasses.js

@@ -47,14 +47,14 @@ const squashUmlClasses = (umlClasses, baseContractNames) => {
     let removedClassIds = [];
     for (const baseContractName of baseContractNames) {
         // Find the base UML Class to squash
-        let baseIndex = umlClasses.findIndex(({ name }) => {
+        const baseIndex = umlClasses.findIndex(({ name }) => {
             return name === baseContractName;
         });
         if (baseIndex === undefined) {
             throw Error(`Failed to find contract with name "${baseContractName}" to squash`);
         }
         const baseClass = umlClasses[baseIndex];
-        let squashedClass = new umlClass_1.UmlClass({
+        const squashedClass = new umlClass_1.UmlClass({
             name: baseClass.name,
             absolutePath: baseClass.absolutePath,
             relativePath: baseClass.relativePath,

package/lib/utils/block.js

@@ -6,12 +6,12 @@ const debug = require('debug')('sol2uml');
 const getBlock = async (options) => {
     if (options.block === 'latest') {
         try {
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(options.url);
+            const provider = new ethers_1.JsonRpcProvider(options.url);
             const block = await provider.getBlockNumber();
             debug(`Latest block is ${block}. All storage slot values will be from this block.`);
             return block;
         }
-        catch (err) {
+        catch {
             const defaultMessage = options.url === 'http://localhost:8545'
                 ? 'This is the default url. Use the `-u, --url` option or `NODE_URL` environment variable to set the url of your blockchain node.'
                 : `Check your --url option or NODE_URL environment variable is pointing to the correct node for the "${options.network}" blockchain.`;
@@ -21,7 +21,7 @@ const getBlock = async (options) => {
     try {
         return parseInt(options.block);
     }
-    catch (err) {
+    catch {
         throw Error(`Invalid block number: ${options.block}`);
     }
 };

package/lib/utils/diff.js

@@ -44,7 +44,7 @@ const SkippedLinesMarker = `\n---`;
  * @param lineBuff the number of lines to display before and after each change.
  */
 const diffCode = (codeA, codeB, lineBuff) => {
-    // @ts-ignore
+    // @ts-ignore diff_match_patch constructor has no type declarations
     const dmp = new diff_match_patch_1.default();
     const diff = dmp.diff_main(codeA, codeB);
     dmp.diff_cleanupSemantic(diff);
@@ -70,18 +70,20 @@ const diff_pretty = (diffs, lines, lineBuff = 2) => {
         const op = diff[0]; // Operation (insert, delete, equal)
         const text = diff[1]; // Text of change.
         switch (op) {
-            case diff_match_patch_1.DIFF_INSERT:
+            case diff_match_patch_1.DIFF_INSERT: {
                 // If first diff then we need to add the first line number
                 const linesInserted = addLineNumbers(text, lineCount, linePad);
                 output += initialLineNumber + clc.green(linesInserted);
                 lineCount += countLines(text);
                 break;
-            case diff_match_patch_1.DIFF_DELETE:
+            }
+            case diff_match_patch_1.DIFF_DELETE: {
                 // zero start line means blank line numbers are used
                 const linesDeleted = addLineNumbers(text, 0, linePad);
                 output += initialLineNumber + clc.red(linesDeleted);
                 break;
-            case diff_match_patch_1.DIFF_EQUAL:
+            }
+            case diff_match_patch_1.DIFF_EQUAL: {
                 const eolPositions = findEOLPositions(text);
                 // If no changes yet
                 if (diffIndex <= 1) {
@@ -97,6 +99,7 @@ const diff_pretty = (diffs, lines, lineBuff = 2) => {
                 }
                 lineCount += eolPositions.length;
                 break;
+            }
         }
     }
     output += '\n';
@@ -178,7 +181,7 @@ const countLines = (text) => (text.match(/\n/g) || '').length;
 const addLineNumbers = (text, lineStart, linePad) => {
     let lineCount = lineStart;
     let textWithLineNumbers = '';
-    text.split('').forEach((c, i) => {
+    text.split('').forEach((c) => {
         if (c === '\n') {
             if (lineStart > 0) {
                 textWithLineNumbers += `\n${(++lineCount)

package/lib/utils/validators.js

@@ -3,15 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateTypes = exports.validateSlotNames = exports.validateLineBuffer = exports.validateNames = exports.validateAddress = void 0;
 const regEx_1 = require("./regEx");
 const commander_1 = require("commander");
-const utils_1 = require("ethers/lib/utils");
+const ethers_1 = require("ethers");
 const converterClasses2Storage_1 = require("../converterClasses2Storage");
 const debug = require('debug')('sol2uml');
 const validateAddress = (address) => {
     try {
         if (typeof address === 'string' && address?.match(regEx_1.ethereumAddress))
-            return (0, utils_1.getAddress)(address);
+            return (0, ethers_1.getAddress)(address);
     }
-    catch (err) { }
+    catch { /* validation failed */ }
     throw new commander_1.InvalidArgumentError(`Address must be in hexadecimal format with a 0x prefix.`);
 };
 exports.validateAddress = validateAddress;
@@ -22,7 +22,7 @@ const validateNames = (variables) => {
             variables.match(regEx_1.commaSeparatedList))
             return variables.split(',');
     }
-    catch (err) { }
+    catch { /* validation failed */ }
     throw new commander_1.InvalidArgumentError(`Must be a comma-separate list of names with no white spaces.`);
 };
 exports.validateNames = validateNames;
@@ -32,7 +32,7 @@ const validateLineBuffer = (lineBufferParam) => {
         if (lineBuffer >= 0)
             return lineBuffer;
     }
-    catch (err) { }
+    catch { /* validation failed */ }
     throw new commander_1.InvalidOptionArgumentError(`Must be a zero or a positive integer.`);
 };
 exports.validateLineBuffer = validateLineBuffer;
@@ -46,7 +46,7 @@ const validateSlotNames = (slotNames) => {
                     offset: slot,
                 };
             }
-            const offset = (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(slot));
+            const offset = (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(slot));
             debug(`Slot name "${slot}" has hash "${offset}"`);
             return {
                 name: slot,
@@ -56,7 +56,7 @@ const validateSlotNames = (slotNames) => {
         console.log(results.length);
         return results;
     }
-    catch (err) { }
+    catch { /* validation failed */ }
     throw new commander_1.InvalidOptionArgumentError(`Must be a comma-separate list of slots with no white spaces.`);
 };
 exports.validateSlotNames = validateSlotNames;
@@ -72,7 +72,7 @@ const validateTypes = (typesString) => {
             return types;
         }
     }
-    catch (err) { }
+    catch { /* validation failed */ }
     throw new commander_1.InvalidArgumentError(`Slot type must be an elementary type which includes dynamic and fixed size arrays. eg address, address[], uint256, int256[2], bytes32, string, bool`);
 };
 exports.validateTypes = validateTypes;

package/lib/writerFiles.js

@@ -13,6 +13,7 @@ const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const sync_1 = __importDefault(require("@aduh95/viz.js/sync"));
 const { convert } = require('convert-svg-to-png');
+const puppeteer = require('puppeteer');
 const debug = require('debug')('sol2uml');
 /**
  * Writes output files to the file system based on the provided input and options.
@@ -39,7 +40,9 @@ const writeOutputFiles = async (dot, contractName, outputFormat = 'svg', outputF
                         outputExt;
             }
         }
-        catch (err) { } // we can ignore errors as it just means outputFilename does not exist yet
+        catch {
+            /* outputFilename does not exist yet */
+        }
     }
     if (outputFormat === 'dot' || outputFormat === 'all') {
         writeDot(dot, outputFilename);
@@ -140,7 +143,7 @@ async function writePng(svg, filename) {
     debug(`About to write png file ${pngFilename}`);
     try {
         const png = await convert(svg, {
-            outputFilePath: pngFilename,
+            launch: { executablePath: puppeteer.executablePath() },
         });
         return new Promise((resolve, reject) => {
             (0, fs_1.writeFile)(pngFilename, png, (err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol2uml",
-  "version": "2.5.22",
+  "version": "2.5.24",
   "description": "Solidity contract visualisation tool.",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -8,6 +8,7 @@
     "buildSol": "cd ./src/contracts && solc **/*.sol",
     "build": "tsc --build ./tsconfig.json",
     "clean": "tsc --build --clean ./tsconfig.json",
+    "lint": "eslint src/ts",
     "package-lock": "npm i --package-lock-only",
     "permit": " chmod 775 lib/sol2uml.js",
     "prettier": "prettier --write src/**/*.ts **/*.md",
@@ -28,23 +29,28 @@
     "axios-debug-log": "^1.0.0",
     "cli-color": "^2.0.4",
     "commander": "^12.1.0",
-    "convert-svg-to-png": "^0.6.4",
+    "convert-svg-to-png": "^0.7.1",
     "debug": "^4.4.1",
     "diff-match-patch": "^1.0.5",
-    "ethers": "^5.8.0",
+    "ethers": "^6.16.0",
     "js-graph-algorithms": "^1.0.18",
-    "klaw": "^4.1.0"
+    "klaw": "^4.1.0",
+    "puppeteer": "^24.37.3"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@openzeppelin/contracts": "^4.9.3",
     "@types/diff-match-patch": "^1.0.36",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/klaw": "^3.0.7",
-    "jest": "^30.0.0",
-    "prettier": "^3.5.3",
-    "ts-jest": "^29.4.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "jest": "^30.2.0",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.55.0"
   },
   "files": [
     "lib/*.js",