Add skale-contracts

.eslintrc.cjs

@@ -1,20 +1,35 @@
 /* eslint-env node */
 module.exports = {
-    extends: [
-        // 'eslint:all',
-        'eslint:recommended',
-        'plugin:@typescript-eslint/recommended'
+    "extends": [
+        "eslint:all",
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
     ],
-    parser: '@typescript-eslint/parser',
-    plugins: ['@typescript-eslint'],
-    root: true,
-    rules: {
-        "object-curly-spacing": [ "error", "always" ],
-        "padded-blocks": [ "error", "never" ],
-        "one-var": ["error", "consecutive"]
-    },
-    ignorePatterns: [
+    "ignorePatterns": [
         "dist/**",
         "typechain-types/**"
-    ]
-  };
+    ],
+    "parser": "@typescript-eslint/parser",
+    "plugins": ["@typescript-eslint"],
+    "root": true,
+    "rules": {
+        "@typescript-eslint/no-shadow": "error",
+        "lines-around-comment": [
+            "error",
+            {"allowBlockStart": true}
+        ],
+        "no-console": "off",
+        // Replaced with @typescript-eslint/no-shadow
+        "no-shadow": "off",
+        "no-warning-comments": "warn",
+        "object-curly-spacing": "error",
+        "one-var": [
+            "error",
+            "never"
+        ],
+        "padded-blocks": [
+            "error",
+            "never"
+        ]
+    }
+};

cspell.json

@@ -17,7 +17,8 @@
         "**/*.egg-info/**",
         "**/dist/**",
         "**/coverage.json",
-        "**/*.hbs"
+        "**/*.hbs",
+        "**/*.orig"
     ],
     "dictionaries": ["domain-terms", "libraries", "names", "skale-terms", "solidity"],
     "dictionaryDefinitions": [
@@ -27,4 +28,4 @@
         { "name": "names", "path": "./dictionaries/names.txt"},
         { "name": "solidity", "path": "./dictionaries/solidity.txt"}
     ]
-}
+}

hardhat.config.ts

@@ -1,12 +1,16 @@
-import { HardhatUserConfig } from "hardhat/config";
-import '@typechain/hardhat'
-import "@nomiclabs/hardhat-ethers";
+import "@typechain/hardhat";
+import "@nomicfoundation/hardhat-ethers";
 import "@openzeppelin/hardhat-upgrades";
+import {HardhatUserConfig} from "hardhat/config";
+
+
+const coreArtifacts =
+    "node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json";
 
 const config: HardhatUserConfig = {
-    typechain: {
-        target: "ethers-v5",
-        externalArtifacts: ['node_modules/@openzeppelin/upgrades-core/artifacts/[!b]*.json']
+    "typechain": {
+        "externalArtifacts": [coreArtifacts],
+        "target": "ethers-v6"
     }
 };
 

package.json

@@ -25,33 +25,34 @@
   "devDependencies": {
     "@openzeppelin/contracts-upgradeable": "^4.4.2",
     "@tsconfig/recommended": "^1.0.2",
-    "@typechain/ethers-v5": "^9.0.0",
-    "@typechain/hardhat": "^8.0.0",
+    "@typechain/ethers-v6": "^0.5.1",
+    "@typechain/hardhat": "^9.1.0",
     "@types/node": "^20.6.0",
     "@typescript-eslint/eslint-plugin": "^6.6.0",
     "@typescript-eslint/parser": "^6.6.0",
     "cspell": "^8.8.3",
     "eslint": "^8.15.0",
     "install-peers-cli": "^2.2.0",
     "ts-node": "^10.5.0",
-    "typechain": "^8.2.0",
+    "typechain": "^8.3.2",
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@safe-global/api-kit": "^1.3.0",
-    "@safe-global/protocol-kit": "^1.2.0",
-    "@safe-global/safe-core-sdk-types": "^2.2.0",
-    "@skalenetwork/skale-contracts-ethers-v5": "0.1.0-develop.0",
+    "@safe-global/api-kit": "^2.4.1",
+    "@safe-global/protocol-kit": "^4.0.1",
+    "@safe-global/safe-core-sdk-types": "^5.0.1",
+    "@skalenetwork/skale-contracts-ethers-v6": "^1.0.0",
     "axios": "^1.4.0",
-    "ethereumjs-util": "^7.1.4"
+    "ethereumjs-util": "^7.1.4",
+    "semaphore-async-await": "^1.5.1"
   },
   "peerDependencies": {
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
     "@nomicfoundation/hardhat-verify": "^1.1.1",
-    "@nomiclabs/hardhat-ethers": "^2.0.4",
-    "@openzeppelin/hardhat-upgrades": "^1.14.0",
+    "@openzeppelin/hardhat-upgrades": "^3.1.1",
     "@openzeppelin/upgrades-core": "^1.27.1",
     "@types/mocha": "^9.1.0",
-    "ethers": "^5.7.2",
-    "hardhat": "^2.16.1"
+    "ethers": "^6.1.0",
+    "hardhat": "^2.9.9"
   }
 }

src/abi.ts

@@ -1,16 +1,27 @@
-import { Interface } from "ethers/lib/utils";
+import {Interface} from "ethers";
 
