Remove extra functions

Author: ernestognw

contracts/utils/Memory.sol

@@ -30,57 +30,11 @@ library Memory {
         }
     }
 
-    /// @dev Returns a `Pointer` to the content of a `bytes` buffer. Skips the length word.
-    function contentPointer(bytes memory buffer) internal pure returns (Pointer) {
-        return addOffset(asPointer(buffer), 32);
-    }
-
-    /**
-     * @dev Copies `length` bytes from `srcPtr` to `destPtr`. Equivalent to https://www.evm.codes/?fork=cancun#5e[`mcopy`].
-     *
-     * WARNING: Reading or writing beyond the allocated memory bounds of either pointer
-     * will result in undefined behavior and potential memory corruption.
-     */
-    function copy(Pointer destPtr, Pointer srcPtr, uint256 length) internal pure {
-        assembly ("memory-safe") {
-            mcopy(destPtr, srcPtr, length)
-        }
-    }
-
-    /**
-     * @dev Extracts a `bytes1` from a `Pointer`. `offset` starts from the most significant byte.
-     *
-     * NOTE: Will return `0x00` if `offset` is larger or equal to `32`.
-     */
-    function loadByte(Pointer ptr, uint256 offset) internal pure returns (bytes1 v) {
-        bytes32 word = load(ptr);
-        assembly ("memory-safe") {
-            v := byte(offset, word)
-        }
-    }
-
-    /// @dev Extracts a `bytes32` from a `Pointer`.
-    function load(Pointer ptr) internal pure returns (bytes32 v) {
-        assembly ("memory-safe") {
-            v := mload(ptr)
-        }
-    }
-
-    /// @dev Adds an offset to a `Pointer`.
-    function addOffset(Pointer ptr, uint256 offset) internal pure returns (Pointer) {
-        return asPointer(bytes32(asUint256(ptr) + offset));
-    }
-
     /// @dev `Pointer` to `bytes32`. Expects a pointer to a properly ABI-encoded `bytes` object.
     function asBytes32(Pointer ptr) internal pure returns (bytes32) {
         return Pointer.unwrap(ptr);
     }
 
-    /// @dev `Pointer` to `uint256`. Expects a pointer to a properly ABI-encoded `bytes` object.
-    function asUint256(Pointer ptr) internal pure returns (uint256) {
-        return uint256(asBytes32(ptr));
-    }
-
     /// @dev `bytes32` to `Pointer`. Expects a pointer to a properly ABI-encoded `bytes` object.
     function asPointer(bytes32 value) internal pure returns (Pointer) {
         return Pointer.wrap(value);

test/utils/Memory.t.sol

@@ -18,50 +18,4 @@ contract MemoryTest is Test {
         ptr.asPointer().setFreeMemoryPointer();
         assertEq(Memory.getFreeMemoryPointer().asBytes32(), ptr);
     }
-
-    function testSymbolicContentPointer(uint256 seed) public pure {
-        Memory.Pointer ptr = bytes32(bound(seed, START_PTR, END_PTR)).asPointer();
-        assertEq(ptr.asBytes().contentPointer().asBytes32(), ptr.addOffset(32).asBytes32());
-    }
-
-    function testCopy(bytes memory data, uint256 destSeed) public pure {
-        uint256 minDestPtr = Memory.getFreeMemoryPointer().asUint256();
-        Memory.Pointer destPtr = bytes32(bound(destSeed, minDestPtr, minDestPtr + END_PTR)).asPointer();
-        destPtr.addOffset(data.length + 32).setFreeMemoryPointer();
-        destPtr.copy(data.asPointer(), data.length + 32);
-        bytes memory copiedData = destPtr.asBytes();
-        assertEq(data.length, copiedData.length);
-        for (uint256 i = 0; i < data.length; i++) {
-            assertEq(data[i], copiedData[i]);
-        }
-    }
-
-    function testLoadByte(uint256 seed, uint256 index, bytes32 value) public pure {
-        index = bound(index, 0, 31);
-        Memory.Pointer ptr = bytes32(bound(seed, START_PTR, END_PTR)).asPointer();
-
-        assembly ("memory-safe") {
-            mstore(ptr, value)
-        }
-
-        bytes1 expected;
-        assembly ("memory-safe") {
-            expected := byte(index, value)
-        }
-        assertEq(ptr.loadByte(index), expected);
-    }
-
-    function testLoad(uint256 seed, bytes32 value) public pure {
-        Memory.Pointer ptr = bytes32(bound(seed, START_PTR, END_PTR)).asPointer();
-        assembly ("memory-safe") {
-            mstore(ptr, value)
-        }
-        assertEq(ptr.load(), value);
-    }
-
-    function testSymbolicAddOffset(uint256 seed, uint256 offset) public pure {
-        offset = bound(offset, 0, type(uint256).max - END_PTR);
-        Memory.Pointer ptr = bytes32(bound(seed, START_PTR, END_PTR)).asPointer();
-        assertEq(ptr.addOffset(offset).asUint256(), ptr.asUint256() + offset);
-    }
 }

