up

Author: ernestognw

contracts/utils/Memory.sol

@@ -52,15 +52,15 @@ library Memory {
      *
      * NOTE: Will return `0x00` if `offset` is larger or equal to `32`.
      */
-    function extractByte(Pointer ptr, uint256 offset) internal pure returns (bytes1 v) {
-        bytes32 word = extractWord(ptr);
+    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 extractWord(Pointer ptr) internal pure returns (bytes32 v) {
+    function load(Pointer ptr) internal pure returns (bytes32 v) {
         assembly ("memory-safe") {
             v := mload(ptr)
         }

test/utils/Memory.t.sol

@@ -36,7 +36,7 @@ contract MemoryTest is Test {
         }
     }
 
-    function testExtractByte(uint256 seed, uint256 index, bytes32 value) public pure {
+    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();
 
@@ -48,15 +48,15 @@ contract MemoryTest is Test {
         assembly ("memory-safe") {
             expected := byte(index, value)
         }
-        assertEq(ptr.extractByte(index), expected);
+        assertEq(ptr.loadByte(index), expected);
     }
 
-    function testExtractWord(uint256 seed, bytes32 value) public pure {
+    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.extractWord(), value);
+        assertEq(ptr.load(), value);
     }
 
     function testSymbolicAddOffset(uint256 seed, uint256 offset) public pure {

test/utils/Memory.test.js

@@ -26,14 +26,14 @@ describe('Memory', function () {
     });
   });
 
-  it('extractWord extracts a word', async function () {
+  it('load extracts a word', async function () {
     const ptr = await this.mock.$getFreePointer();
-    await expect(this.mock.$extractWord(ptr)).to.eventually.equal(ethers.toBeHex(0, 32));
+    await expect(this.mock.$load(ptr)).to.eventually.equal(ethers.toBeHex(0, 32));
   });
 
-  it('extractByte extracts a byte', async function () {
+  it('loadByte extracts a byte', async function () {
     const ptr = await this.mock.$getFreePointer();
-    await expect(this.mock.$extractByte(ptr, 0)).to.eventually.equal(ethers.toBeHex(0, 1));
+    await expect(this.mock.$loadByte(ptr, 0)).to.eventually.equal(ethers.toBeHex(0, 1));
   });
 
   it('contentPointer', async function () {