stellar
diff --git a/‎extension/src/helpers/contactList.ts‎
Lines changed: 180 additions & 0 deletions b/‎extension/src/helpers/contactList.ts‎
Lines changed: 180 additions & 0 deletions
diff --git a/‎extension/src/helpers/stellar.ts‎
Lines changed: 5 additions & 2 deletions b/‎extension/src/helpers/stellar.ts‎
Lines changed: 5 additions & 2 deletions
diff --git a/‎extension/src/popup/Router.tsx‎
Lines changed: 4 additions & 0 deletions b/‎extension/src/popup/Router.tsx‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎extension/src/popup/basics/shadcn/Toast/index.tsx‎
Lines changed: 2 additions & 0 deletions b/‎extension/src/popup/basics/shadcn/Toast/index.tsx‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎extension/src/popup/basics/shadcn/Toast/styles.scss‎
Lines changed: 73 additions & 0 deletions b/‎extension/src/popup/basics/shadcn/Toast/styles.scss‎
Lines changed: 73 additions & 0 deletions
@@ -0,0 +1,180 @@
+import React from "react";
+import { object as YupObject, string as YupString } from "yup";
+import { Federation } from "stellar-sdk";
+
+import {
+  isValidStellarAddress,
+  isFederationAddress,
+  isValidFederatedDomain,
+} from "helpers/stellar";
+
+export const FEDERATION_TIMEOUT_MS = 10_000;
+export const NAME_MAX_LENGTH = 32;
+
+// Strip bidi control characters and zero-width characters that enable visual
+// spoofing — critical in a wallet context where contact names guide sends.
+const BIDI_AND_ZW_RE = /[\u200B-\u200F\u2028-\u202F\u2060-\u2069\uFEFF\u00AD]/g;
+
+export const sanitizeName = (value: string) =>
+  value.replace(BIDI_AND_ZW_RE, "");
+
+/**
+ * Resolves a federation address with a hard timeout and AbortController support.
+ */
+export const resolveFederationAddress = (
+  address: string,
+  signal?: AbortSignal,
+) =>
+  Promise.race([
+    Federation.Server.resolve(address),
+    new Promise<never>((_, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error("Federation resolution timed out")),
+        FEDERATION_TIMEOUT_MS,
+      );
+      signal?.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(new Error("Aborted"));
+      });
+    }),
+  ]);
+
+// ---------------------------------------------------------------------------
+// Contact form validation schema
+// ---------------------------------------------------------------------------
+
+interface ContactsMapEntry {
+  name: string;
+  resolvedAddress?: string;
+}
+
+type ContactsMap = Record<string, ContactsMapEntry>;
+
+/** Mutable refs the schema reads/writes during async federation validation. */
+export interface FederationRefs {
+  resolvedAddress: React.RefObject<string | undefined>;
+  lastResolvedInput: React.RefObject<string | undefined>;
+  federationFailed: React.RefObject<boolean>;
+  hasAddressBlurred: React.RefObject<boolean>;
+  activeField: React.RefObject<string | null>;
+  abortController: React.RefObject<AbortController | null>;
+  isMounted: React.RefObject<boolean>;
+}
+
+export interface ContactFormSchemaConfig {
+  t: (key: string) => string;
+  existingContacts: ContactsMap;
+  refs: FederationRefs;
+  setIsFetchingFederationAddress: (fetching: boolean) => void;
+}
+
+export const createContactFormSchema = ({
+  t,
+  existingContacts,
+  refs,
+  setIsFetchingFederationAddress,
+}: ContactFormSchemaConfig) =>
+  YupObject().shape({
+    address: YupString()
+      .required(t("Invalid Stellar address"))
+      .trim()
+      .test("is-valid-stellar-address", t("Invalid Stellar address"), (val) => {
+        if (!val) return false;
+        const trimmed = val.trim();
+        if (isFederationAddress(trimmed)) {
+          return isValidFederatedDomain(trimmed);
+        }
+        return isValidStellarAddress(trimmed);
+      })
+      .test(
+        "is-not-federation-failure",
+        t("Failed to resolve federated address"),
+        async (val) => {
+          if (!val) return true;
+          const trimmed = val.trim();
+
+          if (!isFederationAddress(trimmed)) {
+            refs.resolvedAddress.current = undefined;
+            refs.lastResolvedInput.current = undefined;
+            refs.federationFailed.current = false;
+            return true;
+          }
+
+          // Use cached result if we already resolved this exact value
+          if (refs.lastResolvedInput.current === trimmed) {
+            return refs.resolvedAddress.current !== undefined;
+          }
+
+          refs.abortController.current?.abort();
+          const controller = new AbortController();
+          refs.abortController.current = controller;
+
+          if (refs.isMounted.current) {
+            setIsFetchingFederationAddress(true);
+          }
+
+          try {
+            const fedResp = await resolveFederationAddress(
+              trimmed,
+              controller.signal,
+            );
+
+            if (controller.signal.aborted) return true;
+
+            refs.resolvedAddress.current = fedResp.account_id;
+            refs.lastResolvedInput.current = trimmed;
+            refs.federationFailed.current = false;
+            return true;
+          } catch {
+            if (controller.signal.aborted) return true;
+            refs.resolvedAddress.current = undefined;
+            refs.lastResolvedInput.current = undefined;
+            refs.federationFailed.current = true;
+            return false;
+          } finally {
+            if (refs.isMounted.current) {
+              setIsFetchingFederationAddress(false);
+            }
+          }
+        },
+      )
+      .test(
+        "is-not-duplicate-address",
+        t("This address already exists in your contacts"),
+        (val) => {
+          if (!val) return true;
+          const trimmed = val.trim();
+
+          const rawDuplicate = Object.keys(existingContacts).some(
+            (key) => key.toLowerCase() === trimmed.toLowerCase(),
+          );
+          if (rawDuplicate) return false;
+
+          const resolved = refs.resolvedAddress.current;
+          if (resolved && refs.lastResolvedInput.current === trimmed) {
+            const resolvedLower = resolved.toLowerCase();
+            return !Object.entries(existingContacts).some(
+              ([key, contact]) =>
+                key.toLowerCase() === resolvedLower ||
+                contact.resolvedAddress?.toLowerCase() === resolvedLower,
+            );
+          }
+          return true;
+        },
+      ),
+    name: YupString()
+      .required(t("Name cannot be empty"))
+      .trim()
+      .max(NAME_MAX_LENGTH, t("Name is too long"))
+      .test(
+        "is-not-duplicate-name",
+        t("This name already exists in your contacts"),
+        (val) => {
+          if (!val) return true;
+          const sanitized = sanitizeName(val.trim());
+          return !Object.values(existingContacts).some(
+            (c) => c.name.toLowerCase() === sanitized.toLowerCase(),
+          );
+        },
+      ),
+  });
@@ -245,11 +245,14 @@ export const isValidStellarAddress = (publicKey: string): boolean => {
   }
 };
 
