@bsv/sdk 1.1.33 → 1.2.0

package/src/overlay-tools/index.ts

@@ -0,0 +1,5 @@
+export * from './LookupResolver.js'
+export * from './SHIPBroadcaster.js'
+export { default as OverlayAdminTokenTemplate } from './OverlayAdminTokenTemplate.js'
+export { default as LookupResolver } from './LookupResolver.js'
+export { default as SHIPBroadcaster } from './SHIPBroadcaster.js'

package/src/script/templates/PushDrop.ts

@@ -0,0 +1,246 @@
+import { ScriptTemplate, LockingScript, UnlockingScript, OP } from '../index.js'
+import { Utils, Hash, TransactionSignature, Signature, PublicKey } from '../../primitives/index.js'
+import { Wallet } from '../../wallet/Wallet.interfaces.js'
+import { Transaction } from '../../transaction/index.js'
+
+/**
+ * For a given piece of data to push onto the stack in script, creates the correct minimally-encoded script chunk,
+ * including the correct push operation.
+ *
+ * TODO: This should be made into a TS-SDK util (distinct from the `minimallyEncode` util)
+ */
+const createMinimallyEncodedScriptChunk = (data: number[]): { op: number, data?: number[] } => {
+  if (data.length === 0) {
+    // Could have used OP_0.
+    return { op: 0 }
+  }
+  if (data.length === 1 && data[0] === 0) {
+    // Could have used OP_0.
+    return { op: 0 }
+  }
+  if (data.length === 1 && data[0] > 0 && data[0] <= 16) {
+    // Could have used OP_0 .. OP_16.
+    return { op: 0x50 + data[0] }
+  }
+  if (data.length === 1 && data[0] === 0x81) {
+    // Could have used OP_1NEGATE.
+    return { op: 0x4f }
+  }
+  if (data.length <= 75) {
+    // Could have used a direct push (opcode indicating number of bytes
+    // pushed + those bytes).
+    return { op: data.length, data }
+  }
+  if (data.length <= 255) {
+    // Could have used OP_PUSHDATA.
+    return { op: 0x4c, data }
+  }
+  if (data.length <= 65535) {
+    // Could have used OP_PUSHDATA2.
+    return { op: 0x4d, data }
+  }
+  return { op: 0x4e, data }
+}
+
+export default class PushDrop implements ScriptTemplate {
+  wallet: Wallet
+
+  /**
+   * Decodes a PushDrop script back into its token fields and the locking public key. If a signature was present, it will be the last field returned.
+   * Warning: Only works with a P2PK lock at the beginning of the script.
+   * @param script PushDrop script to decode back into token fields
+   * @returns An object containing PushDrop token fields and the locking public key. If a signature was included, it will be the last field.
+   */
+  static decode(script: LockingScript): { lockingPublicKey: PublicKey, fields: number[][] } {
+    const lockingPublicKey = PublicKey.fromString(Utils.toHex(script.chunks[0].data))
+    const fields = []
+    for (let i = 2; i < script.chunks.length; i++) {
+      const nextOpcode = script.chunks[i + 1].op
+      let chunk = script.chunks[i].data
+      if (!chunk) {
+        if (script.chunks[i].op >= 80 && script.chunks[i].op <= 95) {
+          chunk = [script.chunks[i].op - 80]
+        } else if (script.chunks[i].op === 0) {
+          chunk = [0]
+        } else if (script.chunks[i].op === 0x4f) {
+          chunk = [0x81]
+        }
+      }
+      fields.push(chunk)
+
+      // If the next value is DROP or 2DROP then this is the final field
+      if (nextOpcode === OP.OP_DROP || nextOpcode === OP.OP_2DROP) {
+        break
+      }
+    }
+
+    return {
+      fields,
+      lockingPublicKey
+    }
+  }
+
+  /**
+   * Constructs a new instance of the PushDrop class.
+   *
+   * @param {Wallet} wallet - The wallet interface used for creating signatures and accessing public keys.
+   */
+  constructor(wallet: Wallet) {
+    this.wallet = wallet
+  }
+
+  /**
+   * Creates a PushDrop locking script with arbitrary data fields and a public key lock.
+   *
+   * @param {number[][]} fields - The token fields to include in the locking script.
+   * @param {[0 | 1 | 2, string]} protocolID - The protocol ID to use.
+   * @param {string} keyID - The key ID to use.
+   * @param {string} counterparty - The counterparty involved in the transaction, "self" or "anyone".
+   * @param {boolean} [forSelf=false] - Flag indicating if the lock is for the creator (default no).
+   * @param {boolean} [includeSignature=true] - Flag indicating if a signature should be included in the script (default yes).
+   * @returns {Promise<LockingScript>} The generated PushDrop locking script.
+   */
+  async lock(fields: number[][], protocolID: [0 | 1 | 2, string], keyID: string, counterparty: string, forSelf = false, includeSignature = true, lockPosition: 'before' | 'after' = 'before'): Promise<LockingScript> {
+    const { publicKey } = await this.wallet.getPublicKey({
+      protocolID,
+      keyID,
+      counterparty,
+      forSelf
+    })
+    const lockChunks: Array<{ op: number, data?: number[] }> = []
+    const pushDropChunks: Array<{ op: number, data?: number[] }> = []
+    lockChunks.push({ op: publicKey.length / 2, data: Utils.toArray(publicKey, 'hex') })
+    lockChunks.push({ op: OP.OP_CHECKSIG })
+    if (includeSignature) {
+      const dataToSign = fields.reduce((a, e) => [...a, ...e], [])
+      const { signature } = await this.wallet.createSignature({
+        data: dataToSign,
+        protocolID,
+        keyID,
+        counterparty
+      })
+      fields.push(signature)
+    }
+    for (const field of fields) {
+      pushDropChunks.push(createMinimallyEncodedScriptChunk(field))
+    }
+    let notYetDropped = fields.length
+    while (notYetDropped > 1) {
+      pushDropChunks.push({ op: OP.OP_2DROP })
+      notYetDropped -= 2
+    }
+    if (notYetDropped) {
+      pushDropChunks.push({ op: OP.OP_DROP })
+    }
+    if (lockPosition === 'before') {
+      return new LockingScript([
+        ...lockChunks,
+        ...pushDropChunks
+      ])
+    } else {
+      return new LockingScript([
+        ...pushDropChunks,
+        ...lockChunks
+      ])
+    }
+  }
+
+  /**
+   * Creates an unlocking script for spending a PushDrop token output.
+   *
+   * @param {[0 | 1 | 2, string]} protocolID - The protocol ID to use.
+   * @param {string} keyID - The key ID to use.
+   * @param {string} counterparty - The counterparty involved in the transaction, "self" or "anyone".
+   * @param {string} [sourceTXID] - The TXID of the source transaction.
+   * @param {number} [sourceSatoshis] - The number of satoshis in the source output.
+   * @param {LockingScript} [lockingScript] - The locking script of the source output.
+   * @param {'all' | 'none' | 'single'} [signOutputs='all'] - Specifies which outputs to sign.
+   * @param {boolean} [anyoneCanPay=false] - Specifies if the anyone-can-pay flag is set.
+   * @returns {Object} An object containing functions to sign the transaction and estimate the script length.
+   */
+  unlock(
+    protocolID: [0 | 1 | 2, string],
+    keyID: string,
+    counterparty: string,
+    signOutputs: 'all' | 'none' | 'single' = 'all',
+    anyoneCanPay = false,
+    sourceSatoshis?: number,
+    lockingScript?: LockingScript
+  ): {
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<73>
+  } {
+    return {
+      sign: async (tx: Transaction, inputIndex: number): Promise<UnlockingScript> => {
+        let signatureScope = TransactionSignature.SIGHASH_FORKID
+        if (signOutputs === 'all') {
+          signatureScope |= TransactionSignature.SIGHASH_ALL
+        }
+        if (signOutputs === 'none') {
+          signatureScope |= TransactionSignature.SIGHASH_NONE
+        }
+        if (signOutputs === 'single') {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE
+        }
+        if (anyoneCanPay) {
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
+        }
+
+        const input = tx.inputs[inputIndex]
+
+        const otherInputs = tx.inputs.filter((_, index) => index !== inputIndex)
+
+        const sourceTXID = input.sourceTXID ? input.sourceTXID : input.sourceTransaction?.id('hex')
+        if (!sourceTXID) {
+          throw new Error(
+            'The input sourceTXID or sourceTransaction is required for transaction signing.'
+          )
+        }
+        sourceSatoshis ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].satoshis
+        if (!sourceSatoshis) {
+          throw new Error(
+            'The sourceSatoshis or input sourceTransaction is required for transaction signing.'
+          )
+        }
+        lockingScript ||= input.sourceTransaction?.outputs[input.sourceOutputIndex].lockingScript
+        if (!lockingScript) {
+          throw new Error(
+            'The lockingScript or input sourceTransaction is required for transaction signing.'
+          )
+        }
+
+        const preimage = TransactionSignature.format({
+          sourceTXID,
+          sourceOutputIndex: input.sourceOutputIndex,
+          sourceSatoshis,
+          transactionVersion: tx.version,
+          otherInputs,
+          inputIndex,
+          outputs: tx.outputs,
+          inputSequence: input.sequence,
+          subscript: lockingScript,
+          lockTime: tx.lockTime,
+          scope: signatureScope
+        })
+        const preimageHash = Hash.sha256(preimage)
+        const { signature: bareSignature } = await this.wallet.createSignature({
+          data: preimageHash,
+          protocolID,
+          keyID,
+          counterparty
+        })
+        const signature = Signature.fromDER([...bareSignature])
+        const txSignature = new TransactionSignature(
+          signature.r,
+          signature.s,
+          signatureScope
+        )
+        const sigForScript = txSignature.toChecksigFormat()
+        return new UnlockingScript([
+          { op: sigForScript.length, data: sigForScript }
+        ])
+      },
+      estimateLength: async () => 73
+    }
+  }
+}

