sol2uml 2.5.23 → 2.5.24

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/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/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/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.24",
   "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": [