diff --git a/README.md b/README.md
index 97dd2784e..ee3640cb6 100644
--- a/README.md
+++ b/README.md
@@ -18,13 +18,13 @@ Catalogue of various wallet and dapp examples implementing WalletConnect's **SDK
 
 **Wallets:**
 
-- [React Wallet (Sign v1 + v2)](https://github.com/WalletConnect/web-examples/tree/main/advanced/wallets/react-wallet-v2) ([Demo](https://react-wallet.walletconnect.com/))
 
 **dApps:**
 
 - [React dApp (with standalone client) - v2](https://github.com/WalletConnect/web-examples/tree/main/advanced/dapps/react-dapp-v2) ([Demo](https://react-app.walletconnect.com/))
 - [React dApp (with EthereumProvider + Ethers.js) - v2](https://github.com/WalletConnect/web-examples/tree/main/advanced/dapps/react-dapp-v2-with-ethers) ([Demo](https://react-dapp-v2-with-ethers.vercel.app/))
 - [React dApp (with EthereumProvider + web3.js) - v2](https://github.com/WalletConnect/web-examples/tree/main/advanced/dapps/react-dapp-v2-with-web3js) ([Demo](https://react-dapp-v2-with-web3js.vercel.app/))
+- [React dApp (with TezosProvider) - v2](https://github.com/WalletConnect/web-examples/tree/main/dapps/tezos-provider)
 
 ### Auth API
 
diff --git a/advanced/wallets/react-wallet-v2/src/lib/TezosLib.ts b/advanced/wallets/react-wallet-v2/src/lib/TezosLib.ts
index be9835c89..d578e4529 100644
--- a/advanced/wallets/react-wallet-v2/src/lib/TezosLib.ts
+++ b/advanced/wallets/react-wallet-v2/src/lib/TezosLib.ts
@@ -153,7 +153,7 @@ export default class TezosLib {
           message: op.message,
         };
       case TezosOperationType.SMART_ROLLUP_ORIGINATE:
-        if (!(op.pvm_kind in PvmKind)) {
+        if (!Object.values(PvmKind).includes(op.pvm_kind)) {
           throw new Error(`Invalid PvmKind: ${op.pvm_kind}`);
         }
         return {
diff --git a/dapps/tezos-provider/src/App.tsx b/dapps/tezos-provider/src/App.tsx
index 4f9f7c94d..5b93dd340 100644
--- a/dapps/tezos-provider/src/App.tsx
+++ b/dapps/tezos-provider/src/App.tsx
@@ -1,8 +1,7 @@
 import { WalletConnectModal } from "@walletconnect/modal";
 import { useState } from "react";
-import { TEZOS_ACTIONS, DEFAULT_TEZOS_METHODS } from "./utils/samples";
+import { SAMPLES, SAMPLE_KINDS } from "./utils/samples";
 import TezosProvider, { formatTezosBalance, getChainId, TezosChainDataMainnet, TezosChainDataTestnet } from "./utils/tezos-provider";
-import { PartialTezosTransactionOperation, TezosBallotOperation } from "@airgap/beacon-types";
 
 const projectId = import.meta.env.VITE_PROJECT_ID;
 
@@ -25,38 +24,49 @@ const provider: TezosProvider = await TezosProvider.init({
 
 const App = () => {
   const [isConnected, setIsConnected] = useState(false);
+  const [lastKind, setLastKind] = useState<any>(null);
   const [result, setResult] = useState<any>(null);
   const [description, setDescription] = useState<any>(null);
   const [contractAddress, setContractAddress] = useState("");
   const [balance, setBalance] = useState("");
 
-  console.log("Provider", provider);
-
   // 3. handle display_uri event and open modal
-  if (provider.signer) {
-    provider.signer.on("display_uri", async (uri: string) => {
-      console.log("event display_uri", uri);
-      await modal.openModal({
-        uri,
+  const subscribe = async () => {
+    if (provider.signer) {
+      console.log("Subscribing to events...");
+      provider.signer.on("display_uri", async (uri: string) => {
+        console.log("event display_uri", uri);
+        await modal.openModal({
+          uri,
+        });
       });
-    });
 
-    provider.signer.on("session_ping", ({ id, topic }: { id: string; topic: string }) => {
-      console.log("Session Ping:", id, topic);
-    });
+      provider.signer.on("session_ping", ({ id, topic }: { id: string; topic: string }) => {
+        console.log("Event session_ping:", id, topic);
+      });
 
-    provider.signer.on("session_event", ({ event, chainId }: { event: any; chainId: string }) => {
-      console.log("Session Event:", event, chainId);
-    });
+      provider.signer.on("session_event", ({ event, chainId }: { event: any; chainId: string }) => {
+        console.log("Event session_event:", event, chainId);
+      });
 
-    provider.signer.on("session_update", ({ topic, params }: { topic: string; params: any }) => {
-      console.log("Session Update:", topic, params);
-    });
+      provider.signer.on("session_update", ({ topic, params }: { topic: string; params: any }) => {
+        console.log("Event session_update:", topic, params);
+      });
 
-    provider.signer.on("session_delete", ({ id, topic }: { id: string; topic: string }) => {
-      console.log("Session Delete:", id, topic);
-    });
-  }
+      provider.signer.on("session_delete", ({ id, topic }: { id: string; topic: string }) => {
+        console.log("Event session_delete:", id, topic);
+      });
+
+      provider.signer.on("connect", ({ id, topic }: { id: string; topic: string }) => {
+        console.log("Event connect:", id, topic);
+      });
+
+      provider.signer.on("disconnect", ({ id, topic }: { id: string; topic: string }) => {
+        console.log("Event disconnect:", id, topic);
+        setIsConnected(false);
+      });
+    }
+  };
 
   const getBalance = async () => {
     if (provider) {
@@ -67,7 +77,10 @@ const App = () => {
 
   // 4. handle connect event
   const connect = async () => {
+    window.localStorage.removeItem('walletconnect');
+    console.log("Connecting...");
     try {
+      await subscribe();
       await provider.connect({chains: [TezosChainDataTestnet, TezosChainDataMainnet]});
       setIsConnected(true);
       console.log("Connected successfully. Provider", provider);
@@ -82,37 +95,42 @@ const App = () => {
 
   // 5. handle disconnect event
   const disconnect = async () => {
+    console.log("Disconnecting...");
     if (provider.signer) {
       await provider.signer.disconnect();
     }
+    window.localStorage.removeItem('walletconnect');
     setIsConnected(false);
     setResult(null); // Clear result on disconnect
   };
 
   // 6. handle operations
-  const handleOp = async (method: string) => {
+  const handleOp = async (kind: SAMPLE_KINDS) => {
     if (!provider) return;
 
+    setLastKind(kind);
+    setResult("Waiting for response from the Wallet...");
+
     try {
       let res = null;
-      switch (method) {
-        case "tezos_getAccounts":
+      switch (kind) {
+        case SAMPLE_KINDS.GET_ACCOUNTS:
           res = await provider.tezosGetAccounts();
           break;
-        case "tezos_sign":
+        case SAMPLE_KINDS.SIGN:
           res = await provider.tezosSign("05010000004254");
           break;
-        case "tezos_send_transaction":
-          res = await provider.tezosSendTransaction(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_TRANSACTION]);
+        case SAMPLE_KINDS.SEND_TRANSACTION:
+          res = await provider.tezosSendTransaction(SAMPLES[SAMPLE_KINDS.SEND_TRANSACTION]);
           break;
-        case "tezos_send_delegation":
-          res = await provider.tezosSendDelegation(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_DELEGATION]);
+        case SAMPLE_KINDS.SEND_DELEGATION:
+          res = await provider.tezosSendDelegation(SAMPLES[SAMPLE_KINDS.SEND_DELEGATION]);
           break;
-        case "tezos_send_undelegation":
+        case SAMPLE_KINDS.SEND_UNDELEGATION:
           res = await provider.tezosSendUndelegation();
           break;
-        case "tezos_send_origination":
-          res = await provider.tezosSendOrigination(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_ORGINATION]);
+        case SAMPLE_KINDS.SEND_ORGINATION:
+          res = await provider.tezosSendOrigination(SAMPLES[SAMPLE_KINDS.SEND_ORGINATION]);
           const contractAddressList = await provider.getContractAddress(res.hash);
           if (contractAddressList.length > 0) {
             setContractAddress(contractAddressList[0]);
@@ -121,86 +139,79 @@ const App = () => {
             console.error("TezosRpc could not find contract address in origination operation.");
           }
           break;
-        case "tezos_send_contract_call":
-          const contract_call: PartialTezosTransactionOperation = {
-            ...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_CONTRACT_CALL],
+        case SAMPLE_KINDS.SEND_CONTRACT_CALL:
+          res = await provider.tezosSendContractCall({
+            ...SAMPLES[SAMPLE_KINDS.SEND_CONTRACT_CALL],
             destination: contractAddress,
-          };
-          res = await provider.tezosSendContractCall(contract_call);
+          });
           break;
-        case "tezos_send_stake":
-          res = await provider.tezosSendStake(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_STAKE]);
+        case SAMPLE_KINDS.SEND_STAKE:
+          res = await provider.tezosSendStake(SAMPLES[SAMPLE_KINDS.SEND_STAKE]);
           break;
-        case "tezos_send_unstake":
-          res = await provider.tezosSendUnstake(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_UNSTAKE]);
+        case SAMPLE_KINDS.SEND_UNSTAKE:
+          res = await provider.tezosSendUnstake(SAMPLES[SAMPLE_KINDS.SEND_UNSTAKE]);
           break;
-        case "tezos_send_finalize":
-          res = await provider.tezosSendFinalizeUnstake(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_FINALIZE]);
+        case SAMPLE_KINDS.SEND_FINALIZE:
+          res = await provider.tezosSendFinalizeUnstake(SAMPLES[SAMPLE_KINDS.SEND_FINALIZE]);
           break;
-        case "tezos_send_ballot":
-          const proposal = await provider.getCurrentProposal() || "[no proposal in progress]";
-          const ballot : TezosBallotOperation = {
-            ...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_BALLOT],
-            proposal: proposal
-          };
-          res = await provider.tezosSendBallot(ballot);
+        case SAMPLE_KINDS.SEND_INCREASE_PAID_STORAGE:
+          res = await provider.tezosSendIncreasePaidStorage({
+            ...SAMPLES[SAMPLE_KINDS.SEND_INCREASE_PAID_STORAGE],
+            destination: contractAddress,
+          });
           break;
-          
+            
         default:
-          throw new Error(`Unsupported method ${method}`);
+          throw new Error(`App: Unsupported kind ${kind}`);
       }
+      setLastKind(kind);
       setResult(res);
       await getBalance();
     } catch (error) {
       if (error instanceof Error) {
-        console.error(`Error sending ${method}:`, error.name, error.message);
+        console.error(`Error sending ${kind}:`, error.name, error.message);
         setResult([error.name, error.message]);
       } else {
-        console.error(`Error sending ${method}:`, error);
+        console.error(`Error sending ${kind}:`, error);
         setResult(error);
       }
-      
     }
   };
 
-  const describe = (method: string) => {
-    switch (method) {
-      case "tezos_send_transaction":
-        setDescription(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_TRANSACTION]);
+  const describe = (kind: SAMPLE_KINDS) => {
+    switch (kind) {
+      case SAMPLE_KINDS.SEND_TRANSACTION:
+        setDescription(SAMPLES[kind]);
         break;
-      case "tezos_send_delegation":
-        setDescription(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_DELEGATION]);
+      case SAMPLE_KINDS.SEND_DELEGATION:
+        setDescription(SAMPLES[kind]);
         break;
-      case "tezos_send_undelegation":
-        setDescription(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_UNDELEGATION]);
+      case SAMPLE_KINDS.SEND_UNDELEGATION:
+        setDescription(SAMPLES[kind]);
         break;
-      case "tezos_send_origination":
-        setDescription(TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_ORGINATION]);
+      case SAMPLE_KINDS.SEND_ORGINATION:
+        setDescription(SAMPLES[kind]);
         break;
-      case "tezos_send_contract_call":
-        const contract_call = {
-          ...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_CONTRACT_CALL],
-          destination: contractAddress
-            ? contractAddress
-            : "[click Origination to get contract address]",
-        };
-        setDescription(contract_call);
+      case SAMPLE_KINDS.SEND_CONTRACT_CALL:
+        setDescription({
+          ...SAMPLES[kind],
+          destination: contractAddress ? contractAddress : "[click Origination to get contract address]",
+        });
         break;
-      case "tezos_send_stake":
-        setDescription({...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_STAKE], destination: provider.address});
+      case SAMPLE_KINDS.SEND_STAKE:
+        setDescription({...SAMPLES[kind], destination: provider.address});
         break;
-      case "tezos_send_unstake":
-        setDescription({...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_UNSTAKE], destination: provider.address});
+      case SAMPLE_KINDS.SEND_UNSTAKE:
+        setDescription({...SAMPLES[kind], destination: provider.address});
         break;
-      case "tezos_send_finalize":
-        setDescription({...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_FINALIZE], destination: provider.address});
+      case SAMPLE_KINDS.SEND_FINALIZE:
+        setDescription({...SAMPLES[kind], destination: provider.address});
         break;
-      case "tezos_send_ballot":
-        const ballot = {
-          ...TEZOS_ACTIONS[DEFAULT_TEZOS_METHODS.TEZOS_SEND_BALLOT],
-          source: provider.address,
-        };
-        setDescription(ballot);
+      case SAMPLE_KINDS.SEND_INCREASE_PAID_STORAGE:
+        setDescription({
+          ...SAMPLES[kind],
+          destination: contractAddress ? contractAddress : "[click Origination to get contract address]",
+        });
         break;
       default:
         setDescription("No description available");
@@ -210,7 +221,7 @@ const App = () => {
   const describeClear = () => {
     setDescription(undefined);
   };
-  
+
   return (
     <div className="App">
       <h1>TezosProvider</h1>
@@ -229,36 +240,37 @@ const App = () => {
             <b>Balance: </b>
             {balance}
           </p>
-          <div className="btn-container">
-          <button onClick={() => handleOp("tezos_getAccounts")}  onMouseEnter={describeClear}>Get Accounts</button>
-          <button onClick={() => handleOp("tezos_sign")}  onMouseEnter={describeClear}>Sign</button>
-          <button onClick={disconnect} onMouseEnter={describeClear}>Disconnect</button>
-          </div>
-          <div className="btn-container">
-          <button onClick={() => handleOp("tezos_send_transaction")}  onMouseEnter={() => describe("tezos_send_transaction")}>Send Transaction</button>
-          <button onClick={() => handleOp("tezos_send_delegation")}  onMouseEnter={() => describe("tezos_send_delegation")}>Delegate</button>
-          <button onClick={() => handleOp("tezos_send_undelegation")}  onMouseEnter={() => describe("tezos_send_undelegation")}>Undelegate</button>
-          <button onClick={() => handleOp("tezos_send_origination")}  onMouseEnter={() => describe("tezos_send_origination")}>Originate</button>
-          <button onClick={() => handleOp("tezos_send_contract_call")}  onMouseEnter={() => describe("tezos_send_contract_call")}>Contract call</button>
-          </div>
-          <div className="btn-container">
-          <button onClick={() => handleOp("tezos_send_stake")}  onMouseEnter={() => describe("tezos_send_stake")}>Stake</button>
-          <button onClick={() => handleOp("tezos_send_unstake")}  onMouseEnter={() => describe("tezos_send_unstake")}>Unstake</button>
-          <button onClick={() => handleOp("tezos_send_finalize")}  onMouseEnter={() => describe("tezos_send_finalize")}>Finalize</button>
-          <button onClick={() => handleOp("tezos_send_ballot")}  onMouseEnter={() => describe("tezos_send_ballot")}>Ballot</button>
+          <div className="layout-container">
+            <div className="btn-container">
+              <button onClick={disconnect} onMouseEnter={describeClear}>Disconnect</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.GET_ACCOUNTS)}  onMouseEnter={describeClear}>Get Accounts</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SIGN)}  onMouseEnter={describeClear}>Sign</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_TRANSACTION)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_TRANSACTION)}>Send Transaction</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_DELEGATION)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_DELEGATION)}>Delegate</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_UNDELEGATION)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_UNDELEGATION)}>Undelegate</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_ORGINATION)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_ORGINATION)}>Originate</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_CONTRACT_CALL)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_CONTRACT_CALL)}>Contract call</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_STAKE)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_STAKE)}>Stake</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_UNSTAKE)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_UNSTAKE)}>Unstake</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_FINALIZE)}  onMouseEnter={() => describe(SAMPLE_KINDS.SEND_FINALIZE)}>Finalize</button>
+              <button onClick={() => handleOp(SAMPLE_KINDS.SEND_INCREASE_PAID_STORAGE)} onMouseEnter={() => describe(SAMPLE_KINDS.SEND_INCREASE_PAID_STORAGE)}>Increase paid storage</button>
+            </div>
+            <div className="result-column">
+              {result && (
+                <>
+                  <p>Result of the last operation:</p>
+                  <pre>{lastKind}</pre>
+                  <pre>{JSON.stringify(result, null, 2)}</pre>
+                </>
+              )}
+            {description && (
+                <>
+                  <p>Operation:</p>
+                  <pre>{JSON.stringify(description, null, 2)}</pre>
+                </>
+              )}
+            </div>
           </div>
