diff --git a/App/iOS/Delegates/AppDelegate.swift b/App/iOS/Delegates/AppDelegate.swift
index 02e70321d2c7..12f9539d1148 100644
--- a/App/iOS/Delegates/AppDelegate.swift
+++ b/App/iOS/Delegates/AppDelegate.swift
@@ -27,6 +27,7 @@ import BraveTalk
 #endif
 import Onboarding
 import os
+import BraveWallet
 
 extension AppDelegate {
   // A model that is passed used in every scene
@@ -418,10 +419,10 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
       (SessionRestoreHandler.path, SessionRestoreHandler()),
       (ErrorPageHandler.path, ErrorPageHandler()),
       (ReaderModeHandler.path, ReaderModeHandler(profile: profile)),
-      (SNSDomainHandler.path, SNSDomainHandler()),
-      (IPFSSchemeHandler.path, IPFSSchemeHandler())
+      (IPFSSchemeHandler.path, IPFSSchemeHandler()),
+      (Web3DomainHandler.path, Web3DomainHandler())
     ]
-    
+
     responders.forEach { (path, responder) in
       InternalSchemeHandler.responders[path] = responder
     }
diff --git a/Package.swift b/Package.swift
index e1db954617a9..83b009b0dc75 100644
--- a/Package.swift
+++ b/Package.swift
@@ -368,7 +368,7 @@ var braveTarget: PackageDescription.Target = .target(
     .copy("Assets/Interstitial Pages/Pages/CertificateError.html"),
     .copy("Assets/Interstitial Pages/Pages/GenericError.html"),
     .copy("Assets/Interstitial Pages/Pages/NetworkError.html"),
-    .copy("Assets/Interstitial Pages/Pages/SNSDomain.html"),
+    .copy("Assets/Interstitial Pages/Pages/Web3Domain.html"),
     .copy("Assets/Interstitial Pages/Pages/IPFSPreference.html"),
     .copy("Assets/Interstitial Pages/Images/Carret.png"),
     .copy("Assets/Interstitial Pages/Images/Clock.svg"),
@@ -383,7 +383,7 @@ var braveTarget: PackageDescription.Target = .target(
     .copy("Assets/Interstitial Pages/Styles/CertificateError.css"),
     .copy("Assets/Interstitial Pages/Styles/InterstitialStyles.css"),
     .copy("Assets/Interstitial Pages/Styles/NetworkError.css"),
-    .copy("Assets/Interstitial Pages/Styles/SNSDomain.css"),
+    .copy("Assets/Interstitial Pages/Styles/Web3Domain.css"),
     .copy("Assets/Interstitial Pages/Styles/IPFSPreference.css"),
     .copy("Assets/SearchPlugins"),
     .copy("Frontend/Reader/Reader.css"),
diff --git a/Sources/Brave/Assets/Interstitial Pages/Pages/SNSDomain.html b/Sources/Brave/Assets/Interstitial Pages/Pages/Web3Domain.html
similarity index 73%
rename from Sources/Brave/Assets/Interstitial Pages/Pages/SNSDomain.html
rename to Sources/Brave/Assets/Interstitial Pages/Pages/Web3Domain.html
index 42a118ab22e1..fd573968701f 100644
--- a/Sources/Brave/Assets/Interstitial Pages/Pages/SNSDomain.html	
+++ b/Sources/Brave/Assets/Interstitial Pages/Pages/Web3Domain.html	
@@ -10,7 +10,7 @@
   <meta name="referrer" content="no-referrer">
   <title>%page_title%</title>
   <link rel="stylesheet" href="internal://local/interstitial-style/InterstitialStyles.css">
-  <link rel="stylesheet" href="internal://local/interstitial-style/SNSDomain.css">
+  <link rel="stylesheet" href="internal://local/interstitial-style/Web3Domain.css">
 </head>
 
 <body dir="&locale.dir;" class="background content">
@@ -28,23 +28,25 @@
     <br />
     
     <div id="navigationButtons" class="navigationButtons">
-      <button id="disableSNSButton" class="disableButton disableButtonTitle">%button_disable%</button>
-      <button id="proceedSNSButton" class="proceedButton proceedButtonTitle">%button_procced%</button>
+      <button id="disableWeb3Button" class="disableButton disableButtonTitle">%button_disable%</button>
+      <button id="proceedWeb3Button" class="proceedButton proceedButtonTitle">%button_procced%</button>
     </div>
     
     <script type="text/javascript">
-      var disableButton = document.getElementById("disableSNSButton")
+      var disableButton = document.getElementById("disableWeb3Button")
       disableButton.addEventListener('click', function(e) {
         e.preventDefault();
         webkit.messageHandlers["%message_handler%"].postMessage({
-          "type": "SNSDisable",
+          "button_type": "disable",
+          "service_id": "%service_id%"
         });
       });
-      var proceedButton = document.getElementById("proceedSNSButton")
+      var proceedButton = document.getElementById("proceedWeb3Button")
       proceedButton.addEventListener('click', function(e) {
         e.preventDefault();
         webkit.messageHandlers["%message_handler%"].postMessage({
-          "type": "SNSProceed",
+          "button_type": "proceed",
+          "service_id": "%service_id%"
         });
       });
       
diff --git a/Sources/Brave/Assets/Interstitial Pages/Styles/SNSDomain.css b/Sources/Brave/Assets/Interstitial Pages/Styles/Web3Domain.css
similarity index 100%
rename from Sources/Brave/Assets/Interstitial Pages/Styles/SNSDomain.css
rename to Sources/Brave/Assets/Interstitial Pages/Styles/Web3Domain.css
diff --git a/Sources/Brave/Frontend/Browser/BrowserViewController.swift b/Sources/Brave/Frontend/Browser/BrowserViewController.swift
index 7a92e86661c5..f9045a73ba87 100644
--- a/Sources/Brave/Frontend/Browser/BrowserViewController.swift
+++ b/Sources/Brave/Frontend/Browser/BrowserViewController.swift
@@ -259,6 +259,9 @@ public class BrowserViewController: UIViewController {
   weak var walletStore: WalletStore?
   
   var lastEnteredURLVisitType: VisitType = .unknown
+  
+  var processAddressBarTask: Task<(), Never>?
+  var topToolbarDidPressReloadTask: Task<(), Never>?
 
   public init(
     profile: Profile,
@@ -1607,10 +1610,12 @@ public class BrowserViewController: UIViewController {
     tab.webView?.load(PrivilegedRequest(url: internalUrl) as URLRequest)
   }
 
-  func showSNSDomainInterstitialPage(originalURL: URL, visitType: VisitType) {
+  func showWeb3ServiceInterstitialPage(service: Web3Service, originalURL: URL, visitType: VisitType = .unknown) {
     topToolbar.leaveOverlayMode()
-    
-    guard let tab = tabManager.selectedTab, let encodedURL = originalURL.absoluteString.addingPercentEncoding(withAllowedCharacters: .alphanumerics), let internalUrl = URL(string: "\(InternalURL.baseUrl)/\(SNSDomainHandler.path)?url=\(encodedURL)") else {
+
+    guard let tab = tabManager.selectedTab,
+          let encodedURL = originalURL.absoluteString.addingPercentEncoding(withAllowedCharacters: .alphanumerics),
+          let internalUrl = URL(string: "\(InternalURL.baseUrl)/\(Web3DomainHandler.path)?\(Web3NameServiceScriptHandler.ParamKey.serviceId.rawValue)=\(service.rawValue)&url=\(encodedURL)") else {
       return
     }
     let scriptHandler = tab.getContentScript(name: Web3NameServiceScriptHandler.scriptName) as? Web3NameServiceScriptHandler
diff --git a/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+ToolbarDelegate.swift b/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+ToolbarDelegate.swift
index 0afd4357026d..ea18b135db80 100644
--- a/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+ToolbarDelegate.swift
+++ b/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+ToolbarDelegate.swift
@@ -107,29 +107,28 @@ extension BrowserViewController: TopToolbarDelegate {
   }
 
   func topToolbarDidPressReload(_ topToolbar: TopToolbarView) {
-    let isPrivateMode = PrivateBrowsingManager.shared.isPrivateBrowsing
-    
     if let url = topToolbar.currentURL {
       if url.isIPFSScheme {
         if !handleIPFSSchemeURL(url, visitType: .unknown) {
           tabManager.selectedTab?.reload()
         }
-      } else if !isPrivateMode, url.domainURL.schemelessAbsoluteDisplayString.endsWithSupportedSNSExtension, let rpcService = BraveWallet.JsonRpcServiceFactory.get(privateMode: isPrivateMode) {
-        Task { @MainActor in
-          let currentStatus = await rpcService.snsResolveMethod()
-          switch currentStatus {
-          case .ask:
-            // show name service interstitial page
-            showSNSDomainInterstitialPage(originalURL: url, visitType: .unknown)
-          case .enabled:
-            if let resolvedURL = await resolveSNSHost(url.schemelessAbsoluteDisplayString, rpcService: rpcService) {
+      } else if let decentralizedDNSHelper = decentralizedDNSHelperFor(url: topToolbar.currentURL) {
+        topToolbarDidPressReloadTask?.cancel()
+        topToolbarDidPressReloadTask = Task { @MainActor in
+          topToolbar.locationView.loading = true
+          let result = await decentralizedDNSHelper.lookup(domain: url.schemelessAbsoluteDisplayString)
+          topToolbar.locationView.loading = tabManager.selectedTab?.loading ?? false
+          guard !Task.isCancelled else { return } // user pressed stop, or typed new url
+          switch result {
+          case let .loadInterstitial(service):
+            showWeb3ServiceInterstitialPage(service: service, originalURL: url)
+          case let .load(resolvedURL):
+            if resolvedURL.isIPFSScheme {
+              handleIPFSSchemeURL(resolvedURL, visitType: .unknown)
+            } else {
               tabManager.selectedTab?.loadRequest(URLRequest(url: resolvedURL))
-              return
             }
-            tabManager.selectedTab?.loadRequest(URLRequest(url: url))
-          case .disabled:
-            tabManager.selectedTab?.reload()
-          @unknown default:
+          case .none:
             tabManager.selectedTab?.reload()
           }
         }
@@ -143,6 +142,9 @@ extension BrowserViewController: TopToolbarDelegate {
 
   func topToolbarDidPressStop(_ topToolbar: TopToolbarView) {
     tabManager.selectedTab?.stop()
+    processAddressBarTask?.cancel()
+    topToolbarDidPressReloadTask?.cancel()
+    topToolbar.locationView.loading = tabManager.selectedTab?.loading ?? false
   }
 
   func topToolbarDidLongPressReloadButton(_ topToolbar: TopToolbarView, from button: UIButton) {
@@ -246,7 +248,8 @@ extension BrowserViewController: TopToolbarDelegate {
   }
 
   func processAddressBar(text: String, visitType: VisitType, isBraveSearchPromotion: Bool = false) {
-    Task { @MainActor in
+    processAddressBarTask?.cancel()
+    processAddressBarTask = Task { @MainActor in
       if !isBraveSearchPromotion, await submitValidURL(text, visitType: visitType) {
         return
       } else {
@@ -260,12 +263,6 @@ extension BrowserViewController: TopToolbarDelegate {
     }
   }
   
-  @MainActor func resolveSNSHost(_ host: String, rpcService: BraveWalletJsonRpcService) async -> URL? {
-    let (url, status, _) = await rpcService.snsResolveHost(host)
-    guard let url = url, status == .success else { return nil }
-    return url
-  }
-  
   @discardableResult
   func handleIPFSSchemeURL(_ url: URL, visitType: VisitType) -> Bool {
     guard !PrivateBrowsingManager.shared.isPrivateBrowsing else {
@@ -307,24 +304,26 @@ extension BrowserViewController: TopToolbarDelegate {
       // Do not allow users to enter URLs with the following schemes.
       // Instead, submit them to the search engine like Chrome-iOS does.
       if !["file"].contains(fixupURL.scheme) {
-        // check text is SNS domain
-        let isPrivateMode = PrivateBrowsingManager.shared.isPrivateBrowsing
-        if !isPrivateMode, fixupURL.domainURL.schemelessAbsoluteDisplayString.endsWithSupportedSNSExtension, let rpcService = BraveWallet.JsonRpcServiceFactory.get(privateMode: isPrivateMode) {
-          let currentStatus = await rpcService.snsResolveMethod()
-          switch currentStatus {
-          case .ask:
-            // show name service interstitial page
-            showSNSDomainInterstitialPage(originalURL: fixupURL, visitType: visitType)
+        // check text is decentralized DNS supported domain
+        if let decentralizedDNSHelper = self.decentralizedDNSHelperFor(url: fixupURL) {
+          topToolbar.leaveOverlayMode()
+          updateToolbarCurrentURL(fixupURL)
+          topToolbar.locationView.loading = true
+          let result = await decentralizedDNSHelper.lookup(domain: fixupURL.schemelessAbsoluteDisplayString)
+          topToolbar.locationView.loading = tabManager.selectedTab?.loading ?? false
+          guard !Task.isCancelled else { return true } // user pressed stop, or typed new url
+          switch result {
+          case let .loadInterstitial(service):
+            showWeb3ServiceInterstitialPage(service: service, originalURL: fixupURL, visitType: visitType)
             return true
-          case .enabled:
-            if let resolvedURL = await resolveSNSHost(text, rpcService: rpcService) {
-              // resolved url
+          case let .load(resolvedURL):
+            if resolvedURL.isIPFSScheme {
+              return handleIPFSSchemeURL(resolvedURL, visitType: visitType)
+            } else {
               finishEditingAndSubmit(resolvedURL, visitType: visitType)
               return true
             }
-          case .disabled:
-            break
-          @unknown default:
+          case .none:
             break
           }
         }
diff --git a/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+WKNavigationDelegate.swift b/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+WKNavigationDelegate.swift
index 742b3ff2af3c..c2cabaad0f14 100644
--- a/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+WKNavigationDelegate.swift
+++ b/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+WKNavigationDelegate.swift
@@ -126,7 +126,7 @@ extension BrowserViewController: WKNavigationDelegate {
 
   @MainActor
   public func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, preferences: WKWebpagePreferences) async -> (WKNavigationActionPolicy, WKWebpagePreferences) {
-    guard let url = navigationAction.request.url else {
+    guard var url = navigationAction.request.url else {
       return (.cancel, preferences)
     }
 
@@ -198,6 +198,31 @@ extension BrowserViewController: WKNavigationDelegate {
       }
       return (.cancel, preferences)
     }
+    
+    // handles Decentralized DNS
+    if let decentralizedDNSHelper = self.decentralizedDNSHelperFor(url: url),
+       navigationAction.targetFrame?.isMainFrame == true {
+      topToolbar.locationView.loading = true
+      let result = await decentralizedDNSHelper.lookup(domain: url.schemelessAbsoluteDisplayString)
+      topToolbar.locationView.loading = tabManager.selectedTab?.loading ?? false
+      guard !Task.isCancelled else { // user pressed stop, or typed new url
+        return (.cancel, preferences)
+      }
+      switch result {
+      case let .loadInterstitial(service):
+        showWeb3ServiceInterstitialPage(service: service, originalURL: url, visitType: .link)
+        return (.cancel, preferences)
+      case let .load(resolvedURL):
+        if resolvedURL.isIPFSScheme {
+          handleIPFSSchemeURL(resolvedURL, visitType: .link)
+          return (.cancel, preferences)
+        } else { // non-ipfs, treat as normal url / link tapped
+          url = resolvedURL
+        }
+      case .none:
+        break
+      }
+    }
 
     let isPrivateBrowsing = PrivateBrowsingManager.shared.isPrivateBrowsing
     
diff --git a/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+Web3NameService.swift b/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+Web3NameService.swift
index 3f37b61d78f6..3e82d99e4e12 100644
--- a/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+Web3NameService.swift
+++ b/Sources/Brave/Frontend/Browser/BrowserViewController/BrowserViewController+Web3NameService.swift
@@ -9,23 +9,51 @@ import BraveShared
 import BraveCore
 
 extension BrowserViewController: Web3NameServiceScriptHandlerDelegate {
-  func web3NameServiceDecisionHandler(_ proceed: Bool, originalURL: URL, visitType: VisitType) {
+  /// Returns a `DecentralizedDNSHelper` for the given mode if supported and not in private mode.
+  func decentralizedDNSHelperFor(url: URL?) -> DecentralizedDNSHelper? {
     let isPrivateMode = PrivateBrowsingManager.shared.isPrivateBrowsing
-    guard let rpcService = BraveWallet.JsonRpcServiceFactory.get(privateMode: isPrivateMode) else {
+    guard !isPrivateMode,
+          let url,
+          DecentralizedDNSHelper.isSupported(domain: url.domainURL.schemelessAbsoluteDisplayString),
+          let rpcService = BraveWallet.JsonRpcServiceFactory.get(privateMode: isPrivateMode) else { return nil }
+    return DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: braveCore.ipfsAPI,
+      isPrivateMode: isPrivateMode
+    )
+  }
+
+  func web3NameServiceDecisionHandler(_ proceed: Bool, web3Service: Web3Service, originalURL: URL, visitType: VisitType) {
+    let isPrivateMode = PrivateBrowsingManager.shared.isPrivateBrowsing
+    guard let rpcService = BraveWallet.JsonRpcServiceFactory.get(privateMode: isPrivateMode),
+          let decentralizedDNSHelper = self.decentralizedDNSHelperFor(url: originalURL) else {
       finishEditingAndSubmit(originalURL, visitType: visitType)
       return
     }
-    if proceed {
-      Task { @MainActor in
-        rpcService.setSnsResolveMethod(.enabled)
-        if let host = originalURL.host, let resolvedUrl = await resolveSNSHost(host, rpcService: rpcService) {
-          // resolved url
-          finishEditingAndSubmit(resolvedUrl, visitType: visitType)
+    Task { @MainActor in
+      switch web3Service {
+      case .solana:
+        rpcService.setSnsResolveMethod(proceed ? .enabled : .disabled)
+      case .ethereum:
+        rpcService.setEnsResolveMethod(proceed ? .enabled : .disabled)
+      case .ethereumOffchain:
+        rpcService.setEnsOffchainLookupResolveMethod(proceed ? .enabled : .disabled)
+      }
+      let result = await decentralizedDNSHelper.lookup(domain: originalURL.host ?? originalURL.absoluteString)
+      switch result {
+      case let .load(resolvedURL):
+        if resolvedURL.isIPFSScheme {
+          handleIPFSSchemeURL(resolvedURL, visitType: visitType)
+        } else {
+          finishEditingAndSubmit(resolvedURL, visitType: visitType)
         }
+      case let .loadInterstitial(service):
+        // ENS interstitial -> ENS Offchain interstitial possible
+        showWeb3ServiceInterstitialPage(service: service, originalURL: originalURL, visitType: visitType)
+      case .none:
+        // failed to resolve domain or disabled
+        finishEditingAndSubmit(originalURL, visitType: visitType)
       }
-    } else {
-      rpcService.setSnsResolveMethod(.disabled)
-      finishEditingAndSubmit(originalURL, visitType: visitType)
     }
   }
 }
diff --git a/Sources/Brave/Frontend/Browser/Handlers/IPFSSchemeHandler.swift b/Sources/Brave/Frontend/Browser/Handlers/IPFSSchemeHandler.swift
index acc63941124e..de50ee1260e4 100644
--- a/Sources/Brave/Frontend/Browser/Handlers/IPFSSchemeHandler.swift
+++ b/Sources/Brave/Frontend/Browser/Handlers/IPFSSchemeHandler.swift
@@ -29,7 +29,7 @@ public class IPFSSchemeHandler: InternalSchemeResponse {
       "interstitial_ipfs_title": Strings.Wallet.web3IPFSInterstitialIPFSTitle,
       "interstitial_ipfs_privacy": String.localizedStringWithFormat(Strings.Wallet.web3IPFSInterstitialIPFSPrivacy, WalletConstants.ipfsLearnMoreLink.absoluteString, Strings.learnMore.lowercased().capitalizeFirstLetter),
       "interstitial_ipfs_public_gateway": Strings.Wallet.web3IPFSInterstitialIPFSPublicGateway,
-      "button_disable": Strings.Wallet.snsDomainInterstitialPageButtonDisable,
+      "button_disable": Strings.Wallet.web3DomainInterstitialPageButtonDisable,
       "button_procced": Strings.Wallet.web3IPFSInterstitialProceedButton,
       "message_handler": Web3IPFSScriptHandler.messageHandlerName,
     ]
diff --git a/Sources/Brave/Frontend/Browser/Handlers/SNSDomainHandler.swift b/Sources/Brave/Frontend/Browser/Handlers/SNSDomainHandler.swift
deleted file mode 100644
index 018f0868ced3..000000000000
--- a/Sources/Brave/Frontend/Browser/Handlers/SNSDomainHandler.swift
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2023 The Brave Authors. All rights reserved.
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-import Foundation
-import WebKit
-import Shared
-
-public class SNSDomainHandler: InternalSchemeResponse {
-  public static let path = "web3/sns"
-  
-  /// The term of use page of Syndica server to resolve SNS domain
-  let snsThirdPartyTermsofUseLink: URL = URL(string: "https://syndica.io/terms-and-conditions/")!
-  
-  /// The privacy policy page of Syndica server to resolve SNS domain
-  let snsThirdPartyPrivacyPolicyLink: URL = URL(string: "https://syndica.io/privacy-policy/")!
-  
-  public func response(forRequest request: URLRequest) -> (URLResponse, Data)? {
-    guard let url = request.url else { return nil }
-    let response = InternalSchemeHandler.response(forUrl: url)
-    guard let path = Bundle.module.path(forResource: "SNSDomain", ofType: "html")
-    else {
-      return nil
-    }
-    
-    guard var html = try? String(contentsOfFile: path) else {
-      assert(false)
-      return nil
-    }
-    
-    let variables = [
-      "page_title": request.url?.displayURL?.absoluteDisplayString ?? "",
-      "error_title": Strings.Wallet.snsDomainInterstitialPageTitle,
-      "error_description": String.localizedStringWithFormat(Strings.Wallet.snsDomainInterstitialPageDescription, snsThirdPartyTermsofUseLink.absoluteString, Strings.Wallet.snsDomainInterstitialPageTAndU, snsThirdPartyPrivacyPolicyLink.absoluteString, Strings.Wallet.snsDomainInterstitialPagePrivacyPolicy),
-      "button_disable": Strings.Wallet.snsDomainInterstitialPageButtonDisable,
-      "button_procced": Strings.Wallet.snsDomainInterstitialPageButtonProceed,
-      "message_handler": Web3NameServiceScriptHandler.messageHandlerName,
-    ]
-    
-    variables.forEach { (arg, value) in
-      html = html.replacingOccurrences(of: "%\(arg)%", with: value)
-    }
-    
-    guard let data = html.data(using: .utf8) else {
-      return nil
-    }
-    
-    return (response, data)
-  }
-  
-  public init() { }
-}
diff --git a/Sources/Brave/Frontend/Browser/Handlers/Web3DomainHandler.swift b/Sources/Brave/Frontend/Browser/Handlers/Web3DomainHandler.swift
new file mode 100644
index 000000000000..957cefb08bb8
--- /dev/null
+++ b/Sources/Brave/Frontend/Browser/Handlers/Web3DomainHandler.swift
@@ -0,0 +1,109 @@
+// Copyright 2023 The Brave Authors. All rights reserved.
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import Foundation
+import WebKit
+import Shared
+import BraveWallet
+
+extension Web3Service {
+  
+  var errorTitle: String {
+    switch self {
+    case .solana:
+      return Strings.Wallet.snsDomainInterstitialPageTitle
+    case .ethereum:
+      return Strings.Wallet.ensDomainInterstitialPageTitle
+    case .ethereumOffchain:
+      return Strings.Wallet.ensOffchainDomainInterstitialPageTitle
+    }
+  }
+  
+  var errorDescription: String {
+    switch self {
+    case .solana:
+      let termsOfUseUrl = WalletConstants.snsTermsOfUseURL.absoluteString
+      let privacyPolicyUrl = WalletConstants.snsPrivacyPolicyURL.absoluteString
+      return String.localizedStringWithFormat(
+        Strings.Wallet.snsDomainInterstitialPageDescription,
+        termsOfUseUrl,
+        Strings.Wallet.web3DomainInterstitialPageTAndU,
+        privacyPolicyUrl,
+        Strings.Wallet.web3DomainInterstitialPagePrivacyPolicy)
+    case .ethereum:
+      let termsOfUseUrl = WalletConstants.ensTermsOfUseURL.absoluteString
+      let privacyPolicyUrl = WalletConstants.ensPrivacyPolicyURL.absoluteString
+      return String.localizedStringWithFormat(
+        Strings.Wallet.ensDomainInterstitialPageDescription,
+        termsOfUseUrl,
+        Strings.Wallet.web3DomainInterstitialPageTAndU,
+        privacyPolicyUrl,
+        Strings.Wallet.web3DomainInterstitialPagePrivacyPolicy)
+    case .ethereumOffchain:
+      let learnMore = WalletConstants.braveWalletENSOffchainURL.absoluteString
+      return String.localizedStringWithFormat(
+        Strings.Wallet.ensOffchainDomainInterstitialPageDescription,
+        learnMore,
+        Strings.Wallet.learnMoreButton)
+    }
+  }
+  
+  var disableButtonTitle: String {
+    Strings.Wallet.web3DomainInterstitialPageButtonDisable
+  }
+  
+  var proceedButtonTitle: String {
+    switch self {
+    case .solana:
+      return Strings.Wallet.snsDomainInterstitialPageButtonProceed
+    case .ethereum:
+      return Strings.Wallet.ensDomainInterstitialPageButtonProceed
+    case .ethereumOffchain:
+      return Strings.Wallet.ensOffchainDomainInterstitialPageButtonProceed
+    }
+  }
+}
+
+public class Web3DomainHandler: InternalSchemeResponse {
+  
+  public static let path = "web3/ddns"
+
+  public init() {}
+  
+  public func response(forRequest request: URLRequest) -> (URLResponse, Data)? {
+    guard let url = request.url else { return nil }
+    let response = InternalSchemeHandler.response(forUrl: url)
+    guard let path = Bundle.module.path(forResource: "Web3Domain", ofType: "html"),
+          let serviceId = request.url?.getQuery()[Web3NameServiceScriptHandler.ParamKey.serviceId.rawValue],
+          let service = Web3Service(rawValue: serviceId) else {
+      return nil
+    }
+    
+    guard var html = try? String(contentsOfFile: path) else {
+      assert(false)
+      return nil
+    }
+    
+    let variables = [
+      "page_title": request.url?.displayURL?.absoluteDisplayString ?? "",
+      "error_title": service.errorTitle,
+      "error_description": service.errorDescription,
+      "button_disable": service.disableButtonTitle,
+      "button_procced": service.proceedButtonTitle,
+      "message_handler": Web3NameServiceScriptHandler.messageHandlerName,
+      Web3NameServiceScriptHandler.ParamKey.serviceId.rawValue: service.id
+    ]
+    
+    variables.forEach { (arg, value) in
+      html = html.replacingOccurrences(of: "%\(arg)%", with: value)
+    }
+    
+    guard let data = html.data(using: .utf8) else {
+      return nil
+    }
+    
+    return (response, data)
+  }
+}
diff --git a/Sources/Brave/Frontend/Browser/Interstitial Pages/InternalSchemeHandler.swift b/Sources/Brave/Frontend/Browser/Interstitial Pages/InternalSchemeHandler.swift
index dde421778539..63ad014bc7d9 100644
--- a/Sources/Brave/Frontend/Browser/Interstitial Pages/InternalSchemeHandler.swift	
+++ b/Sources/Brave/Frontend/Browser/Interstitial Pages/InternalSchemeHandler.swift	
@@ -37,7 +37,7 @@ public class InternalSchemeHandler: NSObject, WKURLSchemeHandler {
       "/interstitial-style/InterstitialStyles.css": "text/css",
       "/interstitial-style/NetworkError.css": "text/css",
       "/interstitial-style/CertificateError.css": "text/css",
-      "/interstitial-style/SNSDomain.css": "text/css",
+      "/interstitial-style/Web3Domain.css": "text/css",
       "/interstitial-style/IPFSPreference.css": "text/css",
       "/interstitial-icon/Generic.svg": "image/svg+xml",
       "/interstitial-icon/Cloud.svg": "image/svg+xml",
diff --git a/Sources/Brave/Frontend/UserContent/UserScripts/Scripts_Dynamic/ScriptHandlers/Internal/Web3NameServiceScriptHandler.swift b/Sources/Brave/Frontend/UserContent/UserScripts/Scripts_Dynamic/ScriptHandlers/Internal/Web3NameServiceScriptHandler.swift
index 2ca4d63ba03d..f86bbd35c929 100644
--- a/Sources/Brave/Frontend/UserContent/UserScripts/Scripts_Dynamic/ScriptHandlers/Internal/Web3NameServiceScriptHandler.swift
+++ b/Sources/Brave/Frontend/UserContent/UserScripts/Scripts_Dynamic/ScriptHandlers/Internal/Web3NameServiceScriptHandler.swift
@@ -6,12 +6,24 @@ import Foundation
 import Shared
 import WebKit
 import os.log
+import BraveWallet
 
 protocol Web3NameServiceScriptHandlerDelegate: AnyObject {
-  func web3NameServiceDecisionHandler(_ proceed: Bool, originalURL: URL, visitType: VisitType)
+  func web3NameServiceDecisionHandler(_ proceed: Bool, web3Service: Web3Service, originalURL: URL, visitType: VisitType)
 }
 
 class Web3NameServiceScriptHandler: TabContentScript {
+  
+  // The `rawValue`s MUST match `Web3Domain.html`
+  enum ParamKey: String {
+    case buttonType = "button_type"
+    case serviceId = "service_id"
+  }
+  enum ParamValue: String {
+    case proceed
+    case disable
+  }
+  
   weak var delegate: Web3NameServiceScriptHandlerDelegate?
   var originalURL: URL?
   var visitType: VisitType = .unknown
@@ -34,10 +46,14 @@ class Web3NameServiceScriptHandler: TabContentScript {
       return
     }
     
-    if params["type"] == "SNSDisable" {
-      delegate?.web3NameServiceDecisionHandler(false, originalURL: originalURL, visitType: visitType)
-    } else if params["type"] == "SNSProceed" {
-      delegate?.web3NameServiceDecisionHandler(true, originalURL: originalURL, visitType: visitType)
+    if params[ParamKey.buttonType.rawValue] == ParamValue.disable.rawValue,
+       let serviceId = params[ParamKey.serviceId.rawValue],
+       let service = Web3Service(rawValue: serviceId) {
+      delegate?.web3NameServiceDecisionHandler(false, web3Service: service, originalURL: originalURL, visitType: visitType)
+    } else if params[ParamKey.buttonType.rawValue] == ParamValue.proceed.rawValue,
+              let serviceId = params[ParamKey.serviceId.rawValue],
+              let service = Web3Service(rawValue: serviceId) {
+      delegate?.web3NameServiceDecisionHandler(true, web3Service: service, originalURL: originalURL, visitType: visitType)
     } else {
       assertionFailure("Invalid message: \(message.body)")
     }
diff --git a/Sources/BraveWallet/Crypto/Stores/SettingsStore.swift b/Sources/BraveWallet/Crypto/Stores/SettingsStore.swift
index a94cfd49cb4a..6be1ecfdab80 100644
--- a/Sources/BraveWallet/Crypto/Stores/SettingsStore.swift
+++ b/Sources/BraveWallet/Crypto/Stores/SettingsStore.swift
@@ -35,6 +35,14 @@ public class SettingsStore: ObservableObject {
     }
   }
   
+  /// The current ENS Resolve Method preference (Ask / Enabled / Disabled)
+  @Published var ensResolveMethod: BraveWallet.ResolveMethod = .ask {
+    didSet {
+      guard oldValue != ensResolveMethod else { return }
+      rpcService.setEnsResolveMethod(ensResolveMethod)
+    }
+  }
+  
   /// The current ENS Offchain Resolve Method preference (Ask / Enabled / Disabled)
   @Published var ensOffchainResolveMethod: BraveWallet.ResolveMethod = .ask {
     didSet {
@@ -84,8 +92,9 @@ public class SettingsStore: ObservableObject {
       let autoLockMinutes = await keyringService.autoLockMinutes()
       self.autoLockInterval = .init(value: autoLockMinutes)
 
-      self.ensOffchainResolveMethod = await rpcService.ensOffchainLookupResolveMethod()
       self.snsResolveMethod = await rpcService.snsResolveMethod()
+      self.ensResolveMethod = await rpcService.ensResolveMethod()
+      self.ensOffchainResolveMethod = await rpcService.ensOffchainLookupResolveMethod()
     }
   }
 
diff --git a/Sources/BraveWallet/DecentralizedDNSHelper.swift b/Sources/BraveWallet/DecentralizedDNSHelper.swift
new file mode 100644
index 000000000000..335ab6649aad
--- /dev/null
+++ b/Sources/BraveWallet/DecentralizedDNSHelper.swift
@@ -0,0 +1,99 @@
+// Copyright 2023 The Brave Authors. All rights reserved.
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import BraveCore
+import Shared
+
+public enum Web3Service: String, CaseIterable {
+  case solana
+  case ethereum
+  case ethereumOffchain
+  
+  public var id: String { rawValue }
+}
+
+@MainActor public class DecentralizedDNSHelper {
+  
+  private let rpcService: BraveWalletJsonRpcService
+  private let ipfsApi: IpfsAPI?
+  
+  public init?(
+    rpcService: BraveWalletJsonRpcService,
+    ipfsApi: IpfsAPI?,
+    isPrivateMode: Bool
+  ) {
+    guard !isPrivateMode else { return nil }
+    self.rpcService = rpcService
+    self.ipfsApi = ipfsApi
+  }
+  
+  public enum DNSLookupResult: Equatable {
+    case none
+    case loadInterstitial(Web3Service)
+    case load(URL)
+  }
+  
+  public func lookup(domain: String) async -> DNSLookupResult {
+    guard let fixupURL = URIFixup.getURL(domain) else {
+      return .none
+    }
+    if fixupURL.domainURL.schemelessAbsoluteDisplayString.endsWithSupportedENSExtension {
+      return await lookupENS(domain: domain)
+    } else if fixupURL.domainURL.schemelessAbsoluteDisplayString.endsWithSupportedSNSExtension {
+      return await lookupSNS(domain: domain)
+    }
+    return .none
+  }
+  
+  /// Decentralized DNS lookup for an ENS domain
+  private func lookupENS(domain: String) async -> DNSLookupResult {
+    let ensResolveMethod = await rpcService.ensResolveMethod()
+    switch ensResolveMethod {
+    case .ask:
+      return .loadInterstitial(.ethereum)
+    case .enabled:
+      let (contentHash, isOffchainConsentRequired, status, _) = await rpcService.ensGetContentHash(domain)
+      if isOffchainConsentRequired {
+        return .loadInterstitial(.ethereumOffchain)
+      }
+      guard status == .success,
+            !contentHash.isEmpty,
+            let ipfsUrl = ipfsApi?.contentHashToCIDv1URL(for: contentHash),
+            !ipfsUrl.isBookmarklet else {
+        return .none
+      }
+      return .load(ipfsUrl)
+    case .disabled:
+      return .none
+    @unknown default:
+      return .none
+    }
+  }
+  
+  /// Decentralized DNS lookup for an SNS domain
+  private func lookupSNS(domain: String) async -> DNSLookupResult {
+    let snsResolveMethod = await rpcService.snsResolveMethod()
+    switch snsResolveMethod {
+    case .ask:
+      return .loadInterstitial(.solana)
+    case .enabled:
+      let (url, status, _) = await rpcService.snsResolveHost(domain)
+      guard status == .success,
+            let url,
+            !url.isBookmarklet else {
+        return .none
+      }
+      return .load(url)
+    case .disabled:
+      return .none
+    @unknown default:
+      return .none
+    }
+  }
+  
+  public static func isSupported(domain: String) -> Bool {
+    domain.endsWithSupportedENSExtension || domain.endsWithSupportedSNSExtension
+  }
+}
diff --git a/Sources/BraveWallet/Settings/Web3SettingsView.swift b/Sources/BraveWallet/Settings/Web3SettingsView.swift
index 3e172d7a069a..034e02e3eda4 100644
--- a/Sources/BraveWallet/Settings/Web3SettingsView.swift
+++ b/Sources/BraveWallet/Settings/Web3SettingsView.swift
@@ -300,7 +300,9 @@ struct WalletSettingsView_Previews: PreviewProvider {
 
 /*
  Section containing the follow preferences:
- - SNS Resolve (Ask/Enabled/Disabled)
+ - Allow SNS Resolve (Ask/Enabled/Disabled)
+ - Allow ENS Resolve (Ask/Enabled/Disabled)
+ - Allow ENS Offchain Resolve (Ask/Enabled/Disabled)
  */
 private struct Web3DomainSettingsView: View {
 
@@ -312,12 +314,27 @@ private struct Web3DomainSettingsView: View {
     Section(header: Text(Strings.Wallet.web3DomainOptionsHeader)) {
       Group {
         snsResolveMethodPreference
+        ensResolveMethodPreference
         ensOffchainResolveMethodPreference
       }
       .listRowBackground(Color(.secondaryBraveGroupedBackground))
     }
   }
   
+  @ViewBuilder private var ensResolveMethodPreference: some View {
+    Picker(selection: $settingsStore.ensResolveMethod) {
+      ForEach(BraveWallet.ResolveMethod.allCases) { option in
+        Text(option.name)
+          .foregroundColor(Color(.secondaryBraveLabel))
+          .tag(option)
+      }
+    } label: {
+      Text(Strings.Wallet.ensResolveMethodTitle)
+        .foregroundColor(Color(.braveLabel))
+        .padding(.vertical, 4)
+    }
+  }
+  
   @ViewBuilder private var ensOffchainResolveMethodPreference: some View {
     Picker(selection: $settingsStore.ensOffchainResolveMethod) {
       ForEach(BraveWallet.ResolveMethod.allCases) { option in
diff --git a/Sources/BraveWallet/WalletConstants.swift b/Sources/BraveWallet/WalletConstants.swift
index 1bebeb238f3a..3a1a75614aaf 100644
--- a/Sources/BraveWallet/WalletConstants.swift
+++ b/Sources/BraveWallet/WalletConstants.swift
@@ -26,8 +26,20 @@ public struct WalletConstants {
   /// The url to Brave Help Center for Wallet.
   static let braveWalletSupportURL = URL(string: "https://support.brave.com/hc/en-us/categories/360001059151-Brave-Wallet")!
   
+  /// Terms of Use for Solana Name Service (SNS)
+  public static let snsTermsOfUseURL: URL = URL(string: "https://syndica.io/terms-and-conditions/")!
+  
+  /// Privacy Policy for Solana Name Service (SNS)
+  public static let snsPrivacyPolicyURL: URL = URL(string: "https://syndica.io/privacy-policy/")!
+  
+  /// Terms of Use for Ethereum Name Service (ENS)
+  public static let ensTermsOfUseURL: URL = URL(string: "https://consensys.net/terms-of-use/")!
+  
+  /// Privacy Policy for Ethereum Name Service (ENS)
+  public static let ensPrivacyPolicyURL: URL = URL(string: "https://consensys.net/privacy-policy/")!
+  
   /// The url to learn more about ENS off-chain lookups
-  static let braveWalletENSOffchainURL = URL(string: "https://github.com/brave/brave-browser/wiki/ENS-offchain-lookup")!
+  public static let braveWalletENSOffchainURL = URL(string: "https://github.com/brave/brave-browser/wiki/ENS-offchain-lookup")!
   
   /// The url to the privacy policy for 0x swaps
   static let zeroXPrivacyPolicy = URL(string: "https://www.0x.org/privacy")!
diff --git a/Sources/BraveWallet/WalletStrings.swift b/Sources/BraveWallet/WalletStrings.swift
index 27ec3632064b..32664baf33a2 100644
--- a/Sources/BraveWallet/WalletStrings.swift
+++ b/Sources/BraveWallet/WalletStrings.swift
@@ -3802,6 +3802,28 @@ extension Strings {
       value: "[Learn more](%@) about IPFS gateway privacy considerations.",
       comment: "The description for the options to allow to resolve IPFS scheme urls. '%@' will be replaced with a url to explain more about IPFS gateway privacy."
     )
+    public static let web3DomainInterstitialPageTAndU = NSLocalizedString(
+      "wallet.web3DomainInterstitialPageTAndU",
+      tableName: "BraveWallet",
+      bundle: .module,
+      value: "terms of use",
+      comment: "Hyper link copy displayed as part of 'snsDomainInterstitialPageDescription'. It will redirect user to the 'terms of use' webpage of the server that Brave uses to resolve SNS domain."
+    )
+    public static let web3DomainInterstitialPagePrivacyPolicy = NSLocalizedString(
+      "wallet.web3DomainInterstitialPagePrivacyPolicy",
+      tableName: "BraveWallet",
+      bundle: .module,
+      value: "privacy policy",
+      comment: "Hyper link copy displayed as part of 'snsDomainInterstitialPageDescription'. It will redirect user to the privay policy webpage of the server that Brave uses to resolve SNS domain."
+    )
+    public static let web3DomainInterstitialPageButtonDisable = NSLocalizedString(
+      "wallet.web3DomainInterstitialPageButtonDisable",
+      tableName: "BraveWallet",
+      bundle: .module,
+      value: "Disable",
+      comment: "Title on the button that users can click to disable Brave to resolve the ENS/SNS domain they entered."
+    )
+    // SNS
     public static let snsDomainInterstitialPageTitle = NSLocalizedString(
       "wallet.snsDomainInterstitialPageTitle",
       tableName: "BraveWallet",
@@ -3816,33 +3838,56 @@ extension Strings {
       value: "Brave will be using Syndica to resolve .sol domain names. Brave hides your IP address. If you enable this, Syndica will see that someone is trying to visit these .sol domains but nothing else. See Syndica's <a href=%@>%@</a> and <a href=%@>%@</a>.",
       comment: "Description displayed when users chose Brave to ask them if they want the SNS to be resolved every time they enter one. The first '%@' will be replaced with a link to Syndica's terms of use page. The second '%@' will be replaced with the value of 'snsDomainInterstitialPageTAndU'. The third '%@' will be replaced with a link to Syndica's privacy policy page. The last '%@' will be replaced with the value of 'snsDomainInterstitialPagePrivacyPolicy'."
     )
-    public static let snsDomainInterstitialPageTAndU = NSLocalizedString(
-      "wallet.snsDomainInterstitialPageTAndU",
+    public static let snsDomainInterstitialPageButtonProceed = NSLocalizedString(
+      "wallet.snsDomainInterstitialPageButtonProceed",
       tableName: "BraveWallet",
       bundle: .module,
-      value: "terms of use",
-      comment: "Hyper link copy displayed as part of 'snsDomainInterstitialPageDescription'. It will redirect user to the 'terms of use' webpage of the server that Brave uses to resolve SNS domain."
+      value: "Proceed using Syndica server",
+      comment: "Title on the button that users can click to enable Brave to resolve the SNS domain they entered."
     )
-    public static let snsDomainInterstitialPagePrivacyPolicy = NSLocalizedString(
-      "wallet.snsDomainInterstitialPagePrivacyPolicy",
+    // ENS
+    public static let ensDomainInterstitialPageTitle = NSLocalizedString(
+      "wallet.ensDomainInterstitialPageTitle",
       tableName: "BraveWallet",
       bundle: .module,
-      value: "privacy policy",
-      comment: "Hyper link copy displayed as part of 'snsDomainInterstitialPageDescription'. It will redirect user to the privay policy webpage of the server that Brave uses to resolve SNS domain."
+      value: "Enable support of Ethereum Name Service (ENS) in Brave?",
+      comment: "Title displayed when users chose Brave to ask them if they want the ENS domain to be resolved every time they enter one."
     )
-    public static let snsDomainInterstitialPageButtonDisable = NSLocalizedString(
-      "wallet.snsDomainInterstitialPageButtonDisable",
+    public static let ensDomainInterstitialPageDescription = NSLocalizedString(
+      "wallet.ensDomainInterstitialPageDescription",
       tableName: "BraveWallet",
       bundle: .module,
-      value: "Disable",
-      comment: "Title on the button that users can click to disable Brave to resolve the SNS domain or IPFS scheme url they entered."
+      value: "Brave will be using Infura to resolve .eth domain names that are on Ethereum Name Service (ENS). Brave hides your IP address. If you enable this, Infura will see that someone is trying to visit these .eth domains but nothing else. See Infura's <a href=%@>%@</a> and <a href=%@>%@</a>.",
+      comment: "Description displayed when users chose Brave to ask them if they want the ENS to be resolved every time they enter one. The first '%@' will be replaced with a link to Infura's terms of use page. The second '%@' will be replaced with the value of 'Web3DomainInterstitialPageTAndU'. The third '%@' will be replaced with a link to Infura's privacy policy page. The last '%@' will be replaced with the value of 'Web3DomainInterstitialPagePrivacyPolicy'."
     )
-    public static let snsDomainInterstitialPageButtonProceed = NSLocalizedString(
-      "wallet.snsDomainInterstitialPageButtonProceed",
+    public static let ensDomainInterstitialPageButtonProceed = NSLocalizedString(
+      "wallet.ensDomainInterstitialPageButtonProceed",
       tableName: "BraveWallet",
       bundle: .module,
-      value: "Proceed using Syndica server",
-      comment: "Title on the button that users can click to enable Brave to resolve the SNS domain they entered."
+      value: "Proceed using Infura server",
+      comment: "Title on the button that users can click to enable Brave to resolve the ENS domain they entered."
+    )
+    // ENS offchain
+    public static let ensOffchainDomainInterstitialPageTitle = NSLocalizedString(
+      "wallet.ensOffchainDomainInterstitialPageTitle",
+      tableName: "BraveWallet",
+      bundle: .module,
+      value: "Enable support of Ethereum Name Service (ENS) offchain lookup in Brave?",
+      comment: "Title displayed when users chose Brave to ask them if they want the ENS Offchain domain to be resolved every time they enter one."
+    )
+    public static let ensOffchainDomainInterstitialPageDescription = NSLocalizedString(
+      "wallet.ensOffchainDomainInterstitialPageDescription",
+      tableName: "BraveWallet",
+      bundle: .module,
+      value: "This .eth domain name is stored offchain and will be resolved by a third party gateway. If you enable ENS offchain lookup, the third party gateway will see that you're trying to visit the .eth domain. <a href=%@>%@</a>.",
+      comment: "Description displayed when users chose Brave to ask them if they want the ENS to be resolved every time they enter one. The first '%@' will be replaced with a link to Brave Wallet's offchain lookup privacy considerations. The second '%@' will be replaced with the value of 'ensOffchainDomainInterstitialLearnMore'."
+    )
+    public static let ensOffchainDomainInterstitialPageButtonProceed = NSLocalizedString(
+      "wallet.ensOffchainDomainInterstitialPageButtonProceed",
+      tableName: "BraveWallet",
+      bundle: .module,
+      value: "Proceed with offchain lookup",
+      comment: "Title on the button that users can click to enable Brave to resolve the ENS offchain lookup for the domain they entered."
     )
   }
 }
diff --git a/Tests/BraveWalletTests/DecentralizedDNSHelperTests.swift b/Tests/BraveWalletTests/DecentralizedDNSHelperTests.swift
new file mode 100644
index 000000000000..167f99a8c0ea
--- /dev/null
+++ b/Tests/BraveWalletTests/DecentralizedDNSHelperTests.swift
@@ -0,0 +1,281 @@
+// Copyright 2023 The Brave Authors. All rights reserved.
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import Foundation
+import XCTest
+import Combine
+import BraveCore
+@testable import BraveWallet
+
+@MainActor class DecentralizedDNSHelperTests: XCTestCase {
+  
+  /// Test `.init(rpcService:ipfsApi:isPrivateMode:)` will return nil when `isPrivateMode` is true.
+  func testInitFailsInPrivateMode() {
+    XCTAssertNil(DecentralizedDNSHelper(rpcService: MockJsonRpcService(), ipfsApi: nil, isPrivateMode: true))
+    XCTAssertNil(DecentralizedDNSHelper(rpcService: MockJsonRpcService(), ipfsApi: TestIpfsAPI(), isPrivateMode: true))
+  }
+  
+  /// Test `lookup(domain:)` provided an `.eth` domain will return `.loadInterstitial(.ethereum)` when ENS Resolve Method is `.ask`.
+  func testLookupWithENSDomainAsk() async {
+    let domain = "braveexample.eth"
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.ask) }
+    rpcService._ensGetContentHash = { _, completion in
+      completion([], false, .success, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    guard case let .loadInterstitial(service) = result else {
+      XCTFail("Expected to load interstitial")
+      return
+    }
+    XCTAssertEqual(service, .ethereum)
+  }
+  
+  /// Test `lookup(domain:)` provided an `.eth` domain will return `.load(URL)` when ENS Resolve Method is `.enabled`.
+  func testLookupWithENSDomainEnabled() async {
+    let domain = "braveexample.eth"
+    let resolvedURL = URL(string: "ipfs://braveexampleeth")!
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.enabled) }
+    rpcService._ensGetContentHash = { _, completion in
+      let contentHash = (0..<10).map { NSNumber(value: $0) }
+      completion(contentHash, false, .success, "")
+    }
+    
+    let ipfsApi = TestIpfsAPI()
+    ipfsApi._contentHashToCIDv1URL = { _ in
+      resolvedURL
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: ipfsApi,
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    guard case let .load(url) = result else {
+      XCTFail("Expected to load url")
+      return
+    }
+    XCTAssertEqual(url, resolvedURL)
+  }
+  
+  /// Test `lookup(domain:)` provided an `.eth` domain will return `.none` when ENS Resolve Method is `.disabled`.
+  func testLookupWithENSDomainDisabled() async {
+    let domain = "braveexample.eth"
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.disabled) }
+    rpcService._ensGetContentHash = { _, completion in
+      completion([], false, .success, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    XCTAssertEqual(result, .none)
+  }
+  
+  /// Test `lookup(domain:)` provided an `.eth` domain will return `.loadInterstitial(.ethereumOffchain)` when ENS Resolve Method is `.enabled` & ENS Offchain Resolve Method is `.ask`.
+  func testLookupWithENSOffchainDomainAsk() async {
+    let domain = "braveoffchainexample.eth"
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.enabled) }
+    rpcService._ensOffchainLookupResolveMethod = { $0(.ask) }
+    rpcService._ensGetContentHash = { _, completion in
+      completion([], true, .success, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    guard case let .loadInterstitial(service) = result else {
+      XCTFail("Expected to load interstitial")
+      return
+    }
+    XCTAssertEqual(service, .ethereumOffchain)
+    
+  }
+  
+  /// Test `lookup(domain:)` provided an `.eth` domain will return `.load(URL)` when ENS Resolve Method is `.enabled` & ENS Offchain Resolve Method is `.enabled`.
+  func testLookupWithENSOffchainDomainEnabled() async {
+    let domain = "braveoffchainexample.eth"
+    let resolvedURL = URL(string: "ipfs://braveoffchainexampleeth")!
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.enabled) }
+    rpcService._ensOffchainLookupResolveMethod = { $0(.enabled) }
+    rpcService._ensGetContentHash = { _, completion in
+      let contentHash = (0..<10).map { NSNumber(value: $0) }
+      completion(contentHash, false, .success, "")
+    }
+    
+    let ipfsApi = TestIpfsAPI()
+    ipfsApi._contentHashToCIDv1URL = { _ in
+      resolvedURL
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: ipfsApi,
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    guard case let .load(url) = result else {
+      XCTFail("Expected to load url")
+      return
+    }
+    XCTAssertEqual(url, resolvedURL)
+  }
+  
+  /// Test `lookup(domain:)` provided an `.eth` domain will return `.none` when ENS Resolve Method is `.enabled` & ENS Offchain Resolve Method is `.disabled`.
+  func testLookupWithENSOffchainDomainDisabled() async {
+    let domain = "braveoffchainexample.eth"
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.enabled) }
+    rpcService._ensOffchainLookupResolveMethod = { $0(.disabled) }
+    rpcService._ensGetContentHash = { _, completion in
+      completion([], false, .internalError, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    XCTAssertEqual(result, .none)
+  }
+  
+  /// Test `lookup(domain:)` provided a `.sol` domain  will return `.loadInterstitial(.solana)` when SNS Resolve Method is `.ask`.
+  func testLookupWithSNSDomainAsk() async {
+    let domain = "braveexample.sol"
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._snsResolveMethod = { $0(.ask) }
+    rpcService._snsResolveHost = { _, completion in
+      completion(nil, .internalError, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    guard case let .loadInterstitial(service) = result else {
+      XCTFail("Expected to load interstitial")
+      return
+    }
+    XCTAssertEqual(service, .solana)
+  }
+  
+  /// Test `lookup(domain:)` provided a `.sol` domain  will return `.loadURL(URL)` when SNS Resolve Method is `.enabled`.
+  func testLookupWithSNSDomainEnabled() async {
+    let domain = "braveexample.sol"
+    let resolvedURL = URL(string: "https://brave.com")!
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._snsResolveMethod = { $0(.enabled) }
+    rpcService._snsResolveHost = { _, completion in
+      completion(resolvedURL, .success, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    guard case let .load(url) = result else {
+      XCTFail("Expected to load url")
+      return
+    }
+    XCTAssertEqual(url, resolvedURL)
+  }
+  
+  /// Test `lookup(domain:)` provided a `.sol` domain  will return `.none` when SNS Resolve Method is `.disabled`.
+  func testLookupWithSNSDomainDisabled() async {
+    let domain = "braveexample.sol"
+    
+    let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._snsResolveMethod = { $0(.disabled) }
+    rpcService._snsResolveHost = { _, completion in
+      completion(nil, .internalError, "")
+    }
+    
+    guard let sut = DecentralizedDNSHelper(
+      rpcService: rpcService,
+      ipfsApi: TestIpfsAPI(),
+      isPrivateMode: false
+    ) else {
+      XCTFail("Unexpected test setup")
+      return
+    }
+    
+    let result = await sut.lookup(domain: domain)
+    XCTAssertEqual(result, .none)
+  }
+  
+  func testIsSupported() {
+    let ensDomain = "ethereum.eth"
+    XCTAssertTrue(DecentralizedDNSHelper.isSupported(domain: ensDomain))
+    let nonSupportedENSDomain = "ethereumeth"
+    XCTAssertFalse(DecentralizedDNSHelper.isSupported(domain: nonSupportedENSDomain))
+    
+    let snsDomain = "braveexample.sol"
+    XCTAssertTrue(DecentralizedDNSHelper.isSupported(domain: snsDomain))
+    let nonSupportedSNSDomain = "braveexamplesol"
+    XCTAssertFalse(DecentralizedDNSHelper.isSupported(domain: nonSupportedSNSDomain))
+  }
+}
diff --git a/Tests/BraveWalletTests/SettingsStoreTests.swift b/Tests/BraveWalletTests/SettingsStoreTests.swift
index db9d84152185..6e1c42f34e15 100644
--- a/Tests/BraveWalletTests/SettingsStoreTests.swift
+++ b/Tests/BraveWalletTests/SettingsStoreTests.swift
@@ -43,6 +43,8 @@ class SettingsStoreTests: XCTestCase {
     walletService._defaultBaseCurrency = { $0(CurrencyCode.usd.code) } // default is USD
     
     let rpcService = BraveWallet.TestJsonRpcService()
+    rpcService._ensResolveMethod = { $0(.ask) }
+    rpcService._setEnsResolveMethod = { _ in }
     rpcService._ensOffchainLookupResolveMethod = { $0(.ask) }
     rpcService._setEnsOffchainLookupResolveMethod = { _ in }
     rpcService._snsResolveMethod = { $0(.ask) }
@@ -60,6 +62,7 @@ class SettingsStoreTests: XCTestCase {
     let (keyringService, walletService, rpcService, txService, ipfsApi) = setupServices()
     keyringService._autoLockMinutes = { $0(1) }
     walletService._defaultBaseCurrency = { $0(CurrencyCode.cad.code) }
+    rpcService._ensResolveMethod = { $0(.disabled) }
     rpcService._ensOffchainLookupResolveMethod = { $0(.disabled) }
     rpcService._snsResolveMethod = { $0(.disabled) }
 
@@ -90,6 +93,15 @@ class SettingsStoreTests: XCTestCase {
       }
       .store(in: &cancellables)
     
+    let ensResolveMethodExpectation = expectation(description: "setup-ensResolveMethod")
+    sut.$ensResolveMethod
+      .dropFirst()
+      .sink { ensResolveMethod in
+        defer { ensResolveMethodExpectation.fulfill() }
+        XCTAssertEqual(ensResolveMethod, .disabled)
+      }
+      .store(in: &cancellables)
+    
     let ensOffchainResolveMethodExpectation = expectation(description: "setup-ensOffchainResolveMethod")
     sut.$ensOffchainResolveMethod
       .dropFirst()
