diff --git a/packages/mobile/src/modals/add-token/index.tsx b/packages/mobile/src/modals/add-token/index.tsx
index a4de26fcee..c3aeee7154 100644
--- a/packages/mobile/src/modals/add-token/index.tsx
+++ b/packages/mobile/src/modals/add-token/index.tsx
@@ -1,4 +1,4 @@
-import React, { FunctionComponent } from "react";
+import React, { FunctionComponent, useState } from "react";
 import { registerModal } from "../base";
 import { CardModal } from "../card";
 import { useStore } from "../../stores";
@@ -6,14 +6,21 @@ import { observer } from "mobx-react-lite";
 import { TextInput } from "../../components/input";
 import { Button } from "../../components/button";
 import { useStyle } from "../../styles";
-import { View } from "react-native";
+import { StyleSheet, View } from "react-native";
+import { DownArrowIcon, UpArrowIcon } from "../../components/icon";
+import { AppCurrency } from "@keplr-wallet/types";
 
 export const AddTokenModal: FunctionComponent<{
   isOpen: boolean;
   close: () => void;
 }> = registerModal(
   observer(() => {
-    const { chainStore, queriesStore, tokensStore } = useStore();
+    const { chainStore, accountStore, queriesStore, tokensStore } = useStore();
+
+    const [isAdvanced, setAdvanced] = useState(false);
+    const [viewingKey, setViewingKey] = useState(
+      tokensStore.waitingSuggestedToken?.data?.viewingKey ?? ""
+    );
 
     const style = useStyle();
 
@@ -22,10 +29,37 @@ export const AddTokenModal: FunctionComponent<{
       chainStore.current.chainId;
     const contractAddress =
       tokensStore.waitingSuggestedToken?.data.contractAddress || "";
+    const account = accountStore.getAccount(chainId);
+
+    const isSecret20 =
+      (chainStore.getChain(chainId).features ?? []).find(
+        (feature) => feature === "secretwasm"
+      ) != null;
+
+    const queries = queriesStore.get(chainId);
+
+    const query = isSecret20
+      ? queries.secret.querySecret20ContractInfo
+      : queries.cosmwasm.querycw20ContractInfo;
 
-    const queryTokenInfo = queriesStore
-      .get(chainId)
-      .cosmwasm.querycw20ContractInfo.getQueryContract(contractAddress);
+    const queryContractInfo = query.getQueryContract(contractAddress);
+    const tokenInfo = queryContractInfo.tokenInfo;
+
+    const createViewingKey = async (): Promise<string> => {
+      return new Promise((resolve, reject) => {
+        account.secret
+          .createSecret20ViewingKey(
+            contractAddress,
+            "",
+            {},
+            {},
+            (_, viewingKey) => {
+              resolve(viewingKey);
+            }
+          )
+          .catch(reject);
+      });
+    };
 
     return (
       <CardModal title="Add Token">
@@ -37,33 +71,88 @@ export const AddTokenModal: FunctionComponent<{
         <TextInput
           label="Name"
           editable={false}
-          value={queryTokenInfo.tokenInfo?.name ?? ""}
+          value={tokenInfo?.name ?? ""}
         />
         <TextInput
           label="Symbol"
           editable={false}
-          value={queryTokenInfo.tokenInfo?.symbol ?? ""}
+          value={tokenInfo?.symbol ?? ""}
         />
         <TextInput
           label="Decimals"
           editable={false}
-          value={queryTokenInfo.tokenInfo?.decimals.toString() ?? ""}
+          value={tokenInfo?.decimals.toString() ?? ""}
         />
+        {isSecret20 ? (
+          <View
+            style={StyleSheet.flatten([
+              style.flatten(["flex-row", "justify-center"]),
+            ])}
+          >
+            <Button
+              text="Advanced"
+              mode="text"
+              rightIcon={
+                <View style={style.flatten(["padding-left-4"])}>
+                  {isAdvanced ? (
+                    <UpArrowIcon size={16} color="#314FDF" />
+                  ) : (
+                    <DownArrowIcon size={16} color="#314FDF" />
+                  )}
+                </View>
+              }
+              style={StyleSheet.flatten([
+                style.flatten(["width-122", "items-center"]),
+              ])}
+              onPress={() => {
+                setAdvanced(!isAdvanced);
+              }}
+            />
+          </View>
+        ) : null}
+        {isAdvanced ? (
+          <TextInput
+            label="Viewing key"
+            placeholder="Import my own viewing key"
+            value={viewingKey}
+            onChangeText={setViewingKey}
+          />
+        ) : null}
         <View style={style.flatten(["height-16"])} />
         <Button
           text="Submit"
           size="large"
-          disabled={!queryTokenInfo.tokenInfo || queryTokenInfo.error != null}
-          loading={!queryTokenInfo.tokenInfo && queryTokenInfo.isFetching}
+          disabled={!tokenInfo || queryContractInfo.error != null}
+          loading={!tokenInfo && queryContractInfo.isFetching}
           onPress={async () => {
-            if (queryTokenInfo.tokenInfo) {
-              await tokensStore.approveSuggestedToken({
-                type: "cw20",
-                contractAddress,
-                coinMinimalDenom: queryTokenInfo.tokenInfo.name,
-                coinDenom: queryTokenInfo.tokenInfo.symbol,
-                coinDecimals: queryTokenInfo.tokenInfo.decimals,
-              });
+            if (tokenInfo) {
+              let currency: AppCurrency;
+
+              if (isSecret20) {
+                let newViewingKey = viewingKey;
+
+                if (!viewingKey) {
+                  newViewingKey = await createViewingKey();
+                }
+
+                currency = {
+                  type: "secret20",
+                  contractAddress,
+                  viewingKey: newViewingKey,
+                  coinMinimalDenom: tokenInfo.name,
+                  coinDenom: tokenInfo.symbol,
+                  coinDecimals: tokenInfo.decimals,
+                };
+              } else {
+                currency = {
+                  type: "cw20",
+                  contractAddress,
+                  coinMinimalDenom: tokenInfo.name,
+                  coinDenom: tokenInfo.symbol,
+                  coinDecimals: tokenInfo.decimals,
+                };
+              }
+              await tokensStore.approveSuggestedToken(currency);
             }
           }}
         />
diff --git a/packages/mobile/src/stores/wallet-connect/index.ts b/packages/mobile/src/stores/wallet-connect/index.ts
index e1b2fdeadf..673ad19513 100644
--- a/packages/mobile/src/stores/wallet-connect/index.ts
+++ b/packages/mobile/src/stores/wallet-connect/index.ts
@@ -334,6 +334,128 @@ export abstract class WalletConnectManager {
           });
           break;
         }
+        case "keplr_enigma_decrypt_wallet_connect_v1": {
+          if (payload.params.length !== 3) {
+            throw new Error("Invalid parmas");
+          }
+          for (const param of payload.params) {
+            if (typeof param !== "string") {
+              throw new Error("Invalid parmas");
+            }
+          }
+          const result = await keplr.enigmaDecrypt(
+            payload.params[0],
+            Buffer.from(payload.params[1], "base64"),
+            Buffer.from(payload.params[2], "base64")
+          );
+
+          client.approveRequest({
+            id,
+            result: [Buffer.from(result).toString("base64")],
+          });
+          break;
+        }
+        case "keplr_enigma_encrypt_wallet_connect_v1": {
+          if (payload.params.length !== 3) {
+            throw new Error("Invalid parmas");
+          }
+          if (
+            typeof payload.params[0] !== "string" &&
+            typeof payload.params[1] !== "string" &&
+            typeof payload.params[2] !== "object"
+          ) {
+            throw new Error("Invalid parmas");
+          }
+          const result = await keplr.enigmaEncrypt(
+            payload.params[0],
+            payload.params[1],
+            payload.params[2]
+          );
+
+          client.approveRequest({
+            id,
+            result: [Buffer.from(result).toString("base64")],
+          });
+          break;
+        }
+        case "keplr_enigma_pub_key_wallet_connect_v1": {
+          if (payload.params.length !== 1) {
+            throw new Error("Invalid parmas");
+          }
+          if (typeof payload.params[0] !== "string") {
+            throw new Error("Invalid parmas");
+          }
+          const result = await keplr.getEnigmaPubKey(payload.params[0]);
+
+          client.approveRequest({
+            id,
+            result: [Buffer.from(result).toString("base64")],
+          });
+          break;
+        }
+        case "keplr_enigma_tx_encryption_key_wallet_connect_v1": {
+          if (payload.params.length !== 2) {
+            throw new Error("Invalid parmas");
+          }
+          for (const param of payload.params) {
+            if (typeof param !== "string") {
+              throw new Error("Invalid parmas");
+            }
+          }
+          const result = await keplr.getEnigmaTxEncryptionKey(
+            payload.params[0],
+            Buffer.from(payload.params[1], "base64")
+          );
+
+          client.approveRequest({
+            id,
+            result: [Buffer.from(result).toString("base64")],
+          });
+          break;
+        }
+        case "keplr_suggest_token_wallet_connect_v1": {
+          if (payload.params.length !== 2 && payload.params.length !== 3) {
+            throw new Error("Invalid parmas");
+          }
+          if (
+            typeof payload.params[0] !== "string" &&
+            typeof payload.params[1] !== "string" &&
+            (typeof payload.params[2] !== "string" ||
+              typeof payload.params[2] !== undefined)
+          ) {
+            throw new Error("Invalid parmas");
+          }
+          await keplr.suggestToken(
+            payload.params[0],
+            payload.params[1],
+            payload.params[2]
+          );
+
+          client.approveRequest({
+            id,
+            result: [],
+          });
+          break;
+        }
+        case "keplr_get_scrt20_viewing_key_wallet_connect_v1": {
+          if (payload.params.length !== 2) {
+            throw new Error("Invalid parmas");
+          }
+          for (const param of payload.params) {
+            if (typeof param !== "string") {
+              throw new Error("Invalid parmas");
+            }
+          }
+          const result = await keplr.getSecret20ViewingKey(
+            payload.params[0],
+            payload.params[1]
+          );
+          client.approveRequest({
+            id,
+            result: [result],
+          });
+          break;
+        }
         default:
           throw new Error(`Unknown method (${payload.method})`);
       }
diff --git a/packages/provider-mock/src/mock.ts b/packages/provider-mock/src/mock.ts
index af153efebd..2a20cf2209 100644
--- a/packages/provider-mock/src/mock.ts
+++ b/packages/provider-mock/src/mock.ts
@@ -148,6 +148,13 @@ export class MockKeplr implements Keplr {
     throw new Error("Not implemented");
   }
 
+  getSecret20QueryAuthorization(
+    _chainId: string,
+    _contractAddress: string
+  ): Promise<{ permit: any | undefined; viewing_key: string | undefined }> {
+    throw new Error("Not implemented");
+  }
+
   sendTx(
     chainId: string,
     stdTx: Uint8Array,
diff --git a/packages/provider/src/core.ts b/packages/provider/src/core.ts
index 8b76677e5e..2bc371e049 100644
--- a/packages/provider/src/core.ts
+++ b/packages/provider/src/core.ts
@@ -256,6 +256,17 @@ export class Keplr implements IKeplr, KeplrCoreTypes {
     return await this.requester.sendMessage(BACKGROUND_PORT, msg);
   }
 
+  async getSecret20QueryAuthorization(
+    chainId: string,
+    contractAddress: string
+  ): Promise<{ permit: any | undefined; viewing_key: string | undefined }> {
+    return {
+      // todo: once support for saving permits is implemented, getting a saved permit should be implemented here
+      permit: null,
+      viewing_key: await this.getSecret20ViewingKey(chainId, contractAddress),
+    };
+  }
+
   async getEnigmaPubKey(chainId: string): Promise<Uint8Array> {
     return await this.requester.sendMessage(
       BACKGROUND_PORT,
diff --git a/packages/provider/src/inject.ts b/packages/provider/src/inject.ts
index 138f6496e5..c3f441b059 100644
--- a/packages/provider/src/inject.ts
+++ b/packages/provider/src/inject.ts
@@ -498,6 +498,17 @@ export class InjectedKeplr implements IKeplr {
     ]);
   }
 
+  async getSecret20QueryAuthorization(
+    chainId: string,
+    contractAddress: string
+  ): Promise<{ permit: any | undefined; viewing_key: string | undefined }> {
+    return {
+      // todo: once support for saving permits is implemented, getting a saved permit should be implemented here
+      permit: null,
+      viewing_key: await this.getSecret20ViewingKey(chainId, contractAddress),
+    };
+  }
+
   async getEnigmaPubKey(chainId: string): Promise<Uint8Array> {
     return await this.requestMethod("getEnigmaPubKey", [chainId]);
   }
diff --git a/packages/types/src/wallet/keplr.ts b/packages/types/src/wallet/keplr.ts
index 46803679ce..c63fffb035 100644
--- a/packages/types/src/wallet/keplr.ts
+++ b/packages/types/src/wallet/keplr.ts
@@ -115,6 +115,10 @@ export interface Keplr {
     chainId: string,
     contractAddress: string
   ): Promise<string>;
+  getSecret20QueryAuthorization(
+    chainId: string,
+    contractAddress: string
+  ): Promise<{ permit: any | undefined; viewing_key: string | undefined }>;
   getEnigmaUtils(chainId: string): SecretUtils;
 
   // Related to Enigma.
diff --git a/packages/wc-client-example/src/app.tsx b/packages/wc-client-example/src/app.tsx
index 949795e781..c6b34ed2d0 100644
--- a/packages/wc-client-example/src/app.tsx
+++ b/packages/wc-client-example/src/app.tsx
@@ -1,6 +1,7 @@
 import React, { FunctionComponent } from "react";
 import { observer } from "mobx-react-lite";
 import { useStore } from "./stores";
+import { Buffer } from "buffer";
 
 const IBCChannel = "channel-141";
 const CounterpartyIBCChannel = "channel-0";
@@ -73,6 +74,202 @@ export const App: FunctionComponent = observer(() => {
       >
         Test IBC 2
       </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.enigmaEncrypt(
+                chainInfo.chainId,
+                "5b64d22c7774b11cbc3aac55168d11f624a51921679b005df7d59487d254c892",
+                { hello: "world" }
+              )
+            )
+            .then((encrypted) => {
+              const nonce = Buffer.from(encrypted ?? [])
+                .slice(0, 32)
+                .toString("base64");
+              const cyphertext = Buffer.from(encrypted ?? [])
+                .slice(64)
+                .toString("base64");
+              console.log(`enigmaEncrypt: ${nonce}`);
+              console.log(`enigmaEncrypt: ${cyphertext}`);
+            });
+        }}
+      >
+        Test Encrypt
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.enigmaDecrypt(
+                chainInfo.chainId,
+                Buffer.from(
+                  "7qK+rsMx1IdnFl/TBfFp8DlzuSAy/vRBYyStbP2GU36Yipt/+NKF3khoXZ3yYPEEFtEs1faXhCK5Ad8OxHoWmpp4CXsMmnjBOjZQuGeqWb8FoXNNFj96Eu6HaBgcuHtQjw==",
+                  "base64"
+                ),
+                Buffer.from(
+                  "nyCG0DftPcW7HJshdhGs+rXpHZfK5hQQDx+wJ3Jtu08=",
+                  "base64"
+                )
+              )
+            )
+            .then((plaintext) => {
+              const decoded = Buffer.from(plaintext ?? []).toString();
+              console.log(`enigmaDecrypt: ${decoded}`);
+            });
+        }}
+      >
+        Test Decrypt
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) => keplr?.getEnigmaPubKey(chainInfo.chainId))
+            .then((pubKey) => {
+              const encoded = Buffer.from(pubKey ?? []).toString("base64");
+              console.log(`getEnigmaPubKey: ${encoded}`);
+            });
+        }}
+      >
+        Test getEnigmaPubKey
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.getEnigmaTxEncryptionKey(
+                chainInfo.chainId,
+                Uint8Array.from([])
+              )
+            )
+            .then((result) => {
+              const encoded = Buffer.from(result ?? []).toString("base64");
+              console.log(`getEnigmaTxEncryptionKey: ${encoded}`);
+            });
+        }}
+      >
+        Test getEnigmaTxEncryptionKey
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[3];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.suggestToken(
+                chainInfo.chainId,
+                "juno1epxnvge53c4hkcmqzlxryw5fp7eae2utyk6ehjcfpwajwp48km3sgxsh9k"
+              )
+            )
+            .then(() => {
+              console.log(`suggestToken:cw20 complete`);
+            });
+        }}
+      >
+        Test suggestToken:cw20
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.suggestToken(
+                chainInfo.chainId,
+                "secret1k6u0cy4feepm6pehnz804zmwakuwdapm69tuc4"
+              )
+            )
+            .then(() => {
+              console.log(`suggestToken:snip20 complete`);
+            });
+        }}
+      >
+        Test suggestToken:snip20
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.suggestToken(
+                chainInfo.chainId,
+                "secret1k6u0cy4feepm6pehnz804zmwakuwdapm69tuc4",
+                "viewingkey"
+              )
+            )
+            .then(() => {
+              console.log(`suggestToken:snip20 w/ viewing key complete`);
+            });
+        }}
+      >
+        Test suggestToken:snip20 w/ viewingkey
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.getSecret20ViewingKey(
+                chainInfo.chainId,
+                "secret1k6u0cy4feepm6pehnz804zmwakuwdapm69tuc4"
+              )
+            )
+            .then((result) => {
+              console.log(`getSecret20ViewingKey: ${result}`);
+            });
+        }}
+      >
+        Test getSecret20ViewingKey
+      </button>
+      <button
+        onClick={() => {
+          const chainInfo = chainStore.chainInfos[2];
+          const account = accountStore.getAccount(chainInfo.chainId);
+
+          account
+            .getKeplr()
+            .then((keplr) =>
+              keplr?.getSecret20QueryAuthorization(
+                chainInfo.chainId,
+                "secret1k6u0cy4feepm6pehnz804zmwakuwdapm69tuc4"
+              )
+            )
+            .then((result) => {
+              console.log(
+                `getSecret20QueryAuthorization: ${JSON.stringify(result)}`
+              );
+            });
+        }}
+      >
+        Test getSecret20QueryAuthorization
+      </button>
     </div>
   );
 });
