feat: Add div mod hint

src/hints/hintHandler.ts

@@ -48,6 +48,7 @@ import {
   shouldSkipSquashLoop,
 } from './dict/shouldSkipSquashLoop';
 import { TestLessThan, testLessThan } from './math/testLessThan';
+import { DivMod, divMod } from './math/divMod';
 
 /**
  * Map hint names to the function executing their logic.
@@ -125,4 +126,8 @@ export const handlers: HintHandler = {
     const h = hint as TestLessThan;
     testLessThan(vm, h.lhs, h.rhs, h.dst);
   },
+  [HintName.DivMod]: (vm, hint) => {
+    const h = hint as DivMod;
+    divMod(vm, h.leftHandSide, h.rightHandSide, h.quotientAddress, h.remainderAddress);
+  },
 };

src/hints/hintName.ts

@@ -15,4 +15,5 @@ export enum HintName {
   ShouldContinueSquashLoop = 'ShouldContinueSquashLoop',
   ShouldSkipSquashLoop = 'ShouldSkipSquashLoop',
   TestLessThan = 'TestLessThan',
+  DivMod = 'DivMod',
 }

src/hints/hintSchema.ts

@@ -15,6 +15,7 @@ import { initSquashDataParser } from './dict/initSquashData';
 import { shouldContinueSquashLoopParser } from './dict/shouldContinueSquashLoop';
 import { shouldSkipSquashLoopParser } from './dict/shouldSkipSquashLoop';
 import { testLessThanParser } from './math/testLessThan';
+import { divModParser } from './math/divMod';
 
 /** Zod object to parse any implemented hints */
 const hint = z.union([
@@ -33,6 +34,7 @@ const hint = z.union([
   shouldContinueSquashLoopParser,
   shouldSkipSquashLoopParser,
   testLessThanParser,
+  divModParser
 ]);
 
 /** Zod object to parse an array of hints grouped on a given PC */

src/hints/math/divMod.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+
+import { VirtualMachine } from 'vm/virtualMachine';
+
+import { resOperand, ResOperand, cellRef, CellRef, } from 'hints/hintParamsSchema';
+import { HintName } from 'hints/hintName';
+import { Felt } from 'primitives/felt';
+
+/** Zod object to parse DivMod hint */
+export const divModParser = z
+  .object({
+    DivMod: z.object({
+      lhs: resOperand,
+      rhs: resOperand,
+      quotient: cellRef,
+      remainder: cellRef,
+    }),
+  })
+  .transform(({ DivMod: { lhs, rhs, quotient, remainder } }) => ({
+    type: HintName.DivMod,
+    leftHandSide: lhs,
+    rightHandSide: rhs,
+    quotientAddress: quotient,
+    remainderAddress: remainder,
+  }));
+
+
+/**
+ * DivMod hint type
+ */
+export type DivMod = z.infer<typeof divModParser>;
+
+/**
+ * Perform division and modulus operations.
+ *
+ * @param {VirtualMachine} vm - The virtual machine instance
+ * @param {ResOperand} leftHandSide - The left-hand side operand
+ * @param {ResOperand} rightHandSide - The right-hand side operand
+ * @param {CellRef} quotientAddress - The address to store the quotient
+ * @param {CellRef} remainderAddress - The address to store the remainder
+ */
+
+export const divMod = (
+    vm: VirtualMachine,
+    leftHandSide: ResOperand,
+    rightHandSide: ResOperand,
+    quotientAddress: CellRef,
+    remainderAddress: CellRef
+  ) => {
+    const lhsValue = vm.getResOperandValue(leftHandSide).toBigInt();
+    const rhsValue = vm.getResOperandValue(rightHandSide).toBigInt();
+
+    const quotientValue = new Felt(lhsValue / rhsValue);
+    const remainderValue = new Felt(lhsValue % rhsValue);
+
+    const quotientAddr = vm.cellRefToRelocatable(quotientAddress);
+    const remainderAddr = vm.cellRefToRelocatable(remainderAddress);
+  };