package/src/script/templates/__tests/PushDrop.test.ts

@@ -0,0 +1,158 @@
+/* eslint-env jest */
+import PushDrop from '../../../../dist/cjs/src/script/templates/PushDrop.js'
+import ProtoWallet from '../../../../dist/cjs/src/wallet/ProtoWallet.js'
+import { PrivateKey, Utils } from '../../../../dist/cjs/src/primitives/index.js'
+import { Script, Spend } from '../../../../dist/cjs/src/script/index.js'
+import { Transaction } from '../../../../dist/cjs/src/transaction/index.js'
+
+describe('PushDrop', () => {
+  let privateKey: typeof PrivateKey
+  let wallet
+  let pushDrop: PushDrop
+
+  const createDecodeRedeem = async (fields: number[][] = [], protocolID: [0 | 1 | 2, string] = [0, 'tests'], keyID: string = 'test-key', counterparty: string = 'self', signOutputs: 'all' | 'none' | 'single' = 'all', anyoneCanPay: boolean = false) => {
+    const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+    expect(lockingScript).toBeInstanceOf(Script)
+    const decoded = await PushDrop.decode(lockingScript)
+    expect(decoded.fields).toEqual(fields)
+    const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+    expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    const satoshis = 1
+    const unlockingTemplate = await pushDrop.unlock(protocolID, keyID, counterparty, signOutputs, anyoneCanPay)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    expect(await unlockingTemplate.estimateLength()).toEqual(73)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  }
+
+  beforeEach(() => {
+    privateKey = PrivateKey.fromRandom()
+    wallet = new ProtoWallet(privateKey)
+    pushDrop = new PushDrop(wallet)
+  })
+
+  it('Passes various test vectors', async () => {
+    await createDecodeRedeem()
+    await createDecodeRedeem([[0]])
+    await createDecodeRedeem([[1]])
+    await createDecodeRedeem([[0x81]])
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]])
+    await createDecodeRedeem([new Array(200).fill(0xff)])
+    await createDecodeRedeem([new Array(400).fill(0xff)])
+    await createDecodeRedeem([new Array(70000).fill(0xff)])
+    await createDecodeRedeem([[0], [1], [2]])
+    await createDecodeRedeem([[0], [1], [2], [3]])
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'none', false)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'single', false)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'all', true)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'none', true)
+    await createDecodeRedeem([[3, 1, 4, 1, 5, 9]], undefined, undefined, undefined, 'single', true)
+  })
+
+  describe('lock', () => {
+    it('creates a correct locking script', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+
+      // Check that the locking script is not null
+      expect(lockingScript).toBeInstanceOf(Script)
+
+      // Decode the locking script and check the fields and locking public key
+      const decoded = await PushDrop.decode(lockingScript)
+      expect(decoded.fields).toEqual(fields)
+      const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    })
+  })
+
+  describe('unlock', () => {
+    it('creates a correct unlocking script', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+      const satoshis = 1
+      const unlockingTemplate = await pushDrop.unlock(protocolID, keyID, counterparty)
+      const sourceTx = new Transaction(1, [], [{
+        lockingScript,
+        satoshis
+      }], 0)
+      const spendTx = new Transaction(1, [{
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        sequence: 0xffffffff
+      }], [], 0)
+      const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+      expect(await unlockingTemplate.estimateLength()).toEqual(73)
+      const spend = new Spend({
+        sourceTXID: sourceTx.id('hex'),
+        sourceOutputIndex: 0,
+        sourceSatoshis: satoshis,
+        lockingScript,
+        transactionVersion: 1,
+        otherInputs: [],
+        inputIndex: 0,
+        unlockingScript,
+        outputs: [],
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      const valid = spend.validate()
+      expect(valid).toBe(true)
+    })
+  })
+
+  describe('decode', () => {
+    it('decodes the locking script correctly', async () => {
+      const fields = [
+        Utils.toArray('hello world', 'utf8'),
+        Utils.toArray('This is a field', 'utf8'),
+        [0xde, 0xad, 0xbe, 0xef]
+      ]
+      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
+      const keyID = 'test-key'
+      const counterparty = 'self'
+
+      const lockingScript = await pushDrop.lock(fields, protocolID, keyID, counterparty)
+
+      const decoded = await PushDrop.decode(lockingScript)
+      expect(decoded.fields).toEqual(fields)
+      const expectedPublicKey = (await wallet.getPublicKey({ protocolID, keyID, counterparty })).publicKey
+      expect(decoded.lockingPublicKey.toString()).toEqual(expectedPublicKey)
+    })
+  })
+})

