@bsv/wallet-toolbox 1.7.16 → 1.7.17

package/mobile/node_modules/@bsv/sdk/src/primitives/PublicKey.ts

@@ -1,282 +0,0 @@
-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'
-
-/**
- * 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.
- * The class comes with static methods to generate PublicKey instances from private keys or from strings.
- *
- * @extends {Point}
- * @see {@link Point} for more information on Point.
- */
-export default class PublicKey extends Point {
-  /**
-   * Static factory method to derive a public key from a private key.
-   * It multiplies the generator point 'g' on the elliptic curve by the private key.
-   *
-   * @static
-   * @method fromPrivateKey
-   *
-   * @param key - The private key from which to derive the public key.
-   *
-   * @returns Returns the PublicKey derived from the given PrivateKey.
-   *
-   * @example
-   * const myPrivKey = new PrivateKey(...)
-   * const myPubKey = PublicKey.fromPrivateKey(myPrivKey)
-   */
-  static fromPrivateKey (key: PrivateKey): PublicKey {
-    const c = new Curve()
-    const p = c.g.mul(key)
-    return new PublicKey(p.x, p.y)
-  }
-
-  /**
-   * Static factory method to create a PublicKey instance from a string.
-   *
-   * @param str - A string representing a public key.
-   *
-   * @returns Returns the PublicKey created from the string.
-   *
-   * @example
-   * const myPubKey = PublicKey.fromString("03....")
-   */
-  static fromString (str: string): PublicKey {
-    const p = Point.fromString(str)
-    return new PublicKey(p.x, p.y)
-  }
-
-  /**
-   * Static factory method to create a PublicKey instance from a number array.
-   *
-   * @param bytes - A number array representing a public key.
-   *
-   * @returns Returns the PublicKey created from the number array.
-   *
-   * @example
-   * const myPubKey = PublicKey.fromString("03....")
-   */
-  static fromDER (bytes: number[]): PublicKey {
-    const p = Point.fromDER(bytes)
-    return new PublicKey(p.x, p.y)
-  }
-
-  /**
-   * @constructor
-   * @param x - A point or the x-coordinate of the point. May be a number, a BigNumber, a string (which will be interpreted as hex), a number array, or null. If null, an "Infinity" point is constructed.
-   * @param y - If x is not a point, the y-coordinate of the point, similar to x.
-   * @param isRed - A boolean indicating if the point is a member of the field of integers modulo the k256 prime. Default is true.
-   *
-   * @example
-   * new PublicKey(point1);
-   * new PublicKey('abc123', 'def456');
-   */
-  constructor (
-    x: Point | BigNumber | number | number[] | string | null,
-    y: BigNumber | number | number[] | string | null = null,
-    isRed: boolean = true
-  ) {
-    if (x instanceof Point) {
-      super(x.getX(), x.getY())
-    } else {
-      // 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.'
-          )
-        }
-      }
-      super(x, y, isRed)
-    }
-  }
-
-  /**
-   * Derive a shared secret from a public key and a private key for use in symmetric encryption.
-   * This method multiplies the public key (an instance of Point) with a private key.
-   *
-   * @param priv - The private key to use in deriving the shared secret.
-   *
-   * @returns Returns the Point representing the shared secret.
-   *
-   * @throws Will throw an error if the public key is not valid for ECDH secret derivation.
-   *
-   * @example
-   * const myPrivKey = new PrivateKey(...)
-   * const sharedSecret = myPubKey.deriveSharedSecret(myPrivKey)
-   */
-  deriveSharedSecret (priv: PrivateKey): Point {
-    if (!this.validate()) {
-      throw new Error('Public key not valid for ECDH secret derivation')
-    }
-    return this.mul(priv)
-  }
-
-  /**
-   * Verify a signature of a message using this public key.
-   *
-   * @param msg - The message to verify. It can be a string or an array of numbers.
-   * @param sig - The Signature of the message that needs verification.
-   * @param enc - The encoding of the message. It defaults to 'utf8'.
-   *
-   * @returns Returns true if the signature is verified successfully, otherwise false.
-   *
-   * @example
-   * const myMessage = "Hello, world!"
-   * const mySignature = new Signature(...)
-   * const isVerified = myPubKey.verify(myMessage, mySignature)
-   */
-  verify (
-    msg: number[] | string,
-    sig: Signature,
-    enc?: 'hex' | 'utf8'
-  ): boolean {
-    const msgHash = new BigNumber(sha256(msg, enc), 16)
-    return verify(msgHash, sig, this)
-  }
-
-  /**
-   * Encode the public key to DER (Distinguished Encoding Rules) format.
-   *
-   * @returns Returns the DER-encoded public key in number array or string.
-   *
-   * @param enc - The encoding of the DER string. undefined = number array, 'hex' = hex string.
-   *
-   * @example
-   * const derPublicKey = myPubKey.toDER()
-   */
-  toDER (enc?: 'hex' | undefined): number[] | string {
-    if (enc === 'hex') return this.encode(true, enc) as string
-    return this.encode(true) as number[]
-  }
-
-  /**
-   * Hash sha256 and ripemd160 of the public key.
-   *
-   * @returns Returns the hash of the public key.
-   *
-   * @example
-   * const publicKeyHash = pubkey.toHash()
-   */
-  toHash (enc?: 'hex'): number[] | string {
-    const pkh = hash160(this.encode(true))
-    if (enc === 'hex') {
-      return toHex(pkh)
-    }
-    return pkh
-  }
-
-  /**
-   * Base58Check encodes the hash of the public key with a prefix to indicate locking script type.
-   * Defaults to P2PKH for mainnet, otherwise known as a "Bitcoin Address".
-   *
-   * @param prefix defaults to [0x00] for mainnet, set to [0x6f] for testnet or use the strings 'mainnet' or 'testnet'
-   *
-   * @returns Returns the address encoding associated with the hash of the public key.
-   *
-   * @example
-   * const address = pubkey.toAddress()
-   * const address = pubkey.toAddress('mainnet')
-   * const testnetAddress = pubkey.toAddress([0x6f])
-   * const testnetAddress = pubkey.toAddress('testnet')
-   */
-  toAddress (prefix: number[] | string = [0x00]): string {
-    if (typeof prefix === 'string') {
-      if (prefix === 'testnet' || prefix === 'test') {
-        prefix = [0x6f]
-      } else if (prefix === 'mainnet' || prefix === 'main') {
-        prefix = [0x00]
-      } else {
-        throw new Error(`Invalid prefix ${prefix}`)
-      }
-    }
-    return toBase58Check(this.toHash() as number[], prefix)
-  }
-
-  /**
-   * Derives a child key with BRC-42.
-   * @param privateKey The private key of the other party
-   * @param invoiceNumber The invoice number used to derive the child key
-   * @param cacheSharedSecret Optional function to cache shared secrets
-   * @param retrieveCachedSharedSecret Optional function to retrieve shared secrets from the cache
-   * @returns The derived child key.
-   */
-  deriveChild (
-    privateKey: PrivateKey,
-    invoiceNumber: string,
-    cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void),
-    retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))
-  ): PublicKey {
-    let sharedSecret: Point
-    if (typeof retrieveCachedSharedSecret === 'function') {
-      const retrieved = retrieveCachedSharedSecret(privateKey, this)
-      if (typeof retrieved !== 'undefined') {
-        sharedSecret = retrieved
-      } else {
-        sharedSecret = this.deriveSharedSecret(privateKey)
-        if (typeof cacheSharedSecret === 'function') {
-          cacheSharedSecret(privateKey, this, sharedSecret)
-        }
-      }
-    } else {
-      sharedSecret = this.deriveSharedSecret(privateKey)
-    }
-    const invoiceNumberBin = toArray(invoiceNumber, 'utf8')
-    const hmac = sha256hmac(sharedSecret.encode(true), invoiceNumberBin)
-    const curve = new Curve()
-    const point = curve.g.mul(new BigNumber(hmac))
-    const finalPoint = this.add(point)
-    return new PublicKey(finalPoint.x, finalPoint.y)
-  }
-
-  /**
-   * Takes an array of numbers or a string and returns a new PublicKey instance.
-   * This method will throw an error if the Compact encoding is invalid.
-   * If a string is provided, it is assumed to represent a hexadecimal sequence.
-   * compactByte value 27-30 means uncompressed public key.
-   * 31-34 means compressed public key.
-   * The range represents the recovery param which can be 0,1,2,3.
-   *
-   * @static
-   * @method fromMsgHashAndCompactSignature
-   * @param msgHash - The message hash which was signed.
-   * @param signature - The signature in compact format.
-   * @param enc - The encoding of the signature string.
-   * @returns A PublicKey instance derived from the message hash and compact signature.
-   * @example
-   * const publicKey = Signature.fromMsgHashAndCompactSignature(msgHash, 'IMOl2mVKfDgsSsHT4uIYBNN4e...', 'base64');
-   */
-  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')
-    }
-    const compactByte = data[0]
-    if (compactByte < 27 || compactByte >= 35) {
-      throw new Error('Invalid Compact Byte')
-    }
-    let r = data[0] - 27
-    // NOTE: We don't use uncompressed pubkeys in this library,
-    // but whether the key is compressed is captured in the recovery param.
-    // Code below is commented out for reference of how you could capture this.
-    // let compressed = false
-    if (r > 3) {
-      // compressed = true
-      r -= 4
-    }
-    const s = new Signature(
-      new BigNumber(data.slice(1, 33)),
-      new BigNumber(data.slice(33, 65))
-    )
-    return s.RecoverPublicKey(r, msgHash)
-  }
-}

