@etherisc/gif-next 0.0.2-eb1b869-461 → 0.0.2-eb98db7-932

package/contracts/types/UFixed.sol

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.19;
-
-import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+pragma solidity ^0.8.20;
 
 /// @dev UFixed is a fixed point number with 18 decimals precision.
 type UFixed is uint256;
@@ -15,9 +13,16 @@ using {
     gteUFixed as >=,
     ltUFixed as <,
     lteUFixed as <=,
-    eqUFixed as ==
+    eqUFixed as ==,
+    neUFixed as !=,
+    UFixedLib.toInt,
+    UFixedLib.gtz
 } for UFixed global;
 
+function zeroUFixed() pure returns (UFixed zero) {
+    return UFixed.wrap(0);
+}
+
 function addUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));
 }
@@ -29,14 +34,14 @@ function subUFixed(UFixed a, UFixed b) pure returns (UFixed) {
 
 function mulUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
+        UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
 }
 
 function divUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");
 
     return
-        UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
+        UFixed.wrap(MathLib.mulDiv(UFixed.unwrap(a), 10 ** 18, UFixed.unwrap(b)));
 }
 
 function gtUFixed(UFixed a, UFixed b) pure returns (bool isGreaterThan) {
@@ -59,6 +64,10 @@ function eqUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
     return UFixed.unwrap(a) == UFixed.unwrap(b);
 }
 
+function neUFixed(UFixed a, UFixed b) pure returns (bool isEqual) {
+    return UFixed.unwrap(a) != UFixed.unwrap(b);
+}
+
 function gtzUFixed(UFixed a) pure returns (bool isZero) {
     return UFixed.unwrap(a) > 0;
 }
@@ -75,8 +84,115 @@ function deltaUFixed(UFixed a, UFixed b) pure returns (UFixed) {
     return b - a;
 }
 
-library UFixedMathLib {
+/// @dev copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.3/contracts/utils/math/Math.sol
+library MathLib {
+
+    enum Rounding {
+        Down, // Toward negative infinity
+        Up, // Toward infinity
+        Zero // Toward zero
+    }
+
+    /**
+     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
+     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
+     * with further edits by Uniswap Labs also under MIT license.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
+        unchecked {
+            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
+            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
+            // variables such that product = prod1 * 2^256 + prod0.
+            uint256 prod0; // Least significant 256 bits of the product
+            uint256 prod1; // Most significant 256 bits of the product
+            assembly {
+                let mm := mulmod(x, y, not(0))
+                prod0 := mul(x, y)
+                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
+            }
+
+            // Handle non-overflow cases, 256 by 256 division.
+            if (prod1 == 0) {
+                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
+                // The surrounding unchecked block does not change this fact.
+                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
+                return prod0 / denominator;
+            }
+
+            // Make sure the result is less than 2^256. Also prevents denominator == 0.
+            require(denominator > prod1, "Math: mulDiv overflow");
+
+            ///////////////////////////////////////////////
+            // 512 by 256 division.
+            ///////////////////////////////////////////////
+
+            // Make division exact by subtracting the remainder from [prod1 prod0].
+            uint256 remainder;
+            assembly {
+                // Compute remainder using mulmod.
+                remainder := mulmod(x, y, denominator)
+
+                // Subtract 256 bit number from 512 bit number.
+                prod1 := sub(prod1, gt(remainder, prod0))
+                prod0 := sub(prod0, remainder)
+            }
+
+            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
+            // See https://cs.stackexchange.com/q/138556/92363.
+
+            // Does not overflow because the denominator cannot be zero at this stage in the function.
+            uint256 twos = denominator & (~denominator + 1);
+            assembly {
+                // Divide denominator by twos.
+                denominator := div(denominator, twos)
+
+                // Divide [prod1 prod0] by twos.
+                prod0 := div(prod0, twos)
+
+                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
+                twos := add(div(sub(0, twos), twos), 1)
+            }
+
+            // Shift in bits from prod1 into prod0.
+            prod0 |= prod1 * twos;
+
+            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
+            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
+            // four bits. That is, denominator * inv = 1 mod 2^4.
+            uint256 inverse = (3 * denominator) ^ 2;
+
+            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
+            // in modular arithmetic, doubling the correct bits in each step.
+            inverse *= 2 - denominator * inverse; // inverse mod 2^8
+            inverse *= 2 - denominator * inverse; // inverse mod 2^16
+            inverse *= 2 - denominator * inverse; // inverse mod 2^32
+            inverse *= 2 - denominator * inverse; // inverse mod 2^64
+            inverse *= 2 - denominator * inverse; // inverse mod 2^128
+            inverse *= 2 - denominator * inverse; // inverse mod 2^256
+
+            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
+            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
+            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
+            // is no longer required.
+            result = prod0 * inverse;
+            return result;
+        }
+    }
+
+    /**
+     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
+     */
+    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
+        uint256 result = mulDiv(x, y, denominator);
+        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
+            result += 1;
+        }
+        return result;
+    }
 
