diff --git a/packages/get-starknet/webpack.config.local.js b/packages/get-starknet/webpack.config.local.js
index ce25a4b7..9c847444 100644
--- a/packages/get-starknet/webpack.config.local.js
+++ b/packages/get-starknet/webpack.config.local.js
@@ -1,7 +1,11 @@
 // eslint-disable-next-line @typescript-eslint/no-var-requires
+const { merge } = require('webpack-merge');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const common = require('./webpack.common.js');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const path = require('path');
 
-module.exports = {
+module.exports = (env) => merge(common, {
   mode: 'development',
   output: {
     publicPath: process.env.GET_STARKNET_PUBLIC_PATH ?? 'http://localhost:8082/', // Adjust the development publicPath as needed
@@ -11,4 +15,4 @@ module.exports = {
     compress: true,
     port: 8082,
   }
-};
+});
diff --git a/packages/starknet-snap/snap.manifest.json b/packages/starknet-snap/snap.manifest.json
index 170837ee..13827448 100644
--- a/packages/starknet-snap/snap.manifest.json
+++ b/packages/starknet-snap/snap.manifest.json
@@ -7,7 +7,7 @@
     "url": "https://github.com/ConsenSys/starknet-snap.git"
   },
   "source": {
-    "shasum": "kl5iM2GRyXtFYwezb2vvrh2iTNC4Gw4K1I3PVOttXJ4=",
+    "shasum": "w/9IComQVArE5jU1RHIW8Y5CnN//nBoHKBQDFRhM8yI=",
     "location": {
       "npm": {
         "filePath": "dist/bundle.js",
diff --git a/packages/starknet-snap/src/declareContract.ts b/packages/starknet-snap/src/declareContract.ts
index eb17dbaf..c935e899 100644
--- a/packages/starknet-snap/src/declareContract.ts
+++ b/packages/starknet-snap/src/declareContract.ts
@@ -1,7 +1,7 @@
 import { toJson } from './utils/serializer';
 import { ApiParams, DeclareContractRequestParams } from './types/snapApi';
-import { getNetworkFromChainId, getDeclareSnapTxt } from './utils/snapUtils';
-import { getKeysFromAddress, declareContract as declareContractUtil } from './utils/starknetUtils';
+import { getNetworkFromChainId, getDeclareSnapTxt, showUpgradeRequestModal } from './utils/snapUtils';
+import { getKeysFromAddress, declareContract as declareContractUtil, isUpgradeRequired } from './utils/starknetUtils';
 import { DialogType } from '@metamask/rpc-methods';
 import { heading, panel } from '@metamask/snaps-sdk';
 import { logger } from './utils/logger';
@@ -17,6 +17,11 @@ export async function declareContract(params: ApiParams) {
     const network = getNetworkFromChainId(state, requestParamsObj.chainId);
     const { privateKey } = await getKeysFromAddress(keyDeriver, network, state, senderAddress);
 
+    if (await isUpgradeRequired(network, senderAddress)) {
+      await showUpgradeRequestModal(wallet);
+      throw new Error('Upgrade required');
+    }
+
     const snapComponents = getDeclareSnapTxt(
       senderAddress,
       network,
diff --git a/packages/starknet-snap/src/executeTxn.ts b/packages/starknet-snap/src/executeTxn.ts
index 6b52c5a6..8a4da29b 100644
--- a/packages/starknet-snap/src/executeTxn.ts
+++ b/packages/starknet-snap/src/executeTxn.ts
@@ -1,5 +1,5 @@
 import { Invocations, TransactionType } from 'starknet';
-import { getNetworkFromChainId, getTxnSnapTxt, addDialogTxt } from './utils/snapUtils';
+import { getNetworkFromChainId, getTxnSnapTxt, addDialogTxt, showUpgradeRequestModal } from './utils/snapUtils';
 import {
   getKeysFromAddress,
   executeTxn as executeTxnUtil,
@@ -7,13 +7,14 @@ import {
   estimateFeeBulk,
   getAccContractAddressAndCallData,
   addFeesFromAllTransactions,
+  isUpgradeRequired,
 } from './utils/starknetUtils';
 import { ApiParams, ExecuteTxnRequestParams } from './types/snapApi';
 import { createAccount } from './createAccount';
 import { DialogType } from '@metamask/rpc-methods';
 import { heading, panel, divider } from '@metamask/snaps-sdk';
 import { logger } from './utils/logger';
-import { PROXY_CONTRACT_HASH } from './utils/constants';
+import { ACCOUNT_CLASS_HASH } from './utils/constants';
 
 export async function executeTxn(params: ApiParams) {
   try {
@@ -27,6 +28,11 @@ export async function executeTxn(params: ApiParams) {
       addressIndex,
     } = await getKeysFromAddress(keyDeriver, network, state, senderAddress);
 
+    if (await isUpgradeRequired(network, senderAddress)) {
+      await showUpgradeRequestModal(wallet);
+      throw new Error('Upgrade required');
+    }
+
     const txnInvocationArray = Array.isArray(requestParamsObj.txnInvocation)
       ? requestParamsObj.txnInvocation
       : [requestParamsObj.txnInvocation];
@@ -34,11 +40,11 @@ export async function executeTxn(params: ApiParams) {
       type: TransactionType.INVOKE,
       payload: ele,
     }));
-    const accountDeployed = await isAccountDeployed(network, publicKey);
+    const accountDeployed = await isAccountDeployed(network, senderAddress);
     if (!accountDeployed) {
       const { callData } = getAccContractAddressAndCallData(publicKey);
       const deployAccountpayload = {
-        classHash: PROXY_CONTRACT_HASH,
+        classHash: ACCOUNT_CLASS_HASH,
         contractAddress: senderAddress,
         constructorCalldata: callData,
         addressSalt: publicKey,
diff --git a/packages/starknet-snap/src/signDeclareTransaction.ts b/packages/starknet-snap/src/signDeclareTransaction.ts
index 808b3fca..37bb6ec0 100644
--- a/packages/starknet-snap/src/signDeclareTransaction.ts
+++ b/packages/starknet-snap/src/signDeclareTransaction.ts
@@ -1,8 +1,12 @@
 import { toJson } from './utils/serializer';
 import { Signature } from 'starknet';
 import { ApiParams, SignDeclareTransactionRequestParams } from './types/snapApi';
-import { getKeysFromAddress, signDeclareTransaction as signDeclareTransactionUtil } from './utils/starknetUtils';
-import { getNetworkFromChainId, getSignTxnTxt } from './utils/snapUtils';
+import {
+  getKeysFromAddress,
+  signDeclareTransaction as signDeclareTransactionUtil,
+  isUpgradeRequired,
+} from './utils/starknetUtils';
+import { getNetworkFromChainId, getSignTxnTxt, showUpgradeRequestModal } from './utils/snapUtils';
 import { DialogType } from '@metamask/rpc-methods';
 import { heading, panel } from '@metamask/snaps-sdk';
 import { logger } from './utils/logger';
@@ -15,6 +19,11 @@ export async function signDeclareTransaction(params: ApiParams): Promise<Signatu
     const network = getNetworkFromChainId(state, requestParamsObj.chainId);
     const { privateKey } = await getKeysFromAddress(keyDeriver, network, state, signerAddress);
 
+    if (await isUpgradeRequired(network, signerAddress)) {
+      await showUpgradeRequestModal(wallet);
+      throw new Error('Upgrade required');
+    }
+
     logger.log(`signDeclareTransaction params: ${toJson(requestParamsObj.transaction, 2)}}`);
 
     const snapComponents = getSignTxnTxt(signerAddress, network, requestParamsObj.transaction);
diff --git a/packages/starknet-snap/src/signDeployAccountTransaction.ts b/packages/starknet-snap/src/signDeployAccountTransaction.ts
index c861f94c..5ae8ebf2 100644
--- a/packages/starknet-snap/src/signDeployAccountTransaction.ts
+++ b/packages/starknet-snap/src/signDeployAccountTransaction.ts
@@ -4,8 +4,9 @@ import { ApiParams, SignDeployAccountTransactionRequestParams } from './types/sn
 import {
   getKeysFromAddress,
   signDeployAccountTransaction as signDeployAccountTransactionUtil,
+  isUpgradeRequired,
 } from './utils/starknetUtils';
-import { getNetworkFromChainId, getSignTxnTxt } from './utils/snapUtils';
+import { getNetworkFromChainId, getSignTxnTxt, showUpgradeRequestModal } from './utils/snapUtils';
 import { DialogType } from '@metamask/rpc-methods';
 import { heading, panel } from '@metamask/snaps-sdk';
 import { logger } from '../src/utils/logger';
@@ -18,6 +19,11 @@ export async function signDeployAccountTransaction(params: ApiParams): Promise<S
     const network = getNetworkFromChainId(state, requestParamsObj.chainId);
     const { privateKey } = await getKeysFromAddress(keyDeriver, network, state, signerAddress);
 
+    if (await isUpgradeRequired(network, signerAddress)) {
+      await showUpgradeRequestModal(wallet);
+      throw new Error('Upgrade required');
+    }
+
     logger.log(`signDeployAccountTransaction params: ${toJson(requestParamsObj.transaction, 2)}}`);
 
     const snapComponents = getSignTxnTxt(signerAddress, network, requestParamsObj.transaction);
diff --git a/packages/starknet-snap/src/signMessage.ts b/packages/starknet-snap/src/signMessage.ts
index d4693f2c..0765a4a1 100644
--- a/packages/starknet-snap/src/signMessage.ts
+++ b/packages/starknet-snap/src/signMessage.ts
@@ -1,8 +1,12 @@
 import { toJson } from './utils/serializer';
-import { signMessage as signMessageUtil, getKeysFromAddress, isUpgradeRequired } from './utils/starknetUtils';
-import { getNetworkFromChainId, addDialogTxt } from './utils/snapUtils';
+import {
+  signMessage as signMessageUtil,
+  getKeysFromAddress,
+  isUpgradeRequired,
+  validateAndParseAddress,
+} from './utils/starknetUtils';
+import { getNetworkFromChainId, addDialogTxt, showUpgradeRequestModal } from './utils/snapUtils';
 import { ApiParams, SignMessageRequestParams } from './types/snapApi';
-import { validateAndParseAddress } from '../src/utils/starknetUtils';
 import { DialogType } from '@metamask/rpc-methods';
 import { heading, panel } from '@metamask/snaps-sdk';
 import { logger } from './utils/logger';
@@ -15,6 +19,11 @@ export async function signMessage(params: ApiParams) {
     const typedDataMessage = requestParamsObj.typedDataMessage;
     const network = getNetworkFromChainId(state, requestParamsObj.chainId);
 
+    if (await isUpgradeRequired(network, signerAddress)) {
+      await showUpgradeRequestModal(wallet);
+      throw new Error('Upgrade required');
+    }
+
     logger.log(`signMessage:\nsignerAddress: ${signerAddress}\ntypedDataMessage: ${toJson(typedDataMessage)}`);
 
     if (!signerAddress) {
diff --git a/packages/starknet-snap/src/signTransaction.ts b/packages/starknet-snap/src/signTransaction.ts
index cd8c6434..cc1b9a6b 100644
--- a/packages/starknet-snap/src/signTransaction.ts
+++ b/packages/starknet-snap/src/signTransaction.ts
@@ -1,8 +1,8 @@
 import { toJson } from './utils/serializer';
 import { Signature } from 'starknet';
 import { ApiParams, SignTransactionRequestParams } from './types/snapApi';
-import { getKeysFromAddress, signTransactions } from './utils/starknetUtils';
-import { getNetworkFromChainId, getSignTxnTxt } from './utils/snapUtils';
+import { getKeysFromAddress, signTransactions, isUpgradeRequired } from './utils/starknetUtils';
+import { getNetworkFromChainId, getSignTxnTxt, showUpgradeRequestModal } from './utils/snapUtils';
 import { DialogType } from '@metamask/rpc-methods';
 import { heading, panel } from '@metamask/snaps-sdk';
 import { logger } from '../src/utils/logger';
@@ -15,6 +15,11 @@ export async function signTransaction(params: ApiParams): Promise<Signature | bo
     const network = getNetworkFromChainId(state, requestParamsObj.chainId);
     const { privateKey } = await getKeysFromAddress(keyDeriver, network, state, signerAddress);
 
+    if (await isUpgradeRequired(network, signerAddress)) {
+      await showUpgradeRequestModal(wallet);
+      throw new Error('Upgrade required');
+    }
+
     logger.log(`signTransaction params: ${toJson(requestParamsObj.transactions, 2)}}`);
 
     const snapComponents = getSignTxnTxt(signerAddress, network, requestParamsObj.transactions);
diff --git a/packages/starknet-snap/src/utils/snapUtils.ts b/packages/starknet-snap/src/utils/snapUtils.ts
index f0c63ae5..ebb0748c 100644
--- a/packages/starknet-snap/src/utils/snapUtils.ts
+++ b/packages/starknet-snap/src/utils/snapUtils.ts
@@ -11,7 +11,7 @@ import {
   constants,
 } from 'starknet';
 import { validateAndParseAddress } from './starknetUtils';
-import { Component, text, copyable } from '@metamask/snaps-sdk';
+import { Component, text, copyable, panel, heading } from '@metamask/snaps-sdk';
 import {
   Network,
   Erc20Token,
@@ -42,6 +42,7 @@ import {
   ChainIdFilter,
 } from './transaction/filter';
 import { logger } from './logger';
+import { DialogType } from '@metamask/rpc-methods';
 
 function hasOnlyAsciiChars(str: string) {
   return /^[ -~]+$/.test(str);
@@ -757,3 +758,18 @@ export function dappUrl(envt: string) {
       return DAPP.prod;
   }
 }
+
+export async function showUpgradeRequestModal(wallet) {
+  await wallet.request({
+    method: 'snap_dialog',
+    params: {
+      type: DialogType.Alert,
+      content: panel([
+        heading('Account Upgrade Mandatory!'),
+        text(
+          `Visit the [companion dapp for Starknet](${dappUrl(process.env.SNAP_ENV)}) and click “Upgrade”.\nThank you!`,
+        ),
+      ]),
+    },
+  });
+}
diff --git a/packages/starknet-snap/test/src/declareContract.test.ts b/packages/starknet-snap/test/src/declareContract.test.ts
index 385e55e1..45c440e9 100644
--- a/packages/starknet-snap/test/src/declareContract.test.ts
+++ b/packages/starknet-snap/test/src/declareContract.test.ts
@@ -3,6 +3,7 @@ import sinon from 'sinon';
 import sinonChai from 'sinon-chai';
 import { WalletMock } from '../wallet.mock.test';
 import * as utils from '../../src/utils/starknetUtils';
+import * as snapsUtil from '../../src/utils/snapUtils';
 import { declareContract } from '../../src/declareContract';
 import { SnapState } from '../../src/types/snapState';
 import { STARKNET_MAINNET_NETWORK, STARKNET_SEPOLIA_TESTNET_NETWORK } from '../../src/utils/constants';
@@ -55,7 +56,23 @@ describe('Test function: declareContract', function () {
     sandbox.restore();
   });
 
+  it('should 1) throw an error and 2) show upgrade modal if account deployed required', async function () {
+    const isUpgradeRequiredStub = sandbox.stub(utils, 'isUpgradeRequired').resolves(true);
+    const showUpgradeRequestModalStub = sandbox.stub(snapsUtil, 'showUpgradeRequestModal').resolves();
+    let result;
+    try {
+      result = await declareContract(apiParams);
+    } catch (err) {
+      result = err;
+    } finally {
+      expect(isUpgradeRequiredStub).to.have.been.calledOnceWith(STARKNET_SEPOLIA_TESTNET_NETWORK, account1.address);
+      expect(showUpgradeRequestModalStub).to.have.been.calledOnce;
+      expect(result).to.be.an('Error');
+    }
+  });
+
   it('should declareContract correctly', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const declareContractStub = sandbox.stub(utils, 'declareContract').resolves({
       transaction_hash: 'transaction_hash',
       class_hash: 'class_hash',
@@ -83,6 +100,7 @@ describe('Test function: declareContract', function () {
   });
 
   it('should throw error if declareContract fail', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const declareContractStub = sandbox.stub(utils, 'declareContract').rejects('error');
     const { privateKey } = await utils.getKeysFromAddress(
       apiParams.keyDeriver,
@@ -109,6 +127,7 @@ describe('Test function: declareContract', function () {
   });
 
   it('should return false if user rejected to sign the transaction', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     walletStub.rpcStubs.snap_dialog.resolves(false);
     const declareContractStub = sandbox.stub(utils, 'declareContract').resolves({
       transaction_hash: 'transaction_hash',
diff --git a/packages/starknet-snap/test/src/executeTxn.test.ts b/packages/starknet-snap/test/src/executeTxn.test.ts
index 667c0eab..b01b2afc 100644
--- a/packages/starknet-snap/test/src/executeTxn.test.ts
+++ b/packages/starknet-snap/test/src/executeTxn.test.ts
@@ -14,6 +14,7 @@ import {
   estimateFeeResp,
 } from '../constants.test';
 import * as createAccountUtils from '../../src/createAccount';
+import * as snapsUtil from '../../src/utils/snapUtils';
 import { getAddressKeyDeriver } from '../../src/utils/keyPair';
 import { Mutex } from 'async-mutex';
 import { ApiParams, ExecuteTxnRequestParams } from '../../src/types/snapApi';
@@ -79,7 +80,23 @@ describe('Test function: executeTxn', function () {
     apiParams.requestParams = requestObject;
   });
 
+  it('should 1) throw an error and 2) show upgrade modal if account deployed required', async function () {
+    const isUpgradeRequiredStub = sandbox.stub(utils, 'isUpgradeRequired').resolves(true);
+    const showUpgradeRequestModalStub = sandbox.stub(snapsUtil, 'showUpgradeRequestModal').resolves();
+    let result;
+    try {
+      result = await executeTxn(apiParams);
+    } catch (err) {
+      result = err;
+    } finally {
+      expect(isUpgradeRequiredStub).to.have.been.calledOnceWith(STARKNET_MAINNET_NETWORK, account1.address);
+      expect(showUpgradeRequestModalStub).to.have.been.calledOnce;
+      expect(result).to.be.an('Error');
+    }
+  });
+
   it('should executeTxn correctly and deploy an account', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'isAccountDeployed').resolves(false);
     const createAccountStub = sandbox.stub(createAccountUtils, 'createAccount').resolvesThis();
     const stub = sandbox.stub(utils, 'executeTxn').resolves({
@@ -111,6 +128,7 @@ describe('Test function: executeTxn', function () {
   });
 
   it('should executeTxn multiple and deploy an account', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'isAccountDeployed').resolves(false);
     const createAccountStub = sandbox.stub(createAccountUtils, 'createAccount').resolvesThis();
     const stub = sandbox.stub(utils, 'executeTxn').resolves({
@@ -171,6 +189,7 @@ describe('Test function: executeTxn', function () {
 
   it('should executeTxn and not deploy an account', async function () {
     const createAccountStub = sandbox.stub(createAccountUtils, 'createAccount');
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'isAccountDeployed').resolves(true);
     const stub = sandbox.stub(utils, 'executeTxn').resolves({
       transaction_hash: 'transaction_hash',
@@ -204,6 +223,7 @@ describe('Test function: executeTxn', function () {
 
   it('should executeTxn multiple and not deploy an account', async function () {
     const createAccountStub = sandbox.stub(createAccountUtils, 'createAccount');
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'isAccountDeployed').resolves(true);
     const stub = sandbox.stub(utils, 'executeTxn').resolves({
       transaction_hash: 'transaction_hash',
@@ -262,6 +282,7 @@ describe('Test function: executeTxn', function () {
   });
 
   it('should throw error if executeTxn fail', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'isAccountDeployed').resolves(true);
     const stub = sandbox.stub(utils, 'executeTxn').rejects('error');
     const { privateKey } = await utils.getKeysFromAddress(
@@ -295,6 +316,7 @@ describe('Test function: executeTxn', function () {
 
   it('should return false if user rejected to sign the transaction', async function () {
     sandbox.stub(utils, 'isAccountDeployed').resolves(true);
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     walletStub.rpcStubs.snap_dialog.resolves(false);
     const stub = sandbox.stub(utils, 'executeTxn').resolves({
       transaction_hash: 'transaction_hash',
diff --git a/packages/starknet-snap/test/src/signDeclareTransaction.test.ts b/packages/starknet-snap/test/src/signDeclareTransaction.test.ts
index 3274ae17..c15d43bd 100644
--- a/packages/starknet-snap/test/src/signDeclareTransaction.test.ts
+++ b/packages/starknet-snap/test/src/signDeclareTransaction.test.ts
@@ -11,6 +11,7 @@ import { Mutex } from 'async-mutex';
 import { ApiParams, SignDeclareTransactionRequestParams } from '../../src/types/snapApi';
 import { DeclareSignerDetails, constants } from 'starknet';
 import * as utils from '../../src/utils/starknetUtils';
+import * as snapsUtil from '../../src/utils/snapUtils';
 
 chai.use(sinonChai);
 const sandbox = sinon.createSandbox();
@@ -63,13 +64,30 @@ describe('Test function: signDeclareTransaction', function () {
   });
 
   it('should sign a transaction from an user account correctly', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeclareTransaction').resolves(signature3);
     const result = await signDeclareTransaction(apiParams);
     expect(walletStub.rpcStubs.snap_dialog).to.have.been.calledOnce;
     expect(result).to.be.eql(signature3);
   });
 
+  it('should 1) throw an error and 2) show upgrade modal if account deployed required', async function () {
+    const isUpgradeRequiredStub = sandbox.stub(utils, 'isUpgradeRequired').resolves(true);
+    const showUpgradeRequestModalStub = sandbox.stub(snapsUtil, 'showUpgradeRequestModal').resolves();
+    let result;
+    try {
+      result = await signDeclareTransaction(apiParams);
+    } catch (err) {
+      result = err;
+    } finally {
+      expect(isUpgradeRequiredStub).to.have.been.calledOnceWith(STARKNET_SEPOLIA_TESTNET_NETWORK, account1.address);
+      expect(showUpgradeRequestModalStub).to.have.been.calledOnce;
+      expect(result).to.be.an('Error');
+    }
+  });
+
   it('should throw error if signDeclareTransaction fail', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeclareTransaction').throws(new Error());
     let result;
     try {
@@ -83,6 +101,7 @@ describe('Test function: signDeclareTransaction', function () {
   });
 
   it('should return false if user deny to sign the transaction', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const stub = sandbox.stub(utils, 'signDeclareTransaction');
     walletStub.rpcStubs.snap_dialog.resolves(false);
 
@@ -93,6 +112,7 @@ describe('Test function: signDeclareTransaction', function () {
   });
 
   it('should skip dialog if enableAuthorize is false', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeclareTransaction').resolves(signature3);
     const paramsObject = apiParams.requestParams as SignDeclareTransactionRequestParams;
     paramsObject.enableAuthorize = false;
@@ -103,6 +123,7 @@ describe('Test function: signDeclareTransaction', function () {
   });
 
   it('should skip dialog if enableAuthorize is omit', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeclareTransaction').resolves(signature3);
     const paramsObject = apiParams.requestParams as SignDeclareTransactionRequestParams;
     paramsObject.enableAuthorize = undefined;
diff --git a/packages/starknet-snap/test/src/signDeployAccountTransaction.test.ts b/packages/starknet-snap/test/src/signDeployAccountTransaction.test.ts
index e8de8315..f290bc80 100644
--- a/packages/starknet-snap/test/src/signDeployAccountTransaction.test.ts
+++ b/packages/starknet-snap/test/src/signDeployAccountTransaction.test.ts
@@ -11,6 +11,7 @@ import { Mutex } from 'async-mutex';
 import { ApiParams, SignDeployAccountTransactionRequestParams } from '../../src/types/snapApi';
 import { DeployAccountSignerDetails, constants } from 'starknet';
 import * as utils from '../../src/utils/starknetUtils';
+import * as snapsUtil from '../../src/utils/snapUtils';
 
 chai.use(sinonChai);
 const sandbox = sinon.createSandbox();
@@ -65,13 +66,30 @@ describe('Test function: signDeployAccountTransaction', function () {
   });
 
   it('should sign a transaction from an user account correctly', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeployAccountTransaction').resolves(signature3);
     const result = await signDeployAccountTransaction(apiParams);
     expect(walletStub.rpcStubs.snap_dialog).to.have.been.calledOnce;
     expect(result).to.be.eql(signature3);
   });
 
+  it('should 1) throw an error and 2) show upgrade modal if account deployed required', async function () {
+    const isUpgradeRequiredStub = sandbox.stub(utils, 'isUpgradeRequired').resolves(true);
+    const showUpgradeRequestModalStub = sandbox.stub(snapsUtil, 'showUpgradeRequestModal').resolves();
+    let result;
+    try {
+      result = await signDeployAccountTransaction(apiParams);
+    } catch (err) {
+      result = err;
+    } finally {
+      expect(isUpgradeRequiredStub).to.have.been.calledOnceWith(STARKNET_SEPOLIA_TESTNET_NETWORK, account1.address);
+      expect(showUpgradeRequestModalStub).to.have.been.calledOnce;
+      expect(result).to.be.an('Error');
+    }
+  });
+
   it('should throw error if signDeployAccountTransaction fail', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeployAccountTransaction').throws(new Error());
     let result;
     try {
@@ -85,6 +103,7 @@ describe('Test function: signDeployAccountTransaction', function () {
   });
 
   it('should return false if user deny to sign the transaction', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const stub = sandbox.stub(utils, 'signDeployAccountTransaction');
     walletStub.rpcStubs.snap_dialog.resolves(false);
 
@@ -95,6 +114,7 @@ describe('Test function: signDeployAccountTransaction', function () {
   });
 
   it('should skip dialog if enableAuthorize is false', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeployAccountTransaction').resolves(signature3);
     const paramsObject = apiParams.requestParams as SignDeployAccountTransactionRequestParams;
     paramsObject.enableAuthorize = false;
@@ -105,6 +125,7 @@ describe('Test function: signDeployAccountTransaction', function () {
   });
 
   it('should skip dialog if enableAuthorize is omit', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signDeployAccountTransaction').resolves(signature3);
     const paramsObject = apiParams.requestParams as SignDeployAccountTransactionRequestParams;
     paramsObject.enableAuthorize = undefined;
diff --git a/packages/starknet-snap/test/src/signTransaction.test.ts b/packages/starknet-snap/test/src/signTransaction.test.ts
index 76a7883d..faecfd03 100644
--- a/packages/starknet-snap/test/src/signTransaction.test.ts
+++ b/packages/starknet-snap/test/src/signTransaction.test.ts
@@ -11,6 +11,7 @@ import { Mutex } from 'async-mutex';
 import { ApiParams, SignTransactionRequestParams } from '../../src/types/snapApi';
 import { constants } from 'starknet';
 import * as utils from '../../src/utils/starknetUtils';
+import * as snapsUtil from '../../src/utils/snapUtils';
 
 chai.use(sinonChai);
 const sandbox = sinon.createSandbox();
@@ -73,12 +74,29 @@ describe('Test function: signMessage', function () {
   });
 
   it('should sign a transaction from an user account correctly', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const result = await signTransaction(apiParams);
     expect(walletStub.rpcStubs.snap_dialog).to.have.been.calledOnce;
     expect(result).to.be.eql(signature3);
   });
 
+  it('should 1) throw an error and 2) show upgrade modal if account deployed required', async function () {
+    const isUpgradeRequiredStub = sandbox.stub(utils, 'isUpgradeRequired').resolves(true);
+    const showUpgradeRequestModalStub = sandbox.stub(snapsUtil, 'showUpgradeRequestModal').resolves();
+    let result;
+    try {
+      result = await signTransaction(apiParams);
+    } catch (err) {
+      result = err;
+    } finally {
+      expect(isUpgradeRequiredStub).to.have.been.calledOnceWith(STARKNET_SEPOLIA_TESTNET_NETWORK, account1.address);
+      expect(showUpgradeRequestModalStub).to.have.been.calledOnce;
+      expect(result).to.be.an('Error');
+    }
+  });
+
   it('should throw error if signTransaction fail', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     sandbox.stub(utils, 'signTransactions').throws(new Error());
     let result;
     try {
@@ -92,6 +110,7 @@ describe('Test function: signMessage', function () {
   });
 
   it('should return false if user deny to sign the transaction', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const stub = sandbox.stub(utils, 'signTransactions');
     walletStub.rpcStubs.snap_dialog.resolves(false);
 
@@ -102,6 +121,7 @@ describe('Test function: signMessage', function () {
   });
 
   it('should skip dialog if enableAuthorize is false', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const paramsObject = apiParams.requestParams as SignTransactionRequestParams;
     paramsObject.enableAuthorize = false;
     const result = await signTransaction(apiParams);
@@ -111,6 +131,7 @@ describe('Test function: signMessage', function () {
   });
 
   it('should skip dialog if enableAuthorize is omit', async function () {
+    sandbox.stub(utils, 'isUpgradeRequired').resolves(false);
     const paramsObject = apiParams.requestParams as SignTransactionRequestParams;
     paramsObject.enableAuthorize = undefined;
     const result = await signTransaction(apiParams);
diff --git a/yarn.lock b/yarn.lock
index fe09fb61..71c7c3e1 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3247,7 +3247,7 @@ __metadata:
 
 "@consensys/starknet-snap@file:../starknet-snap::locator=wallet-ui%40workspace%3Apackages%2Fwallet-ui":
   version: 2.7.0
-  resolution: "@consensys/starknet-snap@file:../starknet-snap#../starknet-snap::hash=66cf07&locator=wallet-ui%40workspace%3Apackages%2Fwallet-ui"
+  resolution: "@consensys/starknet-snap@file:../starknet-snap#../starknet-snap::hash=64cb92&locator=wallet-ui%40workspace%3Apackages%2Fwallet-ui"
   dependencies:
     "@metamask/snaps-sdk": 3.0.1
     async-mutex: ^0.3.2
@@ -3256,7 +3256,7 @@ __metadata:
     ethers: ^5.5.1
     starknet: 6.7.0
     starknet_v4.22.0: "npm:starknet@4.22.0"
-  checksum: db7248bd426721c92ab82206f5cb9cc39f3b7edaaa4ffd26e03a26ef847b670767a06e3fc18d4572807118aa8b65422d0531853256b92d107179a4e1a9951fb3
+  checksum: 12c71045fd6bd5d137d51a9fb9a92b3aae206b7b1b1a036bd8fe4ddbf953d94967be56ecb170c4e871a30fa065ba64571dca714180522b89b5a9bf4cc6476b41
   languageName: node
   linkType: hard