@bsv/sdk 1.5.3 → 1.6.0

package/src/primitives/K256.ts

@@ -43,38 +43,58 @@ export default class K256 extends Mersenne {
    * k256.split(input, output);
    */
   split (input: BigNumber, output: BigNumber): void {
-    // 256 = 9 * 26 + 22
-    const mask = 0x3fffff
+    const mask = 0x3fffff // 22 bits
+    const inputWords = input.words // Access via getter
+    const inputNominalLength = input.length // Access via getter, respects _nominalWordLength
 
-    const outLen = Math.min(input.length, 9)
-    let i = 0
-    for (; i < outLen; i++) {
-      output.words[i] = input.words[i]
+    const outLen = Math.min(inputNominalLength, 9)
+    const tempOutputWords = new Array(outLen + (inputNominalLength > 9 ? 1 : 0)).fill(0)
+
+    for (let i = 0; i < outLen; i++) {
+      tempOutputWords[i] = inputWords[i]
     }
-    output.length = outLen
+    let currentOutputWordCount = outLen
+
+    if (inputNominalLength <= 9) {
+      const finalOutputWords = new Array(currentOutputWordCount)
+      for (let i = 0; i < currentOutputWordCount; ++i) finalOutputWords[i] = tempOutputWords[i]
+      output.words = finalOutputWords // Use setter
 
-    if (input.length <= 9) {
-      input.words[0] = 0
-      input.length = 1
+      input.words = [0] // Use setter to set to 0
       return
     }
 
     // Shift by 9 limbs
-    let prev = input.words[9]
-    output.words[output.length++] = prev & mask
+    let prev = inputWords[9]
+    tempOutputWords[currentOutputWordCount++] = prev & mask
+
+    const finalOutputWords = new Array(currentOutputWordCount)
+    for (let i = 0; i < currentOutputWordCount; ++i) finalOutputWords[i] = tempOutputWords[i]
+    output.words = finalOutputWords // Use setter for output
 
-    for (i = 10; i < input.length; i++) {
-      const next = input.words[i] | 0
-      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22)
+    // For input modification
+    const tempInputNewWords = new Array(Math.max(1, inputNominalLength - 9)).fill(0)
+    let currentInputNewWordCount = 0
+
+    for (let i = 10; i < inputNominalLength; i++) {
+      const next = inputWords[i] | 0
+      if (currentInputNewWordCount < tempInputNewWords.length) { // Boundary check
+        tempInputNewWords[currentInputNewWordCount++] = ((next & mask) << 4) | (prev >>> 22)
+      }
       prev = next
     }
     prev >>>= 22
-    input.words[i - 10] = prev
-    if (prev === 0 && input.length > 10) {
-      input.length -= 10
-    } else {
-      input.length -= 9
+    if (currentInputNewWordCount < tempInputNewWords.length) { // Boundary check
+      tempInputNewWords[currentInputNewWordCount++] = prev
+    } else if (prev !== 0 && tempInputNewWords.length > 0) { // If prev is non-zero but no space, this is an issue.
+      // This case implies original logic might have relied on array auto-expansion or specific length handling
+      // For safety, if there's still a carry and no space, the array should have been bigger.
+      // However, the original logic `input.length -= 9` suggests truncation.
     }
+
+    const finalInputNewWords = new Array(currentInputNewWordCount)
+    for (let i = 0; i < currentInputNewWordCount; ++i) finalInputNewWords[i] = tempInputNewWords[i]
+    input.words = finalInputNewWords // Use setter, which will strip and set magnitude
   }
 
   /**
@@ -90,27 +110,27 @@ export default class K256 extends Mersenne {
    * const result = k256.imulK(number);
    */
   imulK (num: BigNumber): BigNumber {
-    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
-    num.words[num.length] = 0
-    num.words[num.length + 1] = 0
-    num.length += 2
+    const currentWords = num.words // Get current words based on _magnitude and _nominalWordLength
+    const originalNominalLength = num.length // Getter
 
-    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
-    let lo = 0
-    for (let i = 0; i < num.length; i++) {
-      const w = num.words[i] | 0
-      lo += w * 0x3d1
-      num.words[i] = lo & 0x3ffffff
-      lo = w * 0x40 + ((lo / 0x4000000) | 0)
+    const newNominalLength = originalNominalLength + 2
+    const tempWords = new Array(newNominalLength).fill(0)
+
+    for (let i = 0; i < originalNominalLength; i++) {
+      tempWords[i] = currentWords[i]
     }
+    // tempWords is now effectively num.words expanded with zeroes
 
-    // Fast length reduction
-    if (num.words[num.length - 1] === 0) {
-      num.length--
-      if (num.words[num.length - 1] === 0) {
-        num.length--
-      }
+    let lo = 0
+    for (let i = 0; i < newNominalLength; i++) { // Iterate up to new expanded length
+      const w = tempWords[i] | 0
+      lo += w * 0x3d1 // 0x3d1 = 977
+      tempWords[i] = lo & 0x3ffffff // 26-bit mask
+      lo = w * 0x40 + ((lo / 0x4000000) | 0) // 0x40 = 64. 0x4000000 = 2^26
     }
+
+    num.words = tempWords // Use setter to re-initialize from tempWords
+    // The setter will handle _magnitude, _sign, _nominalWordLength, and strip.
     return num
   }
 }

package/src/primitives/Mersenne.ts

@@ -31,7 +31,7 @@ export default class Mersenne {
     this.name = name
     this.p = new BigNumber(p, 16)
     this.n = this.p.bitLength()
-    this.k = new BigNumber(1).iushln(this.n).isub(this.p)
+    this.k = new BigNumber(BigInt(1)).iushln(this.n).isub(this.p) // Use 1n for BigInt compatibility
 
     this.tmp = this._tmp()
   }
@@ -44,8 +44,9 @@ export default class Mersenne {
    * @returns A BigNumber with scaled size depending on prime magnitude.
    */
   private _tmp (): BigNumber {
-    const tmp = new BigNumber()
-    tmp.words = new Array(Math.ceil(this.n / 13))
+    const tmp = new BigNumber(BigInt(0)) // Initialize with BigInt 0
+    const requiredWords = Math.ceil(this.n / BigNumber.wordSize)
+    tmp.expand(Math.max(1, requiredWords)) // Expand sets _nominalWordLength
     return tmp
   }
 
@@ -63,32 +64,25 @@ export default class Mersenne {
   ireduce (num: BigNumber): BigNumber {
     // Assumes that `num` is less than `P^2`
     // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
-    let r = num
+    const r = num // num is directly modified
     let rlen
 
     do {
-      this.split(r, this.tmp)
-      r = this.imulK(r)
-      r = r.iadd(this.tmp)
+      this.split(r, this.tmp) // r is modified (becomes HI), this.tmp becomes LO
+      this.imulK(r) // r becomes HI * K
+      r.iadd(this.tmp) // r becomes HI * K + LO
       rlen = r.bitLength()
     } while (rlen > this.n)
 
     const cmp = rlen < this.n ? -1 : r.ucmp(this.p)
     if (cmp === 0) {
-      r.words[0] = 0
-      r.length = 1
+      r.words = [0] // Set to zero using the words setter
     } else if (cmp > 0) {
       r.isub(this.p)
-    } else {
-      if (r.strip !== undefined) {
-        // r is a BN v4 instance
-        r.strip()
-      } else {
-        // r is a BN v5 instance
-        r.strip()
-      }
     }
-
+    // No explicit strip needed here if operations maintain correctness and setter handles it.
+    // However, ensuring it's stripped to minimal form after reduction is good.
+    r.strip()
     return r
   }
 
@@ -97,13 +91,15 @@ export default class Mersenne {
    * to meet the magnitude of the pseudo-Mersenne prime.
    *
    * @method split
-   * @param input - The BigNumber to be shifted.
-   * @param out - The BigNumber to hold the shifted result.
+   * @param input - The BigNumber to be shifted (will contain HI part).
+   * @param out - The BigNumber to hold the shifted result (LO part).
    *
    * @example
    * mersenne.split(new BigNumber('2345', 16), new BigNumber());
    */
   split (input: BigNumber, out: BigNumber): void {
+    // out gets the LO bits (shifted out part)
+    // input gets modified to be the HI bits (remaining part after shift)
     input.iushrn(this.n, 0, out)
   }
 

package/src/primitives/MontgomoryMethod.ts

@@ -94,8 +94,8 @@ export default class MontgomoryMethod extends ReductionContext {
    */
   imul (a: BigNumber, b: BigNumber): BigNumber {
     if (a.isZero() || b.isZero()) {
-      a.words[0] = 0
-      a.length = 1
+      a.words[0] = 0;
+      (a as any).length = 1
       return a
     }
 

package/src/primitives/__tests/ReductionContext.test.ts

@@ -248,7 +248,12 @@ describe('BN.js/Reduction context', function () {
 
   it('should avoid 4.1.0 regresion', function () {
     const bits2int = (obits, q): BigNumber => {
-      const bits = new BigNumber(obits)
+      let bits
+      if (Buffer.isBuffer(obits)) {
+        bits = new BigNumber(obits.toString('hex'), 16)
+      } else {
+        bits = new BigNumber(obits)
+      }
       const shift = (obits.length << 3) - q.bitLength()
       if (shift > 0) {
         bits.ishrn(shift)

package/src/primitives/utils.ts

@@ -379,21 +379,20 @@ export const fromBase58Check = (
 
 export class Writer {
   public bufs: number[][]
+  private length: number
 
   constructor (bufs?: number[][]) {
     this.bufs = bufs !== undefined ? bufs : []
+    this.length = 0
+    for (const b of this.bufs) this.length += b.length
   }
 
   getLength (): number {
-    let len = 0
-    for (const buf of this.bufs) {
-      len = len + buf.length
-    }
-    return len
+    return this.length
   }
 
   toArray (): number[] {
-    const totalLength = this.getLength()
+    const totalLength = this.length
     const ret = new Array(totalLength)
     let offset = 0
     for (const buf of this.bufs) {
@@ -406,6 +405,7 @@ export class Writer {
 
   write (buf: number[]): this {
     this.bufs.push(buf)
+    this.length += buf.length
     return this
   }
 
@@ -415,6 +415,7 @@ export class Writer {
       buf2[i] = buf[buf.length - 1 - i]
     }
     this.bufs.push(buf2)
+    this.length += buf2.length
     return this
   }
 
@@ -433,10 +434,12 @@ export class Writer {
   }
 
   writeUInt16BE (n: number): this {
-    this.bufs.push([
+    const buf = [
       (n >> 8) & 0xff, // shift right 8 bits to get the high byte
       n & 0xff // low byte is just the last 8 bits
-    ])
+    ]
+    this.bufs.push(buf)
+    this.length += 2
     return this
   }
 
@@ -445,10 +448,12 @@ export class Writer {
   }
 
   writeUInt16LE (n: number): this {
-    this.bufs.push([
+    const buf = [
       n & 0xff, // low byte is just the last 8 bits
       (n >> 8) & 0xff // shift right 8 bits to get the high byte
-    ])
+    ]
+    this.bufs.push(buf)
+    this.length += 2
     return this
   }
 
@@ -457,12 +462,14 @@ export class Writer {
   }
 
   writeUInt32BE (n: number): this {
-    this.bufs.push([
+    const buf = [
       (n >> 24) & 0xff, // highest byte
       (n >> 16) & 0xff,
       (n >> 8) & 0xff,
       n & 0xff // lowest byte
-    ])
+    ]
+    this.bufs.push(buf)
+    this.length += 4
     return this
   }
 
@@ -471,12 +478,14 @@ export class Writer {
   }
 
   writeUInt32LE (n: number): this {
-    this.bufs.push([
+    const buf = [
       n & 0xff, // lowest byte
       (n >> 8) & 0xff,
       (n >> 16) & 0xff,
       (n >> 24) & 0xff // highest byte
-    ])
+    ]
+    this.bufs.push(buf)
+    this.length += 4
     return this
   }
 
@@ -587,24 +596,26 @@ export class Writer {
 export class Reader {
   public bin: number[]
   public pos: number
+  private readonly length: number
 
   constructor (bin: number[] = [], pos: number = 0) {
     this.bin = bin
     this.pos = pos
+    this.length = bin.length
   }
 
   public eof (): boolean {
-    return this.pos >= this.bin.length
+    return this.pos >= this.length
   }
 
-  public read (len = this.bin.length): number[] {
+  public read (len = this.length): number[] {
     const start = this.pos
     const end = this.pos + len
     this.pos = end
     return this.bin.slice(start, end)
   }
 
-  public readReverse (len = this.bin.length): number[] {
+  public readReverse (len = this.length): number[] {
     const buf2 = new Array(len)
     for (let i = 0; i < len; i++) {
       buf2[i] = this.bin[this.pos + len - 1 - i]