-          {result && (
-            <>
-              <p>Result of the last operation:</p>
-              <pre>{JSON.stringify(result, null, 2)}</pre>
-            </>
-          )}
-          {description && (
-            <>
-              <p>Operation:</p>
-              <pre>{JSON.stringify(description, null, 2)}</pre>
-            </>
-          )}
         </>
       ) : (
         <>
diff --git a/dapps/tezos-provider/src/styles/index.css b/dapps/tezos-provider/src/styles/index.css
index 9b4b9e894..d3623baf5 100644
--- a/dapps/tezos-provider/src/styles/index.css
+++ b/dapps/tezos-provider/src/styles/index.css
@@ -62,11 +62,33 @@ button:focus-visible {
   outline: 4px auto -webkit-focus-ring-color;
 }
 
+.layout-container {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  flex-direction: row;
+  gap: 2rem;
+}
+
 .btn-container {
   display: flex;
-  align-items: left;
-  justify-content: left;
+  flex-direction: column;
   gap: 1rem;
+  margin-right: 20px;
+}
+
+.result-column {
+  display: flex;
+  flex-direction: column;
+  flex-grow: 1;
+  margin-top: 20px; /* Space between the result and the description */
+}
+
+pre {
+  background-color: #f4f4f4;
+  padding: 10px;
+  border-radius: 5px;
+  overflow-x: auto;
 }
 
 @media (prefers-color-scheme: light) {
@@ -79,5 +101,6 @@ button:focus-visible {
   }
   button {
     background-color: #f9f9f9;
+    width: 250px;
   }
 }
diff --git a/dapps/tezos-provider/src/utils/samples.ts b/dapps/tezos-provider/src/utils/samples.ts
index 2f781e34e..062a824b3 100644
--- a/dapps/tezos-provider/src/utils/samples.ts
+++ b/dapps/tezos-provider/src/utils/samples.ts
@@ -1,10 +1,9 @@
 import {
+    TezosOperationType, 
+    PartialTezosTransactionOperation,
     PartialTezosDelegationOperation,
     PartialTezosOriginationOperation as PartialTezosOriginationOperationOriginal,
-    PartialTezosTransactionOperation,
-    TezosBallotOperation,
-    TezosOperationType, 
-    TezosTransactionOperation}
+    PartialTezosIncreasePaidStorageOperation}
     from "@airgap/beacon-types";
 
 import { ScriptedContracts } from "@taquito/rpc";
