Merge pull request #978 from skalenetwork/skale-contracts-integration

Skale-contracts integration

.eslintrc.cjs

@@ -0,0 +1,38 @@
+/* eslint-env node */
+module.exports = {
+ "extends": [
+ "eslint:recommended",
+ "plugin:@typescript-eslint/recommended"
+ ],
+ "ignorePatterns": [
+ "coverage/**",
+ "typechain-types/**"
+ ],
+ "env": {
+ "node": true
+ },
+ "parser": "@typescript-eslint/parser",
+ "plugins": ["@typescript-eslint"],
+ "root": true,
+ "rules": {
+ "@typescript-eslint/no-shadow": "error",
+ "@typescript-eslint/no-unused-vars": "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"
+ ]
+ }
+};

.github/workflows/publish.yml

@@ -13,7 +13,7 @@ on:
  - 'custom-release-*'
 
 env:
- NODE_VERSION: 18
+ NODE_VERSION: 20
 
 jobs:
  build:

.github/workflows/test.yml

@@ -17,7 +17,7 @@ jobs:
 
  strategy:
  matrix:
- node-version: [16.x, 18.x, 20.x]
+ node-version: [18.x, 20.x]
 
  env:
  CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
@@ -57,10 +57,12 @@ jobs:
  NODE_VERSION: ${{ matrix.node-version }}
  run: ./scripts/test_upgrade.sh
 
- - name: Test ABI ageneration
+ - name: Test ABI generation
  run: npx hardhat run scripts/generateAbi.ts
 
  - name: Run tests
+ env:
+ NODE_OPTIONS: --max-old-space-size=12288
  run: npx hardhat coverage --solcoverjs .solcover.js
 
  - name: Upload coverage to Codecov

.gitignore

