diff --git a/packages/site/src/components/cards/GetAccountInfo.tsx b/packages/site/src/components/cards/GetAccountInfo.tsx
index 1517bef..8ffaa43 100644
--- a/packages/site/src/components/cards/GetAccountInfo.tsx
+++ b/packages/site/src/components/cards/GetAccountInfo.tsx
@@ -12,7 +12,9 @@ import {
 } from '../../utils';
 import { hederaNetworks } from '../../utils/hedera';
 import { Card, SendHelloButton } from '../base';
-import { GetExternalAccountRef } from '../sections/ExternalAccount';
+import ExternalAccount, {
+  GetExternalAccountRef,
+} from '../sections/ExternalAccount';
 
 type Props = {
   setCurrentNetwork: React.Dispatch<React.SetStateAction<string>>;
@@ -70,7 +72,7 @@ const GetAccountInfo: FC<Props> = ({
         description: 'Get the current account information',
         form: (
           <>
-            {/* <ExternalAccount ref={externalAccountRef} /> */}
+            <ExternalAccount ref={externalAccountRef} />
             <label>
               Enter an account Id
               <input
diff --git a/packages/site/src/components/cards/SendHelloMessage.tsx b/packages/site/src/components/cards/SendHelloMessage.tsx
index 76609f4..5730f1f 100644
--- a/packages/site/src/components/cards/SendHelloMessage.tsx
+++ b/packages/site/src/components/cards/SendHelloMessage.tsx
@@ -30,6 +30,7 @@ const SendHelloHessage: FC<Props> = ({
       const network = hederaNetworks.get('testnet') as string;
       setCurrentNetwork(network);
       const metamaskAddress = await getCurrentMetamaskAccount();
+      console.log('address: ', metamaskAddress);
       setMetamaskAddress(metamaskAddress);
 
       const response: any = await sendHello(network);
diff --git a/packages/site/src/components/sections/ExternalAccount.tsx b/packages/site/src/components/sections/ExternalAccount.tsx
index b36cbf2..4d11696 100644
--- a/packages/site/src/components/sections/ExternalAccount.tsx
+++ b/packages/site/src/components/sections/ExternalAccount.tsx
@@ -8,7 +8,7 @@ export type GetExternalAccountRef = {
 
 const ExternalAccount = forwardRef(({}, ref: Ref<GetExternalAccountRef>) => {
   const [externalAccount, setExternalAccount] = useState(false);
-  const [accountId, setAccountId] = useState('');
+  const [accountIdOrEvmAddress, setAccountIdOrEvmAddress] = useState('');
 
   useImperativeHandle(ref, () => ({
     handleGetAccountParams() {
@@ -16,7 +16,7 @@ const ExternalAccount = forwardRef(({}, ref: Ref<GetExternalAccountRef>) => {
       if (externalAccount) {
         params = {
           externalAccount: {
-            accountId,
+            accountIdOrEvmAddress,
           },
         };
       }
@@ -25,7 +25,7 @@ const ExternalAccount = forwardRef(({}, ref: Ref<GetExternalAccountRef>) => {
   }));
 
   return (
-    <>
+    <div>
       <Form>
         <Form.Check
           type="checkbox"
@@ -35,16 +35,22 @@ const ExternalAccount = forwardRef(({}, ref: Ref<GetExternalAccountRef>) => {
             setExternalAccount(e.target.checked);
           }}
         />
-        <Form.Label>Account Id</Form.Label>
-        <Form.Control
-          size="lg"
-          type="text"
-          placeholder="Account Id"
-          style={{ marginBottom: 8 }}
-          onChange={(e) => setAccountId(e.target.value)}
-        />
+        {externalAccount && (
+          <>
+            <Form.Label>
+              Enter your Account Id or EVM address to connect to
+            </Form.Label>
+            <Form.Control
+              size="lg"
+              type="text"
+              placeholder="Account Id or EVM address"
+              style={{ marginBottom: 8 }}
+              onChange={(e) => setAccountIdOrEvmAddress(e.target.value)}
+            />
+          </>
+        )}
       </Form>
-    </>
+    </div>
   );
 });
 
diff --git a/packages/site/src/pages/index.tsx b/packages/site/src/pages/index.tsx
index 1362524..a576d6c 100644
--- a/packages/site/src/pages/index.tsx
+++ b/packages/site/src/pages/index.tsx
@@ -60,8 +60,14 @@ const Index = () => {
             <dd>{currentNetwork ? 'Connected' : 'Disconnected'}</dd>
             <dt>Current Network:</dt>
             <dd>{currentNetwork}</dd>
-            <dt>Currently Connected Metamask Account: </dt>
-            <dd>{metamaskAddress}</dd>
+            <dt>Currently Connected Account Type: </dt>
+            <dd>
+              {metamaskAddress === accountInfo?.metamaskAddress
+                ? 'Metamask Account'
+                : 'Non-Metamask Account'}
+            </dd>
+            <dt>Currently Connected Address: </dt>
+            <dd>{accountInfo?.metamaskAddress}</dd>
             <dt>Hedera Account ID: </dt>
             <dd>{accountInfo?.hederaAccountId}</dd>
             <dt>Hedera EVM Address: </dt>
diff --git a/packages/site/src/types/snap.ts b/packages/site/src/types/snap.ts
index c60442a..dd7ca36 100644
--- a/packages/site/src/types/snap.ts
+++ b/packages/site/src/types/snap.ts
@@ -7,32 +7,33 @@ export type Snap = {
   initialPermissions: Record<string, unknown>;
 };
 
-export type Account = {
-  metamaskAddress: string;
-  hederaAccountId: string;
-  hederaEvmAddress: string;
-  balance: AccountBalance;
-  network: string;
+export type TokenBalance = {
+  // balance has already had decimals applied
+  balance: number;
+  decimals: number;
 };
 
 export type AccountBalance = {
   // balance here in hbars
   hbars: number;
+  timestamp: string;
   tokens: Map<string, TokenBalance>; // Map of TOKEN -> decimals
 };
 
-export type TokenBalance = {
-  // balance has already had decimals applied
-  balance: number;
-  decimals: number;
+export type Account = {
+  metamaskAddress: string;
+  hederaAccountId: string;
+  hederaEvmAddress: string;
+  balance: AccountBalance;
+  network: string;
 };
 
 export type SimpleTransfer = {
   // HBAR or Token ID (as string)
-  asset?: string;
-  to?: string;
+  asset: string;
+  to: string;
   // amount must be in low denom
-  amount?: number;
+  amount: number;
 };
 
 export type TransferCryptoRequestParams = {
@@ -43,6 +44,6 @@ export type TransferCryptoRequestParams = {
 
 export type ExternalAccountParams = {
   externalAccount: {
-    accountId: string;
+    accountIdOrEvmAddress: string;
   };
 };
diff --git a/packages/snap/snap.manifest.json b/packages/snap/snap.manifest.json
index 65b39d6..e937600 100644
--- a/packages/snap/snap.manifest.json
+++ b/packages/snap/snap.manifest.json
@@ -7,7 +7,7 @@
     "url": "https://github.com/tuum-tech/hedera-pulse.git"
   },
   "source": {
-    "shasum": "+GQraBauxdm43Ba4RQf0FFrA59AzXZeNalbkYslzVMg=",
+    "shasum": "zPnXj8v/itQVsoTFa5vgxROTDDJheMBC2yfhDx9qDss=",
     "location": {
       "npm": {
         "filePath": "dist/snap.js",
diff --git a/packages/snap/src/index.ts b/packages/snap/src/index.ts
index 10650b7..989e797 100644
--- a/packages/snap/src/index.ts
+++ b/packages/snap/src/index.ts
@@ -10,6 +10,7 @@ import { getSnapStateUnchecked } from './snap/state';
 import { PulseSnapParams } from './types/state';
 import { init } from './utils/init';
 import {
+  isExternalAccountFlagSet,
   isValidGetAccountInfoRequest,
   isValidTransferCryptoParams,
 } from './utils/params';
@@ -36,9 +37,9 @@ export const onRpcRequest: OnRpcRequestHandler = async ({
     JSON.stringify(request.params, null, 4),
   );
 
-  let state = await getSnapStateUnchecked(snap);
+  let state = await getSnapStateUnchecked();
   if (state === null || _.isEmpty(state)) {
-    state = await init(origin, snap);
+    state = await init(origin);
   }
   console.log(
     'state:',
@@ -49,7 +50,12 @@ export const onRpcRequest: OnRpcRequestHandler = async ({
     ),
   );
 
-  await setCurrentAccount(origin, state, request.params);
+  let isExternalAccount = false;
+  if (isExternalAccountFlagSet(request.params)) {
+    isExternalAccount = true;
+  }
+
+  await setCurrentAccount(origin, state, request.params, isExternalAccount);
   console.log(
     `Current account: ${JSON.stringify(state.currentAccount, null, 4)}`,
   );
diff --git a/packages/snap/src/rpc/account/getAccountBalance.ts b/packages/snap/src/rpc/account/getAccountBalance.ts
index 3b9022a..a55fb75 100644
--- a/packages/snap/src/rpc/account/getAccountBalance.ts
+++ b/packages/snap/src/rpc/account/getAccountBalance.ts
@@ -17,6 +17,7 @@ export async function getAccountBalance(
 
   try {
     const hederaClient = await createHederaClient(
+      state.accountState[metamaskAddress].keyStore.curve,
       state.accountState[metamaskAddress].keyStore.privateKey,
       hederaAccountId,
       network,
@@ -28,7 +29,7 @@ export async function getAccountBalance(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     state.accountState[metamaskAddress].accountInfo.balance!.timestamp =
       new Date().toISOString();
-    await updateSnapState(snap, state);
+    await updateSnapState(state);
   } catch (error: any) {
     console.error(
       `Error while trying to get account balance: ${String(error)}`,
diff --git a/packages/snap/src/rpc/account/getAccountInfo.ts b/packages/snap/src/rpc/account/getAccountInfo.ts
index 60d82f0..5b95205 100644
--- a/packages/snap/src/rpc/account/getAccountInfo.ts
+++ b/packages/snap/src/rpc/account/getAccountInfo.ts
@@ -1,3 +1,4 @@
+import { AccountId } from '@hashgraph/sdk';
 import { AccountInfoJson } from '@hashgraph/sdk/lib/account/AccountInfo';
 import _ from 'lodash';
 import { createHederaClient } from '../../snap/account';
@@ -23,12 +24,21 @@ export async function getAccountInfo(
 
   try {
     const hederaClient = await createHederaClient(
+      state.accountState[metamaskAddress].keyStore.curve,
       state.accountState[metamaskAddress].keyStore.privateKey,
       hederaAccountId,
       network,
     );
 
     if (accountId && !_.isEmpty(accountId)) {
+      if (!AccountId.fromString(accountId)) {
+        console.error(
+          `Invalid Hedera Account Id '${accountId}' is not a valid account Id`,
+        );
+        throw new Error(
+          `Invalid Hedera Account Id '${accountId}' is not a valid account Id`,
+        );
+      }
       accountInfo = await hederaClient.getAccountInfo(accountId);
     } else {
       accountInfo = await hederaClient.getAccountInfo(hederaAccountId);
@@ -42,7 +52,7 @@ export async function getAccountInfo(
         new Date().toISOString();
 
       state.accountState[metamaskAddress].accountInfo.extraData = accountInfo;
-      await updateSnapState(snap, state);
+      await updateSnapState(state);
     }
   } catch (error: any) {
     console.error(`Error while trying to get account info: ${String(error)}`);
diff --git a/packages/snap/src/rpc/account/transferCrypto.ts b/packages/snap/src/rpc/account/transferCrypto.ts
index 52fdd69..0283400 100644
--- a/packages/snap/src/rpc/account/transferCrypto.ts
+++ b/packages/snap/src/rpc/account/transferCrypto.ts
@@ -67,6 +67,7 @@ export async function transferCrypto(
       }
 
       const hederaClient = await createHederaClient(
+        state.accountState[metamaskAddress].keyStore.curve,
         state.accountState[metamaskAddress].keyStore.privateKey,
         hederaAccountId,
         network,
diff --git a/packages/snap/src/services/impl/hedera/index.ts b/packages/snap/src/services/impl/hedera/index.ts
index 8bfc715..1b88fcc 100644
--- a/packages/snap/src/services/impl/hedera/index.ts
+++ b/packages/snap/src/services/impl/hedera/index.ts
@@ -59,7 +59,10 @@ export class HederaServiceImpl implements HederaService {
     } else if (this.network === 'previewnet') {
       client = Client.forPreviewnet();
     } else {
-      client = Client.forMainnet();
+      // client = Client.forMainnet();
+      client = Client.forNetwork({
+        'https://node01-00-grpc.swirlds.com:443': new AccountId(4),
+      });
     }
 
     // NOTE: important, ensure that we pre-compute the health state of all nodes
@@ -175,6 +178,7 @@ async function testClientOperatorMatch(client: Client) {
   try {
     await tx.execute(client);
   } catch (error: any) {
+    console.log('error: ', String(error));
     if (error instanceof StatusError) {
       if (
         error.status === Status.InsufficientTxFee ||
@@ -202,17 +206,24 @@ async function testClientOperatorMatch(client: Client) {
 /**
  * To HederaAccountInfo.
  *
+ * @param _curve - Curve that was used to derive the keys('ECDSA_SECP256K1' | 'ED25519').
  * @param _privateKey - Private Key.
  * @param _accountId - Account Id.
  * @param _network - Network.
  */
 export async function getHederaClient(
+  _curve: string,
   _privateKey: string,
   _accountId: string,
   _network: string,
 ): Promise<SimpleHederaClient | null> {
   const accountId = AccountId.fromString(_accountId);
-  const privateKey = PrivateKey.fromStringECDSA(_privateKey);
+
+  let privateKey = PrivateKey.fromStringECDSA(_privateKey);
+  if (_curve === 'ED25519') {
+    privateKey = PrivateKey.fromStringED25519(_privateKey);
+  }
+
   const wallet: Wallet = new PrivateKeySoftwareWallet(privateKey);
   const hederaService = new HederaServiceImpl(_network);
 
diff --git a/packages/snap/src/snap/account.ts b/packages/snap/src/snap/account.ts
index df288de..5969bd2 100644
--- a/packages/snap/src/snap/account.ts
+++ b/packages/snap/src/snap/account.ts
@@ -1,4 +1,6 @@
+import { PrivateKey } from '@hashgraph/sdk';
 import { divider, heading, text } from '@metamask/snaps-ui';
+import { Wallet, ethers } from 'ethers';
 import _ from 'lodash';
 import {
   AccountBalance,
@@ -9,13 +11,9 @@ import {
   TokenBalance,
 } from '../services/hedera';
 import { HederaServiceImpl, getHederaClient } from '../services/impl/hedera';
-import { Account } from '../types/account';
+import { Account, ExternalAccount, NetworkParams } from '../types/account';
 import { hederaNetworks } from '../types/constants';
-import {
-  HederaAccountParams,
-  PulseSnapState,
-  SnapDialogParams,
-} from '../types/state';
+import { KeyStore, PulseSnapState, SnapDialogParams } from '../types/state';
 import { generateWallet } from '../utils/keyPair';
 import { generateCommonPanel, snapDialog } from './dialog';
 import { validHederaNetwork } from './network';
@@ -32,21 +30,37 @@ const getCurrentMetamaskAccount = async (): Promise<string> => {
   return accounts[0];
 };
 
+/**
+ * Adds the prefix to the EVM address.
+ *
+ * @param address - EVM Account address.
+ * @returns EVM address.
+ */
+function ensure0xPrefix(address: string): string {
+  let result = address;
+  if (!address.startsWith('0x')) {
+    result = `0x${address}`;
+  }
+  return result.toLowerCase();
+}
+
 /**
  * Function that returns account info of the currently selected MetaMask account.
  *
  * @param origin - Source.
  * @param state - PulseSnapState.
  * @param params - Parameters that were passed by the user.
+ * @param isExternalAccount - Whether this is a metamask or a non-metamask account.
  * @returns MetaMask Hedera client.
  */
 export async function setCurrentAccount(
   origin: string,
   state: PulseSnapState,
   params: unknown,
+  isExternalAccount: boolean,
 ): Promise<void> {
   try {
-    const { network = 'mainnet' } = (params ?? {}) as HederaAccountParams;
+    const { network = 'mainnet' } = (params ?? {}) as NetworkParams;
     if (!validHederaNetwork(network)) {
       console.error(
         `Invalid Hedera network '${network}'. Valid networks are '${hederaNetworks.join(
@@ -61,74 +75,349 @@ export async function setCurrentAccount(
       );
     }
 
-    const metamaskAddress = await getCurrentMetamaskAccount();
+    let connectedAddress = '';
+    let keyStore = {} as KeyStore;
+    // Handle external account(non-metamask account)
+    if (isExternalAccount) {
+      const nonMetamaskAccount = params as ExternalAccount;
+      const { accountIdOrEvmAddress } = nonMetamaskAccount.externalAccount;
+      if (ethers.isAddress(accountIdOrEvmAddress)) {
+        const { connectedAddress: _connectedAddress, keyStore: _keyStore } =
+          await connectEVMAccount(
+            origin,
+            state,
+            ensure0xPrefix(accountIdOrEvmAddress),
+          );
+        connectedAddress = _connectedAddress;
+        keyStore = _keyStore;
+      } else {
+        try {
+          const { connectedAddress: _connectedAddress, keyStore: _keyStore } =
+            await connectHederaAccount(
+              origin,
+              state,
+              network,
+              (accountIdOrEvmAddress as string).toLowerCase(),
+            );
+          connectedAddress = _connectedAddress;
+          keyStore = _keyStore;
+        } catch (error: any) {
+          console.error(
+            `Could not connect to '${
+              accountIdOrEvmAddress as string
+            }'. Please try again: ${String(error)}`,
+          );
+          throw new Error(
+            `Could not connect to '${
+              accountIdOrEvmAddress as string
+            }'. Please try again: ${String(error)}`,
+          );
+        }
+      }
+    } else {
+      // Handle metamask connected account
+      connectedAddress = await getCurrentMetamaskAccount();
+    }
+
+    connectedAddress = connectedAddress.toLowerCase();
+
     // Retrieve the values if already in state
-    if (!Object.keys(state.accountState).includes(metamaskAddress)) {
+    if (!Object.keys(state.accountState).includes(connectedAddress)) {
       // Initialize if not in snap state
       console.log(
-        `The address ${metamaskAddress} has NOT yet been configured in the Hedera Pulse Snap. Configuring now...`,
+        `The address ${connectedAddress} has NOT yet been configured in the Hedera Pulse Snap. Configuring now...`,
       );
-      await initAccountState(snap, state, metamaskAddress);
+      await initAccountState(state, connectedAddress);
     }
 
-    await importMetaMaskAccount(origin, state, network, metamaskAddress);
+    await importMetaMaskAccount(
+      origin,
+      state,
+      network,
+      connectedAddress,
+      keyStore,
+      isExternalAccount,
+    );
   } catch (error: any) {
     console.error(`Error while trying to get the account: ${String(error)}`);
     throw new Error(`Error while trying to get the account: ${String(error)}`);
   }
 }
 
+/**
+ * Connect EVM Account.
+ *
+ * @param origin - Source.
+ * @param state - Pulse state.
+ * @param evmAddress - EVM Account address.
+ */
+async function connectEVMAccount(
+  origin: string,
+  state: PulseSnapState,
+  evmAddress: string,
+): Promise<any> {
+  let result = {} as KeyStore;
+  let connectedAddress = '';
+  for (const addr of Object.keys(state.accountState)) {
+    const { keyStore } = state.accountState[addr];
+
+    if (evmAddress === addr) {
+      connectedAddress = addr;
+      result = keyStore;
+      break;
+    }
+
+    if (evmAddress === keyStore.address) {
+      connectedAddress = addr;
+      result = keyStore;
+      break;
+    }
+  }
+
+  if (_.isEmpty(connectedAddress)) {
+    const dialogParamsForPrivateKey: SnapDialogParams = {
+      type: 'prompt',
+      content: await generateCommonPanel(origin, [
+        heading('Connect to EVM Account'),
+        text('Enter private key for the following account'),
+        divider(),
+        text(`EVM Address: ${evmAddress}`),
+      ]),
+      placeholder: '2386d1d21644dc65d...', // You can use '2386d1d21644dc65d4e4b9e2242c5f155cab174916cbc46ad85622cdaeac835c' for testing purposes
+    };
+    const privateKey = (await snapDialog(dialogParamsForPrivateKey)) as string;
+
+    try {
+      const wallet: Wallet = new ethers.Wallet(privateKey);
+      if (evmAddress !== wallet.address) {
+        console.error(
+          `The private key you passed was invalid for the EVM address '${evmAddress}'. Please try again.`,
+        );
+        throw new Error(
+          `The private key you passed was invalid for the EVM address '${evmAddress}'. Please try again.`,
+        );
+      }
+      result.curve = 'ECDSA_SECP256K1';
+      result.privateKey = privateKey;
+      result.publicKey = wallet.signingKey.publicKey;
+      result.address = ensure0xPrefix(wallet.address);
+      connectedAddress = ensure0xPrefix(wallet.address);
+    } catch (error: any) {
+      console.error(
+        'Error while trying to retrieve the private key. Please try again.',
+      );
+      throw new Error(
+        'Error while trying to retrieve the private key. Please try again.',
+      );
+    }
+  }
+
+  return {
+    connectedAddress,
+    keyStore: result,
+  };
+}
+
+/**
+ * Connect Hedera Account.
+ *
+ * @param origin - Source.
+ * @param state - Pulse state.
+ * @param network - Hedera network.
+ * @param accountId - Hedera Account id.
+ */
+async function connectHederaAccount(
+  origin: string,
+  state: PulseSnapState,
+  network: string,
+  accountId: string,
+): Promise<any> {
+  let result = {} as KeyStore;
+  let connectedAddress = '';
+  for (const addr of Object.keys(state.accountState)) {
+    const { keyStore } = state.accountState[addr];
+    if (keyStore.hederaAccountId === accountId) {
+      connectedAddress = addr;
+      result = keyStore;
+      break;
+    }
+  }
+
+  if (_.isEmpty(connectedAddress)) {
+    const dialogParamsForPrivateKey: SnapDialogParams = {
+      type: 'prompt',
+      content: await generateCommonPanel(origin, [
+        heading('Connect to Hedera Account'),
+        text('Enter private key for the following account'),
+        divider(),
+        text(`Account Id: ${accountId}`),
+      ]),
+      placeholder: '2386d1d21644dc65d...', // You can use '2386d1d21644dc65d4e4b9e2242c5f155cab174916cbc46ad85622cdaeac835c' for testing purposes
+    };
+    const privateKey = (await snapDialog(dialogParamsForPrivateKey)) as string;
+
+    try {
+      const hederaService = new HederaServiceImpl(network);
+      const accountInfo: MirrorAccountInfo =
+        await hederaService.getMirrorAccountInfo(accountId);
+      const publicKey =
+        PrivateKey.fromString(privateKey).publicKey.toStringRaw();
+      if (_.isEmpty(accountInfo)) {
+        const dialogParamsForHederaAccountId: SnapDialogParams = {
+          type: 'alert',
+          content: await generateCommonPanel(origin, [
+            heading('Hedera Account Status'),
+            text(
+              `This Hedera account is not yet active on ${network}. Please activate it by sending some HBAR to this account.`,
+            ),
+            divider(),
+            text(`Public Key: ${publicKey}`),
+            divider(),
+          ]),
+        };
+        await snapDialog(dialogParamsForHederaAccountId);
+
+        console.error(
+          `This Hedera account is not yet active. Please activate it by sending some HBAR to this account. Public Key: ${publicKey}`,
+        );
+        throw new Error(
+          `This Hedera account is not yet active. Please activate it by sending some HBAR to this account. Public Key: ${publicKey}`,
+        );
+      }
+      const hederaClient = await getHederaClient(
+        accountInfo.key._type,
+        privateKey,
+        accountId,
+        network,
+      );
+      if (hederaClient) {
+        result.privateKey = hederaClient
+          ?.getPrivateKey()
+          ?.toStringRaw() as string;
+        result.curve = accountInfo.key._type as 'ECDSA_SECP256K1' | 'ED25519';
+        result.publicKey = hederaClient.getPublicKey().toStringRaw();
+        result.hederaAccountId = accountId;
+        result.address = ensure0xPrefix(accountInfo.evm_address);
+        connectedAddress = ensure0xPrefix(accountInfo.evm_address);
+      } else {
+        const dialogParamsForHederaAccountId: SnapDialogParams = {
+          type: 'alert',
+          content: await generateCommonPanel(origin, [
+            heading('Hedera Account Status'),
+            text(
+              `The private key you passed is not associated with the Hedera account '${accountId}'`,
+            ),
+            divider(),
+            text(`Public Key: ${publicKey}`),
+            divider(),
+          ]),
+        };
+        await snapDialog(dialogParamsForHederaAccountId);
+
+        console.error(
+          `The private key you passed is not associated with the Hedera account '${accountId}'`,
+        );
+        throw new Error(
+          `The private key you passed is not associated with the Hedera account '${accountId}'`,
+        );
+      }
+    } catch (error: any) {
+      console.error(
+        'Error while trying to setup a Hedera client. Please try again.',
+      );
+      throw new Error(
+        'Error while trying to setup a Hedera client. Please try again.',
+      );
+    }
+  }
+
+  return {
+    connectedAddress,
+    keyStore: result,
+  };
+}
+
 /**
  * Veramo Import metamask account.
  *
  * @param origin - Source.
  * @param state - IdentitySnapState.
  * @param network - Hedera network.
- * @param metamaskAddress - EVM address.
+ * @param connectedAddress - Currently connected EVm address.
+ * @param keyStore - Keystore for private, public keys and EVM address.
+ * @param isExternalAccount - Whether this is a metamask or a non-metamask account.
  */
 export async function importMetaMaskAccount(
   origin: string,
   state: PulseSnapState,
   network: string,
-  metamaskAddress: string,
+  connectedAddress: string,
+  keyStore: KeyStore,
+  isExternalAccount: boolean,
 ): Promise<void> {
-  let { privateKey, publicKey, address } =
-    state.accountState[metamaskAddress].keyStore;
-  let balance = state.accountState[metamaskAddress].accountInfo
-    .balance as AccountBalance;
-
-  if (_.isEmpty(privateKey)) {
-    const res = await generateWallet(metamaskAddress);
-    if (!res) {
-      console.log('Failed to generate snap wallet for DID operations');
-      throw new Error('Failed to generate snap wallet for DID operations');
+  let curve = '';
+  let privateKey = '';
+  let publicKey = '';
+  let address = '';
+  let hederaAccountId = '';
+  let idOrAliasOrEvmAddress = '';
+
+  if (isExternalAccount) {
+    curve = keyStore.curve;
+    privateKey = keyStore.privateKey;
+    publicKey = keyStore.publicKey;
+    address = keyStore.address;
+    hederaAccountId = keyStore.hederaAccountId;
+  } else {
+    const { keyStore: ksInner } = state.accountState[connectedAddress];
+    curve = ksInner.curve;
+    privateKey = ksInner.privateKey;
+    publicKey = ksInner.publicKey;
+    address = ksInner.address;
+
+    if (_.isEmpty(privateKey)) {
+      // Generate a new wallet according to the Hedera Pulse's entrophy combined with the currently connected EVM address
+      const res = await generateWallet(connectedAddress);
+      if (!res) {
+        console.log('Failed to generate snap wallet for DID operations');
+        throw new Error('Failed to generate snap wallet for DID operations');
+      }
+      curve = 'ECDSA_SECP256K1';
+      privateKey = res.privateKey;
+      publicKey = res.publicKey;
+      address = res.address;
     }
-    const {
-      privateKey: _privateKey,
-      publicKey: _publicKey,
-      address: _address,
-    } = res;
-    privateKey = _privateKey;
-    publicKey = _publicKey;
-    address = _address;
+    hederaAccountId = await getHederaAccountIdIfExists(state, address);
   }
 
-  // eslint-disable-next-line require-atomic-updates
-  state.accountState[metamaskAddress].keyStore = {
-    privateKey,
-    publicKey,
-    address,
-  };
+  address = address.toLowerCase();
 
-  let hederaAccountId = await getHederaAccountIdIfExists(state, address);
   if (_.isEmpty(hederaAccountId)) {
+    idOrAliasOrEvmAddress = address;
+  } else {
+    idOrAliasOrEvmAddress = hederaAccountId;
+  }
+
+  let { balance } = state.accountState[connectedAddress].accountInfo;
+  if (
+    _.isEmpty(hederaAccountId) ||
+    _.isEmpty(state.accountState[connectedAddress].accountInfo)
+  ) {
     const hederaService = new HederaServiceImpl(network);
     const accountInfo: MirrorAccountInfo =
-      await hederaService.getMirrorAccountInfo(address);
+      await hederaService.getMirrorAccountInfo(idOrAliasOrEvmAddress);
     if (!_.isEmpty(accountInfo)) {
       hederaAccountId = accountInfo.account;
-      // eslint-disable-next-line require-atomic-updates
-      state.accountState[metamaskAddress].accountId = hederaAccountId;
+
+      // Make sure that the EVM address of this accountId matches the one on Hedera
+      if (accountInfo.evm_address !== address) {
+        console.error(
+          `The Hedera account '${hederaAccountId}' is associated with the EVM address '${accountInfo.evm_address}' but you tried to associate it with the address '${address}.`,
+        );
+        throw new Error(
+          `The Hedera account '${hederaAccountId}' is associated with the EVM address '${accountInfo.evm_address}' but you tried to associate it with the address '${address}.`,
+        );
+      }
 
       const accountBalance = accountInfo.balance;
       const hbars = accountBalance.balance / 100000000;
@@ -157,13 +446,8 @@ export async function importMetaMaskAccount(
         tokens,
       } as AccountBalance;
 
-      console.log(
-        'created_timestamp: ',
-        accountInfo.created_timestamp,
-        typeof accountInfo.created_timestamp,
-      );
       // eslint-disable-next-line require-atomic-updates
-      state.accountState[metamaskAddress].accountInfo = {
+      state.accountState[connectedAddress].accountInfo = {
         alias: accountInfo.alias,
         createdTime: new Date(
           parseFloat(accountInfo.created_timestamp) * 1000,
@@ -204,29 +488,41 @@ export async function importMetaMaskAccount(
 
   // eslint-disable-next-line require-atomic-updates
   state.currentAccount = {
-    metamaskAddress,
+    metamaskAddress: connectedAddress,
     hederaAccountId,
     hederaEvmAddress: address,
     balance,
     network,
   } as Account;
 
-  await updateSnapState(snap, state);
+  // eslint-disable-next-line require-atomic-updates
+  state.accountState[connectedAddress].keyStore = {
+    curve: curve as 'ECDSA_SECP256K1' | 'ED25519',
+    privateKey,
+    publicKey,
+    address,
+    hederaAccountId,
+  };
+
+  await updateSnapState(state);
 }
 
 /**
  * Create Hedera Client to use for transactions.
  *
+ * @param curve - Curve that was used to derive the keys('ECDSA_SECP256K1' | 'ED25519').
  * @param privateKey - Private key of the account.
  * @param hederaAccountId - Hedera Account ID.
  * @param network - Hedera network.
  */
 export async function createHederaClient(
+  curve: string,
   privateKey: string,
   hederaAccountId: string,
   network: string,
 ): Promise<SimpleHederaClient> {
   const hederaClient = await getHederaClient(
+    curve,
     privateKey,
     hederaAccountId,
     network,
diff --git a/packages/snap/src/snap/dapp.ts b/packages/snap/src/snap/dapp.ts
index a3bcac2..3f3889b 100644
--- a/packages/snap/src/snap/dapp.ts
+++ b/packages/snap/src/snap/dapp.ts
@@ -1,40 +1,28 @@
-import { SnapsGlobalObject } from '@metamask/snaps-types';
-
 import { PulseSnapState } from '../types/state';
 import { updateSnapState } from './state';
 
 /**
  * Function that lets you add a friendly dApp.
  *
- * @param snap - Snap.
  * @param state - PulseSnapState.
  * @param dapp - Dapp.
  */
-export async function addFriendlyDapp(
-  snap: SnapsGlobalObject,
-  state: PulseSnapState,
-  dapp: string,
-) {
+export async function addFriendlyDapp(state: PulseSnapState, dapp: string) {
   state.snapConfig.dApp.friendlyDapps.push(dapp);
-  await updateSnapState(snap, state);
+  await updateSnapState(state);
 }
 
 /**
  * Function that removes a friendly dApp.
  *
- * @param snap - Snap.
  * @param state - PulseSnapState.
  * @param dapp - Dapp.
  */
-export async function removeFriendlyDapp(
-  snap: SnapsGlobalObject,
-  state: PulseSnapState,
-  dapp: string,
-) {
+export async function removeFriendlyDapp(state: PulseSnapState, dapp: string) {
   // FIXME: TEST IF YOU CAN REFERENCE FRIENDLY DAPS
   // let friendlyDapps = state.snapConfig.dApp.friendlyDapps;
   // friendlyDapps = friendlyDapps.filter((app) => app !== dapp);
   state.snapConfig.dApp.friendlyDapps =
     state.snapConfig.dApp.friendlyDapps.filter((app) => app !== dapp);
-  await updateSnapState(snap, state);
+  await updateSnapState(state);
 }
diff --git a/packages/snap/src/snap/dialog.ts b/packages/snap/src/snap/dialog.ts
index d5b06af..f8817d3 100644
--- a/packages/snap/src/snap/dialog.ts
+++ b/packages/snap/src/snap/dialog.ts
@@ -10,7 +10,7 @@ import { updateSnapState } from './state';
  */
 export async function updatePopups(state: PulseSnapState) {
   state.snapConfig.dApp.disablePopups = !state.snapConfig.dApp.disablePopups;
-  await updateSnapState(snap, state);
+  await updateSnapState(state);
 }
 
 /**
diff --git a/packages/snap/src/snap/state.ts b/packages/snap/src/snap/state.ts
index 34fd863..d753b8a 100644
--- a/packages/snap/src/snap/state.ts
+++ b/packages/snap/src/snap/state.ts
@@ -1,5 +1,3 @@
-import { SnapsGlobalObject } from '@metamask/snaps-types';
-
 import _ from 'lodash';
 import { Account } from '../types/account';
 import { PulseSnapState } from '../types/state';
@@ -9,13 +7,9 @@ import { getEmptyAccountState, getInitialSnapState } from '../utils/config';
  * Function for updating PulseSnapState object in the MetaMask state.
  *
  * @public
- * @param snap - Snap.
  * @param snapState - Object to replace the current object in the MetaMask state.
  */
-export async function updateSnapState(
-  snap: SnapsGlobalObject,
-  snapState: PulseSnapState,
-) {
+export async function updateSnapState(snapState: PulseSnapState) {
   await snap.request({
     method: 'snap_manageState',
     params: {
@@ -28,13 +22,10 @@ export async function updateSnapState(
 /**
  * Function to retrieve PulseSnapState object from the MetaMask state.
  *
- * @param snap - Snap.
  * @public
  * @returns Object from the state.
  */
-export async function getSnapState(
-  snap: SnapsGlobalObject,
-): Promise<PulseSnapState> {
+export async function getSnapState(): Promise<PulseSnapState> {
   const state = (await snap.request({
     method: 'snap_manageState',
     params: { operation: 'get' },
@@ -50,13 +41,10 @@ export async function getSnapState(
 /**
  * Function to retrieve PulseSnapState object from the MetaMask state.
  *
- * @param snap - Snap.
  * @public
  * @returns Object from the state.
  */
-export async function getSnapStateUnchecked(
-  snap: SnapsGlobalObject,
-): Promise<PulseSnapState | null> {
+export async function getSnapStateUnchecked(): Promise<PulseSnapState | null> {
   const state = (await snap.request({
     method: 'snap_manageState',
     params: { operation: 'get' },
@@ -68,33 +56,28 @@ export async function getSnapStateUnchecked(
 /**
  * Function to initialize PulseSnapState object.
  *
- * @param snap - Snap.
  * @public
  * @returns Object.
  */
-export async function initSnapState(
-  snap: SnapsGlobalObject,
-): Promise<PulseSnapState> {
+export async function initSnapState(): Promise<PulseSnapState> {
   const state = getInitialSnapState();
-  await updateSnapState(snap, state);
+  await updateSnapState(state);
   return state;
 }
 
 /**
  * Function that creates an empty IdentitySnapState object in the Identity Snap state for the provided address.
  *
- * @param snap - Snap.
  * @param state - PulseSnapState.
  * @param evmAddress - The account address.
  */
 export async function initAccountState(
-  snap: SnapsGlobalObject,
   state: PulseSnapState,
   evmAddress: string,
 ): Promise<void> {
   state.currentAccount = { metamaskAddress: evmAddress } as Account;
   state.accountState[evmAddress] = getEmptyAccountState();
-  await updateSnapState(snap, state);
+  await updateSnapState(state);
 }
 
 /**
@@ -110,9 +93,9 @@ export async function getHederaAccountIdIfExists(
 ): Promise<string> {
   let result = '';
   for (const address of Object.keys(state.accountState)) {
-    const { keyStore, accountId } = state.accountState[address];
+    const { keyStore } = state.accountState[address];
     if (keyStore.address === evmAddress) {
-      result = accountId;
+      result = keyStore.hederaAccountId;
     }
   }
   return result;
diff --git a/packages/snap/src/types/account.ts b/packages/snap/src/types/account.ts
index c1f9478..ee5ce4c 100644
--- a/packages/snap/src/types/account.ts
+++ b/packages/snap/src/types/account.ts
@@ -1,6 +1,12 @@
 import { AccountInfoJson } from '@hashgraph/sdk/lib/account/AccountInfo';
 import { AccountBalance } from '../services/hedera';
 
+export type ExternalAccount = {
+  externalAccount: {
+    accountIdOrEvmAddress: string;
+  };
+};
+
 export type Account = {
   metamaskAddress: string; // This is not being used currently
   hederaAccountId: string;
@@ -16,3 +22,7 @@ export type AccountInfo = {
   balance?: AccountBalance;
   extraData?: AccountInfoJson;
 };
+
+export type NetworkParams = {
+  network: string;
+};
diff --git a/packages/snap/src/types/state.ts b/packages/snap/src/types/state.ts
index 222ce5f..2703e6f 100644
--- a/packages/snap/src/types/state.ts
+++ b/packages/snap/src/types/state.ts
@@ -28,9 +28,11 @@ export type PulseSnapConfig = {
 };
 
 export type KeyStore = {
+  curve: 'ECDSA_SECP256K1' | 'ED25519';
   privateKey: string;
   publicKey: string;
   address: string;
+  hederaAccountId: string;
 };
 
 /**
@@ -38,7 +40,6 @@ export type KeyStore = {
  */
 export type PulseAccountState = {
   keyStore: KeyStore;
-  accountId: string;
   accountInfo: AccountInfo;
 };
 
@@ -52,7 +53,3 @@ export type SnapDialogParams = {
   content: Panel;
   placeholder?: string;
 };
-
-export type HederaAccountParams = {
-  network: string;
-};
diff --git a/packages/snap/src/utils/config.ts b/packages/snap/src/utils/config.ts
index f6d3210..5c3397c 100644
--- a/packages/snap/src/utils/config.ts
+++ b/packages/snap/src/utils/config.ts
@@ -5,11 +5,12 @@ import { KeyStore, PulseAccountState, PulseSnapState } from '../types/state';
 
 const emptyAccountState = {
   keyStore: {
+    curve: 'ECDSA_SECP256K1',
     privateKey: '',
     publicKey: '',
     address: '',
+    hederaAccountId: '',
   } as KeyStore,
-  accountId: '',
   accountInfo: {} as AccountInfo,
 } as PulseAccountState;
 
diff --git a/packages/snap/src/utils/init.ts b/packages/snap/src/utils/init.ts
index 5373d1f..5749db3 100644
--- a/packages/snap/src/utils/init.ts
+++ b/packages/snap/src/utils/init.ts
@@ -1,4 +1,3 @@
-import { SnapsGlobalObject } from '@metamask/snaps-types';
 import { heading, text } from '@metamask/snaps-ui';
 
 import { generateCommonPanel, snapDialog } from '../snap/dialog';
@@ -9,12 +8,8 @@ import { PulseSnapState, SnapDialogParams } from '../types/state';
  * Init snap state.
  *
  * @param origin - Source.
- * @param snap - Snap.
  */
-export async function init(
-  origin: string,
-  snap: SnapsGlobalObject,
-): Promise<PulseSnapState> {
+export async function init(origin: string): Promise<PulseSnapState> {
   const dialogParams: SnapDialogParams = {
     type: 'alert',
     content: await generateCommonPanel(origin, [
@@ -27,5 +22,5 @@ export async function init(
 
   await snapDialog(dialogParams);
   console.log('starting init');
-  return await initSnapState(snap);
+  return await initSnapState();
 }
diff --git a/packages/snap/src/utils/params.ts b/packages/snap/src/utils/params.ts
index a0cd552..db13ff2 100644
--- a/packages/snap/src/utils/params.ts
+++ b/packages/snap/src/utils/params.ts
@@ -1,9 +1,46 @@
 import _ from 'lodash';
+import { ExternalAccount } from '../types/account';
 import {
   GetAccountInfoRequestParams,
   TransferCryptoRequestParams,
 } from '../types/params';
 
+/**
+ * Check whether the the account was imported using private key(external account).
+ *
+ * @param params - Request params.
+ * @returns Whether to treat it as an external account that was imported using private key.
+ */
+export function isExternalAccountFlagSet(params: unknown): boolean {
+  if (
+    params !== null &&
+    typeof params === 'object' &&
+    'externalAccount' in params &&
+    params.externalAccount !== null &&
+    typeof params.externalAccount === 'object'
+  ) {
+    const parameter = params as ExternalAccount;
+
+    if ('accountIdOrEvmAddress' in parameter.externalAccount) {
+      if (
+        parameter.externalAccount.accountIdOrEvmAddress !== null &&
+        typeof parameter.externalAccount.accountIdOrEvmAddress === 'string'
+      ) {
+        if (_.isEmpty(parameter.externalAccount.accountIdOrEvmAddress)) {
+          console.error(
+            'Invalid externalAccount Params passed. "accountIdOrEvmAddress" must not be empty',
+          );
+          throw new Error(
+            'Invalid externalAccount Params passed. "accountIdOrEvmAddress" must not be empty',
+          );
+        }
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 /**
  * Check Validation of getAccountInfo request.
  *