@hashgraph/hedera-wallet-connect 1.3.2-0 → 1.3.2-1

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

@@ -0,0 +1,236 @@
+/*
+ *
+ * Hedera Wallet Connect
+ *
+ * Copyright (C) 2023 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { AccountId, AccountInfoQuery, LedgerId, TopicCreateTransaction } from '@hashgraph/sdk';
+import { DAppConnector, HederaJsonRpcMethod, HederaSessionEvent, queryToBase64String, transactionToBase64String, transactionToTransactionBody, transactionBodyToBase64String, } from '../../src';
+import { projectId, dAppMetadata, useJsonFixture, prepareTestTransaction, testUserAccountId, } from '../_helpers';
+import Client from '@walletconnect/sign-client';
+describe('DAppConnector', () => {
+    let connector;
+    const fakeSession = useJsonFixture('fakeSession');
+    beforeEach(() => {
+        connector = new DAppConnector(dAppMetadata, LedgerId.TESTNET, projectId);
+    });
+    afterEach(() => {
+        global.gc && global.gc();
+    });
+    describe('constructor', () => {
+        it('should create a valid class object', () => {
+            const methods = ['hedera_testMethod', 'any_testMethod'];
+            const events = [HederaSessionEvent.ChainChanged, HederaSessionEvent.AccountsChanged];
+            connector = new DAppConnector(dAppMetadata, LedgerId.TESTNET, projectId, methods, events);
+            expect(connector.dAppMetadata).toBe(dAppMetadata);
+            expect(connector.network).toBe(LedgerId.TESTNET);
+            expect(connector.projectId).toBe(projectId);
+            expect(connector.supportedMethods).toEqual(methods);
+            expect(connector.supportedEvents).toEqual(events);
+        });
+        it('should create a valid class object without passing of methods and events', () => {
+            connector = new DAppConnector(dAppMetadata, LedgerId.TESTNET, projectId);
+            expect(connector.dAppMetadata).toBe(dAppMetadata);
+            expect(connector.network).toBe(LedgerId.TESTNET);
+            expect(connector.projectId).toBe(projectId);
+            expect(connector.supportedMethods).toEqual(Object.values(HederaJsonRpcMethod));
+            expect(connector.supportedEvents).toEqual([]);
+        });
+    });
+    describe('init', () => {
+        it('should init SignClient correctly', async () => {
+            var _a, _b, _c;
+            await connector.init({ logger: 'error' });
+            expect(connector.walletConnectClient).toBeInstanceOf(Client);
+            expect((_a = connector.walletConnectClient) === null || _a === void 0 ? void 0 : _a.metadata).toBe(dAppMetadata);
+            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]);
+            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();
+        });
+    });
+    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 () => {
+            const walletConnectDisconnectSpy = jest.spyOn(connector.walletConnectClient, 'disconnect');
+            walletConnectDisconnectSpy.mockImplementation(async () => { });
+            connector.disconnect(fakeSession.topic);
+            expect(walletConnectDisconnectSpy).toHaveBeenCalled();
+            expect(walletConnectDisconnectSpy).toHaveBeenCalledTimes(1);
+            expect(walletConnectDisconnectSpy).toHaveBeenCalledWith(expect.objectContaining({ topic: fakeSession.topic }));
+            walletConnectDisconnectSpy.mockRestore();
+        });
+    });
+    describe('requests', () => {
+        let lastSignerRequestMock;
+        beforeEach(async () => {
+            const checkPersistedStateSpy = jest.spyOn(connector, 'checkPersistedState');
+            checkPersistedStateSpy.mockReturnValue([fakeSession]);
+            await connector.init({ logger: 'error' });
+            checkPersistedStateSpy.mockRestore();
+            lastSignerRequestMock = jest.spyOn(connector.signers[0], 'request');
+            lastSignerRequestMock.mockImplementation(() => { });
+        });
+        afterEach(() => {
+            lastSignerRequestMock.mockRestore();
+        });
+        // 1
+        describe(DAppConnector.prototype.getNodeAddresses, () => {
+            it('should throw an error if there is no any 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 });
+            const params = {
+                transactionList: transactionToBase64String(transaction),
+            };
+            it('should throw an error if there is no any signer', async () => {
+                connector.signers = [];
+                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.executeTransaction(params);
+                expect(lastSignerRequestMock).toHaveBeenCalled();
+                expect(lastSignerRequestMock).toHaveBeenCalledTimes(1);
+                expect(lastSignerRequestMock).toHaveBeenCalledWith({
+                    method: HederaJsonRpcMethod.ExecuteTransaction,
+                    params,
+                });
+            });
+        });
+        // 3
+        describe(DAppConnector.prototype.signMessage, () => {
+            const params = {
+                message: 'test message',
+                signerAccountId: testUserAccountId.toString(),
+            };
+            it('should throw an error if there is no any signer', async () => {
+                connector.signers = [];
+                await expect(connector.signMessage(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);
+                expect(lastSignerRequestMock).toHaveBeenCalledWith({
+                    method: HederaJsonRpcMethod.SignMessage,
+                    params,
+                });
+            });
+        });
+        // 4
+        describe(DAppConnector.prototype.signAndExecuteQuery, () => {
+            const query = new AccountInfoQuery().setAccountId(testUserAccountId.toString());
+            const params = {
+                signerAccountId: testUserAccountId.toString(),
+                query: queryToBase64String(query),
+            };
+            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.');
+            });
+            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, () => {
+            const transaction = prepareTestTransaction(new TopicCreateTransaction(), { freeze: true });
+            const params = {
+                signerAccountId: testUserAccountId.toString(),
+                transactionList: transactionToBase64String(transaction),
+            };
+            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.');
+            });
+            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, () => {
+            const transaction = prepareTestTransaction(new TopicCreateTransaction(), { freeze: true });
+            const params = {
+                signerAccountId: testUserAccountId.toString(),
+                transactionBody: transactionBodyToBase64String(
+                // must specify a node account id for the transaction body
+                transactionToTransactionBody(transaction, AccountId.fromString('0.0.3'))),
+            };
+            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.');
+            });
+            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,
+                });
+            });
+        });
+    });
+    // describe('connect', () => {
+    //   it('should establish connection and create session', async () => {
+    //     connector = new DAppConnector(appMetadata, LedgerId.TESTNET, PROJECT_ID)
+    //     await connector.init()
+    //     expect(connector.walletConnectClient).not.toBeNull()
+    //     await connector.connect((pairing) => {
+    //       console.log('PairingString: ', pairing)
+    //     })
+    //     expect(connector.walletConnectClient?.session.getAll()).toHaveLength(1)
+    //   }, 60_000)
+    // })
+});

package/dist/test/dapp/DAppSigner.test.d.ts

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

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

@@ -0,0 +1,155 @@
+/*
+ *
+ * Hedera Wallet Connect
+ *
+ * Copyright (C) 2023 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { AccountBalanceQuery, AccountCreateTransaction, AccountId, AccountInfoQuery, AccountRecordsQuery, AccountUpdateTransaction, LedgerId, PrivateKey, TokenAssociateTransaction, TokenCreateTransaction, TopicCreateTransaction, TransactionId, } 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';
+describe('DAppSigner', () => {
+    let connector;
+    const fakeSession = useJsonFixture('fakeSession');
+    beforeEach(() => {
+        connector = new DAppConnector(dAppMetadata, LedgerId.TESTNET, projectId);
+    });
+    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;
+                if (method === HederaJsonRpcMethod.SignAndExecuteTransaction) {
+                    const response = {
+                        transactionId: TransactionId.generate('0.0.999').toString(),
+                        nodeId: '0.0.3',
+                        transactionHash: '0x',
+                    };
+                    return Promise.resolve(response);
+                }
+                else if (method === HederaJsonRpcMethod.ExecuteTransaction) {
+                    const response = {
+                        transactionId: TransactionId.generate('0.0.999').toString(),
+                        nodeId: '0.0.3',
+                        transactionHash: '0x',
+                    };
+                    return Promise.resolve(response);
+                }
+                else if (method === HederaJsonRpcMethod.SignAndExecuteQuery) {
+                    const query = base64StringToQuery(request.params.query);
+                    let queryResponse = 'ERROR: Unsupported query type';
+                    if (query instanceof AccountBalanceQuery) {
+                        queryResponse = Uint8ArrayToBase64String(proto.CryptoGetAccountBalanceResponse.encode({
+                            balance: 0,
+                        }).finish());
+                    }
+                    else if (query instanceof AccountInfoQuery) {
+                        queryResponse = Uint8ArrayToBase64String(proto.CryptoGetInfoResponse.AccountInfo.encode({
+                            accountID: {
+                                shardNum: 0,
+                                realmNum: 0,
+                                accountNum: 3,
+                            },
+                            contractAccountID: AccountId.fromString('0.0.3').toSolidityAddress(),
+                            key: {
+                                ed25519: PrivateKey.generate().publicKey.toBytes(),
+                            },
+                            expirationTime: { seconds: 0, nanos: 0 },
+                        }).finish());
+                    }
+                    else if (query instanceof AccountRecordsQuery) {
+                        queryResponse = Uint8ArrayToBase64String(proto.TransactionGetRecordResponse.encode({
+                            transactionRecord: {
+                                alias: proto.Key.encode(PrivateKey.generate().publicKey._toProtobufKey()).finish(),
+                                receipt: {
+                                    status: proto.ResponseCodeEnum.OK,
+                                    accountID: {
+                                        shardNum: 0,
+                                        realmNum: 0,
+                                        accountNum: 3,
+                                    },
+                                },
+                                consensusTimestamp: { seconds: 0, nanos: 0 },
+                                transactionID: {
+                                    accountID: {
+                                        shardNum: 0,
+                                        realmNum: 0,
+                                        accountNum: 3,
+                                    },
+                                    transactionValidStart: { seconds: 0, nanos: 0 },
+                                    nonce: 0,
+                                },
+                            },
+                        }).finish());
+                    }
+                    const response = {
+                        response: queryResponse,
+                    };
+                    return Promise.resolve(response);
+                }
+            });
+        });
+        afterEach(() => {
+            signerRequestSpy.mockRestore();
+        });
+        it.each([
+            { name: AccountCreateTransaction.name, ExecutableType: AccountCreateTransaction },
+            { name: AccountUpdateTransaction.name, ExecutableType: AccountUpdateTransaction },
+            { name: TopicCreateTransaction.name, ExecutableType: TopicCreateTransaction },
+            { name: TokenAssociateTransaction.name, ExecutableType: TokenAssociateTransaction },
+            { name: TokenCreateTransaction.name, ExecutableType: TokenCreateTransaction },
+        ])('can execute $name transaction', async ({ name, ExecutableType }) => {
+            const transaction = prepareTestTransaction(new ExecutableType(), { freeze: true });
+            const params = {
+                signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                transactionList: transactionToBase64String(transaction),
+            };
+            await signer.call(transaction);
+            expect(signerRequestSpy).toHaveBeenCalled();
+            expect(signerRequestSpy).toHaveBeenCalledTimes(1);
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignAndExecuteTransaction,
+                params,
+            });
+        });
+        it.each([
+            { name: AccountBalanceQuery.name, ExecutableType: AccountBalanceQuery },
+            { name: AccountInfoQuery.name, ExecutableType: AccountInfoQuery },
+            { name: AccountRecordsQuery.name, ExecutableType: AccountRecordsQuery },
+        ])('can execute $name query', async ({ name, ExecutableType }) => {
+            const query = prepareTestQuery(new ExecutableType());
+            const params = {
+                signerAccountId: 'hedera:testnet:' + signer.getAccountId().toString(),
+                query: Uint8ArrayToBase64String(query.toBytes()),
+            };
+            await signer.call(query);
+            expect(signerRequestSpy).toHaveBeenCalled();
+            expect(signerRequestSpy).toHaveBeenCalledTimes(1);
+            expect(signerRequestSpy).toHaveBeenCalledWith({
+                method: HederaJsonRpcMethod.SignAndExecuteQuery,
+                params,
+            });
+        });
+    });
+});

package/dist/test/utils.test.d.ts

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

package/dist/test/utils.test.js

@@ -0,0 +1,202 @@
+/*
+ *
+ * Hedera Wallet Connect
+ *
+ * Copyright (C) 2023 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { AccountId, AccountInfoQuery, LedgerId, Query, TopicCreateTransaction, } from '@hashgraph/sdk';
+import { transactionToBase64String, freezeTransaction, setDefaultNodeAccountIds, base64StringToTransaction, base64StringToUint8Array, Uint8ArrayToBase64String, base64StringToQuery, queryToBase64String, EIPChainIdToLedgerId, ledgerIdToEIPChainId, CAIPChainIdToLedgerId, HederaChainId, ledgerIdToCAIPChainId, networkNameToCAIPChainId, networkNameToEIPChainId, networkNamespaces, HederaSessionEvent, } from '../src';
+import { prepareTestTransaction, testUserAccountId, useJsonFixture } from './_helpers';
+describe(freezeTransaction.name, () => {
+    it('should freeze an unfrozen transaction', () => {
+        const txn = prepareTestTransaction(new TopicCreateTransaction());
+        expect(txn.isFrozen()).toBe(false);
+        freezeTransaction(txn);
+        expect(txn.isFrozen()).toBe(true);
+    });
+    it('should have no effect on a frozen transaction', () => {
+        const txn = prepareTestTransaction(new TopicCreateTransaction());
+        txn.freeze();
+        expect(txn.isFrozen()).toBe(true);
+        freezeTransaction(txn);
+        expect(txn.isFrozen()).toBe(true);
+    });
+});
+describe(setDefaultNodeAccountIds.name, () => {
+    it('should set default node account ids if none are set', () => {
+        var _a;
+        const txn = new TopicCreateTransaction();
+        expect(txn.nodeAccountIds).toBeNull();
+        setDefaultNodeAccountIds(txn);
+        const result = (_a = txn.nodeAccountIds) === null || _a === void 0 ? void 0 : _a.map((id) => id.toString());
+        expect(result).toEqual(['0.0.3', '0.0.4', '0.0.5']);
+    });
+    it('should do nothing if node account ids are already set', () => {
+        var _a;
+        const txn = new TopicCreateTransaction();
+        txn.setNodeAccountIds([new AccountId(4)]);
+        setDefaultNodeAccountIds(txn);
+        const result = (_a = txn.nodeAccountIds) === null || _a === void 0 ? void 0 : _a.map((id) => id.toString());
+        expect(result).toEqual(['0.0.4']);
+    });
+});
+describe(transactionToBase64String.name, () => {
+    it('should convert a transaction to a base64 encoded string', () => {
+        const txn = prepareTestTransaction(new TopicCreateTransaction());
+        const result = transactionToBase64String(txn);
+        const { expected } = useJsonFixture('transactionToBase64StringResult');
+        expect(result).toBe(expected);
+    });
+});
+describe(base64StringToTransaction.name, () => {
+    it('should create a transaction from a base64 string', () => {
+        const txn = prepareTestTransaction(new TopicCreateTransaction());
+        txn.setTransactionMemo('I should be restored');
+        const str = transactionToBase64String(txn);
+        const resultWithParam = base64StringToTransaction(str);
+        const resultWithoutParam = base64StringToTransaction(str);
+        expect(resultWithParam).toBeInstanceOf(TopicCreateTransaction);
+        expect(resultWithoutParam).toBeInstanceOf(TopicCreateTransaction);
+        expect(resultWithParam.transactionMemo).toBe('I should be restored');
+    });
+});
+describe(`Uint8Array helpers`, () => {
+    let uInt8Array;
+    describe(base64StringToUint8Array.name, () => {
+        it('should decode base64 string to Uint8Array', async () => {
+            const base64String = btoa('Hello World!');
+            uInt8Array = base64StringToUint8Array(base64String);
+            console.log(Array.from(uInt8Array));
+            expect(uInt8Array).toBeInstanceOf(Uint8Array);
+            expect(Array.from(uInt8Array)).toEqual([
+                72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33,
+            ]);
+        });
+    });
+    describe(Uint8ArrayToBase64String.name, () => {
+        it('should encode Uint8Array to base64 string', async () => {
+            const base64String = Uint8ArrayToBase64String(uInt8Array);
+            expect(typeof base64String).toBe('string');
+            expect(base64String).toBe('SGVsbG8gV29ybGQh');
+            expect(atob(base64String)).toBe('Hello World!');
+        });
+    });
+});
+describe(`Query helpers`, () => {
+    let base64Query;
+    describe(queryToBase64String.name, () => {
+        it('should encode Query to base64 string', async () => {
+            const query = new AccountInfoQuery().setAccountId(testUserAccountId);
+            base64Query = queryToBase64String(query);
+            expect(typeof base64Query).toBe('string');
+            expect(base64Query).toEqual('Sg0KAhAAEgcIABAAGLlg');
+        });
+    });
+    describe(base64StringToQuery.name, () => {
+        it('should decode base64 string to Query', async () => {
+            var _a;
+            const query = base64StringToQuery(base64Query);
+            expect(query).toBeInstanceOf(Query);
+            expect(query).toBeInstanceOf(AccountInfoQuery);
+            expect((_a = query.accountId) === null || _a === void 0 ? void 0 : _a.toString()).toBe(testUserAccountId.toString());
+        });
+    });
+});
+describe(EIPChainIdToLedgerId.name, () => {
+    it('should convert a EIP chain id to a LedgerId object', async () => {
+        const mainnetLedgerId = EIPChainIdToLedgerId(295);
+        const testnetLedgerId = EIPChainIdToLedgerId(296);
+        const previewnetLedgerId = EIPChainIdToLedgerId(297);
+        const localnodeLedgerId = EIPChainIdToLedgerId(298);
+        const localnodeLedgerIdWithRandomId = EIPChainIdToLedgerId(999);
+        expect(mainnetLedgerId).toBe(LedgerId.MAINNET);
+        expect(testnetLedgerId).toBe(LedgerId.TESTNET);
+        expect(previewnetLedgerId).toBe(LedgerId.PREVIEWNET);
+        expect(localnodeLedgerId).toBe(LedgerId.LOCAL_NODE);
+        expect(localnodeLedgerIdWithRandomId).toBe(LedgerId.LOCAL_NODE);
+    });
+});
+describe(ledgerIdToEIPChainId.name, () => {
+    it('should convert a LedgerId object to a EIP chain id', async () => {
+        const mainnetChainId = ledgerIdToEIPChainId(LedgerId.MAINNET);
+        const testnetChainId = ledgerIdToEIPChainId(LedgerId.TESTNET);
+        const previewnetChainId = ledgerIdToEIPChainId(LedgerId.PREVIEWNET);
+        const localnodeChainId = ledgerIdToEIPChainId(LedgerId.LOCAL_NODE);
+        expect(mainnetChainId).toBe(295);
+        expect(testnetChainId).toBe(296);
+        expect(previewnetChainId).toBe(297);
+        expect(localnodeChainId).toBe(298);
+    });
+});
+describe(networkNameToEIPChainId.name, () => {
+    it('should convert a network name to a EIP chain id', async () => {
+        const mainnetChainId = networkNameToEIPChainId('mainnet');
+        const testnetChainId = networkNameToEIPChainId('testnet');
+        const previewnetChainId = networkNameToEIPChainId('previewnet');
+        const localnodeChainId = networkNameToEIPChainId('devnet');
+        expect(mainnetChainId).toBe(295);
+        expect(testnetChainId).toBe(296);
+        expect(previewnetChainId).toBe(297);
+        expect(localnodeChainId).toBe(298);
+    });
+});
+describe(CAIPChainIdToLedgerId.name, () => {
+    it('should convert a CAIP chain id to a LedgerId object', async () => {
+        const mainnetLedgerId = CAIPChainIdToLedgerId(HederaChainId.Mainnet);
+        const testnetLedgerId = CAIPChainIdToLedgerId(HederaChainId.Testnet);
+        const previewnetLedgerId = CAIPChainIdToLedgerId(HederaChainId.Previewnet);
+        const localnodeLedgerId = CAIPChainIdToLedgerId(HederaChainId.Devnet);
+        expect(mainnetLedgerId).toBe(LedgerId.MAINNET);
+        expect(testnetLedgerId).toBe(LedgerId.TESTNET);
+        expect(previewnetLedgerId).toBe(LedgerId.PREVIEWNET);
+        expect(localnodeLedgerId).toBe(LedgerId.LOCAL_NODE);
+    });
+});
+describe(ledgerIdToCAIPChainId.name, () => {
+    it('should convert a LedgerId object to a CAIP chain id', async () => {
+        const mainnetChainId = ledgerIdToCAIPChainId(LedgerId.MAINNET);
+        const testnetChainId = ledgerIdToCAIPChainId(LedgerId.TESTNET);
+        const previewnetChainId = ledgerIdToCAIPChainId(LedgerId.PREVIEWNET);
+        const localnodeChainId = ledgerIdToCAIPChainId(LedgerId.LOCAL_NODE);
+        expect(mainnetChainId).toBe(HederaChainId.Mainnet);
+        expect(testnetChainId).toBe(HederaChainId.Testnet);
+        expect(previewnetChainId).toBe(HederaChainId.Previewnet);
+        expect(localnodeChainId).toBe(HederaChainId.Devnet);
+    });
+});
+describe(networkNameToCAIPChainId.name, () => {
+    it('should convert a network name to a CAIP chain id', async () => {
+        const mainnetChainId = networkNameToCAIPChainId('mainnet');
+        const testnetChainId = networkNameToCAIPChainId('testnet');
+        const previewnetChainId = networkNameToCAIPChainId('previewnet');
+        const localnodeChainId = networkNameToCAIPChainId('devnet');
+        expect(mainnetChainId).toBe(HederaChainId.Mainnet);
+        expect(testnetChainId).toBe(HederaChainId.Testnet);
+        expect(previewnetChainId).toBe(HederaChainId.Previewnet);
+        expect(localnodeChainId).toBe(HederaChainId.Devnet);
+    });
+});
+describe(networkNamespaces.name, () => {
+    it('should create a `ProposalTypes.RequiredNamespaces` object for a given ledgerId', async () => {
+        const methods = ['hedera_signMessage'];
+        const events = Object.values(HederaSessionEvent);
+        const testnetNamespaces = networkNamespaces(LedgerId.TESTNET, methods, events);
+        expect(testnetNamespaces.hedera).not.toBe(undefined);
+        expect(testnetNamespaces.hedera.methods).toBe(methods);
+        expect(testnetNamespaces.hedera.events).toBe(events);
+        expect(testnetNamespaces.hedera.chains).toEqual([HederaChainId.Testnet]);
+    });
+});

package/dist/test/wallet/methods/wallet-executeTransaction.test.d.ts

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

package/dist/test/wallet/methods/wallet-executeTransaction.test.js

@@ -0,0 +1,43 @@
+/*
+ *
+ * Hedera Wallet Connect
+ *
+ * Copyright (C) 2023 Hedera Hashgraph, LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { TopicCreateTransaction } from '@hashgraph/sdk';
+import { HederaChainId, Wallet } from '../../../src';
+import { prepareTestTransaction, projectId, requestId, requestTopic, testPrivateKeyECDSA, testUserAccountId, useJsonFixture, walletMetadata, } from '../../_helpers';
+describe(Wallet.name, () => {
+    describe('executeTransaction', () => {
+        it('should execute signed transaction, returning the transaction response', async () => {
+            try {
+                const wallet = await Wallet.create(projectId, walletMetadata);
+                const hederaWallet = wallet.getHederaWallet(HederaChainId.Testnet, testUserAccountId.toString(), testPrivateKeyECDSA);
+                const signerCallMock = jest.spyOn(hederaWallet, 'call');
+                signerCallMock.mockImplementation(async () => { }); // Mocking the 'call' method to do nothing
+                const transaction = prepareTestTransaction(new TopicCreateTransaction(), {
+                    freeze: true,
+                });
+                const signTransaction = await hederaWallet.signTransaction(transaction);
+                const respondSessionRequestSpy = jest.spyOn(wallet, 'respondSessionRequest');
+                await wallet.hedera_executeTransaction(requestId, requestTopic, signTransaction, hederaWallet);
+                const mockResponse = useJsonFixture('methods/executeTransactionSuccess');
+                expect(respondSessionRequestSpy).toHaveBeenCalledWith(mockResponse);
+            }
+            catch (err) { }
+        }, 15000);
+    });
+});

package/dist/test/wallet/methods/wallet-getNodeAddresses.test.d.ts

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