@bsv/sdk 1.6.14 → 1.6.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.6.14",
+  "version": "1.6.16",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/auth/certificates/__tests/CompletedProtoWallet.ts

@@ -23,7 +23,8 @@ import {
   PubKeyHex,
   AuthenticatedResult,
   GetNetworkResult,
-  GetVersionResult
+  GetVersionResult,
+  CachedKeyDeriver
 } from '../../../wallet/index.js'
 
 // Test Mock wallet which extends ProtoWallet but still implements Wallet interface
@@ -41,7 +42,7 @@ export class CompletedProtoWallet
       typeof rootKeyOrKeyDeriver === 'string' ||
       rootKeyOrKeyDeriver instanceof PrivateKey
     ) {
-      this.keyDeriver = new KeyDeriver(rootKeyOrKeyDeriver)
+      this.keyDeriver = new CachedKeyDeriver(rootKeyOrKeyDeriver)
     } else {
       throw new Error('Invalid key deriver provided')
     }

package/src/primitives/Point.ts

@@ -576,12 +576,159 @@ export default class Point extends BasePoint {
       k = new BigNumber(k as number, 16)
     }
     k = k as BigNumber
-    if (this.isInfinity()) {
-      return this
-    } else if (this._hasDoubles(k)) {
-      return this._fixedNafMul(k)
+    if (typeof BigInt === 'function') {
+      if (this.inf) {
+        return this
+      }
+
+      const zero = BigInt(0)
+      const one = BigInt(1)
+      const two = BigInt(2)
+      const three = BigInt(3)
+      const four = BigInt(4)
+      const eight = BigInt(8)
+
+      const p = BigInt(
+        '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F'
+      )
+      const n = BigInt(
+        '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141'
+      )
+
+      let kBig = BigInt('0x' + k.toString(16))
+      const isNeg = kBig < zero
+      if (isNeg) kBig = -kBig
+      kBig = ((kBig % n) + n) % n
+      if (kBig === zero) {
+        return new Point(null, null)
+      }
+
+      if (this.x === null || this.y === null) {
+        throw new Error('Point coordinates cannot be null')
+      }
+
+      const Px = BigInt('0x' + this.x.fromRed().toString(16))
+      const Py = BigInt('0x' + this.y.fromRed().toString(16))
+
+      const mod = (a: bigint, m: bigint): bigint => ((a % m) + m) % m
+      const modMul = (a: bigint, b: bigint, m: bigint): bigint => mod(a * b, m)
+      const modSub = (a: bigint, b: bigint, m: bigint): bigint => mod(a - b, m)
+      const modInv = (a: bigint, m: bigint): bigint => {
+        let lm = one
+        let hm = zero
+        let low = mod(a, m)
+        let high = m
+        while (low > one) {
+          const r = high / low
+          const nm = hm - lm * r
+          const neww = high - low * r
+          hm = lm
+          lm = nm
+          high = low
+          low = neww
+        }
+        return mod(lm, m)
+      }
+
+      interface JacobianPoint {
+        X: bigint
+        Y: bigint
+        Z: bigint
+      }
+
+      const pointDouble = (P: JacobianPoint): JacobianPoint => {
+        const { X: X1, Y: Y1, Z: Z1 } = P
+        if (Y1 === zero) {
+          return { X: zero, Y: one, Z: zero }
+        }
+
+        const Y1sq = modMul(Y1, Y1, p)
+        const S = modMul(four, modMul(X1, Y1sq, p), p)
+        const M = modMul(three, modMul(X1, X1, p), p)
+        const X3 = modSub(modMul(M, M, p), modMul(two, S, p), p)
+        const Y3 = modSub(
+          modMul(M, modSub(S, X3, p), p),
+          modMul(eight, modMul(Y1sq, Y1sq, p), p),
+          p
+        )
+        const Z3 = modMul(two, modMul(Y1, Z1, p), p)
+        return { X: X3, Y: Y3, Z: Z3 }
+      }
+
+      const pointAdd = (P: JacobianPoint, Q: JacobianPoint): JacobianPoint => {
+        if (P.Z === zero) return Q
+        if (Q.Z === zero) return P
+
+        const Z1Z1 = modMul(P.Z, P.Z, p)
+        const Z2Z2 = modMul(Q.Z, Q.Z, p)
+        const U1 = modMul(P.X, Z2Z2, p)
+        const U2 = modMul(Q.X, Z1Z1, p)
+        const S1 = modMul(P.Y, modMul(Z2Z2, Q.Z, p), p)
+        const S2 = modMul(Q.Y, modMul(Z1Z1, P.Z, p), p)
+
+        const H = modSub(U2, U1, p)
+        const r = modSub(S2, S1, p)
+
+        if (H === zero) {
+          if (r === zero) {
+            return pointDouble(P)
+          } else {
+            return { X: zero, Y: one, Z: zero }
+          }
+        }
+
+        const HH = modMul(H, H, p)
+        const HHH = modMul(H, HH, p)
+        const V = modMul(U1, HH, p)
+
+        const X3 = modSub(modSub(modMul(r, r, p), HHH, p), modMul(two, V, p), p)
+        const Y3 = modSub(modMul(r, modSub(V, X3, p), p), modMul(S1, HHH, p), p)
+        const Z3 = modMul(H, modMul(P.Z, Q.Z, p), p)
+
+        return { X: X3, Y: Y3, Z: Z3 }
+      }
+
+      const scalarMultiply = (
+        kVal: bigint,
+        P0: { x: bigint, y: bigint }
+      ): JacobianPoint => {
+        let N: JacobianPoint = { X: P0.x, Y: P0.y, Z: one }
+        let Q: JacobianPoint = { X: zero, Y: one, Z: zero }
+        let kk = kVal
+        while (kk > zero) {
+          if ((kk & one) === one) {
+            Q = pointAdd(Q, N)
+          }
+          N = pointDouble(N)
+          kk >>= one
+        }
+        return Q
+      }
+
+      const R = scalarMultiply(kBig, { x: Px, y: Py })
+      if (R.Z === zero) {
+        return new Point(null, null)
+      }
+      const zInv = modInv(R.Z, p)
+      const zInv2 = modMul(zInv, zInv, p)
+      const xRes = modMul(R.X, zInv2, p)
+      const yRes = modMul(R.Y, modMul(zInv2, zInv, p), p)
+
+      const xBN = new BigNumber(xRes.toString(16), 16)
+      const yBN = new BigNumber(yRes.toString(16), 16)
+      const result = new Point(xBN, yBN)
+      if (isNeg) {
+        return result.neg()
+      }
+      return result
     } else {
-      return this._endoWnafMulAdd([this], [k]) as Point
+      if (this.isInfinity()) {
+        return this
+      } else if (this._hasDoubles(k)) {
+        return this._fixedNafMul(k)
+      } else {
+        return this._endoWnafMulAdd([this], [k]) as Point
+      }
     }
   }
 