+}
+
+library UFixedLib {
     int8 public constant EXP = 18;
     uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
     uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
@@ -96,51 +212,50 @@ library UFixedMathLib {
         return uint8(2);
     }
 
-    /// @dev returns the decimals precision of the UFixed type
-    function decimals() public pure returns (uint256) {
-        return uint8(EXP);
-    }
-
     /// @dev Converts the uint256 to a UFixed.
-    function itof(uint256 a) public pure returns (UFixed) {
+    function toUFixed(uint256 a) public pure returns (UFixed) {
         return UFixed.wrap(a * MULTIPLIER);
     }
 
-    // TODO rename to toUFixed
     /// @dev Converts the uint256 to a UFixed with given exponent.
-    function itof(uint256 a, int8 exp) public pure returns (UFixed) {
+    function toUFixed(uint256 a, int8 exp) public pure returns (UFixed) {
         require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
         require(EXP + exp <= 64, "ERROR:FM-011:EXPONENT_TOO_LARGE");
 
         return UFixed.wrap(a * 10 ** uint8(EXP + exp));
     }
 
+    /// @dev returns the decimals precision of the UFixed type
+    function decimals() public pure returns (uint256) {
+        return uint8(EXP);
+    }
+
     /// @dev Converts a UFixed to a uint256.
-    function ftoi(UFixed a) public pure returns (uint256) {
-        return ftoi(a, ROUNDING_HALF_UP());
+    function toInt(UFixed a) public pure returns (uint256) {
+        return toIntWithRounding(a, ROUNDING_HALF_UP());
     }
 
     /// @dev Converts a UFixed to a uint256 with given rounding mode.
-    function ftoi(UFixed a, uint8 rounding) public pure returns (uint256) {
+    function toIntWithRounding(UFixed a, uint8 rounding) public pure returns (uint256) {
         if (rounding == ROUNDING_HALF_UP()) {
             return
-                Math.mulDiv(
+                MathLib.mulDiv(
                     UFixed.unwrap(a) + MULTIPLIER_HALF,
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    MathLib.Rounding.Down
                 );
         } else if (rounding == ROUNDING_DOWN()) {
             return
-                Math.mulDiv(
+                MathLib.mulDiv(
                     UFixed.unwrap(a),
                     1,
                     MULTIPLIER,
-                    Math.Rounding.Down
+                    MathLib.Rounding.Down
                 );
         } else {
             return
-                Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Up);
+                MathLib.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, MathLib.Rounding.Up);
         }
     }
 

package/contracts/types/Version.sol

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.19;
+
+type VersionPart is uint8;
+
+using {
+    versionPartGt as >,
+    versionPartEq as ==,
+    versionPartNe as !=,
+    VersionPartLib.toInt
+}
+    for VersionPart global;
+
+function versionPartGt(VersionPart a, VersionPart b) pure returns(bool isGreaterThan) { return VersionPart.unwrap(a) > VersionPart.unwrap(b); }
+function versionPartEq(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) == VersionPart.unwrap(b); }
+function versionPartNe(VersionPart a, VersionPart b) pure returns(bool isSame) { return VersionPart.unwrap(a) != VersionPart.unwrap(b); }
+
+library VersionPartLib {
+    function toInt(VersionPart a) external pure returns(uint) { return VersionPart.unwrap(a); }
+    function toVersionPart(uint256 a) external pure returns(VersionPart) { return VersionPart.wrap(uint8(a)); }
+}
+
+type Version is uint24; // contains major,minor,patch version parts
+
+using {
+    versionGt as >,
+    versionEq as ==,
+    VersionLib.toInt,
+    VersionLib.toUint64,
+    VersionLib.toMajorPart,
+    VersionLib.toVersionParts
+}
+    for Version global;
+
+function versionGt(Version a, Version b) pure returns(bool isGreaterThan) { return Version.unwrap(a) > Version.unwrap(b); }
+function versionEq(Version a, Version b) pure returns(bool isSame) { return Version.unwrap(a) == Version.unwrap(b); }
+
+library VersionLib {
+    function toInt(Version version) external pure returns(uint) { return Version.unwrap(version); }
+
+    function toUint64(Version version) external pure returns(uint64) { return Version.unwrap(version); }
+
+    function toMajorPart(Version version)
+        external    
+        pure 
+        returns(VersionPart major)
+    { 
+        uint24 versionInt = Version.unwrap(version);
+        uint8 majorInt = uint8(versionInt >> 16);
+        return VersionPart.wrap(majorInt);
+    }
+
+    function toVersionParts(Version version)
+        external
+        pure
+        returns(
+            VersionPart major,
+            VersionPart minor,
+            VersionPart patch
+        )
+    {
+        uint24 versionInt = Version.unwrap(version);
+        uint8 majorInt = uint8(versionInt >> 16);
+
+        versionInt -= majorInt << 16;
+        uint8 minorInt = uint8(versionInt >> 8);
+        uint8 patchInt = uint8(versionInt - (minorInt << 8));
+
+        return (
+            VersionPart.wrap(majorInt),
+            VersionPart.wrap(minorInt),
+            VersionPart.wrap(patchInt)
+        );
+    }
+
+    function toVersionPart(uint256 versionPart) external pure returns(VersionPart) { 
+        return VersionPart.wrap(uint8(versionPart)); 
+    }
+
+    function toVersion(
+        uint256 major,
+        uint256 minor,
+        uint256 patch
+    )
+        external
+        pure
+        returns(Version)
+    {
+        require(
+            major < 256 && minor < 256 && patch < 256,
+            "ERROR:VRS-010:VERSION_PART_TOO_BIG");
+
+        return Version.wrap(
+            uint24(
+                (major << 16) + (minor << 8) + patch));
+    }
+
+    // TODO check for overflow?
+    function toVersion(uint64 versionNumber) external pure returns(Version) {
+        //assert(versionNumber <= type(Version).max);
+        return Version.wrap(uint24(versionNumber));
+    }
+
+    function zeroVersion() external pure returns(Version) {
+        return Version.wrap(0);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@etherisc/gif-next",
-  "version": "0.0.2-eb1b869-461",
+  "version": "0.0.2-eb98db7-932",
   "description": "This is the repository for the next version of the Generic Insurance Framework (GIF) smart contracts. ",
   "main": "index.js",
   "scripts": {
@@ -11,7 +11,8 @@
     "coverage": "hh coverage",
     "styleFix": "prettier --write --plugin=prettier-plugin-solidity 'contracts/**/*.sol' 'test_forge/**/*.t.sol'",
     "styleCheck": "prettier --check --plugin=prettier-plugin-solidity 'contracts/**/*.sol' 'test_forge/**/*.t.sol'",
-    "lint": "solhint 'contracts/**/*.sol' 'test_forge/**/*.t.sol'"
+    "lint": "solhint 'contracts/**/*.sol' 'test_forge/**/*.t.sol'",
+    "eslint": "eslint ."
   },
   "repository": {
     "type": "git",
@@ -31,16 +32,21 @@
     "@nomicfoundation/hardhat-foundry": "^1.1.1",
     "@nomicfoundation/hardhat-toolbox": "^3.0.0",
     "@nomicfoundation/hardhat-verify": "^1.1.1",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
     "dotenv": "^16.3.1",
+    "eslint": "^8.50.0",
     "hardhat": "^2.17.2",
     "prettier": "^3.0.3",
-    "prettier-plugin-solidity": "^1.1.3"
+    "prettier-plugin-solidity": "^1.1.3",
+    "typescript": "^5"
   },
   "dependencies": {
-    "@openzeppelin/contracts": "^4.9.3",
-    "@openzeppelin/contracts-upgradeable": "^4.9.3",
+    "@openzeppelin/contracts": "5.0.0",
+    "@openzeppelin/contracts-upgradeable": "5.0.0",
     "abi-coder": "^5.0.0",
     "ethers": "^6.7.1",
+    "solidity-docgen": "^0.6.0-beta.36",
     "winston": "^3.10.0"
   }
 }

package/artifacts/contracts/components/Component.sol/InstanceLinked.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/371956c35f778b248bb1774ada1ed516.json"
-}

package/artifacts/contracts/components/Component.sol/InstanceLinked.json

@@ -1,35 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "InstanceLinked",
-  "sourceName": "contracts/components/Component.sol",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "instance",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [],
-      "name": "getInstance",
-      "outputs": [
-        {
-          "internalType": "contract IInstance",
-          "name": "instance",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b5060405161011438038061011483398101604081905261002f91610054565b600080546001600160a01b0319166001600160a01b0392909216919091179055610084565b60006020828403121561006657600080fd5b81516001600160a01b038116811461007d57600080fd5b9392505050565b6082806100926000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063de7b5d1414602d575b600080fd5b600054604080516001600160a01b039092168252519081900360200190f3fea264697066735822122073a0ea8fa4352d28b2a129d826cfd42d4c8f65d3a006cdf283aa909e0fac0e4264736f6c63430008140033",
-  "deployedBytecode": "0x6080604052348015600f57600080fd5b506004361060285760003560e01c8063de7b5d1414602d575b600080fd5b600054604080516001600160a01b039092168252519081900360200190f3fea264697066735822122073a0ea8fa4352d28b2a129d826cfd42d4c8f65d3a006cdf283aa909e0fac0e4264736f6c63430008140033",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/artifacts/contracts/components/IPool.sol/IPoolComponent.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/371956c35f778b248bb1774ada1ed516.json"
-}

package/artifacts/contracts/components/IProduct.sol/IProductComponent.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/371956c35f778b248bb1774ada1ed516.json"
-}

package/artifacts/contracts/components/IProduct.sol/IProductComponent.json

@@ -1,74 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "IProductComponent",
-  "sourceName": "contracts/components/IProduct.sol",
-  "abi": [
-    {
-      "inputs": [],
-      "name": "getPolicyFee",
-      "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "UFixed",
-              "name": "fractionalFee",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "fixedFee",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct Fee",
-          "name": "policyFee",
-          "type": "tuple"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getPoolNftId",
-      "outputs": [
-        {
-          "internalType": "NftId",
-          "name": "poolNftId",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "getProcessingFee",
-      "outputs": [
-        {
-          "components": [
-            {
-              "internalType": "UFixed",
-              "name": "fractionalFee",
-              "type": "uint256"
-            },
-            {
-              "internalType": "uint256",
-              "name": "fixedFee",
-              "type": "uint256"
-            }
-          ],
-          "internalType": "struct Fee",
-          "name": "processingFee",
-          "type": "tuple"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x",
-  "deployedBytecode": "0x",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/artifacts/contracts/experiment/errors/Require.sol/Require.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/371956c35f778b248bb1774ada1ed516.json"
-}

package/artifacts/contracts/experiment/errors/Require.sol/Require.json

@@ -1,105 +0,0 @@
-{
-  "_format": "hh-sol-artifact-1",
-  "contractName": "Require",
-  "sourceName": "contracts/experiment/errors/Require.sol",
-  "abi": [
-    {
-      "inputs": [],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "a",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "b",
-          "type": "uint256"
-        }
-      ],
-      "name": "AsmallerThanB_L",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "a",
-          "type": "uint256"
-        }
-      ],
-      "name": "AsmallerThanB_M",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "AsmallerThanB_S",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "a",
-          "type": "uint256"
-        }
-      ],
-      "name": "isAlargerThanBRequire_L",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "isLarger",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "a",
-          "type": "uint256"
-        }
-      ],
-      "name": "isAlargerThanBRequire_M",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "isLarger",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "a",
-          "type": "uint256"
-        }
-      ],
-      "name": "isAlargerThanBRequire_S",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "isLarger",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "bytecode": "0x608060405234801561001057600080fd5b50602a6000556101df806100256000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c806342bf62e0146100465780638db581aa1461006d57806394977ddd14610080575b600080fd5b610059610054366004610190565b610093565b604051901515815260200160405180910390f35b61005961007b366004610190565b6100f2565b61005961008e366004610190565b610134565b6000805482116100ea5760405162461bcd60e51b815260206004820152601a60248201527f4552524f523a4142432d3030323a415f49535f534d414c4c455200000000000060448201526064015b60405180910390fd5b506001919050565b6000805482116100ea5760405162461bcd60e51b815260206004820152600d60248201526c4552524f523a4142432d30303160981b60448201526064016100e1565b6000805482116100ea5760405162461bcd60e51b815260206004820152602160248201527f4552524f523a4142432d3030333a415f49535f534d414c4c45525f5448414e5f6044820152602160f91b60648201526084016100e1565b6000602082840312156101a257600080fd5b503591905056fea2646970667358221220572bbc4b1e30046ddb065771b03fa96e34255214cd346e350172d87d56991ba064736f6c63430008140033",
-  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c806342bf62e0146100465780638db581aa1461006d57806394977ddd14610080575b600080fd5b610059610054366004610190565b610093565b604051901515815260200160405180910390f35b61005961007b366004610190565b6100f2565b61005961008e366004610190565b610134565b6000805482116100ea5760405162461bcd60e51b815260206004820152601a60248201527f4552524f523a4142432d3030323a415f49535f534d414c4c455200000000000060448201526064015b60405180910390fd5b506001919050565b6000805482116100ea5760405162461bcd60e51b815260206004820152600d60248201526c4552524f523a4142432d30303160981b60448201526064016100e1565b6000805482116100ea5760405162461bcd60e51b815260206004820152602160248201527f4552524f523a4142432d3030333a415f49535f534d414c4c45525f5448414e5f6044820152602160f91b60648201526084016100e1565b6000602082840312156101a257600080fd5b503591905056fea2646970667358221220572bbc4b1e30046ddb065771b03fa96e34255214cd346e350172d87d56991ba064736f6c63430008140033",
-  "linkReferences": {},
-  "deployedLinkReferences": {}
-}

package/artifacts/contracts/experiment/errors/Revert.sol/Revert.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../build-info/371956c35f778b248bb1774ada1ed516.json"
-}