@bsv/sdk 1.1.23 → 1.1.25

package/src/primitives/Point.ts

@@ -17,6 +17,10 @@ import ReductionContext from './ReductionContext.js'
  * @property inf - Flag to record if the point is at infinity in the Elliptic Curve.
  */
 export default class Point extends BasePoint {
+  private static readonly red: any = new ReductionContext('k256')
+  private static readonly a: BigNumber = new BigNumber(0).toRed(Point.red)
+  private static readonly b: BigNumber = new BigNumber(7).toRed(Point.red)
+  private static readonly zero: BigNumber = new BigNumber(0).toRed(Point.red)
   x: BigNumber | null
   y: BigNumber | null
   inf: boolean
@@ -59,7 +63,7 @@ export default class Point extends BasePoint {
 
       return res
     } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&
-              bytes.length - 1 === len) {
+      bytes.length - 1 === len) {
       return Point.fromX(bytes.slice(1, 1 + len), bytes[0] === 0x03)
     }
     throw new Error('Unknown point format')
@@ -87,6 +91,13 @@ export default class Point extends BasePoint {
     return Point.fromDER(bytes)
   }
 
+  static redSqrtOptimized (y2: BigNumber): BigNumber {
+    const red = Point.red
+    const p = red.m // The modulus
+    const exponent = p.addn(1).iushrn(2) // (p + 1) / 4
+    return y2.redPow(exponent)
+  }
+
   /**
    * Generates a point from an x coordinate and a boolean indicating whether the corresponding
    * y coordinate is odd.
@@ -102,34 +113,108 @@ export default class Point extends BasePoint {
    * const xCoordinate = new BigNumber('10');
    * const point = Point.fromX(xCoordinate, true);
    */