package/src/primitives/PrivateKey.ts

@@ -359,10 +359,30 @@ export default class PrivateKey extends BigNumber {
    * Derives a child key with BRC-42.
    * @param publicKey The public 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 (publicKey: PublicKey, invoiceNumber: string): PrivateKey {
-    const sharedSecret = this.deriveSharedSecret(publicKey)
+  deriveChild (
+    publicKey: PublicKey,
+    invoiceNumber: string,
+    cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void),
+    retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))
+  ): PrivateKey {
+    let sharedSecret: Point
+    if (typeof retrieveCachedSharedSecret === 'function') {
+      const retrieved = retrieveCachedSharedSecret(this, publicKey)
+      if (typeof retrieved !== 'undefined') {
+        sharedSecret = retrieved
+      } else {
+        sharedSecret = this.deriveSharedSecret(publicKey)
+        if (typeof cacheSharedSecret === 'function') {
+          cacheSharedSecret(this, publicKey, sharedSecret)
+        }
+      }
+    } else {
+      sharedSecret = this.deriveSharedSecret(publicKey)
+    }
     const invoiceNumberBin = toArray(invoiceNumber, 'utf8')
     const hmac = sha256hmac(sharedSecret.encode(true), invoiceNumberBin)
     const curve = new Curve()

package/src/primitives/PublicKey.ts

@@ -202,10 +202,30 @@ export default class PublicKey extends Point {
    * 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): PublicKey {
-    const sharedSecret = this.deriveSharedSecret(privateKey)
+  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()

package/src/transaction/http/HttpClient.ts

@@ -23,6 +23,8 @@ export interface HttpClientRequestOptions<Data = any> {
   headers?: Record<string, string>
   /** An object or null to set request's body. */
   data?: Data
+  /** An optional AbortSignal to cancel the request, including by explicit timeout. */
+  signal?: AbortSignal
 }
 
 /**

package/src/wallet/CachedKeyDeriver.ts

@@ -1,5 +1,5 @@
-import { PrivateKey, PublicKey, SymmetricKey } from '../primitives/index.js'
-import { Counterparty, KeyDeriver } from './KeyDeriver.js'
+import { Point, PrivateKey, PublicKey, SymmetricKey } from '../primitives/index.js'
+import { Counterparty, KeyDeriver, KeyDeriverApi } from './KeyDeriver.js'
 import { WalletProtocol } from './Wallet.interfaces.js'
 
 /**
@@ -7,11 +7,21 @@ import { WalletProtocol } from './Wallet.interfaces.js'
  * This is useful for optimizing performance when the same keys are derived multiple times.
  * It supports configurable cache size with sane defaults and maintains cache entries using LRU (Least Recently Used) eviction policy.
  */
-export default class CachedKeyDeriver {
+export default class CachedKeyDeriver implements KeyDeriverApi {
   private readonly keyDeriver: KeyDeriver
-  private readonly cache: Map<string, PublicKey | PrivateKey | SymmetricKey | number[]>
+  private readonly cache: Map<string, PublicKey | PrivateKey | SymmetricKey | Point | number[]>
   private readonly maxCacheSize: number
 
+  /**
+   * The root key from which all other keys are derived.
+   */
+  rootKey: PrivateKey
+
+  /**
+   * The identity of this key deriver which is normally the public key associated with the `rootKey`
+   */
+  identityKey: string
+
   /**
    * Initializes the CachedKeyDeriver instance with a root private key and optional cache settings.
    * @param {PrivateKey | 'anyone'} rootKey - The root private key or the string 'anyone'.
@@ -22,8 +32,22 @@ export default class CachedKeyDeriver {
     rootKey: PrivateKey | 'anyone',
     options?: { maxCacheSize?: number }
   ) {
-    this.keyDeriver = new KeyDeriver(rootKey)
-    this.cache = new Map<string, PublicKey | PrivateKey | SymmetricKey | number[]>()
+    if (rootKey === 'anyone') {
+      this.rootKey = new PrivateKey(1)
+    } else {
+      this.rootKey = rootKey
+    }
+    this.keyDeriver = new KeyDeriver(
+      this.rootKey,
+      (priv, pub, point) => {
+        this.cacheSet(`${priv.toString()}-${pub.toString()}`, point)
+      },
+      (priv, pub) => {
+        return this.cacheGet(`${priv.toString()}-${pub.toString()}`) as Point | undefined
+      }
+    )
+    this.identityKey = this.rootKey.toPublicKey().toString()
+    this.cache = new Map<string, PublicKey | PrivateKey | SymmetricKey | Point | number[]>()
     const maxCacheSize = options?.maxCacheSize
     this.maxCacheSize = (maxCacheSize != null && !isNaN(maxCacheSize) && maxCacheSize > 0) ? maxCacheSize : 1000
   }
@@ -237,7 +261,7 @@ export default class CachedKeyDeriver {
    * @param {string} cacheKey - The key of the cached item.
    * @returns {any} - The cached value.
    */
-  private cacheGet (cacheKey: string): PublicKey | PrivateKey | SymmetricKey | number[] | undefined {
+  private cacheGet (cacheKey: string): PublicKey | PrivateKey | SymmetricKey | Point | number[] | undefined {
     const value = this.cache.get(cacheKey)
     // Update the entry to reflect recent use
     this.cache.delete(cacheKey)
@@ -252,7 +276,7 @@ export default class CachedKeyDeriver {
    * @param {string} cacheKey - The key of the item to cache.
    * @param {any} value - The value to cache.
    */
-  private cacheSet (cacheKey: string, value: PublicKey | PrivateKey | SymmetricKey | number[]): void {
+  private cacheSet (cacheKey: string, value: PublicKey | PrivateKey | SymmetricKey | Point | number[]): void {
     if (this.cache.size >= this.maxCacheSize) {
       // Evict the least recently used item (first item in Map)
       const firstKey = this.cache.keys().next().value

package/src/wallet/KeyDeriver.ts

@@ -3,7 +3,8 @@ import {
   PublicKey,
   SymmetricKey,
   Hash,
-  Utils
+  Utils,
+  Point
 } from '../primitives/index.js'
 import { WalletProtocol, PubKeyHex } from './Wallet.interfaces.js'
 
@@ -92,12 +93,18 @@ export interface KeyDeriverApi {
 export class KeyDeriver implements KeyDeriverApi {
   rootKey: PrivateKey
   identityKey: string
+  private readonly anyone: PublicKey
 
   /**
    * Initializes the KeyDeriver instance with a root private key.
    * @param {PrivateKey | 'anyone'} rootKey - The root private key or the string 'anyone'.
    */
-  constructor (rootKey: PrivateKey | 'anyone') {
+  constructor (
+    rootKey: PrivateKey | 'anyone',
+    private readonly cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void),
+    private readonly retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))
+  ) {
+    this.anyone = new PrivateKey(1).toPublicKey()
     if (rootKey === 'anyone') {
       this.rootKey = new PrivateKey(1)
     } else {
@@ -123,12 +130,19 @@ export class KeyDeriver implements KeyDeriverApi {
     counterparty = this.normalizeCounterparty(counterparty)
     if (forSelf) {
       return this.rootKey
-        .deriveChild(counterparty, this.computeInvoiceNumber(protocolID, keyID))
+        .deriveChild(
+          counterparty,
+          this.computeInvoiceNumber(protocolID, keyID),
+          this.cacheSharedSecret,
+          this.retrieveCachedSharedSecret
+        )
         .toPublicKey()
     } else {
       return counterparty.deriveChild(
         this.rootKey,
-        this.computeInvoiceNumber(protocolID, keyID)
+        this.computeInvoiceNumber(protocolID, keyID),
+        this.cacheSharedSecret,
+        this.retrieveCachedSharedSecret
       )
     }
   }
@@ -148,7 +162,9 @@ export class KeyDeriver implements KeyDeriverApi {
     counterparty = this.normalizeCounterparty(counterparty)
     return this.rootKey.deriveChild(
       counterparty,
-      this.computeInvoiceNumber(protocolID, keyID)
+      this.computeInvoiceNumber(protocolID, keyID),
+      this.cacheSharedSecret,
+      this.retrieveCachedSharedSecret
     )
   }
 
@@ -168,7 +184,7 @@ export class KeyDeriver implements KeyDeriverApi {
     // If counterparty is 'anyone', we use 1*G as the public key.
     // This is a publicly derivable key and should only be used in scenarios where public disclosure is intended.
     if (counterparty === 'anyone') {
-      counterparty = new PrivateKey(1).toPublicKey()
+      counterparty = this.anyone
     }
     counterparty = this.normalizeCounterparty(counterparty)
     const derivedPublicKey = this.derivePublicKey(

package/src/wallet/ProtoWallet.ts

@@ -1,4 +1,5 @@
 import { KeyDeriver, KeyDeriverApi } from './KeyDeriver.js'
+import CachedKeyDeriver from './CachedKeyDeriver.js'
 import {
   Hash,
   ECDSA,
@@ -42,11 +43,11 @@ export class ProtoWallet {
 
   constructor (rootKeyOrKeyDeriver?: PrivateKey | 'anyone' | KeyDeriverApi) {
     if (typeof (rootKeyOrKeyDeriver as KeyDeriver).identityKey !== 'string') {
-      rootKeyOrKeyDeriver = new KeyDeriver(
+      rootKeyOrKeyDeriver = new CachedKeyDeriver(
         rootKeyOrKeyDeriver as PrivateKey | 'anyone'
       )
     }
-    this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriver
+    this.keyDeriver = rootKeyOrKeyDeriver as KeyDeriverApi
   }
 
   async getPublicKey (