diff --git a/packages/wc-client-example/src/config.ts b/packages/wc-client-example/src/config.ts
index b1006d0e5e..18f844f908 100644
--- a/packages/wc-client-example/src/config.ts
+++ b/packages/wc-client-example/src/config.ts
@@ -93,4 +93,90 @@ export const EmbedChainInfos = [
     },
     features: ["stargate", "ibc-transfer"],
   },
+  {
+    chainId: "secret-4",
+    chainName: "Secret",
+    rpc: "https://rpc-secret.keplr.app",
+    rest: "https://lcd-secret.keplr.app",
+    bip44: { coinType: 529 },
+    coinType: 529,
+    stakeCurrency: {
+      coinDenom: "$denom",
+      coinMinimalDenom: "$minimalDenom",
+      coinDecimals: 6,
+    },
+    bech32Config: {
+      bech32PrefixAccAddr: "secret",
+      bech32PrefixAccPub: "secretpub",
+      bech32PrefixValAddr: "secretvaloper",
+      bech32PrefixValPub: "secretvaloperpub",
+      bech32PrefixConsAddr: "secretvalcons",
+      bech32PrefixConsPub: "secretvalconspub",
+    },
+    currencies: [
+      {
+        coinDenom: "$denom",
+        coinMinimalDenom: "$minimalDenom",
+        coinDecimals: 6,
+      },
+    ],
+    feeCurrencies: [
+      {
+        coinDenom: "$denom",
+        coinMinimalDenom: "$minimalDenom",
+        coinDecimals: 6,
+        gasPriceStep: {
+          low: 0.1,
+          average: 0.25,
+          high: 0.4,
+        },
+      },
+    ],
+    features: ["secretwasm"],
+  },
+  {
+    chainId: "juno-1",
+    chainName: "Juno",
+    rpc: "https://rpc-juno.mib.tech:443/",
+    rest: "https://lcd-juno.itastakers.com:443/",
+    stakeCurrency: {
+      coinDenom: "JUNO",
+      coinMinimalDenom: "ujuno",
+      coinDecimals: 6,
+    },
+    bip44: {
+      coinType: 118,
+    },
+    bech32Config: {
+      bech32PrefixAccAddr: "juno",
+      bech32PrefixAccPub: "junopub",
+      bech32PrefixValAddr: "junovaloper",
+      bech32PrefixValPub: "junovaloperpub",
+      bech32PrefixConsAddr: "junovalcons",
+      bech32PrefixConsPub: "junovalconspub",
+    },
+    currencies: [
+      {
+        coinDenom: "JUNO",
+        coinMinimalDenom: "ujuno",
+        coinDecimals: 6,
+        coinGeckoId: "juno-network",
+      },
+    ],
+    feeCurrencies: [
+      {
+        coinDenom: "JUNO",
+        coinMinimalDenom: "ujuno",
+        coinDecimals: 6,
+        coinGeckoId: "juno-network",
+      },
+    ],
+    coinType: 118,
+    gasPriceStep: {
+      low: 0.0025,
+      average: 0.01,
+      high: 0.025,
+    },
+    features: ["cosmwasm", "stargate", "ibc-transfer"],
+  },
 ];