-export const isFederationAddress = (address: string) => address.includes("*");
+export const isFederationAddress = (address: string) => {
+  const parts = address.split("*");
+  return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
+};
 
 export const isValidDomain = (input: string) => {
   // eslint-disable-next-line no-useless-escape
-  const domainRegex = /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,6}$/i;
+  const domainRegex = /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,63}$/i;
   if (domainRegex.test(input)) {
     return true;
   } else {
 
@@ -62,6 +62,7 @@ import { AccountMigration } from "popup/views/AccountMigration";
 import { AddFunds } from "popup/views/AddFunds";
 import { Discover } from "popup/views/Discover";
 import { Wallets } from "popup/views/Wallets";
+import { ContactBook } from "popup/views/ContactBook";
 
 import { DEV_SERVER } from "@shared/constants/services";
 import { SettingsState } from "@shared/api/types";
@@ -71,6 +72,7 @@ import { SignMessage } from "./views/SignMessage";
 import { View } from "./basics/layout/View";
 import { AppDispatch } from "./App";
 
+import { Toaster } from "./basics/shadcn/Toast";
 import "popup/metrics/views";
 
 /*
@@ -170,6 +172,7 @@ export const Router = () => (
           index
           element={
             <ActiveTabProvider>
+              <Toaster />
               <Account />
             </ActiveTabProvider>
           }
@@ -277,6 +280,7 @@ export const Router = () => (
         <Route path={ROUTES.addFunds} element={<AddFunds />} />
         <Route path={ROUTES.discover} element={<Discover />} />
         <Route path={ROUTES.wallets} element={<Wallets />} />
+        <Route path={ROUTES.contactBook} element={<ContactBook />}></Route>
 
         {DEV_SERVER && (
           <>
 
@@ -18,6 +18,8 @@ function Toaster({ ...props }: React.ComponentProps<typeof SonnerToaster>) {
       position="top-center"
       icons={{
         info: <Icon.InfoCircle />,
+        success: <Icon.CheckCircle />,
+        error: <Icon.XCircle />,
       }}
       {...props}
     />
 
@@ -1,5 +1,78 @@
+@use "../../../styles/utils.scss" as *;
+
 .Toast {
   li:before {
     content: none !important;
   }
+
+  [data-sonner-toast][data-styled="true"] {
+    --normal-bg: var(--sds-clr-gray-02);
+    background: var(--sds-clr-gray-02);
+    border: 1px solid var(--sds-clr-gray-06);
+    border-radius: pxToRem(8px);
+    padding: pxToRem(12px);
+    gap: pxToRem(8px);
+    box-shadow: none;
+  }
+
+  [data-close-button] {
+    order: 3;
+    margin-left: auto;
+  }
+
+  [data-sonner-toast][data-styled="true"] [data-title] {
+    font-size: pxToRem(14px);
+    font-weight: 600;
+    line-height: pxToRem(20px);
+    color: var(--sds-clr-gray-12);
+  }
+
+  [data-sonner-toast][data-styled="true"][data-type="success"] [data-icon] {
+    color: var(--sds-clr-green-09, #30a46c);
+
+    svg {
+      width: pxToRem(16px);
+      height: pxToRem(16px);
+    }
+  }
+
+  [data-sonner-toast][data-styled="true"][data-type="error"] [data-icon] {
+    color: var(--sds-clr-red-09, #e5484d);
+
+    svg {
+      width: pxToRem(16px);
+      height: pxToRem(16px);
+    }
+  }
+
+  [data-sonner-toast][data-styled="true"] [data-icon] {
+    svg {
+      width: pxToRem(16px);
+      height: pxToRem(16px);
+    }
+  }
+
+  [data-sonner-toast][data-styled="true"] [data-close-button] {
+    position: static;
+    top: unset;
+    right: unset;
+    left: unset;
+    transform: none;
+    background: transparent;
+    border: none;
+    color: var(--sds-clr-gray-09);
+    width: pxToRem(20px);
+    height: pxToRem(20px);
+    padding: pxToRem(2px);
+
+    &:hover {
+      background: transparent;
+      color: var(--sds-clr-gray-12);
+    }
+
+    svg {
+      width: pxToRem(16px);
+      height: pxToRem(16px);
+    }
+  }
 }