package/src/script/templates/index.ts

@@ -1,2 +1,3 @@
 export { default as P2PKH } from './P2PKH.js'
 export { default as RPuzzle } from './RPuzzle.js'
+export { default as PushDrop } from './PushDrop.js'

package/src/transaction/http/DefaultHttpClient.ts

@@ -16,7 +16,7 @@ export function defaultHttpClient (): HttpClient {
 
   if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
     // Use fetch in a browser environment
-    return new FetchHttpClient(window.fetch)
+    return new FetchHttpClient(window.fetch.bind(window))
   } else if (typeof require !== 'undefined') {
     // Use Node.js https module
     // eslint-disable-next-line

package/src/wallet/CachedKeyDeriver.ts

@@ -0,0 +1,193 @@
+import { PrivateKey, PublicKey, SymmetricKey } from '../primitives/index.js'
+import KeyDeriver from './KeyDeriver.js'
+
+/**
+ * A cached version of KeyDeriver that caches the results of key derivation methods.
+ * 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 {
+  private readonly keyDeriver: KeyDeriver
+  private readonly cache: Map<string, any>
+  private readonly maxCacheSize: number
+
+  /**
+     * 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'.
+     * @param {Object} [options] - Optional settings for the cache.
+     * @param {number} [options.maxCacheSize=1000] - The maximum number of entries to store in the cache.
+     */
+  constructor(rootKey: PrivateKey | 'anyone', options?: { maxCacheSize?: number }) {
+    this.keyDeriver = new KeyDeriver(rootKey)
+    this.cache = new Map<string, any>()
+    this.maxCacheSize = options?.maxCacheSize || 1000
+  }
+
+  /**
+     * Derives a public key based on protocol ID, key ID, and counterparty.
+     * Caches the result for future calls with the same parameters.
+     * @param {[0 | 1 | 2, string]} protocolID - The protocol ID including a security level and protocol name.
+     * @param {string} keyID - The key identifier.
+     * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+     * @param {boolean} [forSelf=false] - Whether deriving for self.
+     * @returns {PublicKey} - The derived public key.
+     */
+  derivePublicKey(
+    protocolID: [0 | 1 | 2, string],
+    keyID: string,
+    counterparty: PublicKey | string | 'self' | 'anyone',
+    forSelf: boolean = false
+  ): PublicKey {
+    const cacheKey = this.generateCacheKey('derivePublicKey', protocolID, keyID, counterparty, forSelf)
+    if (this.cache.has(cacheKey)) {
+      return this.cacheGet(cacheKey)
+    } else {
+      const result = this.keyDeriver.derivePublicKey(protocolID, keyID, counterparty, forSelf)
+      this.cacheSet(cacheKey, result)
+      return result
+    }
+  }
+
+  /**
+     * Derives a private key based on protocol ID, key ID, and counterparty.
+     * Caches the result for future calls with the same parameters.
+     * @param {[0 | 1 | 2, string]} protocolID - The protocol ID including a security level and protocol name.
+     * @param {string} keyID - The key identifier.
+     * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+     * @returns {PrivateKey} - The derived private key.
+     */
+  derivePrivateKey(
+    protocolID: [0 | 1 | 2, string],
+    keyID: string,
+    counterparty: PublicKey | string | 'self' | 'anyone'
+  ): PrivateKey {
+    const cacheKey = this.generateCacheKey('derivePrivateKey', protocolID, keyID, counterparty)
+    if (this.cache.has(cacheKey)) {
+      return this.cacheGet(cacheKey)
+    } else {
+      const result = this.keyDeriver.derivePrivateKey(protocolID, keyID, counterparty)
+      this.cacheSet(cacheKey, result)
+      return result
+    }
+  }
+
+  /**
+     * Derives a symmetric key based on protocol ID, key ID, and counterparty.
+     * Caches the result for future calls with the same parameters.
+     * @param {[0 | 1 | 2, string]} protocolID - The protocol ID including a security level and protocol name.
+     * @param {string} keyID - The key identifier.
+     * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+     * @returns {SymmetricKey} - The derived symmetric key.
+     * @throws {Error} - Throws an error if attempting to derive a symmetric key for 'anyone'.
+     */
+  deriveSymmetricKey(
+    protocolID: [0 | 1 | 2, string],
+    keyID: string,
+    counterparty: PublicKey | string | 'self' | 'anyone'
+  ): SymmetricKey {
+    const cacheKey = this.generateCacheKey('deriveSymmetricKey', protocolID, keyID, counterparty)
+    if (this.cache.has(cacheKey)) {
+      return this.cacheGet(cacheKey)
+    } else {
+      const result = this.keyDeriver.deriveSymmetricKey(protocolID, keyID, counterparty)
+      this.cacheSet(cacheKey, result)
+      return result
+    }
+  }
+
+  /**
+     * Reveals the shared secret between the root key and the counterparty.
+     * Caches the result for future calls with the same parameters.
+     * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+     * @returns {number[]} - The shared secret as a number array.
+     * @throws {Error} - Throws an error if attempting to reveal a shared secret for 'self'.
+     */
+  revealCounterpartySecret(counterparty: PublicKey | string | 'self' | 'anyone'): number[] {
+    const cacheKey = this.generateCacheKey('revealCounterpartySecret', counterparty)
+    if (this.cache.has(cacheKey)) {
+      return this.cacheGet(cacheKey)
+    } else {
+      const result = this.keyDeriver.revealCounterpartySecret(counterparty)
+      this.cacheSet(cacheKey, result)
+      return result
+    }
+  }
+
+  /**
+     * Reveals the specific key association for a given protocol ID, key ID, and counterparty.
+     * Caches the result for future calls with the same parameters.
+     * @param {PublicKey | string | 'self' | 'anyone'} counterparty - The counterparty's public key or a predefined value ('self' or 'anyone').
+     * @param {[0 | 1 | 2, string]} protocolID - The protocol ID including a security level and protocol name.
+     * @param {string} keyID - The key identifier.
+     * @returns {number[]} - The specific key association as a number array.
+     */
+  revealSpecificSecret(
+    counterparty: PublicKey | string | 'self' | 'anyone',
+    protocolID: [0 | 1 | 2, string],
+    keyID: string
+  ): number[] {
+    const cacheKey = this.generateCacheKey('revealSpecificSecret', counterparty, protocolID, keyID)
+    if (this.cache.has(cacheKey)) {
+      return this.cacheGet(cacheKey)
+    } else {
+      const result = this.keyDeriver.revealSpecificSecret(counterparty, protocolID, keyID)
+      this.cacheSet(cacheKey, result)
+      return result
+    }
+  }
+
+  /**
+     * Generates a unique cache key based on the method name and input parameters.
+     * @param {string} methodName - The name of the method.
+     * @param {...any} args - The arguments passed to the method.
+     * @returns {string} - The generated cache key.
+     */
+  private generateCacheKey(methodName: string, ...args: any[]): string {
+    const serializedArgs = args.map((arg) => this.serializeArgument(arg)).join('|')
+    return `${methodName}|${serializedArgs}`
+  }
+
+  /**
+     * Serializes an argument to a string for use in a cache key.
+     * @param {any} arg - The argument to serialize.
+     * @returns {string} - The serialized argument.
+     */
+  private serializeArgument(arg: any): string {
+    if (arg instanceof PublicKey || arg instanceof PrivateKey) {
+      return arg.toString()
+    } else if (Array.isArray(arg)) {
+      return arg.map((item) => this.serializeArgument(item)).join(',')
+    } else if (typeof arg === 'object' && arg !== null) {
+      return JSON.stringify(arg)
+    } else {
+      return String(arg)
+    }
+  }
+
+  /**
+     * Retrieves an item from the cache and updates its position to reflect recent use.
+     * @param {string} cacheKey - The key of the cached item.
+     * @returns {any} - The cached value.
+     */
+  private cacheGet(cacheKey: string): any {
+    const value = this.cache.get(cacheKey)
+    // Update the entry to reflect recent use
+    this.cache.delete(cacheKey)
+    this.cache.set(cacheKey, value)
+    return value
+  }
+
+  /**
+     * Adds an item to the cache and evicts the least recently used item if necessary.
+     * @param {string} cacheKey - The key of the item to cache.
+     * @param {any} value - The value to cache.
+     */
+  private cacheSet(cacheKey: string, value: any): void {
+    if (this.cache.size >= this.maxCacheSize) {
+      // Evict the least recently used item (first item in Map)
+      const firstKey = this.cache.keys().next().value
+      this.cache.delete(firstKey)
+    }
+    this.cache.set(cacheKey, value)
+  }
+}