diff --git a/packages/sdk/src/core/__mocks__/mock-connection-manager.ts b/packages/sdk/src/core/__mocks__/mock-connection-manager.ts
new file mode 100644
index 0000000..959c3c2
--- /dev/null
+++ b/packages/sdk/src/core/__mocks__/mock-connection-manager.ts
@@ -0,0 +1,21 @@
+import { ConnectionState } from '../connection';
+import { WalletProvider } from '../providers';
+import { WalletConnectionEvent } from '../types';
+
+export const defineMockConnectionManager = () => {
+  jest.mock('../connection', () => ({
+    ConnectionManager: jest.fn(() => mockConnectionManager),
+  }));
+};
+
+export const mockConnectionManager = {
+  connectWallet: jest.fn<Promise<void>, []>(),
+  disconnectWallet: jest.fn<void, []>(),
+  getConnectionState: jest.fn<ConnectionState, []>(),
+  getWalletProvider: jest.fn<WalletProvider, []>(),
+  on: jest.fn<void, [(event: WalletConnectionEvent) => void]>(),
+  off: jest.fn<void, [(event: WalletConnectionEvent) => void]>(),
+  connectAdenaWallet: jest.fn<Promise<void>, []>(),
+  connectTM2Wallet: jest.fn<Promise<void>, []>(),
+  triggerConnectionEvent: jest.fn<void, [WalletConnectionEvent]>(),
+};
diff --git a/packages/sdk/src/core/__mocks__/mock-global.ts b/packages/sdk/src/core/__mocks__/mock-global.ts
index b491eaf..a97adde 100644
--- a/packages/sdk/src/core/__mocks__/mock-global.ts
+++ b/packages/sdk/src/core/__mocks__/mock-global.ts
@@ -4,8 +4,20 @@ export const defineGlobalMock = () => {
   Object.defineProperty(global, 'sessionStorage', {
     value: mockSessionStorage,
   });
+  Object.defineProperty(global, 'open', {
+    value: jest.fn(),
+    configurable: true,
+  });
+  Object.defineProperty(global, 'console', {
+    value: {
+      ...console,
+      error() {},
+    },
+  });
 };
 
 export const clearGlobalMock = () => {
   Object.defineProperty(global, 'sessionStorage', {});
+  Object.defineProperty(global, 'open', {});
+  Object.defineProperty(global, 'console', {});
 };
diff --git a/packages/sdk/src/core/__mocks__/mock-wallet-provider.ts b/packages/sdk/src/core/__mocks__/mock-wallet-provider.ts
index e2653de..d832838 100644
--- a/packages/sdk/src/core/__mocks__/mock-wallet-provider.ts
+++ b/packages/sdk/src/core/__mocks__/mock-wallet-provider.ts
@@ -1,164 +1,64 @@
 import { WalletProvider } from '../providers';
