@bsv/sdk 1.4.6 → 1.4.7

package/dist/esm/src/wallet/substrates/__tests/WalletWire.integration.test.js

@@ -1,1962 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const CompletedProtoWallet_1 = require("../../../auth/certificates/__tests/CompletedProtoWallet");
-const index_1 = require("../../../primitives/index");
-const WalletWireTransceiver_1 = __importDefault(require("../../../wallet/substrates/WalletWireTransceiver"));
-const WalletWireProcessor_1 = __importDefault(require("../../../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_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet('anyone')));
-            await expect(() => {
-                return wallet.createAction();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.abortAction();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.signAction();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.listOutputs();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.relinquishOutput();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.listActions();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.internalizeAction();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.acquireCertificate();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.proveCertificate();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.listCertificates();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.relinquishCertificate();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.getHeight();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.getHeaderForHeight();
-            }).rejects.toThrow();
-            // TODO: Remove these two from the throw list once they are implemented.
-            await expect(() => {
-                return wallet.discoverByIdentityKey();
-            }).rejects.toThrow();
-            await expect(() => {
-                return wallet.discoverByAttributes();
-            }).rejects.toThrow();
-        });
-        it('Validates the BRC-3 compliance vector', async () => {
-            const wallet = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet('anyone')));
-            const { valid } = await wallet.verifySignature({
-                data: index_1.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_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(new index_1.PrivateKey('6a2991c9de20e38b31d7ea147bf55f5039e4bbc073160f5e0d541d1f17e321b8', 'hex'))));
-            const { valid } = await wallet.verifyHmac({
-                data: index_1.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_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(new index_1.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(index_1.Utils.toUTF8(plaintext)).toEqual('BRC-2 Encryption Compliance Validated!');
-        });
-        it('Encrypts messages decryptable by the counterparty', async () => {
-            const userKey = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(counterpartyKey)));
-            const { signature } = await user.createSignature({
-                hashToDirectlySign: index_1.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: index_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(userKey)));
-            const counterparty = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const user = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const verifierKey = index_1.PrivateKey.fromRandom();
-            // Initialize wallets
-            const proverWallet = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(proverKey)));
-            const verifierWallet = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const verifierKey = index_1.PrivateKey.fromRandom();
-            // Initialize wallets
-            const proverWallet = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(proverKey)));
-            const verifierWallet = new WalletWireTransceiver_1.default(new WalletWireProcessor_1.default(new CompletedProtoWallet_1.CompletedProtoWallet(verifierKey)));
-            const protocolID = [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, keyID) {
-                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 = index_1.Utils.toArray(invoiceNumber, 'utf8');
-            // Compute expected linkage
-            const expectedLinkage = index_1.Hash.sha256hmac(sharedSecret, invoiceNumberBin);
-            // Compare linkage and expectedLinkage
-            expect(linkage).toEqual(expectedLinkage);
-        });
-    });
-    // Helper function to create a test wallet wire setup
-    const createTestWalletWire = (wallet) => {
-        const processor = new WalletWireProcessor_1.default(wallet);
-        const transceiver = new WalletWireTransceiver_1.default(processor);
-        return transceiver;
-    };
-    // Mock implementation for methods not supported by CompletedProtoWallet
-    const mockUnsupportedMethods = (methods) => {
-        return {
-            ...methods
-        };
-    };
-    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: index_1.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: index_1.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',
-                    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 = index_1.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 = index_1.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',
-                        paymentRemittance: {
-                            derivationPrefix: index_1.Utils.toBase64([1, 2, 3]),
-                            derivationSuffix: index_1.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',
-                        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_1.CompletedProtoWallet(index_1.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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const wallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(userKey));
-            const args = {
-                protocolID: [2, 'tests'],
-                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_1.CompletedProtoWallet(index_1.PrivateKey.fromRandom()));
-            const args = {
-                protocolID: [1, 'testprotocol'],
-                keyID: 'testkeyid',
-                counterparty: '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_1.CompletedProtoWallet(index_1.PrivateKey.fromRandom()));
-            const args = {
-                protocolID: [0, 'minimalprotocol'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const userWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(userKey));
-            const counterpartyWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(counterpartyKey));
-            const plaintext = sampleData;
-            const encryptArgs = {
-                plaintext,
-                protocolID: [2, 'tests'],
-                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'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const counterpartyWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(counterpartyKey));
-            const decryptArgs = {
-                ciphertext: [0x00],
-                protocolID: [2, 'tests'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const userWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(userKey));
-            const counterpartyWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(counterpartyKey));
-            const data = sampleData;
-            const createHmacArgs = {
-                data,
-                protocolID: [2, 'tests'],
-                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'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(index_1.PrivateKey.fromRandom()));
-            const verifyHmacArgs = {
-                data: sampleData,
-                hmac: [0x00],
-                protocolID: [2, 'tests'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const userWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(userKey));
-            const counterpartyWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(counterpartyKey));
-            const data = sampleData;
-            const createSignatureArgs = {
-                data,
-                protocolID: [2, 'tests'],
-                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'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(index_1.PrivateKey.fromRandom()));
-            const verifySignatureArgs = {
-                data: sampleData,
-                signature: [0x00],
-                protocolID: [2, 'tests'],
-                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 = index_1.PrivateKey.fromRandom();
-            const counterpartyKey = index_1.PrivateKey.fromRandom();
-            const verifierKey = index_1.PrivateKey.fromRandom();
-            const proverWallet = createTestWalletWire(new CompletedProtoWallet_1.CompletedProtoWallet(proverKey));
-            const verifierWallet = createTestWalletWire(new CompletedProtoWallet_1.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'],
-                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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                subject: '02' + 'a'.repeat(64),
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                certifier: '02' + 'b'.repeat(64),
-                acquisitionProtocol: 'direct',
-                fields: {
-                    field1: 'value1',
-                    field2: 'value2'
-                },
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                subject: '02' + 'a'.repeat(64),
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                certifier: '02' + 'b'.repeat(64),
-                acquisitionProtocol: 'direct',
-                fields: {
-                    field1: 'value1',
-                    field2: 'value2'
-                },
-                serialNumber: index_1.Utils.toBase64(new Array(32).fill(2)),
-                revocationOutpoint: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-                signature: '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-                keyringRevealer: 'certifier',
-                keyringForSubject: {
-                    field1: index_1.Utils.toBase64([0x01, 0x02, 0x03]),
-                    field2: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                subject: '02' + 'a'.repeat(64),
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                certifier: '02' + 'b'.repeat(64),
-                acquisitionProtocol: 'direct',
-                fields: {
-                    field1: 'value1',
-                    field2: 'value2'
-                },
-                serialNumber: index_1.Utils.toBase64(new Array(32).fill(2)),
-                revocationOutpoint: 'deadbeef20248806deadbeef20248806deadbeef20248806deadbeef20248806.0',
-                signature: '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-                keyringRevealer: keyringRevealerPubKey,
-                keyringForSubject: {
-                    field1: index_1.Utils.toBase64([0x01, 0x02, 0x03]),
-                    field2: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                subject: '02' + 'd'.repeat(64),
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                certifier: '02' + 'b'.repeat(64),
-                acquisitionProtocol: '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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                subject: '02' + 'e'.repeat(64),
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                certifier: '02' + 'b'.repeat(64),
-                acquisitionProtocol: 'direct',
-                fields: {
-                    field5: 'value5'
-                },
-                serialNumber: index_1.Utils.toBase64(new Array(32).fill(2)),
-                revocationOutpoint: 'beadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbeadbead.2',
-                signature: '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-                keyringRevealer: '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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.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: [index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.Utils.toBase64(new Array(32).fill(2)),
-                        certifier: '02' + 'b'.repeat(64),
-                        revocationOutpoint: 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.0',
-                        signature: '3045022100e4d03d959697ed191f9ef7ae7deacd3118b8693d18da0fd76e4ad92664ce05cf02200d753951e766cbf2d2b306e08921c06341d2de67ab75389bf84caf954ee40e88',
-                        fields: {
-                            field1: 'value1',
-                            field2: 'value2'
-                        }
-                    },
-                    {
-                        type: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'c'.repeat(64),
-                        serialNumber: index_1.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: [
-                    index_1.Utils.toBase64(new Array(32).fill(1)),
-                    index_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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'd'.repeat(64),
-                        serialNumber: index_1.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: [index_1.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: index_1.Utils.toBase64([0x01, 0x02, 0x03]),
-                    field2: index_1.Utils.toBase64([0x04, 0x05, 0x06])
-                }
-            });
-            const wallet = createTestWalletWire(mockUnsupportedMethods({
-                proveCertificate: proveCertificateMock
-            }));
-            const args = {
-                certificate: {
-                    type: index_1.Utils.toBase64(new Array(32).fill(1)),
-                    subject: '02' + 'a'.repeat(64),
-                    serialNumber: index_1.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: index_1.Utils.toBase64([0x01, 0x02, 0x03]),
-                    field2: index_1.Utils.toBase64([0x04, 0x05, 0x06])
-                }
-            });
-            const wallet = createTestWalletWire(mockUnsupportedMethods({
-                proveCertificate: proveCertificateMock
-            }));
-            const args = {
-                certificate: {
-                    type: index_1.Utils.toBase64(new Array(32).fill(1)),
-                    subject: '02' + 'a'.repeat(64),
-                    serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                    subject: '02' + 'a'.repeat(64),
-                    serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.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: index_1.Utils.toBase64([0x01])
-                        },
-                        decryptedFields: {
-                            fieldA: 'decryptedValueA'
-                        }
-                    },
-                    {
-                        type: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'a'.repeat(64),
-                        serialNumber: index_1.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: index_1.Utils.toBase64(new Array(32).fill(1)),
-                        subject: '02' + 'd'.repeat(64),
-                        serialNumber: index_1.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: index_1.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, '');
-        });
-    });
-});
-//# sourceMappingURL=WalletWire.integration.test.js.map