-
   static fromX (x: BigNumber | number | number[] | string, odd: boolean): Point {
-    const red = new ReductionContext('k256')
-    const a = new BigNumber(0).toRed(red)
-    const b = new BigNumber(7).toRed(red)
-    const zero = new BigNumber(0).toRed(red)
-    if (!BigNumber.isBN(x)) {
-      x = new BigNumber(x as number, 16)
-    }
-    x = x as BigNumber
-    if (x.red == null) {
-      x = x.toRed(red)
-    }
+    if (typeof BigInt === 'function') {
+      function mod (a: bigint, n: bigint): bigint {
+        return ((a % n) + n) % n
+      }
+      function modPow (base: bigint, exponent: bigint, modulus: bigint): bigint {
+        let result = BigInt(1)
+        base = mod(base, modulus)
+        while (exponent > BigInt(0)) {
+          if ((exponent & BigInt(1)) === BigInt(1)) {
+            result = mod(result * base, modulus)
+          }
+          exponent >>= BigInt(1)
+          base = mod(base * base, modulus)
+        }
+        return result
+      }
+      function sqrtMod (a: bigint, p: bigint): bigint | null {
+        const exponent = (p + BigInt(1)) >> BigInt(2) // Precomputed exponent
+        const sqrtCandidate = modPow(a, exponent, p)
+        if (mod(sqrtCandidate * sqrtCandidate, p) === mod(a, p)) {
+          return sqrtCandidate
+        } else {
+          // No square root exists
+          return null
+        }
+      }
 
-    const y2 = x.redSqr().redMul(x).redIAdd(x.redMul(a)).redIAdd(b)
-    let y = y2.redSqrt()
-    if (y.redSqr().redSub(y2).cmp(zero) !== 0) {
-      throw new Error('invalid point')
-    }
+      // Curve parameters for secp256k1
+      const p = BigInt(
+        '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F'
+      )
+      const a = BigInt(0)
+      const b = BigInt(7)
+
+      // Convert x to BigInt
+      let xBigInt: bigint
+      if (x instanceof BigNumber) {
+        xBigInt = BigInt('0x' + x.toString(16))
+      } else if (typeof x === 'string') {
+        xBigInt = BigInt('0x' + x)
+      } else if (Array.isArray(x)) {
+        xBigInt = BigInt(
+          '0x' +
+          Buffer.from(x).toString('hex').padStart(64, '0')
+        )
+      } else if (typeof x === 'number') {
+        xBigInt = BigInt(x)
+      } else {
+        throw new Error('Invalid x-coordinate type')
+      }
 
-    // XXX Is there any way to tell if the number is odd without converting it
-    // to non-red form?
-    const isOdd = y.fromRed().isOdd()
-    if ((odd && !isOdd) || (!odd && isOdd)) {
-      y = y.redNeg()
-    }
+      // Ensure x is within field range
+      xBigInt = mod(xBigInt, p)
 
-    return new Point(x, y)
+      // Compute y^2 = x^3 + a x + b mod p
+      const y2 = mod(modPow(xBigInt, BigInt(3), p) + b, p)
+
+      // Compute modular square root y = sqrt(y2) mod p
+      let y = sqrtMod(y2, p)
+
+      if (y === null) {
+        throw new Error('Invalid point')
+      }
+
+      // Adjust y to match the oddness
+      const isYOdd = (y % BigInt(2)) === BigInt(1)
+      if ((odd && !isYOdd) || (!odd && isYOdd)) {
+        y = p - y
+      }
+
+      // Convert x and y to BigNumber
+      const xBN = new BigNumber(xBigInt.toString(16), 16)
+      const yBN = new BigNumber(y.toString(16), 16)
+      return new Point(xBN, yBN)
+    } else {
+      const red = new ReductionContext('k256')
+      const a = new BigNumber(0).toRed(red)
+      const b = new BigNumber(7).toRed(red)
+      const zero = new BigNumber(0).toRed(red)
+      if (!BigNumber.isBN(x)) {
+        x = new BigNumber(x as number, 16)
+      }
+      x = x as BigNumber
+      if (x.red == null) {
+        x = x.toRed(red)
+      }
+
+      const y2 = x.redSqr().redMul(x).redIAdd(x.redMul(a)).redIAdd(b)
+      let y = y2.redSqrt()
+      if (y.redSqr().redSub(y2).cmp(zero) !== 0) {
+        throw new Error('invalid point')
+      }
+
+      // XXX Is there any way to tell if the number is odd without converting it
+      // to non-red form?
+      const isOdd = y.fromRed().isOdd()
+      if ((odd && !isOdd) || (!odd && isOdd)) {
+        y = y.redNeg()
+      }
+      return new Point(x, y)
+    }
   }
 
   /**

package/src/primitives/TransactionSignature.ts

@@ -40,7 +40,7 @@ export default class TransactionSignature extends Signature {
       const writer = new Writer()
       for (const input of inputs) {
         if (typeof input.sourceTXID === 'undefined') {
-          writer.writeReverse(input.sourceTransaction.id())
+          writer.write(input.sourceTransaction.hash() as number[])
         } else {
           writer.writeReverse(toArray(input.sourceTXID, 'hex'))
         }
@@ -122,8 +122,9 @@ export default class TransactionSignature extends Signature {
     writer.writeUInt32LE(params.sourceOutputIndex)
 
     // scriptCode of the input (serialized as scripts inside CTxOuts)
-    writer.writeVarIntNum(params.subscript.toBinary().length)
-    writer.write(params.subscript.toBinary())
+    const subscriptBin = params.subscript.toBinary()
+    writer.writeVarIntNum(subscriptBin.length)
+    writer.write(subscriptBin)
 
     // value of the output spent by this input (8-byte little endian)
     writer.writeUInt64LE(params.sourceSatoshis)

package/src/primitives/utils.ts

@@ -320,9 +320,13 @@ export class Writer {
   }
 
   toArray (): number[] {
-    let ret = []
-    for (const x of this.bufs) {
-      if (x.length < 65536) { ret.push(...x) } else { ret = ret.concat(x) }
+    const totalLength = this.getLength()
+    const ret = new Array(totalLength)
+    let offset = 0
+    for (const buf of this.bufs) {
+      for (let i = 0; i < buf.length; i++) {
+        ret[offset++] = buf[i]
+      }
     }
     return ret
   }
@@ -515,18 +519,18 @@ export class Reader {
   }
 
   public read (len = this.bin.length): number[] {
-    const bin = this.bin.slice(this.pos, this.pos + len)
-    this.pos = this.pos + len
-    return bin
+    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[] {
-    const bin = this.bin.slice(this.pos, this.pos + len)
-    this.pos = this.pos + len
-    const buf2 = new Array(bin.length)
-    for (let i = 0; i < buf2.length; i++) {
-      buf2[i] = bin[bin.length - 1 - i]
+    const buf2 = new Array(len)
+    for (let i = 0; i < len; i++) {
+      buf2[i] = this.bin[this.pos + len - 1 - i]
     }
+    this.pos += len
     return buf2
   }
 

package/src/script/Spend.ts

@@ -207,9 +207,9 @@ export default class Spend {
     }
 
     const padDataToSize = (buf: number[], len: number): number[] => {
-      let b = buf
+      const b = buf
       while (b.length < len) {
-        b = [0x00, ...b]
+        b.unshift(0)
       }
       return b
     }
@@ -785,7 +785,7 @@ export default class Spend {
               shifted = bn1.ushrn(n)
             }
             const bufShifted = padDataToSize(
-              [...shifted.toArray().slice(buf1.length * -1)],
+              shifted.toArray().slice(buf1.length * -1),
               buf1.length
             )
             this.stack.push(bufShifted)
@@ -1016,7 +1016,7 @@ export default class Spend {
 
           try {
             sig = TransactionSignature.fromChecksigFormat(bufSig)
-            pubkey = PublicKey.fromString(toHex(bufPubkey))
+            pubkey = PublicKey.fromDER(bufPubkey)
             fSuccess = verifySignature(sig, pubkey, subscript)
           } catch (e) {
             // invalid sig or pubkey

package/src/totp/totp.ts

@@ -106,7 +106,7 @@ function generateHOTP (
   options: Required<TOTPOptions>
 ): string {
   const timePad = new BigNumber(counter).toArray('be', 8)
-  console.log({ timePad })
+  //console.log({ timePad })
   const hmac = calcHMAC(secret, timePad, options.algorithm)
   const signature = hmac.digest()