diff --git a/components/DataTableMyRelays/DataTableMyRelays.vue b/components/DataTableMyRelays/DataTableMyRelays.vue
index 1b0ebec..562efdd 100755
--- a/components/DataTableMyRelays/DataTableMyRelays.vue
+++ b/components/DataTableMyRelays/DataTableMyRelays.vue
@@ -88,6 +88,29 @@ const ethAddressError = ref<string | null>(null);
 const fingerPrintRegister = ref<string>('');
 const fingerPrintRegisterError = ref<string | null>(null);
 
+const relayCredits = ref<Record<string, boolean | undefined>>({});
+const familyVerified = ref<Record<string, boolean>>({});
+const registrationCreditsRequired = ref<boolean>(true);
+const familyRequired = ref<boolean>(true);
+
+const fetchRegistrationCredit = async () => {
+  if (allRelays.value) {
+    for (const relay of filterUniqueRelays(allRelays.value)) {
+      relayCredits.value[relay.fingerprint] =
+        await userStore.hasRegistrationCredit(relay.fingerprint);
+      familyVerified.value[relay.fingerprint] = await userStore.familyVerified2(
+        relay.fingerprint
+      );
+    }
+  }
+
+  registrationCreditsRequired.value = userStore.registrationCreditsRequired;
+  familyRequired.value = userStore.familyRequired;
+};
+
+// Fetch the registration credits when the relays are loaded
+watch(allRelays, fetchRegistrationCredit);
+
 if ((allRelaysError as any).value?.cause?.message == 'rate limited') {
   toast.add({
     id: 'claimable-relays-error',
@@ -553,6 +576,10 @@ const handleUnlockClick = async (fingerprint: string) => {
             userStore.isHardwareRelay(row.fingerprint)
           "
           :is-loading="registratorStore.loading"
+          :has-registration-credit="relayCredits[row.fingerprint]"
+          :registration-credits-required="registrationCreditsRequired"
+          :family-verified="familyVerified[row.fingerprint]"
+          :family-required="familyRequired"
         />
       </template>
       <template #unlock-data="{ row }">
diff --git a/components/DataTableMyRelays/DataTableMyRelaysMobile.vue b/components/DataTableMyRelays/DataTableMyRelaysMobile.vue
index 254feae..910cb81 100755
--- a/components/DataTableMyRelays/DataTableMyRelaysMobile.vue
+++ b/components/DataTableMyRelays/DataTableMyRelaysMobile.vue
@@ -54,10 +54,13 @@ onMounted(() => {
   }, 1000 * 60);
 });
 
+// watch for all relays change and update the relay credits
+
 const unwatch = watchAccount(config, {
   onChange(account) {
     // account change
     userStore.createRelayCache();
+    fetchRegistrationCredit();
   },
 });
 unwatch();
@@ -87,6 +90,29 @@ const ethAddressError = ref<string | null>(null);
 const fingerPrintRegister = ref<string>('');
 const fingerPrintRegisterError = ref<string | null>(null);
 
+const relayCredits = ref<Record<string, boolean | undefined>>({});
+const familyVerified = ref<Record<string, boolean>>({});
+const registrationCreditsRequired = ref<boolean>(true);
+const familyRequired = ref<boolean>(true);
+
+const fetchRegistrationCredit = async () => {
+  if (allRelays.value) {
+    for (const relay of filterUniqueRelays(allRelays.value)) {
+      relayCredits.value[relay.fingerprint] =
+        await userStore.hasRegistrationCredit(relay.fingerprint);
+      familyVerified.value[relay.fingerprint] = await userStore.familyVerified2(
+        relay.fingerprint
+      );
+    }
+  }
+
+  registrationCreditsRequired.value = userStore.registrationCreditsRequired;
+  familyRequired.value = userStore.familyRequired;
+};
+
+// Fetch the registration credits when the relays are loaded
+watch(allRelays, fetchRegistrationCredit);
+
 if ((allRelaysError as any).value?.cause?.message == 'rate limited') {
   toast.add({
     id: 'claimable-relays-error',
@@ -500,6 +526,10 @@ const handleUnlockClick = async (fingerprint: string) => {
             userStore.isHardwareRelay(row.fingerprint)
           "
           :is-loading="registratorStore.loading"
+          :has-registration-credit="relayCredits[row.fingerprint]"
+          :registration-credits-required="registrationCreditsRequired"
+          :family-verified="familyVerified[row.fingerprint]"
+          :family-required="familyRequired"
         />
         <UButton
           v-if="currentTab === 'locked'"
diff --git a/components/DataTableMyRelays/columns/RegistrationActionColumn.vue b/components/DataTableMyRelays/columns/RegistrationActionColumn.vue
index 44b410d..453c999 100755
--- a/components/DataTableMyRelays/columns/RegistrationActionColumn.vue
+++ b/components/DataTableMyRelays/columns/RegistrationActionColumn.vue
@@ -10,26 +10,11 @@ const props = defineProps<{
   row: RelayRow | undefined;
   isLocked: boolean;
   isLoading?: boolean;
+  hasRegistrationCredit: boolean | undefined;
+  registrationCreditsRequired: boolean;
+  familyVerified: boolean | undefined;
+  familyRequired: boolean;
 }>();
-
-const userStore = useUserStore();
-var hasRegistrationCredit: boolean | undefined;
-var registrationCreditsRequired: boolean = true;
-var familyRequired: boolean = true;
-var familyVerified: boolean | undefined;
-
-async function fetchRegistrationCredit() {
-  if (props?.row) {
-    hasRegistrationCredit = await userStore.hasRegistrationCredit(
-      props?.row?.fingerprint
-    );
-    familyVerified = await userStore.familyVerified(props?.row?.fingerprint);
-    registrationCreditsRequired = userStore.registrationCreditsRequired;
-    familyRequired = userStore.familyRequired;
-  }
-}
-
-fetchRegistrationCredit();
 </script>
 
 <template>
@@ -56,8 +41,8 @@ fetchRegistrationCredit();
         v-else-if="
           props.row.status === 'claimable' &&
           props.isLocked &&
-          hasRegistrationCredit &&
-          familyVerified
+          props.hasRegistrationCredit &&
+          props.familyVerified
         "
         size="xl"
         color="green"
@@ -72,8 +57,8 @@ fetchRegistrationCredit();
         v-else-if="
           props.row.status === 'claimable' &&
           props.isLocked &&
-          !hasRegistrationCredit &&
-          registrationCreditsRequired
+          !props.hasRegistrationCredit &&
+          props.registrationCreditsRequired
         "
         size="xl"
         color="green"
@@ -87,8 +72,8 @@ fetchRegistrationCredit();
         v-else-if="
           props.row.status === 'claimable' &&
           props.isLocked &&
-          !familyVerified &&
-          familyRequired
+          !props.familyVerified &&
+          props.familyRequired
         "
         size="xl"
         color="green"
diff --git a/composables/relayCache.ts b/composables/relayCache.ts
index d6e02c3..8353707 100755
--- a/composables/relayCache.ts
+++ b/composables/relayCache.ts
@@ -17,6 +17,7 @@ interface RelayData {
       active: boolean;
       class: string;
     }[];
+    state: any;
     nicknames: { [key: string]: string };
     registrationCredits: string[];
   };
@@ -182,6 +183,7 @@ class RelayCache {
             claimable: key === 'claimable' ? newData : [],
             nicknames: {},
             registrationCredits: [],
+            state: {},
             [key]: newData,
           },
         };
diff --git a/contracts/common/errors.ts b/contracts/common/errors.ts
new file mode 100644
index 0000000..55556fa
--- /dev/null
+++ b/contracts/common/errors.ts
@@ -0,0 +1,11 @@
+export const FINGERPRINT_REQUIRED = 'Fingerprint required';
+export const INVALID_FINGERPRINT = 'Invalid fingerprint';
+export const ADDRESS_REQUIRED = 'Address required';
+export const INVALID_ADDRESS = 'Invalid address';
+export const PUBLIC_KEY_REQUIRED = 'Public Key is required and must valid';
+export const ENABLED_REQUIRED = 'Enabled must be a boolean';
+export const FINGERPRINTS_MUST_BE_ARRAY =
+  'Valid array of fingerprints required';
+export const INVALID_FAMILY = 'Invalid family';
+export const FAMILIES_REQUIRED = 'Families must be an array of family mappings';
+export const DUPLICATE_FINGERPRINT = 'Duplicate fingerprint';
diff --git a/contracts/common/types.ts b/contracts/common/types.ts
new file mode 100644
index 0000000..707a3b4
--- /dev/null
+++ b/contracts/common/types.ts
@@ -0,0 +1,8 @@
+export type Fingerprint = string;
+export type EvmAddress = string;
+export type PublicKey = string;
+
+export type ContractFunctionInput = {
+  function: string;
+  [key: string]: any;
+};
diff --git a/contracts/relay-registry.ts b/contracts/relay-registry.ts
new file mode 100644
index 0000000..88e8459
--- /dev/null
+++ b/contracts/relay-registry.ts
@@ -0,0 +1,841 @@
+import {
+  ContractError,
+  ContractInteraction,
+  HandlerResult,
+} from 'warp-contracts';
+
+import type {
+  EvolvableState,
+  OwnableState,
+  PartialFunctionInput,
+} from './util';
+
+import {
+  ContractAssert,
+  Evolvable,
+  INVALID_INPUT,
+  OnlyOwner,
+  SmartWeave,
+  UPPER_HEX_CHARS,
+  assertValidEvmAddress,
+  assertValidFingerprint,
+  assertValidPublicKey,
+} from './util';
+import type {
+  ContractFunctionInput,
+  EvmAddress,
+  Fingerprint,
+  PublicKey,
+} from './common/types';
+import {
+  DUPLICATE_FINGERPRINT,
+  ENABLED_REQUIRED,
+  FAMILIES_REQUIRED,
+  FINGERPRINTS_MUST_BE_ARRAY,
+  INVALID_FAMILY,
+} from './common/errors';
+
+export const FINGERPRINT_ALREADY_CLAIMABLE = 'Fingerprint already claimable';
+export const FINGERPRINT_NOT_CLAIMABLE = 'Fingerprint not claimable';
+export const FINGERPRINT_NOT_CLAIMABLE_BY_ADDRESS =
+  'Fingerprint not claimable by this address';
+export const FINGERPRINT_ALREADY_CLAIMED = 'Fingerprint already claimed';
+export const FINGERPRINT_NOT_CLAIMED_BY_ADDRESS =
+  'Fingerprint not claimed by address';
+export const REGISTRATION_CREDIT_REQUIRED =
+  'A Registration Credit is required to claim a fingerprint';
+export const ADDRESS_ALREADY_BLOCKED = 'Address already blocked';
+export const ADDRESS_NOT_BLOCKED = 'Address not blocked';
+export const ADDRESS_IS_BLOCKED = 'Address is blocked';
+export const FAMILY_REQUIRED = 'Family required';
+export const FAMILY_NOT_SET =
+  'Subsequent relay claims require family to be set';
+export const HARDWARE_ALREADY_VERIFIED = 'Hardware has already been verified';
+export const SERIAL_NOT_REGISTERED = 'Serial has not been registered';
+export const CREDITS_MUST_BE_ARRAY =
+  'Credits must be a valid array of address & fingerprint tuples';
+export const REGISTRATION_CREDIT_NOT_FOUND = 'Registration credit not found';
+export const HARDWARE_VERIFIED_MUST_BE_BOOLEAN_OR_UNDEFINED =
+  'Argument hardwareVerified must be boolean or undefined';
+export const RELAYS_MUST_BE_VALID_ARRAY =
+  'Argument relays must be an array of (fingerprint, address, hardwareVerified)';
+export const NICKNAME_MUST_BE_VALID =
+  'Nickname must be no more than 20 alphanumeric characters';
+
+export type RelayRegistryState = OwnableState &
+  EvolvableState & {
+    claimable: { [fingerprint in Fingerprint as string]: EvmAddress };
+    verified: { [fingerprint in Fingerprint as string]: EvmAddress };
+    registrationCredits: {
+      [address in EvmAddress as string]: Fingerprint[];
+    };
+    blockedAddresses: EvmAddress[];
+    families: { [fingerprint in Fingerprint as string]: Fingerprint[] };
+    registrationCreditsRequired: boolean;
+    encryptionPublicKey: string;
+    verifiedHardware: { [fingerprint in Fingerprint as string]: 1 };
+    familyRequired: boolean;
+    nicknames: { [fingerprint in Fingerprint as string]: string };
+  };
+
+export interface AddClaimable extends ContractFunctionInput {
+  function: 'addClaimable';
+  fingerprint: Fingerprint;
+  address: EvmAddress;
+  hardwareVerified?: boolean;
+  nickname?: string;
+}
+
+export interface AddClaimableBatched extends ContractFunctionInput {
+  function: 'addClaimableBatched';
+  relays: {
+    fingerprint: Fingerprint;
+    address: EvmAddress;
+    hardwareVerified?: boolean;
+    nickname?: string;
+  }[];
+}
+
+export interface RemoveClaimable extends ContractFunctionInput {
+  function: 'removeClaimable';
+  fingerprint: Fingerprint;
+}
+
+export interface IsClaimable extends ContractFunctionInput {
+  function: 'isClaimable';
+  fingerprint: Fingerprint;
+  address: EvmAddress;
+}
+
+export interface Claimable extends ContractFunctionInput {
+  function: 'claimable';
+  address?: EvmAddress;
+}
+
+export interface Claim extends ContractFunctionInput {
+  function: 'claim';
+  fingerprint: Fingerprint;
+}
+
+export interface Renounce extends ContractFunctionInput {
+  function: 'renounce';
+  fingerprint: Fingerprint;
+}
+
+export interface RemoveVerified extends ContractFunctionInput {
+  function: 'removeVerified';
+  fingerprint: Fingerprint;
+}
+
+export interface Verified extends ContractFunctionInput {
+  function: 'verified';
+  address?: EvmAddress;
+}
+
+export interface IsVerified extends ContractFunctionInput {
+  function: 'isVerified';
+  fingerprint: Fingerprint;
+}
+
+export interface AddRegistrationCredits extends ContractFunctionInput {
+  function: 'addRegistrationCredits';
+  credits: { address: EvmAddress; fingerprint: Fingerprint }[];
+}
+
+export interface RemoveRegistrationCredits extends ContractFunctionInput {
+  function: 'removeRegistrationCredits';
+  credits: { address: EvmAddress; fingerprint: Fingerprint }[];
+}
+
+export interface BlockAddress extends ContractFunctionInput {
+  function: 'blockAddress';
+  address: EvmAddress;
+}
+
+export interface UnblockAddress extends ContractFunctionInput {
+  function: 'unblockAddress';
+  address: EvmAddress;
+}
+
+export interface SetFamilies extends ContractFunctionInput {
+  function: 'setFamilies';
+  families: {
+    fingerprint: Fingerprint;
+    add?: Fingerprint[];
+    remove?: Fingerprint[];
+  }[];
+}
+
+export interface ToggleRegistrationCreditRequirement
+  extends ContractFunctionInput {
+  function: 'toggleRegistrationCreditRequirement';
+  enabled: boolean;
+}
+
+export interface SetEncryptionPublicKey extends ContractFunctionInput {
+  function: 'setEncryptionPublicKey';
+  encryptionPublicKey: PublicKey;
+}
+
+export interface VerifySerials extends ContractFunctionInput {
+  function: 'verifySerials';
+  fingerprints: Fingerprint[];
+}
+
+export interface RemoveSerials extends ContractFunctionInput {
+  function: 'removeSerials';
+  fingerprints: Fingerprint[];
+}
+
+export interface GetVerifiedRelays extends ContractFunctionInput {
+  function: 'getVerifiedRelays';
+}
+
+export interface ToggleFamilyRequirement extends ContractFunctionInput {
+  function: 'toggleFamilyRequirement';
+  enabled: boolean;
+}
+
+export class RelayRegistryContract extends Evolvable(Object) {
+  constructor(state: Partial<RelayRegistryState>) {
+    if (!state.blockedAddresses) {
+      state.blockedAddresses = [];
+    }
+
+    if (!state.claimable) {
+      state.claimable = {};
+    }
+
+    if (!state.families) {
+      state.families = {};
+    }
+
+    if (!state.registrationCredits) {
+      state.registrationCredits = {};
+    }
+
+    if (!state.verified) {
+      state.verified = {};
+    }
+
+    if (!state.registrationCreditsRequired) {
+      state.registrationCreditsRequired = false;
+    }
+
+    if (!state.encryptionPublicKey) {
+      state.encryptionPublicKey = '';
+    }
+
+    if (!state.verifiedHardware) {
+      state.verifiedHardware = {};
+    }
+
+    if (!state.nicknames) {
+      state.nicknames = {};
+    }
+
+    super(state);
+  }
+
+  private isFingerprintClaimable(
+    state: RelayRegistryState,
+    fingerprint: Fingerprint
+  ): boolean {
+    return Object.keys(state.claimable).includes(fingerprint);
+  }
+
+  private isFingerprintVerified(
+    state: RelayRegistryState,
+    fingerprint: Fingerprint
+  ): boolean {
+    return Object.keys(state.verified).includes(fingerprint);
+  }
+
+  addClaimable(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<AddClaimable>>
+  ) {
+    const {
+      input: { address, fingerprint, hardwareVerified, nickname },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+    assertValidEvmAddress(address);
+    ContractAssert(
+      !this.isFingerprintClaimable(state, fingerprint),
+      FINGERPRINT_ALREADY_CLAIMABLE
+    );
+    ContractAssert(
+      !this.isFingerprintVerified(state, fingerprint),
+      FINGERPRINT_ALREADY_CLAIMED
+    );
+    ContractAssert(
+      typeof hardwareVerified === 'boolean' ||
+        typeof hardwareVerified === 'undefined',
+      HARDWARE_VERIFIED_MUST_BE_BOOLEAN_OR_UNDEFINED
+    );
+
+    if (hardwareVerified) {
+      ContractAssert(
+        !state.verifiedHardware[fingerprint],
+        HARDWARE_ALREADY_VERIFIED
+      );
+      state.verifiedHardware[fingerprint] = 1;
+    }
+
+    if (nickname) {
+      ContractAssert(
+        typeof nickname === 'string' &&
+          nickname.length > 0 &&
+          nickname.length <= 20,
+        NICKNAME_MUST_BE_VALID
+      );
+      state.nicknames[fingerprint] = nickname;
+    }
+
+    state.claimable[fingerprint] = address;
+
+    return { state, result: true };
+  }
+
+  addClaimableBatched(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<AddClaimableBatched>>
+  ) {
+    const {
+      caller,
+      interactionType,
+      input: { relays },
+    } = action;
+
+    ContractAssert(Array.isArray(relays), RELAYS_MUST_BE_VALID_ARRAY);
+    ContractAssert(relays.length > 0, RELAYS_MUST_BE_VALID_ARRAY);
+
+    for (let i = 0; i < relays.length; i++) {
+      this.addClaimable(state, {
+        caller,
+        interactionType,
+        input: {
+          function: 'addClaimable',
+          ...relays[i],
+        },
+      });
+    }
+
+    return { state, result: true };
+  }
+
+  removeClaimable(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<AddClaimable>>
+  ) {
+    const {
+      input: { fingerprint },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+    ContractAssert(
+      !this.isFingerprintVerified(state, fingerprint),
+      FINGERPRINT_ALREADY_CLAIMED
+    );
+    ContractAssert(
+      this.isFingerprintClaimable(state, fingerprint),
+      FINGERPRINT_NOT_CLAIMABLE
+    );
+
+    delete state.claimable[fingerprint];
+
+    return { state, result: true };
+  }
+
+  claimable(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<Claimable>>
+  ) {
+    const {
+      input: { address },
+    } = action;
+
+    if (address) {
+      assertValidEvmAddress(address);
+
+      return {
+        state,
+        result: Object.keys(state.claimable).filter(
+          (fp) => state.claimable[fp] === address
+        ),
+      };
+    }
+
+    return { state, result: state.claimable };
+  }
+
+  isClaimable(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<IsClaimable>>
+  ) {
+    const {
+      input: { address, fingerprint },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+    assertValidEvmAddress(address);
+
+    return {
+      state,
+      result:
+        Object.keys(state.claimable).includes(fingerprint) &&
+        state.claimable[fingerprint] === address,
+    };
+  }
+
+  claim(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<Claim>>
+  ) {
+    const {
+      caller,
+      input: { fingerprint },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+    ContractAssert(
+      caller === state.claimable[fingerprint],
+      FINGERPRINT_NOT_CLAIMABLE_BY_ADDRESS
+    );
+    ContractAssert(
+      !state.blockedAddresses.includes(caller),
+      ADDRESS_IS_BLOCKED
+    );
+    const hasVerifiedSerialProof = !!state.verifiedHardware[fingerprint];
+    const hasRegistrationCredit =
+      !!state.registrationCredits[caller] &&
+      state.registrationCredits[caller].includes(fingerprint);
+    if (state.registrationCreditsRequired === true) {
+      ContractAssert(
+        hasRegistrationCredit || hasVerifiedSerialProof,
+        REGISTRATION_CREDIT_REQUIRED
+      );
+    }
+
+    if (state.familyRequired) {
+      const verifiedFingerprintsBelongingToCaller = Object.keys(
+        state.verified
+      ).filter((fp) => state.verified[fp] === caller);
+      const claimingRelayFamily = (state.families[fingerprint] || []).slice(0);
+      const claimingFamilyIncludesAllVerifiedRelays =
+        verifiedFingerprintsBelongingToCaller.every((cf) =>
+          claimingRelayFamily.includes(cf)
+        );
+      ContractAssert(claimingFamilyIncludesAllVerifiedRelays, FAMILY_NOT_SET);
+      for (let i = 0; i < verifiedFingerprintsBelongingToCaller.length; i++) {
+        ContractAssert(
+          state.families[verifiedFingerprintsBelongingToCaller[i]].includes(
+            fingerprint
+          ),
+          FAMILY_NOT_SET
+        );
+      }
+    }
+
+    if (state.registrationCreditsRequired === true && hasRegistrationCredit) {
+      const removeIdx = state.registrationCredits[caller].indexOf(fingerprint);
+      state.registrationCredits[caller].splice(removeIdx, 1);
+    }
+
+    state.verified[fingerprint] = state.claimable[fingerprint];
+    delete state.claimable[fingerprint];
+
+    return { state, result: true };
+  }
+
+  renounce(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<Renounce>>
+  ) {
+    const {
+      caller,
+      input: { fingerprint },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+
+    ContractAssert(
+      caller === state.verified[fingerprint],
+      FINGERPRINT_NOT_CLAIMED_BY_ADDRESS
+    );
+
+    delete state.verified[fingerprint];
+    delete state.verifiedHardware[fingerprint];
+    delete state.nicknames[fingerprint];
+
+    return { state, result: true };
+  }
+
+  removeVerified(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<RemoveVerified>>
+  ) {
+    const {
+      input: { fingerprint },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+
+    delete state.verified[fingerprint];
+    delete state.verifiedHardware[fingerprint];
+
+    return { state, result: true };
+  }
+
+  verified(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<Verified>>
+  ) {
+    const {
+      input: { address },
+    } = action;
+
+    if (address) {
+      assertValidEvmAddress(address);
+
+      return {
+        state,
+        result: Object.keys(state.verified).filter(
+          (fp) => state.verified[fp] === address
+        ),
+      };
+    }
+
+    return { state, result: state.verified };
+  }
+
+  isVerified(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<IsVerified>>
+  ) {
+    const {
+      input: { fingerprint },
+    } = action;
+
+    assertValidFingerprint(fingerprint);
+
+    return {
+      state,
+      result: Object.keys(state.verified).includes(fingerprint),
+    };
+  }
+
+  addRegistrationCredits(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<AddRegistrationCredits>>
+  ) {
+    const {
+      input: { credits },
+    } = action;
+
+    ContractAssert(Array.isArray(credits), CREDITS_MUST_BE_ARRAY);
+
+    for (let i = 0; i < credits.length; i++) {
+      const { address, fingerprint } = credits[i];
+      assertValidEvmAddress(address);
+      assertValidFingerprint(fingerprint);
+      if (!state.registrationCredits[address]) {
+        state.registrationCredits[address] = [];
+      }
+      ContractAssert(
+        !state.registrationCredits[address].includes(fingerprint),
+        DUPLICATE_FINGERPRINT
+      );
+      state.registrationCredits[address].push(fingerprint);
+    }
+
+    return { state, result: true };
+  }
+
+  removeRegistrationCredits(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<RemoveRegistrationCredits>>
+  ) {
+    const {
+      input: { credits },
+    } = action;
+
+    ContractAssert(Array.isArray(credits), CREDITS_MUST_BE_ARRAY);
+
+    for (let i = 0; i < credits.length; i++) {
+      const { address, fingerprint } = credits[i];
+      assertValidEvmAddress(address);
+      assertValidFingerprint(fingerprint);
+      if (!state.registrationCredits[address]) {
+        state.registrationCredits[address] = [];
+      }
+      const foundIdx = state.registrationCredits[address].indexOf(fingerprint);
+      ContractAssert(foundIdx > -1, REGISTRATION_CREDIT_NOT_FOUND);
+
+      state.registrationCredits[address].splice(foundIdx, 1);
+    }
+
+    return { state, result: true };
+
+    return { state, result: true };
+  }
+
+  blockAddress(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<BlockAddress>>
+  ) {
+    const {
+      input: { address },
+    } = action;
+
+    assertValidEvmAddress(address);
+    ContractAssert(
+      !state.blockedAddresses.includes(address),
+      ADDRESS_ALREADY_BLOCKED
+    );
+    state.blockedAddresses.push(address);
+
+    return { state, result: true };
+  }
+
+  unblockAddress(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<UnblockAddress>>
+  ) {
+    const {
+      input: { address },
+    } = action;
+
+    assertValidEvmAddress(address);
+    const blockedIndex = state.blockedAddresses.indexOf(address);
+    ContractAssert(blockedIndex > -1, ADDRESS_NOT_BLOCKED);
+    state.blockedAddresses.splice(blockedIndex, 1);
+
+    return { state, result: true };
+  }
+
+  setFamilies(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<SetFamilies>>
+  ) {
+    const {
+      input: { families },
+    } = action;
+
+    ContractAssert(Array.isArray(families), FAMILIES_REQUIRED);
+    ContractAssert(families.length > 0, FAMILIES_REQUIRED);
+
+    for (const { fingerprint, add, remove } of families) {
+      assertValidFingerprint(fingerprint);
+      ContractAssert(!!add || !!remove, INVALID_FAMILY);
+
+      if (!state.families[fingerprint]) {
+        state.families[fingerprint] = [];
+      }
+
+      if (add) {
+        ContractAssert(Array.isArray(add), INVALID_FAMILY);
+        for (const addFingerprint of add) {
+          assertValidFingerprint(addFingerprint);
+          ContractAssert(
+            !state.families[fingerprint].includes(addFingerprint),
+            DUPLICATE_FINGERPRINT
+          );
+          state.families[fingerprint].push(addFingerprint);
+        }
+      }
+
+      if (remove) {
+        ContractAssert(Array.isArray(remove), INVALID_FAMILY);
+        for (const removeFingerprint of remove) {
+          assertValidFingerprint(removeFingerprint);
+          const indexToRemove =
+            state.families[fingerprint].indexOf(removeFingerprint);
+          state.families[fingerprint].splice(indexToRemove, 1);
+        }
+      }
+    }
+
+    return { state, result: true };
+  }
+
+  toggleRegistrationCreditRequirement(
+    state: RelayRegistryState,
+    action: ContractInteraction<
+      PartialFunctionInput<ToggleRegistrationCreditRequirement>
+    >
+  ) {
+    const {
+      input: { enabled },
+    } = action;
+
+    ContractAssert(typeof enabled === 'boolean', ENABLED_REQUIRED);
+
+    state.registrationCreditsRequired = enabled;
+
+    return { state, result: true };
+  }
+
+  setEncryptionPublicKey(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<SetEncryptionPublicKey>>
+  ) {
+    const {
+      input: { encryptionPublicKey },
+    } = action;
+
+    assertValidPublicKey(encryptionPublicKey);
+
+    state.encryptionPublicKey = encryptionPublicKey;
+
+    return { state, result: true };
+  }
+
+  verifySerials(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<VerifySerials>>
+  ) {
+    const {
+      input: { fingerprints },
+    } = action;
+
+    ContractAssert(Array.isArray(fingerprints), FINGERPRINTS_MUST_BE_ARRAY);
+
+    for (let i = 0; i < fingerprints.length; i++) {
+      const fingerprint = fingerprints[i];
+      assertValidFingerprint(fingerprint);
+      ContractAssert(
+        !state.verifiedHardware[fingerprint],
+        HARDWARE_ALREADY_VERIFIED
+      );
+
+      state.verifiedHardware[fingerprint] = 1;
+    }
+
+    return { state, result: true };
+  }
+
+  removeSerials(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<RemoveSerials>>
+  ) {
+    const {
+      input: { fingerprints },
+    } = action;
+
+    ContractAssert(Array.isArray(fingerprints), FINGERPRINTS_MUST_BE_ARRAY);
+
+    for (let i = 0; i < fingerprints.length; i++) {
+      const fingerprint = fingerprints[i];
+      assertValidFingerprint(fingerprint);
+      ContractAssert(
+        !!state.verifiedHardware[fingerprint],
+        SERIAL_NOT_REGISTERED
+      );
+
+      delete state.verifiedHardware[fingerprint];
+    }
+
+    return { state, result: true };
+  }
+
+  getVerifiedRelays(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<GetVerifiedRelays>>
+  ) {
+    const result: {
+      verified: RelayRegistryState['verified'];
+      verifiedHardware: RelayRegistryState['verified'];
+    } = {
+      verified: {},
+      verifiedHardware: {},
+    };
+
+    const fingerprints = Object.keys(state.verified);
+    for (let i = 0; i < fingerprints.length; i++) {
+      const fingerprint = fingerprints[i];
+      if (!!state.verifiedHardware[fingerprint]) {
+        result.verifiedHardware[fingerprint] = state.verified[fingerprint];
+      } else {
+        result.verified[fingerprint] = state.verified[fingerprint];
+      }
+    }
+
+    return { state, result };
+  }
+
+  toggleFamilyRequirement(
+    state: RelayRegistryState,
+    action: ContractInteraction<PartialFunctionInput<ToggleFamilyRequirement>>
+  ) {
+    const {
+      input: { enabled },
+    } = action;
+
+    ContractAssert(typeof enabled === 'boolean', ENABLED_REQUIRED);
+
+    state.familyRequired = enabled;
+
+    return { state, result: true };
+  }
+}
+
+export function handle(
+  state: RelayRegistryState,
+  action: ContractInteraction<any>
+) {
+  const contract = new RelayRegistryContract(state);
+
+  switch (action.input.function) {
+    case 'addClaimable':
+      return contract.addClaimable(state, action);
+    case 'addClaimableBatched':
+      return contract.addClaimableBatched(state, action);
+    case 'removeClaimable':
+      return contract.removeClaimable(state, action);
+    case 'claimable':
+      return contract.claimable(state, action);
+    case 'isClaimable':
+      return contract.isClaimable(state, action);
+    case 'claim':
+      return contract.claim(state, action);
+    case 'renounce':
+      return contract.renounce(state, action);
+    case 'removeVerified':
+      return contract.removeVerified(state, action);
+    case 'verified':
+      return contract.verified(state, action);
+    case 'isVerified':
+      return contract.isVerified(state, action);
+    case 'addRegistrationCredits':
+      return contract.addRegistrationCredits(state, action);
+    case 'removeRegistrationCredits':
+      return contract.removeRegistrationCredits(state, action);
+    case 'blockAddress':
+      return contract.blockAddress(state, action);
+    case 'unblockAddress':
+      return contract.unblockAddress(state, action);
+    case 'setFamilies':
+      return contract.setFamilies(state, action);
+    case 'toggleRegistrationCreditRequirement':
+      return contract.toggleRegistrationCreditRequirement(state, action);
+    case 'setEncryptionPublicKey':
+      return contract.setEncryptionPublicKey(state, action);
+    case 'verifySerials':
+      return contract.verifySerials(state, action);
+    case 'removeSerials':
+      return contract.removeSerials(state, action);
+    case 'getVerifiedRelays':
+      return contract.getVerifiedRelays(state, action);
+    case 'toggleFamilyRequirement':
+      return contract.toggleFamilyRequirement(state, action);
+    case 'evolve':
+      return contract.evolve(state, action) as HandlerResult<
+        RelayRegistryState,
+        any
+      >;
+    default:
+      throw new ContractError(INVALID_INPUT);
+  }
+}
diff --git a/contracts/util/environment.ts b/contracts/util/environment.ts
new file mode 100644
index 0000000..9ac44fa
--- /dev/null
+++ b/contracts/util/environment.ts
@@ -0,0 +1,18 @@
+import { ContractError } from 'warp-contracts';
+
+export function ContractAssert(cond: boolean, message: any): asserts cond {
+  if (!cond) {
+    throw new ContractError(message);
+  }
+}
+
+export const SmartWeave = {
+  transaction: { id: '' },
+  unsafeClient: {
+    transactions: {
+      async getData(txid: string) {
+        return null;
+      },
+    },
+  },
+};
diff --git a/contracts/util/evolvable.ts b/contracts/util/evolvable.ts
new file mode 100644
index 0000000..88b9417
--- /dev/null
+++ b/contracts/util/evolvable.ts
@@ -0,0 +1,47 @@
+import {
+  ContractInteraction,
+  EvolveState,
+  HandlerResult,
+} from 'warp-contracts';
+
+import type { Constructor, OwnableState, PartialFunctionInput } from './';
+
+import { ContractAssert } from './';
+import type { ContractFunctionInput } from '../common/types';
+
+export const NEW_CONTRACT_SRC_REQUIRED = 'New Contract Src required';
+
+export type EvolvableState = Partial<EvolveState> & OwnableState;
+export type EvolvableResult = any;
+
+export interface Evolve extends ContractFunctionInput {
+  function: 'evolve';
+  newContractSrc: string;
+}
+
+export function Evolvable<Contract extends Constructor>(
+  ContractBase: Contract
+) {
+  return class EvolvableContract extends ContractBase {
+    evolve(
+      state: EvolvableState,
+      action: ContractInteraction<PartialFunctionInput<Evolve>>
+    ) {
+      const { input, caller } = action;
+
+      ContractAssert(
+        state.owner === caller,
+        'Only the owner can evolve the contract.'
+      );
+
+      ContractAssert(
+        !!(input.newContractSrc || input.value),
+        'New Contract Source ID is required to evolve.'
+      );
+
+      state.evolve = input.newContractSrc || input.value;
+
+      return { state, result: true };
+    }
+  };
+}
diff --git a/contracts/util/hex.ts b/contracts/util/hex.ts
new file mode 100644
index 0000000..3d1147c
--- /dev/null
+++ b/contracts/util/hex.ts
@@ -0,0 +1,63 @@
+type LengthOfString<
+  S extends string,
+  Acc extends 0[] = [],
+> = S extends `${string}${infer $Rest}`
+  ? LengthOfString<$Rest, [...Acc, 0]>
+  : Acc['length'];
+
+export type HexNumbers =
+  | '0'
+  | '1'
+  | '2'
+  | '3'
+  | '4'
+  | '5'
+  | '6'
+  | '7'
+  | '8'
+  | '9';
+
+export type HexCharsLower = 'a' | 'b' | 'c' | 'd' | 'e' | 'f';
+export type HexCharsUpper = 'A' | 'B' | 'C' | 'D' | 'E' | 'F';
+
+export type HexLower = HexNumbers | HexCharsLower;
+export type HexUpper = HexNumbers | HexCharsUpper;
+export type Hex = HexNumbers | HexCharsLower | HexCharsUpper;
+
+export type HexString<S> = S extends ''
+  ? unknown
+  : S extends `${Hex}${infer Rest}`
+    ? HexString<Rest>
+    : never;
+
+declare function onlyHexString<S extends string>(
+  hexString: S & HexString<S>
+): any;
+
+// onlyHexString('abcdef1234567890')
+
+export type EvmAddressType<S extends string = ''> = S extends ''
+  ? never
+  : LengthOfString<S> extends 42
+    ? S extends `0x${infer Rest}`
+      ? HexString<Rest>
+      : never
+    : never;
+
+declare function onlyEvmAddress<S extends string>(
+  address: S & EvmAddressType<S>
+): any;
+// onlyEvmAddress('0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')
+
+export type RelayFingerprint<S extends string = ''> = Uppercase<S> &
+  S extends ''
+  ? never
+  : LengthOfString<S> extends 40
+    ? HexString<S>
+    : never;
+
+declare function onlyRelayFingerprint<S extends string>(
+  fingerprint: S & RelayFingerprint<S>
+): any;
+
+// onlyTorFingerprint('AAAAABBBBBCCCCCDDDDDEEEEEFFFFF0000011111')
diff --git a/contracts/util/index.ts b/contracts/util/index.ts
new file mode 100644
index 0000000..11c3afa
--- /dev/null
+++ b/contracts/util/index.ts
@@ -0,0 +1,69 @@
+import { ContractError } from 'warp-contracts';
+import type {
+  ContractFunctionInput,
+  EvmAddress,
+  Fingerprint,
+  PublicKey,
+} from '../common/types';
+import { ContractAssert, SmartWeave } from './environment';
+import {
+  ADDRESS_REQUIRED,
+  FINGERPRINT_REQUIRED,
+  INVALID_ADDRESS,
+  INVALID_FINGERPRINT,
+  PUBLIC_KEY_REQUIRED,
+} from '../common/errors';
+
+import { ethers } from 'ethers';
+
+export * from './ownable';
+export * from './environment';
+export * from './evolvable';
+
+export type PartialFunctionInput<T extends ContractFunctionInput> = Partial<T> &
+  Pick<T, 'function'>;
+
+export interface Constructor<T = {}> {
+  new (...args: any[]): T;
+}
+
+export const INVALID_INPUT = 'Invalid input';
+export const UPPER_HEX_CHARS = '0123456789ABCDEF';
+
+export function assertValidFingerprint(
+  fingerprint?: string
+): asserts fingerprint is Fingerprint {
+  ContractAssert(!!fingerprint, FINGERPRINT_REQUIRED);
+  ContractAssert(typeof fingerprint === 'string', INVALID_FINGERPRINT);
+  ContractAssert(fingerprint.length === 40, INVALID_FINGERPRINT);
+  ContractAssert(
+    fingerprint.split('').every((c) => UPPER_HEX_CHARS.includes(c)),
+    INVALID_FINGERPRINT
+  );
+}
+
+export function assertValidEvmAddress(
+  address?: string
+): asserts address is EvmAddress {
+  ContractAssert(!!address, ADDRESS_REQUIRED);
+  ContractAssert(typeof address === 'string', INVALID_ADDRESS);
+  ContractAssert(address.length === 42, INVALID_ADDRESS);
+
+  try {
+    const checksumAddress = ethers.getAddress(address);
+    ContractAssert(address === checksumAddress, INVALID_ADDRESS);
+  } catch (error) {
+    throw new ContractError(INVALID_ADDRESS);
+  }
+}
+
+export function assertValidPublicKey(
+  publicKey?: string
+): asserts publicKey is PublicKey {
+  try {
+    ContractAssert(typeof publicKey === 'string', PUBLIC_KEY_REQUIRED);
+    ethers.computeAddress(publicKey);
+  } catch (error) {
+    throw new ContractError(PUBLIC_KEY_REQUIRED);
+  }
+}
diff --git a/contracts/util/ownable.ts b/contracts/util/ownable.ts
new file mode 100644
index 0000000..b8c0d60
--- /dev/null
+++ b/contracts/util/ownable.ts
@@ -0,0 +1,59 @@
+import {
+  ContractError,
+  ContractInteraction,
+  HandlerResult,
+} from 'warp-contracts';
+
+export type OwnableState = {
+  owner?: string;
+};
+
+export const ERROR_ONLY_OWNER =
+  'This function is only available to the contract owner';
+
+export const OnlyOwner = <S extends OwnableState>(
+  _target: Object,
+  _propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<
+    (state: S, action: ContractInteraction<any>) => any
+  >
+) => {
+  if (descriptor.value) {
+    const originalMethod = descriptor.value;
+    const wrapper = (state: S, action: ContractInteraction<any>) => {
+      if (action.caller !== state.owner) {
+        throw new ContractError(ERROR_ONLY_OWNER);
+      } else {
+        return originalMethod.apply(_target, [state, action]);
+      }
+    };
+    descriptor.value = wrapper;
+  }
+
+  return descriptor;
+};
+
+export const OnlyOwnerAsync = <S extends OwnableState>(
+  _target: Object,
+  _propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<
+    (
+      state: S,
+      action: ContractInteraction<any>
+    ) => Promise<HandlerResult<S, any>>
+  >
+) => {
+  if (descriptor.value) {
+    const originalMethod = descriptor.value;
+    const wrapper = async (state: S, action: ContractInteraction<any>) => {
+      if (action.caller !== state.owner) {
+        throw new ContractError(ERROR_ONLY_OWNER);
+      } else {
+        return await originalMethod.apply(_target, [state, action]);
+      }
+    };
+    descriptor.value = wrapper;
+  }
+
+  return descriptor;
+};
diff --git a/nuxt.config.ts b/nuxt.config.ts
index 6752519..ace9a3e 100755
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -53,7 +53,7 @@ export default defineNuxtConfig({
   runtimeConfig: {
     public: {
       walletConnectProjectId: 'f5e29d36441ccd0e2f5e3473d5a2021b',
-      relayRegistryAddress: 'ezVJt64LxwHkgZ_bJhe4gbus_IITSFUps2A2HpPaY0Y',
+      relayRegistryAddress: 'dlF1KbJ0yStp5yTzzQKt3ihgokyTZAWHGnZ01ikdULQ',
       facilitatorContract: '0x45F6b9757B36697EFd37e98883894e98025E58a6',
       sepoliaAtorTokenContract: '0x3F7D7e1161B4CbC172517a2957A13814f4a657A2',
       tokenContractMain: '0x0f7b3f5a8fed821c5eb60049538a548db2d479ce',
@@ -67,7 +67,7 @@ export default defineNuxtConfig({
       supportWalletPublicKeyBase64:
         'K3jnSGVyHj4kSzgce3+k8gJsfHvUoQeJMNPO8CcsO2s=',
       commitHash: process.env.NUXT_PUBLIC_COMMIT_HASH || 'dev',
-      version: '1.1.0',
+      version: '1.1.1',
     },
   },
   plugins: [{ src: '~/plugins/vue-query.client.ts', mode: 'client' }],
diff --git a/stores/useUserStore.ts b/stores/useUserStore.ts
index 09cc722..242a0a8 100755
--- a/stores/useUserStore.ts
+++ b/stores/useUserStore.ts
@@ -3,6 +3,7 @@ import { useAccount } from '@wagmi/vue';
 import { getBalance } from '@wagmi/core';
 import { type GetBalanceReturnType } from '@wagmi/core';
 import type { RelayMeta } from '@/types/relay';
+import { handle as RegistryHandle } from '@/contracts/relay-registry';
 
 import { useNickNameCache } from '~/composables/nicknameCache';
 
@@ -38,6 +39,7 @@ export const useUserStore = defineStore('user', {
     claimableRelays: [] as RelayRow[],
     registrationCredits: [] as string[],
     registrationCreditsRequired: true,
+    registrationCreditsCache: {} as Record<string, boolean>,
     families: {} as Record<string, string[]>,
     relaysMeta: {} as Record<string, RelayMeta>,
     nickNames: {} as Record<string, string>,
@@ -45,6 +47,7 @@ export const useUserStore = defineStore('user', {
     claimedRewardsTotal: 0,
     serials: [] as string[],
     familyRequired: false,
+    familyVerifiedCache: {} as Record<string, boolean>,
   }),
   actions: {
     // Get ANON balance
@@ -232,16 +235,29 @@ export const useUserStore = defineStore('user', {
         return true;
       }
 
+      if (
+        !forceRefresh &&
+        this.registrationCreditsCache[fingerprint] !== undefined
+      ) {
+        return this.registrationCreditsCache[fingerprint];
+      }
+
       const relayCache = useRelayCache();
       const cachedData = await relayCache.getRelayData(forceRefresh);
       if (cachedData) {
         this.registrationCredits = cachedData.registrationCredits;
-        return this.registrationCredits.includes(fingerprint);
       } else {
         // build cache
         await this.createRelayCache();
-        return this.registrationCredits.includes(fingerprint);
+        this.registrationCredits = cachedData.registrationCredits;
       }
+      // Check if the fingerprint has registration credits
+      const hasCredit = this.registrationCredits.includes(fingerprint);
+
+      // Cache the result
+      this.registrationCreditsCache[fingerprint] = hasCredit;
+
+      return hasCredit;
     },
     async familyVerified(fingerprint: string) {
       if (!this.userData.address) {
@@ -251,6 +267,10 @@ export const useUserStore = defineStore('user', {
         return true;
       }
 
+      if (this.familyVerifiedCache[fingerprint] !== undefined) {
+        return this.familyVerifiedCache[fingerprint];
+      }
+
       const relayCache = useRelayCache();
       const cachedData = await relayCache.getRelayData();
       if (cachedData) {
@@ -260,6 +280,7 @@ export const useUserStore = defineStore('user', {
             (this.families[fingerprint].length === 1 &&
               this.families[fingerprint][0] === fingerprint)
           ) {
+            this.familyVerifiedCache[fingerprint] = true;
             return true;
           }
 
@@ -273,6 +294,7 @@ export const useUserStore = defineStore('user', {
               familyFingerprints.includes(fp.fingerprint)
             );
           if (!claimingFamilyIncludesAllVerifiedRelays) {
+            this.familyVerifiedCache[fingerprint] = false;
             return false;
           }
 
@@ -282,12 +304,15 @@ export const useUserStore = defineStore('user', {
                 fingerprint
               )
             ) {
+              this.familyVerifiedCache[fingerprint] = false;
               return false;
             }
           }
+          this.familyVerifiedCache[fingerprint] = true;
 
           return true;
         } else {
+          this.familyVerifiedCache[fingerprint] = false;
           return true;
         }
       } else {
@@ -296,6 +321,39 @@ export const useUserStore = defineStore('user', {
         return true;
       }
     },
+    async familyVerified2(fingerprint: string): Promise<boolean> {
+      const input = {
+        function: 'claim',
+        fingerprint: fingerprint,
+      };
+
+      const interaction = {
+        input,
+        caller: this.userData.address,
+        interactionType: 'write',
+      };
+
+      const relayCache = useRelayCache();
+      const cachedData = await relayCache.getRelayData();
+      if (cachedData) {
+        try {
+          const result = await RegistryHandle(cachedData.state, interaction);
+          return true;
+        } catch (error: any) {
+          switch (error.message) {
+            case 'Subsequent relay claims require family to be set':
+              return false;
+            default:
+              return true;
+          }
+        }
+      } else {
+        await this.createRelayCache();
+        return true;
+      }
+
+      return false;
+    },
     async clearCache() {
       const relayCache = useRelayCache();
       this.verifiedRelays = [];
diff --git a/utils/warp.read.ts b/utils/warp.read.ts
index 37765fe..6321ded 100755
--- a/utils/warp.read.ts
+++ b/utils/warp.read.ts
@@ -8,6 +8,7 @@ type FunctionName = 'verified' | 'claimable' | 'serials';
 type RelayData = {
   timestamp: number;
   data: {
+    state: any;
     verified: [
       {
         address: string;
@@ -233,6 +234,7 @@ export const getAllRelays = async (
     return {
       timestamp: Date.now(),
       data: {
+        state: result.cachedValue.state,
         verified: verifiedRelays as [
           {
             address: string;