@@ -9,6 +9,7 @@ cache/
 tmp.sol
 data/*.json
 scTopics
+contracts/hardhat-dependency-compiler
 
 ### Node ###
 # Logs

.solhint.json

@@ -15,7 +15,6 @@
  "func-visibility": ["error", {"ignoreConstructors": true}],
  "function-max-lines": "error",
  "max-states-count": ["error", 20],
- "named-return-values": "error",
  "no-empty-blocks": "error",
  "no-global-import": "error",
  "no-inline-assembly": "error",

.solhintignore

@@ -1,3 +1,4 @@
 node_modules/
 contracts/Migrations.sol
-contracts/thirdparty
+contracts/hardhat-dependency-compiler
+contracts/thirdparty

contracts/ConstantsHolder.sol

@@ -145,7 +145,7 @@ contract ConstantsHolder is Permissions, IConstantsHolder {
  allowableLatency = 150000;
  deltaPeriod = 3600;
  checkTime = 300;
- launchTimestamp = type(uint).max;
+ launchTimestamp = type(uint256).max;
  rotationDelay = 12 hours;
  proofOfUseLockUpPeriodDays = 90;
  proofOfUseDelegationPercentage = 50;

contracts/NodeRotation.sol

@@ -233,7 +233,7 @@ contract NodeRotation is Permissions, INodeRotation {
  schainsInternal.makeSchainNodesInvisible(schainHash);
  require(schainsInternal.isAnyFreeNode(schainHash), "No free Nodes available for rotation");
  IRandom.RandomGenerator memory randomGenerator = Random.createFromEntropy(
- abi.encodePacked(uint(blockhash(block.number - 1)), schainHash)
+ abi.encodePacked(uint256(blockhash(block.number - 1)), schainHash)
  );
  nodeIndex = nodes.getRandomNodeWithFreeSpace(space, randomGenerator);
  require(nodes.removeSpaceFromNode(nodeIndex, space), "Could not remove space from nodeIndex");

contracts/Nodes.sol

@@ -145,7 +145,7 @@ contract Nodes is Permissions, INodes {
  if (space > 0) {
  _moveNodeToNewSpaceMap(
  nodeIndex,
- (uint(spaceOfNodes[nodeIndex].freeSpace) - space).toUint8()
+ (uint256(spaceOfNodes[nodeIndex].freeSpace) - space).toUint8()
  );
  }
  return true;
@@ -165,7 +165,7 @@ contract Nodes is Permissions, INodes {
  if (space > 0) {
  _moveNodeToNewSpaceMap(
  nodeIndex,
- (uint(spaceOfNodes[nodeIndex].freeSpace) + space).toUint8()
+ (uint256(spaceOfNodes[nodeIndex].freeSpace) + space).toUint8()
  );
  }
  }

contracts/Schains.sol

@@ -299,9 +299,9 @@ contract Schains is Permissions, ISchains {
  return 1e18;
  } else {
  uint256 up = nodeDeposit * numberOfNodes * lifetime * 2;
- uint256 down = uint(
- uint(constantsHolder.SMALL_DIVISOR())
- * uint(constantsHolder.SECONDS_TO_YEAR())
+ uint256 down = uint256(
+ uint256(constantsHolder.SMALL_DIVISOR())
+ * uint256(constantsHolder.SECONDS_TO_YEAR())
  / divisor
  );
  return up / down;

contracts/SchainsInternal.sol

@@ -994,7 +994,7 @@ contract SchainsInternal is Permissions, IPruningSchainsInternal {
 
  require(nodes.countNodesWithFreeSpace(space) >= nodesInGroup.length, "Not enough nodes to create Schain");
  IRandom.RandomGenerator memory randomGenerator = Random.createFromEntropy(
- abi.encodePacked(uint(blockhash(block.number - 1)), schainHash)
+ abi.encodePacked(uint256(blockhash(block.number - 1)), schainHash)
  );
  for (uint256 i = 0; i < numberOfNodes; i++) {
  uint256 node = nodes.getRandomNodeWithFreeSpace(space, randomGenerator);

contracts/SkaleManager.sol

@@ -52,7 +52,7 @@ contract SkaleManager is IERC777Recipient, ISkaleManager, Permissions {
  0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
 
  bytes32 constant public ADMIN_ROLE = keccak256("ADMIN_ROLE");
- uint256 constant public HEADER_COSTS = 7486;
+ uint256 constant public HEADER_COSTS = 5310;
  uint256 constant public CALL_PRICE = 21000;
 
  string public version;

contracts/SkaleVerifier.sol

@@ -116,7 +116,7 @@ contract SkaleVerifier is Permissions, ISkaleVerifier {
  if (counter > 100) {
  return false;
  }
- uint256 xCoord = uint(hash) % Fp2Operations.P;
+ uint256 xCoord = uint256(hash) % Fp2Operations.P;
  xCoord = (xCoord + counter) % Fp2Operations.P;
 
  uint256 ySquared = addmod(

contracts/SlashingTable.sol

@@ -45,7 +45,7 @@ contract SlashingTable is Permissions, ISlashingTable {
  */
  function setPenalty(string calldata offense, uint256 penalty) external override {
  require(hasRole(PENALTY_SETTER_ROLE, msg.sender), "PENALTY_SETTER_ROLE is required");
- uint256 offenseHash = uint(keccak256(abi.encodePacked(offense)));
+ uint256 offenseHash = uint256(keccak256(abi.encodePacked(offense)));
  _penalties[offenseHash] = penalty;
  emit PenaltyAdded(offenseHash, offense, penalty);
  }

contracts/dkg/SkaleDkgResponse.sol