diff --git a/packages/wc-client/src/index.ts b/packages/wc-client/src/index.ts
index b183f271d0..2737c44b88 100644
--- a/packages/wc-client/src/index.ts
+++ b/packages/wc-client/src/index.ts
@@ -22,6 +22,7 @@ import {
 import {
   CosmJSOfflineSigner,
   CosmJSOfflineSignerOnlyAmino,
+  KeplrEnigmaUtils,
 } from "@keplr-wallet/provider";
 import { SecretUtils } from "secretjs/types/enigmautils";
 import { payloadId } from "@walletconnect/utils";
@@ -72,6 +73,8 @@ export type KeplrKeystoreMayChangedEventParam = {
 };
 
 export class KeplrWalletConnectV1 implements Keplr {
+  protected enigmaUtils: Map<string, SecretUtils> = new Map();
+
   constructor(
     public readonly connector: IConnector,
     public readonly options: {
@@ -255,40 +258,83 @@ export class KeplrWalletConnectV1 implements Keplr {
     );
   }
 
-  enigmaDecrypt(
-    _chainId: string,
-    _ciphertext: Uint8Array,
-    _nonce: Uint8Array
+  async enigmaDecrypt(
+    chainId: string,
+    ciphertext: Uint8Array,
+    nonce: Uint8Array
   ): Promise<Uint8Array> {
-    throw new Error("Not yet implemented");
+    const encryptedBase64: string = (
+      await this.sendCustomRequest({
+        id: payloadId(),
+        jsonrpc: "2.0",
+        method: "keplr_enigma_decrypt_wallet_connect_v1",
+        params: [
+          chainId,
+          Buffer.from(ciphertext).toString("base64"),
+          Buffer.from(nonce).toString("base64"),
+        ],
+      })
+    )[0];
+    return Buffer.from(encryptedBase64, "base64");
   }
 
-  enigmaEncrypt(
-    _chainId: string,
-    _contractCodeHash: string,
+  async enigmaEncrypt(
+    chainId: string,
+    contractCodeHash: string,
     // eslint-disable-next-line @typescript-eslint/ban-types
-    _msg: object
+    msg: object
   ): Promise<Uint8Array> {
-    throw new Error("Not yet implemented");
+    const encryptedBase64: string = (
+      await this.sendCustomRequest({
+        id: payloadId(),
+        jsonrpc: "2.0",
+        method: "keplr_enigma_encrypt_wallet_connect_v1",
+        params: [chainId, contractCodeHash, msg],
+      })
+    )[0];
+    return Buffer.from(encryptedBase64, "base64");
   }
 
   experimentalSuggestChain(_chainInfo: ChainInfo): Promise<void> {
     throw new Error("Not yet implemented");
   }
 
-  getEnigmaPubKey(_chainId: string): Promise<Uint8Array> {
-    throw new Error("Not yet implemented");
+  async getEnigmaPubKey(chainId: string): Promise<Uint8Array> {
+    const encryptedBase64: string = (
+      await this.sendCustomRequest({
+        id: payloadId(),
+        jsonrpc: "2.0",
+        method: "keplr_enigma_pub_key_wallet_connect_v1",
+        params: [chainId],
+      })
+    )[0];
+    return Buffer.from(encryptedBase64, "base64");
   }
 
-  getEnigmaTxEncryptionKey(
-    _chainId: string,
-    _nonce: Uint8Array
+  async getEnigmaTxEncryptionKey(
+    chainId: string,
+    nonce: Uint8Array
   ): Promise<Uint8Array> {
-    throw new Error("Not yet implemented");
+    const encryptedBase64: string = (
+      await this.sendCustomRequest({
+        id: payloadId(),
+        jsonrpc: "2.0",
+        method: "keplr_enigma_tx_encryption_key_wallet_connect_v1",
+        params: [chainId, Buffer.from(nonce).toString("base64")],
+      })
+    )[0];
+    return Buffer.from(encryptedBase64, "base64");
   }
 
-  getEnigmaUtils(_chainId: string): SecretUtils {
-    throw new Error("Not yet implemented");
+  getEnigmaUtils(chainId: string): SecretUtils {
+    if (this.enigmaUtils.has(chainId)) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return this.enigmaUtils.get(chainId)!;
+    }
+
+    const enigmaUtils = new KeplrEnigmaUtils(chainId, this);
+    this.enigmaUtils.set(chainId, enigmaUtils);
+    return enigmaUtils;
   }
 
   async getKey(chainId: string): Promise<Key> {
@@ -412,11 +458,29 @@ export class KeplrWalletConnectV1 implements Keplr {
     return new CosmJSOfflineSignerOnlyAmino(chainId, this);
   }
 
-  getSecret20ViewingKey(
-    _chainId: string,
-    _contractAddress: string
+  async getSecret20ViewingKey(
+    chainId: string,
+    contractAddress: string
   ): Promise<string> {
-    throw new Error("Not yet implemented");
+    return (
+      await this.sendCustomRequest({
+        id: payloadId(),
+        jsonrpc: "2.0",
+        method: "keplr_get_scrt20_viewing_key_wallet_connect_v1",
+        params: [chainId, contractAddress],
+      })
+    )[0];
+  }
+
+  async getSecret20QueryAuthorization(
+    chainId: string,
+    contractAddress: string
+  ): Promise<{ permit: any | undefined; viewing_key: string | undefined }> {
+    return {
+      // todo: once support for saving permits is implemented, getting a saved permit should be implemented here
+      permit: null,
+      viewing_key: await this.getSecret20ViewingKey(chainId, contractAddress),
+    };
   }
 
   /**
@@ -475,12 +539,17 @@ export class KeplrWalletConnectV1 implements Keplr {
     throw new Error("Not yet implemented");
   }
 
-  suggestToken(
-    _chainId: string,
-    _contractAddress: string,
-    _viewingKey?: string
+  async suggestToken(
+    chainId: string,
+    contractAddress: string,
+    viewingKey?: string
   ): Promise<void> {
-    throw new Error("Not yet implemented");
+    await this.sendCustomRequest({
+      id: payloadId(),
+      jsonrpc: "2.0",
+      method: "keplr_suggest_token_wallet_connect_v1",
+      params: [chainId, contractAddress, viewingKey],
+    });
   }
 
   experimentalSignEIP712CosmosTx_v0(