sol2uml 2.0.3 → 2.1.0

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

@@ -20,16 +20,19 @@ The following installation assumes [Node.js](https://nodejs.org/en/download/) ha
 `sol2uml` works with node 14 or above.
 
 To install globally so you can run `sol2uml` from anywhere
+
 ```bash
 npm link sol2uml --only=production
 ```
 
 To upgrade run
+
 ```bash
 npm upgrade sol2uml -g
 ```
 
 To see which version you are using
+
 ```bash
 npm ls sol2uml -g
 ```
@@ -109,15 +112,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
@@ -139,36 +146,43 @@ Options:
 ## UML Class diagram examples
 
 To generate a diagram of all contracts under the contracts folder and its sub folders
+
 ```bash
 sol2uml class ./contracts
 ```
 
 To generate a diagram of EtherDelta's contract from the verified source code on [Etherscan](https://etherscan.io/address/0x8d12A197cB00D4747a1fe03395095ce2A5CC6819#code). The output wil be a svg file `0x8d12A197cB00D4747a1fe03395095ce2A5CC6819.svg` in the working folder.
+
 ```bash
 sol2uml class 0x8d12A197cB00D4747a1fe03395095ce2A5CC6819
 ```
 
 To generate a diagram of EtherDelta's contract from the verified source code on [Etherscan Ropsten](https://ropsten.etherscan.io/address/0xa19833bd291b66aB0E17b9C6d46D2Ec5fEC15190#code). The output wil be a svg file `0xa19833bd291b66aB0E17b9C6d46D2Ec5fEC15190.svg` in the working folder.
+
 ```bash
 sol2uml class 0xa19833bd291b66aB0E17b9C6d46D2Ec5fEC15190 -n ropsten
 ```
 
 To generate all Solidity files under some root folder and output the svg file to a specific location
+
 ```bash
 sol2uml class path/to/contracts/root/folder -o ./outputFile.svg
 ```
 
 To generate a diagram of all contracts in a single Solidity file, the output file in png format to output file `./someFile.png`
+
 ```bash
 sol2uml class path/to/contracts/root/folder/solidity/file.sol -f png -o ./someFile.png
 ```
 
-To generate a diagram of all Solidity files under the `contracts` and `node_modules/openzeppelin-solidity` folders.  The output will be `contracts.svg` and `contracts.png` files in the working folder.
+To generate a diagram of all Solidity files under the `contracts` and `node_modules/openzeppelin-solidity` folders. The output will be `contracts.svg` and `contracts.png` files in the working folder.
+
 ```bash
 sol2uml class ./contracts,node_modules/openzeppelin-solidity -f all -v
 ```
 
 To generate a diagram of all Solidity files under the working folder ignoring and files under the `solparse`, `@solidity-parser` and `ethlint` folders, which will be under the `node_modules` folder.
+
 ```bash
 sol2uml class -i solparse,@solidity-parser,ethlint
 ```
@@ -176,8 +190,9 @@ sol2uml class -i solparse,@solidity-parser,ethlint
 # UML Class Diagram Syntax
 
 Good online resources for learning UML
-* [UML 2 Class Diagramming Guidelines](http://www.agilemodeling.com/style/classDiagram.htm)
-* [Creating class diagrams with UML](https://www.ionos.com/digitalguide/websites/web-development/class-diagrams-with-uml/)
+
+-   [UML 2 Class Diagramming Guidelines](http://www.agilemodeling.com/style/classDiagram.htm)
+-   [Creating class diagrams with UML](https://www.ionos.com/digitalguide/websites/web-development/class-diagrams-with-uml/)
 
 ## Terminology differences
 
@@ -187,33 +202,35 @@ A Solidity variable becomes an attribute in UML and a Solidity function becomes
 
 ### Class stereotypes
 
-* Interface
-* Abstract - if any of the contract's functions are abstract, the class will have an Abstract stereotype. Child contracts of abstract contracts that do not implement all the abstract functions are currently not marked as Abstract.
-* Library
+-   Interface
+-   Abstract - if any of the contract's functions are abstract, the class will have an Abstract stereotype. Child contracts of abstract contracts that do not implement all the abstract functions are currently not marked as Abstract.
+-   Library
 
 ### Operator stereotypes
 
-* event
-* modifier
-* abstract - if there is no function body on a contract, the operator is marked as abstract. Operators on an Interface do not have an abstract stereotype as all operators are abstract.
-* fallback - abstract fallback functions will just have an abstract stereotype.
-* payable - payable fallback functions will just have a fallback stereotype.
+-   event
+-   modifier
+-   abstract - if there is no function body on a contract, the operator is marked as abstract. Operators on an Interface do not have an abstract stereotype as all operators are abstract.
+-   fallback - abstract fallback functions will just have an abstract stereotype.
+-   payable - payable fallback functions will just have a fallback stereotype.
 
 ## UML Associations
 
 Lines:
-- Solid lines for
-    - link the contract types of storage (state) variables. This can be linked to contracts, interfaces, libraries or file level structs and enums.
-    - generalisations of contracts and abstract contracts.
-    - aggregated contract level structs and enums.
-- Dashed lines for
-    - generalisations of interfaces.
-    - types of memory variables.
+
+-   Solid lines for
+    -   link the contract types of storage (state) variables. This can be linked to contracts, interfaces, libraries or file level structs and enums.
+    -   generalisations of contracts and abstract contracts.
+    -   aggregated contract level structs and enums.
+-   Dashed lines for
+    -   generalisations of interfaces.
+    -   types of memory variables.
 
 Heads/Tails:
-- An empty triangle head for generalisations of contracts, interfaces and abstract contracts.
-- An open arrow head for storage or memory variable dependencies
-- A diamond tail for aggregations of contract level structs and enums
+
+-   An empty triangle head for generalisations of contracts, interfaces and abstract contracts.
+-   An open arrow head for storage or memory variable dependencies
+-   A diamond tail for aggregations of contract level structs and enums
 
 ## Storage diagram
 

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

@@ -3,7 +3,7 @@ export declare enum StorageType {
     Contract = 0,
     Struct = 1
 }
-export interface Storage {
+export interface Variable {
     id: number;
     fromSlot: number;
     toSlot: number;
@@ -12,18 +12,25 @@ export interface Storage {
     type: string;
     variable: string;
     contractName?: string;
-    value?: string;
-    structObjectId?: number;
+    values: string[];
+    structStorageId?: number;
     enumId?: number;
 }
-export interface StorageObject {
+export interface Storage {
     id: number;
     name: string;
     address?: string;
     type: StorageType;
-    storages: Storage[];
+    variables: Variable[];
 }
-export declare const convertClasses2StorageObjects: (contractName: string, umlClasses: UmlClass[]) => StorageObject[];
-export declare const parseStructStorageObject: (attribute: Attribute, otherClasses: UmlClass[], storageObjects: StorageObject[]) => StorageObject | undefined;
+/**
+ *
+ * @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 parseStructStorage: (attribute: Attribute, otherClasses: UmlClass[], storages: Storage[]) => Storage | undefined;
 export declare const calcStorageByteSize: (attribute: Attribute, umlClass: UmlClass, otherClasses: UmlClass[]) => number;
 export declare const isElementary: (type: string) => boolean;

package/lib/converterClasses2Storage.js

@@ -1,16 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isElementary = exports.calcStorageByteSize = exports.parseStructStorageObject = exports.convertClasses2StorageObjects = exports.StorageType = void 0;
+exports.isElementary = exports.calcStorageByteSize = exports.parseStructStorage = exports.convertClasses2Storages = exports.addStorageValues = exports.StorageType = void 0;
 const umlClass_1 = require("./umlClass");
 const associations_1 = require("./associations");
+const slotValues_1 = require("./slotValues");
 var StorageType;
 (function (StorageType) {
     StorageType[StorageType["Contract"] = 0] = "Contract";
     StorageType[StorageType["Struct"] = 1] = "Struct";
 })(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 slots = storage.variables.map((s) => s.fromSlot);
+    const values = await (0, slotValues_1.getStorageValues)(url, contractAddress, slots, blockTag);
+    storage.variables.forEach((storage, i) => {
+        storage.values = [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 +33,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();
@@ -50,7 +65,7 @@ const parseStorage = (umlClass, umlClasses, storages, storageObjects, inheritedC
         if (!parentClass)
             throw Error(`Failed to find parent 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) => {
@@ -59,20 +74,20 @@ const parseStorage = (umlClass, umlClasses, storages, storageObjects, inheritedC
             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 linkedStruct = (0, exports.parseStructStorage)(attribute, umlClasses, storages);
+        const structStorageId = linkedStruct?.id;
         // 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;
         }
         if (nextOffset + byteSize > 32) {
-            const nextFromSlot = storages.length > 0 ? lastToSlot + 1 : 0;
-            storages.push({
-                id: storageId++,
+            const nextFromSlot = variables.length > 0 ? lastToSlot + 1 : 0;
+            variables.push({
+                id: variableId++,
                 fromSlot: nextFromSlot,
                 toSlot: nextFromSlot + Math.floor((byteSize - 1) / 32),
                 byteSize,
@@ -80,12 +95,13 @@ const parseStorage = (umlClass, umlClasses, storages, storageObjects, inheritedC
                 type: attribute.type,
                 variable: attribute.name,
                 contractName: umlClass.name,
-                structObjectId,
+                structStorageId,
+                values: [],
             });
         }
         else {
-            storages.push({
-                id: storageId++,
+            variables.push({
+                id: variableId++,
                 fromSlot: lastToSlot,
                 toSlot: lastToSlot,
                 byteSize,
@@ -93,18 +109,19 @@ const parseStorage = (umlClass, umlClasses, storages, storageObjects, inheritedC
                 type: attribute.type,
                 variable: attribute.name,
                 contractName: umlClass.name,
-                structObjectId,
+                structStorageId,
+                values: [],
             });
         }
     });
-    return storages;
+    return variables;
 };
-const parseStructStorageObject = (attribute, otherClasses, storageObjects) => {
+const parseStructStorage = (attribute, otherClasses, storages) => {
     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;
+        // Have we already created the storage?
+        const existingStorage = storages.find((dep) => dep.name === attribute.type);
+        if (existingStorage) {
+            return existingStorage;
         }
         // Is the user defined type linked to another Contract, Struct or Enum?
         const dependentClass = otherClasses.find(({ name }) => {
@@ -114,15 +131,15 @@ 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;
     }
@@ -135,10 +152,10 @@ const parseStructStorageObject = (attribute, otherClasses, storageObjects) => {
             ? attribute.type.match(/=\\>((?!mapping)\w*)[\\[]/)
             : attribute.type.match(/(\w+)\[/);
         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;
+            // Have we already created the storage?
+            const existingStorage = storages.find(({ name }) => name === result[1] || name === result[1].split('.')[1]);
+            if (existingStorage) {
+                return existingStorage;
             }
             // Find UserDefined type
             const typeClass = otherClasses.find(({ name }) => name === result[1] || name === result[1].split('.')[1]);
@@ -146,22 +163,22 @@ const parseStructStorageObject = (attribute, otherClasses, storageObjects) => {
                 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.parseStructStorage = parseStructStorage;
 // Calculates the storage size of an attribute in bytes
 const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
     if (attribute.attributeType === umlClass_1.AttributeType.Mapping ||
@@ -170,7 +187,7 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
     }
     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]*)\])+$/);
+        const result = attribute.type.match(/(\w+)(\[([\w][\w]*)\])+$/);
         // 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) {
@@ -180,9 +197,19 @@ const calcStorageByteSize = (attribute, umlClass, otherClasses) => {
         }
         // 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 arrayDimensions = attribute.type.match(/\[\w+/g);
         const dimensionsStr = arrayDimensions.map((d) => d.slice(1));
-        const dimensions = dimensionsStr.map((d) => parseInt(d));
+        const dimensions = dimensionsStr.map((dimension) => {
+            const dimensionNum = parseInt(dimension);
+            if (!isNaN(dimensionNum))
+                return dimensionNum;
+            // Try and size array dimension from declared constants
+            const constant = umlClass.constants.find((constant) => constant.name === dimension);
+            if (constant) {
+                return constant.value;
+            }
+            throw Error(`Could not size fixed sized array with dimension "${dimension}"`);
+        });
         let elementSize;
         // If a fixed sized array
         if ((0, exports.isElementary)(result[1])) {

package/lib/converterStorage2Dot.d.ts

@@ -1,3 +1,3 @@
-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[]) => string;
+export declare function convertStorage2Dot(storage: Storage, dotString: string): 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) => {
     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);
+    // process contract and the struct storages
+    storages.forEach((storage) => {
+        dotString = convertStorage2Dot(storage, dotString);
     });
     // 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.structStorageId) {
+                dotString += `\n ${slot.id}:${storage.id} -> ${storage.structStorageId}`;
             }
         });
     });
@@ -27,63 +27,72 @@ 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) {
+    const steorotype = storage.type === converterClasses2Storage_1.StorageType.Struct ? 'Struct' : 'Contract';
+    // write storage header with name and optional address
+    dotString += `\n${storage.id} [label="${storage.name} \\<\\<${steorotype}\\>\\>\\n${storage.address || ''} | {`;
+    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 (startingVariables[0]?.values[0]) {
+        dotString += '} | {value';
+        startingVariables.forEach((variable, i) => {
+            dotString += ` | ${variable.values[0]}`;
+        });
+    }
+    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) {
+            slotVariables.push({
+                id: 0,
+                fromSlot: variable.fromSlot,
+                toSlot: variable.fromSlot,
+                byteSize: 32 - usedBytes,
+                byteOffset: usedBytes,
+                type: 'unallocated',
+                contractName: variable.contractName,
+                variable: '',
+                values: [],
+            });
         }
-        // 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.structStorageId !== 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/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) => data.result);
+    }
+    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

@@ -75,14 +75,14 @@ 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);
+        const { 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);
         }
         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, combinedOptions.outputFormat, combinedOptions.outputFileName);
         debug(`Finished generating UML`);
     }
     catch (err) {
@@ -91,25 +91,49 @@ If an Ethereum address with a 0x prefix is passed, the verified source code from
 });
 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 = {
             ...command.parent._optionValues,
             ...options,
         };
-        const { umlClasses, contractName } = await (0, parserGeneral_1.parserUmlClasses)(fileFolderAddress, combinedOptions);
-        const storageObjects = (0, converterClasses2Storage_1.convertClasses2StorageObjects)(combinedOptions.contractName || contractName, umlClasses);
+        let { umlClasses, contractName } = await (0, parserGeneral_1.parserUmlClasses)(fileFolderAddress, combinedOptions);
+        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, combinedOptions.outputFormat, combinedOptions.outputFileName);
+        const dotString = (0, converterStorage2Dot_1.convertStorages2Dot)(storages);
+        await (0, writerFiles_1.writeOutputFiles)(dotString, fileFolderAddress, contractName, combinedOptions.outputFormat, combinedOptions.outputFileName);
     }
     catch (err) {
         console.error(`Failed to generate storage diagram ${err}`);

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;
@@ -85,6 +90,7 @@ export declare class UmlClass implements ClassProperties {
     relativePath: string;
     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

@@ -1,7 +1,7 @@
 export declare type OutputFormats = 'svg' | 'png' | 'dot' | 'all';
-export declare const writeOutputFiles: (dot: string, outputBaseName: string, outputFormat?: OutputFormats, outputFilename?: string) => Promise<void>;
+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

@@ -9,7 +9,26 @@ const path_1 = __importDefault(require("path"));
 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, outputBaseName, outputFormat = 'svg', outputFilename) => {
+const writeOutputFiles = async (dot, fileFolderAddress, contractName, outputFormat = 'svg', outputFilename) => {
+    // If all output then extension is svg
+    const outputExt = outputFormat === 'all' ? 'svg' : outputFormat;
+    if (!outputFilename) {
+        outputFilename =
+            path_1.default.join(process.cwd(), contractName) + '.' + outputExt;
+    }
+    else {
+        // check if outputFilename is a folder
+        try {
+            const folderOrFile = (0, fs_1.lstatSync)(outputFilename);
+            if (folderOrFile.isDirectory()) {
+                outputFilename =
+                    path_1.default.join(process.cwd(), outputFilename, contractName) +
+                        '.' +
+                        outputExt;
+            }
+        }
+        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
@@ -17,20 +36,6 @@ const writeOutputFiles = async (dot, outputBaseName, outputFormat = 'svg', outpu
             return;
         }
     }
-    if (!outputFilename) {
-        // If all output then extension is svg
-        const outputExt = outputFormat === 'all' ? 'svg' : outputFormat;
-        // if outputBaseName is a folder
-        try {
-            const folderOrFile = (0, fs_1.lstatSync)(outputBaseName);
-            if (folderOrFile.isDirectory()) {
-                const parsedDir = path_1.default.parse(process.cwd());
-                outputBaseName = path_1.default.join(process.cwd(), parsedDir.name);
-            }
-        }
-        catch (err) { } // we can ignore errors as it just means outputBaseName is not a folder
-        outputFilename = outputBaseName + '.' + outputExt;
-    }
     const svg = convertDot2Svg(dot);
     if (outputFormat === 'svg' || outputFormat === 'all') {
         await writeSVG(svg, outputFilename, outputFormat);
@@ -68,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.3",
+  "version": "2.1.0",
   "description": "Unified Modeling Language (UML) class diagram generator for Solidity contracts",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -8,8 +8,8 @@
     "buildSol": "cd ./src/contracts && solc **/*.sol",
     "build": "tsc --build ./tsconfig.json",
     "clean": "tsc --build --clean ./tsconfig.json",
-    "prettier": "prettier --write \"src/**/*.ts\"",
-    "prettier:check": "prettier --check \"src/**/*.ts\"",
+    "prettier": "prettier --write src/**/*.ts **/*.md",
+    "prettier:check": "prettier --check src/**/*.ts  **/*.md",
     "test": "npx jest"
   },
   "preferGlobal": true,
@@ -25,6 +25,7 @@
     "commander": "^9.4.0",
     "convert-svg-to-png": "^0.6.4",
     "debug": "^4.3.4",
+    "ethers": "^5.6.9",
     "js-graph-algorithms": "^1.0.18",
     "klaw": "^4.0.1"
   },