@bsv/wallet-toolbox 1.7.16 → 1.7.17

package/mobile/node_modules/@bsv/sdk/src/wallet/substrates/__tests/WalletWire.integration.test.ts

@@ -1,2353 +0,0 @@
-import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
-import { Utils, PrivateKey, Hash } from '../../../primitives/index'
-import WalletWireTransceiver from '../../../wallet/substrates/WalletWireTransceiver'
-import WalletWireProcessor from '../../../wallet/substrates/WalletWireProcessor'
-
-const sampleData = [3, 1, 4, 1, 5, 9]
-
-describe('WalletWire Integration Tests', () => {
-  /**
-   * This is a copy of the test suite for CompletedProtoWallet, but instead of using a CompletedProtoWallet directly, we're using it over the WalletWire.
-   * This serves as an imperfect but still useful way to ensure that the WalletWire doesn't contain serialization or deserialization issues.
-   */
-  describe('ProtoWallet Over Wallet Wire', () => {
-    it('Throws when functions are not supported', async () => {
-      const wallet = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet('anyone'))
-      )
-      await expect(() => {
-        return (wallet as any).createAction()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).abortAction()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).signAction()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).listOutputs()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).relinquishOutput()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).listActions()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).internalizeAction()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).acquireCertificate()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).proveCertificate()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).listCertificates()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).relinquishCertificate()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).getHeight()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).getHeaderForHeight()
-      }).rejects.toThrow()
-      // TODO: Remove these two from the throw list once they are implemented.
-      await expect(() => {
-        return (wallet as any).discoverByIdentityKey()
-      }).rejects.toThrow()
-      await expect(() => {
-        return (wallet as any).discoverByAttributes()
-      }).rejects.toThrow()
-    })
-    it('Validates the BRC-3 compliance vector', async () => {
-      const wallet = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet('anyone'))
-      )
-      const { valid } = await wallet.verifySignature({
-        data: Utils.toArray('BRC-3 Compliance Validated!', 'utf8'),
-        signature: [
-          48, 68, 2, 32, 43, 34, 58, 156, 219, 32, 50, 70, 29, 240, 155, 137,
-          88, 60, 200, 95, 243, 198, 201, 21, 56, 82, 141, 112, 69, 196, 170,
-          73, 156, 6, 44, 48, 2, 32, 118, 125, 254, 201, 44, 87, 177, 170, 93,
-          11, 193, 134, 18, 70, 9, 31, 234, 27, 170, 177, 54, 96, 181, 140, 166,
-          196, 144, 14, 230, 118, 106, 105
-        ],
-        protocolID: [2, 'BRC3 Test'],
-        keyID: '42',
-        counterparty:
-          '0294c479f762f6baa97fbcd4393564c1d7bd8336ebd15928135bbcf575cd1a71a1'
-      })
-      expect(valid).toBe(true)
-    })
-    it('Validates the BRC-2 HMAC compliance vector', async () => {
-      const wallet = new WalletWireTransceiver(
-        new WalletWireProcessor(
-          new CompletedProtoWallet(
-            new PrivateKey(
-              '6a2991c9de20e38b31d7ea147bf55f5039e4bbc073160f5e0d541d1f17e321b8',
-              'hex'
-            )
-          )
-        )
-      )
-      const { valid } = await wallet.verifyHmac({
-        data: Utils.toArray('BRC-2 HMAC Compliance Validated!', 'utf8'),
-        hmac: [
-          81, 240, 18, 153, 163, 45, 174, 85, 9, 246, 142, 125, 209, 133, 82,
-          76, 254, 103, 46, 182, 86, 59, 219, 61, 126, 30, 176, 232, 233, 100,
-          234, 14
-        ],
-        protocolID: [2, 'BRC2 Test'],
-        keyID: '42',
-        counterparty:
-          '0294c479f762f6baa97fbcd4393564c1d7bd8336ebd15928135bbcf575cd1a71a1'
-      })
-      expect(valid).toBe(true)
-    })
-    it('Validates the BRC-2 Encryption compliance vector', async () => {
-      const wallet = new WalletWireTransceiver(
-        new WalletWireProcessor(
-          new CompletedProtoWallet(
-            new PrivateKey(
-              '6a2991c9de20e38b31d7ea147bf55f5039e4bbc073160f5e0d541d1f17e321b8',
-              'hex'
-            )
-          )
-        )
-      )
-      const { plaintext } = await wallet.decrypt({
-        ciphertext: [
-          252, 203, 216, 184, 29, 161, 223, 212, 16, 193, 94, 99, 31, 140, 99,
-          43, 61, 236, 184, 67, 54, 105, 199, 47, 11, 19, 184, 127, 2, 165, 125,
-          9, 188, 195, 196, 39, 120, 130, 213, 95, 186, 89, 64, 28, 1, 80, 20,
-          213, 159, 133, 98, 253, 128, 105, 113, 247, 197, 152, 236, 64, 166,
-          207, 113, 134, 65, 38, 58, 24, 127, 145, 140, 206, 47, 70, 146, 84,
-          186, 72, 95, 35, 154, 112, 178, 55, 72, 124
-        ],
-        protocolID: [2, 'BRC2 Test'],
-        keyID: '42',
-        counterparty:
-          '0294c479f762f6baa97fbcd4393564c1d7bd8336ebd15928135bbcf575cd1a71a1'
-      })
-      expect(Utils.toUTF8(plaintext)).toEqual(
-        'BRC-2 Encryption Compliance Validated!'
-      )
-    })
-    it('Encrypts messages decryptable by the counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { ciphertext } = await user.encrypt({
-        plaintext: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      const { plaintext } = await counterparty.decrypt({
-        ciphertext,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: userKey.toPublicKey().toString()
-      })
-      expect(plaintext).toEqual(sampleData)
-      expect(ciphertext).not.toEqual(plaintext)
-    })
-    it('Fails to decryupt messages for the wrong protocol, key, and counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { ciphertext } = await user.encrypt({
-        plaintext: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      await expect(
-        async () =>
-          await counterparty.decrypt({
-            ciphertext,
-            protocolID: [1, 'tests'],
-            keyID: '4',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.decrypt({
-            ciphertext,
-            protocolID: [2, 'tests'],
-            keyID: '5',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.decrypt({
-            ciphertext,
-            protocolID: [2, 'tests'],
-            keyID: '4',
-            counterparty: counterpartyKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-    })
-    it('Correctly derives keys for a counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { publicKey: identityKey } = await user.getPublicKey({
-        identityKey: true
-      })
-      expect(identityKey).toEqual(userKey.toPublicKey().toString())
-      const { publicKey: derivedForCounterparty } = await user.getPublicKey({
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      const { publicKey: derivedByCounterparty } =
-        await counterparty.getPublicKey({
-          protocolID: [2, 'tests'],
-          keyID: '4',
-          counterparty: userKey.toPublicKey().toString(),
-          forSelf: true
-        })
-      expect(derivedForCounterparty).toEqual(derivedByCounterparty)
-    })
-    it('Signs messages verifiable by the counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { signature } = await user.createSignature({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      const { valid } = await counterparty.verifySignature({
-        signature,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: userKey.toPublicKey().toString()
-      })
-      expect(valid).toEqual(true)
-      expect(signature.length).not.toEqual(0)
-    })
-    it('Directly signs hash of message verifiable by the counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { signature } = await user.createSignature({
-        hashToDirectlySign: Hash.sha256(sampleData),
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      const { valid } = await counterparty.verifySignature({
-        signature,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: userKey.toPublicKey().toString()
-      })
-      expect(valid).toEqual(true)
-      const { valid: hashValid } = await counterparty.verifySignature({
-        signature,
-        hashToDirectlyVerify: Hash.sha256(sampleData),
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: userKey.toPublicKey().toString()
-      })
-      expect(hashValid).toEqual(true)
-      expect(signature.length).not.toEqual(0)
-    })
-    it('Fails to verify signature for the wrong data, protocol, key, and counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { signature } = await user.createSignature({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      await expect(
-        async () =>
-          await counterparty.verifySignature({
-            signature,
-            data: [0, ...sampleData],
-            protocolID: [2, 'tests'],
-            keyID: '4',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.verifySignature({
-            signature,
-            data: sampleData,
-            protocolID: [2, 'wrong'],
-            keyID: '4',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.verifySignature({
-            signature,
-            data: sampleData,
-            protocolID: [2, 'tests'],
-            keyID: '2',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.verifySignature({
-            signature,
-            data: sampleData,
-            protocolID: [2, 'tests'],
-            keyID: '4',
-            counterparty: counterpartyKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-    })
-    it('Computes HMAC over messages verifiable by the counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { hmac } = await user.createHmac({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      const { valid } = await counterparty.verifyHmac({
-        hmac,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: userKey.toPublicKey().toString()
-      })
-      expect(valid).toEqual(true)
-      expect(hmac.length).toEqual(32)
-    })
-    it('Fails to verify HMAC for the wrong data, protocol, key, and counterparty', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const counterparty = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(counterpartyKey))
-      )
-      const { hmac } = await user.createHmac({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      })
-      await expect(
-        async () =>
-          await counterparty.verifyHmac({
-            hmac,
-            data: [0, ...sampleData],
-            protocolID: [2, 'tests'],
-            keyID: '4',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.verifyHmac({
-            hmac,
-            data: sampleData,
-            protocolID: [2, 'wrong'],
-            keyID: '4',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.verifyHmac({
-            hmac,
-            data: sampleData,
-            protocolID: [2, 'tests'],
-            keyID: '2',
-            counterparty: userKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-      await expect(
-        async () =>
-          await counterparty.verifyHmac({
-            hmac,
-            data: sampleData,
-            protocolID: [2, 'tests'],
-            keyID: '4',
-            counterparty: counterpartyKey.toPublicKey().toString()
-          })
-      ).rejects.toThrow()
-    })
-    it('Uses anyone for creating signatures and self for other operations if no counterparty is provided', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const user = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(userKey))
-      )
-      const { hmac } = await user.createHmac({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4'
-      })
-      const { valid: hmacValid } = await user.verifyHmac({
-        hmac,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4'
-      })
-      expect(hmacValid).toEqual(true)
-      const { valid: explicitSelfHmacValid } = await user.verifyHmac({
-        hmac,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: 'self'
-      })
-      expect(explicitSelfHmacValid).toEqual(true)
-      expect(hmac.length).toEqual(32)
-      const { signature: anyoneSig } = await user.createSignature({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4'
-        // counterparty=anyone is implicit for creating signatures
-      })
-      const anyone = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet('anyone'))
-      )
-      const { valid: anyoneSigValid } = await anyone.verifySignature({
-        signature: anyoneSig,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: userKey.toPublicKey().toString()
-      })
-      expect(anyoneSigValid).toEqual(true)
-      const { signature: selfSig } = await user.createSignature({
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: 'self'
-      })
-      const { valid: selfSigValid } = await user.verifySignature({
-        signature: selfSig,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4'
-        // Self is implicit when verifying signatures
-      })
-      expect(selfSigValid).toEqual(true)
-      const { valid: explicitSelfSigValid } = await user.verifySignature({
-        signature: selfSig,
-        data: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: 'self'
-      })
-      expect(explicitSelfSigValid).toEqual(true)
-      const { publicKey } = await user.getPublicKey({
-        protocolID: [2, 'tests'],
-        keyID: '4'
-      })
-      const { publicKey: explicitSelfPublicKey } = await user.getPublicKey({
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: 'self'
-      })
-      expect(publicKey).toEqual(explicitSelfPublicKey)
-      const { ciphertext } = await user.encrypt({
-        plaintext: sampleData,
-        protocolID: [2, 'tests'],
-        keyID: '4'
-      })
-      const { plaintext } = await user.decrypt({
-        ciphertext,
-        protocolID: [2, 'tests'],
-        keyID: '4'
-      })
-      const { plaintext: explicitSelfPlaintext } = await user.decrypt({
-        ciphertext,
-        protocolID: [2, 'tests'],
-        keyID: '4',
-        counterparty: 'self'
-      })
-      expect(plaintext).toEqual(explicitSelfPlaintext)
-      expect(plaintext).toEqual(sampleData)
-    })
-    it('Validates the revealCounterpartyKeyLinkage function', async () => {
-      // Initialize keys
-      const proverKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const verifierKey = PrivateKey.fromRandom()
-
-      // Initialize wallets
-      const proverWallet = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(proverKey))
-      )
-      const verifierWallet = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(verifierKey))
-      )
-
-      // Prover reveals counterparty key linkage
-      const revelation = await proverWallet.revealCounterpartyKeyLinkage({
-        counterparty: counterpartyKey.toPublicKey().toString(),
-        verifier: verifierKey.toPublicKey().toString()
-      })
-
-      // Verifier decrypts the encrypted linkage
-      const { plaintext: linkage } = await verifierWallet.decrypt({
-        ciphertext: revelation.encryptedLinkage,
-        protocolID: [2, 'counterparty linkage revelation'],
-        keyID: revelation.revelationTime,
-        counterparty: proverKey.toPublicKey().toString()
-      })
-
-      // Compute expected linkage
-      const expectedLinkage = proverKey
-        .deriveSharedSecret(counterpartyKey.toPublicKey())
-        .encode(true)
-
-      // Compare linkage and expectedLinkage
-      expect(linkage).toEqual(expectedLinkage)
-    })
-
-    it('Validates the revealSpecificKeyLinkage function', async () => {
-      // Initialize keys
-      const proverKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const verifierKey = PrivateKey.fromRandom()
-
-      // Initialize wallets
-      const proverWallet = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(proverKey))
-      )
-      const verifierWallet = new WalletWireTransceiver(
-        new WalletWireProcessor(new CompletedProtoWallet(verifierKey))
-      )
-
-      const protocolID: [0 | 1 | 2, string] = [0, 'tests']
-      const keyID = 'test key id'
-
-      // Prover reveals specific key linkage
-      const revelation = await proverWallet.revealSpecificKeyLinkage({
-        counterparty: counterpartyKey.toPublicKey().toString(),
-        verifier: verifierKey.toPublicKey().toString(),
-        protocolID,
-        keyID
-      })
-      expect(revelation.encryptedLinkageProof).toBeDefined()
-      expect(revelation.proofType).toBeDefined()
-
-      // Verifier decrypts the encrypted linkage
-      const { plaintext: linkage } = await verifierWallet.decrypt({
-        ciphertext: revelation.encryptedLinkage,
-        protocolID: [
-          2,
-          `specific linkage revelation ${protocolID[0]} ${protocolID[1]}`
-        ],
-        keyID,
-        counterparty: proverKey.toPublicKey().toString()
-      })
-
-      // Compute expected linkage
-      const sharedSecret = proverKey
-        .deriveSharedSecret(counterpartyKey.toPublicKey())
-        .encode(true)
-
-      // Function to compute the invoice number
-      const computeInvoiceNumber = function (protocolID: [number, string], keyID: string): string {
-        const securityLevel = protocolID[0]
-        if (
-          !Number.isInteger(securityLevel) ||
-          securityLevel < 0 ||
-          securityLevel > 2
-        ) {
-          throw new Error('Protocol security level must be 0, 1, or 2')
-        }
-        const protocolName = protocolID[1].toLowerCase().trim()
-        if (keyID.length > 800) {
-          throw new Error('Key IDs must be 800 characters or less')
-        }
-        if (keyID.length < 1) {
-          throw new Error('Key IDs must be 1 character or more')
-        }
-        if (protocolName.length > 400) {
-          throw new Error('Protocol names must be 400 characters or less')
-        }
-        if (protocolName.length < 5) {
-          throw new Error('Protocol names must be 5 characters or more')
-        }
-        if (protocolName.includes('  ')) {
-          throw new Error(
-            'Protocol names cannot contain multiple consecutive spaces ("  ")'
-          )
-        }
-        if (!/^[a-z0-9 ]+$/g.test(protocolName)) {
-          throw new Error(
-            'Protocol names can only contain letters, numbers and spaces'
-          )
-        }
-        if (protocolName.endsWith(' protocol')) {
-          throw new Error('No need to end your protocol name with " protocol"')
-        }
-        return `${securityLevel}-${protocolName}-${keyID}`
-      }
-      const invoiceNumber = computeInvoiceNumber(protocolID, keyID)
-      const invoiceNumberBin = Utils.toArray(invoiceNumber, 'utf8')
-
-      // Compute expected linkage
-      const expectedLinkage = Hash.sha256hmac(sharedSecret, invoiceNumberBin)
-
-      // Compare linkage and expectedLinkage
-      expect(linkage).toEqual(expectedLinkage)
-    })
-  })
-  // Helper function to create a test wallet wire setup
-  const createTestWalletWire = (wallet: CompletedProtoWallet): WalletWireTransceiver => {
-    const processor = new WalletWireProcessor(wallet)
-    const transceiver = new WalletWireTransceiver(processor)
-    return transceiver
-  }
-
-  // Mock implementation for methods not supported by CompletedProtoWallet
-  const mockUnsupportedMethods = (
-    methods: Partial<CompletedProtoWallet>
-  ): CompletedProtoWallet => {
-    // @ts-expect-error
-    const result: CompletedProtoWallet = {
-      ...methods
-    }
-    return result
-  }
-
-  describe('createAction', () => {
-    it('should create an action with valid inputs', async () => {
-      // Mock the createAction method
-      const createActionMock = jest.fn().mockResolvedValue({
-        txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806',
-        tx: [1, 2, 3, 4]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          createAction: createActionMock
-        })
-      )
-
-      const args = {
-        description: 'Test action description',
-        outputs: [
-          {
-            lockingScript: '00', // Sample locking script
-            satoshis: 1000,
-            outputDescription: 'Test output',
-            basket: 'test-basket',
-            customInstructions: 'Test instructions',
-            tags: ['test-tag']
-          }
-        ],
-        labels: ['test-label']
-      }
-      const result = await wallet.createAction(args)
-      expect(result).toHaveProperty('txid')
-      expect(result).toHaveProperty('tx')
-      expect(result.tx).toBeInstanceOf(Array)
-      expect(createActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should create an action with minimal inputs (only description)', async () => {
-      // Mock the createAction method
-      const createActionMock = jest.fn().mockResolvedValue({
-        txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806'
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          createAction: createActionMock
-        })
-      )
-
-      const args = {
-        description: 'Minimal action description'
-      }
-      const result = await wallet.createAction(args)
-      expect(result).toHaveProperty('txid')
-      expect(result).not.toHaveProperty('tx')
-      expect(result).not.toHaveProperty('noSendChange')
-      expect(result).not.toHaveProperty('sendWithResults')
-      expect(result).not.toHaveProperty('signableTransaction')
-      expect(createActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should create an action and return only txid when returnTXIDOnly is true', async () => {
-      // Mock the createAction method
-      const createActionMock = jest.fn().mockResolvedValue({
-        txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806'
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          createAction: createActionMock
-        })
-      )
-
-      const args = {
-        description: 'Test action with returnTXIDOnly',
-        options: {
-          returnTXIDOnly: true
-        }
-      }
-      const result = await wallet.createAction(args)
-      expect(result).toHaveProperty('txid')
-      expect(result).not.toHaveProperty('tx')
-      expect(result).not.toHaveProperty('noSendChange')
-      expect(result).not.toHaveProperty('sendWithResults')
-      expect(result).not.toHaveProperty('signableTransaction')
-      expect(createActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should create an action and return a signableTransaction when noSend is true', async () => {
-      // Mock the createAction method
-      const createActionMock = jest.fn().mockResolvedValue({
-        signableTransaction: {
-          tx: [0x01],
-          reference: Utils.toBase64([0x01])
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          createAction: createActionMock
-        })
-      )
-
-      const args = {
-        description: 'Test action with noSend',
-        options: {
-          noSend: true
-        }
-      }
-      const result = await wallet.createAction(args)
-      expect(result).toHaveProperty('signableTransaction')
-      expect(result.signableTransaction).toHaveProperty('tx')
-      expect(result.signableTransaction).toHaveProperty('reference')
-      expect(result).not.toHaveProperty('txid')
-      expect(result).not.toHaveProperty('tx')
-      expect(createActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should create an action with all options set and handle all return values', async () => {
-      // Mock the createAction method
-      const createActionMock = jest.fn().mockResolvedValue({
-        txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806',
-        tx: [1, 2, 3, 4],
-        noSendChange: [
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0'
-        ],
-        sendWithResults: [
-          {
-            txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806',
-            status: 'sending'
-          }
-        ],
-        signableTransaction: {
-          tx: [0x01],
-          reference: Utils.toBase64([0x01])
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          createAction: createActionMock
-        })
-      )
-
-      const args = {
-        description: 'Test action with all options',
-        inputs: [],
-        inputBEEF: [1, 2, 3, 4],
-        outputs: [
-          {
-            lockingScript: '016a',
-            satoshis: 1,
-            outputDescription: 'This is a test.'
-          }
-        ],
-        lockTime: 0,
-        version: 1,
-        labels: ['label1', 'label2'],
-        options: {
-          signAndProcess: false,
-          acceptDelayedBroadcast: false,
-          trustSelf: 'known' as 'known',
-          knownTxids: [
-            'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806'
-          ],
-          returnTXIDOnly: false,
-          noSend: true,
-          noSendChange: [
-            'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0'
-          ],
-          sendWith: [
-            'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806'
-          ],
-          randomizeOutputs: false
-        }
-      }
-      const result = await wallet.createAction(args)
-      expect(result).toHaveProperty('txid')
-      expect(result).toHaveProperty('tx')
-      expect(result).toHaveProperty('noSendChange')
-      expect(result).toHaveProperty('sendWithResults')
-      expect(result).toHaveProperty('signableTransaction')
-      expect(createActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid inputs', async () => {
-      // Mock the createAction method to throw an error
-      const createActionMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid inputs'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          createAction: createActionMock
-        })
-      )
-      const args = {
-        description: '' // Invalid description (too short)
-      }
-      await expect(wallet.createAction(args)).rejects.toThrow('Invalid inputs')
-      expect(createActionMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('signAction', () => {
-    it('should sign an action with valid inputs', async () => {
-      // Mock the signAction method
-      const signActionMock = jest.fn().mockResolvedValue({
-        txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806',
-        tx: [1, 2, 3, 4]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          signAction: signActionMock
-        })
-      )
-
-      const spends = {
-        0: {
-          unlockingScript: '00' // Sample unlocking script
-        }
-      }
-      const reference = Utils.toBase64([1, 2, 3])
-      const args = { spends, reference }
-      const result = await wallet.signAction(args)
-      expect(result).toHaveProperty('txid')
-      expect(result).toHaveProperty('tx')
-      expect(result.tx).toBeInstanceOf(Array)
-      expect(signActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid inputs', async () => {
-      // Mock the signAction method to throw an error
-      const signActionMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid inputs'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          signAction: signActionMock
-        })
-      )
-      const spends = {}
-      const reference = ''
-      const args = { spends, reference }
-      await expect(wallet.signAction(args)).rejects.toThrow('Invalid inputs')
-      expect(signActionMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('abortAction', () => {
-    it('should abort an action with valid reference', async () => {
-      // Mock the abortAction method
-      const abortActionMock = jest.fn().mockResolvedValue({ aborted: true })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          abortAction: abortActionMock
-        })
-      )
-
-      const reference = Utils.toBase64([1, 2, 3])
-      const args = { reference }
-      const result = await wallet.abortAction(args)
-      expect(result).toEqual({ aborted: true })
-      expect(abortActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid reference', async () => {
-      // Mock the abortAction method to throw an error
-      const abortActionMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid reference'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          abortAction: abortActionMock
-        })
-      )
-      const reference = ''
-      const args = { reference }
-      await expect(wallet.abortAction(args)).rejects.toThrow(
-        'Invalid reference'
-      )
-      expect(abortActionMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('listActions', () => {
-    it('should list actions with valid inputs', async () => {
-      // Mock the listActions method
-      const listActionsMock = jest.fn().mockResolvedValue({
-        totalActions: 1,
-        actions: [
-          {
-            txid: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806',
-            satoshis: 1000,
-            status: 'completed',
-            isOutgoing: true,
-            description: 'Test action',
-            labels: ['test-label'],
-            version: 1,
-            lockTime: 0
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listActions: listActionsMock
-        })
-      )
-
-      const args = {
-        labels: ['test-label'],
-        includeLabels: true,
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.listActions(args)
-      expect(result).toHaveProperty('totalActions')
-      expect(result).toHaveProperty('actions')
-      expect(Array.isArray(result.actions)).toBe(true)
-      expect(listActionsMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should list actions with empty labels array', async () => {
-      // Mock the listActions method
-      const listActionsMock = jest.fn().mockResolvedValue({
-        totalActions: 0,
-        actions: []
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listActions: listActionsMock
-        })
-      )
-
-      const args = {
-        labels: [],
-        includeLabels: true,
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.listActions(args)
-      expect(result).toHaveProperty('totalActions')
-      expect(result.totalActions).toBe(0)
-      expect(result.actions).toEqual([])
-      expect(listActionsMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid inputs', async () => {
-      // Mock the listActions method to throw an error
-      const listActionsMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid inputs'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listActions: listActionsMock
-        })
-      )
-      const args = {
-        labels: []
-      }
-      await expect(wallet.listActions(args)).rejects.toThrow('Invalid inputs')
-      expect(listActionsMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('internalizeAction', () => {
-    it('should internalize an action with valid inputs', async () => {
-      // Mock the internalizeAction method
-      const internalizeActionMock = jest
-        .fn()
-        .mockResolvedValue({ accepted: true })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          internalizeAction: internalizeActionMock
-        })
-      )
-
-      const args = {
-        tx: [0x00], // Sample transaction byte array
-        outputs: [
-          {
-            outputIndex: 0,
-            protocol: 'wallet payment' as 'wallet payment',
-            paymentRemittance: {
-              derivationPrefix: Utils.toBase64([1, 2, 3]),
-              derivationSuffix: Utils.toBase64([4, 5, 6]),
-              senderIdentityKey: '02' + '1'.repeat(64)
-            }
-          }
-        ],
-        description: 'Test internalize action',
-        labels: ['test-label']
-      }
-      const result = await wallet.internalizeAction(args)
-      expect(result).toEqual({ accepted: true })
-      expect(internalizeActionMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid inputs', async () => {
-      // Mock the internalizeAction method to throw an error
-      const internalizeActionMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid inputs'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          internalizeAction: internalizeActionMock
-        })
-      )
-      const args = {
-        tx: [], // Empty transaction array
-        outputs: [],
-        description: 'Test internalize action'
-      }
-      await expect(wallet.internalizeAction(args)).rejects.toThrow(
-        'Invalid inputs'
-      )
-      expect(internalizeActionMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should internalize an action with "basket insertion" protocol', async () => {
-      // Mock the internalizeAction method
-      const internalizeActionMock = jest
-        .fn()
-        .mockResolvedValue({ accepted: true })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          internalizeAction: internalizeActionMock
-        })
-      )
-
-      const args = {
-        tx: [0x00], // Sample transaction byte array
-        outputs: [
-          {
-            outputIndex: 0,
-            protocol: 'basket insertion' as 'basket insertion',
-            insertionRemittance: {
-              basket: 'test-basket',
-              customInstructions: 'Test instructions',
-              tags: ['test-tag1', 'test-tag2']
-            }
-          }
-        ],
-        description: 'Test internalize action with basket insertion',
-        labels: ['test-label']
-      }
-      const result = await wallet.internalizeAction(args)
-      expect(result).toEqual({ accepted: true })
-      expect(internalizeActionMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('listOutputs', () => {
-    it('should list outputs with valid inputs', async () => {
-      // Mock the listOutputs method
-      const listOutputsMock = jest.fn().mockResolvedValue({
-        totalOutputs: 1,
-        outputs: [
-          {
-            outpoint:
-              'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-            satoshis: 1000,
-            lockingScript: '00',
-            spendable: true,
-            customInstructions: 'Test instructions',
-            tags: ['test-tag'],
-            labels: ['test-label']
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listOutputs: listOutputsMock
-        })
-      )
-
-      const args = {
-        basket: 'test-basket',
-        includeLabels: true,
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.listOutputs(args)
-      expect(result).toHaveProperty('totalOutputs')
-      expect(result).toHaveProperty('outputs')
-      expect(Array.isArray(result.outputs)).toBe(true)
-      expect(listOutputsMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid inputs', async () => {
-      // Mock the listOutputs method to throw an error
-      const listOutputsMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid inputs'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listOutputs: listOutputsMock
-        })
-      )
-      const args = {
-        basket: ''
-      }
-      await expect(wallet.listOutputs(args)).rejects.toThrow('Invalid inputs')
-      expect(listOutputsMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should list outputs without specifying optional parameters', async () => {
-      // Mock the listOutputs method
-      const listOutputsMock = jest.fn().mockResolvedValue({
-        totalOutputs: 1,
-        BEEF: [1, 2, 3, 4],
-        outputs: [
-          {
-            outpoint:
-              'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-            satoshis: 1000,
-            spendable: true
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listOutputs: listOutputsMock
-        })
-      )
-
-      const args = {
-        basket: 'test-basket'
-        // Optional parameters are not specified
-      }
-      const result = await wallet.listOutputs(args)
-      expect(result).toHaveProperty('totalOutputs')
-      expect(result).toHaveProperty('outputs')
-      expect(result).toHaveProperty('BEEF')
-      expect(result.outputs[0]).toHaveProperty('outpoint')
-      expect(result.outputs[0]).toHaveProperty('satoshis')
-      expect(result.outputs[0]).toHaveProperty('spendable')
-      expect(result.outputs[0]).not.toHaveProperty('lockingScript')
-      expect(result.outputs[0]).not.toHaveProperty('customInstructions')
-      expect(result.outputs[0]).not.toHaveProperty('tags')
-      expect(result.outputs[0]).not.toHaveProperty('labels')
-      expect(listOutputsMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('getPublicKey', () => {
-    it('should get the identity public key', async () => {
-      const wallet = createTestWalletWire(
-        new CompletedProtoWallet(PrivateKey.fromRandom())
-      )
-      const result = await wallet.getPublicKey({ identityKey: true })
-      expect(result).toHaveProperty('publicKey')
-      expect(typeof result.publicKey).toBe('string')
-      expect(result.publicKey.length).toBe(66) // Compressed public key hex length
-    })
-
-    it('should get a derived public key with valid inputs', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const wallet = createTestWalletWire(new CompletedProtoWallet(userKey))
-      const args = {
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      }
-      const result = await wallet.getPublicKey(args)
-      expect(result).toHaveProperty('publicKey')
-      expect(typeof result.publicKey).toBe('string')
-      expect(result.publicKey.length).toBe(66)
-    })
-
-    it('should get the public key with counterparty "anyone"', async () => {
-      const wallet = createTestWalletWire(
-        new CompletedProtoWallet(PrivateKey.fromRandom())
-      )
-      const args = {
-        protocolID: [1, 'testprotocol'] as [0 | 1 | 2, string],
-        keyID: 'testkeyid',
-        counterparty: 'anyone' as 'anyone'
-      }
-      const result = await wallet.getPublicKey(args)
-      expect(result).toHaveProperty('publicKey')
-      expect(typeof result.publicKey).toBe('string')
-      expect(result.publicKey.length).toBe(66) // Compressed public key hex length
-    })
-
-    it('should get the public key with missing optional parameters', async () => {
-      const wallet = createTestWalletWire(
-        new CompletedProtoWallet(PrivateKey.fromRandom())
-      )
-      const args = {
-        protocolID: [0, 'minimalprotocol'] as [0 | 1 | 2, string],
-        keyID: 'minimalkeyid'
-        // Missing counterparty, should default to 'self' or 'anyone' based on context
-      }
-      const result = await wallet.getPublicKey(args)
-      expect(result).toHaveProperty('publicKey')
-      expect(typeof result.publicKey).toBe('string')
-      expect(result.publicKey.length).toBe(66)
-    })
-  })
-
-  describe('encrypt and decrypt', () => {
-    it('should encrypt and decrypt data correctly', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const userWallet = createTestWalletWire(new CompletedProtoWallet(userKey))
-      const counterpartyWallet = createTestWalletWire(
-        new CompletedProtoWallet(counterpartyKey)
-      )
-
-      const plaintext = sampleData
-      const encryptArgs = {
-        plaintext,
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      }
-      const encryptResult = await userWallet.encrypt(encryptArgs)
-      expect(encryptResult).toHaveProperty('ciphertext')
-      expect(encryptResult.ciphertext).not.toEqual(plaintext)
-
-      const decryptArgs = {
-        ciphertext: encryptResult.ciphertext,
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: userKey.toPublicKey().toString()
-      }
-      const decryptResult = await counterpartyWallet.decrypt(decryptArgs)
-      expect(decryptResult).toHaveProperty('plaintext')
-      expect(decryptResult.plaintext).toEqual(plaintext)
-    })
-
-    it('should throw an error for invalid decryption inputs', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const counterpartyWallet = createTestWalletWire(
-        new CompletedProtoWallet(counterpartyKey)
-      )
-
-      const decryptArgs = {
-        ciphertext: [0x00],
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: userKey.toPublicKey().toString()
-      }
-      await expect(counterpartyWallet.decrypt(decryptArgs)).rejects.toThrow()
-    })
-  })
-
-  describe('createHmac and verifyHmac', () => {
-    it('should create and verify HMAC correctly', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const userWallet = createTestWalletWire(new CompletedProtoWallet(userKey))
-      const counterpartyWallet = createTestWalletWire(
-        new CompletedProtoWallet(counterpartyKey)
-      )
-
-      const data = sampleData
-      const createHmacArgs = {
-        data,
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      }
-      const createHmacResult = await userWallet.createHmac(createHmacArgs)
-      expect(createHmacResult).toHaveProperty('hmac')
-      expect(createHmacResult.hmac.length).toBe(32)
-
-      const verifyHmacArgs = {
-        data,
-        hmac: createHmacResult.hmac,
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: userKey.toPublicKey().toString()
-      }
-      const verifyHmacResult =
-        await counterpartyWallet.verifyHmac(verifyHmacArgs)
-      expect(verifyHmacResult).toEqual({ valid: true })
-    })
-
-    it('should throw an error for invalid HMAC verification', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyWallet = createTestWalletWire(
-        new CompletedProtoWallet(PrivateKey.fromRandom())
-      )
-
-      const verifyHmacArgs = {
-        data: sampleData,
-        hmac: [0x00],
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: userKey.toPublicKey().toString()
-      }
-      await expect(
-        counterpartyWallet.verifyHmac(verifyHmacArgs)
-      ).rejects.toThrow()
-    })
-  })
-
-  describe('createSignature and verifySignature', () => {
-    it('should create and verify signature correctly', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const userWallet = createTestWalletWire(new CompletedProtoWallet(userKey))
-      const counterpartyWallet = createTestWalletWire(
-        new CompletedProtoWallet(counterpartyKey)
-      )
-
-      const data = sampleData
-      const createSignatureArgs = {
-        data,
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: counterpartyKey.toPublicKey().toString()
-      }
-      const createSignatureResult =
-        await userWallet.createSignature(createSignatureArgs)
-      expect(createSignatureResult).toHaveProperty('signature')
-      expect(createSignatureResult.signature.length).toBeGreaterThan(0)
-
-      const verifySignatureArgs = {
-        data,
-        signature: createSignatureResult.signature,
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: userKey.toPublicKey().toString()
-      }
-      const verifySignatureResult =
-        await counterpartyWallet.verifySignature(verifySignatureArgs)
-      expect(verifySignatureResult).toEqual({ valid: true })
-    })
-
-    it('should throw an error for invalid signature verification', async () => {
-      const userKey = PrivateKey.fromRandom()
-      const counterpartyWallet = createTestWalletWire(
-        new CompletedProtoWallet(PrivateKey.fromRandom())
-      )
-
-      const verifySignatureArgs = {
-        data: sampleData,
-        signature: [0x00],
-        protocolID: [2, 'tests'] as [0 | 1 | 2, string],
-        keyID: 'test-key-id',
-        counterparty: userKey.toPublicKey().toString()
-      }
-      await expect(
-        counterpartyWallet.verifySignature(verifySignatureArgs)
-      ).rejects.toThrow()
-    })
-  })
-
-  describe('revealCounterpartyKeyLinkage', () => {
-    it('should reveal counterparty key linkage correctly', async () => {
-      const proverKey = PrivateKey.fromRandom()
-      const counterpartyKey = PrivateKey.fromRandom()
-      const verifierKey = PrivateKey.fromRandom()
-
-      const proverWallet = createTestWalletWire(
-        new CompletedProtoWallet(proverKey)
-      )
-      const verifierWallet = createTestWalletWire(
-        new CompletedProtoWallet(verifierKey)
-      )
-
-      const args = {
-        counterparty: counterpartyKey.toPublicKey().toString(),
-        verifier: verifierKey.toPublicKey().toString()
-      }
-
-      const revelation = await proverWallet.revealCounterpartyKeyLinkage(args)
-      expect(revelation.encryptedLinkageProof).toBeDefined()
-
-      const decryptArgs = {
-        ciphertext: revelation.encryptedLinkage,
-        protocolID: [2, 'counterparty linkage revelation'] as [
-          0 | 1 | 2,
-          string
-        ],
-        keyID: revelation.revelationTime,
-        counterparty: proverKey.toPublicKey().toString()
-      }
-      const decryptedResult = await verifierWallet.decrypt(decryptArgs)
-
-      const expectedLinkage = proverKey
-        .deriveSharedSecret(counterpartyKey.toPublicKey())
-        .encode(true)
-      expect(decryptedResult.plaintext).toEqual(expectedLinkage)
-    })
-  })
-
-  describe('acquireCertificate', () => {
-    it('should acquire a certificate with valid inputs', async () => {
-      // Mock the acquireCertificate method
-      const acquireCertificateMock = jest.fn().mockResolvedValue({
-        type: Utils.toBase64(new Array(32).fill(1)),
-        subject: '02' + 'a'.repeat(64),
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        certifier: '02' + 'b'.repeat(64),
-        revocationOutpoint:
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        fields: {
-          field1: 'value1',
-          field2: 'value2'
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          acquireCertificate: acquireCertificateMock
-        })
-      )
-
-      const args = {
-        type: Utils.toBase64(new Array(32).fill(1)),
-        certifier: '02' + 'b'.repeat(64),
-        acquisitionProtocol: 'direct' as 'direct',
-        fields: {
-          field1: 'value1',
-          field2: 'value2'
-        },
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        revocationOutpoint:
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        keyringRevealer: 'certifier',
-        keyringForSubject: {}
-      }
-      const result = await wallet.acquireCertificate(args)
-      expect(result).toHaveProperty('type')
-      expect(result).toHaveProperty('subject')
-      expect(result).toHaveProperty('serialNumber')
-      expect(result).toHaveProperty('certifier')
-      expect(result).toHaveProperty('revocationOutpoint')
-      expect(result).toHaveProperty('signature')
-      expect(result).toHaveProperty('fields')
-      expect(acquireCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should acquire a certificate using acquisitionProtocol "direct" with keyringRevealer as "certifier"', async () => {
-      // Mock the acquireCertificate method
-      const acquireCertificateMock = jest.fn().mockResolvedValue({
-        type: Utils.toBase64(new Array(32).fill(1)),
-        subject: '02' + 'a'.repeat(64),
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        certifier: '02' + 'b'.repeat(64),
-        revocationOutpoint:
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        fields: {
-          field1: 'value1',
-          field2: 'value2'
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          acquireCertificate: acquireCertificateMock
-        })
-      )
-
-      const args = {
-        type: Utils.toBase64(new Array(32).fill(1)),
-        certifier: '02' + 'b'.repeat(64),
-        acquisitionProtocol: 'direct' as 'direct',
-        fields: {
-          field1: 'value1',
-          field2: 'value2'
-        },
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        revocationOutpoint:
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        keyringRevealer: 'certifier' as 'certifier',
-        keyringForSubject: {
-          field1: Utils.toBase64([0x01, 0x02, 0x03]),
-          field2: Utils.toBase64([0x04, 0x05, 0x06])
-        }
-      }
-      const result = await wallet.acquireCertificate(args)
-      expect(result).toHaveProperty('type')
-      expect(result).toHaveProperty('subject')
-      expect(result).toHaveProperty('serialNumber')
-      expect(result).toHaveProperty('certifier')
-      expect(result).toHaveProperty('revocationOutpoint')
-      expect(result).toHaveProperty('signature')
-      expect(result).toHaveProperty('fields')
-      expect(acquireCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should acquire a certificate using acquisitionProtocol "direct" with keyringRevealer as PubKeyHex', async () => {
-      // Mock the acquireCertificate method
-      const acquireCertificateMock = jest.fn().mockResolvedValue({
-        type: Utils.toBase64(new Array(32).fill(1)),
-        subject: '02' + 'a'.repeat(64),
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        certifier: '02' + 'b'.repeat(64),
-        revocationOutpoint:
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        fields: {
-          field1: 'value1',
-          field2: 'value2'
-        }
-      })
-      const keyringRevealerPubKey = '02' + 'c'.repeat(64)
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          acquireCertificate: acquireCertificateMock
-        })
-      )
-
-      const args = {
-        type: Utils.toBase64(new Array(32).fill(1)),
-        certifier: '02' + 'b'.repeat(64),
-        acquisitionProtocol: 'direct' as 'direct',
-        fields: {
-          field1: 'value1',
-          field2: 'value2'
-        },
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        revocationOutpoint:
-          'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        keyringRevealer: keyringRevealerPubKey,
-        keyringForSubject: {
-          field1: Utils.toBase64([0x01, 0x02, 0x03]),
-          field2: Utils.toBase64([0x04, 0x05, 0x06])
-        }
-      }
-      const result = await wallet.acquireCertificate(args)
-      expect(result).toHaveProperty('type')
-      expect(result).toHaveProperty('subject')
-      expect(result).toHaveProperty('serialNumber')
-      expect(result).toHaveProperty('certifier')
-      expect(result).toHaveProperty('revocationOutpoint')
-      expect(result).toHaveProperty('signature')
-      expect(result).toHaveProperty('fields')
-      expect(acquireCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should acquire a certificate using acquisitionProtocol "issuance"', async () => {
-      // Mock the acquireCertificate method
-      const acquireCertificateMock = jest.fn().mockResolvedValue({
-        type: Utils.toBase64(new Array(32).fill(1)),
-        subject: '02' + 'd'.repeat(64),
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        certifier: '02' + 'b'.repeat(64),
-        revocationOutpoint:
-          'cafebabedeadbeefcafebabedeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.1',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        fields: {
-          field3: 'value3',
-          field4: 'value4'
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          acquireCertificate: acquireCertificateMock
-        })
-      )
-
-      const args = {
-        type: Utils.toBase64(new Array(32).fill(1)),
-        certifier: '02' + 'b'.repeat(64),
-        acquisitionProtocol: 'issuance' as 'issuance',
-        fields: {
-          field3: 'value3',
-          field4: 'value4'
-        },
-        certifierUrl: 'https://certifier.example.com/api/issue'
-      }
-      const result = await wallet.acquireCertificate(args)
-      expect(result).toHaveProperty('type')
-      expect(result).toHaveProperty('subject')
-      expect(result).toHaveProperty('serialNumber')
-      expect(result).toHaveProperty('certifier')
-      expect(result).toHaveProperty('revocationOutpoint')
-      expect(result).toHaveProperty('signature')
-      expect(result).toHaveProperty('fields')
-      expect(acquireCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should handle optional keyringForSubject being empty in "direct" protocol', async () => {
-      // Mock the acquireCertificate method
-      const acquireCertificateMock = jest.fn().mockResolvedValue({
-        type: Utils.toBase64(new Array(32).fill(1)),
-        subject: '02' + 'e'.repeat(64),
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        certifier: '02' + 'b'.repeat(64),
-        revocationOutpoint:
-          'beadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbead.2',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        fields: {
-          field5: 'value5'
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          acquireCertificate: acquireCertificateMock
-        })
-      )
-
-      const args = {
-        type: Utils.toBase64(new Array(32).fill(1)),
-        certifier: '02' + 'b'.repeat(64),
-        acquisitionProtocol: 'direct' as 'direct',
-        fields: {
-          field5: 'value5'
-        },
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        revocationOutpoint:
-          'beadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbead.2',
-        signature:
-          '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-        keyringRevealer: 'certifier' as 'certifier',
-        keyringForSubject: {} // Empty keyring
-      }
-      const result = await wallet.acquireCertificate(args)
-      expect(result).toHaveProperty('type')
-      expect(result).toHaveProperty('subject')
-      expect(result).toHaveProperty('serialNumber')
-      expect(result).toHaveProperty('certifier')
-      expect(result).toHaveProperty('revocationOutpoint')
-      expect(result).toHaveProperty('signature')
-      expect(result).toHaveProperty('fields')
-      expect(result.fields).toEqual({ field5: 'value5' })
-      expect(acquireCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('listCertificates', () => {
-    it('should list certificates with valid inputs', async () => {
-      // Mock the listCertificates method
-      const listCertificatesMock = jest.fn().mockResolvedValue({
-        totalCertificates: 1,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {
-              field1: 'value1',
-              field2: 'value2'
-            }
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listCertificates: listCertificatesMock
-        })
-      )
-
-      const args = {
-        certifiers: ['02' + 'b'.repeat(64)],
-        types: [Utils.toBase64(new Array(32).fill(1))],
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.listCertificates(args)
-      expect(result).toHaveProperty('totalCertificates')
-      expect(result).toHaveProperty('certificates')
-      expect(Array.isArray(result.certificates)).toBe(true)
-      expect(listCertificatesMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should list certificates with multiple fields in each certificate', async () => {
-      // Mock the listCertificates method
-      const listCertificatesMock = jest.fn().mockResolvedValue({
-        totalCertificates: 2,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.0',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {
-              field1: 'value1',
-              field2: 'value2'
-            }
-          },
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'c'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe.1',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {
-              field3: 'value3',
-              field4: 'value4',
-              field5: 'value5'
-            }
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listCertificates: listCertificatesMock
-        })
-      )
-
-      const args = {
-        certifiers: ['02' + 'b'.repeat(64)],
-        types: [
-          Utils.toBase64(new Array(32).fill(1)),
-          Utils.toBase64(new Array(32).fill(2))
-        ],
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.listCertificates(args)
-      expect(result).toHaveProperty('totalCertificates', 2)
-      expect(result.certificates.length).toBe(2)
-      expect(result.certificates[0].fields).toEqual({
-        field1: 'value1',
-        field2: 'value2'
-      })
-      expect(result.certificates[1].fields).toEqual({
-        field3: 'value3',
-        field4: 'value4',
-        field5: 'value5'
-      })
-      expect(listCertificatesMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should list certificates when privileged is true', async () => {
-      // Mock the listCertificates method
-      const listCertificatesMock = jest.fn().mockResolvedValue({
-        totalCertificates: 1,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'd'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'e'.repeat(64),
-            revocationOutpoint:
-              'cafecafecafecafecafecafecafecafecafecafecafecafecafecafecafecafe.2',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {
-              field6: 'value6'
-            }
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          listCertificates: listCertificatesMock
-        })
-      )
-
-      const args = {
-        certifiers: ['02' + 'e'.repeat(64)],
-        types: [Utils.toBase64(new Array(32).fill(1))],
-        limit: 10,
-        offset: 0,
-        privileged: true,
-        privilegedReason: 'Testing privileged access'
-      }
-      const result = await wallet.listCertificates(args)
-      expect(result).toHaveProperty('totalCertificates', 1)
-      expect(result.certificates[0].fields).toEqual({ field6: 'value6' })
-      expect(listCertificatesMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('proveCertificate', () => {
-    it('should prove a certificate with valid inputs', async () => {
-      // Mock the proveCertificate method
-      const proveCertificateMock = jest.fn().mockResolvedValue({
-        keyringForVerifier: {
-          field1: Utils.toBase64([0x01, 0x02, 0x03]),
-          field2: Utils.toBase64([0x04, 0x05, 0x06])
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          proveCertificate: proveCertificateMock
-        })
-      )
-
-      const args = {
-        certificate: {
-          type: Utils.toBase64(new Array(32).fill(1)),
-          subject: '02' + 'a'.repeat(64),
-          serialNumber: Utils.toBase64(new Array(32).fill(2)),
-          certifier: '02' + 'b'.repeat(64),
-          revocationOutpoint:
-            'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-          signature:
-            '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-          fields: {
-            field1: 'value1',
-            field2: 'value2'
-          }
-        },
-        fieldsToReveal: ['field1'],
-        verifier: '02' + 'c'.repeat(64)
-      }
-      const result = await wallet.proveCertificate(args)
-      expect(result).toHaveProperty('keyringForVerifier')
-      expect(proveCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should prove a certificate revealing multiple fields', async () => {
-      // Mock the proveCertificate method
-      const proveCertificateMock = jest.fn().mockResolvedValue({
-        keyringForVerifier: {
-          field1: Utils.toBase64([0x01, 0x02, 0x03]),
-          field2: Utils.toBase64([0x04, 0x05, 0x06])
-        }
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          proveCertificate: proveCertificateMock
-        })
-      )
-
-      const args = {
-        certificate: {
-          type: Utils.toBase64(new Array(32).fill(1)),
-          subject: '02' + 'a'.repeat(64),
-          serialNumber: Utils.toBase64(new Array(32).fill(2)),
-          certifier: '02' + 'b'.repeat(64),
-          revocationOutpoint:
-            'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.0',
-          signature:
-            '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-          fields: {
-            field1: 'value1',
-            field2: 'value2',
-            field3: 'value3'
-          }
-        },
-        fieldsToReveal: ['field1', 'field2'],
-        verifier: '02' + 'f'.repeat(64)
-      }
-      const result = await wallet.proveCertificate(args)
-      expect(result).toHaveProperty('keyringForVerifier')
-      expect(Object.keys(result.keyringForVerifier)).toEqual([
-        'field1',
-        'field2'
-      ])
-      expect(proveCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should handle empty fieldsToReveal array (no fields revealed)', async () => {
-      // Mock the proveCertificate method
-      const proveCertificateMock = jest.fn().mockResolvedValue({
-        keyringForVerifier: {}
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          proveCertificate: proveCertificateMock
-        })
-      )
-
-      const args = {
-        certificate: {
-          type: Utils.toBase64(new Array(32).fill(1)),
-          subject: '02' + 'a'.repeat(64),
-          serialNumber: Utils.toBase64(new Array(32).fill(2)),
-          certifier: '02' + 'b'.repeat(64),
-          revocationOutpoint:
-            'cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe.1',
-          signature:
-            '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-          fields: {
-            field4: 'value4',
-            field5: 'value5'
-          }
-        },
-        fieldsToReveal: [],
-        verifier: '02' + 'f'.repeat(64)
-      }
-      const result = await wallet.proveCertificate(args)
-      expect(result).toHaveProperty('keyringForVerifier')
-      expect(Object.keys(result.keyringForVerifier).length).toBe(0)
-      expect(proveCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('relinquishCertificate', () => {
-    it('should relinquish a certificate with valid inputs', async () => {
-      // Mock the relinquishCertificate method
-      const relinquishCertificateMock = jest
-        .fn()
-        .mockResolvedValue({ relinquished: true })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          relinquishCertificate: relinquishCertificateMock
-        })
-      )
-
-      const args = {
-        type: Utils.toBase64(new Array(32).fill(1)),
-        serialNumber: Utils.toBase64(new Array(32).fill(2)),
-        certifier: '02' + 'b'.repeat(64)
-      }
-      const result = await wallet.relinquishCertificate(args)
-      expect(result).toEqual({ relinquished: true })
-      expect(relinquishCertificateMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('getHeight and getHeaderForHeight', () => {
-    it('should get the current blockchain height', async () => {
-      // Mock the getHeight method
-      const getHeightMock = jest.fn().mockResolvedValue({ height: 680000 })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          getHeight: getHeightMock
-        })
-      )
-
-      const result = await wallet.getHeight({})
-      expect(result).toHaveProperty('height')
-      expect(typeof result.height).toBe('number')
-      expect(result.height).toBeGreaterThan(0)
-      expect(getHeightMock).toHaveBeenCalledWith({}, '')
-    })
-
-    it('should throw an error when getHeight fails', async () => {
-      // Mock the getHeight method to throw an error
-      const getHeightMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Failed to get height'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          getHeight: getHeightMock
-        })
-      )
-      await expect(wallet.getHeight({})).rejects.toThrow('Failed to get height')
-      expect(getHeightMock).toHaveBeenCalledWith({}, '')
-    })
-
-    it('should get the header for a given height', async () => {
-      // Mock the getHeaderForHeight method
-      const getHeaderForHeightMock = jest.fn().mockResolvedValue({
-        header: '00' + 'ff'.repeat(79)
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          getHeaderForHeight: getHeaderForHeightMock
-        })
-      )
-
-      const args = { height: 680000 }
-      const result = await wallet.getHeaderForHeight(args)
-      expect(result).toHaveProperty('header')
-      expect(typeof result.header).toBe('string')
-      expect(result.header.length).toBe(80 * 2) // 80 bytes in hex
-      expect(getHeaderForHeightMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error when getHeaderForHeight fails', async () => {
-      // Mock the getHeaderForHeight method to throw an error
-      const getHeaderForHeightMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Failed to get header'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          getHeaderForHeight: getHeaderForHeightMock
-        })
-      )
-      const args = { height: -1 } // Invalid height
-      await expect(wallet.getHeaderForHeight(args)).rejects.toThrow(
-        'Failed to get header'
-      )
-      expect(getHeaderForHeightMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('discoverByIdentityKey', () => {
-    it('should discover certificates by identity key with valid inputs', async () => {
-      // Mock the discoverByIdentityKey method
-      const discoverByIdentityKeyMock = jest.fn().mockResolvedValue({
-        totalCertificates: 1,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {},
-            certifierInfo: {
-              name: 'Test Certifier',
-              iconUrl: 'https://example.com/icon.png',
-              description: 'Test description',
-              trust: 5
-            },
-            publiclyRevealedKeyring: {},
-            decryptedFields: {}
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByIdentityKey: discoverByIdentityKeyMock
-        })
-      )
-
-      const args = {
-        identityKey: '02' + 'a'.repeat(64),
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.discoverByIdentityKey(args)
-      expect(result).toHaveProperty('totalCertificates')
-      expect(result).toHaveProperty('certificates')
-      expect(Array.isArray(result.certificates)).toBe(true)
-      expect(discoverByIdentityKeyMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should discover certificates with empty decryptedFields and publiclyRevealedKeyring', async () => {
-      // Mock the discoverByIdentityKey method
-      const discoverByIdentityKeyMock = jest.fn().mockResolvedValue({
-        totalCertificates: 1,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.0',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {},
-            certifierInfo: {
-              name: 'Test Certifier',
-              iconUrl: 'https://example.com/icon.png',
-              description: 'Test description',
-              trust: 5
-            },
-            publiclyRevealedKeyring: {},
-            decryptedFields: {}
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByIdentityKey: discoverByIdentityKeyMock
-        })
-      )
-
-      const args = {
-        identityKey: '02' + 'a'.repeat(64),
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.discoverByIdentityKey(args)
-      expect(result).toHaveProperty('totalCertificates')
-      expect(result.certificates.length).toBe(1)
-      expect(result.certificates[0].publiclyRevealedKeyring).toEqual({})
-      expect(result.certificates[0].decryptedFields).toEqual({})
-      expect(discoverByIdentityKeyMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should discover multiple certificates with varying fields', async () => {
-      // Mock the discoverByIdentityKey method
-      const discoverByIdentityKeyMock = jest.fn().mockResolvedValue({
-        totalCertificates: 2,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.0',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {},
-            certifierInfo: {
-              name: 'Certifier One',
-              iconUrl: 'https://example.com/icon1.png',
-              description: 'First certifier',
-              trust: 5
-            },
-            publiclyRevealedKeyring: {
-              field1: Utils.toBase64([0x01])
-            },
-            decryptedFields: {
-              fieldA: 'decryptedValueA'
-            }
-          },
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'c'.repeat(64),
-            revocationOutpoint:
-              'cafebabecafebabecafebabecafebabecafebabecafebabecafebabecafebabe.1',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {},
-            certifierInfo: {
-              name: 'Certifier Two',
-              iconUrl: 'https://example.com/icon2.png',
-              description: 'Second certifier',
-              trust: 7
-            },
-            publiclyRevealedKeyring: {},
-            decryptedFields: {
-              fieldB: 'decryptedValueB',
-              fieldC: 'decryptedValueC'
-            }
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByIdentityKey: discoverByIdentityKeyMock
-        })
-      )
-
-      const args = {
-        identityKey: '02' + 'a'.repeat(64),
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.discoverByIdentityKey(args)
-      expect(result).toHaveProperty('totalCertificates', 2)
-      expect(result.certificates.length).toBe(2)
-      expect(result.certificates[0].certifierInfo.name).toBe('Certifier One')
-      expect(result.certificates[1].certifierInfo.name).toBe('Certifier Two')
-      expect(discoverByIdentityKeyMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-
-  describe('discoverByAttributes', () => {
-    it('should discover certificates by attributes with valid inputs', async () => {
-      // Mock the discoverByAttributes method
-      const discoverByAttributesMock = jest.fn().mockResolvedValue({
-        totalCertificates: 1,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'a'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'b'.repeat(64),
-            revocationOutpoint:
-              'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {},
-            certifierInfo: {
-              name: 'Test Certifier',
-              iconUrl: 'https://example.com/icon.png',
-              description: 'Test description',
-              trust: 5
-            },
-            publiclyRevealedKeyring: {},
-            decryptedFields: {}
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByAttributes: discoverByAttributesMock
-        })
-      )
-
-      const args = {
-        attributes: {
-          field1: 'value1'
-        },
-        limit: 10,
-        offset: 0
-      }
-      const result = await wallet.discoverByAttributes(args)
-      expect(result).toHaveProperty('totalCertificates')
-      expect(result).toHaveProperty('certificates')
-      expect(Array.isArray(result.certificates)).toBe(true)
-      expect(discoverByAttributesMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should throw an error with invalid inputs', async () => {
-      // Mock the discoverByAttributes method to throw an error
-      const discoverByAttributesMock = jest
-        .fn()
-        .mockRejectedValue(new Error('Invalid inputs'))
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByAttributes: discoverByAttributesMock
-        })
-      )
-      const args = {
-        attributes: {}
-      }
-      await expect(wallet.discoverByAttributes(args)).rejects.toThrow(
-        'Invalid inputs'
-      )
-      expect(discoverByAttributesMock).toHaveBeenCalledWith(args, '')
-    })
-    it('should discover certificates matching provided attributes', async () => {
-      // Mock the discoverByAttributes method
-      const discoverByAttributesMock = jest.fn().mockResolvedValue({
-        totalCertificates: 1,
-        certificates: [
-          {
-            type: Utils.toBase64(new Array(32).fill(1)),
-            subject: '02' + 'd'.repeat(64),
-            serialNumber: Utils.toBase64(new Array(32).fill(2)),
-            certifier: '02' + 'e'.repeat(64),
-            revocationOutpoint:
-              'beadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbead.2',
-            signature:
-              '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-            fields: {},
-            certifierInfo: {
-              name: 'Certifier Three',
-              iconUrl: 'https://example.com/icon3.png',
-              description: 'Third certifier',
-              trust: 8
-            },
-            publiclyRevealedKeyring: {
-              fieldX: Utils.toBase64([0x0a, 0x0b])
-            },
-            decryptedFields: {
-              fieldY: 'decryptedValueY'
-            }
-          }
-        ]
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByAttributes: discoverByAttributesMock
-        })
-      )
-
-      const args = {
-        attributes: {
-          fieldY: 'decryptedValueY'
-        },
-        limit: 5,
-        offset: 0
-      }
-      const result = await wallet.discoverByAttributes(args)
-      expect(result).toHaveProperty('totalCertificates', 1)
-      expect(result.certificates.length).toBe(1)
-      expect(result.certificates[0].certifierInfo.name).toBe('Certifier Three')
-      expect(result.certificates[0].decryptedFields.fieldY).toBe(
-        'decryptedValueY'
-      )
-      expect(discoverByAttributesMock).toHaveBeenCalledWith(args, '')
-    })
-
-    it('should return empty certificates array when no matches found', async () => {
-      // Mock the discoverByAttributes method
-      const discoverByAttributesMock = jest.fn().mockResolvedValue({
-        totalCertificates: 0,
-        certificates: []
-      })
-      const wallet = createTestWalletWire(
-        mockUnsupportedMethods({
-          discoverByAttributes: discoverByAttributesMock
-        })
-      )
-
-      const args = {
-        attributes: {
-          nonExistentField: 'noValue'
-        },
-        limit: 5,
-        offset: 0
-      }
-      const result = await wallet.discoverByAttributes(args)
-      expect(result).toHaveProperty('totalCertificates', 0)
-      expect(result.certificates.length).toBe(0)
-      expect(discoverByAttributesMock).toHaveBeenCalledWith(args, '')
-    })
-  })
-})