IdBuilder now accepts either number or bigint

Author: jeffsmale90

packages/delegation-toolkit/src/caveatBuilder/idBuilder.ts

@@ -14,21 +14,31 @@ export const id = 'id';
  */
 export function idBuilder(
   environment: DeleGatorEnvironment,
-  idValue: number,
+  idValue: bigint | number,
 ): Caveat {
-  if (!Number.isInteger(idValue)) {
-    throw new Error('Invalid id: must be an integer');
+  let idValueBigInt: bigint;
+
+  if (typeof idValue === 'number') {
+    if (!Number.isInteger(idValue)) {
+      throw new Error('Invalid id: must be an integer');
+    }
+
+    idValueBigInt = BigInt(idValue);
+  } else if (typeof idValue === 'bigint') {
+    idValueBigInt = idValue;
+  } else {
+    throw new Error('Invalid id: must be a bigint or number');
   }
 
-  if (idValue < 0) {
+  if (idValueBigInt < 0n) {
     throw new Error('Invalid id: must be positive');
   }
 
-  if (idValue > maxUint256) {
+  if (idValueBigInt > maxUint256) {
     throw new Error('Invalid id: must be less than 2^256');
   }
 
-  const terms = toHex(idValue, { size: 32 });
+  const terms = toHex(idValueBigInt, { size: 32 });
 
   const {
     caveatEnforcers: { IdEnforcer },

packages/delegation-toolkit/test/caveatBuilder/createCaveatBuilder.test.ts

@@ -238,7 +238,7 @@ describe('createCaveatBuilder()', () => {
     it("should add an 'id' caveat", () => {
       const builder = createCaveatBuilder(environment);
 
-      const id = Math.floor(Math.random() * 2 ** 32);
+      const id = BigInt(Math.floor(Math.random() * 2 ** 32));
       const caveats = builder.addCaveat('id', id).build();
 
       expect(caveats).to.deep.equal([

packages/delegation-toolkit/test/caveatBuilder/idBuilder.test.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { size, toHex } from 'viem';
+import { maxUint256, size, toHex } from 'viem';
 
 import { idBuilder } from '../../src/caveatBuilder/idBuilder';
 import type { DeleGatorEnvironment } from '../../src/types';
@@ -11,42 +11,35 @@ describe('idBuilder()', () => {
     caveatEnforcers: { IdEnforcer: randomAddress() },
   } as any as DeleGatorEnvironment;
 
-  const buildWithId = (id: number) => {
+  const buildWithId = (id: bigint | number) => {
     return idBuilder(environment, id);
   };
 
   describe('validation', () => {
-    it('should fail with an invalid id (not a number)', () => {
-      const invalidId = 'not-a-hex-string' as any;
-      expect(() => buildWithId(invalidId)).to.throw(
-        'Invalid id: must be an integer',
-      );
-    });
-
     it('should fail with an invalid id (not an integer)', () => {
-      const invalidId = Math.random() * 2 ** 32;
+      const invalidId = Math.random();
       expect(() => buildWithId(invalidId)).to.throw(
         'Invalid id: must be an integer',
       );
     });
 
     it('should fail with an invalid id (negative)', () => {
-      const invalidId = -1;
+      const invalidId = -1n;
       expect(() => buildWithId(invalidId)).to.throw(
         'Invalid id: must be positive',
       );
     });
 
     it('should fail with an invalid id (too high)', () => {
       const invalidId = 2n ** 256n;
-      expect(() => buildWithId(Number(invalidId))).to.throw(
+      expect(() => buildWithId(invalidId)).to.throw(
         'Invalid id: must be less than 2^256',
       );
     });
   });
 
   describe('builds a caveat', () => {
-    it('should build a caveat with a valid id', () => {
+    it('should build a caveat with a valid Number', () => {
       const validId = Math.floor(Math.random() * 2 ** 32);
 
       const caveat = buildWithId(validId);
@@ -59,6 +52,18 @@ describe('idBuilder()', () => {
         args: '0x',
       });
     });
+
+    it('should build a caveat with a large bigint', () => {
+      const caveat = buildWithId(maxUint256);
+
+      const expectedTerms = toHex(maxUint256, { size: 32 });
+
+      expect(caveat).to.deep.equal({
+        enforcer: environment.caveatEnforcers.IdEnforcer,
+        terms: expectedTerms,
+        args: '0x',
+      });
+    });
   });
 
   it('should create a caveat with terms length matching number of targets', () => {