diff --git a/frontend/src/components/AccountReceiveTable.vue b/frontend/src/components/AccountReceiveTable.vue
index 09d6f2bd3..576cff943 100644
--- a/frontend/src/components/AccountReceiveTable.vue
+++ b/frontend/src/components/AccountReceiveTable.vue
@@ -14,124 +14,161 @@
       <div class="text-center text-italic">Scanning for funds...</div>
     </div>
 
-    <q-table
-      v-else
-      :columns="mainTableColumns"
-      :data="formattedAnnouncements"
-      :expanded.sync="expanded"
-      no-data-label="This account has not received any funds"
-      :pagination="paginationConfig"
-      row-key="randomNumber"
-      title="Received Funds"
-    >
-      <!-- Header labels -->
-      <template v-slot:header="props">
-        <q-tr :props="props">
-          <q-th v-for="col in props.cols" :key="col.name" :props="props">
-            {{ col.label }}
-          </q-th>
-          <q-th auto-width />
-        </q-tr>
-      </template>
-
-      <!-- Body row configuration -->
-      <template v-slot:body="props">
-        <q-tr :props="props" :key="props.row.id">
-          <q-td v-for="col in props.cols" :key="col.name" :props="props">
-            <!-- Asset column -->
-            <div v-if="col.name === 'date'" class="d-inline-block">
-              <div
-                @click="openInEtherscan(props.row)"
-                class="row justify-start items-center cursor-pointer external-link-icon-parent"
-              >
-                <div class="col-auto">
-                  <div>{{ formatDate(col.value.timestamp * 1000) }}</div>
-                  <div class="text-caption text-grey">{{ formatTime(col.value.timestamp * 1000) }}</div>
+    <!-- Received funds table -->
+    <div v-else>
+      <div v-if="advancedMode" class="text-caption q-mb-sm">
+        {{ scanDescriptionString }}.
+        <span @click="context.emit('reset')" class="cursor-pointer hyperlink">Change scan settings</span>.
+      </div>
+      <q-table
+        :columns="mainTableColumns"
+        :data="formattedAnnouncements"
+        :expanded.sync="expanded"
+        no-data-label="This account has not received any funds"
+        :pagination="paginationConfig"
+        row-key="randomNumber"
+        title="Received Funds"
+      >
+        <!-- Header labels -->
+        <template v-slot:header="props">
+          <q-tr :props="props">
+            <q-th v-for="col in props.cols" :key="col.name" :props="props"> {{ col.label }} </q-th>
+            <q-th auto-width />
+          </q-tr>
+        </template>
+
+        <!-- Body row configuration -->
+        <template v-slot:body="props">
+          <q-tr :props="props" :key="props.row.id">
+            <q-td v-for="col in props.cols" :key="col.name" :props="props">
+              <!-- Asset column -->
+              <div v-if="col.name === 'date'" class="d-inline-block">
+                <div
+                  @click="openInEtherscan(props.row)"
+                  class="row justify-start items-center cursor-pointer external-link-icon-parent"
+                >
+                  <div class="col-auto">
+                    <div>{{ formatDate(col.value.timestamp * 1000) }}</div>
+                    <div class="text-caption text-grey">{{ formatTime(col.value.timestamp * 1000) }}</div>
+                  </div>
+                  <q-icon class="external-link-icon" name="fas fa-external-link-alt" right />
+                </div>
+              </div>
+
+              <!-- Amount column -->
+              <div v-else-if="col.name === 'amount'">
+                <div class="row justify-start items-center no-wrap">
+                  <img class="col-auto q-mr-md" :src="getTokenLogoUri(props.row.token)" style="width: 1.5rem" />
+                  <div class="col-auto">
+                    {{ formatAmount(col.value, props.row.token) }}
+                    {{ getTokenSymbol(props.row.token) }}
+                  </div>
                 </div>
-                <q-icon class="external-link-icon" name="fas fa-external-link-alt" right />
               </div>
-            </div>
-
-            <!-- Amount column -->
-            <div v-else-if="col.name === 'amount'">
-              <div class="row justify-start items-center no-wrap">
-                <img class="col-auto q-mr-md" :src="getTokenLogoUri(props.row.token)" style="width: 1.5rem" />
-                <div class="col-auto">
-                  {{ formatAmount(col.value, props.row.token) }}
-                  {{ getTokenSymbol(props.row.token) }}
+
+              <!-- From column -->
+              <div v-else-if="col.name === 'from'" class="d-inline-block">
+                <div @click="copySenderAddress(props.row)" class="cursor-pointer copy-icon-parent">
+                  <span>{{ col.value.from }}</span>
+                  <q-icon class="copy-icon" name="far fa-copy" right />
+                </div>
+                <div v-if="hasPayloadExtension(props.row.randomNumber)" class="text-caption text-grey">
+                  {{ formatPayloadExtensionText(props.row.randomNumber) }}
                 </div>
               </div>
-            </div>
 
-            <!-- From column -->
-            <div v-else-if="col.name === 'from'" class="d-inline-block">
-              <div @click="copySenderAddress(props.row)" class="cursor-pointer copy-icon-parent">
-                <span>{{ col.value.from }}</span>
-                <q-icon class="copy-icon" name="far fa-copy" right />
+              <!-- Default -->
+              <div v-else>{{ col.value }}</div>
+            </q-td>
+
+            <!-- Expansion button, works accordian-style -->
+            <!--
+            The click modifier is a bit clunky because it touches state in two independent composition functions,
+             so we explain the two things it does here
+              1. First it calls hidePrivateKey(), which is an advancedMode only feature to show your private key.
+                 We call this to make sure a private key is never shown when initially expanding a row
+              2. If the new row key is the same as the value of the value of expanded[0], we clicked the currently
+                 expanded row and therefore set `expanded = []` to hide the row. Otherwise we update the `expanded`
+                 array so it's only element is the key of the new row. This enables showing/hiding of rows and ensures
+                 only one row is every expanded at a time
+          -->
+            <q-td auto-width>
+              <div v-if="props.row.isWithdrawn" class="text-positive">
+                Withdrawn<q-icon name="fas fa-check" class="q-ml-sm" />
               </div>
