up

Author: ernestognw

contracts/utils/Memory.sol

@@ -47,7 +47,11 @@ library Memory {
         }
     }
 
-    /// @dev Extracts a `bytes1` from a `Pointer`. `offset` starts from the most significant byte.
+    /**
+     * @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 extractByte(Pointer ptr, uint256 offset) internal pure returns (bytes1 v) {
         bytes32 word = extractWord(ptr);
         assembly ("memory-safe") {
@@ -67,22 +71,22 @@ library Memory {
         return asPointer(bytes32(asUint256(ptr) + offset));
     }
 
-    /// @dev `Pointer` to `bytes32`.
+    /// @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`.
+    /// @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`.
+    /// @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);
     }
 
-    /// @dev `bytes` to `Pointer`.
+    /// @dev Returns a `Pointer` to the `value`'s header (i.e. includes the length word).
     function asPointer(bytes memory value) internal pure returns (Pointer) {
         bytes32 ptr;
         assembly ("memory-safe") {
@@ -91,7 +95,7 @@ library Memory {
         return asPointer(ptr);
     }
 
-    /// @dev `Pointer` to `bytes`.
+    /// @dev `Pointer` to `bytes`. Expects a pointer to a properly ABI-encoded `bytes` object.
     function asBytes(Pointer ptr) internal pure returns (bytes memory b) {
         assembly ("memory-safe") {
             b := ptr

test/utils/Memory.test.js

@@ -14,28 +14,78 @@ describe('Memory', function () {
   });
 
   describe('free pointer', function () {
-    it('sets memory pointer', async function () {
-      const ptr = '0x00000000000000000000000000000000000000000000000000000000000000a0';
-      expect(await this.mock.$setFreePointer(ptr)).to.not.be.reverted;
+    it('sets free memory pointer', async function () {
+      const ptr = ethers.toBeHex(0xa0, 32);
+      await expect(this.mock.$setFreePointer(ptr)).to.not.be.reverted;
     });
 
-    it('gets memory pointer', async function () {
-      expect(await this.mock.$getFreePointer()).to.equal(
-        // Default pointer
-        '0x0000000000000000000000000000000000000000000000000000000000000080',
+    it('gets free memory pointer', async function () {
+      await expect(this.mock.$getFreePointer()).to.eventually.equal(
+        ethers.toBeHex(0x80, 32), // Default pointer
       );
     });
+  });
 
-    it('asBytes32', async function () {
-      const ptr = ethers.toBeHex('0x1234', 32);
-      await this.mock.$setFreePointer(ptr);
-      expect(await this.mock.$asBytes32(ptr)).to.equal(ptr);
+  it('extractWord extracts a word', async function () {
+    const ptr = await this.mock.$getFreePointer();
+    await expect(this.mock.$extractWord(ptr)).to.eventually.equal(ethers.toBeHex(0, 32));
+  });
+
+  it('extractByte 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));
+  });
+
+  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('asPointer', async function () {
+    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);
-      await this.mock.$setFreePointer(ptr);
-      expect(await this.mock.$asPointer(ptr)).to.equal(ptr);
+      await expect(this.mock.$asBytes32(ptr)).to.eventually.equal(ptr);
+      await expect(this.mock.$asPointer(ethers.Typed.bytes32(ptr))).to.eventually.equal(ptr);
+    });
+
+    it('asBytes / asPointer', async function () {
+      const ptr = await this.mock.$asPointer(ethers.Typed.bytes(ethers.toUtf8Bytes('hello world')));
+      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;
     });
   });
 });