@inco/lightning 0.6.7 → 0.6.9

package/src/test/TestAddTwo.t.sol

@@ -7,6 +7,7 @@ import {IncoTest} from "./IncoTest.sol";
 import {AddTwo} from "./AddTwo.sol";
 
 contract TestAddTwo is IncoTest {
+
     AddTwo addTwo;
 
     function setUp() public override {
@@ -25,9 +26,8 @@ contract TestAddTwo is IncoTest {
     }
 
     function testAddTwoEoaAndPublicReveal() public {
-        (euint256 result, euint256 revealedResult) = addTwo.addTwoEOA(
-            fakePrepareEuint256Ciphertext(3, address(this), address(addTwo))
-        );
+        (euint256 result, euint256 revealedResult) =
+            addTwo.addTwoEoa(fakePrepareEuint256Ciphertext(3, address(this), address(addTwo)));
         processAllOperations();
         assertEq(getUint256Value(result), 5);
         assertEq(getUint256Value(revealedResult), 5);
@@ -41,4 +41,5 @@ contract TestAddTwo is IncoTest {
         assertEq(getBoolValue(trueVal), true);
         assertTrue(inco.isAllowed(ebool.unwrap(trueVal), bob));
     }
+
 }

package/src/test/TestDeploy.t.sol

@@ -9,24 +9,22 @@ import {inco} from "../Lib.sol";
 import {IncoTest} from "./IncoTest.sol";
 
 contract ReturnTwo is UUPSUpgradeable {
+
     function getTwo() external pure returns (uint256) {
         return 2;
     }
 
     function _authorizeUpgrade(address) internal override {}
+
 }
 
 contract TestDeploy is Test, IncoTest {
+
     // todo test that inco gets deployed at the predicted address
 
     function testDeployedCorrectly() public {
         vm.expectEmit(false, false, true, false, address(inco));
-        emit TrivialEncryption.TrivialEncrypt(
-            bytes32(uint256(1)),
-            bytes32(uint256(1)),
-            ETypes.Bool,
-            0
-        );
+        emit TrivialEncryption.TrivialEncrypt(bytes32(uint256(1)), bytes32(uint256(1)), ETypes.Bool, 0);
         inco.asEbool(true);
     }
 
@@ -36,4 +34,5 @@ contract TestDeploy is Test, IncoTest {
         inco.upgradeToAndCall(address(newImplem), "");
         assertEq(ReturnTwo(address(inco)).getTwo(), 2);
     }
+
 }

package/src/test/TestExtractDataOfEventTooLarge.t.sol

@@ -3,27 +3,19 @@ pragma solidity ^0.8;
 
 import {Test, Vm, console} from "forge-std/Test.sol";
 
-event EventTooLarge(
-    bytes32 control, // can't index >3 fields
-    bytes32 indexed ifTrue,
-    bytes32 indexed ifFalse,
-    bytes32 indexed result,
-    uint256 eventId
-);
+event EventTooLarge( // can't index >3 fields
+bytes32 control, bytes32 indexed ifTrue, bytes32 indexed ifFalse, bytes32 indexed result, uint256 eventId);
 
 contract Emitter {
+
     function emitEventTooLarge() external {
-        emit EventTooLarge(
-            bytes32(uint256(1)),
-            bytes32(uint256(2)),
-            bytes32(uint256(3)),
-            bytes32(uint256(4)),
-            5
-        );
+        emit EventTooLarge(bytes32(uint256(1)), bytes32(uint256(2)), bytes32(uint256(3)), bytes32(uint256(4)), 5);
     }
+
 }
 
 contract TestExtractDataOfEventTooLarge is Test {
+
     function testEmit() public {
         Emitter emitter = new Emitter();
         vm.recordLogs();
@@ -40,4 +32,5 @@ contract TestExtractDataOfEventTooLarge is Test {
         assertEq(first32Bytes, bytes32(uint256(1)));
         assertEq(second32Bytes, bytes32(uint256(5)));
     }
+
 }

package/src/test/TestFakeInfra.t.sol

@@ -5,13 +5,10 @@ import {IncoTest} from "./IncoTest.sol";
 import {e, euint256, ebool, eaddress, inco} from "../Lib.sol";
 import {SenderNotAllowedForHandle} from "../Types.sol";
 import {TEELifecycle} from "../lightning-parts/TEELifecycle.sol";
-import {MockRemoteAttestation} from "./FakeIncoInfra/MockRemoteAttestation.sol";
-import {
-    TD10ReportBody,
-    MINIMUM_QUOTE_LENGTH
-} from "../interfaces/automata-interfaces/Types.sol";
+import {Td10ReportBody, MINIMUM_QUOTE_LENGTH} from "../interfaces/automata-interfaces/Types.sol";
 
 contract TakesEInput is IncoTest {
+
     using e for bytes;
     using e for euint256;
 
@@ -27,10 +24,12 @@ contract TakesEInput is IncoTest {
     function setB(bytes memory boolEInput) external {
         b = boolEInput.newEbool(msg.sender);
     }
+
 }
 
 // its meta: this is testing correct behavior of our testing infrastructure
-contract TestFakeInfra is IncoTest, MockRemoteAttestation {
+contract TestFakeInfra is IncoTest {
+
     using e for euint256;
     using e for ebool;
     using e for uint256;
@@ -153,10 +152,7 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
         euint256 b = e.asEuint256(4);
         euint256 c = a.rotr(b);
         processAllOperations();
-        assertEq(
-            getUint256Value(c),
-            72370055773322622139731865630429942408293740416025352524660990004945706024960
-        );
+        assertEq(getUint256Value(c), 72370055773322622139731865630429942408293740416025352524660990004945706024960);
     }
 
     function testEEq() public {
@@ -272,17 +268,9 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
         TakesEInput inputContract = new TakesEInput();
         vm.deal(address(inputContract), 1 ether);
         address self = address(this);
-        bytes memory ciphertext = fakePrepareEuint256Ciphertext(
-            12,
-            self,
-            address(inputContract)
-        );
+        bytes memory ciphertext = fakePrepareEuint256Ciphertext(12, self, address(inputContract));
         inputContract.setA(ciphertext);
-        inputContract.setB(
-            fakePrepareEboolCiphertext(true,
-                self,
-                address(inputContract)
-            ));
+        inputContract.setB(fakePrepareEboolCiphertext(true, self, address(inputContract)));
         processAllOperations();
         assertEq(getUint256Value(inputContract.a()), 12);
         assertEq(getBoolValue(inputContract.b()), true);
@@ -291,35 +279,24 @@ contract TestFakeInfra is IncoTest, MockRemoteAttestation {
     function testUninitializedHandleIsDisallowed() public {
         bytes32 randomHandle = keccak256("random handle");
         euint256 a = e.asEuint256(12);
-        vm.expectRevert(
-            abi.encodeWithSelector(
-                SenderNotAllowedForHandle.selector,
-                randomHandle,
-                address(this)
-            )
-        );
+        vm.expectRevert(abi.encodeWithSelector(SenderNotAllowedForHandle.selector, randomHandle, address(this)));
         a.add(euint256.wrap(randomHandle));
     }
 
     function testCreateQuote() public view {
-        bytes
-            memory mrtd = hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+        bytes memory mrtd =
+            hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
         address signer = address(0x1234567890123456789012345678901234567890);
         bytes memory quote = createQuote(mrtd, signer);
         TEELifecycle lifecycle = TEELifecycle(address(inco.incoVerifier()));
-        TD10ReportBody memory tdReport = lifecycle.parseTD10ReportBody(quote);
-        (address reportDataSigner, bytes32 reportMrAggregated) = lifecycle
-            .parseReport(tdReport);
+        Td10ReportBody memory tdReport = lifecycle.parseTd10ReportBody(quote);
+        (address reportDataSigner, bytes32 reportMrAggregated) = lifecycle.parseReport(tdReport);
         assertEq(reportDataSigner, signer);
         assertEq(
             reportMrAggregated,
-            lifecycle.computeMrAggregated(
-                tdReport.mrTd,
-                tdReport.rtMr0,
-                tdReport.rtMr1,
-                tdReport.rtMr2
-            )
+            lifecycle.computeMrAggregated(tdReport.mrTd, tdReport.rtMr0, tdReport.rtMr1, tdReport.rtMr2)
         );
         assertEq(quote.length, MINIMUM_QUOTE_LENGTH);
     }
+
 }

package/src/test/TestUpgrade.t.sol

@@ -12,48 +12,34 @@ import {IncoLightning} from "../IncoLightning.sol";
 import {IVersion} from "../version/interfaces/IVersion.sol";
 import {Version} from "../version/Version.sol";
 import {IIncoVerifier} from "../interfaces/IIncoVerifier.sol";
-import {
-    MAJOR_VERSION,
-    MINOR_VERSION,
-    PATCH_VERSION
-} from "../version/IncoLightningConfig.sol";
+import {MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION} from "../version/IncoLightningConfig.sol";
 
 interface IUUPS {
-    function upgradeToAndCall(
-        address newImplementation,
-        bytes calldata data
-    ) external payable;
+
+    function upgradeToAndCall(address newImplementation, bytes calldata data) external payable;
+
 }
 
 contract IncoLightningV2 is IncoLightning {
+
     uint8 constant MAJOR_VERSION_MOCK = 255;
     uint8 constant MINOR_VERSION_MOCK = 255;
     uint8 constant PATCH_VERSION_MOCK = 255;
 
     constructor(bytes32 salt) IncoLightning(salt, IIncoVerifier(address(0))) {}
 
-    function getVersion()
-        public
-        view
-        virtual
-        override(IVersion, Version)
-        returns (string memory)
-    {
-        return
-            versionString(
-                MAJOR_VERSION_MOCK,
-                MINOR_VERSION_MOCK,
-                PATCH_VERSION_MOCK
-            );
+    function getVersion() public view virtual override(IVersion, Version) returns (string memory) {
+        return versionString(MAJOR_VERSION_MOCK, MINOR_VERSION_MOCK, PATCH_VERSION_MOCK);
     }
+
 }
 
 contract TestUpgrade is IncoTest {
+
     using Strings for uint256;
 
     // EIP-1967 implementation slot
-    bytes32 private constant IMPLEMENTATION_SLOT =
-        0x360894A13BA1A3210667C828492DB98DCA3E2076CC3735A920A3CA505D382BBC;
+    bytes32 private constant IMPLEMENTATION_SLOT = 0x360894A13BA1A3210667C828492DB98DCA3E2076CC3735A920A3CA505D382BBC;
 
     address private incoProxyAddr;
     IncoLightning private v1Impl;
@@ -84,20 +70,13 @@ contract TestUpgrade is IncoTest {
             0,
             payable(address(0))
         );
-        safe = Safe(
-            payable(factory.createProxyWithNonce(address(master), setupData, 0))
-        );
+        safe = Safe(payable(factory.createProxyWithNonce(address(master), setupData, 0)));
 
         vm.prank(owner);
         inco.transferOwnership(address(safe));
 
         // Deploy V2
-        bytes32 salt = getSalt(
-            "IncoLightningV2",
-            255,
-            testDeployer,
-            "testnet"
-        );
+        bytes32 salt = getSalt("IncoLightningV2", 255, testDeployer, "testnet");
         v2Impl = new IncoLightningV2(salt);
     }
 
@@ -114,11 +93,7 @@ contract TestUpgrade is IncoTest {
             )
         );
         // data to sign
-        bytes memory data = abi.encodeWithSelector(
-            IUUPS.upgradeToAndCall.selector,
-            address(v2Impl),
-            ""
-        );
+        bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         // prepare txhash
         bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
         // sign txHash
@@ -129,9 +104,7 @@ contract TestUpgrade is IncoTest {
         // execute tx with sorted signatures
         _execSafe(safe, incoProxyAddr, 0, data, signatures);
 
-        address implAfter = address(
-            uint160(uint256(vm.load(incoProxyAddr, IMPLEMENTATION_SLOT)))
-        );
+        address implAfter = address(uint160(uint256(vm.load(incoProxyAddr, IMPLEMENTATION_SLOT))));
         assertEq(implAfter, address(v2Impl));
 
         string memory versionAfter = inco.getVersion();
@@ -139,11 +112,7 @@ contract TestUpgrade is IncoTest {
     }
 
     function test_SafeSingleSignature_Fails() public {
-        bytes memory data = abi.encodeWithSelector(
-            IUUPS.upgradeToAndCall.selector,
-            address(v2Impl),
-            ""
-        );
+        bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
         bytes memory sigA = _sign(alicePrivKey, txHash);
         vm.expectRevert();
@@ -151,11 +120,7 @@ contract TestUpgrade is IncoTest {
     }
 
     function test_Safe_UnsortedSignatures_Fails() public {
-        bytes memory data = abi.encodeWithSelector(
-            IUUPS.upgradeToAndCall.selector,
-            address(v2Impl),
-            ""
-        );
+        bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
         bytes memory sigA = _sign(alicePrivKey, txHash);
         bytes memory sigC = _sign(carolPrivKey, txHash);
@@ -165,30 +130,17 @@ contract TestUpgrade is IncoTest {
     }
 
     function test_Safe_WrongSigner_Fails() public {
-        bytes memory data = abi.encodeWithSelector(
-            IUUPS.upgradeToAndCall.selector,
-            address(v2Impl),
-            ""
-        );
+        bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
         bytes memory sigOwner = _sign(alicePrivKey, txHash);
         bytes memory sigAttacker = _sign(davePrivKey, txHash);
-        bytes memory signatures = _packSortedTwo(
-            sigOwner,
-            alice,
-            sigAttacker,
-            dave
-        ); // dave not an owner
+        bytes memory signatures = _packSortedTwo(sigOwner, alice, sigAttacker, dave); // dave not an owner
         vm.expectRevert();
         _execSafe(safe, incoProxyAddr, 0, data, signatures);
     }
 
     function test_Safe_ReplayNonce_Fails() public {
-        bytes memory data = abi.encodeWithSelector(
-            IUUPS.upgradeToAndCall.selector,
-            address(v2Impl),
-            ""
-        );
+        bytes memory data = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         bytes32 txHash = _txHash(safe, incoProxyAddr, 0, data);
         bytes memory sigA = _sign(alicePrivKey, txHash);
         bytes memory sigB = _sign(bobPrivKey, txHash);
@@ -204,21 +156,11 @@ contract TestUpgrade is IncoTest {
 
     function test_Safe_UpdateSigners_SwapOwner_ThenUpgrade() public {
         // swap bob -> eve (prevOwner = alice since owners were [alice, bob, carol])
-        bytes memory change = abi.encodeWithSelector(
-            IOwnerManager.swapOwner.selector,
-            alice,
-            bob,
-            eve
-        );
+        bytes memory change = abi.encodeWithSelector(IOwnerManager.swapOwner.selector, alice, bob, eve);
         bytes32 changeHash = _txHash(safe, address(safe), 0, change);
         bytes memory changeSigA = _sign(alicePrivKey, changeHash);
         bytes memory changeSigC = _sign(carolPrivKey, changeHash);
-        bytes memory changeSigs = _packSortedTwo(
-            changeSigA,
-            alice,
-            changeSigC,
-            carol
-        );
+        bytes memory changeSigs = _packSortedTwo(changeSigA, alice, changeSigC, carol);
         _execSafe(safe, address(safe), 0, change, changeSigs);
 
         // assertions on owners/threshold
@@ -227,11 +169,7 @@ contract TestUpgrade is IncoTest {
         assertEq(safe.getThreshold(), 2, "threshold changed unexpectedly");
 
         // Attempt upgrade signed by removed owner should fail
-        bytes memory upg = abi.encodeWithSelector(
-            IUUPS.upgradeToAndCall.selector,
-            address(v2Impl),
-            ""
-        );
+        bytes memory upg = abi.encodeWithSelector(IUUPS.upgradeToAndCall.selector, address(v2Impl), "");
         bytes32 upgHash = _txHash(safe, incoProxyAddr, 0, upg);
         bytes memory badSigA = _sign(alicePrivKey, upgHash);
         bytes memory badSigB = _sign(bobPrivKey, upgHash); // removed owner
@@ -245,9 +183,7 @@ contract TestUpgrade is IncoTest {
         bytes memory goodSigs = _packSortedTwo(goodSigA, alice, goodSigE, eve);
         _execSafe(safe, incoProxyAddr, 0, upg, goodSigs);
 
-        address implAfter = address(
-            uint160(uint256(vm.load(incoProxyAddr, IMPLEMENTATION_SLOT)))
-        );
+        address implAfter = address(uint160(uint256(vm.load(incoProxyAddr, IMPLEMENTATION_SLOT))));
         assertEq(implAfter, address(v2Impl));
 
         string memory versionAfter = inco.getVersion();
@@ -261,61 +197,30 @@ contract TestUpgrade is IncoTest {
     }
 
     // Helpers
-    function _txHash(
-        Safe _safe,
-        address to,
-        uint256 value,
-        bytes memory data
-    ) internal view returns (bytes32) {
-        return
-            _safe.getTransactionHash(
-                to,
-                value,
-                data,
-                Enum.Operation.Call,
-                0,
-                0,
-                0,
-                address(0),
-                payable(address(0)),
-                _safe.nonce()
-            );
+    function _txHash(Safe _safe, address to, uint256 value, bytes memory data) internal view returns (bytes32) {
+        return _safe.getTransactionHash(
+            to, value, data, Enum.Operation.Call, 0, 0, 0, address(0), payable(address(0)), _safe.nonce()
+        );
     }
-    function _sign(
-        uint256 pk,
-        bytes32 txHash
-    ) internal view returns (bytes memory) {
+
+    function _sign(uint256 pk, bytes32 txHash) internal pure returns (bytes memory) {
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(pk, txHash);
         if (v < 27) v += 27;
         return abi.encodePacked(r, s, v);
     }
-    function _packSortedTwo(
-        bytes memory sigA,
-        address addrA,
-        bytes memory sigB,
-        address addrB
-    ) internal pure returns (bytes memory) {
-        return
-            addrA < addrB ? bytes.concat(sigA, sigB) : bytes.concat(sigB, sigA);
+
+    function _packSortedTwo(bytes memory sigA, address addrA, bytes memory sigB, address addrB)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return addrA < addrB ? bytes.concat(sigA, sigB) : bytes.concat(sigB, sigA);
     }
-    function _execSafe(
-        Safe _safe,
-        address to,
-        uint256 value,
-        bytes memory data,
-        bytes memory signatures
-    ) internal {
+
+    function _execSafe(Safe _safe, address to, uint256 value, bytes memory data, bytes memory signatures) internal {
         _safe.execTransaction(
-            to,
-            value,
-            data,
-            Enum.Operation.Call,
-            0,
-            0,
-            0,
-            address(0),
-            payable(address(0)),
-            signatures
+            to, value, data, Enum.Operation.Call, 0, 0, 0, address(0), payable(address(0)), signatures
         );
     }
+
 }

package/src/test/TestVersion.t.sol

@@ -5,10 +5,13 @@ import {Test} from "forge-std/Test.sol";
 import {Version} from "../version/Version.sol";
 
 contract SomeContract is Version {
-    constructor() Version(1, 2, 3, bytes32(uint(12345678)), "SomeContract") {}
+
+    constructor() Version(1, 2, 3, bytes32(uint256(12345678)), "SomeContract") {}
+
 }
 
 contract TestVersion is Test {
+
     SomeContract someContract;
 
     function setUp() public {
@@ -21,9 +24,7 @@ contract TestVersion is Test {
         assertEq(someContract.patchVersion(), 3);
         assertEq(someContract.getName(), "SomeContract");
         assertEq(someContract.getVersion(), "1_2_3");
-        assertEq(
-            someContract.getVersionedName(),
-            "SomeContract_1_2_3__12345678"
-        );
+        assertEq(someContract.getVersionedName(), "SomeContract_1_2_3__12345678");
     }
+
 }

package/src/version/IncoLightningConfig.sol

@@ -13,6 +13,6 @@ uint8 constant MINOR_VERSION = 0;
 // otherwise make test_upgrade will fail
 // consequently, when we do a patch release, we don't need to pump it as it's already pumped
 // when the previous release was done
-uint8 constant PATCH_VERSION = 3;
+uint8 constant PATCH_VERSION = 4;
 
 string constant VERIFIER_NAME = "incoVerifier";

package/src/version/Version.sol

@@ -2,77 +2,74 @@
 pragma solidity ^0.8;
 
 import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
-import {
-    ShortStrings,
-    ShortString
-} from "@openzeppelin/contracts/utils/ShortStrings.sol";
+import {ShortStrings, ShortString} from "@openzeppelin/contracts/utils/ShortStrings.sol";
 import {IVersion} from "./interfaces/IVersion.sol";
 
 contract Version is IVersion {
+
     using ShortStrings for ShortString;
     using ShortStrings for string;
 
-    uint8 public immutable majorVersion;
-    uint8 public immutable minorVersion;
-    uint8 public immutable patchVersion;
-    bytes32 public immutable salt;
-    ShortString internal immutable name;
+    uint8 internal immutable VERSION_MAJOR;
+    uint8 internal immutable VERSION_MINOR;
+    uint8 internal immutable VERSION_PATCH;
+    bytes32 internal immutable SALT;
+    ShortString internal immutable NAME;
 
-    constructor(
-        uint8 _majorVersion,
-        uint8 _minorVersion,
-        uint8 _patchVersion,
-        bytes32 _salt,
-        string memory _name
-    ) {
-        majorVersion = _majorVersion;
-        minorVersion = _minorVersion;
-        patchVersion = _patchVersion;
-        salt = _salt;
-        name = _name.toShortString();
+    constructor(uint8 _majorVersion, uint8 _minorVersion, uint8 _patchVersion, bytes32 _salt, string memory _name) {
+        VERSION_MAJOR = _majorVersion;
+        VERSION_MINOR = _minorVersion;
+        VERSION_PATCH = _patchVersion;
+        SALT = _salt;
+        NAME = _name.toShortString();
     }
 
     function getVersionedName() public view virtual returns (string memory) {
-        uint256 shortSalt = uint256(salt) % 10e8;
-        return
-            string(
-                abi.encodePacked(
-                    getName(),
-                    "_",
-                    getVersion(),
-                    "__",
-                    // avoids name collision for deployments of the same version
-                    Strings.toString(shortSalt)
-                )
-            );
+        uint256 shortSalt = uint256(SALT) % 10e8;
+        return string(
+            abi.encodePacked(
+                getName(),
+                "_",
+                getVersion(),
+                "__",
+                // avoids name collision for deployments of the same version
+                Strings.toString(shortSalt)
+            )
+        );
     }
 
     function getVersion() public view virtual returns (string memory) {
-        return versionString(majorVersion, minorVersion, patchVersion);
+        return versionString(VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH);
     }
 
-    function versionString(
-        uint8 major,
-        uint8 minor,
-        uint8 patch
-    ) internal pure returns (string memory) {
-        return
-            string(
-                abi.encodePacked(
-                    Strings.toString(major),
-                    "_",
-                    Strings.toString(minor),
-                    "_",
-                    Strings.toString(patch)
-                )
-            );
+    function versionString(uint8 major, uint8 minor, uint8 patch) internal pure returns (string memory) {
+        return string(
+            abi.encodePacked(Strings.toString(major), "_", Strings.toString(minor), "_", Strings.toString(patch))
+        );
     }
 
     function getName() public view virtual returns (string memory) {
-        return name.toString();
+        return NAME.toString();
     }
 
     function getMajorVersion() public view virtual returns (string memory) {
-        return Strings.toString(majorVersion);
+        return Strings.toString(VERSION_MAJOR);
+    }
+
+    function majorVersion() public view returns (uint8) {
+        return VERSION_MAJOR;
+    }
+
+    function minorVersion() public view returns (uint8) {
+        return VERSION_MINOR;
     }
+
+    function patchVersion() public view returns (uint8) {
+        return VERSION_PATCH;
+    }
+
+    function salt() public view returns (bytes32) {
+        return SALT;
+    }
+
 }

package/src/version/interfaces/IVersion.sol

@@ -2,8 +2,14 @@
 pragma solidity ^0.8;
 
 interface IVersion {
+
     function getVersionedName() external view returns (string memory);
     function getVersion() external view returns (string memory);
     function getName() external view returns (string memory);
     function getMajorVersion() external view returns (string memory);
+    function majorVersion() external view returns (uint8);
+    function minorVersion() external view returns (uint8);
+    function patchVersion() external view returns (uint8);
+    function salt() external view returns (bytes32);
+
 }