-            </div>
-
-            <!-- Default -->
-            <div v-else>
-              {{ col.value }}
-            </div>
-          </q-td>
-
-          <!-- Expansion button, works accordian-style -->
-          <q-td auto-width>
-            <div v-if="props.row.isWithdrawn" class="text-positive">
-              Withdrawn<q-icon name="fas fa-check" class="q-ml-sm" />
-            </div>
-            <base-button
-              v-else
-              @click="expanded = expanded[0] === props.key ? [] : [props.key]"
-              color="primary"
-              :dense="true"
-              :flat="true"
-              :label="props.expand ? 'Hide' : 'Withdraw'"
-            />
-          </q-td>
-        </q-tr>
-
-        <!-- Expansion row -->
-        <q-tr v-show="props.expand" :props="props">
-          <q-td colspan="100%" class="bg-muted">
-            <q-form class="form q-py-md" style="white-space: normal">
-              <div>Enter address to withdraw funds to</div>
-              <base-input
-                v-model="destinationAddress"
-                @click="initializeWithdraw(props.row)"
-                appendButtonLabel="Withdraw"
-                :appendButtonDisable="isWithdrawInProgress"
-                :appendButtonLoading="isWithdrawInProgress"
+              <base-button
+                v-else
+                @click="
+                  hidePrivateKey();
+                  expanded = expanded[0] === props.key ? [] : [props.key];
+                "
+                color="primary"
+                :dense="true"
                 :disable="isWithdrawInProgress"
-                label="Address"
-                lazy-rules
-                :rules="(val) => (val && val.length > 4) || 'Please enter valid address'"
+                :flat="true"
+                :label="props.expand ? 'Hide' : 'Withdraw'"
               />
-              <div class="text-caption">
-                <span class="text-bold">WARNING</span>: Be sure you understand the security implications before entering
-                a withdrawal address. If you withdraw to an address publicly associated with you, privacy for this
-                transaction will be lost.
-              </div>
-            </q-form>
-          </q-td>
-        </q-tr>
-      </template>
-    </q-table>
+            </q-td>
+          </q-tr>
+
+          <!-- Expansion row -->
+          <q-tr v-show="props.expand" :props="props">
+            <q-td colspan="100%" class="bg-muted">
+              <q-form class="form-wide q-py-md" style="white-space: normal">
+                <div>Enter address to withdraw funds to</div>
+                <base-input
+                  v-model="destinationAddress"
+                  @click="initializeWithdraw(props.row)"
+                  appendButtonLabel="Withdraw"
+                  :appendButtonDisable="isWithdrawInProgress"
+                  :appendButtonLoading="isWithdrawInProgress"
+                  :disable="isWithdrawInProgress"
+                  label="Address"
+                  lazy-rules
+                  :rules="(val) => (val && val.length > 4) || 'Please enter valid address'"
+                />
+                <div class="text-caption">
+                  <span class="text-bold">WARNING</span>: Be sure you understand the security implications before
+                  entering a withdrawal address. If you withdraw to an address publicly associated with you, privacy for
+                  this transaction will be lost.
+                </div>
+
+                <!-- Advanced feature: show private key -->
+                <div v-if="advancedMode">
+                  <div @click="togglePrivateKey(props.row)" class="text-caption hyperlink q-mt-lg">
+                    {{ spendingPrivateKey ? 'Hide' : 'Show' }} withdrawal private key
+                  </div>
+                  <div
+                    v-if="spendingPrivateKey"
+                    @click="copyPrivateKey(spendingPrivateKey)"
+                    class="cursor-pointer copy-icon-parent q-mt-sm"
+                  >
+                    <span class="text-caption">{{ spendingPrivateKey }}</span>
+                    <q-icon class="copy-icon" name="far fa-copy" right />
+                  </div>
+                </div>
+              </q-form>
+            </q-td>
+          </q-tr>
+        </template>
+      </q-table>
+    </div>
   </div>
 </template>
 
 <script lang="ts">
-import { defineComponent, onMounted, PropType, ref } from '@vue/composition-api';
+import { computed, defineComponent, onMounted, PropType, ref } from '@vue/composition-api';
 import { date, copyToClipboard } from 'quasar';
 import { Contract } from 'ethers';
 import { BigNumber } from '@ethersproject/bignumber';
+import { arrayify } from '@ethersproject/bytes';
 import { Block, ExternalProvider, TransactionResponse, Web3Provider } from '@ethersproject/providers';
+import { toUtf8String } from '@ethersproject/strings';
 import { formatUnits } from '@ethersproject/units';
 import { DomainService, Umbra, UserAnnouncement, KeyPair } from '@umbra/umbra-js';
 import { RelayProvider } from '@opengsn/gsn/dist/src/relayclient/RelayProvider';
 import { Web3ProviderBaseInterface } from '@opengsn/gsn/dist/src/common/types/Aliases';
+import useSettingsStore from 'src/store/settings';
 import useWalletStore from 'src/store/wallet';
 import useAlerts from 'src/utils/alerts';
 import UmbraRelayRecipient from 'src/contracts/umbra-relay-recipient.json';
@@ -140,8 +177,47 @@ import { SupportedChainIds } from 'components/models';
 import { lookupOrFormatAddresses, toAddress, isAddressSafe } from 'src/utils/address';
 import BaseButton from './BaseButton.vue';
 
