@wopr-network/platform-core 1.39.2 → 1.39.3

package/dist/credits/credit.js

@@ -91,15 +91,27 @@ export class Credit {
     }
     /** Add another Credit, returning a new Credit. */
     add(other) {
-        return new Credit(this.raw + other.raw);
+        const result = this.raw + other.raw;
+        if (!Number.isSafeInteger(result)) {
+            throw new RangeError(`Credit.add overflow: ${this.raw} + ${other.raw} = ${result}`);
+        }
+        return new Credit(result);
     }
     /** Subtract another Credit, returning a new Credit (may be negative). */
     subtract(other) {
-        return new Credit(this.raw - other.raw);
+        const result = this.raw - other.raw;
+        if (!Number.isSafeInteger(result)) {
+            throw new RangeError(`Credit.subtract overflow: ${this.raw} - ${other.raw} = ${result}`);
+        }
+        return new Credit(result);
     }
     /** Multiply by a factor, rounding to nearest raw unit. */
     multiply(factor) {
-        return new Credit(Math.round(this.raw * factor));
+        const result = Math.round(this.raw * factor);
+        if (!Number.isSafeInteger(result)) {
+            throw new RangeError(`Credit.multiply overflow: ${this.raw} * ${factor} = ${result}`);
+        }
+        return new Credit(result);
     }
     /** True if this credit is negative. */
     isNegative() {

package/dist/credits/credit.test.js

@@ -103,6 +103,38 @@ describe("Credit", () => {
         it("multiply by zero gives zero", () => {
             expect(Credit.fromDollars(5).multiply(0).isZero()).toBe(true);
         });
+        it("add throws RangeError on positive overflow", () => {
+            const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+            const b = Credit.fromRaw(1);
+            expect(() => a.add(b)).toThrow(RangeError);
+        });
+        it("subtract throws RangeError on negative overflow", () => {
+            const a = Credit.fromRaw(-Number.MAX_SAFE_INTEGER);
+            const b = Credit.fromRaw(1);
+            expect(() => a.subtract(b)).toThrow(RangeError);
+        });
+        it("multiply throws RangeError on overflow", () => {
+            const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+            expect(() => a.multiply(2)).toThrow(RangeError);
+        });
+        it("multiply throws RangeError on Infinity factor", () => {
+            const a = Credit.fromRaw(1);
+            expect(() => a.multiply(Infinity)).toThrow(RangeError);
+        });
+        it("multiply throws RangeError on NaN factor", () => {
+            const a = Credit.fromRaw(1);
+            expect(() => a.multiply(NaN)).toThrow(RangeError);
+        });
+        it("add does not throw for values within safe range", () => {
+            const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER - 1);
+            const b = Credit.fromRaw(1);
+            expect(a.add(b).toRaw()).toBe(Number.MAX_SAFE_INTEGER);
+        });
+        it("subtract does not throw for values within safe range", () => {
+            const a = Credit.fromRaw(-(Number.MAX_SAFE_INTEGER - 1));
+            const b = Credit.fromRaw(1);
+            expect(a.subtract(b).toRaw()).toBe(-Number.MAX_SAFE_INTEGER);
+        });
     });
     describe("comparison", () => {
         it("isNegative returns true for negative", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.39.2",
+  "version": "1.39.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/credits/credit.test.ts

@@ -124,6 +124,45 @@ describe("Credit", () => {
     it("multiply by zero gives zero", () => {
       expect(Credit.fromDollars(5).multiply(0).isZero()).toBe(true);
     });
+
+    it("add throws RangeError on positive overflow", () => {
+      const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+      const b = Credit.fromRaw(1);
+      expect(() => a.add(b)).toThrow(RangeError);
+    });
+
+    it("subtract throws RangeError on negative overflow", () => {
+      const a = Credit.fromRaw(-Number.MAX_SAFE_INTEGER);
+      const b = Credit.fromRaw(1);
+      expect(() => a.subtract(b)).toThrow(RangeError);
+    });
+
+    it("multiply throws RangeError on overflow", () => {
+      const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+      expect(() => a.multiply(2)).toThrow(RangeError);
+    });
+
+    it("multiply throws RangeError on Infinity factor", () => {
+      const a = Credit.fromRaw(1);
+      expect(() => a.multiply(Infinity)).toThrow(RangeError);
+    });
+
+    it("multiply throws RangeError on NaN factor", () => {
+      const a = Credit.fromRaw(1);
+      expect(() => a.multiply(NaN)).toThrow(RangeError);
+    });
+
+    it("add does not throw for values within safe range", () => {
+      const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER - 1);
+      const b = Credit.fromRaw(1);
+      expect(a.add(b).toRaw()).toBe(Number.MAX_SAFE_INTEGER);
+    });
+
+    it("subtract does not throw for values within safe range", () => {
+      const a = Credit.fromRaw(-(Number.MAX_SAFE_INTEGER - 1));
+      const b = Credit.fromRaw(1);
+      expect(a.subtract(b).toRaw()).toBe(-Number.MAX_SAFE_INTEGER);
+    });
   });
 
   describe("comparison", () => {

package/src/credits/credit.ts

@@ -101,17 +101,29 @@ export class Credit {
 
   /** Add another Credit, returning a new Credit. */
   add(other: Credit): Credit {
-    return new Credit(this.raw + other.raw);
+    const result = this.raw + other.raw;
+    if (!Number.isSafeInteger(result)) {
+      throw new RangeError(`Credit.add overflow: ${this.raw} + ${other.raw} = ${result}`);
+    }
+    return new Credit(result);
   }
 
   /** Subtract another Credit, returning a new Credit (may be negative). */
   subtract(other: Credit): Credit {
-    return new Credit(this.raw - other.raw);
+    const result = this.raw - other.raw;
+    if (!Number.isSafeInteger(result)) {
+      throw new RangeError(`Credit.subtract overflow: ${this.raw} - ${other.raw} = ${result}`);
+    }
+    return new Credit(result);
   }
 
   /** Multiply by a factor, rounding to nearest raw unit. */
   multiply(factor: number): Credit {
-    return new Credit(Math.round(this.raw * factor));
+    const result = Math.round(this.raw * factor);
+    if (!Number.isSafeInteger(result)) {
+      throw new RangeError(`Credit.multiply overflow: ${this.raw} * ${factor} = ${result}`);
+    }
+    return new Credit(result);
   }
 
   /** True if this credit is negative. */