sol2uml 2.5.23 → 2.5.25

package/README.md

@@ -111,6 +111,7 @@ Options:
   -c, --clusterFolders             cluster contracts into source folders (default: false)
   -hv, --hideVariables             hide variables from contracts, interfaces, structs and enums (default: false)
   -hf, --hideFunctions             hide functions from contracts, interfaces and libraries (default: false)
+  -hy, --hideTypes                 hide types of variables, function arguments and return types (default: false)
   -hp, --hidePrivates              hide private and internal attributes and operators (default: false)
   -hm, --hideModifiers             hide modifier functions from contracts (default: false)
   -ht, --hideEvents                hide events from contracts, interfaces and libraries (default: false)
@@ -122,6 +123,7 @@ Options:
   -hi, --hideInterfaces            hide interfaces (default: false)
   -ha, --hideAbstracts             hide abstract contracts (default: false)
   -hn, --hideFilename              hide relative path and file name (default: false)
+  -hd, --hideDepFunctions          hide function names on dependency arrows (default: false)
   -s, --squash                     squash inherited contracts to the base contract(s) (default: false)
   -hsc, --hideSourceContract       hide the source contract when using squash (default: false)
   -h, --help                       display help for command

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.
@@ -17,7 +17,7 @@ class SlotValueCache {
         const cachedValues = [];
         const missingKeys = [];
         slotKeys.forEach((slotKey) => {
-            const key = bignumber_1.BigNumber.from(slotKey).toHexString();
+            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

@@ -533,7 +533,24 @@ function parseExpression(expression, umlClass) {
         parseExpression(expression.right, umlClass);
     }
     else if (expression.type === 'FunctionCall') {
-        parseExpression(expression.expression, umlClass);
+        if (expression.expression.type === 'MemberAccess' &&
+            expression.expression.expression?.type === 'Identifier') {
+            // Pattern: ClassName.functionName(args) — explicit library/contract call
+            const memberName = expression.expression.memberName;
+            umlClass.addAssociation({
+                referenceType: umlClass_1.ReferenceType.Memory,
+                targetUmlClassName: expression.expression.expression.name,
+                functionsCalled: [memberName],
+            });
+            umlClass.memberAccessCalls.add(memberName);
+        }
+        else {
+            // Track member access calls inside other FunctionCall patterns (e.g. x.functionName())
+            if (expression.expression.type === 'MemberAccess') {
+                umlClass.memberAccessCalls.add(expression.expression.memberName);
+            }
+            parseExpression(expression.expression, umlClass);
+        }
         expression.arguments.forEach((arg) => {
             parseExpression(arg, umlClass);
         });

package/lib/converterClass2Dot.d.ts

@@ -4,6 +4,7 @@ export interface ClassOptions {
     hideContracts?: boolean;
     hideVariables?: boolean;
     hideFunctions?: boolean;
+    hideTypes?: boolean;
     hideModifiers?: boolean;
     hideEvents?: boolean;
     hideStructs?: boolean;
@@ -14,6 +15,7 @@ export interface ClassOptions {
     hideAbstracts?: boolean;
     hideFilename?: boolean;
     hideSourceContract?: boolean;
+    hideDepFunctions?: boolean;
     backColor?: string;
     shapeColor?: string;
     fillColor?: string;

package/lib/converterClass2Dot.js

@@ -116,7 +116,8 @@ const dotAttributes = (attributes, options, vizGroup, indent = true) => {
         const sourceContract = attribute.sourceContract && !options.hideSourceContract
             ? ` \\<\\<${attribute.sourceContract}\\>\\>`
             : '';
-        dotString += `${indentString}${attribute.name}: ${attribute.type}${sourceContract}\\l`;
+        const type = options.hideTypes ? '' : `: ${attribute.type}`;
+        dotString += `${indentString}${attribute.name}${type}${sourceContract}\\l`;
     });
     return dotString;
 };
@@ -176,8 +177,8 @@ const dotOperators = (umlClass, vizGroup, operators, options) => {
             dotString += dotOperatorStereotype(umlClass, operator.stereotype);
         }
         dotString += operator.name;
-        dotString += dotParameters(operator.parameters);
-        if (operator.returnParameters?.length > 0) {
+        dotString += dotParameters(operator.parameters, false, options.hideTypes);
+        if (operator.returnParameters?.length > 0 && !options.hideTypes) {
             dotString += ': ' + dotParameters(operator.returnParameters, true);
         }
         if (options.hideModifiers === false && operator.modifiers?.length > 0) {
@@ -214,7 +215,10 @@ const dotOperatorStereotype = (umlClass, operatorStereotype) => {
     }
     return dotString + ' ';
 };
-const dotParameters = (parameters, returnParams = false) => {
+const dotParameters = (parameters, returnParams = false, hideTypes = false) => {
+    if (hideTypes && !returnParams) {
+        return '()';
+    }
     if (parameters.length == 1 && !parameters[0].name) {
         if (returnParams) {
             return parameters[0].type;

package/lib/converterClasses2Dot.js

@@ -139,6 +139,39 @@ function addAssociationToDot(sourceUmlClass, targetUmlClass, association, classO
             dotString += 'weight=3, ';
         }
     }
+    // Add function name labels on dependency arrows (not on realization/inheritance)
+    if (!association.realization && !classOptions.hideDepFunctions) {
+        const functionNames = getAssociationFunctionNames(sourceUmlClass, targetUmlClass, association);
+        if (functionNames.length > 0) {
+            const label = functionNames.map((fn) => fn + '\\l').join('');
+            dotString += `label="${label}", fontsize=10, `;
+        }
+    }
     return dotString + ']';
 }
+function getAssociationFunctionNames(sourceUmlClass, targetUmlClass, association) {
+    const names = new Set();
+    // Add explicitly captured function names
+    if (association.functionsCalled) {
+        for (const fn of association.functionsCalled) {
+            names.add(fn);
+        }
+    }
+    // Cross-reference: if no explicit calls, check if source class's member
+    // access calls match any of the target class's operator names.
+    // Applies to libraries (using...for) and interfaces (e.g. IERC20(token).transfer())
+    if (names.size === 0 &&
+        (targetUmlClass.stereotype === umlClass_1.ClassStereotype.Library ||
+            targetUmlClass.stereotype === umlClass_1.ClassStereotype.Interface) &&
+        sourceUmlClass.memberAccessCalls?.size > 0 &&
+        targetUmlClass.operators?.length > 0) {
+        const targetOperatorNames = new Set(targetUmlClass.operators.map((op) => op.name));
+        for (const callName of sourceUmlClass.memberAccessCalls) {
+            if (targetOperatorNames.has(callName)) {
+                names.add(callName);
+            }
+        }
+    }
+    return [...names].sort();
+}
 //# sourceMappingURL=converterClasses2Dot.js.map

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");
@@ -630,10 +629,10 @@ const isElementary = (type) => {
 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) => {
@@ -791,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/parserEtherscan.js

@@ -192,14 +192,29 @@ class EtherscanParser {
         const description = `get verified source code for address ${contractAddress} from Etherscan API.`;
         try {
             debug(`About to get Solidity source code for ${contractAddress} from ${this.url}`);
-            const response = await axios_1.default.get(this.url, {
-                params: {
-                    module: 'contract',
-                    action: 'getsourcecode',
-                    address: contractAddress,
-                    apikey: this.apiKey,
-                },
-            });
+            let response;
+            const maxRetries = 3;
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                response = await axios_1.default.get(this.url, {
+                    params: {
+                        module: 'contract',
+                        action: 'getsourcecode',
+                        address: contractAddress,
+                        apikey: this.apiKey,
+                    },
+                });
+                // Retry on rate limit errors
+                if (!Array.isArray(response?.data?.result) &&
+                    typeof response?.data?.result === 'string' &&
+                    response.data.result.includes('rate limit') &&
+                    attempt < maxRetries) {
+                    const delay = attempt * 2000;
+                    debug(`Rate limited on attempt ${attempt}. Retrying in ${delay}ms...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
+                break;
+            }
             if (!Array.isArray(response?.data?.result)) {
                 throw new Error(`Failed to ${description}. No result array in HTTP data: ${JSON.stringify(response?.data)}`);
             }

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
+    // 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

@@ -34,7 +34,7 @@ Can also flatten or compare verified source files on Etherscan-like explorers.`)
     parserEtherscan_1.networks.join(', '))
     .default('ethereum')
     .env('ETH_NETWORK'))
-    .addOption(new commander_1.Option('-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'))
+    .addOption(new commander_1.Option('-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'))
     .addOption(new commander_1.Option('-k, --apiKey <key>', 'Blockchain explorer API key.').env('SCAN_API_KEY'))
     .option('-bc, --backColor <color>', 'Canvas background color. "none" will use a transparent canvas.', 'white')
     .option('-sc, --shapeColor <color>', 'Basic drawing color for graphics, not text', 'black')
@@ -61,6 +61,7 @@ program
     .option('-c, --clusterFolders', 'cluster contracts into source folders', false)
     .option('-hv, --hideVariables', 'hide variables from contracts, interfaces, structs and enums', false)
     .option('-hf, --hideFunctions', 'hide functions from contracts, interfaces and libraries', false)
+    .option('-hy, --hideTypes', 'hide types of variables, function arguments and return types', false)
     .option('-hp, --hidePrivates', 'hide private and internal attributes and operators', false)
     .option('-hm, --hideModifiers', 'hide modifier functions from contracts', false)
     .option('-ht, --hideEvents', 'hide events from contracts, interfaces and libraries', false)
@@ -72,6 +73,7 @@ program
     .option('-hi, --hideInterfaces', 'hide interfaces', false)
     .option('-ha, --hideAbstracts', 'hide abstract contracts', false)
     .option('-hn, --hideFilename', 'hide relative path and file name', false)
+    .option('-hd, --hideDepFunctions', 'hide function names on dependency arrows', false)
     .option('-s, --squash', 'squash inherited contracts to the base contract(s)', false)
     .option('-hsc, --hideSourceContract', 'hide the source contract when using squash', false)
     .action(async (fileFolderAddress, options, command) => {

package/lib/squashClasses.js

@@ -117,6 +117,12 @@ const recursiveSquash = (squashedClass, inheritedContractNames, baseClass, umlCl
     baseClass.enums.forEach((e) => squashedClass.enums.push(e));
     baseClass.structs.forEach((s) => squashedClass.structs.push(s));
     baseClass.imports.forEach((i) => squashedClass.imports.push(i));
+    // Merge memberAccessCalls for cross-referencing function names on dependency arrows
+    if (baseClass.memberAccessCalls?.size > 0) {
+        for (const call of baseClass.memberAccessCalls) {
+            squashedClass.memberAccessCalls.add(call);
+        }
+    }
     // copy the functions
     baseClass.operators.forEach((f) => squashedClass.operators.push({
         ...f,

package/lib/umlClass.d.ts

@@ -69,6 +69,7 @@ export interface Association {
     parentUmlClassName?: string;
     targetUmlClassName: string;
     realization?: boolean;
+    functionsCalled?: string[];
 }
 export interface Constants {
     name: string;
@@ -108,6 +109,7 @@ export declare class UmlClass implements ClassProperties {
     associations: {
         [name: string]: Association;
     };
+    memberAccessCalls: Set<string>;
     constructor(properties: ClassProperties);
     addAssociation(association: Association): void;
     /**

package/lib/umlClass.js

@@ -52,6 +52,8 @@ class UmlClass {
         this.enums = [];
         this.structs = [];
         this.associations = {};
+        // Tracks all member access function call names for cross-referencing with using...for libraries
+        this.memberAccessCalls = new Set();
         if (!properties || !properties.name) {
             throw TypeError(`Failed to instantiate UML Class with no name property`);
         }
@@ -73,6 +75,20 @@ class UmlClass {
             if (association.referenceType === ReferenceType.Storage) {
                 this.associations[association.targetUmlClassName].referenceType = ReferenceType.Storage;
             }
+            // Merge functionsCalled arrays with deduplication
+            if (association.functionsCalled?.length) {
+                const existing = this.associations[association.targetUmlClassName];
+                if (!existing.functionsCalled) {
+                    existing.functionsCalled = [...association.functionsCalled];
+                }
+                else {
+                    for (const fn of association.functionsCalled) {
+                        if (!existing.functionsCalled.includes(fn)) {
+                            existing.functionsCalled.push(fn);
+                        }
+                    }
+                }
+            }
         }
     }
     /**

package/lib/utils/block.js

@@ -6,7 +6,7 @@ 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;

package/lib/utils/validators.js

@@ -3,13 +3,13 @@ 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 { /* validation failed */ }
     throw new commander_1.InvalidArgumentError(`Address must be in hexadecimal format with a 0x prefix.`);
@@ -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,

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 { /* 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.23",
+  "version": "2.5.25",
   "description": "Solidity contract visualisation tool.",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -29,26 +29,27 @@
     "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",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "jest": "^30.0.0",
-    "prettier": "^3.5.3",
-    "ts-jest": "^29.4.0",
+    "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": [