style: run trunk

src/hints/hintHandler.ts

@@ -48,7 +48,10 @@ import {
   shouldSkipSquashLoop,
 } from './dict/shouldSkipSquashLoop';
 import { TestLessThan, testLessThan } from './math/testLessThan';
-import { TestLessThanOrEqualAddress, testLessThanOrEqualAddress } from './math/testLessThanOrEqualAddress';
+import {
+  TestLessThanOrEqualAddress,
+  testLessThanOrEqualAddress,
+} from './math/testLessThanOrEqualAddress';
 
 /**
  * Map hint names to the function executing their logic.

src/hints/hintName.ts

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

src/hints/hintSchema.ts

@@ -34,7 +34,7 @@ const hint = z.union([
   shouldContinueSquashLoopParser,
   shouldSkipSquashLoopParser,
   testLessThanParser,
-  testLessThanOrEqualAddressParser
+  testLessThanOrEqualAddressParser,
 ]);
 
 /** Zod object to parse an array of hints grouped on a given PC */

src/hints/math/testLessThanOrEqualAddress.test.ts

@@ -32,7 +32,9 @@ const TEST_LESS_THAN_OR_EQUAL_ADDRESS = {
 
 describe('TestLessThanOrEqualAddress', () => {
   test('should properly parse TestLessThanOrEqualAddress hint', () => {
-    const hint = testLessThanOrEqualAddressParser.parse(TEST_LESS_THAN_OR_EQUAL_ADDRESS);
+    const hint = testLessThanOrEqualAddressParser.parse(
+      TEST_LESS_THAN_OR_EQUAL_ADDRESS
+    );
 
     expect(hint).toEqual({
       type: HintName.TestLessThanOrEqualAddress,
@@ -62,15 +64,22 @@ describe('TestLessThanOrEqualAddress', () => {
     [new Relocatable(1, 1), new Relocatable(1, 0), new Felt(0n)],
     [new Relocatable(1, 1), new Relocatable(1, 1), new Felt(1n)],
     [new Relocatable(0, 0), new Relocatable(1, 0), new Felt(1n)],
-  ])('should properly execute TestLessThanOrEqualAddress hint', (lhs, rhs, expected) => {
-    const hint = testLessThanOrEqualAddressParser.parse(TEST_LESS_THAN_OR_EQUAL_ADDRESS);
-    const vm = new VirtualMachine();
-    vm.memory.addSegment();
-    vm.memory.addSegment();    
-    vm.memory.assertEq(vm.ap, lhs);    
-    vm.memory.assertEq(vm.ap.add(1), rhs);
+  ])(
+    'should properly execute TestLessThanOrEqualAddress hint',
+    (lhs, rhs, expected) => {
+      const hint = testLessThanOrEqualAddressParser.parse(
+        TEST_LESS_THAN_OR_EQUAL_ADDRESS
+      );
+      const vm = new VirtualMachine();
+      vm.memory.addSegment();
+      vm.memory.addSegment();
+      vm.memory.assertEq(vm.ap, lhs);
+      vm.memory.assertEq(vm.ap.add(1), rhs);
 
-    vm.executeHint(hint);
-    expect(vm.memory.get(vm.cellRefToRelocatable(hint.dst))).toEqual(expected);
-  });
+      vm.executeHint(hint);
+      expect(vm.memory.get(vm.cellRefToRelocatable(hint.dst))).toEqual(
+        expected
+      );
+    }
+  );
 });

src/hints/math/testLessThanOrEqualAddress.ts

@@ -15,7 +15,11 @@ import { Relocatable } from 'primitives/relocatable';
 /** Zod object to parse TestLessThanOrEqualAddress hint */
 export const testLessThanOrEqualAddressParser = z
   .object({
-    TestLessThanOrEqualAddress: z.object({ lhs: resOperand, rhs: resOperand, dst: cellRef }),
+    TestLessThanOrEqualAddress: z.object({
+      lhs: resOperand,
+      rhs: resOperand,
+      dst: cellRef,
+    }),
   })
   .transform(({ TestLessThanOrEqualAddress: { lhs, rhs, dst } }) => ({
     type: HintName.TestLessThanOrEqualAddress,
@@ -29,13 +33,15 @@ export const testLessThanOrEqualAddressParser = z
  *
  * Check whether the Relocatable value at `lhs` is inferior or equal to the value at `rhs`
  */
-export type TestLessThanOrEqualAddress = z.infer<typeof testLessThanOrEqualAddressParser>;
+export type TestLessThanOrEqualAddress = z.infer<
+  typeof testLessThanOrEqualAddressParser
+>;
 
 /**
  * TestLessThanOrEqualAddress hint
  *
- * Compares the values at the relocatable values `lhs` and `rhs` and stores 
- * the result in `dst`. The result is `1` if the value at `lhs` is 
+ * Compares the values at the relocatable values `lhs` and `rhs` and stores
+ * the result in `dst`. The result is `1` if the value at `lhs` is
  * less than or equal to the value at `rhs`, and `0` otherwise.
  *
  * @param {VirtualMachine} vm - The virtual machine instance.
@@ -53,7 +59,7 @@ export const testLessThanOrEqualAddress = (
   const rhsValue = vm.getResOperandRelocatable(rhs);
 
   const isLessThanOrEqual = lhsValue <= rhsValue;
-                            
+
   const result = new Felt(isLessThanOrEqual ? 1n : 0n);
 
   vm.memory.assertEq(vm.cellRefToRelocatable(dst), result);