@@ -14,19 +13,19 @@ interface PartialTezosOriginationOperation
   script: ScriptedContracts;
 }
   
-export enum DEFAULT_TEZOS_METHODS {
-  TEZOS_GET_ACCOUNTS = "tezos_getAccounts",
-  TEZOS_SEND = "tezos_send",
-  TEZOS_SEND_TRANSACTION = "tezos_send:transaction",
-  TEZOS_SEND_ORGINATION = "tezos_send:origination",
-  TEZOS_SEND_CONTRACT_CALL = "tezos_send:contract_call",
-  TEZOS_SEND_DELEGATION = "tezos_send:delegation",
-  TEZOS_SEND_UNDELEGATION = "tezos_send:undelegation",
-  TEZOS_SEND_STAKE = "tezos_send:stake",
-  TEZOS_SEND_UNSTAKE = "tezos_send:unstake",
-  TEZOS_SEND_FINALIZE = "tezos_send:finalize",
-  TEZOS_SEND_BALLOT = "tezos_send:ballot",
-  TEZOS_SIGN = "tezos_sign",
+export enum SAMPLE_KINDS {
+  GET_ACCOUNTS = "tezos_getAccounts",
+  SEND = "tezos_send",
+  SEND_TRANSACTION = "tezos_send:transaction",
+  SEND_ORGINATION = "tezos_send:origination",
+  SEND_CONTRACT_CALL = "tezos_send:contract_call",
+  SEND_DELEGATION = "tezos_send:delegation",
+  SEND_UNDELEGATION = "tezos_send:undelegation",
+  SEND_STAKE = "tezos_send:stake",
+  SEND_UNSTAKE = "tezos_send:unstake",
+  SEND_FINALIZE = "tezos_send:finalize",
+  SEND_INCREASE_PAID_STORAGE = "tezos_send:increase_paid_storage",
+  SIGN = "tezos_sign",
 }
 
 const tezosTransactionOperation: PartialTezosTransactionOperation = {
@@ -103,16 +102,14 @@ const tezosFinalizeOperation: PartialTezosTransactionOperation = {
   },
 };
 
-const tezosBallotOperation: TezosBallotOperation = {
-  kind: TezosOperationType.BALLOT,
-  source: "tz3ZmB8oWUmi8YZXgeRpgAcPnEMD8VgUa4Ve", // Tezos Foundation Ghost Baker
-  period: "0",
-  proposal: "[current proposal]",
-  ballot: "yay"
+const TezosIncreasePaidStorageOperation: PartialTezosIncreasePaidStorageOperation = {
+  kind: TezosOperationType.INCREASE_PAID_STORAGE,
+  amount: "10",
+  destination: "[contract address]"
 };
 
 // Assign the specific types to the TEZOS_ACTIONS object
-export const TEZOS_ACTIONS = {
+export const SAMPLES = {
   "tezos_send:transaction": tezosTransactionOperation,
   "tezos_send:origination": tezosOriginationOperation,
   "tezos_send:contract_call": tezosContractCallOperation,
@@ -121,7 +118,7 @@ export const TEZOS_ACTIONS = {
   "tezos_send:stake": tezosStakeOperation,
   "tezos_send:unstake": tezosUnstakeOperation,
   "tezos_send:finalize": tezosFinalizeOperation,
-  "tezos_send:ballot": tezosBallotOperation,
+  "tezos_send:increase_paid_storage": TezosIncreasePaidStorageOperation,
 };
 
 export enum DEFAULT_TEZOS_EVENTS {}
diff --git a/dapps/tezos-provider/src/utils/tezos-provider.ts b/dapps/tezos-provider/src/utils/tezos-provider.ts
index 3e27df242..b6ed18aed 100644
--- a/dapps/tezos-provider/src/utils/tezos-provider.ts
+++ b/dapps/tezos-provider/src/utils/tezos-provider.ts
@@ -2,14 +2,43 @@ import { UniversalProvider, Metadata } from "@walletconnect/universal-provider";
 import { KeyValueStorageOptions } from "@walletconnect/keyvaluestorage";
 import { Logger } from "@walletconnect/logger";
 import { TezosToolkit } from "@taquito/taquito";
-import { DEFAULT_TEZOS_METHODS } from "./samples";
 import { 
+  PartialTezosDalPublishCommitmentOperation,
   PartialTezosDelegationOperation, 
+  PartialTezosIncreasePaidStorageOperation, 
   PartialTezosOperation as PartialTezosOperationOriginal, 
   PartialTezosOriginationOperation as PartialTezosOriginationOperationOriginal,
+  PartialTezosRegisterGlobalConstantOperation,
+  PartialTezosRevealOperation,
+  PartialTezosSetDepositsLimitOperation,
+  PartialTezosSmartRollupAddMessagesOperation,
+  PartialTezosSmartRollupCementOperation,
+  PartialTezosSmartRollupExecuteOutboxMessageOperation,
+  PartialTezosSmartRollupOriginateOperation,
+  PartialTezosSmartRollupPublishOperation,
+  PartialTezosSmartRollupRecoverBondOperation,
+  PartialTezosSmartRollupRefuteOperation,
+  PartialTezosSmartRollupTimeoutOperation,
   PartialTezosTransactionOperation, 
+  PartialTezosTransferTicketOperation, 
+  PartialTezosUpdateConsensusKeyOperation, 
+  TezosActivateAccountOperation, 
+  TezosAttestationOperation, 
+  TezosAttestationWithSlotOperation, 
   TezosBallotOperation, 
-  TezosOperationType 
+  TezosDoubleAttestationEvidenceOperation, 
+  TezosDoubleBakingEvidenceOperation, 
+  TezosDoublePreAttestationEvidenceOperation, 
+  TezosDoublePreEndorsementEvidenceOperation, 
+  TezosDrainDelegateOperation, 
+  TezosEndorsementOperation, 
+  TezosEndorsementWithSlotOperation, 
+  TezosFailingNoopOperation, 
+  TezosOperationType, 
+  TezosPreAttestationOperation,
+  TezosProposalOperation,
+  TezosSeedNonceRevelationOperation,
+  TezosVdfRevelationOperation
 } from "@airgap/beacon-types";
 
 import { ScriptedContracts } from "@taquito/rpc";
@@ -103,8 +132,8 @@ export interface TezosConnectOpts {
 
 export enum TezosMethod {
   GET_ACCOUNTS = "tezos_getAccounts",
-  SEND = "tezos_sign",
-  SIGN = "tezos_send"
+  SEND = "tezos_send",
+  SIGN = "tezos_sign"
 }
 
 export enum TezosEvent { 
@@ -301,9 +330,9 @@ class TezosProvider {
   }
 
   public async checkConnection(): Promise<boolean> {
-    if (!this.isConnected) {
+    if (!this.isConnected || !this.address) {
       throw new TezosConnectionError();
-    }
+    }    
     return true;
   }
   
@@ -316,7 +345,7 @@ class TezosProvider {
     await this.checkConnection();
   
     const result = await this.signer.request<TezosGetAccountResponse>({
-      method: DEFAULT_TEZOS_METHODS.TEZOS_GET_ACCOUNTS,
+      method: TezosMethod.GET_ACCOUNTS,
       params: {},
     }, this.chainId);
     this.accounts = result.map((account) => account.address);
@@ -332,7 +361,7 @@ class TezosProvider {
     await this.checkConnection();
     
     const result = await this.signer.request<TezosSignResponse>({
-      method: DEFAULT_TEZOS_METHODS.TEZOS_SIGN,
+      method: TezosMethod.SIGN,
       params: {
         account: this.address,
         payload,
@@ -347,10 +376,14 @@ class TezosProvider {
     if (!this.signer) {
       throw new TezosInitializationError();
     }
+    if (!this.address) {
+      throw new TezosConnectionError();
+    }
+
     await this.checkConnection();
     
     const result = await this.signer.request<TezosSendResponse>({
-      method: DEFAULT_TEZOS_METHODS.TEZOS_SEND,
+      method: TezosMethod.SEND,
       params: {
         account: this.address,
         operations: [op],
@@ -441,11 +474,131 @@ class TezosProvider {
     return this.tezosSend(this.createStakingOperation("finalize_unstake", op));
   }
 
-  public async tezosSendBallot(op: TezosBallotOperation): Promise<TezosSendResponse> {
+  public async tezosSendActivateAccount(op: TezosActivateAccountOperation): Promise<TezosSendResponse> {
     if (!this.address) {
       throw new TezosConnectionError();
     }
-    return this.tezosSend({...op, source: this.address});
+    return this.tezosSend({...op, pkh: this.address});
+  }
+
+  public async tezosSendAttestation(op: TezosAttestationOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendAttestationWithSlot(op: TezosAttestationWithSlotOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendBallot(op: TezosBallotOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendDalPublishCommitment(op: PartialTezosDalPublishCommitmentOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendDoubleAttestationEvidence(op: TezosDoubleAttestationEvidenceOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendDoubleBakingEvidence(op: TezosDoubleBakingEvidenceOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendDoublePreAttestationEvidence(op: TezosDoublePreAttestationEvidenceOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendDoublePreEndorsementEvidence(op: TezosDoublePreEndorsementEvidenceOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendDrainDelegate(op: TezosDrainDelegateOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendEndorsement(op: TezosEndorsementOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendEndorsementWithSlot(op: TezosEndorsementWithSlotOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendFailingNoop(op: TezosFailingNoopOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendIncreasePaidStorage(op: PartialTezosIncreasePaidStorageOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendPreAttestation(op: TezosPreAttestationOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendProposal(op: TezosProposalOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendRegisterGlobalConstant(op: PartialTezosRegisterGlobalConstantOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendReveal(op: PartialTezosRevealOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSeedNonceRevelation(op: TezosSeedNonceRevelationOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSetDepositsLimit(op: PartialTezosSetDepositsLimitOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupAddMessages(op: PartialTezosSmartRollupAddMessagesOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupCement(op: PartialTezosSmartRollupCementOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupExecuteOutboxMessage(op: PartialTezosSmartRollupExecuteOutboxMessageOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupOriginate(op: PartialTezosSmartRollupOriginateOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupPublish(op: PartialTezosSmartRollupPublishOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupRecoverBond(op: PartialTezosSmartRollupRecoverBondOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupRefute(op: PartialTezosSmartRollupRefuteOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendSmartRollupTimeout(op: PartialTezosSmartRollupTimeoutOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendTransferTicket(op: PartialTezosTransferTicketOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendUpdateConsensusKey(op: PartialTezosUpdateConsensusKeyOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
+  }
+
+  public async tezosSendVdfRevelation(op: TezosVdfRevelationOperation): Promise<TezosSendResponse> {
+    return this.tezosSend(op);
   }
 
 }