fix: memory management

src/memory/memory.test.ts

@@ -0,0 +1,45 @@
+import { test, expect, describe } from 'bun:test';
+import { Memory, UnknownAddressError, WriteOnceError } from './memory';
+import { Relocatable, RelocatableError } from './primitives/relocatable';
+import { Felt } from './primitives/felt';
+import { UnsignedInteger } from './primitives/uint';
+
+describe('Memory', () => {
+  describe('get', () => {
+    test('should throw if address is not written to', () => {
+      const memory = new Memory();
+      const address = new Relocatable(0, 0);
+
+      expect(() => memory.get(address)).toThrow(new UnknownAddressError());
+    });
+    test('should return the value at the address', () => {
+      const memory = new Memory();
+      memory.numSegments = UnsignedInteger.toUint(1);
+      const address = new Relocatable(0, 0);
+      const value = new Felt(10n);
+      memory.insert(address, value);
+
+      expect(memory.get(address)).toEqual(value);
+    });
+  });
+  describe('insert', () => {
+    test('should throw if relocatable is out of memory segment bounds', () => {
+      const memory = new Memory();
+      const address = new Relocatable(1, 0);
+      const value = new Felt(10n);
+
+      expect(() => memory.insert(address, value)).toThrow(
+        new RelocatableError()
+      );
+    });
+    test('should throw if address is already written to', () => {
+      let memory = new Memory();
+      memory.numSegments = UnsignedInteger.toUint(1);
+      const address = new Relocatable(0, 0);
+      const value = new Felt(10n);
+      memory.insert(address, value);
+
+      expect(() => memory.insert(address, value)).toThrow(new WriteOnceError());
+    });
+  });
+});

src/memory/memory.ts

@@ -9,13 +9,13 @@ export class MemoryError extends Error {}
 export class WriteOnceError extends MemoryError {}
 export class UnknownAddressError extends MemoryError {}
 
-class Memory {
+export class Memory {
   data: Map<Relocatable, MaybeRelocatable>;
   numSegments: Uint;
 
-  constructor(data: Map<Relocatable, MaybeRelocatable>, numSegments: number) {
-    this.data = data;
-    this.numSegments = UnsignedInteger.toUint(numSegments);
+  constructor() {
+    this.data = new Map();
+    this.numSegments = UnsignedInteger.toUint(0);
   }
 
   insert(address: Relocatable, value: MaybeRelocatable) {
@@ -30,37 +30,36 @@ class Memory {
     this.data.set(address, value);
   }
 
-  get(address: Relocatable) {
+  get(address: Relocatable): MaybeRelocatable {
     const value = this.data.get(address);
     if (value === undefined) {
       throw new UnknownAddressError();
     }
+    return value;
   }
 }
 
-class MemorySegmentManager {
-  segmentSizes: Record<number, number>;
+export class MemorySegmentManager {
+  segmentSizes: Record<Uint, Uint>;
   memory: Memory;
 
-  constructor(segmentSizes: Record<number, number>, memory: Memory) {
-    this.segmentSizes = segmentSizes;
-    this.memory = memory;
+  constructor() {
+    this.segmentSizes = {};
+    this.memory = new Memory();
   }
 
-  addSegment() {
+  addSegment(): Relocatable {
+    const ptr = new Relocatable(this.memory.numSegments, 0);
     this.memory.numSegments = UnsignedInteger.toUint(
       this.memory.numSegments + 1
     );
-    return new Relocatable(this.memory.numSegments - 1, 0);
+    return ptr;
   }
 
-  loadData(address: Relocatable, data: MaybeRelocatable[]) {
+  loadData(address: Relocatable, data: MaybeRelocatable[]): Relocatable {
     data.forEach((d, index) =>
-      this.memory.insert(
-        address.addPositiveNumber(UnsignedInteger.toUint(index)),
-        d
-      )
+      this.memory.insert(address.add(UnsignedInteger.toUint(index)), d)
     );
-    return address.addPositiveNumber(UnsignedInteger.toUint(data.length));
+    return address.add(UnsignedInteger.toUint(data.length));
   }
 }

src/memory/primitives/felt.test.ts

@@ -3,10 +3,10 @@ import { ConversionError, Felt, FeltError } from './felt';
 
 describe('Felt', () => {
   describe('constructor', () => {
-    test('should throw if initialising a felt with a negative inner', () => {
+    test('should throw if initializing a felt with a negative inner', () => {
       expect(() => new Felt(-10n)).toThrow(new FeltError());
     });
-    test('should throw a FeltError when initialising with a BigInt larger than PRIME', () => {
+    test('should throw a FeltError when initializing with a BigInt larger than PRIME', () => {
       const biggerThanPrime = Felt.PRIME + 1n;
       expect(() => new Felt(biggerThanPrime)).toThrow(new FeltError());
     });

src/memory/primitives/felt.ts

@@ -41,7 +41,7 @@ export class Felt {
   }
 
   toNumber(): number {
-    let num = Number(this.inner);
+    const num = Number(this.inner);
     // The value of the largest integer n such that n and n + 1 are both exactly representable as a Number value.
     // The value of Number.MAX_SAFE_INTEGER is 9007199254740991, i.e. 2^53 − 1.
     if (num > Number.MAX_SAFE_INTEGER) {