sol2uml 2.0.4 → 2.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Nick Addison
+Copyright (c) 2022 Nick Addison
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,17 +2,19 @@
 
 [![npm version](https://badge.fury.io/js/sol2uml.svg)](https://badge.fury.io/js/sol2uml)
 
-[Unified Modeling Language (UML)](https://en.wikipedia.org/wiki/Unified_Modeling_Language) [class diagram](https://en.wikipedia.org/wiki/Class_diagram) generator for [Solidity](https://solidity.readthedocs.io/) contracts.
+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.
+2. Contract storage layout diagrams.
 
-Open Zeppelin's ERC20 token contracts generated from [version 2.5.1](https://github.com/OpenZeppelin/openzeppelin-solidity/tree/v2.5.1/contracts/token/ERC20)
+UML class diagram of Open Zeppelin's ERC20 token contracts generated from [version 2.5.1](https://github.com/OpenZeppelin/openzeppelin-solidity/tree/v2.5.1/contracts/token/ERC20)
 ![Open Zeppelin ERC20](./examples/OpenZeppelinERC20.svg)
 
 See more contract diagrams [here](./examples/README.md).
 
-USDC storage slots from the [verified source code](https://etherscan.io/address/0xa2327a938febf5fec13bacfb16ae10ecbc4cbdcf#code) on Etherscan.
-![USDC](./examples/storage/usdc.png)
+Storage layout diagram of USDC's [verified source code](https://etherscan.io/address/0xa2327a938febf5fec13bacfb16ae10ecbc4cbdcf#code) on Etherscan.
+![USDC](./examples/storage/usdcData.svg)
 
-See more storage slot diagrams [here](./examples/storage/README.md).
+See more contract storage diagram examples [here](./examples/storage/README.md).
 
 # Install
 
@@ -112,15 +114,19 @@ Usage: sol2uml storage [options] <fileFolderAddress>
 
 Visually display a contract's storage slots.
 
-WARNING: sol2uml does not use the Solidity compiler so may differ with solc. A known example is storage arrays declared with a constant, immutable or expression will show as only taking one slot but it could be more. Storage arrays declared with an integer work.
+WARNING: sol2uml does not use the Solidity compiler so may differ with solc. A known example is fixed-sized arrays declared with an expression will fail to be sized.
 
 Arguments:
-  fileFolderAddress           file name, base folder or contract address
+  fileFolderAddress        file name, base folder or contract address
 
 Options:
-  -c, --contractName <value>  Contract name in local Solidity files. Not needed when using an address as the first argument.
-  -h, --help                  display help for command
-
+  -c, --contract <name>    Contract name in local Solidity files. Not needed when using an address as the first argument as the contract name can be derived from Etherscan.
+  -d, --data               Gets the values in the storage slots from an Ethereum node. (default: false)
+  -s, --storage <address>  The address of the contract with the storage values. This will be different from the contract with the code if a proxy contract is used. This is not needed if `fileFolderAddress` is an address and
+                           the contract is not proxied.
+  -u, --url <url>          URL of the Ethereum node to get storage values if the `data` option is used. (default: "http://localhost:8545", env: NODE_URL)
+  -bn, --block <number>    Block number to get the contract storage values from. (default: "latest")
+  -h, --help               display help for command
 ```
 
 ### Flatten usage

package/lib/associations.d.ts

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

package/lib/associations.js

@@ -1,31 +1,75 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findAssociatedClass = void 0;
+const umlClass_1 = require("./umlClass");
 // Find the UML class linked to the association
 const findAssociatedClass = (association, sourceUmlClass, umlClasses) => {
-    return umlClasses.find((targetUmlClass) => {
-        return (
-        // class is in the same source file
+    let umlClass = umlClasses.find((targetUmlClass) => {
+        // is the source class link via the association to the target class?
+        if (isAssociated(association, sourceUmlClass, targetUmlClass))
+            return true;
+        // Not linked so now try linking to target under the node_modules folder.
+        // eg remove node_modules from node_modules/@openzeppelin/contracts-upgradeable/proxy/Initializable.sol
+        // is the target class under node_modules?
+        if (targetUmlClass.relativePath.match(/^node_modules\//)) {
+            // clone the target and updated absolutePath and relativePath so it's no longer under node_modules
+            const clonedTargetClass = new umlClass_1.UmlClass(targetUmlClass);
+            clonedTargetClass.absolutePath =
+                targetUmlClass.absolutePath.replace(/^node_modules\//, '');
+            clonedTargetClass.relativePath =
+                targetUmlClass.relativePath.replace(/^node_modules\//, '');
+            // is the source class link via the association to the target class?
+            return isAssociated(association, sourceUmlClass, clonedTargetClass);
+        }
+        // could not find a link from the source to target via the association
+        return false;
+    });
+    // If a link was found
+    if (umlClass)
+        return umlClass;
+    // Could not find a link so now need to recursively look at imports of imports
+    return findImplicitImport(association, sourceUmlClass, umlClasses);
+};
+exports.findAssociatedClass = findAssociatedClass;
+// Tests if source class can be linked to the target class via an association
+const isAssociated = (association, sourceUmlClass, targetUmlClass) => {
+    return (
+    // class is in the same source file
+    (association.targetUmlClassName === targetUmlClass.name &&
+        sourceUmlClass.absolutePath === targetUmlClass.absolutePath) ||
+        // imported classes with no explicit import names
         (association.targetUmlClassName === targetUmlClass.name &&
-            sourceUmlClass.absolutePath === targetUmlClass.absolutePath) ||
-            // imported classes with no explicit import names
-            (association.targetUmlClassName === targetUmlClass.name &&
-                sourceUmlClass.imports.find((i) => i.absolutePath === targetUmlClass.absolutePath &&
-                    i.classNames.length === 0)) ||
-            // imported classes with explicit import names or import aliases
             sourceUmlClass.imports.find((i) => i.absolutePath === targetUmlClass.absolutePath &&
-                i.classNames.find((importedClass) => 
-                // no import alias
+                i.classNames.length === 0)) ||
+        // imported classes with explicit import names or import aliases
+        sourceUmlClass.imports.find((i) => i.absolutePath === targetUmlClass.absolutePath &&
+            i.classNames.find((importedClass) => 
+            // no import alias
+            (association.targetUmlClassName ===
+                importedClass.className &&
+                importedClass.className === targetUmlClass.name &&
+                importedClass.alias == undefined) ||
+                // import alias
                 (association.targetUmlClassName ===
-                    importedClass.className &&
-                    importedClass.className ===
-                        targetUmlClass.name &&
-                    importedClass.alias == undefined) ||
-                    // import alias
-                    (association.targetUmlClassName ===
-                        importedClass.alias &&
-                        importedClass.className === targetUmlClass.name))));
-    });
+                    importedClass.alias &&
+                    importedClass.className === targetUmlClass.name))));
+};
+const findImplicitImport = (association, sourceUmlClass, umlClasses) => {
+    // Get all implicit imports. That is, imports that do not explicitly import contracts or interfaces.
+    const implicitImports = sourceUmlClass.imports.filter((i) => i.classNames.length === 0);
+    // For each implicit import
+    for (const importDetail of implicitImports) {
+        // 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;
+        }
+        // TODO need to handle imports that use aliases as the association will not be found
+        const umlClass = (0, exports.findAssociatedClass)(association, newSourceUmlClass, umlClasses);
+        if (umlClass)
+            return umlClass;
+    }
+    return undefined;
 };
-exports.findAssociatedClass = findAssociatedClass;
 //# sourceMappingURL=associations.js.map

package/lib/converterAST2Classes.js

@@ -98,7 +98,9 @@ function convertAST2UmlClasses(node, relativePath, filesystem = false) {
                 }
                 else {
                     // this has come from Etherscan
-                    const importPath = path.join(codeFolder, childNode.path);
+                    const importPath = childNode.path[0] === '@'
+                        ? childNode.path
+                        : path.join(codeFolder, childNode.path);
                     imports.push({
                         absolutePath: importPath,
                         classNames: childNode.symbolAliases
@@ -172,6 +174,16 @@ function parseContractDefinition(umlClass, node) {
                     attributeType,
                     compiled: valueStore,
                 });
+                // Is the variable a constant that could be used in declaring fixed sized arrays
+                if (variable.isDeclaredConst) {
+                    if (variable?.expression?.type === 'NumberLiteral') {
+                        umlClass.constants.push({
+                            name: variable.name,
+                            value: parseInt(variable.expression.number),
+                        });
+                    }
+                    // TODO handle expressions. eg N_COINS * 2
+                }
             });
             // Recursively parse variables for associations
             umlClass = addAssociations(subNode.variables, umlClass);

package/lib/converterClasses2Storage.d.ts

@@ -1,29 +1,48 @@
 import { Attribute, UmlClass } from './umlClass';
 export declare enum StorageType {
-    Contract = 0,
-    Struct = 1
+    Contract = "Contract",
+    Struct = "Struct",
+    Array = "Array"
 }
-export interface Storage {
+export interface Variable {
     id: number;
     fromSlot: number;
     toSlot: number;
     byteSize: number;
     byteOffset: number;
     type: string;
-    variable: string;
+    dynamic: boolean;
+    variable?: string;
     contractName?: string;
+    noValue: boolean;
     value?: string;
-    structObjectId?: number;
+    referenceStorageId?: number;
     enumId?: number;
 }
-export interface StorageObject {
+export interface Storage {
     id: number;
     name: string;
     address?: string;
+    slotKey?: string;
     type: StorageType;
-    storages: Storage[];
+    arrayLength?: number;
+    arrayDynamic?: boolean;
+    variables: Variable[];
 }
-export declare const convertClasses2StorageObjects: (contractName: string, umlClasses: UmlClass[]) => StorageObject[];
-export declare const parseStructStorageObject: (attribute: Attribute, otherClasses: UmlClass[], storageObjects: StorageObject[]) => StorageObject | undefined;
-export declare const calcStorageByteSize: (attribute: Attribute, umlClass: UmlClass, otherClasses: UmlClass[]) => number;
+/**
+ *
+ * @param url
+ * @param contractAddress Contract address to get the storage slot values from
+ * @param storage is mutated with the storage values
+ */
+export declare const addStorageValues: (url: string, contractAddress: string, storage: Storage, blockTag: string) => Promise<void>;
+export declare const convertClasses2Storages: (contractName: string, umlClasses: UmlClass[]) => Storage[];
+export declare const parseReferenceStorage: (attribute: Attribute, umlClass: UmlClass, otherClasses: UmlClass[], storages: Storage[]) => Storage | undefined;
+export declare const calcStorageByteSize: (attribute: Attribute, umlClass: UmlClass, otherClasses: UmlClass[]) => {
+    size: number;
+    dynamic: boolean;
+};
 export declare const isElementary: (type: string) => boolean;
+export declare const calcSlotKey: (variable: Variable) => string | undefined;
+export declare const offsetStorageSlots: (storage: Storage, slots: number, storages: Storage[]) => void;
+export declare const findDimensionLength: (umlClass: UmlClass, dimension: string) => number;

package/lib/converterClasses2Storage.js

@@ -1,16 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isElementary = exports.calcStorageByteSize = exports.parseStructStorageObject = exports.convertClasses2StorageObjects = exports.StorageType = void 0;
+exports.findDimensionLength = exports.offsetStorageSlots = exports.calcSlotKey = exports.isElementary = exports.calcStorageByteSize = exports.parseReferenceStorage = exports.convertClasses2Storages = exports.addStorageValues = exports.StorageType = void 0;
 const umlClass_1 = require("./umlClass");
 const associations_1 = require("./associations");
+const slotValues_1 = require("./slotValues");
+const utils_1 = require("ethers/lib/utils");
+const ethers_1 = require("ethers");
 var StorageType;
 (function (StorageType) {
-    StorageType[StorageType["Contract"] = 0] = "Contract";
-    StorageType[StorageType["Struct"] = 1] = "Struct";
+    StorageType["Contract"] = "Contract";
+    StorageType["Struct"] = "Struct";
+    StorageType["Array"] = "Array";
 })(StorageType = exports.StorageType || (exports.StorageType = {}));
-let storageObjectId = 1;
 let storageId = 1;
-const convertClasses2StorageObjects = (contractName, umlClasses) => {
+let variableId = 1;
+/**
+ *
+ * @param url
+ * @param contractAddress Contract address to get the storage slot values from
+ * @param storage is mutated with the storage values
+ */
+const addStorageValues = async (url, contractAddress, storage, blockTag) => {
+    const valueVariables = storage.variables.filter((s) => !s.noValue);
+    const slots = valueVariables.map((s) => s.fromSlot);
+    const values = await (0, slotValues_1.getStorageValues)(url, contractAddress, slots, blockTag);
+    valueVariables.forEach((storage, i) => {
+        storage.value = values[i];
+    });
+};
+exports.addStorageValues = addStorageValues;
+const convertClasses2Storages = (contractName, umlClasses) => {
     // Find the base UML Class from the base contract name
     const umlClass = umlClasses.find(({ name }) => {
         return name === contractName;
@@ -18,25 +37,25 @@ const convertClasses2StorageObjects = (contractName, umlClasses) => {
     if (!umlClass) {
         throw Error(`Failed to find contract with name "${contractName}"`);
     }
-    const storageObjects = [];
-    const storages = parseStorage(umlClass, umlClasses, [], storageObjects, []);
-    storageObjects.unshift({
-        id: storageObjectId++,
+    const storages = [];
+    const variables = parseVariables(umlClass, umlClasses, [], storages, []);
+    storages.unshift({
+        id: storageId++,
         name: contractName,
         type: StorageType.Contract,
-        storages,
+        variables: variables,
     });
-    return storageObjects;
+    return storages;
 };
-exports.convertClasses2StorageObjects = convertClasses2StorageObjects;
+exports.convertClasses2Storages = convertClasses2Storages;
 /**
- * Recursively parses the storage for a given contract.
+ * Recursively parses the storage variables for a given contract.
  * @param umlClass contract or file level struct
  * @param umlClasses other contracts, structs and enums that may be a type of a storage variable.
- * @param storages mutable array of storage slots that is appended to
- * @param storageObjects mutable array of StorageObjects that is appended with structs
+ * @param variables mutable array of storage slots that is appended to
+ * @param storages mutable array of storages that is appended with structs
  */
-const parseStorage = (umlClass, umlClasses, storages, storageObjects, inheritedContracts) => {
+const parseVariables = (umlClass, umlClasses, variables, storages, inheritedContracts) => {
     // Add storage slots from inherited contracts first.
     // Get immediate parent contracts that the class inherits from
     const parentContracts = umlClass.getParentContracts();
@@ -47,65 +66,145 @@ const parseStorage = (umlClass, umlClasses, storages, storageObjects, inheritedC
     // Recursively parse each new inherited contract
     newInheritedContracts.forEach((parent) => {
         const parentClass = (0, associations_1.findAssociatedClass)(parent, umlClass, umlClasses);
-        if (!parentClass)
-            throw Error(`Failed to find parent contract ${parent.targetUmlClassName} of ${umlClass.absolutePath}`);
+        if (!parentClass) {
+            throw Error(`Failed to find inherited contract "${parent.targetUmlClassName}" of "${umlClass.absolutePath}"`);
+        }
         // recursively parse inherited contract
-        parseStorage(parentClass, umlClasses, storages, storageObjects, inheritedContracts);
+        parseVariables(parentClass, umlClasses, variables, storages, inheritedContracts);
     });
     // Parse storage for each attribute
     umlClass.attributes.forEach((attribute) => {
         // Ignore any attributes that are constants or immutable
         if (attribute.compiled)
             return;
-        const byteSize = (0, exports.calcStorageByteSize)(attribute, umlClass, umlClasses);
-        // find any dependent structs
-        const linkedStruct = (0, exports.parseStructStorageObject)(attribute, umlClasses, storageObjects);
-        const structObjectId = linkedStruct?.id;
+        const { size: byteSize, dynamic } = (0, exports.calcStorageByteSize)(attribute, umlClass, umlClasses);
+        const noValue = attribute.attributeType === umlClass_1.AttributeType.Mapping ||
+            (attribute.attributeType === umlClass_1.AttributeType.Array && !dynamic);
+        // find any dependent storage locations
+        const referenceStorage = (0, exports.parseReferenceStorage)(attribute, umlClass, umlClasses, storages);
         // Get the toSlot of the last storage item
         let lastToSlot = 0;
         let nextOffset = 0;
-        if (storages.length > 0) {
-            const lastStorage = storages[storages.length - 1];
+        if (variables.length > 0) {
+            const lastStorage = variables[variables.length - 1];
             lastToSlot = lastStorage.toSlot;
             nextOffset = lastStorage.byteOffset + lastStorage.byteSize;
         }
+        let newVariable;
         if (nextOffset + byteSize > 32) {
-            const nextFromSlot = storages.length > 0 ? lastToSlot + 1 : 0;
-            storages.push({
-                id: storageId++,
+            const nextFromSlot = variables.length > 0 ? lastToSlot + 1 : 0;
+            newVariable = {
+                id: variableId++,
                 fromSlot: nextFromSlot,
                 toSlot: nextFromSlot + Math.floor((byteSize - 1) / 32),
                 byteSize,
                 byteOffset: 0,
                 type: attribute.type,
+                dynamic,
+                noValue,
                 variable: attribute.name,
                 contractName: umlClass.name,
-                structObjectId,
-            });
+                referenceStorageId: referenceStorage?.id,
+            };
         }
         else {
-            storages.push({
-                id: storageId++,
+            newVariable = {
+                id: variableId++,
                 fromSlot: lastToSlot,
                 toSlot: lastToSlot,
                 byteSize,
                 byteOffset: nextOffset,
                 type: attribute.type,
+                dynamic,
+                noValue,
                 variable: attribute.name,
                 contractName: umlClass.name,
-                structObjectId,
-            });
+                referenceStorageId: referenceStorage?.id,
+            };
+        }
+        if (referenceStorage) {
+            if (!newVariable.dynamic) {
+                (0, exports.offsetStorageSlots)(referenceStorage, newVariable.fromSlot, storages);
+            }
+            else if (attribute.attributeType === umlClass_1.AttributeType.Array) {
+                referenceStorage.slotKey = (0, exports.calcSlotKey)(newVariable);
+            }
         }
+        variables.push(newVariable);
     });
-    return storages;
+    return variables;
 };
-const parseStructStorageObject = (attribute, otherClasses, storageObjects) => {
-    if (attribute.attributeType === umlClass_1.AttributeType.UserDefined) {
-        // Have we already created the storageObject?
-        const existingStorageObject = storageObjects.find((dep) => dep.name === attribute.type);
-        if (existingStorageObject) {
-            return existingStorageObject;
+const parseReferenceStorage = (attribute, umlClass, otherClasses, storages) => {
+    if (attribute.attributeType === umlClass_1.AttributeType.Array) {
+        // storage is dynamic if the attribute type ends in []
+        const result = attribute.type.match(/\[(\w*)]$/);
+        const dynamic = result[1] === '';
+        const arrayLength = !dynamic
+            ? (0, exports.findDimensionLength)(umlClass, result[1])
+            : undefined;
+        // get the type of the array items. eg
+        // address[][4][2] will have base type address[][4]
+        const baseType = attribute.type.substring(0, attribute.type.lastIndexOf('['));
+        let baseAttributeType;
+        if ((0, exports.isElementary)(baseType)) {
+            baseAttributeType = umlClass_1.AttributeType.Elementary;
+        }
+        else if (baseType[baseType.length - 1] === ']') {
+            baseAttributeType = umlClass_1.AttributeType.Array;
+        }
+        else {
+            baseAttributeType = umlClass_1.AttributeType.UserDefined;
+        }
+        const baseAttribute = {
+            visibility: attribute.visibility,
+            name: baseType,
+            type: baseType,
+            attributeType: baseAttributeType,
+        };
+        const { size: arrayItemSize } = (0, exports.calcStorageByteSize)(baseAttribute, umlClass, otherClasses);
+        const slotSize = arrayItemSize > 16 ? 32 : arrayItemSize;
+        const firstVariable = {
+            id: variableId++,
+            fromSlot: 0,
+            toSlot: Math.floor((slotSize - 1) / 32),
+            byteSize: arrayItemSize,
+            byteOffset: 0,
+            type: baseType,
+            dynamic,
+            noValue: false,
+        };
+        const variables = [firstVariable];
+        if (arrayLength > 1) {
+            for (let i = 1; i < arrayLength; i++) {
+                variables.push({
+                    id: variableId++,
+                    fromSlot: Math.floor((i * slotSize) / 32),
+                    toSlot: Math.floor(((i + 1) * slotSize - 1) / 32),
+                    byteSize: arrayItemSize,
+                    byteOffset: (i * slotSize) % 32,
+                    type: baseType,
+                    dynamic,
+                    noValue: false,
+                });
+            }
         }
+        // recursively add storage
+        if (baseAttributeType !== umlClass_1.AttributeType.Elementary) {
+            const referenceStorage = (0, exports.parseReferenceStorage)(baseAttribute, umlClass, otherClasses, storages);
+            firstVariable.referenceStorageId = referenceStorage?.id;
+        }
+        const newStorage = {
+            id: storageId++,
+            name: `${attribute.type}: ${attribute.name}`,
+            type: StorageType.Array,
+            arrayDynamic: dynamic,
+            arrayLength,
+            variables,
+        };
+        storages.push(newStorage);
+        return newStorage;
+    }
+    if (attribute.attributeType === umlClass_1.AttributeType.UserDefined) {
         // Is the user defined type linked to another Contract, Struct or Enum?
         const dependentClass = otherClasses.find(({ name }) => {
             return (name === attribute.type || name === attribute.type.split('.')[1]);
@@ -114,103 +213,118 @@ const parseStructStorageObject = (attribute, otherClasses, storageObjects) => {
             throw Error(`Failed to find user defined type "${attribute.type}"`);
         }
         if (dependentClass.stereotype === umlClass_1.ClassStereotype.Struct) {
-            const storages = parseStorage(dependentClass, otherClasses, [], storageObjects, []);
-            const newStorageObject = {
-                id: storageObjectId++,
+            const variables = parseVariables(dependentClass, otherClasses, [], storages, []);
+            const newStorage = {
+                id: storageId++,
                 name: attribute.type,
                 type: StorageType.Struct,
-                storages,
+                variables,
             };
-            storageObjects.push(newStorageObject);
-            return newStorageObject;
+            storages.push(newStorage);
+            return newStorage;
         }
         return undefined;
     }
-    if (attribute.attributeType === umlClass_1.AttributeType.Mapping ||
-        attribute.attributeType === umlClass_1.AttributeType.Array) {
-        // get the UserDefined type from the mapping or array
+    if (attribute.attributeType === umlClass_1.AttributeType.Mapping) {
+        // get the UserDefined type from the mapping
         // note the mapping could be an array of Structs
         // Could also be a mapping of a mapping
-        const result = attribute.attributeType === umlClass_1.AttributeType.Mapping
-            ? attribute.type.match(/=\\>((?!mapping)\w*)[\\[]/)
-            : attribute.type.match(/(\w+)\[/);
+        const result = attribute.type.match(/=\\>((?!mapping)\w*)[\\[]/);
+        // If mapping of user defined type
         if (result !== null && result[1] && !(0, exports.isElementary)(result[1])) {
-            // Have we already created the storageObject?
-            const existingStorageObject = storageObjects.find(({ name }) => name === result[1] || name === result[1].split('.')[1]);
-            if (existingStorageObject) {
-                return existingStorageObject;
-            }
             // Find UserDefined type
             const typeClass = otherClasses.find(({ name }) => name === result[1] || name === result[1].split('.')[1]);
             if (!typeClass) {
                 throw Error(`Failed to find user defined type "${result[1]}" in attribute type "${attribute.type}"`);
             }
             if (typeClass.stereotype === umlClass_1.ClassStereotype.Struct) {
-                const storages = parseStorage(typeClass, otherClasses, [], storageObjects, []);
-                const newStorageObject = {
-                    id: storageObjectId++,
+                const variables = parseVariables(typeClass, otherClasses, [], storages, []);
+                const newStorage = {
+                    id: storageId++,
                     name: typeClass.name,
                     type: StorageType.Struct,
-                    storages,
+                    variables,
                 };
-                storageObjects.push(newStorageObject);
-                return newStorageObject;
+                storages.push(newStorage);
+                return newStorage;
             }
         }
         return undefined;
     }
     return undefined;
 };
-exports.parseStructStorageObject = parseStructStorageObject;
+exports.parseReferenceStorage = parseReferenceStorage;
 // Calculates the storage size of an attribute in bytes
 const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
     if (attribute.attributeType === umlClass_1.AttributeType.Mapping ||
         attribute.attributeType === umlClass_1.AttributeType.Function) {
-        return 32;
+        return { size: 32, dynamic: true };
     }
     if (attribute.attributeType === umlClass_1.AttributeType.Array) {
-        // All array dimensions must be fixed. eg [2][3][8].
-        const result = attribute.type.match(/(\w+)(\[([1-9][0-9]*)\])+$/);
-        // The above will not match any dynamic array dimensions, eg [],
-        // as there needs to be one or more [0-9]+ in the square brackets
-        if (result === null) {
-            // Any dynamic array dimension means the whole array is dynamic
-            // so only takes 32 bytes (1 slot)
-            return 32;
+        // Fixed sized arrays are read from right to left until there is a dynamic dimension
+        // eg address[][3][2] is a fixed size array that uses 6 slots.
+        // while address [2][] is a dynamic sized array.
+        const arrayDimensions = attribute.type.match(/\[\w*]/g);
+        // Remove first [ and last ] from each arrayDimensions
+        const dimensionsStr = arrayDimensions.map((a) => a.slice(1, -1));
+        // fixed-sized arrays are read from right to left so reverse the dimensions
+        const dimensionsStrReversed = dimensionsStr.reverse();
+        // read fixed-size dimensions until we get a dynamic array with no dimension
+        let dimension = dimensionsStrReversed.shift();
+        const fixedDimensions = [];
+        while (dimension && dimension !== '') {
+            const dimensionNum = (0, exports.findDimensionLength)(umlClass, dimension);
+            fixedDimensions.push(dimensionNum);
+            // read the next dimension for the next loop
+            dimension = dimensionsStrReversed.shift();
+        }
+        // If the first dimension is dynamic, ie []
+        if (fixedDimensions.length === 0) {
+            // dynamic arrays start at the keccak256 of the slot number
+            // the array length is stored in the 32 byte slot
+            return { size: 32, dynamic: true };
         }
-        // All array dimensions are fixes so we now need to multiply all the dimensions
-        // to get a total number of array elements
-        const arrayDimensions = attribute.type.match(/\[\d+/g);
-        const dimensionsStr = arrayDimensions.map((d) => d.slice(1));
-        const dimensions = dimensionsStr.map((d) => parseInt(d));
         let elementSize;
+        const type = attribute.type.substring(0, attribute.type.indexOf('['));
         // If a fixed sized array
-        if ((0, exports.isElementary)(result[1])) {
+        if ((0, exports.isElementary)(type)) {
             const elementAttribute = {
                 attributeType: umlClass_1.AttributeType.Elementary,
-                type: result[1],
+                type,
                 name: 'element',
             };
-            elementSize = (0, exports.calcStorageByteSize)(elementAttribute, umlClass, otherClasses);
+            ({ size: elementSize } = (0, exports.calcStorageByteSize)(elementAttribute, umlClass, otherClasses));
         }
         else {
             const elementAttribute = {
                 attributeType: umlClass_1.AttributeType.UserDefined,
-                type: result[1],
+                type,
                 name: 'userDefined',
             };
-            elementSize = (0, exports.calcStorageByteSize)(elementAttribute, umlClass, otherClasses);
+            ({ size: elementSize } = (0, exports.calcStorageByteSize)(elementAttribute, umlClass, otherClasses));
         }
         // Anything over 16 bytes, like an address, will take a whole 32 byte slot
         if (elementSize > 16 && elementSize < 32) {
             elementSize = 32;
         }
-        const firstDimensionBytes = elementSize * dimensions[0];
-        const firstDimensionSlotBytes = Math.ceil(firstDimensionBytes / 32) * 32;
-        const remainingElements = dimensions
-            .slice(1)
+        // If multi dimension, then the first element is 32 bytes
+        if (fixedDimensions.length < arrayDimensions.length) {
+            const totalDimensions = fixedDimensions.reduce((total, dimension) => total * dimension, 1);
+            return {
+                size: 32 * totalDimensions,
+                dynamic: false,
+            };
+        }
+        const lastItem = fixedDimensions.length - 1;
+        const lastDimensionBytes = elementSize * fixedDimensions[lastItem];
+        const lastDimensionSlotBytes = Math.ceil(lastDimensionBytes / 32) * 32;
+        const remainingDimensions = fixedDimensions
+            .slice(0, lastItem)
             .reduce((total, dimension) => total * dimension, 1);
-        return firstDimensionSlotBytes * remainingElements;
+        return {
+            size: lastDimensionSlotBytes * remainingDimensions,
+            dynamic: false,
+        };
     }
     // If a Struct or Enum
     if (attribute.attributeType === umlClass_1.AttributeType.UserDefined) {
@@ -223,12 +337,12 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
         }
         switch (attributeClass.stereotype) {
             case umlClass_1.ClassStereotype.Enum:
-                return 1;
+                return { size: 1, dynamic: false };
             case umlClass_1.ClassStereotype.Contract:
             case umlClass_1.ClassStereotype.Abstract:
             case umlClass_1.ClassStereotype.Interface:
             case umlClass_1.ClassStereotype.Library:
-                return 20;
+                return { size: 20, dynamic: false };
             case umlClass_1.ClassStereotype.Struct:
                 let structByteSize = 0;
                 attributeClass.attributes.forEach((structAttribute) => {
@@ -253,7 +367,7 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
                             structByteSize = Math.ceil(structByteSize / 32) * 32;
                         }
                     }
-                    const attributeSize = (0, exports.calcStorageByteSize)(structAttribute, umlClass, otherClasses);
+                    const { size: attributeSize } = (0, exports.calcStorageByteSize)(structAttribute, umlClass, otherClasses);
                     // check if attribute will fit into the remaining slot
                     const endCurrentSlot = Math.ceil(structByteSize / 32) * 32;
                     const spaceLeftInSlot = endCurrentSlot - structByteSize;
@@ -265,24 +379,27 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
                     }
                 });
                 // structs take whole 32 byte slots so round up to the nearest 32 sized slots
-                return Math.ceil(structByteSize / 32) * 32;
+                return {
+                    size: Math.ceil(structByteSize / 32) * 32,
+                    dynamic: false,
+                };
             default:
-                return 32;
+                return { size: 32, dynamic: false };
         }
     }
     if (attribute.attributeType === umlClass_1.AttributeType.Elementary) {
         switch (attribute.type) {
             case 'bool':
-                return 1;
+                return { size: 1, dynamic: false };
             case 'address':
-                return 20;
+                return { size: 20, dynamic: false };
             case 'string':
             case 'bytes':
             case 'uint':
             case 'int':
             case 'ufixed':
             case 'fixed':
-                return 32;
+                return { size: 32, dynamic: false };
             default:
                 const result = attribute.type.match(/[u]*(int|fixed|bytes)([0-9]+)/);
                 if (result === null || !result[2]) {
@@ -290,12 +407,12 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
                 }
                 // If bytes
                 if (result[1] === 'bytes') {
-                    return parseInt(result[2]);
+                    return { size: parseInt(result[2]), dynamic: false };
                 }
                 // TODO need to handle fixed types when they are supported
                 // If an int
                 const bitSize = parseInt(result[2]);
-                return bitSize / 8;
+                return { size: bitSize / 8, dynamic: false };
         }
     }
     throw new Error(`Failed to calc bytes size of attribute with name "${attribute.name}" and type ${attribute.type}`);
@@ -318,4 +435,44 @@ const isElementary = (type) => {
     }
 };
 exports.isElementary = isElementary;
+const calcSlotKey = (variable) => {
+    if (variable.dynamic) {
+        return (0, utils_1.keccak256)((0, utils_1.toUtf8Bytes)(ethers_1.BigNumber.from(variable.fromSlot).toHexString()));
+    }
+    return ethers_1.BigNumber.from(variable.fromSlot).toHexString();
+};
+exports.calcSlotKey = calcSlotKey;
+// recursively offset the slots numbers of a storage item
+const offsetStorageSlots = (storage, slots, storages) => {
+    storage.variables.forEach((variable) => {
+        variable.fromSlot += slots;
+        variable.toSlot += slots;
+        if (variable.referenceStorageId) {
+            // recursively offset the referenced storage
+            const referenceStorage = storages.find((s) => s.id === variable.referenceStorageId);
+            if (!referenceStorage.arrayDynamic) {
+                (0, exports.offsetStorageSlots)(referenceStorage, slots, storages);
+            }
+            else {
+                referenceStorage.slotKey = (0, exports.calcSlotKey)(variable);
+            }
+        }
+    });
+};
+exports.offsetStorageSlots = offsetStorageSlots;
+const findDimensionLength = (umlClass, dimension) => {
+    const dimensionNum = parseInt(dimension);
+    if (Number.isInteger(dimensionNum)) {
+        return dimensionNum;
+    }
+    else {
+        // Try and size array dimension from declared constants
+        const constant = umlClass.constants.find((constant) => constant.name === dimension);
+        if (!constant) {
+            throw Error(`Could not size fixed sized array with dimension "${dimension}"`);
+        }
+        return constant.value;
+    }
+};
+exports.findDimensionLength = findDimensionLength;
 //# sourceMappingURL=converterClasses2Storage.js.map

package/lib/converterStorage2Dot.d.ts

@@ -1,3 +1,7 @@
-import { StorageObject } from './converterClasses2Storage';
-export declare const convertStorage2Dot: (storageObjects: StorageObject[]) => string;
-export declare function convertStorageObject2Dot(storageObject: StorageObject, dotString: string): string;
+import { Storage } from './converterClasses2Storage';
+export declare const convertStorages2Dot: (storages: Storage[], options: {
+    data: boolean;
+}) => string;
+export declare function convertStorage2Dot(storage: Storage, dotString: string, options: {
+    data: boolean;
+}): string;

package/lib/converterStorage2Dot.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertStorageObject2Dot = exports.convertStorage2Dot = void 0;
+exports.convertStorage2Dot = exports.convertStorages2Dot = void 0;
 const converterClasses2Storage_1 = require("./converterClasses2Storage");
 const debug = require('debug')('sol2uml');
-const convertStorage2Dot = (storageObjects) => {
+const convertStorages2Dot = (storages, options) => {
     let dotString = `
 digraph StorageDiagram {
 rankdir=LR
 color=black
 arrowhead=open
-node [shape=record, style=filled, fillcolor=gray95]`;
-    // process contract and the struct objects
-    storageObjects.forEach((storageObject) => {
-        dotString = convertStorageObject2Dot(storageObject, dotString);
+node [shape=record, style=filled, fillcolor=gray95 fontname="Courier New"]`;
+    // process contract and the struct storages
+    storages.forEach((storage) => {
+        dotString = convertStorage2Dot(storage, dotString, options);
     });
     // link contract and structs to structs
-    storageObjects.forEach((slot) => {
-        slot.storages.forEach((storage) => {
-            if (storage.structObjectId) {
-                dotString += `\n ${slot.id}:${storage.id} -> ${storage.structObjectId}`;
+    storages.forEach((slot) => {
+        slot.variables.forEach((storage) => {
+            if (storage.referenceStorageId) {
+                dotString += `\n ${slot.id}:${storage.id} -> ${storage.referenceStorageId}`;
             }
         });
     });
@@ -27,63 +27,74 @@ node [shape=record, style=filled, fillcolor=gray95]`;
     debug(dotString);
     return dotString;
 };
-exports.convertStorage2Dot = convertStorage2Dot;
-function convertStorageObject2Dot(storageObject, dotString) {
-    const steorotype = storageObject.type === converterClasses2Storage_1.StorageType.Struct ? 'Struct' : 'Contract';
-    // write object header with name and optional address
-    dotString += `\n${storageObject.id} [label="{\\<\\<${steorotype}\\>\\>\\n${storageObject.name}\\n${storageObject.address || ''} | `;
+exports.convertStorages2Dot = convertStorages2Dot;
+function convertStorage2Dot(storage, dotString, options) {
+    // write storage header with name and optional address
+    dotString += `\n${storage.id} [label="${storage.name} \\<\\<${storage.type}\\>\\>\\n${storage.address || storage.slotKey || ''}`;
+    dotString += ' | {';
+    const startingVariables = storage.variables.filter((s) => s.byteOffset === 0);
     // write slot numbers
-    storageObject.storages.forEach((storage, i) => {
-        if (i === 0) {
-            dotString += `{slot | 0`;
+    dotString += '{ slot';
+    startingVariables.forEach((variable, i) => {
+        if (variable.fromSlot === variable.toSlot) {
+            dotString += `| ${variable.fromSlot} `;
         }
-        else if (storage.byteOffset === 0) {
-            if (storage.fromSlot === storage.toSlot) {
-                dotString += `| ${storage.fromSlot}`;
-            }
-            else {
-                dotString += `| ${storage.fromSlot}-${storage.toSlot}`;
-            }
+        else {
+            dotString += `| ${variable.fromSlot}-${variable.toSlot} `;
         }
     });
-    // write storage types
-    storageObject.storages.forEach((storage, i) => {
-        const lastStorage = i > 0 ? storageObject.storages[i - 1] : undefined;
-        const nextStorage = i + 1 < storageObject.storages.length
-            ? storageObject.storages[i + 1]
-            : undefined;
-        if (i === 0) {
-            const contractVaraiblePrefix = storageObject.type === converterClasses2Storage_1.StorageType.Contract
-                ? '\\<inherited contract\\>.'
-                : '';
-            dotString += `} | {type: ${contractVaraiblePrefix}variable (bytes) `;
-        }
-        // if next storage is in the same slot
-        // and storage is the first in the slot
-        if (nextStorage?.fromSlot === storage.fromSlot &&
-            storage.byteOffset === 0) {
-            dotString += `| { ${dotVariable(storage, storageObject.name)} `;
-            return;
-        }
-        // if last storage was on the same slot
-        // and the next storage is on a different slot
-        if (lastStorage?.fromSlot === storage.fromSlot &&
-            (nextStorage?.fromSlot > storage.fromSlot ||
-                nextStorage === undefined)) {
-            dotString += `| ${dotVariable(storage, storageObject.name)} } `;
-            return;
+    // write slot values if available
+    if (options.data) {
+        dotString += '} | {value';
+        startingVariables.forEach((variable, i) => {
+            dotString += ` | ${variable.value || ''}`;
+        });
+    }
+    const contractVariablePrefix = storage.type === converterClasses2Storage_1.StorageType.Contract ? '\\<inherited contract\\>.' : '';
+    dotString += `} | { type: ${contractVariablePrefix}variable (bytes)`;
+    // For each slot
+    startingVariables.forEach((variable) => {
+        // Get all the storage variables in this slot
+        const slotVariables = storage.variables.filter((s) => s.fromSlot === variable.fromSlot);
+        const usedBytes = slotVariables.reduce((acc, s) => acc + s.byteSize, 0);
+        if (usedBytes < 32) {
+            // Create an unallocated variable for display purposes
+            slotVariables.push({
+                id: 0,
+                fromSlot: variable.fromSlot,
+                toSlot: variable.fromSlot,
+                byteSize: 32 - usedBytes,
+                byteOffset: usedBytes,
+                type: 'unallocated',
+                dynamic: false,
+                noValue: true,
+                contractName: variable.contractName,
+                variable: '',
+            });
         }
-        // If storage covers a whole slot or is not at the start or end of a slot
-        dotString += `| ${dotVariable(storage, storageObject.name)} `;
+        const slotVariablesReversed = slotVariables.reverse();
+        // For each variable in the slot
+        slotVariablesReversed.forEach((variable, i) => {
+            if (i === 0) {
+                dotString += ` | { ${dotVariable(variable, storage.name)} `;
+            }
+            else {
+                dotString += ` | ${dotVariable(variable, storage.name)} `;
+            }
+        });
+        dotString += '}';
     });
     // Need to close off the last label
     dotString += '}}"]\n';
     return dotString;
 }
-exports.convertStorageObject2Dot = convertStorageObject2Dot;
+exports.convertStorage2Dot = convertStorage2Dot;
 const dotVariable = (storage, contractName) => {
-    const port = storage.structObjectId !== undefined ? `<${storage.id}>` : '';
+    const port = storage.referenceStorageId !== undefined ? `<${storage.id}>` : '';
     const contractNamePrefix = storage.contractName !== contractName ? `${storage.contractName}.` : '';
-    return `${port} ${storage.type}: ${contractNamePrefix}${storage.variable} (${storage.byteSize})`;
+    const variable = storage.variable
+        ? `: ${contractNamePrefix}${storage.variable}`
+        : '';
+    return `${port} ${storage.type}${variable} (${storage.byteSize})`;
 };
 //# sourceMappingURL=converterStorage2Dot.js.map

package/lib/parserEtherscan.js

@@ -71,7 +71,14 @@ class EtherscanParser {
         const { files, contractName } = await this.getSourceCode(contractAddress);
         let solidityCode = '';
         files.forEach((file) => {
-            solidityCode += file.code;
+            // comment out any import statements
+            // match whitespace before import
+            // and characters after import up to ;
+            // replace all in file and match across multiple lines
+            const removedImports = file.code.replace(/(\s)(import.*;)/gm, '$1/* $2 */');
+            // Rename SPDX-License-Identifier to SPDX--License-Identifier so the merged file will compile
+            const removedSPDX = removedImports.replace(/SPDX-/, 'SPDX--');
+            solidityCode += removedSPDX;
         });
         return {
             solidityCode,

package/lib/slotValues.d.ts

@@ -0,0 +1,3 @@
+import { BigNumberish } from '@ethersproject/bignumber';
+export declare const getStorageValue: (url: string, contractAddress: string, slot: BigNumberish, blockTag?: BigNumberish | 'latest') => Promise<string>;
+export declare const getStorageValues: (url: string, contractAddress: string, slots: BigNumberish[], blockTag?: BigNumberish | 'latest') => Promise<string[]>;

package/lib/slotValues.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorageValues = exports.getStorageValue = void 0;
+const bignumber_1 = require("@ethersproject/bignumber");
+const axios_1 = __importDefault(require("axios"));
+const debug = require('debug')('sol2uml');
+const getStorageValue = async (url, contractAddress, slot, blockTag = 'latest') => {
+    debug(`About to get storage slot ${slot} value for ${contractAddress}`);
+    const values = await (0, exports.getStorageValues)(url, contractAddress, [slot], blockTag);
+    debug(`Got slot ${slot} value: ${values[0]}`);
+    return values[0];
+};
+exports.getStorageValue = getStorageValue;
+let jsonRpcId = 0;
+const getStorageValues = async (url, contractAddress, slots, blockTag = 'latest') => {
+    try {
+        debug(`About to get ${slots.length} storage values for ${contractAddress} at block ${blockTag}`);
+        const block = blockTag === 'latest'
+            ? blockTag
+            : bignumber_1.BigNumber.from(blockTag).toHexString();
+        const payload = slots.map((slot) => ({
+            id: (jsonRpcId++).toString(),
+            jsonrpc: '2.0',
+            method: 'eth_getStorageAt',
+            params: [
+                contractAddress,
+                bignumber_1.BigNumber.from(slot).toHexString(),
+                block,
+            ],
+        }));
+        const response = await axios_1.default.post(url, payload);
+        console.log(response.data);
+        if (response.data?.error?.message) {
+            throw new Error(response.data.error.message);
+        }
+        if (response.data.length !== slots.length) {
+            throw new Error(`Requested ${slots.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);
+        return sortedResponses.map((data) => '0x' + data.result.toUpperCase().slice(2));
+    }
+    catch (err) {
+        throw new Error(`Failed to get ${slots.length} storage values for ${contractAddress} from ${url}`, { cause: err });
+    }
+};
+exports.getStorageValues = getStorageValues;
+//# sourceMappingURL=slotValues.js.map

package/lib/sol2uml.js

@@ -39,8 +39,9 @@ The Solidity code can be pulled from verified source code on Blockchain explorer
     'goerli',
     'sepolia',
 ])
-    .default('mainnet'))
-    .option('-k, --apiKey <key>', 'Etherscan, Polygonscan, BscScan or Arbiscan API key')
+    .default('mainnet')
+    .env('ETH_NETWORK'))
+    .addOption(new commander_1.Option('-k, --apiKey <key>', 'Etherscan, Polygonscan, BscScan or Arbiscan API key').env('SCAN_API_KEY'))
     .option('-v, --verbose', 'run with debugging statements', false);
 program
     .command('class', { isDefault: true })
@@ -75,26 +76,32 @@ If an Ethereum address with a 0x prefix is passed, the verified source code from
             ...command.parent._optionValues,
             ...options,
         };
-        const { umlClasses } = await (0, parserGeneral_1.parserUmlClasses)(fileFolderAddress, combinedOptions);
+        let { umlClasses, contractName } = await (0, parserGeneral_1.parserUmlClasses)(fileFolderAddress, combinedOptions);
         let filteredUmlClasses = umlClasses;
         if (options.baseContractNames) {
             const baseContractNames = options.baseContractNames.split(',');
             filteredUmlClasses = (0, filterClasses_1.classesConnectedToBaseContracts)(umlClasses, baseContractNames, options.depth);
+            contractName = baseContractNames[0];
         }
         const dotString = (0, converterClasses2Dot_1.convertUmlClasses2Dot)(filteredUmlClasses, combinedOptions.clusterFolders, combinedOptions);
-        await (0, writerFiles_1.writeOutputFiles)(dotString, fileFolderAddress, combinedOptions.outputFormat, combinedOptions.outputFileName);
+        await (0, writerFiles_1.writeOutputFiles)(dotString, fileFolderAddress, contractName || 'classDiagram', combinedOptions.outputFormat, combinedOptions.outputFileName);
         debug(`Finished generating UML`);
     }
     catch (err) {
-        console.error(`Failed to generate UML diagram ${err}`);
+        console.error(`Failed to generate UML diagram\n${err.stack}`);
     }
 });
 program
     .command('storage')
-    .description("Visually display a contract's storage slots.\n\nWARNING: sol2uml does not use the Solidity compiler so may differ with solc. A known example is storage arrays declared with a constant, immutable or expression will show as only taking one slot but it could be more. Storage arrays declared with an integer work.")
+    .description("Visually display a contract's storage slots.\n\nWARNING: sol2uml does not use the Solidity compiler so may differ with solc. A known example is fixed-sized arrays declared with an expression will fail to be sized.")
     .argument('<fileFolderAddress>', 'file name, base folder or contract address')
-    .option('-c, --contractName <value>', 'Contract name in local Solidity files. Not needed when using an address as the first argument.')
-    // .option('-d, --data', 'gets the data in the storage slots')
+    .option('-c, --contract <name>', 'Contract name in local Solidity files. Not needed when using an address as the first argument as the contract name can be derived from Etherscan.')
+    .option('-d, --data', 'Gets the values in the storage slots from an Ethereum node.', false)
+    .option('-s, --storage <address>', 'The address of the contract with the storage values. This will be different from the contract with the code if a proxy contract is used. This is not needed if `fileFolderAddress` is an address and the contract is not proxied.')
+    .addOption(new commander_1.Option('-u, --url <url>', 'URL of the Ethereum node to get storage values if the `data` option is used.')
+    .env('NODE_URL')
+    .default('http://localhost:8545'))
+    .option('-bn, --block <number>', 'Block number to get the contract storage values from.', 'latest')
     .action(async (fileFolderAddress, options, command) => {
     try {
         const combinedOptions = {
@@ -102,18 +109,36 @@ program
             ...options,
         };
         let { umlClasses, contractName } = await (0, parserGeneral_1.parserUmlClasses)(fileFolderAddress, combinedOptions);
-        contractName = combinedOptions.contractName || contractName;
-        const storageObjects = (0, converterClasses2Storage_1.convertClasses2StorageObjects)(contractName, umlClasses);
+        contractName = combinedOptions.contract || contractName;
+        const storages = (0, converterClasses2Storage_1.convertClasses2Storages)(contractName, umlClasses);
         if ((0, regEx_1.isAddress)(fileFolderAddress)) {
-            // The first object is the contract
-            storageObjects[0].address = fileFolderAddress;
+            // The first storage is the contract
+            storages[0].address = fileFolderAddress;
+        }
+        debug(storages);
+        if (combinedOptions.data) {
+            let storageAddress = combinedOptions.storage;
+            if (storageAddress) {
+                if (!(0, regEx_1.isAddress)(storageAddress)) {
+                    throw Error(`Invalid address to get storage data from "${storageAddress}"`);
+                }
+            }
+            else {
+                if (!(0, regEx_1.isAddress)(fileFolderAddress)) {
+                    throw Error(`Can not get storage slot values if first param is not an address and the \`address\` option is not used.`);
+                }
+                storageAddress = fileFolderAddress;
+            }
+            const storage = storages.find((so) => so.name === contractName);
+            if (!storageAddress)
+                throw Error(`Could not find the "${contractName}" contract in list of parsed storages`);
+            await (0, converterClasses2Storage_1.addStorageValues)(combinedOptions.url, storageAddress, storage, combinedOptions.blockNumber);
         }
-        debug(storageObjects);
-        const dotString = (0, converterStorage2Dot_1.convertStorage2Dot)(storageObjects);
-        await (0, writerFiles_1.writeOutputFiles)(dotString, fileFolderAddress, contractName, combinedOptions.outputFormat, combinedOptions.outputFileName);
+        const dotString = (0, converterStorage2Dot_1.convertStorages2Dot)(storages, combinedOptions);
+        await (0, writerFiles_1.writeOutputFiles)(dotString, fileFolderAddress, contractName || 'storageDiagram', combinedOptions.outputFormat, combinedOptions.outputFileName);
     }
     catch (err) {
-        console.error(`Failed to generate storage diagram ${err}`);
+        console.error(`Failed to generate storage diagram.\n${err.stack}`);
     }
 });
 program
@@ -121,16 +146,21 @@ program
     .description('get all verified source code for a contract from the Blockchain explorer into one local file')
     .argument('<contractAddress>', 'Contract address')
     .action(async (contractAddress, options, command) => {
-    debug(`About to flatten ${contractAddress}`);
-    const combinedOptions = {
-        ...command.parent._optionValues,
-        ...options,
-    };
-    const etherscanParser = new parserEtherscan_1.EtherscanParser(combinedOptions.apiKey, combinedOptions.network);
-    const { solidityCode, contractName } = await etherscanParser.getSolidityCode(contractAddress);
-    // Write Solidity to the contract address
-    const outputFilename = combinedOptions.outputFileName || contractName;
-    await (0, writerFiles_1.writeSolidity)(solidityCode, outputFilename);
+    try {
+        debug(`About to flatten ${contractAddress}`);
+        const combinedOptions = {
+            ...command.parent._optionValues,
+            ...options,
+        };
+        const etherscanParser = new parserEtherscan_1.EtherscanParser(combinedOptions.apiKey, combinedOptions.network);
+        const { solidityCode, contractName } = await etherscanParser.getSolidityCode(contractAddress);
+        // Write Solidity to the contract address
+        const outputFilename = combinedOptions.outputFileName || contractName;
+        await (0, writerFiles_1.writeSolidity)(solidityCode, outputFilename);
+    }
+    catch (err) {
+        console.error(`Failed to flatten files.\n${err.stack}`);
+    }
 });
 program.on('option:verbose', () => {
     debugControl.enable('sol2uml');

package/lib/umlClass.d.ts

@@ -63,6 +63,10 @@ export interface Association {
     targetUmlClassStereotype?: ClassStereotype;
     realization?: boolean;
 }
+export interface Constants {
+    name: string;
+    value: number;
+}
 export interface ClassProperties {
     name: string;
     absolutePath: string;
@@ -76,6 +80,7 @@ export interface ClassProperties {
     associations?: {
         [name: string]: Association;
     };
+    constants?: Constants[];
 }
 export declare class UmlClass implements ClassProperties {
     static idCounter: number;
@@ -83,8 +88,9 @@ export declare class UmlClass implements ClassProperties {
     name: string;
     absolutePath: string;
     relativePath: string;
-    imports?: Import[];
+    imports: Import[];
     stereotype?: ClassStereotype;
+    constants: Constants[];
     attributes: Attribute[];
     operators: Operator[];
     enums: number[];

package/lib/umlClass.js

@@ -43,6 +43,7 @@ var ReferenceType;
 })(ReferenceType = exports.ReferenceType || (exports.ReferenceType = {}));
 class UmlClass {
     constructor(properties) {
+        this.constants = [];
         this.attributes = [];
         this.operators = [];
         this.enums = [];

package/lib/writerFiles.d.ts

@@ -2,6 +2,6 @@ export declare type OutputFormats = 'svg' | 'png' | 'dot' | 'all';
 export declare const writeOutputFiles: (dot: string, fileFolderAddress: string, contractName: string, outputFormat?: OutputFormats, outputFilename?: string) => Promise<void>;
 export declare function convertDot2Svg(dot: string): any;
 export declare function writeSolidity(code: string, filename?: string): void;
-export declare function writeDot(dot: string, filename?: string): void;
+export declare function writeDot(dot: string, filename: string): void;
 export declare function writeSVG(svg: any, svgFilename?: string, outputFormats?: OutputFormats): Promise<void>;
 export declare function writePng(svg: any, filename: string): Promise<void>;

package/lib/writerFiles.js

@@ -10,13 +10,6 @@ const sync_1 = __importDefault(require("@aduh95/viz.js/sync"));
 const { convert } = require('convert-svg-to-png');
 const debug = require('debug')('sol2uml');
 const writeOutputFiles = async (dot, fileFolderAddress, contractName, outputFormat = 'svg', outputFilename) => {
-    if (outputFormat === 'dot' || outputFormat === 'all') {
-        writeDot(dot, outputFilename);
-        // No need to continue if only generating a dot file
-        if (outputFormat === 'dot') {
-            return;
-        }
-    }
     // If all output then extension is svg
     const outputExt = outputFormat === 'all' ? 'svg' : outputFormat;
     if (!outputFilename) {
@@ -36,6 +29,13 @@ const writeOutputFiles = async (dot, fileFolderAddress, contractName, outputForm
         }
         catch (err) { } // we can ignore errors as it just means outputFilename does not exist yet
     }
+    if (outputFormat === 'dot' || outputFormat === 'all') {
+        writeDot(dot, outputFilename);
+        // No need to continue if only generating a dot file
+        if (outputFormat === 'dot') {
+            return;
+        }
+    }
     const svg = convertDot2Svg(dot);
     if (outputFormat === 'svg' || outputFormat === 'all') {
         await writeSVG(svg, outputFilename, outputFormat);
@@ -73,18 +73,16 @@ function writeSolidity(code, filename = 'solidity') {
     });
 }
 exports.writeSolidity = writeSolidity;
-function writeDot(dot, filename = 'classDiagram.dot') {
-    const extension = path_1.default.extname(filename);
-    const outputFile = extension === '.dot' ? filename : filename + '.dot';
-    debug(`About to write Dot file to ${outputFile}`);
-    (0, fs_1.writeFile)(outputFile, dot, (err) => {
+function writeDot(dot, filename) {
+    debug(`About to write Dot file to ${filename}`);
+    (0, fs_1.writeFile)(filename, dot, (err) => {
         if (err) {
-            throw new Error(`Failed to write Dot file to ${outputFile}`, {
+            throw new Error(`Failed to write Dot file to ${filename}`, {
                 cause: err,
             });
         }
         else {
-            console.log(`Dot file written to ${outputFile}`);
+            console.log(`Dot file written to ${filename}`);
         }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol2uml",
-  "version": "2.0.4",
+  "version": "2.1.1",
   "description": "Unified Modeling Language (UML) class diagram generator for Solidity contracts",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",