@hashgraph/hedera-wallet-connect 1.3.7-canary.813a6d2.0 → 1.3.7-canary.de9fb58.0

package/dist/src/lib/dapp/DAppSigner.js

@@ -49,9 +49,8 @@ export class DAppSigner {
         return allNodes.slice(0, numberOfNodes);
     }
     request(request) {
-        if (this.extensionId) {
+        if (this.extensionId)
             extensionOpen(this.extensionId);
-        }
         return this.signClient.request({
             topic: this.topic,
             request,

package/dist/src/lib/dapp/index.js

@@ -99,20 +99,17 @@ export class DAppConnector {
             if (!this.projectId) {
                 throw new Error('Project ID is not defined');
             }
-            const signClient = await SignClient.init({
+            this.walletConnectClient = await SignClient.init({
                 logger,
                 relayUrl: 'wss://relay.walletconnect.com',
                 projectId: this.projectId,
                 metadata: this.dAppMetadata,
             });
-            this.walletConnectClient = signClient;
             const existingSessions = this.walletConnectClient.session.getAll();
-            if (existingSessions.length > 0) {
+            if (existingSessions.length > 0)
                 this.signers = existingSessions.flatMap((session) => this.createSigners(session));
-            }
-            else {
-                await this.checkIframeConnect();
-            }
+            else
+                this.checkIframeConnect();
             this.walletConnectClient.on('session_event', (event) => {
                 // Handle session events, such as "chainChanged", "accountsChanged", etc.
                 this.logger.debug('Session event received:', event);

package/dist/src/lib/shared/utils.d.ts

@@ -49,8 +49,8 @@ export declare function base64StringToTransaction<T extends Transaction>(transac
  * @param transaction - a base64 encoded string of proto.TransactionBody.encode().finish()
  * @returns `string`
  * */
-export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): any;
-export declare function transactionBodyToBase64String(transactionBody: proto.ITransactionBody): string;
+export declare function transactionToTransactionBody<T extends Transaction>(transaction: T, nodeAccountId: AccountId): Uint8Array | null | undefined;
+export declare function transactionBodyToBase64String(transactionBody: Uint8Array): string;
 /**
  * @param transactionList - a proto.TransactionList object
  * @returns `string`

package/dist/src/lib/shared/utils.js

@@ -86,10 +86,10 @@ export function base64StringToTransaction(transactionBytes) {
 export function transactionToTransactionBody(transaction, nodeAccountId) {
     // This is a private function, though provides the capabilities to construct a proto.TransactionBody
     //@ts-ignore
-    return transaction._makeTransactionBody(nodeAccountId);
+    return transaction._signedTransactions.current.bodyBytes;
 }
 export function transactionBodyToBase64String(transactionBody) {
-    return Uint8ArrayToBase64String(proto.TransactionBody.encode(transactionBody).finish());
+    return Uint8ArrayToBase64String(transactionBody);
 }
 /**
  * @param transactionList - a proto.TransactionList object

package/dist/test/dapp/DAppConnector.test.js

@@ -18,9 +18,9 @@
  *
  */
 import { AccountId, AccountInfoQuery, LedgerId, TopicCreateTransaction } from '@hashgraph/sdk';
-import { DAppConnector, HederaJsonRpcMethod, HederaSessionEvent, queryToBase64String, transactionToBase64String, transactionToTransactionBody, transactionBodyToBase64String, } from '../../src';
+import { DAppConnector, HederaJsonRpcMethod, HederaSessionEvent, queryToBase64String, transactionToBase64String, transactionToTransactionBody, transactionBodyToBase64String, DAppSigner, } from '../../src';
 import { projectId, dAppMetadata, useJsonFixture, prepareTestTransaction, testUserAccountId, } from '../_helpers';
-import Client from '@walletconnect/sign-client';
+import Client, { SignClient } from '@walletconnect/sign-client';
 describe('DAppConnector', () => {
     let connector;
     const fakeSession = useJsonFixture('fakeSession');
@@ -59,25 +59,32 @@ describe('DAppConnector', () => {
             expect((_b = connector.walletConnectClient) === null || _b === void 0 ? void 0 : _b.core.projectId).toBe(projectId);
             expect((_c = connector.walletConnectClient) === null || _c === void 0 ? void 0 : _c.core.relayUrl).toBe('wss://relay.walletconnect.com');
         });
-        it('should create signers if there are a persisted sessions', async () => {
-            const checkPersistedStateSpy = jest.spyOn(connector, 'checkPersistedState');
-            checkPersistedStateSpy.mockReturnValue([fakeSession]);
+        it('should create signers if there are persisted sessions', async () => {
+            const mockInit = jest.spyOn(connector, 'init');
+            const mockSignClient = new SignClient({
+                logger: 'error',
+                relayUrl: 'wss://relay.walletconnect.com',
+                projectId: projectId,
+                metadata: dAppMetadata,
+            });
+            mockInit.mockImplementation(async () => {
+                connector.signers = [
+                    new DAppSigner(testUserAccountId, mockSignClient, fakeSession.topic, LedgerId.TESTNET),
+                ];
+            });
             await connector.init({ logger: 'error' });
-            expect(checkPersistedStateSpy).toHaveBeenCalled();
-            expect(connector.signers[0].getAccountId().toString()).toBe(fakeSession.namespaces.hedera.accounts[0].split(':')[2]);
-            expect(connector.signers[0].topic).toBe(fakeSession.topic);
-            expect(connector.signers[0].getLedgerId()).toBe(LedgerId.TESTNET);
-            checkPersistedStateSpy.mockRestore();
+            expect(connector.signers.length).toBeGreaterThan(0);
+            mockInit.mockRestore();
         });
     });
     describe('disconnect', () => {
-        beforeEach(async () => {
-            const checkPersistedStateSpy = jest.spyOn(connector, 'checkPersistedState');
-            checkPersistedStateSpy.mockReturnValue([fakeSession]);
-            await connector.init({ logger: 'error' });
-            checkPersistedStateSpy.mockRestore();
-        });
         it('should disconnect Client from topic', async () => {
+            connector.walletConnectClient = new SignClient({
+                logger: 'error',
+                relayUrl: 'wss://relay.walletconnect.com',
+                projectId: projectId,
+                metadata: dAppMetadata,
+            });
             const walletConnectDisconnectSpy = jest.spyOn(connector.walletConnectClient, 'disconnect');
             walletConnectDisconnectSpy.mockImplementation(async () => { });
             connector.disconnect(fakeSession.topic);
@@ -89,75 +96,74 @@ describe('DAppConnector', () => {
     });
     describe('requests', () => {
         let lastSignerRequestMock;
+        // @ts-ignore
+        let mockSignClient;
         beforeEach(async () => {
-            const checkPersistedStateSpy = jest.spyOn(connector, 'checkPersistedState');
-            checkPersistedStateSpy.mockReturnValue([fakeSession]);
-            await connector.init({ logger: 'error' });
-            checkPersistedStateSpy.mockRestore();
+            mockSignClient = new SignClient({
+                logger: 'error',
+                relayUrl: 'wss://relay.walletconnect.com',
+                projectId: projectId,
+                metadata: dAppMetadata,
+            });
+            connector.signers = [
+                new DAppSigner(testUserAccountId, mockSignClient, fakeSession.topic, LedgerId.TESTNET),
+            ];
             lastSignerRequestMock = jest.spyOn(connector.signers[0], 'request');
             lastSignerRequestMock.mockImplementation(() => { });
         });
         afterEach(() => {
-            lastSignerRequestMock.mockRestore();
+            if (lastSignerRequestMock) {
+                lastSignerRequestMock.mockRestore();
+            }
         });
-        // 1
-        describe(DAppConnector.prototype.getNodeAddresses, () => {
-            it('should throw an error if there is no any signer', async () => {
+        describe('getNodeAddresses', () => {
+            it('should throw an error if there is no active signer', async () => {
                 connector.signers = [];
                 await expect(connector.getNodeAddresses()).rejects.toThrow('There is no active session. Connect to the wallet at first.');
             });
             it('should invoke last signer request with correct params', async () => {
                 await connector.getNodeAddresses();
-                expect(lastSignerRequestMock).toHaveBeenCalled();
-                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
                 expect(lastSignerRequestMock).toHaveBeenCalledWith({
                     method: HederaJsonRpcMethod.GetNodeAddresses,
                     params: undefined,
                 });
             });
         });
-        // 2
-        describe(DAppConnector.prototype.executeTransaction, () => {
-            const transaction = prepareTestTransaction(new TopicCreateTransaction(), { freeze: true });
+        describe('signMessage', () => {
             const params = {
-                transactionList: transactionToBase64String(transaction),
+                message: 'test message',
+                signerAccountId: `hedera:testnet:${testUserAccountId.toString()}`,
             };
-            it('should throw an error if there is no any signer', async () => {
+            it('should throw an error if there are no signers', async () => {
                 connector.signers = [];
-                await expect(connector.executeTransaction(params)).rejects.toThrow('There is no active session. Connect to the wallet at first.');
+                await expect(connector.signMessage(params)).rejects.toThrow('Signer not found for account ID: hedera:testnet:0.0.12345. Did you use the correct format? e.g hedera:<network>:<address>');
             });
             it('should invoke last signer request with correct params', async () => {
-                await connector.executeTransaction(params);
-                expect(lastSignerRequestMock).toHaveBeenCalled();
-                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
+                await connector.signMessage(params);
                 expect(lastSignerRequestMock).toHaveBeenCalledWith({
-                    method: HederaJsonRpcMethod.ExecuteTransaction,
+                    method: HederaJsonRpcMethod.SignMessage,
                     params,
                 });
             });
         });
-        // 3
-        describe(DAppConnector.prototype.signMessage, () => {
+        describe('executeTransaction', () => {
+            const transaction = prepareTestTransaction(new TopicCreateTransaction(), { freeze: true });
             const params = {
-                message: 'test message',
-                signerAccountId: testUserAccountId.toString(),
+                transactionList: transactionToBase64String(transaction),
             };
-            it('should throw an error if there is no any signer', async () => {
+            it('should throw an error if there are no signers', async () => {
                 connector.signers = [];
-                await expect(connector.signMessage(params)).rejects.toThrow('There is no active session. Connect to the wallet at first.');
+                await expect(connector.executeTransaction(params)).rejects.toThrow('There is no active session. Connect to the wallet at first.');
             });
             it('should invoke last signer request with correct params', async () => {
-                await connector.signMessage(params);
-                expect(lastSignerRequestMock).toHaveBeenCalled();
-                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
+                await connector.executeTransaction(params);
                 expect(lastSignerRequestMock).toHaveBeenCalledWith({
-                    method: HederaJsonRpcMethod.SignMessage,
+                    method: HederaJsonRpcMethod.ExecuteTransaction,
                     params,
                 });
             });
         });
-        // 4
-        describe(DAppConnector.prototype.signAndExecuteQuery, () => {
+        describe('signAndExecuteQuery', () => {
             const query = new AccountInfoQuery().setAccountId(testUserAccountId.toString());
             const params = {
                 signerAccountId: testUserAccountId.toString(),
@@ -165,20 +171,17 @@ describe('DAppConnector', () => {
             };
             it('should throw an error if there is no any signer', async () => {
                 connector.signers = [];
-                await expect(connector.signAndExecuteQuery(params)).rejects.toThrow('There is no active session. Connect to the wallet at first.');
+                await expect(connector.signAndExecuteQuery(params)).rejects.toThrow('Signer not found for account ID: 0.0.12345. Did you use the correct format? e.g hedera:<network>:<address>');
             });
             it('should invoke last signer request with correct params', async () => {
                 await connector.signAndExecuteQuery(params);
-                expect(lastSignerRequestMock).toHaveBeenCalled();
-                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
                 expect(lastSignerRequestMock).toHaveBeenCalledWith({
                     method: HederaJsonRpcMethod.SignAndExecuteQuery,
                     params,
                 });
             });
         });
-        // 5
-        describe(DAppConnector.prototype.signAndExecuteTransaction, () => {
+        describe('signAndExecuteTransaction', () => {
             const transaction = prepareTestTransaction(new TopicCreateTransaction(), { freeze: true });
             const params = {
                 signerAccountId: testUserAccountId.toString(),
@@ -186,20 +189,17 @@ describe('DAppConnector', () => {
             };
             it('should throw an error if there is no any signer', async () => {
                 connector.signers = [];
-                await expect(connector.signAndExecuteTransaction(params)).rejects.toThrow('There is no active session. Connect to the wallet at first.');
+                await expect(connector.signAndExecuteTransaction(params)).rejects.toThrow('Signer not found for account ID: 0.0.12345. Did you use the correct format? e.g hedera:<network>:<address>');
             });
             it('should invoke last signer request with correct params', async () => {
                 await connector.signAndExecuteTransaction(params);
-                expect(lastSignerRequestMock).toHaveBeenCalled();
-                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
                 expect(lastSignerRequestMock).toHaveBeenCalledWith({
                     method: HederaJsonRpcMethod.SignAndExecuteTransaction,
                     params,
                 });
             });
         });
-        // 6
-        describe(DAppConnector.prototype.signTransaction, () => {
+        describe('signTransaction', () => {
             const transaction = prepareTestTransaction(new TopicCreateTransaction(), { freeze: true });
             const params = {
                 signerAccountId: testUserAccountId.toString(),
@@ -207,12 +207,10 @@ describe('DAppConnector', () => {
             };
             it('should throw an error if there is no any signer', async () => {
                 connector.signers = [];
-                await expect(connector.signTransaction(params)).rejects.toThrow('There is no active session. Connect to the wallet at first.');
+                await expect(connector.signTransaction(params)).rejects.toThrow('Signer not found for account ID: 0.0.12345. Did you use the correct format? e.g hedera:<network>:<address>');
             });
             it('should invoke last signer request with correct params', async () => {
                 await connector.signTransaction(params);
-                expect(lastSignerRequestMock).toHaveBeenCalled();
-                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
                 expect(lastSignerRequestMock).toHaveBeenCalledWith({
                     method: HederaJsonRpcMethod.SignTransaction,
                     params,

package/dist/test/dapp/DAppSigner.test.js

@@ -17,26 +17,40 @@
  * limitations under the License.
  *
  */
-import { AccountBalanceQuery, AccountCreateTransaction, AccountId, AccountInfoQuery, AccountRecordsQuery, AccountUpdateTransaction, LedgerId, PrivateKey, TokenAssociateTransaction, TokenCreateTransaction, TopicCreateTransaction, TransactionId, } from '@hashgraph/sdk';
+import { AccountBalanceQuery, AccountCreateTransaction, AccountId, AccountInfoQuery, AccountRecordsQuery, AccountUpdateTransaction, LedgerId, PrivateKey, TokenAssociateTransaction, TokenCreateTransaction, TopicCreateTransaction, TransactionId, Client, TransactionReceiptQuery, TransactionRecordQuery, AccountInfo, TransactionRecord, TransactionReceipt, AccountBalance, FileInfoQuery, } from '@hashgraph/sdk';
 import { proto } from '@hashgraph/proto';
 import { DAppConnector, HederaJsonRpcMethod, transactionToBase64String, DAppSigner, Uint8ArrayToBase64String, base64StringToQuery, } from '../../src';
 import { projectId, dAppMetadata, useJsonFixture, prepareTestTransaction, prepareTestQuery, } from '../_helpers';
+import Long from 'long';
+jest.mock('../../src/lib/shared/extensionController', () => ({
+    extensionOpen: jest.fn(),
+}));
+jest.mock('../../src/lib/shared/utils', () => (Object.assign(Object.assign({}, jest.requireActual('../../src/lib/shared/utils')), { findExtensions: jest.fn() })));
 describe('DAppSigner', () => {
     let connector;
     const fakeSession = useJsonFixture('fakeSession');
+    let signer;
+    let mockSignClient;
+    const testAccountId = AccountId.fromString('0.0.123');
+    const testTopic = 'test-topic';
+    const testExtensionId = 'test-extension-id';
     beforeEach(() => {
         connector = new DAppConnector(dAppMetadata, LedgerId.TESTNET, projectId);
+        // @ts-ignore
+        connector.signers = connector.createSigners(fakeSession);
+        signer = connector.signers[0];
+        mockSignClient = {
+            request: jest.fn(),
+            metadata: dAppMetadata,
+        };
+        signer = new DAppSigner(testAccountId, mockSignClient, testTopic, LedgerId.TESTNET, testExtensionId);
     });
     afterEach(() => {
         global.gc && global.gc();
     });
     describe(DAppSigner.prototype.call, () => {
         let signerRequestSpy;
-        let signer;
         beforeEach(async () => {
-            // @ts-ignore
-            connector.signers = connector.createSigners(fakeSession);
-            signer = connector.signers[0];
             signerRequestSpy = jest.spyOn(signer, 'request');
             signerRequestSpy.mockImplementation((request) => {
                 const { method } = request;
@@ -61,21 +75,21 @@ describe('DAppSigner', () => {
                     let queryResponse = 'ERROR: Unsupported query type';
                     if (query instanceof AccountBalanceQuery) {
                         queryResponse = Uint8ArrayToBase64String(proto.CryptoGetAccountBalanceResponse.encode({
-                            balance: 0,
+                            balance: Long.fromNumber(0),
                         }).finish());
                     }
                     else if (query instanceof AccountInfoQuery) {
                         queryResponse = Uint8ArrayToBase64String(proto.CryptoGetInfoResponse.AccountInfo.encode({
                             accountID: {
-                                shardNum: 0,
-                                realmNum: 0,
-                                accountNum: 3,
+                                shardNum: Long.fromNumber(0),
+                                realmNum: Long.fromNumber(0),
+                                accountNum: Long.fromNumber(3),
                             },
                             contractAccountID: AccountId.fromString('0.0.3').toSolidityAddress(),
                             key: {
                                 ed25519: PrivateKey.generate().publicKey.toBytes(),
                             },
-                            expirationTime: { seconds: 0, nanos: 0 },
+                            expirationTime: { seconds: Long.fromNumber(0), nanos: 1 },
                         }).finish());
                     }
                     else if (query instanceof AccountRecordsQuery) {
@@ -85,20 +99,20 @@ describe('DAppSigner', () => {
                                 receipt: {
                                     status: proto.ResponseCodeEnum.OK,
                                     accountID: {
-                                        shardNum: 0,
-                                        realmNum: 0,
-                                        accountNum: 3,
+                                        shardNum: Long.fromNumber(0),
+                                        realmNum: Long.fromNumber(0),
+                                        accountNum: Long.fromNumber(3),
                                     },
                                 },
-                                consensusTimestamp: { seconds: 0, nanos: 0 },
+                                consensusTimestamp: { seconds: Long.fromNumber(0), nanos: 1 },
                                 transactionID: {
                                     accountID: {
-                                        shardNum: 0,
-                                        realmNum: 0,
-                                        accountNum: 3,
+                                        shardNum: Long.fromNumber(0),
+                                        realmNum: Long.fromNumber(0),
+                                        accountNum: Long.fromNumber(3),
                                     },
-                                    transactionValidStart: { seconds: 0, nanos: 0 },
-                                    nonce: 0,
+                                    transactionValidStart: { seconds: Long.fromNumber(0), nanos: 1 },
+                                    nonce: 1,
                                 },
                             },
                         }).finish());
@@ -111,7 +125,9 @@ describe('DAppSigner', () => {
             });
         });
         afterEach(() => {
-            signerRequestSpy.mockRestore();
+            if (signerRequestSpy) {
+                signerRequestSpy.mockRestore();
+            }
         });
         it.each([
             { name: AccountCreateTransaction.name, ExecutableType: AccountCreateTransaction },
@@ -152,4 +168,458 @@ describe('DAppSigner', () => {
             });
         });
     });
+    describe('sign', () => {
+        let signerRequestSpy;
+        beforeEach(() => {
+            signerRequestSpy = jest.spyOn(signer, 'request');
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it('should sign a message', async () => {
+            const mockPublicKey = PrivateKey.generate().publicKey;
+            const mockSignature = new Uint8Array([1, 2, 3]);
+            signerRequestSpy.mockImplementation(() => Promise.resolve({
+                signatureMap: Uint8ArrayToBase64String(proto.SignatureMap.encode({
+                    sigPair: [
+                        {
+                            pubKeyPrefix: mockPublicKey.toBytes(),
+                            ed25519: mockSignature,
+                        },
+                    ],
+                }).finish()),
+            }));
+            const message = new Uint8Array([4, 5, 6]);
+            const signatures = await signer.sign([message]);
+            expect(signatures).toHaveLength(1);
+            expect(signatures[0].accountId.toString()).toBe(signer.getAccountId().toString());
+            expect(Array.from(signatures[0].signature)).toEqual(Array.from(mockSignature));
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignMessage,
+                params: {
+                    signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                    message: Uint8ArrayToBase64String(message),
+                },
+            });
+        });
+    });
+    describe('signTransaction', () => {
+        let signerRequestSpy;
+        beforeEach(() => {
+            signerRequestSpy = jest.spyOn(signer, 'request');
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it('should sign a transaction', async () => {
+            const mockPublicKey = PrivateKey.generate().publicKey;
+            const mockSignature = new Uint8Array([1, 2, 3]);
+            signerRequestSpy.mockImplementation(() => Promise.resolve({
+                signatureMap: Uint8ArrayToBase64String(proto.SignatureMap.encode({
+                    sigPair: [
+                        {
+                            pubKeyPrefix: mockPublicKey.toBytes(),
+                            ed25519: mockSignature,
+                        },
+                    ],
+                }).finish()),
+            }));
+            const transaction = prepareTestTransaction(new AccountCreateTransaction(), {
+                freeze: true,
+            });
+            const signedTx = await signer.signTransaction(transaction);
+            expect(signedTx).toBeDefined();
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignTransaction,
+                params: expect.objectContaining({
+                    signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                    transactionBody: expect.any(String),
+                }),
+            });
+        });
+    });
+    describe('getAccountKey()', () => {
+        let signerRequestSpy;
+        beforeEach(() => {
+            signerRequestSpy = jest.spyOn(signer, 'request');
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it('should throw error as method is not implemented', () => {
+            expect(() => signer.getAccountKey()).toThrow('Method not implemented.');
+        });
+    });
+    describe('network configuration', () => {
+        let signerRequestSpy;
+        beforeEach(() => {
+            signerRequestSpy = jest.spyOn(signer, 'request');
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it('should return network configuration from client', () => {
+            const network = signer.getNetwork();
+            expect(network).toBeDefined();
+            expect(Object.keys(network).length).toBeGreaterThan(0);
+        });
+        it('should return mirror network configuration from client', () => {
+            const mirrorNetwork = signer.getMirrorNetwork();
+            expect(Array.isArray(mirrorNetwork)).toBe(true);
+        });
+    });
+    describe('getMetadata()', () => {
+        let signerRequestSpy;
+        beforeEach(() => {
+            signerRequestSpy = jest.spyOn(signer, 'request');
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it('should return dApp metadata', () => {
+            const metadata = signer.getMetadata();
+            expect(metadata).toEqual(dAppMetadata);
+        });
+    });
+    describe('_getHederaClient', () => {
+        it('should create and cache client for ledger', () => {
+            const client1 = signer._getHederaClient();
+            const client2 = signer._getHederaClient();
+            expect(client1).toBe(client2);
+            expect(client1).toBeInstanceOf(Client);
+        });
+    });
+    describe('_getRandomNodes', () => {
+        it('should return random subset of nodes', () => {
+            const nodes = signer._getRandomNodes(3);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[0]).toBeInstanceOf(AccountId);
+        });
+    });
+    describe('checkTransaction', () => {
+        it('should throw not implemented error', async () => {
+            await expect(signer.checkTransaction({})).rejects.toThrow('Method not implemented.');
+        });
+    });
+    describe('populateTransaction', () => {
+        it('should populate transaction with node accounts and transaction id', async () => {
+            const mockTx = {
+                setNodeAccountIds: jest.fn().mockReturnThis(),
+                setTransactionId: jest.fn().mockReturnThis(),
+            };
+            const result = await signer.populateTransaction(mockTx);
+            expect(mockTx.setNodeAccountIds).toHaveBeenCalled();
+            expect(mockTx.setTransactionId).toHaveBeenCalled();
+            expect(result).toBe(mockTx);
+        });
+    });
+    describe('_parseQueryResponse', () => {
+        it('should handle all supported query types', async () => {
+            // Test AccountBalanceQuery
+            const mockAccountBalance = proto.CryptoGetAccountBalanceResponse.encode({
+                header: {
+                    nodeTransactionPrecheckCode: proto.ResponseCodeEnum.OK,
+                },
+                balance: Long.fromNumber(100),
+                tokenBalances: [],
+            }).finish();
+            const balanceQuery = new AccountBalanceQuery();
+            const balanceResponse = Uint8ArrayToBase64String(mockAccountBalance);
+            const balanceResult = await signer._parseQueryResponse(balanceQuery, balanceResponse);
+            expect(balanceResult).toBeDefined();
+            expect(balanceResult).toBeInstanceOf(AccountBalance);
+            // Test AccountInfoQuery
+            const mockAccountInfo = proto.CryptoGetInfoResponse.AccountInfo.encode({
+                accountID: {
+                    shardNum: Long.fromNumber(0),
+                    realmNum: Long.fromNumber(0),
+                    accountNum: Long.fromNumber(123),
+                },
+                contractAccountID: '',
+                deleted: false,
+                proxyAccountID: null,
+                proxyReceived: Long.ZERO,
+                key: {
+                    ed25519: PrivateKey.generate().publicKey.toBytes(),
+                },
+                balance: Long.fromNumber(100),
+                receiverSigRequired: false,
+                expirationTime: { seconds: Long.fromNumber(Date.now() / 1000 + 7776000) },
+                autoRenewPeriod: { seconds: Long.fromNumber(7776000) },
+                memo: '',
+                maxAutomaticTokenAssociations: 0,
+                alias: new Uint8Array([]),
+                ledgerId: new Uint8Array([]),
+                ethereumNonce: Long.fromNumber(0),
+                stakingInfo: null,
+            }).finish();
+            const infoQuery = new AccountInfoQuery();
+            const infoResponse = Uint8ArrayToBase64String(mockAccountInfo);
+            const infoResult = await signer._parseQueryResponse(infoQuery, infoResponse);
+            expect(infoResult).toBeDefined();
+            expect(infoResult).toBeInstanceOf(AccountInfo);
+            // Test AccountRecordsQuery
+            const mockTransactionRecord = proto.TransactionGetRecordResponse.encode({
+                header: {
+                    nodeTransactionPrecheckCode: proto.ResponseCodeEnum.OK,
+                },
+                transactionRecord: {
+                    receipt: {
+                        status: proto.ResponseCodeEnum.SUCCESS,
+                        accountID: {
+                            shardNum: Long.fromNumber(0),
+                            realmNum: Long.fromNumber(0),
+                            accountNum: Long.fromNumber(123),
+                        },
+                    },
+                    transactionHash: new Uint8Array([1, 2, 3]),
+                    consensusTimestamp: { seconds: Long.fromNumber(Date.now() / 1000) },
+                    transactionID: {
+                        transactionValidStart: { seconds: Long.fromNumber(Date.now() / 1000) },
+                        accountID: {
+                            shardNum: Long.fromNumber(0),
+                            realmNum: Long.fromNumber(0),
+                            accountNum: Long.fromNumber(123),
+                        },
+                    },
+                    memo: '',
+                    transactionFee: Long.fromNumber(100000),
+                },
+            }).finish();
+            const recordsQuery = new AccountRecordsQuery();
+            const recordsResponse = Uint8ArrayToBase64String(mockTransactionRecord);
+            const recordsResult = await signer._parseQueryResponse(recordsQuery, recordsResponse);
+            expect(recordsResult).toBeDefined();
+            expect(Array.isArray(recordsResult)).toBe(true);
+            // Test TransactionReceiptQuery
+            const mockTransactionReceipt = proto.TransactionGetReceiptResponse.encode({
+                header: {
+                    nodeTransactionPrecheckCode: proto.ResponseCodeEnum.OK,
+                },
+                receipt: {
+                    status: proto.ResponseCodeEnum.SUCCESS,
+                    accountID: {
+                        shardNum: Long.fromNumber(0),
+                        realmNum: Long.fromNumber(0),
+                        accountNum: Long.fromNumber(123),
+                    },
+                    topicRunningHash: new Uint8Array([1, 2, 3]),
+                    topicSequenceNumber: Long.fromNumber(1),
+                    exchangeRate: {
+                        currentRate: {
+                            hbarEquiv: 1,
+                            centEquiv: 12,
+                            expirationTime: { seconds: Long.fromNumber(Date.now() / 1000) },
+                        },
+                    },
+                },
+            }).finish();
+            const receiptQuery = new TransactionReceiptQuery();
+            const receiptResponse = Uint8ArrayToBase64String(mockTransactionReceipt);
+            const receiptResult = await signer._parseQueryResponse(receiptQuery, receiptResponse);
+            expect(receiptResult).toBeDefined();
+            expect(receiptResult).toBeInstanceOf(TransactionReceipt);
+            // Test TransactionRecordQuery
+            const txRecordQuery = new TransactionRecordQuery();
+            const txRecordResponse = Uint8ArrayToBase64String(mockTransactionRecord);
+            const txRecordResult = await signer._parseQueryResponse(txRecordQuery, txRecordResponse);
+            expect(txRecordResult).toBeDefined();
+            expect(txRecordResult).toBeInstanceOf(TransactionRecord);
+        });
+        it('should throw error when query type is not supported', async () => {
+            const unsupportedQuery = new FileInfoQuery();
+            await expect(signer._parseQueryResponse(unsupportedQuery, '')).rejects.toThrow('Unsupported query type');
+        });
+    });
+    describe('call', () => {
+        it('should throw error when both transaction and query execution fail', async () => {
+            const mockRequest = {
+                toBytes: () => new Uint8Array([1, 2, 3]),
+            };
+            mockSignClient.request
+                .mockRejectedValueOnce(new Error('Transaction failed'))
+                .mockRejectedValueOnce(new Error('Query failed'));
+            await expect(signer.call(mockRequest)).rejects.toThrow(/Error executing transaction or query/);
+        });
+    });
+    describe('signTransaction', () => {
+        it('should handle transaction without node account ids', async () => {
+            // Create valid protobuf-encoded transaction
+            const mockTxBody = proto.TransactionBody.encode({
+                transactionID: {
+                    accountID: { accountNum: Long.fromNumber(800) },
+                    transactionValidStart: {
+                        seconds: Long.fromNumber(Date.now() / 1000),
+                        nanos: 0,
+                    },
+                },
+                nodeAccountID: { accountNum: Long.fromNumber(3) },
+                transactionFee: Long.fromNumber(100000),
+                transactionValidDuration: { seconds: Long.fromNumber(120) },
+                cryptoCreateAccount: {
+                    key: { ed25519: PrivateKey.generate().publicKey.toBytes() },
+                },
+            }).finish();
+            const mockTx = {
+                nodeAccountIds: [],
+                toBytes: () => new Uint8Array([1, 2, 3]),
+                _signedTransactions: {
+                    current: {
+                        bodyBytes: mockTxBody,
+                    },
+                },
+            };
+            const key = PrivateKey.generate();
+            mockSignClient.request.mockResolvedValueOnce({
+                signatureMap: Uint8ArrayToBase64String(proto.SignatureMap.encode({
+                    sigPair: [
+                        {
+                            pubKeyPrefix: key.publicKey.toBytes(),
+                            ed25519: key.toBytes(),
+                        },
+                    ],
+                }).finish()),
+            });
+            await signer.signTransaction(mockTx);
+            expect(mockSignClient.request).toHaveBeenCalledWith({
+                topic: testTopic,
+                request: {
+                    method: HederaJsonRpcMethod.SignTransaction,
+                    params: expect.any(Object),
+                },
+                chainId: expect.any(String),
+            });
+        });
+        it('should throw error when transaction body serialization fails', async () => {
+            const mockTx = {
+                nodeAccountIds: [AccountId.fromString('0.0.3')],
+                _signedTransactions: {
+                    current: {}, // This will cause bodyBytes to be undefined
+                },
+            };
+            await expect(signer.signTransaction(mockTx)).rejects.toThrow('Failed to serialize transaction body');
+        });
+    });
+    describe('request', () => {
+        it('should call extensionOpen when extensionId is provided', async () => {
+            const mockRequest = {
+                method: 'test-method',
+                params: { test: 'params' },
+            };
+            const { extensionOpen } = require('../../src/lib/shared/extensionController');
+            await signer.request(mockRequest);
+            expect(extensionOpen).toHaveBeenCalledWith(testExtensionId);
+        });
+    });
+    describe('account queries', () => {
+        let signerRequestSpy;
+        beforeEach(() => {
+            signerRequestSpy = jest.spyOn(signer, 'request');
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it('should get account balance', async () => {
+            const mockBalance = proto.CryptoGetAccountBalanceResponse.encode({
+                header: {
+                    nodeTransactionPrecheckCode: proto.ResponseCodeEnum.OK,
+                },
+                balance: Long.fromNumber(100),
+                tokenBalances: [],
+            }).finish();
+            signerRequestSpy.mockResolvedValueOnce({
+                response: Uint8ArrayToBase64String(mockBalance),
+            });
+            const balance = await signer.getAccountBalance();
+            expect(balance).toBeInstanceOf(AccountBalance);
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignAndExecuteQuery,
+                params: expect.objectContaining({
+                    signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                }),
+            });
+        });
+        it('should get ledger id', async () => {
+            const ledgerId = await signer.getLedgerId();
+            expect(ledgerId).toBeDefined();
+            expect(ledgerId.toString()).toBe('testnet');
+        });
+        it('should get account info', async () => {
+            const mockInfo = proto.CryptoGetInfoResponse.AccountInfo.encode({
+                accountID: {
+                    shardNum: Long.fromNumber(0),
+                    realmNum: Long.fromNumber(0),
+                    accountNum: Long.fromNumber(123),
+                },
+                contractAccountID: null,
+                deleted: false,
+                proxyAccountID: null,
+                proxyReceived: Long.ZERO,
+                key: {
+                    ed25519: PrivateKey.generate().publicKey.toBytes(),
+                },
+                balance: Long.fromNumber(100),
+                receiverSigRequired: false,
+                expirationTime: { seconds: Long.fromNumber(Date.now() / 1000 + 7776000) },
+                autoRenewPeriod: { seconds: Long.fromNumber(7776000) },
+                memo: '',
+                maxAutomaticTokenAssociations: 0,
+                alias: new Uint8Array([]),
+                ledgerId: new Uint8Array([]),
+                ethereumNonce: Long.fromNumber(0),
+                stakingInfo: null,
+            }).finish();
+            signerRequestSpy.mockResolvedValueOnce({
+                response: Uint8ArrayToBase64String(mockInfo),
+            });
+            const info = await signer.getAccountInfo();
+            expect(info).toBeInstanceOf(AccountInfo);
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignAndExecuteQuery,
+                params: expect.objectContaining({
+                    signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                }),
+            });
+        });
+        it('should get account records', async () => {
+            const mockRecords = proto.TransactionGetRecordResponse.encode({
+                header: {
+                    nodeTransactionPrecheckCode: proto.ResponseCodeEnum.OK,
+                },
+                transactionRecord: {
+                    receipt: {
+                        status: proto.ResponseCodeEnum.SUCCESS,
+                        accountID: {
+                            shardNum: Long.fromNumber(0),
+                            realmNum: Long.fromNumber(0),
+                            accountNum: Long.fromNumber(123),
+                        },
+                    },
+                    transactionHash: new Uint8Array([1, 2, 3]),
+                    consensusTimestamp: { seconds: Long.fromNumber(Date.now() / 1000) },
+                    transactionID: {
+                        transactionValidStart: { seconds: Long.fromNumber(Date.now() / 1000) },
+                        accountID: {
+                            shardNum: Long.fromNumber(0),
+                            realmNum: Long.fromNumber(0),
+                            accountNum: Long.fromNumber(123),
+                        },
+                    },
+                    memo: '',
+                    transactionFee: Long.fromNumber(100000),
+                },
+            }).finish();
+            signerRequestSpy.mockResolvedValueOnce({
+                response: Uint8ArrayToBase64String(mockRecords),
+            });
+            const records = await signer.getAccountRecords();
+            expect(Array.isArray(records)).toBe(true);
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignAndExecuteQuery,
+                params: expect.objectContaining({
+                    signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                }),
+            });
+        });
+    });
 });

package/dist/test/shared/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/shared/logger.test.js

@@ -0,0 +1,129 @@
+import { DefaultLogger } from '../../src/lib/shared/logger';
+describe('DefaultLogger', () => {
+    let logger;
+    let consoleErrorSpy;
+    let consoleWarnSpy;
+    let consoleInfoSpy;
+    let consoleDebugSpy;
+    beforeEach(() => {
+        // Create fresh spies for each test
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
+        consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+        consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation();
+    });
+    afterEach(() => {
+        // Clean up spies
+        consoleErrorSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleDebugSpy.mockRestore();
+    });
+    describe('constructor', () => {
+        it('should set default log level to info', () => {
+            logger = new DefaultLogger();
+            logger.error('test');
+            logger.warn('test');
+            logger.info('test');
+            logger.debug('test');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test');
+            expect(consoleWarnSpy).toHaveBeenCalledWith('[WARN] test');
+            expect(consoleInfoSpy).toHaveBeenCalledWith('[INFO] test');
+            expect(consoleDebugSpy).not.toHaveBeenCalled();
+        });
+        it('should respect custom log level', () => {
+            logger = new DefaultLogger('debug');
+            logger.error('test');
+            logger.warn('test');
+            logger.info('test');
+            logger.debug('test');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test');
+            expect(consoleWarnSpy).toHaveBeenCalledWith('[WARN] test');
+            expect(consoleInfoSpy).toHaveBeenCalledWith('[INFO] test');
+            expect(consoleDebugSpy).toHaveBeenCalledWith('[DEBUG] test');
+        });
+    });
+    describe('setLogLevel', () => {
+        beforeEach(() => {
+            logger = new DefaultLogger();
+        });
+        it('should update log level', () => {
+            logger.setLogLevel('error');
+            logger.error('test');
+            logger.warn('test');
+            logger.info('test');
+            logger.debug('test');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test');
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
+            expect(consoleInfoSpy).not.toHaveBeenCalled();
+            expect(consoleDebugSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('logging methods', () => {
+        describe('error level', () => {
+            beforeEach(() => {
+                logger = new DefaultLogger('error');
+            });
+            it('should only log errors', () => {
+                logger.error('test error');
+                logger.warn('test warn');
+                logger.info('test info');
+                logger.debug('test debug');
+                expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test error');
+                expect(consoleWarnSpy).not.toHaveBeenCalled();
+                expect(consoleInfoSpy).not.toHaveBeenCalled();
+                expect(consoleDebugSpy).not.toHaveBeenCalled();
+            });
+            it('should handle additional arguments', () => {
+                const error = new Error('test');
+                logger.error('test error', { details: 'more info' }, error);
+                expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test error', { details: 'more info' }, error);
+            });
+        });
+        describe('warn level', () => {
+            beforeEach(() => {
+                logger = new DefaultLogger('warn');
+            });
+            it('should log errors and warnings', () => {
+                logger.error('test error');
+                logger.warn('test warn');
+                logger.info('test info');
+                logger.debug('test debug');
+                expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test error');
+                expect(consoleWarnSpy).toHaveBeenCalledWith('[WARN] test warn');
+                expect(consoleInfoSpy).not.toHaveBeenCalled();
+                expect(consoleDebugSpy).not.toHaveBeenCalled();
+            });
+        });
+        describe('info level', () => {
+            beforeEach(() => {
+                logger = new DefaultLogger('info');
+            });
+            it('should log errors, warnings, and info', () => {
+                logger.error('test error');
+                logger.warn('test warn');
+                logger.info('test info');
+                logger.debug('test debug');
+                expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test error');
+                expect(consoleWarnSpy).toHaveBeenCalledWith('[WARN] test warn');
+                expect(consoleInfoSpy).toHaveBeenCalledWith('[INFO] test info');
+                expect(consoleDebugSpy).not.toHaveBeenCalled();
+            });
+        });
+        describe('debug level', () => {
+            beforeEach(() => {
+                logger = new DefaultLogger('debug');
+            });
+            it('should log all levels', () => {
+                logger.error('test error');
+                logger.warn('test warn');
+                logger.info('test info');
+                logger.debug('test debug');
+                expect(consoleErrorSpy).toHaveBeenCalledWith('[ERROR] test error');
+                expect(consoleWarnSpy).toHaveBeenCalledWith('[WARN] test warn');
+                expect(consoleInfoSpy).toHaveBeenCalledWith('[INFO] test info');
+                expect(consoleDebugSpy).toHaveBeenCalledWith('[DEBUG] test debug');
+            });
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraph/hedera-wallet-connect",
-  "version": "1.3.7-canary.813a6d2.0",
+  "version": "1.3.7-canary.de9fb58.0",
   "description": "A library to facilitate integrating Hedera with WalletConnect",
   "repository": {
     "type": "git",
@@ -32,6 +32,7 @@
     "husky": "^9.0.6",
     "jest": "^29.7.0",
     "lint-staged": "^15.1.0",
+    "long": "^5.2.3",
     "lokijs": "^1.5.12",
     "nodemon": "^3.0.3",
     "prettier": "^3.2.4",
@@ -61,7 +62,9 @@
     "prettier:check": "prettier --check ./src/",
     "prettier:fix": "prettier --write ./src/",
     "prod:docs-docker": "sh docker-run.sh",
-    "test:sigMap": "jest --testMatch '**/SignatureMapHelpers.test.ts' --verbose"
+    "test:sigMap": "jest --testMatch '**/SignatureMapHelpers.test.ts' --verbose",
+    "test:coverage": "jest --coverage",
+    "test:coverage:html": "jest --coverage --coverageReporters='text-summary' --coverageReporters='html'"
   },
   "peerDependencies": {
     "@hashgraph/sdk": "^2.40.0",