test/utils/Memory.test.js

@@ -26,39 +26,6 @@ describe('Memory', function () {
     });
   });
 
-  it('load extracts a word', async function () {
-    const ptr = await this.mock.$getFreeMemoryPointer();
-    await expect(this.mock.$load(ptr)).to.eventually.equal(ethers.toBeHex(0, 32));
-  });
-
-  it('loadByte extracts a byte', async function () {
-    const ptr = await this.mock.$getFreeMemoryPointer();
-    await expect(this.mock.$loadByte(ptr, 0)).to.eventually.equal(ethers.toBeHex(0, 1));
-  });
-
-  it('contentPointer', async function () {
-    const data = ethers.toUtf8Bytes('hello world');
-    const result = await this.mock.$contentPointer(data);
-    expect(result).to.equal(ethers.toBeHex(0xa0, 32)); // 0x80 is the default free pointer (length)
-  });
-
-  describe('addOffset', function () {
-    it('addOffset', async function () {
-      const basePtr = ethers.toBeHex(0x80, 32);
-      const offset = 32;
-      const expectedPtr = ethers.toBeHex(0xa0, 32);
-
-      await expect(this.mock.$addOffset(basePtr, offset)).to.eventually.equal(expectedPtr);
-    });
-
-    it('addOffsetwraps around', async function () {
-      const basePtr = ethers.toBeHex(0x80, 32);
-      const offset = 256;
-      const expectedPtr = ethers.toBeHex(0x180, 32);
-      await expect(this.mock.$addOffset(basePtr, offset)).to.eventually.equal(expectedPtr);
-    });
-  });
-
   describe('pointer conversions', function () {
     it('asBytes32 / asPointer', async function () {
       const ptr = ethers.toBeHex('0x1234', 32);
@@ -71,21 +38,5 @@ describe('Memory', function () {
       expect(ptr).to.equal(ethers.toBeHex(0x80, 32)); // Default free pointer
       await expect(this.mock.$asBytes(ptr)).to.eventually.equal(ethers.toBeHex(0x20, 32));
     });
-
-    it('asUint256', async function () {
-      const value = 0x1234;
-      const ptr = ethers.toBeHex(value, 32);
-      await expect(this.mock.$asUint256(ptr)).to.eventually.equal(value);
-    });
-  });
-
-  describe('memory operations', function () {
-    it('copy', async function () {
-      await expect(this.mock.$copy(ethers.toBeHex(0x80, 32), ethers.toBeHex(0xc0, 32), 32)).to.not.be.reverted;
-    });
-
-    it('copy with zero length', async function () {
-      await expect(this.mock.$copy(ethers.toBeHex(0x80, 32), ethers.toBeHex(0xc0, 32), 0)).to.not.be.reverted;
-    });
   });
 });