Feat/u512

contracts/libs/bn/U512.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity ^0.8.19;
 
 type uint512 is uint256;
 type call is uint256;
@@ -1183,3 +1183,22 @@ library U512 {
         }
     }
 }
+
+// Operator overloading pure functions
+function add(uint512 a_, uint512 b_) pure returns (uint512 r_) {
+    return U512.add(a_, b_);
+}
+
+function sub(uint512 a_, uint512 b_) pure returns (uint512 r_) {
+    return U512.sub(a_, b_);
+}
+
+function mul(uint512 a_, uint512 b_) pure returns (uint512 r_) {
+    return U512.mul(a_, b_);
+}
+
+function eq(uint512 a_, uint512 b_) pure returns (bool eq_) {
+    return U512.eq(a_, b_);
+}
+
+using {add as +, sub as -, mul as *, eq as ==} for uint512 global;

contracts/mock/libs/bn/U512Mock.sol

@@ -38,6 +38,16 @@ contract U512Mock {
         return U512.eq(a_, b_);
     }
 
+    function eqOperator(
+        bytes memory aBytes_,
+        bytes memory bBytes_
+    ) external view returns (bool eq_) {
+        uint512 a_ = U512.fromBytes(aBytes_);
+        uint512 b_ = U512.fromBytes(bBytes_);
+
+        return a_ == b_;
+    }
+
     function eqUint256(bytes memory aBytes_, uint256 u256_) external view returns (bool eq_) {
         uint512 a_ = U512.fromBytes(aBytes_);
 
@@ -145,6 +155,16 @@ contract U512Mock {
         return U512.add(a_, b_).toBytes();
     }
 
+    function addOperator(
+        bytes memory aBytes_,
+        bytes memory bBytes_
+    ) external view returns (bytes memory rBytes_) {
+        uint512 a_ = U512.fromBytes(aBytes_);
+        uint512 b_ = U512.fromBytes(bBytes_);
+
+        return (a_ + b_).toBytes();
+    }
+
     function addAssign(
         bytes memory aBytes_,
         bytes memory bBytes_
@@ -181,6 +201,16 @@ contract U512Mock {
         return U512.sub(a_, b_).toBytes();
     }
 
+    function subOperator(
+        bytes memory aBytes_,
+        bytes memory bBytes_
+    ) external view returns (bytes memory rBytes_) {
+        uint512 a_ = U512.fromBytes(aBytes_);
+        uint512 b_ = U512.fromBytes(bBytes_);
+
+        return (a_ - b_).toBytes();
+    }
+
     function subAssign(
         bytes memory aBytes_,
         bytes memory bBytes_
@@ -217,6 +247,16 @@ contract U512Mock {
         return U512.mul(a_, b_).toBytes();
     }
 
+    function mulOperator(
+        bytes memory aBytes_,
+        bytes memory bBytes_
+    ) external view returns (bytes memory rBytes_) {
+        uint512 a_ = U512.fromBytes(aBytes_);
+        uint512 b_ = U512.fromBytes(bBytes_);
+
+        return (a_ * b_).toBytes();
+    }
+
     function mulAssign(
         bytes memory aBytes_,
         bytes memory bBytes_

test/libs/bn/U512.test.ts

@@ -132,8 +132,11 @@ describe("U512", () => {
 
   it("eq test", async () => {
     expect(await u512.eq(toBytes(1020n), toBytes(1002n))).to.be.false;
+    expect(await u512.eqOperator(toBytes(1020n), toBytes(1002n))).to.be.false;
     expect(await u512.eq(toBytes(200n), toBytes(200n))).to.be.true;
+    expect(await u512.eqOperator(toBytes(200n), toBytes(200n))).to.be.true;
     expect(await u512.eq("0x00", "0x00")).to.be.true;
+    expect(await u512.eqOperator("0x00", "0x00")).to.be.true;
   });
 
   it("eqUint256 test", async () => {
@@ -183,6 +186,7 @@ describe("U512", () => {
       const to = randomU512();
 
       expect(await u512.add(a, b)).to.be.equal(add(a, b));
+      expect(await u512.addOperator(a, b)).to.be.equal(add(a, b));
       expect(await u512.addAssign(a, b)).to.be.equal(add(a, b));
       expect(await u512.addAssignTo(a, b, to)).to.be.equal(add(a, b));
     }
@@ -195,6 +199,7 @@ describe("U512", () => {
       const to = randomU512();
 
       expect(await u512.sub(a, b)).to.be.equal(sub(a, b));
+      expect(await u512.subOperator(a, b)).to.be.equal(sub(a, b));
       expect(await u512.subAssign(a, b)).to.be.equal(sub(a, b));
       expect(await u512.subAssignTo(a, b, to)).to.be.equal(sub(a, b));
     }
@@ -207,6 +212,7 @@ describe("U512", () => {
       const to = randomU512();
 
       expect(await u512.mul(a, b)).to.be.equal(mul(a, b));
+      expect(await u512.mulOperator(a, b)).to.be.equal(mul(a, b));
       expect(await u512.mulAssign(a, b)).to.be.equal(mul(a, b));
       expect(await u512.mulAssignTo(a, b, to)).to.be.equal(mul(a, b));
     }