@izi-noir/sdk 0.1.13 → 0.1.14

package/dist/index.cjs

@@ -146,6 +146,8 @@ var init_R1csBuilder = __esm({
       // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
       // -1 mod Fr = Fr - 1
       NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      // Number of bits for range checks (64 bits handles values up to ~18 quintillion)
+      COMPARISON_BITS = 64;
       /**
        * Build R1CS definition from the parsed circuit
        */
@@ -255,13 +257,18 @@ var init_R1csBuilder = __esm({
             throw new Error(
               `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
             );
-          case "<":
+          case ">=":
+            this.processGreaterThanOrEqual(left, right);
+            break;
           case ">":
+            this.processGreaterThan(left, right);
+            break;
           case "<=":
-          case ">=":
-            throw new Error(
-              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
-            );
+            this.processGreaterThanOrEqual(right, left);
+            break;
+          case "<":
+            this.processGreaterThan(right, left);
+            break;
           case "&":
           case "|":
             throw new Error(
@@ -368,6 +375,83 @@ var init_R1csBuilder = __esm({
           // = c
         });
       }
+      /**
+       * Process greater than or equal: assert(a >= b)
+       * Uses bit decomposition to prove that a - b is non-negative.
+       *
+       * The approach:
+       * 1. Create diff = a - b
+       * 2. Decompose diff into COMPARISON_BITS bits
+       * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+       * 4. Sum of bits * powers of 2 = diff
+       *
+       * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+       */
+      processGreaterThanOrEqual(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Process greater than: assert(a > b)
+       * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+       */
+      processGreaterThan(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx],
+            [this.NEG_ONE, 0]
+            // -1 (using w_0 = 1)
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Add bit decomposition constraints for a value.
+       * Creates COMPARISON_BITS witnesses for the bits and constrains:
+       * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+       * 2. Sum of bits * 2^i = value
+       */
+      addBitDecompositionConstraints(valueIdx) {
+        const bitIndices = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const bitIdx = this.nextWitnessIdx++;
+          bitIndices.push(bitIdx);
+          this.constraints.push({
+            a: [["0x1", bitIdx]],
+            b: [["0x1", bitIdx]],
+            c: [["0x1", bitIdx]]
+          });
+        }
+        const sumTerms = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const coeff = (1n << BigInt(i)).toString(16);
+          sumTerms.push([`0x${coeff}`, bitIndices[i]]);
+        }
+        this.constraints.push({
+          a: sumTerms,
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", valueIdx]]
+        });
+      }
       /**
        * Process a variable declaration: let x = expr
        * Creates a new witness for x and adds constraint if needed

package/dist/index.d.cts

@@ -108,6 +108,7 @@ declare class R1csBuilder {
     private publicIndices;
     private privateIndices;
     private readonly NEG_ONE;
+    private readonly COMPARISON_BITS;
     constructor(parsedCircuit: ParsedCircuit);
     /**
      * Build R1CS definition from the parsed circuit
@@ -156,6 +157,31 @@ declare class R1csBuilder {
      * R1CS: (a - b) * 1 = c
      */
     private processSubtractionEquality;
+    /**
+     * Process greater than or equal: assert(a >= b)
+     * Uses bit decomposition to prove that a - b is non-negative.
+     *
+     * The approach:
+     * 1. Create diff = a - b
+     * 2. Decompose diff into COMPARISON_BITS bits
+     * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+     * 4. Sum of bits * powers of 2 = diff
+     *
+     * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+     */
+    private processGreaterThanOrEqual;
+    /**
+     * Process greater than: assert(a > b)
+     * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+     */
+    private processGreaterThan;
+    /**
+     * Add bit decomposition constraints for a value.
+     * Creates COMPARISON_BITS witnesses for the bits and constrains:
+     * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+     * 2. Sum of bits * 2^i = value
+     */
+    private addBitDecompositionConstraints;
     /**
      * Process a variable declaration: let x = expr
      * Creates a new witness for x and adds constraint if needed

package/dist/index.d.ts

@@ -108,6 +108,7 @@ declare class R1csBuilder {
     private publicIndices;
     private privateIndices;
     private readonly NEG_ONE;
+    private readonly COMPARISON_BITS;
     constructor(parsedCircuit: ParsedCircuit);
     /**
      * Build R1CS definition from the parsed circuit
@@ -156,6 +157,31 @@ declare class R1csBuilder {
      * R1CS: (a - b) * 1 = c
      */
     private processSubtractionEquality;
+    /**
+     * Process greater than or equal: assert(a >= b)
+     * Uses bit decomposition to prove that a - b is non-negative.
+     *
+     * The approach:
+     * 1. Create diff = a - b
+     * 2. Decompose diff into COMPARISON_BITS bits
+     * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+     * 4. Sum of bits * powers of 2 = diff
+     *
+     * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+     */
+    private processGreaterThanOrEqual;
+    /**
+     * Process greater than: assert(a > b)
+     * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+     */
+    private processGreaterThan;
+    /**
+     * Add bit decomposition constraints for a value.
+     * Creates COMPARISON_BITS witnesses for the bits and constrains:
+     * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+     * 2. Sum of bits * 2^i = value
+     */
+    private addBitDecompositionConstraints;
     /**
      * Process a variable declaration: let x = expr
      * Creates a new witness for x and adds constraint if needed

package/dist/index.js

@@ -124,6 +124,8 @@ var init_R1csBuilder = __esm({
       // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
       // -1 mod Fr = Fr - 1
       NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      // Number of bits for range checks (64 bits handles values up to ~18 quintillion)
+      COMPARISON_BITS = 64;
       /**
        * Build R1CS definition from the parsed circuit
        */
@@ -233,13 +235,18 @@ var init_R1csBuilder = __esm({
             throw new Error(
               `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
             );
-          case "<":
+          case ">=":
+            this.processGreaterThanOrEqual(left, right);
+            break;
           case ">":
+            this.processGreaterThan(left, right);
+            break;
           case "<=":
-          case ">=":
-            throw new Error(
-              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
-            );
+            this.processGreaterThanOrEqual(right, left);
+            break;
+          case "<":
+            this.processGreaterThan(right, left);
+            break;
           case "&":
           case "|":
             throw new Error(
@@ -346,6 +353,83 @@ var init_R1csBuilder = __esm({
           // = c
         });
       }
+      /**
+       * Process greater than or equal: assert(a >= b)
+       * Uses bit decomposition to prove that a - b is non-negative.
+       *
+       * The approach:
+       * 1. Create diff = a - b
+       * 2. Decompose diff into COMPARISON_BITS bits
+       * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+       * 4. Sum of bits * powers of 2 = diff
+       *
+       * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+       */
+      processGreaterThanOrEqual(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Process greater than: assert(a > b)
+       * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+       */
+      processGreaterThan(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx],
+            [this.NEG_ONE, 0]
+            // -1 (using w_0 = 1)
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Add bit decomposition constraints for a value.
+       * Creates COMPARISON_BITS witnesses for the bits and constrains:
+       * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+       * 2. Sum of bits * 2^i = value
+       */
+      addBitDecompositionConstraints(valueIdx) {
+        const bitIndices = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const bitIdx = this.nextWitnessIdx++;
+          bitIndices.push(bitIdx);
+          this.constraints.push({
+            a: [["0x1", bitIdx]],
+            b: [["0x1", bitIdx]],
+            c: [["0x1", bitIdx]]
+          });
+        }
+        const sumTerms = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const coeff = (1n << BigInt(i)).toString(16);
+          sumTerms.push([`0x${coeff}`, bitIndices[i]]);
+        }
+        this.constraints.push({
+          a: sumTerms,
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", valueIdx]]
+        });
+      }
       /**
        * Process a variable declaration: let x = expr
        * Creates a new witness for x and adds constraint if needed

package/dist/providers/arkworks.cjs

@@ -49,6 +49,8 @@ var init_R1csBuilder = __esm({
       // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
       // -1 mod Fr = Fr - 1
       NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      // Number of bits for range checks (64 bits handles values up to ~18 quintillion)
+      COMPARISON_BITS = 64;
       /**
        * Build R1CS definition from the parsed circuit
        */
@@ -158,13 +160,18 @@ var init_R1csBuilder = __esm({
             throw new Error(
               `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
             );
-          case "<":
+          case ">=":
+            this.processGreaterThanOrEqual(left, right);
+            break;
           case ">":
+            this.processGreaterThan(left, right);
+            break;
           case "<=":
-          case ">=":
-            throw new Error(
-              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
-            );
+            this.processGreaterThanOrEqual(right, left);
+            break;
+          case "<":
+            this.processGreaterThan(right, left);
+            break;
           case "&":
           case "|":
             throw new Error(
@@ -271,6 +278,83 @@ var init_R1csBuilder = __esm({
           // = c
         });
       }
+      /**
+       * Process greater than or equal: assert(a >= b)
+       * Uses bit decomposition to prove that a - b is non-negative.
+       *
+       * The approach:
+       * 1. Create diff = a - b
+       * 2. Decompose diff into COMPARISON_BITS bits
+       * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+       * 4. Sum of bits * powers of 2 = diff
+       *
+       * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+       */
+      processGreaterThanOrEqual(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Process greater than: assert(a > b)
+       * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+       */
+      processGreaterThan(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx],
+            [this.NEG_ONE, 0]
+            // -1 (using w_0 = 1)
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Add bit decomposition constraints for a value.
+       * Creates COMPARISON_BITS witnesses for the bits and constrains:
+       * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+       * 2. Sum of bits * 2^i = value
+       */
+      addBitDecompositionConstraints(valueIdx) {
+        const bitIndices = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const bitIdx = this.nextWitnessIdx++;
+          bitIndices.push(bitIdx);
+          this.constraints.push({
+            a: [["0x1", bitIdx]],
+            b: [["0x1", bitIdx]],
+            c: [["0x1", bitIdx]]
+          });
+        }
+        const sumTerms = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const coeff = (1n << BigInt(i)).toString(16);
+          sumTerms.push([`0x${coeff}`, bitIndices[i]]);
+        }
+        this.constraints.push({
+          a: sumTerms,
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", valueIdx]]
+        });
+      }
       /**
        * Process a variable declaration: let x = expr
        * Creates a new witness for x and adds constraint if needed

package/dist/providers/arkworks.js

@@ -27,6 +27,8 @@ var init_R1csBuilder = __esm({
       // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
       // -1 mod Fr = Fr - 1
       NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      // Number of bits for range checks (64 bits handles values up to ~18 quintillion)
+      COMPARISON_BITS = 64;
       /**
        * Build R1CS definition from the parsed circuit
        */
@@ -136,13 +138,18 @@ var init_R1csBuilder = __esm({
             throw new Error(
               `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
             );
-          case "<":
+          case ">=":
+            this.processGreaterThanOrEqual(left, right);
+            break;
           case ">":
+            this.processGreaterThan(left, right);
+            break;
           case "<=":
-          case ">=":
-            throw new Error(
-              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
-            );
+            this.processGreaterThanOrEqual(right, left);
+            break;
+          case "<":
+            this.processGreaterThan(right, left);
+            break;
           case "&":
           case "|":
             throw new Error(
@@ -249,6 +256,83 @@ var init_R1csBuilder = __esm({
           // = c
         });
       }
+      /**
+       * Process greater than or equal: assert(a >= b)
+       * Uses bit decomposition to prove that a - b is non-negative.
+       *
+       * The approach:
+       * 1. Create diff = a - b
+       * 2. Decompose diff into COMPARISON_BITS bits
+       * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+       * 4. Sum of bits * powers of 2 = diff
+       *
+       * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+       */
+      processGreaterThanOrEqual(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Process greater than: assert(a > b)
+       * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+       */
+      processGreaterThan(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx],
+            [this.NEG_ONE, 0]
+            // -1 (using w_0 = 1)
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Add bit decomposition constraints for a value.
+       * Creates COMPARISON_BITS witnesses for the bits and constrains:
+       * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+       * 2. Sum of bits * 2^i = value
+       */
+      addBitDecompositionConstraints(valueIdx) {
+        const bitIndices = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const bitIdx = this.nextWitnessIdx++;
+          bitIndices.push(bitIdx);
+          this.constraints.push({
+            a: [["0x1", bitIdx]],
+            b: [["0x1", bitIdx]],
+            c: [["0x1", bitIdx]]
+          });
+        }
+        const sumTerms = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const coeff = (1n << BigInt(i)).toString(16);
+          sumTerms.push([`0x${coeff}`, bitIndices[i]]);
+        }
+        this.constraints.push({
+          a: sumTerms,
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", valueIdx]]
+        });
+      }
       /**
        * Process a variable declaration: let x = expr
        * Creates a new witness for x and adds constraint if needed

package/dist/providers/barretenberg.cjs

@@ -146,6 +146,8 @@ var init_R1csBuilder = __esm({
       // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
       // -1 mod Fr = Fr - 1
       NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      // Number of bits for range checks (64 bits handles values up to ~18 quintillion)
+      COMPARISON_BITS = 64;
       /**
        * Build R1CS definition from the parsed circuit
        */
@@ -255,13 +257,18 @@ var init_R1csBuilder = __esm({
             throw new Error(
               `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
             );
-          case "<":
+          case ">=":
+            this.processGreaterThanOrEqual(left, right);
+            break;
           case ">":
+            this.processGreaterThan(left, right);
+            break;
           case "<=":
-          case ">=":
-            throw new Error(
-              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
-            );
+            this.processGreaterThanOrEqual(right, left);
+            break;
+          case "<":
+            this.processGreaterThan(right, left);
+            break;
           case "&":
           case "|":
             throw new Error(
@@ -368,6 +375,83 @@ var init_R1csBuilder = __esm({
           // = c
         });
       }
+      /**
+       * Process greater than or equal: assert(a >= b)
+       * Uses bit decomposition to prove that a - b is non-negative.
+       *
+       * The approach:
+       * 1. Create diff = a - b
+       * 2. Decompose diff into COMPARISON_BITS bits
+       * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+       * 4. Sum of bits * powers of 2 = diff
+       *
+       * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+       */
+      processGreaterThanOrEqual(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Process greater than: assert(a > b)
+       * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+       */
+      processGreaterThan(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx],
+            [this.NEG_ONE, 0]
+            // -1 (using w_0 = 1)
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Add bit decomposition constraints for a value.
+       * Creates COMPARISON_BITS witnesses for the bits and constrains:
+       * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+       * 2. Sum of bits * 2^i = value
+       */
+      addBitDecompositionConstraints(valueIdx) {
+        const bitIndices = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const bitIdx = this.nextWitnessIdx++;
+          bitIndices.push(bitIdx);
+          this.constraints.push({
+            a: [["0x1", bitIdx]],
+            b: [["0x1", bitIdx]],
+            c: [["0x1", bitIdx]]
+          });
+        }
+        const sumTerms = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const coeff = (1n << BigInt(i)).toString(16);
+          sumTerms.push([`0x${coeff}`, bitIndices[i]]);
+        }
+        this.constraints.push({
+          a: sumTerms,
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", valueIdx]]
+        });
+      }
       /**
        * Process a variable declaration: let x = expr
        * Creates a new witness for x and adds constraint if needed

package/dist/providers/barretenberg.js

@@ -124,6 +124,8 @@ var init_R1csBuilder = __esm({
       // Fr modulus = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
       // -1 mod Fr = Fr - 1
       NEG_ONE = "0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000000";
+      // Number of bits for range checks (64 bits handles values up to ~18 quintillion)
+      COMPARISON_BITS = 64;
       /**
        * Build R1CS definition from the parsed circuit
        */
@@ -233,13 +235,18 @@ var init_R1csBuilder = __esm({
             throw new Error(
               `Arithmetic operator ${operator} must be part of an equality assertion. Use: assert(a ${operator} b == c)`
             );
-          case "<":
+          case ">=":
+            this.processGreaterThanOrEqual(left, right);
+            break;
           case ">":
+            this.processGreaterThan(left, right);
+            break;
           case "<=":
-          case ">=":
-            throw new Error(
-              `Comparison operators (${operator}) require range proofs which are not yet supported. Use the Barretenberg backend for comparison operations.`
-            );
+            this.processGreaterThanOrEqual(right, left);
+            break;
+          case "<":
+            this.processGreaterThan(right, left);
+            break;
           case "&":
           case "|":
             throw new Error(
@@ -346,6 +353,83 @@ var init_R1csBuilder = __esm({
           // = c
         });
       }
+      /**
+       * Process greater than or equal: assert(a >= b)
+       * Uses bit decomposition to prove that a - b is non-negative.
+       *
+       * The approach:
+       * 1. Create diff = a - b
+       * 2. Decompose diff into COMPARISON_BITS bits
+       * 3. For each bit: bit_i * (1 - bit_i) = 0 (ensures 0 or 1)
+       * 4. Sum of bits * powers of 2 = diff
+       *
+       * If decomposition succeeds, diff is in [0, 2^COMPARISON_BITS - 1], so a >= b
+       */
+      processGreaterThanOrEqual(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx]
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Process greater than: assert(a > b)
+       * Equivalent to assert(a - b - 1 >= 0), or assert(a >= b + 1)
+       */
+      processGreaterThan(left, right) {
+        const leftIdx = this.getOrCreateWitness(left);
+        const rightIdx = this.getOrCreateWitness(right);
+        const diffIdx = this.nextWitnessIdx++;
+        this.constraints.push({
+          a: [
+            ["0x1", leftIdx],
+            [this.NEG_ONE, rightIdx],
+            [this.NEG_ONE, 0]
+            // -1 (using w_0 = 1)
+          ],
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", diffIdx]]
+        });
+        this.addBitDecompositionConstraints(diffIdx);
+      }
+      /**
+       * Add bit decomposition constraints for a value.
+       * Creates COMPARISON_BITS witnesses for the bits and constrains:
+       * 1. Each bit is 0 or 1: bit * (1 - bit) = 0
+       * 2. Sum of bits * 2^i = value
+       */
+      addBitDecompositionConstraints(valueIdx) {
+        const bitIndices = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const bitIdx = this.nextWitnessIdx++;
+          bitIndices.push(bitIdx);
+          this.constraints.push({
+            a: [["0x1", bitIdx]],
+            b: [["0x1", bitIdx]],
+            c: [["0x1", bitIdx]]
+          });
+        }
+        const sumTerms = [];
+        for (let i = 0; i < this.COMPARISON_BITS; i++) {
+          const coeff = (1n << BigInt(i)).toString(16);
+          sumTerms.push([`0x${coeff}`, bitIndices[i]]);
+        }
+        this.constraints.push({
+          a: sumTerms,
+          b: [["0x1", 0]],
+          // * 1
+          c: [["0x1", valueIdx]]
+        });
+      }
       /**
        * Process a variable declaration: let x = expr
        * Creates a new witness for x and adds constraint if needed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izi-noir/sdk",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Write ZK circuits in JavaScript/TypeScript, generate Noir code and proofs automatically",
   "type": "module",
   "main": "./dist/index.cjs",