@bsv/sdk 1.3.12 → 1.3.14

package/src/primitives/Point.ts

@@ -1,3 +1,4 @@
+
 import BasePoint from './BasePoint.js'
 import JPoint from './JacobianPoint.js'
 import BigNumber from './BigNumber.js'
@@ -44,8 +45,10 @@ export default class Point extends BasePoint {
   static fromDER (bytes: number[]): Point {
     const len = 32
     // uncompressed, hybrid-odd, hybrid-even
-    if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
-      bytes.length - 1 === 2 * len) {
+    if (
+      (bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&
+      bytes.length - 1 === 2 * len
+    ) {
       if (bytes[0] === 0x06) {
         if (bytes[bytes.length - 1] % 2 !== 0) {
           throw new Error('Point string value is wrong length')
@@ -62,8 +65,10 @@ export default class Point extends BasePoint {
       )
 
       return res
-    } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&
-      bytes.length - 1 === len) {
+    } else if (
+      (bytes[0] === 0x02 || bytes[0] === 0x03) &&
+      bytes.length - 1 === len
+    ) {
       return Point.fromX(bytes.slice(1, 1 + len), bytes[0] === 0x03)
     }
     throw new Error('Unknown point format')
@@ -145,7 +150,7 @@ export default class Point extends BasePoint {
       const p = BigInt(
         '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F'
       )
-      const a = BigInt(0)
+      // const a = BigInt(0)
       const b = BigInt(7)
 
       // Convert x to BigInt
@@ -155,10 +160,7 @@ export default class Point extends BasePoint {
       } else if (typeof x === 'string') {
         xBigInt = BigInt('0x' + x)
       } else if (Array.isArray(x)) {
-        xBigInt = BigInt(
-          '0x' +
-          toHex(x).padStart(64, '0')
-        )
+        xBigInt = BigInt('0x' + toHex(x).padStart(64, '0'))
       } else if (typeof x === 'number') {
         xBigInt = BigInt(x)
       } else {
@@ -179,7 +181,7 @@ export default class Point extends BasePoint {
       }
 
       // Adjust y to match the oddness
-      const isYOdd = (y % BigInt(2)) === BigInt(1)
+      const isYOdd = y % BigInt(2) === BigInt(1)
       if ((odd && !isYOdd) || (!odd && isYOdd)) {
         y = p - y
       }
@@ -232,9 +234,7 @@ export default class Point extends BasePoint {
    * const serializedPoint = '{"x":52,"y":15}';
    * const point = Point.fromJSON(serializedPoint, true);
    */
-  static fromJSON (
-    obj: string | any[], isRed: boolean
-  ): Point {
+  static fromJSON (obj: string | any[], isRed: boolean): Point {
     if (typeof obj === 'string') {
       obj = JSON.parse(obj)
     }
@@ -250,18 +250,20 @@ export default class Point extends BasePoint {
     const pre = obj[2]
     res.precomputed = {
       beta: null,
-      doubles: typeof pre.doubles === 'object' && pre.doubles !== null
-        ? {
-            step: pre.doubles.step,
-            points: [res].concat(pre.doubles.points.map(obj2point))
-          }
-        : undefined,
-      naf: typeof pre.naf === 'object' && pre.naf !== null
-        ? {
-            wnd: pre.naf.wnd,
-            points: [res].concat(pre.naf.points.map(obj2point))
-          }
-        : undefined
+      doubles:
+        typeof pre.doubles === 'object' && pre.doubles !== null
+          ? {
+              step: pre.doubles.step,
+              points: [res].concat(pre.doubles.points.map(obj2point))
+            }
+          : undefined,
+      naf:
+        typeof pre.naf === 'object' && pre.naf !== null
+          ? {
+              wnd: pre.naf.wnd,
+              points: [res].concat(pre.naf.points.map(obj2point))
+            }
+          : undefined
     }
     return res
   }
@@ -301,8 +303,12 @@ export default class Point extends BasePoint {
         this.x.forceRed(this.curve.red)
         this.y.forceRed(this.curve.red)
       }
-      if (this.x.red === null) { this.x = this.x.toRed(this.curve.red) }
-      if (this.y.red === null) { this.y = this.y.toRed(this.curve.red) }
+      if (this.x.red === null) {
+        this.x = this.x.toRed(this.curve.red)
+      }
+      if (this.y.red === null) {
+        this.y = this.y.toRed(this.curve.red)
+      }
       this.inf = false
     }
   }
@@ -378,25 +384,40 @@ export default class Point extends BasePoint {
    * const aPoint = new Point(x, y);
    * const jsonPoint = aPoint.toJSON();
    */
-  toJSON (): [BigNumber | null, BigNumber | null, { doubles: { step: any, points: any[] } | undefined, naf: { wnd: any, points: any[] } | undefined }?] {
-    if (this.precomputed == null) { return [this.x, this.y] }
+  toJSON (): [
+    BigNumber | null,
+    BigNumber | null,
+    {
+      doubles: { step: any, points: any[] } | undefined
+      naf: { wnd: any, points: any[] } | undefined
+    }?,
+  ] {
+    if (this.precomputed == null) {
+      return [this.x, this.y]
+    }
 
-    return [this.x, this.y, typeof this.precomputed === 'object' && this.precomputed !== null
-      ? {
-          doubles: (this.precomputed.doubles != null)
-            ? {
-                step: this.precomputed.doubles.step,
-                points: this.precomputed.doubles.points.slice(1)
-              }
-            : undefined,
-          naf: (this.precomputed.naf != null)
-            ? {
-                wnd: this.precomputed.naf.wnd,
-                points: this.precomputed.naf.points.slice(1)
-              }
-            : undefined
-        }
-      : undefined]
+    return [
+      this.x,
+      this.y,
+      typeof this.precomputed === 'object' && this.precomputed !== null
+        ? {
+            doubles:
+            this.precomputed.doubles != null
+              ? {
+                  step: this.precomputed.doubles.step,
+                  points: this.precomputed.doubles.points.slice(1)
+                }
+              : undefined,
+            naf:
+            this.precomputed.naf != null
+              ? {
+                  wnd: this.precomputed.naf.wnd,
+                  points: this.precomputed.naf.points.slice(1)
+                }
+              : undefined
+          }
+        : undefined
+    ]
   }
 
   /**
@@ -413,8 +434,13 @@ export default class Point extends BasePoint {
     if (this.isInfinity()) {
       return '<EC Point Infinity>'
     }
-    return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +
-      ' y: ' + this.y.fromRed().toString(16, 2) + '>'
+    return (
+      '<EC Point x: ' +
+      (this.x?.fromRed()?.toString(16, 2) ?? 'undefined') +
+      ' y: ' +
+      (this.y?.fromRed()?.toString(16, 2) ?? 'undefined') +
+      '>'
+    )
   }
 
   /**
@@ -444,25 +470,41 @@ export default class Point extends BasePoint {
    */
   add (p: Point): Point {
     // O + P = P
-    if (this.inf) { return p }
+    if (this.inf) {
+      return p
+    }
 
     // P + O = P
-    if (p.inf) { return this }
+    if (p.inf) {
+      return this
+    }
 
     // P + P = 2P
-    if (this.eq(p)) { return this.dbl() }
+    if (this.eq(p)) {
+      return this.dbl()
+    }
 
     // P + (-P) = O
-    if (this.neg().eq(p)) { return new Point(null, null) }
+    if (this.neg().eq(p)) {
+      return new Point(new BigNumber(0), new BigNumber(0))
+    }
 
     // P + Q = O
-    if (this.x.cmp(p.x) === 0) { return new Point(null, null) }
+    if (this.x?.cmp(p.x ?? new BigNumber(0)) === 0) {
+      return new Point(new BigNumber(0), new BigNumber(0))
+    }
 
-    let c = this.y.redSub(p.y)
-    if (c.cmpn(0) !== 0) { c = c.redMul(this.x.redSub(p.x).redInvm()) }
-    const nx = c.redSqr().redISub(this.x).redISub(p.x)
-    const ny = c.redMul(this.x.redSub(nx)).redISub(this.y)
-    return new Point(nx, ny)
+    let c = this.y?.redSub(p.y ?? new BigNumber(0)) ?? new BigNumber(0)
+    if (c.cmpn(0) !== 0) {
+      c = c.redMul(this.x?.redSub(p.x ?? new BigNumber(0)).redInvm() ?? new BigNumber(1))
+    }
+
+    const nx = c?.redSqr().redISub(this.x ?? new BigNumber(0)).redISub(p.x ?? new BigNumber(0))
+    const ny = (c ?? new BigNumber(1))
+      .redMul((this.x ?? new BigNumber(0)).redSub(nx ?? new BigNumber(0)))
+      .redISub(this.y ?? new BigNumber(0))
+
+    return new Point(nx ?? new BigNumber(0), ny ?? new BigNumber(0))
   }
 
   /**
@@ -475,22 +517,24 @@ export default class Point extends BasePoint {
    * const result = P.dbl();
    * */
   dbl (): Point {
-    if (this.inf) { return this }
+    if (this.inf) {
+      return this
+    }
 
     // 2P = O
-    const ys1 = this.y.redAdd(this.y)
+    const ys1 = (this.y ?? new BigNumber(0)).redAdd(this.y ?? new BigNumber(0))
     if (ys1.cmpn(0) === 0) {
-      return new Point(null, null)
+      return new Point(new BigNumber(0), new BigNumber(0))
     }
 
     const a = this.curve.a
-
-    const x2 = this.x.redSqr()
+    const x2 = (this.x ?? new BigNumber(0)).redSqr()
     const dyinv = ys1.redInvm()
     const c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv)
 
-    const nx = c.redSqr().redISub(this.x.redAdd(this.x))
-    const ny = c.redMul(this.x.redSub(nx)).redISub(this.y)
+    const nx = c.redSqr().redISub((this.x ?? new BigNumber(0)).redAdd(this.x ?? new BigNumber(0)))
+    const ny = c.redMul((this.x ?? new BigNumber(0)).redSub(nx)).redISub(this.y ?? new BigNumber(0))
+
     return new Point(nx, ny)
   }
 
@@ -502,7 +546,7 @@ export default class Point extends BasePoint {
    * const x = P.getX();
    */
   getX (): BigNumber {
-    return this.x.fromRed()
+    return (this.x ?? new BigNumber(0)).fromRed()
   }
 
   /**
@@ -513,7 +557,7 @@ export default class Point extends BasePoint {
    * const x = P.getX();
    */
   getY (): BigNumber {
-    return this.y.fromRed()
+    return (this.y ?? new BigNumber(0)).fromRed()
   }
 
   /**
@@ -597,9 +641,11 @@ export default class Point extends BasePoint {
    * const areEqual = p1.eq(p2); // returns true
    */
   eq (p: Point): boolean {
-    return this === p || (
-      (this.inf === p.inf) &&
-      (this.inf || (this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0)))
+    return (
+      this === p ||
+      (this.inf === p.inf &&
+        (this.inf || ((this.x ?? new BigNumber(0)).cmp(p.x ?? new BigNumber(0)) === 0 && (this.y ?? new BigNumber(0)).cmp(p.y ?? new BigNumber(0)) === 0)))
+    )
   }
 
   /**
@@ -612,24 +658,30 @@ export default class Point extends BasePoint {
    * const result = P.neg();
    */
   neg (_precompute?: boolean): Point {
-    if (this.inf) { return this }
-
-    const res = new Point(this.x, this.y.redNeg())
-    if (_precompute && (this.precomputed != null)) {
+    if (this.inf) {
+      return this
+    }
+    const res = new Point(this.x, (this.y ?? new BigNumber(0)).redNeg())
+    if (_precompute === true && this.precomputed != null) {
       const pre = this.precomputed
       const negate = (p: Point): Point => p.neg()
       res.precomputed = {
-        naf: (pre.naf != null) && {
-          wnd: pre.naf.wnd,
-          points: pre.naf.points.map(negate)
-        },
-        doubles: (pre.doubles != null) && {
-          step: pre.doubles.step,
-          points: pre.doubles.points.map((p) => p.neg())
-        },
+        naf: pre.naf != null
+          ? {
+              wnd: pre.naf.wnd,
+              points: pre.naf.points.map(negate) as BasePoint[]
+            }
+          : undefined,
+        doubles: pre.doubles != null
+          ? {
+              step: pre.doubles.step,
+              points: pre.doubles.points.map((p) => (p as Point).neg())
+            }
+          : undefined,
         beta: undefined
       }
     }
+
     return res
   }
 
@@ -650,7 +702,9 @@ export default class Point extends BasePoint {
   dblp (k: number): Point {
     /* eslint-disable @typescript-eslint/no-this-alias */
     let r: Point = this
-    for (let i = 0; i < k; i++) { r = r.dbl() }
+    for (let i = 0; i < k; i++) {
+      r = r.dbl()
+    }
     return r
   }
 
@@ -674,34 +728,49 @@ export default class Point extends BasePoint {
   }
 
   private _getBeta (): undefined | Point {
-    if (typeof this.curve.endo !== 'object') { return }
+    if (typeof this.curve.endo !== 'object') {
+      return
+    }
 
     const pre = this.precomputed
-    if (typeof pre === 'object' && pre !== null && typeof pre.beta === 'object' && pre.beta !== null) {
+    if (
+      typeof pre === 'object' &&
+      pre !== null &&
+      typeof pre.beta === 'object' &&
+      pre.beta !== null
+    ) {
       return pre.beta as Point
     }
 
-    const beta = new Point(this.x.redMul(this.curve.endo.beta), this.y)
+    const beta = new Point((this.x ?? new BigNumber(0)).redMul(this.curve.endo.beta), this.y)
     if (pre != null) {
       const curve = this.curve
       const endoMul = (p: Point): Point => {
+        if (p.x === null) {
+          throw new Error('p.x is null')
+        }
+        if (curve.endo === undefined || curve.endo === null) {
+          throw new Error('curve.endo is undefined')
+        }
         return new Point(p.x.redMul(curve.endo.beta), p.y)
       }
       pre.beta = beta
       beta.precomputed = {
         beta: null,
-        naf: (pre.naf != null)
-          ? {
-              wnd: pre.naf.wnd,
-              points: pre.naf.points.map(endoMul)
-            }
-          : undefined,
-        doubles: (pre.doubles != null)
-          ? {
-              step: pre.doubles.step,
-              points: pre.doubles.points.map(endoMul)
-            }
-          : undefined
+        naf:
+          pre.naf != null
+            ? {
+                wnd: pre.naf.wnd,
+                points: pre.naf.points.map(endoMul)
+              }
+            : undefined,
+        doubles:
+          pre.doubles != null
+            ? {
+                step: pre.doubles.step,
+                points: pre.doubles.points.map(endoMul)
+              }
+            : undefined
       }
     }
     return beta
@@ -735,7 +804,7 @@ export default class Point extends BasePoint {
         if (nafW === i) {
           b = b.mixedAdd(doubles.points[j])
         } else if (nafW === -i) {
-          b = b.mixedAdd((doubles.points[j]).neg())
+          b = b.mixedAdd(doubles.points[j].neg())
         }
       }
       a = a.add(b)
@@ -750,17 +819,17 @@ export default class Point extends BasePoint {
     len: number,
     jacobianResult?: boolean
   ): BasePoint {
-    const wndWidth = this.curve._wnafT1
-    const wnd = this.curve._wnafT2
-    const naf = this.curve._wnafT3
+    const wndWidth: number[] = this.curve._wnafT1.map(num => num.toNumber()) // Convert BigNumber to number
+    const wnd: Point[][] = this.curve._wnafT2.map(() => []) // Initialize as empty Point[][] array
+    const naf: number[][] = this.curve._wnafT3.map(() => []) // Initialize as empty number[][] array
 
     // Fill all arrays
     let max = 0
     for (let i = 0; i < len; i++) {
       const p = points[i]
       const nafPoints = p._getNAFPoints(defW)
-      wndWidth[i] = nafPoints.wnd
-      wnd[i] = nafPoints.points
+      wndWidth[i] = nafPoints.wnd // Ensure correct type
+      wnd[i] = nafPoints.points // Ensure correct type
     }
 
     // Comb small window NAFs
@@ -768,27 +837,33 @@ export default class Point extends BasePoint {
       const a = i - 1
       const b = i
       if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
-        naf[a] = this.curve
-          .getNAF(coeffs[a], wndWidth[a], this.curve._bitLength)
-        naf[b] = this.curve
-          .getNAF(coeffs[b], wndWidth[b], this.curve._bitLength)
+        naf[a] = this.curve.getNAF(
+          coeffs[a],
+          wndWidth[a],
+          this.curve._bitLength
+        )
+        naf[b] = this.curve.getNAF(
+          coeffs[b],
+          wndWidth[b],
+          this.curve._bitLength
+        )
         max = Math.max(naf[a].length, max)
         max = Math.max(naf[b].length, max)
         continue
       }
 
       const comb: any[] = [
-        points[a], /* 1 */
-        null, /* 3 */
-        null, /* 5 */
+        points[a] /* 1 */,
+        null /* 3 */,
+        null /* 5 */,
         points[b] /* 7 */
       ]
 
       // Try to avoid Projective points, if possible
-      if (points[a].y.cmp(points[b].y) === 0) {
+      if ((points[a].y ?? new BigNumber(0)).cmp(points[b].y ?? new BigNumber(0)) === 0) {
         comb[1] = points[a].add(points[b])
         comb[2] = points[a].toJ().mixedAdd(points[b].neg())
-      } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
+      } else if ((points[a].y ?? new BigNumber(0)).cmp((points[b].y ?? new BigNumber(0)).redNeg()) === 0) {
         comb[1] = points[a].toJ().mixedAdd(points[b])
         comb[2] = points[a].add(points[b].neg())
       } else {
@@ -797,15 +872,8 @@ export default class Point extends BasePoint {
       }
 
       const index = [
-        -3, /* -1 -1 */
-        -1, /* -1 0 */
-        -5, /* -1 1 */
-        -7, /* 0 -1 */
-        0, /* 0 0 */
-        7, /* 0 1 */
-        5, /* 1 -1 */
-        1, /* 1 0 */
-        3 /* 1 1 */
+        -3 /* -1 -1 */, -1 /* -1 0 */, -5 /* -1 1 */, -7 /* 0 -1 */,
+        0 /* 0 0 */, 7 /* 0 1 */, 5 /* 1 -1 */, 1 /* 1 0 */, 3 /* 1 1 */
       ]
 
       const jsf = this.curve.getJSF(coeffs[a], coeffs[b])
@@ -830,26 +898,38 @@ export default class Point extends BasePoint {
       while (i >= 0) {
         let zero = true
         for (let j = 0; j < len; j++) {
-          tmp[j] = naf[j][i] | 0
-          if (tmp[j] !== 0) { zero = false }
+          tmp[j] = new BigNumber(typeof naf[j][i] === 'number' ? naf[j][i] : 0) // Ensure type consistency
+          if (!tmp[j].isZero()) { // Use BigNumber's built-in comparison
+            zero = false
+          }
+        }
+        if (!zero) {
+          break
         }
-        if (!zero) { break }
         k++
         i--
       }
-      if (i >= 0) { k++ }
+      if (i >= 0) {
+        k++
+      }
       acc = acc.dblp(k)
-      if (i < 0) { break }
+      if (i < 0) {
+        break
+      }
+
+      const one = new BigNumber(1)
+      const two = new BigNumber(2)
 
       for (let j = 0; j < len; j++) {
         const z = tmp[j]
         let p
-        if (z === 0) {
+
+        if (z.cmpn(0) === 0) { // Check if z is 0
           continue
-        } else if (z > 0) {
-          p = wnd[j][(z - 1) >> 1]
-        } else if (z < 0) {
-          p = wnd[j][(-z - 1) >> 1].neg()
+        } else if (!z.isNeg()) { // If z is positive
+          p = wnd[j][z.sub(one).div(two).toNumber()]
+        } else { // If z is negative
+          p = wnd[j][z.neg().sub(one).div(two).toNumber()].neg()
         }
 
         if (p.type === 'affine') {
@@ -860,23 +940,29 @@ export default class Point extends BasePoint {
       }
     }
     // Zeroify references
-    for (let i = 0; i < len; i++) { wnd[i] = null }
+    for (let i = 0; i < len; i++) {
+      wnd[i] = []
+    }
 
-    if (jacobianResult) {
+    if (jacobianResult === true) {
       return acc
     } else {
       return acc.toP()
     }
   }
 
-  private _endoWnafMulAdd (points: Point[], coeffs, jacobianResult?: boolean): BasePoint {
-    const npoints = this.curve._endoWnafT1
-    const ncoeffs = this.curve._endoWnafT2
-    let i
+  private _endoWnafMulAdd (
+    points: Point[],
+    coeffs: BigNumber[], // Explicitly type coeffs
+    jacobianResult?: boolean
+  ): BasePoint {
+    const npoints: Point[] = new Array(points.length * 2)
+    const ncoeffs: BigNumber[] = new Array(points.length * 2)
+    let i: number
     for (i = 0; i < points.length; i++) {
       const split = this.curve._endoSplit(coeffs[i])
       let p = points[i]
-      let beta = p._getBeta()
+      let beta: Point = p._getBeta() ?? new Point(new BigNumber(0), new BigNumber(0))
 
       if (split.k1.negative !== 0) {
         split.k1.ineg()
@@ -892,31 +978,39 @@ export default class Point extends BasePoint {
       ncoeffs[i * 2] = split.k1
       ncoeffs[i * 2 + 1] = split.k2
     }
+
     const res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult)
 
     // Clean-up references to points and coefficients
     for (let j = 0; j < i * 2; j++) {
-      npoints[j] = null
-      ncoeffs[j] = null
+      npoints[j] = null as unknown as Point
+      ncoeffs[j] = null as unknown as BigNumber
     }
     return res
   }
 
   private _hasDoubles (k: BigNumber): boolean {
-    if (this.precomputed == null) { return false }
+    if (this.precomputed == null) {
+      return false
+    }
 
     const doubles = this.precomputed.doubles
-    if (typeof doubles !== 'object') { return false }
+    if (typeof doubles !== 'object') {
+      return false
+    }
 
-    return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step)
-  };
+    return (
+      doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step)
+    )
+  }
 
   private _getDoubles (
     step?: number,
     power?: number
   ): { step: number, points: any[] } {
     if (
-      typeof this.precomputed === 'object' && this.precomputed !== null &&
+      typeof this.precomputed === 'object' &&
+      this.precomputed !== null &&
       typeof this.precomputed.doubles === 'object' &&
       this.precomputed.doubles !== null
     ) {
@@ -926,20 +1020,24 @@ export default class Point extends BasePoint {
     const doubles = [this]
     /* eslint-disable @typescript-eslint/no-this-alias */
     let acc: Point = this
-    for (let i = 0; i < power; i += step) {
-      for (let j = 0; j < step; j++) { acc = acc.dbl() }
+    for (let i = 0; i < (power ?? 0); i += (step ?? 1)) {
+      for (let j = 0; j < (step ?? 1); j++) {
+        acc = acc.dbl()
+      }
       doubles.push(acc as this)
     }
     return {
-      step,
+      step: step ?? 1,
       points: doubles
     }
-  };
+  }
 
   private _getNAFPoints (wnd: number): { wnd: number, points: any[] } {
     if (
-      typeof this.precomputed === 'object' && this.precomputed !== null &&
-      typeof this.precomputed.naf === 'object' && this.precomputed.naf !== null
+      typeof this.precomputed === 'object' &&
+      this.precomputed !== null &&
+      typeof this.precomputed.naf === 'object' &&
+      this.precomputed.naf !== null
     ) {
       return this.precomputed.naf
     }
@@ -947,7 +1045,11 @@ export default class Point extends BasePoint {
     const res = [this]
     const max = (1 << wnd) - 1
     const dbl = max === 1 ? null : this.dbl()
-    for (let i = 1; i < max; i++) { res[i] = res[i - 1].add(dbl) as this }
+    for (let i = 1; i < max; i++) {
+      if (dbl !== null) {
+        res[i] = res[i - 1].add(dbl) as this
+      }
+    }
     return {
       wnd,
       points: res