-import { WalletResponseFailureType, WalletResponseStatus, WalletResponseSuccessType } from '../types';
+import {
+  TransactionResultSync,
+  WalletResponseFailureType,
+  WalletResponseRejectType,
+  WalletResponseSuccessType,
+} from '../types';
+import { makeResponseMessage } from '../utils';
+
+export const defineMockWalletProvider = () => {
+  jest.mock('../providers', () => ({
+    WalletProvider: jest.fn(() => mockWalletProvider),
+  }));
+};
 
 export const mockWalletProvider: jest.Mocked<WalletProvider> = {
-  isConnected: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-    message: 'Wallet is connected',
-    data: null,
-  }),
-  addEstablish: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-    message: 'Connection established',
-    data: null,
-  }),
-  getAccount: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.GET_ACCOUNT_SUCCESS,
-    message: 'Account retrieved',
-    data: { address: 'mock-address', connected: true },
-  }),
-  switchNetwork: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-    message: 'Network switched',
-    data: null,
-  }),
-  addNetwork: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.ADD_NETWORK_SUCCESS,
-    message: 'Network added',
-    data: null,
-  }),
-  signTransaction: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.SIGN_SUCCESS,
-    message: 'Transaction signed',
-    data: 'mock-signed-transaction',
-  }),
-  broadcastTransaction: jest.fn().mockResolvedValue({
-    code: 0,
-    status: WalletResponseStatus.SUCCESS,
-    type: WalletResponseSuccessType.TRANSACTION_SUCCESS,
-    message: 'Transaction broadcasted',
-    data: { result: 'mock-result' },
-  }),
+  isConnected: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS)),
+  addEstablish: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS)),
+  getAccount: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.GET_ACCOUNT_SUCCESS)),
+  switchNetwork: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS)),
+  addNetwork: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.ADD_NETWORK_SUCCESS)),
+  signTransaction: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.SIGN_SUCCESS)),
+  broadcastTransaction: jest.fn().mockResolvedValue(makeResponseMessage(WalletResponseSuccessType.TRANSACTION_SUCCESS)),
   onChangeAccount: jest.fn().mockImplementation(() => {
-    return {
-      code: 0,
-      status: WalletResponseStatus.SUCCESS,
-      type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-      message: 'Account change listener added',
-      data: null,
-    };
+    return;
   }),
   onChangeNetwork: jest.fn().mockImplementation(() => {
-    return {
-      code: 0,
-      status: WalletResponseStatus.SUCCESS,
-      type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-      message: 'Network change listener added',
-      data: null,
-    };
+    return;
   }),
 };
 
-jest.mock('../providers', () => ({
-  WalletProvider: jest.fn(() => mockWalletProvider),
-}));
+export const isConnectedSuccessMock = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS, true);
 
-export const isConnectedSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-  message: '',
-  data: true,
-};
+export const isConnectedFailureMock = makeResponseMessage(WalletResponseFailureType.ALREADY_CONNECTED, false);
 
-export const isConnectedFailureMock = {
-  code: 4000,
-  status: WalletResponseStatus.FAILURE,
-  type: WalletResponseFailureType.ALREADY_CONNECTED,
-  message: '',
-  data: false,
-};
+export const addEstablishSuccessMock = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS, true);
 
-export const addEstablishSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-  message: '',
-  data: null,
-};
+export const addEstablishFailureMock = makeResponseMessage(WalletResponseFailureType.ALREADY_CONNECTED, false);
 
-export const addEstablishFailureMock = {
-  code: 4000,
-  status: WalletResponseStatus.FAILURE,
-  type: WalletResponseFailureType.ALREADY_CONNECTED,
-  message: '',
-  data: null,
-};
+export const addEstablishRejectMock = makeResponseMessage(WalletResponseRejectType.CONNECTION_REJECTED, false);
 
-export const getAccountSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.GET_ACCOUNT_SUCCESS,
-  message: '',
-  data: { address: '' },
-};
+export const getAccountSuccessMock = makeResponseMessage(WalletResponseSuccessType.GET_ACCOUNT_SUCCESS);
 
-export const switchNetworkSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-  message: '',
-  data: null,
-};
+export const switchNetworkSuccessMock = makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS);
 
-export const addNetworkSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.ADD_NETWORK_SUCCESS,
-  message: '',
-  data: null,
-};
+export const addNetworkSuccessMock = makeResponseMessage<void>(WalletResponseSuccessType.ADD_NETWORK_SUCCESS);
 
-export const signTransactionSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.SIGN_SUCCESS,
-  message: '',
-  data: '',
-};
+export const addNetworkFailureMock = makeResponseMessage<void>(WalletResponseFailureType.UNADDED_NETWORK);
 
-export const broadcastTransactionSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.TRANSACTION_SUCCESS,
-  message: '',
-  data: { result: '' },
-};
+export const addNetworkRejectMock = makeResponseMessage<void>(WalletResponseRejectType.SWITCH_NETWORK_REJECTED);
 