-function useReceivedFundsTable(announcements: UserAnnouncement[]) {
-  const { tokens, userAddress, signer, provider, umbra, spendingKeyPair, domainService } = useWalletStore();
+function useAdvancedFeatures(spendingKeyPair: KeyPair) {
+  const { startBlock, endBlock, scanPrivateKey } = useSettingsStore();
+  const { notifyUser } = useAlerts();
+  const spendingPrivateKey = ref<string>(); // used for hiding/showing private key in UI, so not a computed property
+
+  const scanDescriptionString = computed(() => {
+    const suffix = scanPrivateKey.value ? ' with custom private key' : '';
+    const hasStartBlock = Number(startBlock.value) >= 0;
+    const hasEndBlock = Number(endBlock.value) >= 0;
+    let msg = `Scanned from block ${Number(startBlock.value)} to ${Number(endBlock.value)}`; // default message
+
+    if (!hasStartBlock && !hasEndBlock) msg = 'All blocks have been scanned';
+    if (!hasStartBlock && hasEndBlock) msg = `Scanned all blocks up to ${Number(endBlock.value)}`;
+    if (hasStartBlock && !hasEndBlock) msg = `Scanned from block ${Number(startBlock.value)} to current block`;
+    return `${msg}${suffix}`;
+  });
+
+  function computePrivateKey(randomNumber: string) {
+    const stealthKeyPair = spendingKeyPair.mulPrivateKey(randomNumber);
+    return stealthKeyPair.privateKeyHex as string;
+  }
+
+  function hidePrivateKey() {
+    spendingPrivateKey.value = undefined;
+  }
+
+  function togglePrivateKey(announcement: UserAnnouncement) {
+    spendingPrivateKey.value = spendingPrivateKey.value ? undefined : computePrivateKey(announcement.randomNumber);
+  }
+
+  async function copyPrivateKey(privateKey: string) {
+    await copyToClipboard(privateKey);
+    notifyUser('positive', 'Private key copied to clipboard');
+    hidePrivateKey();
+  }
+
+  return { scanDescriptionString, hidePrivateKey, togglePrivateKey, spendingPrivateKey, copyPrivateKey };
+}
+
+function useReceivedFundsTable(announcements: UserAnnouncement[], spendingKeyPair: KeyPair) {
+  const { tokens, userAddress, signer, provider, umbra, domainService } = useWalletStore();
   const { txNotify, notifyUser } = useAlerts();
   const paginationConfig = { rowsPerPage: 25 };
   const expanded = ref<string[]>([]); // for managing expansion rows
@@ -151,35 +227,22 @@ function useReceivedFundsTable(announcements: UserAnnouncement[]) {
   const destinationAddress = ref('');
   const isWithdrawInProgress = ref(false);
   const activeAnnouncement = ref<UserAnnouncement>();
+
+  // Define table columns
+  const sortByTime = (a: Block, b: Block) => b.timestamp - a.timestamp;
+  const toString = (val: BigNumber) => val.toString();
   const mainTableColumns = [
-    {
-      align: 'left',
-      field: 'block',
-      label: 'Date Received',
-      name: 'date',
-      sortable: true,
-      sort: (a: Block, b: Block) => b.timestamp - a.timestamp,
-    },
-    {
-      align: 'left',
-      field: 'amount',
-      label: 'Amount',
-      name: 'amount',
-      sortable: true,
-      format: (val: BigNumber) => val.toString(),
-    },
-    {
-      align: 'left',
-      field: 'receipt',
-      label: 'From',
-      name: 'from',
-      sortable: true,
-    },
+    { align: 'left', field: 'block', label: 'Date Received', name: 'date', sortable: true, sort: sortByTime },
+    { align: 'left', field: 'amount', label: 'Amount', name: 'amount', sortable: true, format: toString },
+    { align: 'left', field: 'receipt', label: 'From', name: 'from', sortable: true },
   ];
 
   // Table formatters and helpers
   const formatDate = (timestamp: number) => date.formatDate(timestamp, 'YYYY-MM-DD');
   const formatTime = (timestamp: number) => date.formatDate(timestamp, 'H:mm A');
+  const zeroPrefix = '0x00000000000000000000000000000000'; // 16 bytes of zeros
+  const hasPayloadExtension = (randomNumber: string) => randomNumber.slice(0, 34) !== zeroPrefix;
+  const formatPayloadExtensionText = (randomNumber: string) => toUtf8String(arrayify(randomNumber.slice(0, 34)));
   const isEth = (tokenAddress: string) => tokenAddress === '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
   const getTokenInfo = (tokenAddress: string) => tokens.value.filter((token) => token.address === tokenAddress)[0];
   const getStealthBalance = async (tokenAddress: string, userAddress: string) => {
@@ -270,7 +333,7 @@ function useReceivedFundsTable(announcements: UserAnnouncement[]) {
     // Get token info, stealth private key, and destination (acceptor) address
     const announcement = activeAnnouncement.value;
     const token = getTokenInfo(announcement.token);
-    const stealthKeyPair = (spendingKeyPair.value as KeyPair).mulPrivateKey(announcement.randomNumber);
+    const stealthKeyPair = spendingKeyPair.mulPrivateKey(announcement.randomNumber);
     const spendingPrivateKey = stealthKeyPair.privateKeyHex as string;
     const destinationAddr = await toAddress(destinationAddress.value, domainService.value as DomainService);
 
@@ -346,24 +409,26 @@ function useReceivedFundsTable(announcements: UserAnnouncement[]) {
   }
 
   return {
-    isWithdrawInProgress,
-    isLoading,
-    showPrivacyModal,
-    privacyModalAddressDescription,
-    expanded,
     copySenderAddress,
-    openInEtherscan,
-    paginationConfig,
-    mainTableColumns,
+    destinationAddress,
+    executeWithdraw,
+    expanded,
+    formatAmount,
     formatDate,
+    formatPayloadExtensionText,
+    formattedAnnouncements,
     formatTime,
     getTokenLogoUri,
     getTokenSymbol,
-    formatAmount,
-    formattedAnnouncements,
-    destinationAddress,
+    hasPayloadExtension,
     initializeWithdraw,
-    executeWithdraw,
+    isLoading,
+    isWithdrawInProgress,
+    mainTableColumns,
+    openInEtherscan,
+    paginationConfig,
+    privacyModalAddressDescription,
+    showPrivacyModal,
   };
 }
 
@@ -377,8 +442,22 @@ export default defineComponent({
     },
   },
 
-  setup(props) {
-    return { ...useReceivedFundsTable(props.announcements) };
+  setup(props, context) {
+    const { advancedMode, scanPrivateKey } = useSettingsStore();
+
+    // Check for manually entered private key in advancedMode, otherwise use the key from user's signature
+    const { spendingKeyPair: spendingKeyPairFromSig } = useWalletStore();
+    const spendingKeyPair = computed(() => {
+      if (advancedMode.value && scanPrivateKey.value) return new KeyPair(scanPrivateKey.value);
+      return spendingKeyPairFromSig.value as KeyPair;
+    });
+
+    return {
+      advancedMode,
+      context,
+      ...useAdvancedFeatures(spendingKeyPair.value),
+      ...useReceivedFundsTable(props.announcements, spendingKeyPair.value),
+    };
   },
 });
 </script>
diff --git a/frontend/src/components/BaseInput.vue b/frontend/src/components/BaseInput.vue
index 1225c83b7..1041d88f6 100644
--- a/frontend/src/components/BaseInput.vue
+++ b/frontend/src/components/BaseInput.vue
@@ -32,6 +32,17 @@
         @click="handleClick"
       />
     </template>
+    <template v-else-if="counter" v-slot:append>
+      <q-circular-progress
+        :value="counter"
+        size="2.75rem"
+        :color="counter > 100 ? 'negative' : 'primary'"
+        show-value
+        track-color="grey-4"
+      >
+        {{ counter }} %
+      </q-circular-progress>
+    </template>
   </q-input>
 </template>
 
@@ -78,6 +89,12 @@ export default Vue.extend({
       default: undefined,
     },
 
+    counter: {
+      type: Number,
+      required: false,
+      default: undefined,
+    },
+
     dense: {
       type: Boolean,
       required: false,
@@ -175,6 +192,7 @@ export default Vue.extend({
 
     hideHint() {
       this.hintString = '';
+      this.$emit('blur', this.content);
     },
 
     showHint() {
diff --git a/frontend/src/css/app.sass b/frontend/src/css/app.sass
index 2c5d8537f..b73881cf3 100644
--- a/frontend/src/css/app.sass
+++ b/frontend/src/css/app.sass
@@ -87,7 +87,12 @@ p, div
   text-align: center
 
 .form
-  max-width: 510px
+  max-width: 475px
+  margin: 0 auto
+
+.form-wide
+  // Slightly wider form to ensure withdrawal addresses and private keys don't wrap on the receive table
+  max-width: 525px
   margin: 0 auto
 
 .horizontal-center
diff --git a/frontend/src/layouts/BaseLayout.vue b/frontend/src/layouts/BaseLayout.vue
index ff211072b..4112639df 100644
--- a/frontend/src/layouts/BaseLayout.vue
+++ b/frontend/src/layouts/BaseLayout.vue
@@ -52,8 +52,13 @@
 
             <!-- ADDRESS AND SETTINGS AND SETTINGS -->
             <div class="col-auto q-mr-md">
-              <div v-if="userDisplayName" class="text-caption dark-toggle">
-                {{ userDisplayName }}
+              <div>
+                <span v-if="userDisplayName" class="text-caption dark-toggle">
+                  {{ userDisplayName }}
+                </span>
+                <span v-if="advancedMode" class="q-ml-md">
+                  🧙 <q-tooltip content-class="bg-muted dark-toggle shadow-2 q-pa-md"> Advanced mode is on </q-tooltip>
+                </span>
               </div>
             </div>
           </div>
@@ -71,29 +76,44 @@
 
     <q-footer class="q-mx-md q-mb-md q-pt-xl" style="color: #000000; background-color: rgba(0, 0, 0, 0)">
       <div class="row justify-between">
-        <div class="col-auto">
+        <!-- Column 1: User settings -->
+        <div class="col">
+          <!-- Dark mode toggle -->
           <q-icon
             v-if="!$q.dark.isActive"
-            class="dark-toggle"
+            @click="toggleDarkMode"
+            class="dark-toggle cursor-pointer"
             name="fas fa-moon"
-            size="xs"
-            style="cursor: pointer"
-            @click="toggleDarkMode()"
           />
-          <q-icon
-            v-else
-            class="dark-toggle"
-            name="fas fa-sun"
-            size="xs"
-            style="cursor: pointer"
-            @click="toggleDarkMode()"
+          <q-icon v-else @click="toggleDarkMode" class="dark-toggle cursor-pointer" name="fas fa-sun" />
+
+          <!-- Advanced mode toggle -->
+          <q-toggle
+            @input="toggleAdvancedMode"
+            :value="advancedMode"
+            class="q-ml-lg"
+            color="primary"
+            icon="fas fa-cog"
           />
+          <span class="dark-toggle text-caption">Advanced mode {{ advancedMode ? 'on' : 'off' }}</span>
+          <span>
+            <q-icon class="dark-toggle" right name="fas fa-question-circle">
+              <q-tooltip content-class="bg-muted dark-toggle shadow-2 q-pa-md" max-width="14rem">
+                Enables advanced features such as private key export, additional recipient ID options, and event
+                scanning settings. <span class="text-bold">Use with caution!</span>
+              </q-tooltip>
+            </q-icon>
+          </span>
         </div>
-        <div class="col-auto text-caption">
+
+        <!-- Column 2: Built by ScopeLift -->
+        <div class="col text-center text-caption">
           Built by
           <a href="https://www.scopelift.co/" target="_blank" class="hyperlink">ScopeLift</a>
         </div>
-        <div class="col-auto">
+
+        <!-- Column 3: Links -->
+        <div class="col text-right">
           <a href="https://twitter.com/UmbraCash" target="_blank" class="no-text-decoration">
             <q-icon class="dark-toggle" name="fab fa-twitter" size="xs" />
           </a>
@@ -110,23 +130,10 @@
 </template>
 
 <script lang="ts">
-import { defineComponent, onMounted, ref, watchEffect } from '@vue/composition-api';
-import { Dark, LocalStorage } from 'quasar';
+import { defineComponent, ref, watchEffect } from '@vue/composition-api';
+import useSettingsStore from 'src/store/settings';
 import useWalletStore from 'src/store/wallet';
 
-function useDarkMode() {
-  function toggleDarkMode() {
-    Dark.set(!Dark.isActive);
-    LocalStorage.set('is-dark', Dark.isActive);
-  }
-
-  const mounted = onMounted(function () {
-    Dark.set(Boolean(LocalStorage.getItem('is-dark')));
-  });
-
-  return { toggleDarkMode, mounted };
-}
-
 function useWallet() {
   const { userDisplayName, network } = useWalletStore();
   const networkName = ref('');
@@ -143,7 +150,8 @@ function useWallet() {
 export default defineComponent({
   name: 'BaseLayout',
   setup() {
-    return { ...useDarkMode(), ...useWallet() };
+    const { advancedMode, toggleAdvancedMode, isDark, toggleDarkMode } = useSettingsStore();
+    return { advancedMode, toggleAdvancedMode, isDark, toggleDarkMode, ...useWallet() };
   },
 });
 </script>
diff --git a/frontend/src/pages/AccountReceive.vue b/frontend/src/pages/AccountReceive.vue
index fdc717c59..f80c4e6e6 100644
--- a/frontend/src/pages/AccountReceive.vue
+++ b/frontend/src/pages/AccountReceive.vue
@@ -9,9 +9,49 @@
 
     <div v-else class="q-mx-auto" style="max-width: 800px">
       <!-- Waiting for signature -->
-      <div v-if="!hasKeys" class="form">
-        <div class="text-center q-mb-md">This app needs your signature to scan for funds you've received</div>
-        <base-button @click="getPrivateKeysHandler" class="text-center" label="Sign" />
+      <div v-if="needsSignature || scanStatus === 'waiting'" class="form">
+        <div v-if="needsSignature" class="text-center q-mb-md">
+          This app needs your signature to scan for funds you've received
+        </div>
+        <div v-else class="text-center q-mb-md">Click below to scan for funds you've received</div>
+        <base-button @click="getPrivateKeysHandler" class="text-center" :label="needsSignature ? 'Sign' : 'Scan'" />
+
+        <!-- Advanced mode settings -->
+        <q-card v-if="advancedMode" class="q-pt-md q-px-md q-mt-xl">
+          <q-card-section class="text-center text-primary text-h6 header-black q-pb-none">
+            Scan Settings
+          </q-card-section>
+          <q-card-section>
+            <q-form class="text-left" ref="settingsFormRef">
+              <div>
+                Enter the start or end blocks to use when scanning for events. A blank start block will scan from block
+                zero, and a blank end block will scan through the current block.
+              </div>
+              <div class="row justify-start">
+                <base-input
+                  v-model.number="startBlockLocal"
+                  @blur="setScanBlocks(startBlockLocal, endBlockLocal)"
+                  class="col-5"
+                  label="Start block"
+                  :rules="isValidStartBlock"
+                />
+                <base-input
+                  v-model.number="endBlockLocal"
+                  @blur="setScanBlocks(startBlockLocal, endBlockLocal)"
+                  class="col-5 q-ml-md"
+                  label="End block"
+                  :rules="isValidEndBlock"
+                />
+              </div>
+              <div>
+                Enter the private key to use when scanning for events. A blank private key will use the ones generated
+                from your signature.
+              </div>
+              <!-- Unlike start blocks, no action on blur because we don't want to save private key to LocalStorage -->
+              <base-input v-model="scanPrivateKeyLocal" label="Private key" :rules="isValidPrivateKey" />
+            </q-form>
+          </q-card-section>
+        </q-card>
       </div>
 
       <!-- Scanning in progress -->
@@ -22,51 +62,112 @@
 
       <!-- Scanning complete -->
       <div v-else-if="scanStatus === 'complete'" class="text-center">
-        <account-receive-table :announcements="userAnnouncements" />
+        <account-receive-table :announcements="userAnnouncements" @reset="setFormStatus('waiting', '')" />
       </div>
     </div>
   </q-page>
 </template>
 
 <script lang="ts">
-import { defineComponent, onMounted, ref } from '@vue/composition-api';
+import { computed, defineComponent, onMounted, ref } from '@vue/composition-api';
+import { QForm } from 'quasar';
 import { UserAnnouncement } from '@umbra/umbra-js';
+import { isHexString } from '@ethersproject/bytes';
+import useSettingsStore from 'src/store/settings';
 import useWallet from 'src/store/wallet';
 import AccountReceiveTable from 'components/AccountReceiveTable.vue';
 import ConnectWalletCard from 'components/ConnectWalletCard.vue';
 
 function useScan() {
   const { getPrivateKeys, umbra, spendingKeyPair, viewingKeyPair, hasKeys, userAddress } = useWallet();
-  const scanStatus = ref<'waiting' | 'scanning' | 'complete'>('waiting');
+  type ScanStatus = 'waiting' | 'scanning' | 'complete';
+  const scanStatus = ref<ScanStatus>('waiting');
   const userAnnouncements = ref<UserAnnouncement[]>([]);
 
+  // Start and end blocks for advanced mode settings
+  const { advancedMode, startBlock, endBlock, setScanBlocks, setScanPrivateKey, scanPrivateKey } = useSettingsStore();
+  const startBlockLocal = ref<number>();
+  const endBlockLocal = ref<number>();
+  const scanPrivateKeyLocal = ref<string>();
+  const needsSignature = computed(() => !hasKeys.value && !scanPrivateKeyLocal.value);
+  const settingsFormRef = ref<QForm>(); // for programtically verifying settings form
+
+  // Form validators and configurations
+  const badPrivKeyMsg = 'Please enter a valid private key';
+  const isAnyHex = (val: string) => isHexString(val) || isHexString(`0x${val}`);
+  const isValidPrivateKey = (val: string) => !val || (isAnyHex(val) && [66, 64].includes(val.length)) || badPrivKeyMsg;
+  const isValidStartBlock = (val: string) => !val || Number(val) > 0 || 'Please enter a valid start block';
+  const isValidEndBlock = (val: string) => !val || Number(val) > 0 || 'Please enter a valid start block';
+  const setFormStatus = (scanStatusVal: ScanStatus, scanPrivateKey: string) => {
+    scanStatus.value = scanStatusVal;
+    if (scanPrivateKey.length === 64) scanPrivateKey = `0x${scanPrivateKey}`;
+    setScanPrivateKey(scanPrivateKey);
+    scanPrivateKeyLocal.value = scanPrivateKey;
+  };
+
   onMounted(async () => {
-    // If user already signed and we have their keys in memory, start scanning
-    if (hasKeys.value) {
-      await scan();
-    }
+    startBlockLocal.value = startBlock.value; // read in last used startBlock
+    endBlockLocal.value = endBlock.value; // read in last used endBlock
+    if (hasKeys.value) await scan(); // if user already signed and we have their keys in memory, start scanning
   });
 
   async function getPrivateKeysHandler() {
-    const success = await getPrivateKeys();
-    if (!success) return; // user denied signature or an error was thrown
-    await scan(); // start scanning right after we get the user's signature
+    // Validate form
+    if (advancedMode.value) {
+      const isFormValid = await settingsFormRef.value?.validate(true);
+      if (!isFormValid) return;
+    }
+    if (Number(startBlock.value) > Number(endBlock.value)) {
+      throw new Error('End block is larger than start block');
+    }
+
+    // Get user's signature if required
+    if (needsSignature.value) {
+      const success = await getPrivateKeys();
+      if (!success) return; // user denied signature or an error was thrown
+    }
+
+    // Save off the scanPrivateKeyLocal to memory if it exists, then scan
+    if (scanPrivateKeyLocal.value) setScanPrivateKey(scanPrivateKeyLocal.value);
+    await scan();
   }
 
   async function scan() {
-    if (!umbra.value) {
-      throw new Error('No umbra instance found. Please make sure you are on a supported network');
-    }
+    if (!umbra.value) throw new Error('No umbra instance found. Please make sure you are on a supported network');
     scanStatus.value = 'scanning';
-    const { userAnnouncements: announcements } = await umbra.value.scan(
-      String(spendingKeyPair.value?.publicKeyHex),
-      String(viewingKeyPair.value?.privateKeyHex)
-    );
+
+    // Check for manually entered private key in advancedMode, otherwise use the key from user's signature
+    const chooseKey = (keyPair: string | undefined | null) => {
+      if (advancedMode.value && scanPrivateKey.value) return String(scanPrivateKey.value);
+      return String(keyPair);
+    };
+
+    // Scan for funds
+    const spendingPubKey = chooseKey(spendingKeyPair.value?.publicKeyHex);
+    const viewingPrivKey = chooseKey(viewingKeyPair.value?.privateKeyHex);
+    const overrides = { startBlock: startBlock.value, endBlock: endBlock.value };
+    const { userAnnouncements: announcements } = await umbra.value.scan(spendingPubKey, viewingPrivKey, overrides);
     userAnnouncements.value = announcements;
     scanStatus.value = 'complete';
   }
 
-  return { userAddress, hasKeys, scanStatus, getPrivateKeysHandler, userAnnouncements };
+  return {
+    advancedMode,
+    endBlockLocal,
+    getPrivateKeysHandler,
+    isValidEndBlock,
+    isValidPrivateKey,
+    isValidStartBlock,
+    needsSignature,
+    scanPrivateKeyLocal,
+    scanStatus,
+    setFormStatus,
+    setScanBlocks,
+    settingsFormRef,
+    startBlockLocal,
+    userAddress,
+    userAnnouncements,
+  };
 }
 
 export default defineComponent({
diff --git a/frontend/src/pages/AccountSend.vue b/frontend/src/pages/AccountSend.vue
index cca942616..2790ae552 100644
--- a/frontend/src/pages/AccountSend.vue
+++ b/frontend/src/pages/AccountSend.vue
@@ -10,38 +10,54 @@
     <!-- Send form -->
     <q-form v-else @submit="onFormSubmit" class="form" ref="sendFormRef">
       <!-- Identifier -->
-      <div>Recipient's ENS name</div>
-      <base-input v-model="recipientId" placeholder="vitalik.eth" lazy-rules :rules="isValidId" />
+      <div v-if="!advancedMode">Recipient's ENS or CNS name</div>
+      <div v-else>Recipient's ENS name, CNS name, transaction hash, address, or uncompressed public key</div>
+      <base-input v-model="recipientId" :disable="isSending" placeholder="vitalik.eth" lazy-rules :rules="isValidId" />
 
       <!-- Token -->
       <div>Select token to send</div>
-      <base-select v-model="token" filled label="Token" :options="tokenOptions" option-label="symbol" />
+      <base-select
+        v-model="token"
+        :disable="isSending"
+        filled
+        label="Token"
+        :options="tokenOptions"
+        option-label="symbol"
+      />
 
       <!-- Amount -->
       <div>Amount to send</div>
-      <base-input v-model="humanAmount" placeholder="0" lazy-rules :rules="isValidTokenAmount" />
+      <base-input v-model="humanAmount" :disable="isSending" placeholder="0" lazy-rules :rules="isValidTokenAmount" />
+
+      <!-- Memo (payload extension) -->
+      <div>Include a brief, optional<span v-if="advancedMode"> 16 byte</span> memo</div>
+      <base-input
+        v-model="memo"
+        :counter="payloadCounter"
+        :disable="isSending"
+        placeholder="Memo"
+        lazy-rules
+        :rules="isValidMemo"
+      />
 
       <!-- Send button -->
       <div>
-        <base-button
-          :disable="isSendInProgress"
-          :full-width="true"
-          label="Send"
-          :loading="isSendInProgress"
-          type="submit"
-        />
+        <base-button :disable="isSending" :full-width="true" label="Send" :loading="isSending" type="submit" />
       </div>
     </q-form>
   </q-page>
 </template>
 
 <script lang="ts">
-import { defineComponent, ref } from '@vue/composition-api';
+import { computed, defineComponent, ref } from '@vue/composition-api';
 import { QForm } from 'quasar';
+import { isHexString, hexlify, hexZeroPad } from '@ethersproject/bytes';
 import { MaxUint256 } from '@ethersproject/constants';
 import { Contract } from '@ethersproject/contracts';
 import { parseUnits } from '@ethersproject/units';
-import { ens } from '@umbra/umbra-js';
+import { toUtf8Bytes } from '@ethersproject/strings';
+import { ens, cns } from '@umbra/umbra-js';
+import useSettingsStore from 'src/store/settings';
 import useWalletStore from 'src/store/wallet';
 import useAlerts from 'src/utils/alerts';
 import { TokenInfo } from 'components/models';
@@ -49,17 +65,37 @@ import erc20 from 'src/contracts/erc20.json';
 import ConnectWalletCard from 'components/ConnectWalletCard.vue';
 
 function useSendForm() {
+  const { advancedMode } = useSettingsStore();
   const { tokens: tokenOptions, getTokenBalances, balances, umbra, signer, userAddress } = useWalletStore();
   const { txNotify } = useAlerts();
 
+  // Helpers
+  const sendFormRef = ref<QForm>();
+  const isSending = ref(false);
+  const zeroPrefix = '0x00000000000000000000000000000000'; // 16 bytes of zeros
+  const is16BytesOrLess = (val: string) => isHexString(val) && val.length <= 34; // 0x + 16 hex bytes = 34 characters
+
+  // Form parameters
   const recipientId = ref<string>();
   const token = ref<TokenInfo>();
   const humanAmount = ref<string>();
-  const sendFormRef = ref<QForm>();
-  const isSendInProgress = ref(false);
+  const memo = ref<string>();
+  const payloadExtension = computed(() => (memo.value ? hexlify(toUtf8Bytes(memo.value)) : zeroPrefix));
+  const payloadCounter = computed(() =>
+    // Counts percentage progress of payload extension. Reaches 100% at 16 bytes
+    payloadExtension.value === zeroPrefix ? 0 : Math.round((100 * payloadExtension.value.slice(2).length) / 32)
+  );
 
   function isValidId(val: string) {
-    if (val && (ens.isEnsDomain(val) || val.endsWith('.crypto'))) return true;
+    if (val && (ens.isEnsDomain(val) || cns.isCnsDomain(val))) return true;
+    if (advancedMode.value) {
+      // Also allow identifying recipient by transaction hash, address, or public key. We copy the checks
+      // used by utils.lookupRecipient() here
+      const isPublicKey = val.length === 132 && isHexString(val);
+      const isTxHash = val.length === 66 && isHexString(val);
+      const isValidAddress = val.length === 42 && isHexString(val);
+      return isPublicKey || isTxHash || isValidAddress || 'Please enter a valid recipient identifer';
+    }
     return 'Please enter an ENS or CNS name';
   }
 
@@ -71,12 +107,23 @@ function useSendForm() {
     return amount.gt(balances.value[tokenAddress]) ? 'Amount exceeds wallet balance' : true;
   }
 
+  function isValidMemo(val: string) {
+    // No memo is a valid value
+    if (!val) return true;
+
+    // Memo is limited to 16 bytes of data. Length of a Uint8Array is the number of bytes in that array, but since we
+    // pass it as hex we check the hex length in case there's bugs in hexlify that would make the length incorrect
+    const suffix = advancedMode.value ? ' (cannot be longer than 16 bytes)' : '';
+    return is16BytesOrLess(payloadExtension.value) || `Memo is too long${suffix}`;
+  }
+
   async function onFormSubmit() {
     try {
       // Form validation
       if (!recipientId.value || !token.value || !humanAmount.value) throw new Error('Please complete the form');
       if (!signer.value) throw new Error('Wallet not connected');
       if (!umbra.value) throw new Error('Umbra instance not configured');
+      if (!is16BytesOrLess(payloadExtension.value)) throw new Error('Memo too long. Cannot be longer than 16 bytes');
 
       // Ensure user has enough balance. We re-fetch user token balances in case amounts changed
       // after wallet was connected
@@ -86,7 +133,7 @@ function useSendForm() {
       if (amount.gt(balances.value[tokenAddress])) throw new Error('Amount exceeds wallet balance');
 
       // If token, get approval
-      isSendInProgress.value = true;
+      isSending.value = true;
       if (token.value.symbol !== 'ETH') {
         // Check allowance
         const tokenContract = new Contract(token.value.address, erc20.abi, signer.value);
@@ -101,12 +148,13 @@ function useSendForm() {
       }
 
       // Send with Umbra
-      const { tx } = await umbra.value.send(signer.value, tokenAddress, amount, recipientId.value);
+      const overrides = { payloadExtension: hexZeroPad(payloadExtension.value, 16) };
+      const { tx } = await umbra.value.send(signer.value, tokenAddress, amount, recipientId.value, overrides);
       txNotify(tx.hash);
       await tx.wait();
       resetForm();
     } finally {
-      isSendInProgress.value = false;
+      isSending.value = false;
     }
   }
 
@@ -114,20 +162,25 @@ function useSendForm() {
     recipientId.value = undefined;
     token.value = undefined;
     humanAmount.value = undefined;
+    memo.value = undefined;
     sendFormRef.value?.resetValidation();
   }
 
   return {
-    userAddress,
-    isSendInProgress,
-    sendFormRef,
-    recipientId,
+    advancedMode,
     humanAmount,
-    tokenOptions,
-    token,
-    onFormSubmit,
+    isSending,
     isValidId,
+    isValidMemo,
     isValidTokenAmount,
+    memo,
+    onFormSubmit,
+    payloadCounter,
+    recipientId,
+    sendFormRef,
+    token,
+    tokenOptions,
+    userAddress,
   };
 }
 
diff --git a/frontend/src/store/settings.ts b/frontend/src/store/settings.ts
new file mode 100644
index 000000000..25ff22ef5
--- /dev/null
+++ b/frontend/src/store/settings.ts
@@ -0,0 +1,68 @@
+import { computed, onMounted, ref } from '@vue/composition-api';
+import { Dark, LocalStorage } from 'quasar';
+
+// Local storage key names
+const settings = {
+  isDark: 'is-dark',
+  advancedMode: 'advanced-mode',
+  startBlock: 'start-block',
+  endBlock: 'end-block',
+};
+
+// Shared state between instances
+const isDark = ref(false); // true if user has dark mode turned on
+const advancedMode = ref(false); // true if user has advanced mode turned on
+const startBlock = ref<number | undefined>(undefined); // block number to start scanning from
+const endBlock = ref<number | undefined>(undefined); // block number to scan through
+const scanPrivateKey = ref<string>(); // private key entered when scanning
+
+// Composition function for managing state
+export default function useSettingsStore() {
+  onMounted(() => {
+    setDarkMode(Boolean(LocalStorage.getItem(settings.isDark)));
+    advancedMode.value = Boolean(LocalStorage.getItem(settings.advancedMode));
+    startBlock.value = Number(LocalStorage.getItem(settings.startBlock)) || undefined;
+    endBlock.value = Number(LocalStorage.getItem(settings.endBlock)) || undefined;
+  });
+
+  function setDarkMode(status: boolean) {
+    // In addition to Quasars `Dark` param, we use the isDark state value with this setter, so we can reactively track
+    // the dark mode status in Vue
+    isDark.value = status;
+    Dark.set(status);
+  }
+
+  function toggleDarkMode() {
+    setDarkMode(!isDark.value);
+    LocalStorage.set(settings.isDark, isDark.value);
+  }
+
+  function toggleAdvancedMode() {
+    advancedMode.value = !advancedMode.value;
+    LocalStorage.set(settings.advancedMode, advancedMode.value);
+  }
+
+  function setScanBlocks(startBlock_: number, endBlock_: number) {
+    startBlock.value = startBlock_;
+    endBlock.value = endBlock_;
+    LocalStorage.set(settings.startBlock, startBlock_);
+    LocalStorage.set(settings.endBlock, endBlock_);
+  }
+
+  function setScanPrivateKey(key: string) {
+    if (key.length === 64) key = `0x${key}`;
+    scanPrivateKey.value = key; // we save this in memory for access by components, but do not save it to LocalStorage
+  }
+
+  return {
+    toggleDarkMode,
+    toggleAdvancedMode,
+    setScanBlocks,
+    setScanPrivateKey,
+    isDark: computed(() => isDark.value),
+    advancedMode: computed(() => advancedMode.value),
+    startBlock: computed(() => startBlock.value),
+    endBlock: computed(() => endBlock.value),
+    scanPrivateKey: computed(() => scanPrivateKey.value),
+  };
+}
diff --git a/frontend/src/utils/address.ts b/frontend/src/utils/address.ts
index 6f64a0501..ed6dcf9fe 100644
--- a/frontend/src/utils/address.ts
+++ b/frontend/src/utils/address.ts
@@ -34,19 +34,25 @@ export const lookupCnsName = async (address: string, provider: Provider) => {
   const url = chainId === 4 ? `${baseUrl}/dot-crypto-rinkeby-registry` : `${baseUrl}/dot-crypto-registry`;
 
   // Send request to get names
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      variables: { owner: address.toLowerCase() },
-      query: 'query domainsOfOwner($owner: String!) { domains(where: {owner: $owner}) { name } }',
-    }),
-  });
-
-  // Return the first name in the array, or undefined if user has no CNS names
-  const json = (await res.json()) as CnsQueryResponse;
-  const names = json.data.domains;
-  return names.length > 0 ? names[0].name : undefined;
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        variables: { owner: address.toLowerCase() },
+        query: 'query domainsOfOwner($owner: String!) { domains(where: {owner: $owner}) { name } }',
+      }),
+    });
+
+    // Return the first name in the array, or undefined if user has no CNS names
+    const json = (await res.json()) as CnsQueryResponse;
+    const names = json.data.domains;
+    return names.length > 0 ? names[0].name : undefined;
+  } catch (err) {
+    // Scenario that prompted this try/catch was that The Graph API threw with a CORS error on localhost, blocking login
+    console.error(err);
+    return undefined;
+  }
 };
 
 // Returns an ENS or CNS name if found, otherwise returns undefined
diff --git a/umbra-js/src/classes/Umbra.ts b/umbra-js/src/classes/Umbra.ts
index 6dba4dea6..837c511ae 100644
--- a/umbra-js/src/classes/Umbra.ts
+++ b/umbra-js/src/classes/Umbra.ts
@@ -273,49 +273,51 @@ export class Umbra {
     const announcementFilter = this.umbraContract.filters.Announcement(null, null, null, null, null);
     const announcements = await this.umbraContract.queryFilter(announcementFilter, startBlock, endBlock);
 
-    // Get list of all TokenWithdrawal events
-    const withdrawalFilter = this.umbraContract.filters.TokenWithdrawal(null, null, null, null);
-    const withdrawalEvents = await this.umbraContract.queryFilter(withdrawalFilter, startBlock, endBlock);
-    withdrawalEvents; // to silence tsc error
-
     // Determine which announcements are for the user
     const userAnnouncements = [] as UserAnnouncement[];
     for (let i = 0; i < announcements.length; i += 1) {
-      const event = announcements[i];
-
-      // Extract out event parameters
-      const { receiver, amount, token, pkx, ciphertext } = (event.args as unknown) as Announcement;
-
-      // Get y-coordinate of public key from the x-coordinate by solving secp256k1 equation
-      const uncompressedPubKey = KeyPair.getUncompressedFromX(pkx);
-
-      // Decrypt to get random number
-      const payload = { ephemeralPublicKey: uncompressedPubKey, ciphertext };
-      const viewingKeyPair = new KeyPair(viewingPrivateKey);
-      const randomNumber = viewingKeyPair.decrypt(payload);
-
-      // Get what our receiving address would be with this random number
-      const spendingKeyPair = new KeyPair(spendingPublicKey);
-      const computedReceivingAddress = spendingKeyPair.mulPublicKey(randomNumber).address;
-
-      // If our receiving address matches the event's recipient, the transfer was for us
-      if (computedReceivingAddress === receiver) {
-        const [block, tx, receipt] = await Promise.all([
-          event.getBlock(),
-          event.getTransaction(),
-          event.getTransactionReceipt(),
-        ]);
-        userAnnouncements.push({
-          event,
-          randomNumber,
-          receiver,
-          amount,
-          token,
-          block,
-          tx,
-          receipt,
-          isWithdrawn: false,
-        });
+      try {
+        const event = announcements[i];
+
+        // Extract out event parameters
+        const { receiver, amount, token, pkx, ciphertext } = (event.args as unknown) as Announcement;
+
+        // Get y-coordinate of public key from the x-coordinate by solving secp256k1 equation
+        const uncompressedPubKey = KeyPair.getUncompressedFromX(pkx);
+
+        // Decrypt to get random number
+        const payload = { ephemeralPublicKey: uncompressedPubKey, ciphertext };
+        const viewingKeyPair = new KeyPair(viewingPrivateKey);
+        const randomNumber = viewingKeyPair.decrypt(payload);
+
+        // Get what our receiving address would be with this random number
+        const spendingKeyPair = new KeyPair(spendingPublicKey);
+        const computedReceivingAddress = spendingKeyPair.mulPublicKey(randomNumber).address;
+
+        // If our receiving address matches the event's recipient, the transfer was for us
+        if (computedReceivingAddress === receiver) {
+          const [block, tx, receipt] = await Promise.all([
+            event.getBlock(),
+            event.getTransaction(),
+            event.getTransactionReceipt(),
+          ]);
+          userAnnouncements.push({
+            event,
+            randomNumber,
+            receiver,
+            amount,
+            token,
+            block,
+            tx,
+            receipt,
+            isWithdrawn: false,
+          });
+        }
+      } catch (err) {
+        // We may reach here if people use the sendToken method improperly, e.g. by passing an invalid pkx, so we'd
+        // fail when uncompressing
+        console.log('The following event had the below error while processing:', announcements[i]);
+        console.error(err);
       }
     }
 
diff --git a/umbra-js/src/utils/utils.ts b/umbra-js/src/utils/utils.ts
index 88315d753..f8b46e025 100644
--- a/umbra-js/src/utils/utils.ts
+++ b/umbra-js/src/utils/utils.ts
@@ -9,7 +9,7 @@ import { resolveProperties } from '@ethersproject/properties';
 import { EtherscanProvider } from '@ethersproject/providers';
 import { recoverPublicKey } from '@ethersproject/signing-key';
 import { serialize as serializeTransaction } from '@ethersproject/transactions';
-import * as ens from './ens';
+import { ens, cns } from '..';
 import { DomainService } from '../classes/DomainService';
 import { EthersProvider, SignatureLike } from '../types';
 
@@ -120,20 +120,20 @@ async function getSentTransaction(address: string, ethersProvider: EthersProvide
  */
 export async function lookupRecipient(id: string, provider: EthersProvider) {
   // Check if identifier is a public key. If so we just return that directly
-  const isPublicKey = id.length === 132 && isHexString(id) && id.startsWith('0x04');
+  const isPublicKey = id.length === 132 && isHexString(id);
   if (isPublicKey) {
     return { spendingPublicKey: id, viewingPublicKey: id };
   }
 
   // Check if identifier is a transaction hash
-  const isTxHash = id.length === 66 && isHexString(id) && id.startsWith('0x');
+  const isTxHash = id.length === 66 && isHexString(id);
   if (isTxHash) {
     const publicKey = await recoverPublicKeyFromTransaction(id, provider);
     return { spendingPublicKey: publicKey, viewingPublicKey: publicKey };
   }
 
   // Check if this is a valid address
-  const isValidAddress = id.length === 42 && isHexString(id) && id.startsWith('0x');
+  const isValidAddress = id.length === 42 && isHexString(id);
   if (isValidAddress) {
     // Get last transaction hash sent by that address
     const txHash = await getSentTransaction(id, provider);
@@ -147,7 +147,7 @@ export async function lookupRecipient(id: string, provider: EthersProvider) {
   }
 
   // Check if this is a valid ENS or CNS name
-  const isDomainService = ens.isEnsDomain(id) || id.endsWith('.crypto');
+  const isDomainService = ens.isEnsDomain(id) || cns.isCnsDomain(id);
   if (isDomainService) {
     const domainService = new DomainService(provider);
     return domainService.getPublicKeys(id);