@@ -87,9 +87,9 @@ library SkaleDkgResponse {
  bytes32[2] memory publicKey = INodes(contractManager.getContract("Nodes")).getNodePublicKey(
  complaints[schainHash].fromNodeToComplaint
  );
- uint256 pkX = uint(publicKey[0]);
+ uint256 pkX = uint256(publicKey[0]);
 
- (pkX, ) = IECDH(contractManager.getContract("ECDH")).deriveKey(secretNumber, pkX, uint(publicKey[1]));
+ (pkX, ) = IECDH(contractManager.getContract("ECDH")).deriveKey(secretNumber, pkX, uint256(publicKey[1]));
  bytes32 key = bytes32(pkX);
 
  // Decrypt secret key contribution

contracts/test/SegmentTreeTester.sol

@@ -68,7 +68,7 @@ contract SegmentTreeTester is ISegmentTreeTester {
 
  function getRandomElem(uint256 place) external view override returns (uint256 element) {
  IRandom.RandomGenerator memory randomGenerator = Random.createFromEntropy(
- abi.encodePacked(uint(blockhash(block.number - 1)), place)
+ abi.encodePacked(uint256(blockhash(block.number - 1)), place)
  );
  return _tree.getRandomNonZeroElementFromPlaceToLast(place, randomGenerator);
  }

contracts/test/interfaces/IMathUtilsTester.sol

@@ -23,6 +23,11 @@ pragma solidity 0.8.17;
 
 
 interface IMathUtilsTester {
+ event UnderflowError(
+ uint256 a,
+ uint256 b
+ );
+
  function boundedSub(uint256 a, uint256 b) external returns (uint256 result);
  function boundedSubWithoutEvent(uint256 a, uint256 b) external pure returns (uint256 result);
  function muchGreater(uint256 a, uint256 b) external pure returns (bool greater);

contracts/utils/MathUtils.sol

@@ -49,7 +49,7 @@ library MathUtils {
  }
 
  function muchGreater(uint256 a, uint256 b) internal pure returns (bool result) {
- assert(type(uint).max - _EPS > b);
+ assert(type(uint256).max - _EPS > b);
  return a > b + _EPS;
  }
 

contracts/utils/Random.sol

@@ -45,7 +45,7 @@ library Random {
  * @dev Generates random value
  */
  function random(IRandom.RandomGenerator memory self) internal pure returns (uint256 value) {
- self.seed = uint(sha256(abi.encodePacked(self.seed)));
+ self.seed = uint256(sha256(abi.encodePacked(self.seed)));
  return self.seed;
  }
 
@@ -54,7 +54,7 @@ library Random {
  */
  function random(IRandom.RandomGenerator memory self, uint256 max) internal pure returns (uint256 value) {
  assert(max > 0);
- uint256 maxRand = type(uint).max - type(uint).max % max;
+ uint256 maxRand = type(uint256).max - type(uint256).max % max;
  if (type(uint).max - maxRand == max - 1) {
  return random(self) % max;
  } else {

contracts/utils/SegmentTree.sol

@@ -75,7 +75,7 @@ library SegmentTree {
  function create(Tree storage segmentTree, uint256 size) external {
  require(size > 0, "Size can't be 0");
  require(size & size - 1 == 0, "Size is not power of 2");
- segmentTree.tree = new uint[](size * 2 - 1);
+ segmentTree.tree = new uint256[](size * 2 - 1);
  }
 
  /**

cspell.json

@@ -19,7 +19,8 @@
  "**/coverage.json",
  "**/*.hbs",
  ".openzeppelin/**",
- ".github/**"
+ ".github/**",
+ "**/*.orig"
  ],
  "dictionaries": ["domain-terms", "libraries", "names", "skale-terms", "solidity"],
  "dictionaryDefinitions": [
@@ -29,4 +30,4 @@
  { "name": "names", "path": "./dictionaries/names.txt"},
  { "name": "solidity", "path": "./dictionaries/solidity.txt"}
  ]
-}
+}

gas/createSchain.ts

@@ -1,29 +1,24 @@
-import { deployContractManager } from "../test/tools/deploy/contractManager";
-import { deployValidatorService } from "../test/tools/deploy/delegation/validatorService";
-import { deploySkaleManager } from "../test/tools/deploy/skaleManager";
-import { ContractManager, Schains, SkaleManager, ValidatorService } from "../typechain-types";
-import { deploySchains } from "../test/tools/deploy/schains";
+import {deployContractManager} from "../test/tools/deploy/contractManager";
+import {deployValidatorService} from "../test/tools/deploy/delegation/validatorService";
+import {deploySkaleManager} from "../test/tools/deploy/skaleManager";
+import {ContractManager, Schains, SkaleManager, ValidatorService} from "../typechain-types";
+import {deploySchains} from "../test/tools/deploy/schains";
 import fs from 'fs';
-import { ethers } from "hardhat";
-import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/dist/src/signer-with-address";
-import { Event, Wallet } from "ethers";
-import { getPublicKey, getValidatorIdSignature } from "../test/tools/signatures";
-import { fastBeforeEach } from "../test/tools/mocha";
-import { SchainType } from "../test/tools/types";
-import { TypedEvent } from "../typechain-types/common";
-import { SchainNodesEvent } from "../typechain-types/artifacts/@skalenetwork/skale-manager-interfaces/ISchains";
+import {ethers} from "hardhat";
+import {SignerWithAddress} from "@nomicfoundation/hardhat-ethers/signers";
+import {ContractTransactionReceipt, EventLog, HDNodeWallet, Wallet} from "ethers";
+import {getPublicKey, getValidatorIdSignature} from "../test/tools/signatures";
+import {fastBeforeEach} from "../test/tools/mocha";
+import {SchainType} from "../test/tools/types";
 
-function findEvent<TargetEvent extends TypedEvent>(events: Event[] | undefined, eventName: string) {
- if (events) {
- const target = events.find((event) => event.event === eventName);
- if (target) {
- return target as TargetEvent;
- } else {
- throw new Error("Event was not emitted");
+export function findEvent(receipt: ContractTransactionReceipt | null, eventName: string) {
+ if (receipt) {
+ const log = receipt.logs.find((event) => event instanceof EventLog && event.eventName === eventName);
+ if (log) {
+ return log as EventLog;
  }
- } else {
- throw new Error("Event was not emitted");
  }
+ throw new Error("Event was not emitted");
 }
 
 describe("createSchains", () => {
@@ -50,8 +45,8 @@ describe("createSchains", () => {
  const validatorId = await validatorService.getValidatorId(validator.address);
  await validatorService.disableWhitelist();
  const maxNodesAmount = 1000;
- const etherAmount = ethers.utils.parseEther("10");
- const nodeAddresses: Wallet[] = [];
+ const etherAmount = ethers.parseEther("10");
+ const nodeAddresses: HDNodeWallet[] = [];
  await schains.grantRole(await schains.SCHAIN_CREATOR_ROLE(), owner.address);
 
  const gasLimit = 12e6;
@@ -72,8 +67,11 @@ describe("createSchains", () => {
 
  const nodesAmount = nodeId + 1;
  if (nodesAmount >= 16) {
- const result = await (await schains.addSchainByFoundation(0, SchainType.SMALL, 0, `schain-${nodeId}`, owner.address, ethers.constants.AddressZero, [])).wait();
- const nodeInGroup = findEvent<SchainNodesEvent>(result.events, "SchainNodes").args?.nodesInGroup;
+ const result = await (await schains.addSchainByFoundation(0, SchainType.SMALL, 0, `schain-${nodeId}`, owner.address, ethers.ZeroAddress, [])).wait();
+ if (!result) {
+ throw new Error("addSchainByFoundation was not mined");
+ }
+ const nodeInGroup = findEvent(result, "SchainNodes").args?.nodesInGroup;
  console.log("Nodes in Schain:");
  const setOfNodes = new Set();
  for (const nodeOfSchain of nodeInGroup) {
@@ -87,8 +85,8 @@ describe("createSchains", () => {
  }
 
  measurements.push({nodesAmount, gasUsed: result.gasUsed});
- console.log("create schain on", nodesAmount, "nodes:\t", result.gasUsed.toNumber(), "gu");
- if (result.gasUsed.toNumber() > gasLimit) {
+ console.log("create schain on", nodesAmount, "nodes:\t", result.gasUsed, "gu");
+ if (result.gasUsed > gasLimit) {
  break;
  }
  }