-export function getAbi(contractInterface: Interface) {
-    const abi = JSON.parse(contractInterface.format("json") as string) as [];
+export const getAbi = (contractInterface: Interface) => {
+    const abi = JSON.parse(contractInterface.formatJson()) as [];
 
     abi.forEach((obj: {type: string}) => {
         if (obj.type === "function") {
-            const func = obj as {name: string, type: string, inputs: object[], outputs: object[]};
+            const func = obj as {
+                name: string,
+                type: string,
+                inputs: object[],
+                outputs: object[]
+            };
             func.inputs.concat(func.outputs).forEach((output: object) => {
-                Object.assign(output, Object.assign({ name: "" }, output));
-            })
+                Object.assign(
+                    output,
+                    {
+                        "name": "",
+                        ...output
+                    }
+                );
+            });
         }
     });
 
     return abi;
-}
+};

src/contractFactory.ts

@@ -0,0 +1,142 @@
+import {artifacts, ethers} from "hardhat";
+import {
+    deployLibraries,
+    getManifestFile
+} from "./deploy";
+import {LinkReferences} from "hardhat/types";
+import {NonceProvider} from "./nonceProvider";
+import {SkaleManifestData} from "./types/SkaleManifestData";
+import {promises as fs} from "fs";
+import {hashBytecode} from "@openzeppelin/upgrades-core";
+
+
+const getSkaleManifest = async () => {
+    const manifest = JSON.parse(await fs.readFile(
+        await getManifestFile(),
+        "utf-8"
+    ));
+    if (typeof manifest.libraries === "undefined") {
+        manifest.libraries = {};
+    }
+    return manifest as SkaleManifestData;
+};
+
+const loadBytesCodes = async (libraryNames: string[]) => {
+    const byteCodes = new Map<string, string>();
+
+    (await Promise.
+        all(libraryNames.map((libraryName) => (async () => {
+            const {bytecode} = await artifacts.readArtifact(libraryName);
+            return [
+                libraryName,
+                bytecode
+            ];
+        })()))).forEach(([
+        libraryName,
+        bytecode
+    ]) => {
+        byteCodes.set(
+            libraryName,
+            bytecode
+        );
+    });
+    return byteCodes;
+};
+
+const updateManifest = async (
+    manifest: SkaleManifestData,
+    libraries: Map<string, string>,
+    oldLibraries: {[k: string]: string}
+) => {
+    const byteCodes = await loadBytesCodes(Array.from(libraries.keys()));
+    for (const [
+        libraryName,
+        libraryAddress
+    ] of libraries.entries()) {
+        manifest.libraries[libraryName] = {
+            "address": libraryAddress,
+            "bytecodeHash": hashBytecode(byteCodes.get(libraryName) as string)
+        };
+    }
+    Object.assign(
+        libraries,
+        oldLibraries
+    );
+    const indentation = 4;
+    await fs.writeFile(
+        await getManifestFile(),
+        JSON.stringify(
+            manifest,
+            null,
+            indentation
+        )
+    );
+};
+
+export const getLibrariesNames = (linkReferences: LinkReferences) => {
+    const libraryNames = [];
+    for (const libraryFile of Object.values(linkReferences)) {
+        libraryNames.push(...Object.keys(libraryFile));
+    }
+    return libraryNames;
+};
+
+const getLibrariesToUpgrade = async (
+    manifest: SkaleManifestData,
+    linkReferences: LinkReferences
+) => {
+    const librariesToUpgrade = [];
+    const oldLibraries: {[k: string]: string} = {};
+    const librariesNames = getLibrariesNames(linkReferences);
+    const byteCodes = await loadBytesCodes(librariesNames);
+    for (const libraryName of librariesNames) {
+        if (typeof manifest.libraries[libraryName] === "undefined") {
+            librariesToUpgrade.push(libraryName);
+        } else if (
+            hashBytecode(byteCodes.get(libraryName) as string) ===
+                manifest.libraries[libraryName].bytecodeHash
+        ) {
+            oldLibraries[libraryName] =
+                    manifest.libraries[libraryName].address;
+        } else {
+            librariesToUpgrade.push(libraryName);
+        }
+    }
+    return {
+        librariesToUpgrade,
+        oldLibraries
+    };
+};
+
+export const getContractFactoryAndUpdateManifest = async (
+    contract: string,
+    nonceProvider?: NonceProvider
+) => {
+    const {linkReferences} = await artifacts.readArtifact(contract);
+    if (!Object.keys(linkReferences).length) {
+        return await ethers.getContractFactory(contract);
+    }
+
+    const manifest = await getSkaleManifest();
+
+    const {
+        librariesToUpgrade,
+        oldLibraries
+    } = await getLibrariesToUpgrade(
+        manifest,
+        linkReferences
+    );
+    const libraries = await deployLibraries(
+        librariesToUpgrade,
+        nonceProvider
+    );
+    await updateManifest(
+        manifest,
+        libraries,
+        oldLibraries
+    );
+    return await ethers.getContractFactory(
+        contract,
+        {"libraries": Object.fromEntries(libraries)}
+    );
+};