@bsv/sdk 1.6.15 → 1.6.16

package/docs/reference/primitives.md

@@ -2396,7 +2396,7 @@ export default class PrivateKey extends BigNumber {
     toHex(): string 
     toString(base: number | "hex" = "hex", padding: number = 64): string 
     deriveSharedSecret(key: PublicKey): Point 
-    deriveChild(publicKey: PublicKey, invoiceNumber: string): PrivateKey 
+    deriveChild(publicKey: PublicKey, invoiceNumber: string, cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void), retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))): PrivateKey 
     toKeyShares(threshold: number, totalShares: number): KeyShares 
     toBackupShares(threshold: number, totalShares: number): string[] 
     static fromBackupShares(shares: string[]): PrivateKey 
@@ -2453,9 +2453,9 @@ Returns
 Derives a child key with BRC-42.
 
 ```ts
-deriveChild(publicKey: PublicKey, invoiceNumber: string): PrivateKey 
+deriveChild(publicKey: PublicKey, invoiceNumber: string, cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void), retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))): PrivateKey 
 ```
-See also: [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey)
+See also: [Point](./primitives.md#class-point), [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey)
 
 Returns
 
@@ -2467,6 +2467,10 @@ Argument Details
   + The public key of the other party
 + **invoiceNumber**
   + The invoice number used to derive the child key
++ **cacheSharedSecret**
+  + Optional function to cache shared secrets
++ **retrieveCachedSharedSecret**
+  + Optional function to retrieve shared secrets from the cache
 
 #### Method deriveSharedSecret
 
@@ -2885,7 +2889,7 @@ export default class PublicKey extends Point {
     toDER(enc?: "hex" | undefined): number[] | string 
     toHash(enc?: "hex"): number[] | string 
     toAddress(prefix: number[] | string = [0]): string 
-    deriveChild(privateKey: PrivateKey, invoiceNumber: string): PublicKey 
+    deriveChild(privateKey: PrivateKey, invoiceNumber: string, cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void), retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))): PublicKey 
     static fromMsgHashAndCompactSignature(msgHash: BigNumber, signature: number[] | string, enc?: "hex" | "base64"): PublicKey 
 }
 ```
@@ -2920,9 +2924,9 @@ new PublicKey('abc123', 'def456');
 Derives a child key with BRC-42.
 
 ```ts
-deriveChild(privateKey: PrivateKey, invoiceNumber: string): PublicKey 
+deriveChild(privateKey: PrivateKey, invoiceNumber: string, cacheSharedSecret?: ((priv: PrivateKey, pub: Point, point: Point) => void), retrieveCachedSharedSecret?: ((priv: PrivateKey, pub: Point) => (Point | undefined))): PublicKey 
 ```
-See also: [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey)
+See also: [Point](./primitives.md#class-point), [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey)
 
 Returns
 
@@ -2934,6 +2938,10 @@ Argument Details
   + The private key of the other party
 + **invoiceNumber**
   + The invoice number used to derive the child key
++ **cacheSharedSecret**
+  + Optional function to cache shared secrets
++ **retrieveCachedSharedSecret**
+  + Optional function to retrieve shared secrets from the cache
 
 #### Method deriveSharedSecret
 

package/docs/reference/wallet.md

@@ -1549,7 +1549,9 @@ This is useful for optimizing performance when the same keys are derived multipl
 It supports configurable cache size with sane defaults and maintains cache entries using LRU (Least Recently Used) eviction policy.
 
 ```ts
-export default class CachedKeyDeriver {
+export default class CachedKeyDeriver implements KeyDeriverApi {
+    rootKey: PrivateKey;
+    identityKey: string;
     constructor(rootKey: PrivateKey | "anyone", options?: {
         maxCacheSize?: number;
     }) 
@@ -1561,7 +1563,7 @@ export default class CachedKeyDeriver {
 }
 ```
 
-See also: [Counterparty](./wallet.md#type-counterparty), [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey), [SymmetricKey](./primitives.md#class-symmetrickey), [WalletProtocol](./wallet.md#type-walletprotocol)
+See also: [Counterparty](./wallet.md#type-counterparty), [KeyDeriverApi](./wallet.md#interface-keyderiverapi), [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey), [SymmetricKey](./primitives.md#class-symmetrickey), [WalletProtocol](./wallet.md#type-walletprotocol)
 
 #### Constructor
 
@@ -1581,6 +1583,23 @@ Argument Details
 + **options**
   + Optional settings for the cache.
 
+#### Property identityKey
+
+The identity of this key deriver which is normally the public key associated with the `rootKey`
+
+```ts
+identityKey: string
+```
+
+#### Property rootKey
+
+The root key from which all other keys are derived.
+
+```ts
+rootKey: PrivateKey
+```
+See also: [PrivateKey](./primitives.md#class-privatekey)
+
 #### Method derivePrivateKey
 
 Derives a private key based on protocol ID, key ID, and counterparty.
@@ -1955,7 +1974,7 @@ It supports deriving public and private keys, symmetric keys, and revealing key
 export class KeyDeriver implements KeyDeriverApi {
     rootKey: PrivateKey;
     identityKey: string;
-    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))) 
     derivePublicKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty, forSelf: boolean = false): PublicKey 
     derivePrivateKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): PrivateKey 
     deriveSymmetricKey(protocolID: WalletProtocol, keyID: string, counterparty: Counterparty): SymmetricKey 
@@ -1964,16 +1983,16 @@ export class KeyDeriver implements KeyDeriverApi {
 }
 ```
 
-See also: [Counterparty](./wallet.md#type-counterparty), [KeyDeriverApi](./wallet.md#interface-keyderiverapi), [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey), [SymmetricKey](./primitives.md#class-symmetrickey), [WalletProtocol](./wallet.md#type-walletprotocol)
+See also: [Counterparty](./wallet.md#type-counterparty), [KeyDeriverApi](./wallet.md#interface-keyderiverapi), [Point](./primitives.md#class-point), [PrivateKey](./primitives.md#class-privatekey), [PublicKey](./primitives.md#class-publickey), [SymmetricKey](./primitives.md#class-symmetrickey), [WalletProtocol](./wallet.md#type-walletprotocol)
 
 #### Constructor
 
 Initializes the KeyDeriver instance with a root private key.
 
 ```ts
-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))) 
 ```
-See also: [PrivateKey](./primitives.md#class-privatekey)
+See also: [Point](./primitives.md#class-point), [PrivateKey](./primitives.md#class-privatekey)
 
 Argument Details
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.6.15",
+  "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/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 (