-export const onChangeAccountSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.CONNECTION_SUCCESS,
-  message: '',
-  data: null,
-};
+export const signTransactionSuccessMock = makeResponseMessage(WalletResponseSuccessType.SIGN_SUCCESS);
 
-export const onChangeNetworkSuccessMock = {
-  code: 0,
-  status: WalletResponseStatus.SUCCESS,
-  type: WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS,
-  message: '',
-  data: null,
-};
+export const broadcastTransactionSuccessMock = makeResponseMessage<TransactionResultSync>(
+  WalletResponseSuccessType.TRANSACTION_SUCCESS
+);
+
+export const broadcastTransactionFailureMock = makeResponseMessage<TransactionResultSync>(
+  WalletResponseFailureType.TRANSACTION_FAILED
+);
+
+export const onChangeAccountSuccessMock = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS);
+
+export const onChangeNetworkSuccessMock = makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS);
diff --git a/packages/sdk/src/core/__tests__/methods/add-establish.test.ts b/packages/sdk/src/core/__tests__/methods/add-establish.test.ts
new file mode 100644
index 0000000..d249d8a
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/add-establish.test.ts
@@ -0,0 +1,54 @@
+import {
+  addEstablishFailureMock,
+  addEstablishRejectMock,
+  addEstablishSuccessMock,
+  mockWalletProvider,
+} from '../../__mocks__/mock-wallet-provider';
+import { addEstablish } from '../../methods';
+import { AddEstablishOptions, AddEstablishResponse } from '../../types/methods';
+
+describe('addEstablish', () => {
+  const options: AddEstablishOptions = {
+    siteName: 'Test Site',
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call addEstablish with correct options and return the response', async () => {
+    const mockResponse: AddEstablishResponse = addEstablishSuccessMock;
+    mockWalletProvider.addEstablish.mockResolvedValue(mockResponse);
+
+    const response = await addEstablish(mockWalletProvider, options);
+
+    expect(mockWalletProvider.addEstablish).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const mockResponse: AddEstablishResponse = addEstablishFailureMock;
+    mockWalletProvider.addEstablish.mockResolvedValue(mockResponse);
+
+    const response = await addEstablish(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle reject response', async () => {
+    const mockResponse: AddEstablishResponse = addEstablishRejectMock;
+    mockWalletProvider.addEstablish.mockResolvedValue(mockResponse);
+
+    const response = await addEstablish(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should throw an error if addEstablish fails', async () => {
+    const mockError = new Error('Failed to establish connection');
+
+    mockWalletProvider.addEstablish.mockRejectedValue(mockError);
+
+    await expect(addEstablish(mockWalletProvider, options)).rejects.toThrow('Failed to establish connection');
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/add-network.test.ts b/packages/sdk/src/core/__tests__/methods/add-network.test.ts
new file mode 100644
index 0000000..d939a5b
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/add-network.test.ts
@@ -0,0 +1,43 @@
+import { addNetworkFailureMock, addNetworkSuccessMock, mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { addNetwork } from '../../methods';
+import { AddNetworkOptions, AddNetworkResponse } from '../../types/methods';
+
+describe('addNetwork', () => {
+  const options: AddNetworkOptions = {
+    chainId: 'test-chain-id',
+    chainName: 'Test Chain',
+    rpcUrl: 'https://test-rpc-url.com',
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call addNetwork with correct options and return the response', async () => {
+    const mockResponse: AddNetworkResponse = addNetworkSuccessMock;
+
+    mockWalletProvider.addNetwork.mockResolvedValue(mockResponse);
+
+    const response = await addNetwork(mockWalletProvider, options);
+
+    expect(mockWalletProvider.addNetwork).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const mockResponse: AddNetworkResponse = addNetworkFailureMock;
+
+    mockWalletProvider.addNetwork.mockResolvedValue(mockResponse);
+
+    const response = await addNetwork(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should throw an error if addNetwork fails', async () => {
+    const mockError = new Error('Failed to add network');
+    mockWalletProvider.addNetwork.mockRejectedValue(mockError);
+
+    await expect(addNetwork(mockWalletProvider, options)).rejects.toThrow('Failed to add network');
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/broadcast-transaction.test.ts b/packages/sdk/src/core/__tests__/methods/broadcast-transaction.test.ts
new file mode 100644
index 0000000..37f93c2
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/broadcast-transaction.test.ts
@@ -0,0 +1,51 @@
+import {
+  broadcastTransactionFailureMock,
+  broadcastTransactionSuccessMock,
+  mockWalletProvider,
+} from '../../__mocks__/mock-wallet-provider';
+import { broadcastTransaction } from '../../methods';
+import { BroadcastType } from '../../types';
+import { BroadcastTransactionOptions, BroadcastTransactionResponse } from '../../types/methods';
+
+describe('broadcastTransaction', () => {
+  const options: BroadcastTransactionOptions = {
+    tx: {
+      messages: [],
+      signatures: [],
+      memo: '',
+    },
+    broadcastType: BroadcastType.SYNC,
+  };
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call broadcastTransaction with correct options and return the response', async () => {
+    const mockResponse: BroadcastTransactionResponse = broadcastTransactionSuccessMock;
+
+    mockWalletProvider.broadcastTransaction.mockResolvedValue(mockResponse);
+
+    const response = await broadcastTransaction(mockWalletProvider, options);
+
+    expect(mockWalletProvider.broadcastTransaction).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const mockResponse: BroadcastTransactionResponse = broadcastTransactionFailureMock;
+
+    mockWalletProvider.broadcastTransaction.mockResolvedValue(mockResponse);
+
+    const response = await broadcastTransaction(mockWalletProvider, options);
+
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should throw an error if broadcastTransaction fails', async () => {
+    const mockError = new Error('Failed to broadcast transaction');
+    mockWalletProvider.broadcastTransaction.mockRejectedValue(mockError);
+
+    await expect(broadcastTransaction(mockWalletProvider, options)).rejects.toThrow('Failed to broadcast transaction');
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/connect.test.ts b/packages/sdk/src/core/__tests__/methods/connect.test.ts
new file mode 100644
index 0000000..10af881
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/connect.test.ts
@@ -0,0 +1,75 @@
+import { mockConnectionManager } from '../../__mocks__/mock-connection-manager';
+import { defineGlobalMock } from '../../__mocks__/mock-global';
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { ConnectionManager } from '../../connection';
+import { connect } from '../../methods';
+import { ConnectOptions } from '../../types/methods';
+import { isTM2WalletProvider } from '../../utils/provider.utils';
+
+jest.mock('../../utils/provider.utils', () => ({
+  isTM2WalletProvider: jest.fn(),
+}));
+
+describe('connect', () => {
+  afterEach(() => {
+    defineGlobalMock();
+    jest.clearAllMocks();
+  });
+
+  it('should call connectWallet successfully', async () => {
+    await connect(mockConnectionManager as unknown as ConnectionManager);
+
+    expect(mockConnectionManager.connectWallet).toHaveBeenCalled();
+  });
+
+  it('should open wallet download link if connection fails and wallet provider is not TM2', async () => {
+    const mockError = new Error('Connection failed');
+    mockConnectionManager.connectWallet.mockRejectedValue(mockError);
+    mockConnectionManager.getWalletProvider.mockReturnValueOnce(mockWalletProvider);
+    (isTM2WalletProvider as unknown as jest.Mock).mockReturnValue(false);
+
+    const walletDownloadUrl = 'https://wallet-download-url.com';
+    const connectionOptions: ConnectOptions = {
+      walletDownloadUrl,
+    };
+
+    await connect(mockConnectionManager as unknown as ConnectionManager, connectionOptions);
+
+    expect(mockConnectionManager.connectWallet).toHaveBeenCalled();
+    expect(mockConnectionManager.getWalletProvider).toHaveBeenCalled();
+    expect(open).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not open wallet download link if connection fails and wallet provider is TM2', async () => {
+    const mockError = new Error('Connection failed');
+    mockConnectionManager.connectWallet.mockRejectedValue(mockError);
+    mockConnectionManager.getWalletProvider.mockReturnValueOnce(mockWalletProvider);
+    (isTM2WalletProvider as unknown as jest.Mock).mockReturnValue(true);
+
+    const walletDownloadUrl = 'https://wallet-download-url.com';
+    const connectionOptions: ConnectOptions = {
+      walletDownloadUrl,
+    };
+
+    await connect(mockConnectionManager as unknown as ConnectionManager, connectionOptions);
+
+    expect(mockConnectionManager.connectWallet).toHaveBeenCalled();
+    expect(mockConnectionManager.getWalletProvider).toHaveBeenCalled();
+    expect(open).toHaveBeenCalledTimes(0);
+  });
+
+  it('should not open wallet download link if connection fails and no walletDownloadUrl is provided', async () => {
+    const mockError = new Error('Connection failed');
+    mockConnectionManager.connectWallet.mockRejectedValue(mockError);
+    mockConnectionManager.getWalletProvider.mockReturnValueOnce(mockWalletProvider);
+    (isTM2WalletProvider as unknown as jest.Mock).mockReturnValue(false);
+
+    const connectionOptions: ConnectOptions = {};
+
+    await connect(mockConnectionManager as unknown as ConnectionManager, connectionOptions);
+
+    expect(mockConnectionManager.connectWallet).toHaveBeenCalled();
+    expect(mockConnectionManager.getWalletProvider).toHaveBeenCalled();
+    expect(open).toHaveBeenCalledTimes(0);
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/disconnect.test.ts b/packages/sdk/src/core/__tests__/methods/disconnect.test.ts
new file mode 100644
index 0000000..10a45b3
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/disconnect.test.ts
@@ -0,0 +1,17 @@
+import { mockConnectionManager } from '../../__mocks__/mock-connection-manager';
+import { defineGlobalMock } from '../../__mocks__/mock-global';
+import { ConnectionManager } from '../../connection';
+import { disconnect } from '../../methods';
+
+describe('disconnect', () => {
+  afterEach(() => {
+    defineGlobalMock();
+    jest.clearAllMocks();
+  });
+
+  it('should call disconnectWallet on ConnectionManager', () => {
+    disconnect(mockConnectionManager as unknown as ConnectionManager);
+
+    expect(mockConnectionManager.disconnectWallet).toHaveBeenCalled();
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/get-account.test.ts b/packages/sdk/src/core/__tests__/methods/get-account.test.ts
new file mode 100644
index 0000000..687b099
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/get-account.test.ts
@@ -0,0 +1,40 @@
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { getAccount } from '../../methods';
+import { WalletResponseSuccessType } from '../../types';
+import { GetAccountResponse } from '../../types/methods';
+import { makeResponseMessage } from '../../utils';
+
+describe('getAccount', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call getAccount and return the response', async () => {
+    const mockResponse: GetAccountResponse = makeResponseMessage(WalletResponseSuccessType.GET_ACCOUNT_SUCCESS, {
+      accountNumber: '123456',
+      address: 'test-address',
+      coins: '1000',
+      chainId: 'test-chain-id',
+      sequence: '1',
+      status: 'ACTIVE' as const,
+      publicKey: {
+        '@type': 'type',
+        value: 'public-key-value',
+      },
+    });
+
+    mockWalletProvider.getAccount.mockResolvedValue(mockResponse);
+
+    const response = await getAccount(mockWalletProvider);
+
+    expect(mockWalletProvider.getAccount).toHaveBeenCalled();
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle errors when getAccount fails', async () => {
+    const mockError = new Error('Failed to get account');
+    mockWalletProvider.getAccount.mockRejectedValue(mockError);
+
+    await expect(getAccount(mockWalletProvider)).rejects.toThrow('Failed to get account');
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/get-connection-state.test.ts b/packages/sdk/src/core/__tests__/methods/get-connection-state.test.ts
new file mode 100644
index 0000000..208023d
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/get-connection-state.test.ts
@@ -0,0 +1,20 @@
+import { mockConnectionManager } from '../../__mocks__/mock-connection-manager';
+import { ConnectionManager, ConnectionState } from '../../connection'; // Adjust this import according to your actual file structure
+import { getConnectionState } from '../../methods';
+
+describe('getConnectionState', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call getConnectionState and return the state', () => {
+    const mockState: ConnectionState = ConnectionState.CONNECTED; // Replace with actual state values if needed
+
+    mockConnectionManager.getConnectionState.mockReturnValue(mockState);
+
+    const state = getConnectionState(mockConnectionManager as unknown as ConnectionManager);
+
+    expect(mockConnectionManager.getConnectionState).toHaveBeenCalled();
+    expect(state).toBe(mockState);
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/is-connected.test.ts b/packages/sdk/src/core/__tests__/methods/is-connected.test.ts
new file mode 100644
index 0000000..7b140e7
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/is-connected.test.ts
@@ -0,0 +1,29 @@
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { isConnected } from '../../methods';
+import { WalletResponseSuccessType } from '../../types';
+import { IsConnectedResponse } from '../../types/methods';
+import { makeResponseMessage } from '../../utils';
+
+describe('isConnected', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call isConnected and return the response', async () => {
+    const mockResponse: IsConnectedResponse = makeResponseMessage(WalletResponseSuccessType.CONNECTION_SUCCESS);
+
+    mockWalletProvider.isConnected.mockResolvedValue(mockResponse);
+
+    const response = await isConnected(mockWalletProvider);
+
+    expect(mockWalletProvider.isConnected).toHaveBeenCalled();
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle errors when isConnected fails', async () => {
+    const mockError = new Error('Failed to check connection');
+    mockWalletProvider.isConnected.mockRejectedValue(mockError);
+
+    await expect(isConnected(mockWalletProvider)).rejects.toThrow('Failed to check connection');
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/off-connection-change.test.ts b/packages/sdk/src/core/__tests__/methods/off-connection-change.test.ts
new file mode 100644
index 0000000..812aa22
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/off-connection-change.test.ts
@@ -0,0 +1,28 @@
+import { mockConnectionManager } from '../../__mocks__/mock-connection-manager';
+import { ConnectionManager } from '../../connection';
+import { offConnectionChange } from '../../methods';
+import { OffConnectionChangeOptions } from '../../types/methods'; // Adjust imports based on your actual file structure
+
+describe('offConnectionChange', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call off and remove the listener', () => {
+    const mockCallback = jest.fn();
+    const options: OffConnectionChangeOptions = { callback: mockCallback };
+
+    offConnectionChange(mockConnectionManager as unknown as ConnectionManager, options);
+
+    expect(mockConnectionManager.off).toHaveBeenCalledWith(mockCallback);
+  });
+
+  it('should handle cases where no callback is provided', () => {
+    const callback = () => {};
+    const options: OffConnectionChangeOptions = { callback };
+
+    offConnectionChange(mockConnectionManager as unknown as ConnectionManager, options);
+
+    expect(mockConnectionManager.off).toHaveBeenCalledWith(callback);
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/on-change-account.test.ts b/packages/sdk/src/core/__tests__/methods/on-change-account.test.ts
new file mode 100644
index 0000000..4b2c9e4
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/on-change-account.test.ts
@@ -0,0 +1,18 @@
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { onChangeAccount } from '../../methods';
+import { OnChangeAccountOptions } from '../../types/methods'; // Adjust imports based on your actual file structure
+
+describe('onChangeAccount', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call onChangeAccount with the correct options', () => {
+    const mockCallback = jest.fn();
+    const options: OnChangeAccountOptions = { callback: mockCallback };
+
+    onChangeAccount(mockWalletProvider, options);
+
+    expect(mockWalletProvider.onChangeAccount).toHaveBeenCalledWith(options);
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/on-change-network.test.ts b/packages/sdk/src/core/__tests__/methods/on-change-network.test.ts
new file mode 100644
index 0000000..a3da86d
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/on-change-network.test.ts
@@ -0,0 +1,18 @@
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { onChangeNetwork } from '../../methods';
+import { OnChangeNetworkOptions } from '../../types/methods'; // Adjust imports based on your actual file structure
+
+describe('onChangeNetwork', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call onChangeNetwork with the correct options', () => {
+    const mockCallback = jest.fn();
+    const options: OnChangeNetworkOptions = { callback: mockCallback };
+
+    onChangeNetwork(mockWalletProvider, options);
+
+    expect(mockWalletProvider.onChangeNetwork).toHaveBeenCalledWith(options);
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/on-connection-change.test.ts b/packages/sdk/src/core/__tests__/methods/on-connection-change.test.ts
new file mode 100644
index 0000000..2182731
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/on-connection-change.test.ts
@@ -0,0 +1,21 @@
+import { mockConnectionManager } from '../../__mocks__/mock-connection-manager';
+import { ConnectionManager } from '../../connection';
+import { onConnectionChange } from '../../methods';
+import { OnConnectionChangeOptions } from '../../types/methods'; // Adjust imports based on your actual file structure
+
+describe('onConnectionChange', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call on with the correct options', () => {
+    const mockCallback = jest.fn();
+    const options: OnConnectionChangeOptions = { callback: mockCallback };
+
+    mockConnectionManager.on.mockImplementation(() => {});
+
+    onConnectionChange(mockConnectionManager as unknown as ConnectionManager, options);
+
+    expect(mockConnectionManager.on).toHaveBeenCalledWith(mockCallback);
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/sign-transaction.test.ts b/packages/sdk/src/core/__tests__/methods/sign-transaction.test.ts
new file mode 100644
index 0000000..c9fe0aa
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/sign-transaction.test.ts
@@ -0,0 +1,97 @@
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { signTransaction } from '../../methods';
+import { WalletResponseFailureType, WalletResponseRejectType, WalletResponseSuccessType } from '../../types';
+import { SignTransactionOptions, SignTransactionResponse } from '../../types/methods/sign-transaction.types'; // Adjust imports based on your actual file structure
+import { makeResponseMessage } from '../../utils';
+
+describe('signTransaction', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call signTransaction with the correct options and return the response', async () => {
+    const tx = {
+      messages: [],
+      signatures: [],
+      memo: '',
+    };
+
+    const options: SignTransactionOptions = {
+      tx,
+    };
+
+    const mockResponse: SignTransactionResponse = makeResponseMessage(WalletResponseSuccessType.SIGN_SUCCESS, {
+      encodedTransaction: '',
+    });
+
+    mockWalletProvider.signTransaction.mockResolvedValue(mockResponse);
+
+    const response = await signTransaction(mockWalletProvider, options);
+
+    expect(mockWalletProvider.signTransaction).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const tx = {
+      messages: [],
+      signatures: [],
+      memo: '',
+    };
+
+    const options: SignTransactionOptions = {
+      tx,
+    };
+
+    const mockResponse: SignTransactionResponse = makeResponseMessage(WalletResponseFailureType.SIGN_FAILED, {
+      encodedTransaction: '',
+    });
+
+    mockWalletProvider.signTransaction.mockResolvedValue(mockResponse);
+
+    const response = await signTransaction(mockWalletProvider, options);
+
+    expect(mockWalletProvider.signTransaction).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle rejected response', async () => {
+    const tx = {
+      messages: [],
+      signatures: [],
+      memo: '',
+    };
+
+    const options: SignTransactionOptions = {
+      tx,
+    };
+
+    const mockResponse: SignTransactionResponse = makeResponseMessage(WalletResponseRejectType.SIGN_REJECTED, {
+      encodedTransaction: '',
+    });
+
+    mockWalletProvider.signTransaction.mockResolvedValue(mockResponse);
+
+    const response = await signTransaction(mockWalletProvider, options);
+
+    expect(mockWalletProvider.signTransaction).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle throw errors', async () => {
+    const tx = {
+      messages: [],
+      signatures: [],
+      memo: '',
+    };
+
+    const options: SignTransactionOptions = {
+      tx,
+    };
+
+    const mockError = new Error('Failed to sign transaction');
+    mockWalletProvider.signTransaction.mockRejectedValue(mockError);
+
+    await expect(signTransaction(mockWalletProvider, options)).rejects.toThrow('Failed to sign transaction');
+  });
+});
diff --git a/packages/sdk/src/core/__tests__/methods/switch-network.test.ts b/packages/sdk/src/core/__tests__/methods/switch-network.test.ts
new file mode 100644
index 0000000..a6021dc
--- /dev/null
+++ b/packages/sdk/src/core/__tests__/methods/switch-network.test.ts
@@ -0,0 +1,41 @@
+import { mockWalletProvider } from '../../__mocks__/mock-wallet-provider';
+import { switchNetwork } from '../../methods';
+import { WalletResponseFailureType, WalletResponseSuccessType } from '../../types';
+import { SwitchNetworkOptions, SwitchNetworkResponse } from '../../types/methods';
+import { makeResponseMessage } from '../../utils';
+
+describe('switchNetwork', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call switchNetwork with the correct options and return the response', async () => {
+    const options: SwitchNetworkOptions = {
+      chainId: 'test-chain-id',
+    };
+
+    const mockResponse: SwitchNetworkResponse = makeResponseMessage(WalletResponseSuccessType.SWITCH_NETWORK_SUCCESS);
+
+    mockWalletProvider.switchNetwork.mockResolvedValue(mockResponse);
+
+    const response = await switchNetwork(mockWalletProvider, options);
+
+    expect(mockWalletProvider.switchNetwork).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle failure response', async () => {
+    const options: SwitchNetworkOptions = {
+      chainId: 'test-chain-id',
+    };
+
+    const mockResponse: SwitchNetworkResponse = makeResponseMessage(WalletResponseFailureType.REDUNDANT_CHANGE_REQUEST);
+
+    mockWalletProvider.switchNetwork.mockResolvedValue(mockResponse);
+
+    const response = await switchNetwork(mockWalletProvider, options);
+
+    expect(mockWalletProvider.switchNetwork).toHaveBeenCalledWith(options);
+    expect(response).toEqual(mockResponse);
+  });
+});
diff --git a/packages/sdk/src/core/methods/connect.ts b/packages/sdk/src/core/methods/connect.ts
index af0b88a..a40c0e9 100644
--- a/packages/sdk/src/core/methods/connect.ts
+++ b/packages/sdk/src/core/methods/connect.ts
@@ -13,11 +13,12 @@ export const connect = async (
       !isTM2WalletProvider(connectionManager.getWalletProvider()) && !!connectionOptions.walletDownloadUrl;
     if (openWalletLink) {
       openLink(connectionOptions.walletDownloadUrl!);
+    } else {
+      console.error((e as Error).message);
     }
-    console.error(e);
   }
 };
 
-const openLink = (url: string): void => {
-  window?.open(url, '_blank');
+export const openLink = (url: string): void => {
+  open(url, '_blank');
 };