Some improvements on primitives

src/memory/memory.ts

@@ -1,6 +1,7 @@
 import { MemoryError, WriteOnceError } from 'errors/memory';
 import { SegmentError } from 'errors/primitives';
-import { MaybeRelocatable, Relocatable } from 'primitives/relocatable';
+import { MaybeRelocatable } from 'primitives/maybeRelocatable';
+import { Relocatable } from 'primitives/relocatable';
 
 export class Memory {
   data: Array<Array<MaybeRelocatable>>;

src/primitives/felt.ts

@@ -1,5 +1,4 @@
-import { MaybeRelocatable, Relocatable } from './relocatable';
-
+import { MaybeRelocatable, isFelt, isRelocatable } from './maybeRelocatable';
 import {
   ForbiddenOperation,
   OutOfRangeBigInt,
@@ -19,14 +18,14 @@ export class Felt {
   }
 
   add(other: MaybeRelocatable): Felt {
-    if (!MaybeRelocatable.isFelt(other)) {
+    if (!isFelt(other)) {
       throw new PrimitiveError(ForbiddenOperation);
     }
     return new Felt((this.inner + other.inner) % Felt.PRIME);
   }
 
   sub(other: MaybeRelocatable): Felt {
-    if (!MaybeRelocatable.isFelt(other)) {
+    if (!isFelt(other)) {
       throw new PrimitiveError(ForbiddenOperation);
     }
 
@@ -38,21 +37,21 @@ export class Felt {
   }
 
   mul(other: MaybeRelocatable): Felt {
-    if (!MaybeRelocatable.isFelt(other)) {
+    if (!isFelt(other)) {
       throw new PrimitiveError(ForbiddenOperation);
     }
     return new Felt((this.inner * other.inner) % Felt.PRIME);
   }
 
   div(other: MaybeRelocatable): Felt {
-    if (!MaybeRelocatable.isFelt(other) || other.inner === 0n) {
+    if (!isFelt(other) || other.inner === 0n) {
       throw new PrimitiveError(ForbiddenOperation);
     }
     return new Felt(this.inner / other.inner);
   }
 
   eq(other: MaybeRelocatable): boolean {
-    return !MaybeRelocatable.isRelocatable(other) && this.inner === other.inner;
+    return !isRelocatable(other) && this.inner === other.inner;
   }
 
   toString(): string {

src/primitives/maybeRelocatable.ts

@@ -0,0 +1,28 @@
+import { Felt } from './felt';
+import { Relocatable } from './relocatable';
+
+export type MaybeRelocatable = Relocatable | Felt;
+
+export function isFelt(
+  maybeRelocatable: MaybeRelocatable
+): maybeRelocatable is Felt;
+export function isFelt(
+  maybeRelocatable: MaybeRelocatable | number
+): maybeRelocatable is Felt;
+export function isFelt(
+  maybeRelocatable: MaybeRelocatable | number
+): maybeRelocatable is Felt {
+  return maybeRelocatable instanceof Felt;
+}
+
+export function isRelocatable(
+  maybeRelocatable: MaybeRelocatable
+): maybeRelocatable is Relocatable;
+export function isRelocatable(
+  maybeRelocatable: number | Relocatable
+): maybeRelocatable is Relocatable;
+export function isRelocatable(
+  maybeRelocatable: MaybeRelocatable | number
+): maybeRelocatable is Relocatable {
+  return maybeRelocatable instanceof Relocatable;
+}

src/primitives/relocatable.ts

@@ -5,22 +5,7 @@ import {
   PrimitiveError,
   SegmentError,
 } from 'errors/primitives';
-
-export type MaybeRelocatable = Relocatable | Felt;
-
-export namespace MaybeRelocatable {
-  export function isFelt(
-    maybeRelocatable: MaybeRelocatable
-  ): maybeRelocatable is Felt {
-    return maybeRelocatable instanceof Felt;
-  }
-
-  export function isRelocatable(
-    maybeRelocatable: MaybeRelocatable
-  ): maybeRelocatable is Relocatable {
-    return maybeRelocatable instanceof Relocatable;
-  }
-}
+import { MaybeRelocatable, isFelt, isRelocatable } from './maybeRelocatable';
 
 export class Relocatable {
   segment: number;
@@ -36,14 +21,14 @@ export class Relocatable {
   add(other: Relocatable): never;
   add(other: MaybeRelocatable): MaybeRelocatable;
   add(other: MaybeRelocatable | number): MaybeRelocatable {
-    if (other instanceof Felt) {
+    if (isFelt(other)) {
       const offset = new Felt(BigInt(this.offset));
       const newOffset = Number(offset.add(other));
 
       return new Relocatable(this.segment, newOffset);
     }
 
-    if (other instanceof Relocatable) {
+    if (isRelocatable(other)) {
       throw new PrimitiveError(ForbiddenOperation);
     }
 
@@ -55,7 +40,7 @@ export class Relocatable {
   sub(other: Relocatable): Felt;
   sub(other: MaybeRelocatable): MaybeRelocatable;
   sub(other: MaybeRelocatable | number): MaybeRelocatable {
-    if (other instanceof Felt) {
+    if (isFelt(other)) {
       const delta = Number(other);
 
       if (this.offset < delta) {
@@ -64,7 +49,7 @@ export class Relocatable {
       return new Relocatable(this.segment, this.offset - delta);
     }
 
-    if (other instanceof Relocatable) {
+    if (isRelocatable(other)) {
       if (this.offset < other.offset) {
         throw new PrimitiveError(OffsetUnderflow);
       }
@@ -85,7 +70,7 @@ export class Relocatable {
 
   eq(other: MaybeRelocatable): boolean {
     return (
-      !MaybeRelocatable.isFelt(other) &&
+      !isFelt(other) &&
       other.offset === this.offset &&
       other.segment === this.segment
     );

src/vm/virtualMachine.ts

@@ -11,7 +11,7 @@ import {
 } from 'errors/virtualMachine';
 import { Felt } from 'primitives/felt';
 import { Instruction, Opcode, PcUpdate, OpLogic } from './instruction';
-import { MaybeRelocatable, Relocatable } from 'primitives/relocatable';
+import { Relocatable } from 'primitives/relocatable';
 import { InstructionError } from 'errors/memory';
 
 import {
@@ -23,6 +23,11 @@ import { Memory } from 'memory/memory';
 import { ProgramCounter, MemoryPointer } from 'primitives/relocatable';
 
 import { Op1Source } from 'vm/instruction';
+import {
+  MaybeRelocatable,
+  isFelt,
+  isRelocatable,
+} from 'primitives/maybeRelocatable';
 
 // operand 0 is the first operand in the right side of the computation
 // operand 1 is the second operand in the right side of the computation
@@ -95,7 +100,7 @@ export class VirtualMachine {
           throw new VirtualMachineError(Op0Undefined);
         }
 
-        if (!MaybeRelocatable.isRelocatable(op0)) {
+        if (!isRelocatable(op0)) {
           throw new VirtualMachineError(Op0NotRelocatable);
         }
         baseAddr = op0;
@@ -111,7 +116,7 @@ export class VirtualMachine {
       throw new VirtualMachineError(EndOfInstructionsError);
     }
 
-    if (!(maybeEncodedInstruction instanceof Felt)) {
+    if (!isFelt(maybeEncodedInstruction)) {
       throw new VirtualMachineError(InstructionError);
     }
 
@@ -246,7 +251,7 @@ export class VirtualMachine {
           case 'op0 * op1':
             if (dst !== undefined && op1 !== undefined) {
               try {
-                if (!MaybeRelocatable.isFelt(dst)) {
+                if (!isFelt(dst)) {
                   throw new Error();
                 }
                 // op0 = res / op1
@@ -287,7 +292,7 @@ export class VirtualMachine {
         // op1 = dst / op0
         if (dst !== undefined && op0 !== undefined) {
           try {
-            if (!MaybeRelocatable.isFelt(dst)) {
+            if (!isFelt(dst)) {
               throw new Error();
             }
             return dst.div(op0);
@@ -313,7 +318,7 @@ export class VirtualMachine {
       case 'op0 + op1':
         return op0.add(op1);
       case 'op0 * op1':
-        if (!MaybeRelocatable.isFelt(op0)) {
+        if (!isFelt(op0)) {
           throw new VirtualMachineError(ExpectedFelt);
         }
         return op0.mul(op1);
@@ -363,7 +368,7 @@ export class VirtualMachine {
         if (operands.res === undefined) {
           throw new VirtualMachineError(UnconstrainedResError);
         }
-        if (!MaybeRelocatable.isRelocatable(operands.res)) {
+        if (!isRelocatable(operands.res)) {
           throw new VirtualMachineError(ExpectedRelocatable);
         }
         this.pc = operands.res;
@@ -375,7 +380,7 @@ export class VirtualMachine {
           throw new VirtualMachineError(UnconstrainedResError);
         }
 
-        if (!MaybeRelocatable.isFelt(operands.res)) {
+        if (!isFelt(operands.res)) {
           throw new VirtualMachineError(ExpectedFelt);
         }
         this.pc = this.pc.add(operands.res);
@@ -387,16 +392,13 @@ export class VirtualMachine {
         if (operands.dst === undefined) {
           throw new VirtualMachineError(InvalidDstOperand);
         }
-        if (
-          MaybeRelocatable.isFelt(operands.dst) &&
-          operands.dst.eq(Felt.ZERO)
-        ) {
+        if (isFelt(operands.dst) && operands.dst.eq(Felt.ZERO)) {
           this.incrementPc(instruction.size());
         } else {
           if (operands.op1 === undefined) {
             throw new VirtualMachineError(InvalidOperand1);
           }
-          if (!MaybeRelocatable.isFelt(operands.op1)) {
+          if (!isFelt(operands.op1)) {
             throw new VirtualMachineError(ExpectedFelt);
           }
           this.pc = this.pc.add(operands.op1);
@@ -419,10 +421,10 @@ export class VirtualMachine {
         if (operands.dst === undefined) {
           throw new VirtualMachineError(InvalidDstOperand);
         }
-        if (MaybeRelocatable.isFelt(operands.dst)) {
+        if (isFelt(operands.dst)) {
           this.fp = this.fp.add(operands.dst);
         }
-        if (MaybeRelocatable.isRelocatable(operands.dst)) {
+        if (isRelocatable(operands.dst)) {
           this.fp = operands.dst;
         }
         break;
@@ -437,7 +439,7 @@ export class VirtualMachine {
         if (operands.res === undefined) {
           throw new VirtualMachineError(UnconstrainedResError);
         }
-        if (!MaybeRelocatable.isFelt(operands.res)) {
+        if (!isFelt(operands.res)) {
           throw new VirtualMachineError(ExpectedFelt);
         }