@bsv/sdk 1.3.11 → 1.3.13

package/src/primitives/Polynomial.ts

@@ -1,8 +1,8 @@
-import PrivateKey from './PrivateKey.js'
-import BigNumber from './BigNumber.js'
-import Curve from './Curve.js'
-import Random from './Random.js'
-import { fromBase58, toBase58 } from './utils.js'
+import PrivateKey from './PrivateKey'
+import BigNumber from './BigNumber'
+import Curve from './Curve'
+import Random from './Random'
+import { fromBase58, toBase58 } from './utils'
 
 export class PointInFiniteField {
   x: BigNumber
@@ -20,7 +20,10 @@ export class PointInFiniteField {
 
   static fromString (str: string): PointInFiniteField {
     const [x, y] = str.split('.')
-    return new PointInFiniteField(new BigNumber(fromBase58(x)), new BigNumber(fromBase58(y)))
+    return new PointInFiniteField(
+      new BigNumber(fromBase58(x)),
+      new BigNumber(fromBase58(y))
+    )
   }
 }
 
@@ -51,7 +54,9 @@ export default class Polynomial {
   static fromPrivateKey (key: PrivateKey, threshold: number): Polynomial {
     const P = new Curve().p // arithmetic is mod P
     // The key is the y-intercept of the polynomial where x=0.
-    const points = [new PointInFiniteField(new BigNumber(0), new BigNumber(key.toArray()))]
+    const points = [
+      new PointInFiniteField(new BigNumber(0), new BigNumber(key.toArray()))
+    ]
 
     // The other values are random
     for (let i = 1; i < threshold; i++) {

package/src/primitives/PrivateKey.ts

@@ -1,13 +1,13 @@
-import BigNumber from './BigNumber.js'
-import Signature from './Signature.js'
-import PublicKey from './PublicKey.js'
-import Point from './Point.js'
-import Curve from './Curve.js'
-import { sign, verify } from './ECDSA.js'
-import { sha256, sha256hmac } from './Hash.js'
-import Random from './Random.js'
-import { fromBase58Check, toArray, toBase58, toBase58Check } from './utils.js'
-import Polynomial, { PointInFiniteField } from './Polynomial.js'
+import BigNumber from './BigNumber'
+import Signature from './Signature'
+import PublicKey from './PublicKey'
+import Point from './Point'
+import Curve from './Curve'
+import { sign, verify } from './ECDSA'
+import { sha256, sha256hmac } from './Hash'
+import Random from './Random'
+import { fromBase58Check, toArray, toBase58, toBase58Check } from './utils'
+import Polynomial, { PointInFiniteField } from './Polynomial'
 
 /**
  * @class KeyShares
@@ -29,7 +29,11 @@ export class KeyShares {
   threshold: number
   integrity: string
 
-  constructor (points: PointInFiniteField[], threshold: number, integrity: string) {
+  constructor (
+    points: PointInFiniteField[],
+    threshold: number,
+    integrity: string
+  ) {
     this.points = points
     this.threshold = threshold
     this.integrity = integrity
@@ -40,13 +44,20 @@ export class KeyShares {
     let integrity = ''
     const points = shares.map((share, idx) => {
       const shareParts = share.split('.')
-      if (shareParts.length !== 4) throw Error('Invalid share format in share ' + idx + '. Expected format: "x.y.t.i" - received ' + share)
+      if (shareParts.length !== 4) {
+        throw Error(
+          'Invalid share format in share ' +
+            idx +
+            '. Expected format: "x.y.t.i" - received ' +
+            share
+        )
+      }
       const [x, y, t, i] = shareParts
       if (!t) throw Error('Threshold not found in share ' + idx)
       if (!i) throw Error('Integrity not found in share ' + idx)
       const tInt = parseInt(t)
-      if (idx !== 0 && threshold !== tInt) throw Error('Threshold mismatch in share ' + idx)
-      if (idx !== 0 && integrity !== i) throw Error('Integrity mismatch in share ' + idx)
+      if (idx !== 0 && threshold !== tInt) { throw Error('Threshold mismatch in share ' + idx) }
+      if (idx !== 0 && integrity !== i) { throw Error('Integrity mismatch in share ' + idx) }
       threshold = tInt
       integrity = i
       return PointInFiniteField.fromString([x, y].join('.'))
@@ -55,7 +66,9 @@ export class KeyShares {
   }
 
   toBackupFormat () {
-    return this.points.map(share => share.toString() + '.' + this.threshold + '.' + this.integrity)
+    return this.points.map(
+      (share) => share.toString() + '.' + this.threshold + '.' + this.integrity
+    )
   }
 }
 
@@ -204,7 +217,12 @@ export default class PrivateKey extends BigNumber {
    * const privateKey = PrivateKey.fromRandom();
    * const signature = privateKey.sign('Hello, World!');
    */
-  sign (msg: number[] | string, enc?: 'hex' | 'utf8', forceLowS: boolean = true, customK?: Function | BigNumber): Signature {
+  sign (
+    msg: number[] | string,
+    enc?: 'hex' | 'utf8',
+    forceLowS: boolean = true,
+    customK?: Function | BigNumber
+  ): Signature {
     const msgHash = new BigNumber(sha256(msg, enc), 16)
     return sign(msgHash, this, forceLowS, customK)
   }
@@ -265,7 +283,9 @@ export default class PrivateKey extends BigNumber {
    * const testnetWif = privateKey.toWif([0xef]);
    */
   toWif (prefix: number[] = [0x80]): string {
-    if (!this.isValid()) { throw new Error('Value is out of field') }
+    if (!this.isValid()) {
+      throw new Error('Value is out of field')
+    }
     return toBase58Check([...this.toArray('be', 32), 1], prefix)
   }
 
@@ -362,10 +382,10 @@ export default class PrivateKey extends BigNumber {
    * const shares = key.toKeyShares(2, 5)
    */
   toKeyShares (threshold: number, totalShares: number): KeyShares {
-    if (typeof threshold !== 'number' || typeof totalShares !== 'number') throw new Error('threshold and totalShares must be numbers')
+    if (typeof threshold !== 'number' || typeof totalShares !== 'number') { throw new Error('threshold and totalShares must be numbers') }
     if (threshold < 2) throw new Error('threshold must be at least 2')
     if (totalShares < 2) throw new Error('totalShares must be at least 2')
-    if (threshold > totalShares) throw new Error('threshold should be less than or equal to totalShares')
+    if (threshold > totalShares) { throw new Error('threshold should be less than or equal to totalShares') }
 
     const poly = Polynomial.fromPrivateKey(this, threshold)
 
@@ -427,7 +447,11 @@ export default class PrivateKey extends BigNumber {
   static fromKeyShares (keyShares: KeyShares): PrivateKey {
     const { points, threshold, integrity } = keyShares
     if (threshold < 2) throw new Error('threshold must be at least 2')
-    if (points.length < threshold) throw new Error(`At least ${threshold} shares are required to reconstruct the private key`)
+    if (points.length < threshold) {
+      throw new Error(
+        `At least ${threshold} shares are required to reconstruct the private key`
+      )
+    }
     // check to see if two points have the same x value
     for (let i = 0; i < threshold; i++) {
       for (let j = i + 1; j < threshold; j++) {

package/src/primitives/PublicKey.ts

@@ -1,11 +1,11 @@
-import Point from './Point.js'
-import PrivateKey from './PrivateKey.js'
-import Curve from './Curve.js'
-import { verify } from './ECDSA.js'
-import BigNumber from './BigNumber.js'
-import { sha256, sha256hmac, hash160 } from './Hash.js'
-import Signature from './Signature.js'
-import { toArray, toBase58Check, toHex } from './utils.js'
+import Point from './Point'
+import PrivateKey from './PrivateKey'
+import Curve from './Curve'
+import { verify } from './ECDSA'
+import BigNumber from './BigNumber'
+import { sha256, sha256hmac, hash160 } from './Hash'
+import Signature from './Signature'
+import { toArray, toBase58Check, toHex } from './utils'
 
 /**
  * The PublicKey class extends the Point class. It is used in public-key cryptography to derive shared secret, verify message signatures, and encode the public key in the DER format.
@@ -87,7 +87,9 @@ export default class PublicKey extends Point {
       // Common gotcha: constructing PublicKey with a DER value when you should use .fromString()
       if (y === null && isRed && typeof x === 'string') {
         if (x.length === 66 || x.length === 130) {
-          throw new Error('You are using the "new PublicKey()" constructor with a DER hex string. You need to use "PublicKey.fromString()" instead.')
+          throw new Error(
+            'You are using the "new PublicKey()" constructor with a DER hex string. You need to use "PublicKey.fromString()" instead.'
+          )
         }
       }
       super(x, y, isRed)
@@ -129,7 +131,11 @@ export default class PublicKey extends Point {
    * const mySignature = new Signature(...)
    * const isVerified = myPubKey.verify(myMessage, mySignature)
    */
-  verify (msg: number[] | string, sig: Signature, enc?: 'hex' | 'utf8'): boolean {
+  verify (
+    msg: number[] | string,
+    sig: Signature,
+    enc?: 'hex' | 'utf8'
+  ): boolean {
     const msgHash = new BigNumber(sha256(msg, enc), 16)
     return verify(msgHash, sig, this)
   }
@@ -225,7 +231,11 @@ export default class PublicKey extends Point {
    * @example
    * const publicKey = Signature.fromMsgHashAndCompactSignature(msgHash, 'IMOl2mVKfDgsSsHT4uIYBNN4e...', 'base64');
    */
-  static fromMsgHashAndCompactSignature (msgHash: BigNumber, signature: number[] | string, enc?: 'hex' | 'base64'): PublicKey {
+  static fromMsgHashAndCompactSignature (
+    msgHash: BigNumber,
+    signature: number[] | string,
+    enc?: 'hex' | 'base64'
+  ): PublicKey {
     const data = toArray(signature, enc)
     if (data.length !== 65) {
       throw new Error('Invalid Compact Signature')

package/src/primitives/Random.ts

@@ -2,24 +2,26 @@ class Rand {
   _rand: Function
   constructor () {
     const noRand = () => {
-      throw new Error('No secure random number generator is available in this environment.')
+      throw new Error(
+        'No secure random number generator is available in this environment.'
+      )
     }
     if (typeof self === 'object') {
       /* eslint-disable-next-line */
       if (self.crypto?.getRandomValues) {
-        this._rand = n => {
+        this._rand = (n) => {
           const arr = new Uint8Array(n)
           /* eslint-disable-next-line */
-          self.crypto.getRandomValues(arr)
+          self.crypto.getRandomValues(arr);
           return [...arr]
         }
-      } else /* if (typeof window === 'object') */ {
+      } /* if (typeof window === 'object') */ else {
         this._rand = noRand
       }
     } else {
       try {
         /* eslint-disable-next-line */
-        const crypto = require('crypto')
+        const crypto = require("crypto");
         if (typeof crypto.randomBytes === 'function') {
           this._rand = (n: number) => [...crypto.randomBytes(n)]
         }

package/src/primitives/ReductionContext.ts

@@ -1,6 +1,6 @@
-import BigNumber from './BigNumber.js'
-import K256 from './K256.js'
-import Mersenne from './Mersenne.js'
+import BigNumber from './BigNumber'
+import K256 from './K256'
+import Mersenne from './Mersenne'
 
 /**
  * A base reduction engine that provides several arithmetic operations over
@@ -89,7 +89,7 @@ export default class ReductionContext {
       'red works only with positives'
     )
     this.assert(
-      (a.red != null) && a.red === b.red,
+      a.red != null && a.red === b.red,
       'red works only with red numbers'
     )
   }

package/src/primitives/Schnorr.ts

@@ -1,8 +1,8 @@
-import BigNumber from './BigNumber.js'
-import Curve from './Curve.js'
-import Point from './Point.js'
-import { sha256 } from './Hash.js'
-import { PrivateKey, PublicKey } from './index.js'
+import BigNumber from './BigNumber'
+import Curve from './Curve'
+import Point from './Point'
+import { sha256 } from './Hash'
+import { PrivateKey, PublicKey } from './index'
 
 /**
  * Class representing the Schnorr Zero-Knowledge Proof (ZKP) protocol.
@@ -42,14 +42,19 @@ export default class Schnorr {
   }
 
   /**
-     * Generates a proof that demonstrates the link between public key A and shared secret S
-     * @param a Private key corresponding to public key A
-     * @param A Public key
-     * @param B Other party's public key
-     * @param S Shared secret
-     * @returns Proof (R, S', z)
-     */
-  generateProof (aArg: PrivateKey, AArg: PublicKey, BArg: PublicKey, S: Point): { R: Point, SPrime: Point, z: BigNumber } {
+   * Generates a proof that demonstrates the link between public key A and shared secret S
+   * @param a Private key corresponding to public key A
+   * @param A Public key
+   * @param B Other party's public key
+   * @param S Shared secret
+   * @returns Proof (R, S', z)
+   */
+  generateProof (
+    aArg: PrivateKey,
+    AArg: PublicKey,
+    BArg: PublicKey,
+    S: Point
+  ): { R: Point, SPrime: Point, z: BigNumber } {
     const r = PrivateKey.fromRandom()
     const R = r.toPublicKey()
     const SPrime = BArg.mul(r)
@@ -59,14 +64,19 @@ export default class Schnorr {
   }
 
   /**
-     * Verifies the proof of the link between public key A and shared secret S
-     * @param A Public key
-     * @param B Other party's public key
-     * @param S Shared secret
-     * @param proof Proof (R, S', z)
-     * @returns True if the proof is valid, false otherwise
-     */
-  verifyProof (A: Point, B: Point, S: Point, proof: { R: Point, SPrime: Point, z: BigNumber }): boolean {
+   * Verifies the proof of the link between public key A and shared secret S
+   * @param A Public key
+   * @param B Other party's public key
+   * @param S Shared secret
+   * @param proof Proof (R, S', z)
+   * @returns True if the proof is valid, false otherwise
+   */
+  verifyProof (
+    A: Point,
+    B: Point,
+    S: Point,
+    proof: { R: Point, SPrime: Point, z: BigNumber }
+  ): boolean {
     const { R, SPrime, z } = proof
     const e = this.computeChallenge(A, B, S, SPrime, R)
 
@@ -87,8 +97,20 @@ export default class Schnorr {
     return true
   }
 
-  private computeChallenge (A: Point, B: Point, S: Point, SPrime: Point, R: Point): BigNumber {
-    const message = [...A.encode(true), ...B.encode(true), ...S.encode(true), ...SPrime.encode(true), ...R.encode(true)] as number[]
+  private computeChallenge (
+    A: Point,
+    B: Point,
+    S: Point,
+    SPrime: Point,
+    R: Point
+  ): BigNumber {
+    const message = [
+      ...A.encode(true),
+      ...B.encode(true),
+      ...S.encode(true),
+      ...SPrime.encode(true),
+      ...R.encode(true)
+    ] as number[]
     const hash = sha256(message)
     return new BigNumber(hash).umod(this.curve.n)
   }

package/src/primitives/Signature.ts

@@ -1,10 +1,10 @@
-import BigNumber from './BigNumber.js'
-import PublicKey from './PublicKey.js'
-import { verify } from './ECDSA.js'
-import { sha256 } from './Hash.js'
-import { toArray, toHex, toBase64 } from './utils.js'
-import Point from './Point.js'
-import Curve from './Curve.js'
+import BigNumber from './BigNumber'
+import PublicKey from './PublicKey'
+import { verify } from './ECDSA'
+import { sha256 } from './Hash'
+import { toArray, toHex, toBase64 } from './utils'
+import Point from './Point'
+import Curve from './Curve'
 
 /**
  * Represents a digital signature.
@@ -64,7 +64,7 @@ export default class Signature {
       throw new Error('Signature DER must start with 0x30')
     }
     const len = getLength(data, p)
-    if ((len + p.place) !== data.length) {
+    if (len + p.place !== data.length) {
       throw new Error('Signature DER invalid')
     }
     if (data[p.place++] !== 0x02) {
@@ -96,10 +96,7 @@ export default class Signature {
       }
     }
 
-    return new Signature(
-      new BigNumber(r),
-      new BigNumber(s)
-    )
+    return new Signature(new BigNumber(r), new BigNumber(s))
   }
 
   /**
@@ -120,7 +117,10 @@ export default class Signature {
    * @example
    * const signature = Signature.fromCompact('1b18c1f5502f8...', 'hex');
    */
-  static fromCompact (data: number[] | string, enc?: 'hex' | 'base64'): Signature {
+  static fromCompact (
+    data: number[] | string,
+    enc?: 'hex' | 'base64'
+  ): Signature {
     data = toArray(data, enc)
     if (data.length !== 65) {
       throw new Error('Invalid Compact Signature')
@@ -219,7 +219,7 @@ export default class Signature {
     const rmPadding = (buf: number[]): number[] => {
       let i = 0
       const len = buf.length - 1
-      while ((buf[i] === 0) && ((buf[i + 1] & 0x80) === 0) && i < len) {
+      while (buf[i] === 0 && (buf[i + 1] & 0x80) === 0 && i < len) {
         i++
       }
       if (i === 0) {
@@ -232,14 +232,18 @@ export default class Signature {
     let s = this.s.toArray()
 
     // Pad values
-    if ((r[0] & 0x80) !== 0) { r = [0].concat(r) }
+    if ((r[0] & 0x80) !== 0) {
+      r = [0].concat(r)
+    }
     // Pad values
-    if ((s[0] & 0x80) !== 0) { s = [0].concat(s) }
+    if ((s[0] & 0x80) !== 0) {
+      s = [0].concat(s)
+    }
 
     r = rmPadding(r)
     s = rmPadding(s)
 
-    while ((s[0] === 0) && (s[1] & 0x80) === 0) {
+    while (s[0] === 0 && (s[1] & 0x80) === 0) {
       s = s.slice(1)
     }
     let arr = [0x02]
@@ -274,9 +278,13 @@ export default class Signature {
    * @example
    * const compact = signature.toCompact(3, true, 'base64');
    */
-  toCompact (recovery: number, compressed: boolean, enc?: 'hex' | 'base64'): number[] | string {
+  toCompact (
+    recovery: number,
+    compressed: boolean,
+    enc?: 'hex' | 'base64'
+  ): number[] | string {
     if (recovery < 0 || recovery > 3) throw new Error('Invalid recovery param')
-    if (typeof compressed !== 'boolean') throw new Error('Invalid compressed param')
+    if (typeof compressed !== 'boolean') { throw new Error('Invalid compressed param') }
     let compactByte = 27 + recovery
     if (compressed) {
       compactByte += 4

package/src/primitives/SymmetricKey.ts

@@ -1,7 +1,7 @@
-import BigNumber from './BigNumber.js'
-import { AESGCM, AESGCMDecrypt } from './AESGCM.js'
-import Random from './Random.js'
-import { toArray, encode } from './utils.js'
+import BigNumber from './BigNumber'
+import { AESGCM, AESGCMDecrypt } from './AESGCM'
+import Random from './Random'
+import { toArray, encode } from './utils'
 
 /**
  * `SymmetricKey` is a class that extends the `BigNumber` class and implements symmetric encryption and decryption methods.
@@ -27,19 +27,19 @@ export default class SymmetricKey extends BigNumber {
   }
 
   /**
-  * Encrypts a given message using AES-GCM encryption.
-  * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
-  * The OpenSSL format of |IV|encryptedContent|authTag| is used.
-  *
-  * @method encrypt
-  * @param msg - The message to be encrypted. It can be a string or an array of numbers.
-  * @param enc - optional. The encoding of the message. If hex, the string is assumed to be hex, UTF-8 otherwise.
-  * @returns Returns the encrypted message as a string or an array of numbers, depending on `enc` argument.
-  *
-  * @example
-  * const key = new SymmetricKey(1234);
-  * const encryptedMessage = key.encrypt('plainText', 'utf8');
-  */
+   * Encrypts a given message using AES-GCM encryption.
+   * The generated Initialization Vector (IV) is attached to the encrypted message for decryption purposes.
+   * The OpenSSL format of |IV|encryptedContent|authTag| is used.
+   *
+   * @method encrypt
+   * @param msg - The message to be encrypted. It can be a string or an array of numbers.
+   * @param enc - optional. The encoding of the message. If hex, the string is assumed to be hex, UTF-8 otherwise.
+   * @returns Returns the encrypted message as a string or an array of numbers, depending on `enc` argument.
+   *
+   * @example
+   * const key = new SymmetricKey(1234);
+   * const encryptedMessage = key.encrypt('plainText', 'utf8');
+   */
   encrypt (msg: number[] | string, enc?: 'hex'): string | number[] {
     const iv = Random(32)
     msg = toArray(msg, enc)

package/src/primitives/TransactionSignature.ts

@@ -1,10 +1,10 @@
-import Signature from './Signature.js'
-import BigNumber from './BigNumber.js'
-import * as Hash from './Hash.js'
-import { toArray, Writer } from './utils.js'
-import Script from '../script/Script.js'
-import TransactionInput from '../transaction/TransactionInput.js'
-import TransactionOutput from '../transaction/TransactionOutput.js'
+import Signature from './Signature'
+import BigNumber from './BigNumber'
+import * as Hash from './Hash'
+import { toArray, Writer } from './utils'
+import Script from '../script/Script'
+import TransactionInput from '../transaction/TransactionInput'
+import TransactionOutput from '../transaction/TransactionOutput'
 
 export default class TransactionSignature extends Signature {
   public static readonly SIGHASH_ALL = 0x00000001
@@ -96,15 +96,23 @@ export default class TransactionSignature extends Signature {
       hashPrevouts = getPrevoutHash()
     }
 
-    if ((params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0 &&
+    if (
+      (params.scope & TransactionSignature.SIGHASH_ANYONECANPAY) === 0 &&
       (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
-      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE) {
+      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE
+    ) {
       hashSequence = getSequenceHash()
     }
 
-    if ((params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE && (params.scope & 31) !== TransactionSignature.SIGHASH_NONE) {
+    if (
+      (params.scope & 31) !== TransactionSignature.SIGHASH_SINGLE &&
+      (params.scope & 31) !== TransactionSignature.SIGHASH_NONE
+    ) {
       hashOutputs = getOutputsHash()
-    } else if ((params.scope & 31) === TransactionSignature.SIGHASH_SINGLE && params.inputIndex < params.outputs.length) {
+    } else if (
+      (params.scope & 31) === TransactionSignature.SIGHASH_SINGLE &&
+      params.inputIndex < params.outputs.length
+    ) {
       hashOutputs = getOutputsHash(params.inputIndex)
     }
 
@@ -167,16 +175,19 @@ export default class TransactionSignature extends Signature {
   }
 
   /**
-     * Compares to bitcoind's IsLowDERSignature
-     * See also Ecdsa signature algorithm which enforces this.
-     * See also Bip 62, "low S values in signatures"
-     */
+   * Compares to bitcoind's IsLowDERSignature
+   * See also Ecdsa signature algorithm which enforces this.
+   * See also Bip 62, "low S values in signatures"
+   */
   public hasLowS (): boolean {
     if (
       this.s.ltn(1) ||
-      this.s.gt(new BigNumber(
-        '7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex'
-      ))
+      this.s.gt(
+        new BigNumber(
+          '7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0',
+          'hex'
+        )
+      )
     ) {
       return false
     }