@hashgraph/hedera-wallet-connect 1.3.7-canary.6c7f07a.0 → 1.3.7-canary.76acea8.0

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

@@ -1,234 +0,0 @@
-/*
- *
- * 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(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

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

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

@@ -1,155 +0,0 @@
-/*
- *
- * 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

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

package/dist/test/utils.test.js

@@ -1,201 +0,0 @@
-/*
- *
- * 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);
-            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

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

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

@@ -1,43 +0,0 @@
-/*
- *
- * 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

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