package/mobile/node_modules/@bsv/sdk/src/primitives/Random.ts

@@ -1,101 +0,0 @@
-/**
- * Random number generator that works across modern JavaScript environments.
- *
- * This implementation uses the Web Crypto API which is available in:
- * - Node.js 6+ via require('crypto').randomBytes()
- * - Node.js 18+ via globalThis.crypto
- * - Modern browsers via globalThis.crypto, self.crypto, or window.crypto
- * - Web Workers and Service Workers via self.crypto
- * - Deno and Bun via globalThis.crypto
- *
- * @throws {Error} If no secure random number generator is available
- */
-class Rand {
-  _rand: (n: number) => number[] // ✅ Explicit function type
-
-  getRandomValues (obj: any, n: number): number[] {
-    const arr = new Uint8Array(n)
-    obj.crypto.getRandomValues(arr)
-    return Array.from(arr)
-  }
-
-  constructor () {
-    const noRand = (): never => {
-      throw new Error(
-        'No secure random number generator is available in this environment.'
-      )
-    }
-
-    this._rand = noRand // Assign the function
-
-    // Try globalThis.crypto (works in Node.js 18+, modern browsers, and Deno)
-    if (typeof globalThis !== 'undefined' && typeof (globalThis as any).crypto?.getRandomValues === 'function') {
-      this._rand = (n) => {
-        /* eslint-disable-next-line */
-        return this.getRandomValues(globalThis as any, n)
-      }
-      return
-    }
-
-    // Node.js fallback for versions < 18
-    if (typeof process !== 'undefined' && process.release?.name === 'node') {
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const crypto = require('crypto')
-        if (typeof crypto.randomBytes === 'function') {
-          this._rand = (n) => {
-            return Array.from(crypto.randomBytes(n))
-          }
-          return
-        }
-      } catch (e) {
-        // crypto module not available, continue to other checks
-      }
-    }
-
-    // Try self.crypto (Web Workers and Service Workers)
-    if (typeof self !== 'undefined' && typeof self.crypto?.getRandomValues === 'function') {
-      this._rand = (n) => {
-        /* eslint-disable-next-line */
-        return this.getRandomValues(self as any, n)
-      }
-      return
-    }
-
-    // Try window.crypto (browsers)
-    if (typeof window !== 'undefined' && typeof (window as any).crypto?.getRandomValues === 'function') {
-      this._rand = (n) => {
-        /* eslint-disable-next-line */
-        return this.getRandomValues(window as any, n)
-      }
-      return
-    }
-
-    // No crypto available
-    this._rand = noRand
-  }
-
-  generate (len: number): number[] {
-    return this._rand(len)
-  }
-}
-
-let ayn: Rand | null = null
-
-/**
- * Generates a sequence of pseudo-random bytes with the given length.
- *
- * @param len - The number of bytes to generate
- *
- * @returns The generated bytes
- *
- * @example
- * import Random from '@bsv/sdk/primitives/Random'
- * const bytes = Random(32) // Produces 32 random bytes
- */
-export default (len: number): number[] => {
-  if (ayn == null) {
-    ayn = new Rand()
-  }
-  return ayn.generate(len)
-}