@midnames/sdk 0.1.2 → 0.1.4

package/README.md

@@ -1,46 +1,114 @@
 ># @midnames/sdk
 
-SDK to resolve Midnames domains, and render a profile widget.
+SDK to resolve Midnames domains and render profile widgets with a clean, provider-optional API.
 
-## Build
+## Quick Start
 
-Run the `build` script with `npm`, `bun`, etc.
+```ts
+import { getDomainProfile, setupDefaultProvider } from '@midnames/sdk';
 
-## Usage
+// One-liner setup with testnet defaults
+setupDefaultProvider();
 
-Resolve a domain:
+// Now use functions without provider
+const result = await getDomainProfile('alice.night');
+if (result.success) {
+  console.log(result.data.fields);
+}
+```
 
-```ts
-import { resolveDomain, getDomainProfile } from '@midnames/sdk';
-import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
+## Installation
 
-async function demo(provider: PublicDataProvider) {
-  const target = await resolveDomain(provider, 'alice.night');
-  const profile = await getDomainProfile(provider, 'id.alice.night');
-  console.log(target, profile.fields);
-}
+```bash
+npm install @midnames/sdk
 ```
 
-React widget:
+## Usage Examples
 
-```tsx
-import '@midnames/sdk/styles.css';
-import { DomainProfileWidget } from '@midnames/sdk/react';
+### Basic Usage
 
-<DomainProfileWidget fullDomain="id.alice.night" publicDataProvider={provider} />
-```
+```ts
+import { resolveDomain, getDomainProfile, setupDefaultProvider } from '@midnames/sdk';
 
-Fields recognized for display: `name`, `bio`, `avatar`, `banner`, `website`, `twitter`, `github`, `location`, and `epk`.
+// Setup once
+setupDefaultProvider();
 
-## API
+// Use without provider
+const target = await resolveDomain('alice.night');
+const profile = await getDomainProfile('alice.night');
 
-- `resolveDomain(provider, domain): Promise<string|null>`
-- `getDomainProfile(provider, fullDomain): Promise<{ fullDomain, resolvedTarget, info, fields, settings }>`
+if (profile.success) {
+  console.log('Domain:', profile.data.fullDomain);
+  console.log('Owner:', profile.data.info?.owner);
+  console.log('Fields:', profile.data.fields);
+}
+```
+
+### Custom Provider
 
 ```ts
-export interface DomainInfo { owner: string; resolver: string; contractAddress?: string; }
-export interface DomainSettings { coinColor: Uint8Array; domainCost: bigint; }
+import { getDomainProfile, setupDefaultProvider, setDefaultProvider } from '@midnames/sdk';
+
+// Manually create and set your own provider
+setupDefaultProvider({
+  indexerUrl: 'https://custom-indexer.com',
+  indexerWsUrl: 'wss://custom-indexer.com'
+});
+
+// Or pass per-call
+const profile = await getDomainProfile('alice.night', { provider });
 ```
 
-Notes: Uses TestNet TLD contract by default. Provide a custom TLD address in `resolveDomain` if needed.
+### React Widget
+
+```tsx
+import '@midnames/sdk/styles.css';
+import { DomainProfileWidget, HolographicCard } from '@midnames/sdk/react';
+import { setupDefaultProvider } from '@midnames/sdk';
+
+// Setup provider once globally
+setupDefaultProvider();
+
+// Now widgets work without provider prop
+<DomainProfileWidget 
+  fullDomain="alice.night" 
+  variant="compact"
+  showStatus={true}
+/>
+
+<HolographicCard 
+  domain="alice.night"
+  enableTilt={true}
+/>
+
+// Or pass custom provider
+<DomainProfileWidget 
+  fullDomain="alice.night" 
+  publicDataProvider={customProvider}
+/>
+```
 
+## Widget Configuration
+
+The React widget recognizes these profile fields:
+- `name`, `bio`, `avatar`, `banner`
+- `website`, `twitter`, `github`, `location`
+- `epk` (Electronic Press Kit)
+
+### Widget Props
+
+#### DomainProfileWidget
+- `fullDomain`: Domain to display (required)
+- `publicDataProvider?`: Provider (optional if default is set)
+- `variant?`: `'full' | 'compact' | 'inline' | 'minimal'`
+- `showStatus?`: Show loading/error states
+- `showBanner?`: Display banner image
+- `onError?`: Error callback
+
+#### HolographicCard
+- `domain`: Domain to display (required)
+- `publicDataProvider?`: Provider (optional if default is set)
+- `enableTilt?`: Enable 3D tilt effect
+- `behindGradient?`: Background gradient
+- `innerGradient?`: Card gradient
+- `onError?`: Error callback

package/dist/core.d.ts

@@ -1,10 +1,5 @@
-import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
-import type { DomainInfo, DomainSettings, DomainProfileData, Result } from './types.js';
-export declare const TESTNET_TLD_ADDRESS = "02003c6d04b83541c303f9d8aad271dd0f77525a41c63747a5ef94235d2f2fe8c170";
-export declare function resolveDomain(publicDataProvider: PublicDataProvider, domain: string, tldAddress?: string): Promise<Result<string>>;
-export declare function getDomainInfo(publicDataProvider: PublicDataProvider, contractAddress: string, domainName: string): Promise<Result<DomainInfo>>;
-export declare function getDomainInfoByResolving(publicDataProvider: PublicDataProvider, fullDomain: string): Promise<Result<DomainInfo>>;
-export declare function getDomainFields(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<Array<[string, string]>>>;
-export declare function getNamespacedDomainFields(publicDataProvider: PublicDataProvider, _parentContractAddress: string, fullDomainName: string): Promise<Result<Array<[string, string]>>>;
-export declare function getDomainSettings(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<DomainSettings>>;
-export declare function getDomainProfile(publicDataProvider: PublicDataProvider, fullDomain: string): Promise<Result<DomainProfileData>>;
+export { resolveDomain, TESTNET_TLD_ADDRESS } from './modules/core.js';
+export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
+export type { Result } from './types.js';
+export { success, failure, isSuccess, isError, unwrap, unwrapOr } from './types.js';
+export { MidNamesError, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';

package/dist/core.js

@@ -1,204 +1,4 @@
-import { getNetworkId, getZswapNetworkId, NetworkId } from '@midnight-ntwrk/midnight-js-network-id';
-import { ShieldedCoinPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { ledger } from '../managed/index.js';
-import { formatContractAddress } from './utils/address.js';
-import { normalizeDomain, parseFullDomain } from './utils/domain.js';
-import { success, failure, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';
-const TLD = 'night';
-export const TESTNET_TLD_ADDRESS = '02003c6d04b83541c303f9d8aad271dd0f77525a41c63747a5ef94235d2f2fe8c170';
-function getDefaultTldAddress() {
-    const currentNetwork = getNetworkId();
-    switch (currentNetwork) {
-        case NetworkId.TestNet:
-            return TESTNET_TLD_ADDRESS;
-        default:
-            throw new Error('Provide an address to use the resolver on a Standalone Network.');
-    }
-}
-function getTargetFromLedger(contractLedger) {
-    const target = contractLedger.DOMAIN_TARGET;
-    if (target.is_left) {
-        const coinPublicKey = new ShieldedCoinPublicKey(Buffer.from(target.left.bytes));
-        return ShieldedCoinPublicKey.codec.encode(getZswapNetworkId(), coinPublicKey).asString();
-    }
-    else {
-        return formatContractAddress(target.right.bytes);
-    }
-}
-async function queryContractStateSafely(publicDataProvider, contractAddress) {
-    try {
-        const contractState = await publicDataProvider.queryContractState(contractAddress);
-        if (contractState == null) {
-            return failure(new ContractNotFoundError(contractAddress));
-        }
-        return success(contractState);
-    }
-    catch (error) {
-        return failure(new ProviderError(`Failed to query contract state: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-async function getResolverAddress(publicDataProvider, fullDomain) {
-    try {
-        const tldAddress = getDefaultTldAddress();
-        const domainParts = fullDomain.split('.');
-        const traversalParts = domainParts.slice(0, -1).reverse();
-        if (traversalParts.length === 0)
-            return success(tldAddress);
-        let currentResolver = tldAddress;
-        for (const part of traversalParts) {
-            const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-            if (!contractStateResult.success) {
-                return failure(contractStateResult.error);
-            }
-            const contractLedger = ledger(contractStateResult.data.data);
-            if (!contractLedger.domains.member(part)) {
-                return failure(new DomainNotFoundError(`${part} in ${currentResolver}`));
-            }
-            const domainData = contractLedger.domains.lookup(part);
-            const resolverBytes = domainData.resolver.bytes;
-            currentResolver = formatContractAddress(resolverBytes);
-        }
-        return success(currentResolver);
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get resolver address: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function resolveDomain(publicDataProvider, domain, tldAddress) {
-    const tldContractAddress = tldAddress || getDefaultTldAddress();
-    const fullDomain = normalizeDomain(domain);
-    try {
-        const domainParts = fullDomain.split('.');
-        if (domainParts[domainParts.length - 1] !== TLD) {
-            return failure(new InvalidDomainError(fullDomain, `Domain must end with .${TLD}`));
-        }
-        const parsedDomain = domainParts.slice(0, -1).reverse();
-        let currentResolver = tldContractAddress;
-        if (parsedDomain.length === 0) {
-            const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-            if (!contractStateResult.success)
-                return failure(contractStateResult.error);
-            const contractLedger = ledger(contractStateResult.data.data);
-            return success(getTargetFromLedger(contractLedger));
-        }
-        for (const part of parsedDomain) {
-            const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-            if (!contractStateResult.success)
-                return failure(contractStateResult.error);
-            const contractLedger = ledger(contractStateResult.data.data);
-            if (!contractLedger.domains.member(part)) {
-                return failure(new DomainNotFoundError(`${part} in ${fullDomain}`));
-            }
-            const domainData = contractLedger.domains.lookup(part);
-            const resolverBytes = domainData.resolver.bytes;
-            currentResolver = formatContractAddress(resolverBytes);
-        }
-        const finalContractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-        if (!finalContractStateResult.success)
-            return failure(finalContractStateResult.error);
-        const finalLedger = ledger(finalContractStateResult.data.data);
-        return success(getTargetFromLedger(finalLedger));
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to resolve domain: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function getDomainInfo(publicDataProvider, contractAddress, domainName) {
-    try {
-        const contractStateResult = await queryContractStateSafely(publicDataProvider, contractAddress);
-        if (!contractStateResult.success)
-            return failure(contractStateResult.error);
-        const contractLedger = ledger(contractStateResult.data.data);
-        if (!contractLedger.domains.member(domainName)) {
-            return failure(new DomainNotFoundError(domainName));
-        }
-        const domainData = contractLedger.domains.lookup(domainName);
-        const ownerCoinPublicKey = new ShieldedCoinPublicKey(Buffer.from(domainData.owner.bytes));
-        const ownerAddress = ShieldedCoinPublicKey.codec.encode(getZswapNetworkId(), ownerCoinPublicKey).asString();
-        return success({ owner: ownerAddress, resolver: formatContractAddress(domainData.resolver.bytes) });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain info: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function getDomainInfoByResolving(publicDataProvider, fullDomain) {
-    try {
-        const normalizedDomain = normalizeDomain(fullDomain);
-        const parsed = parseFullDomain(normalizedDomain);
-        if (!parsed.isValid) {
-            return failure(new InvalidDomainError(fullDomain, 'Invalid domain format'));
-        }
-        const parentContractAddressResult = await getResolverAddress(publicDataProvider, parsed.parentDomainPath);
-        if (!parentContractAddressResult.success)
-            return failure(parentContractAddressResult.error);
-        const infoResult = await getDomainInfo(publicDataProvider, parentContractAddressResult.data, parsed.domainName);
-        if (!infoResult.success)
-            return failure(infoResult.error);
-        return success({ ...infoResult.data, contractAddress: parentContractAddressResult.data });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain info by resolving: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function getDomainFields(publicDataProvider, contractAddress) {
-    try {
-        const contractStateResult = await queryContractStateSafely(publicDataProvider, contractAddress);
-        if (!contractStateResult.success)
-            return failure(contractStateResult.error);
-        const contractLedger = ledger(contractStateResult.data.data);
-        const fields = [];
-        for (const [key, value] of contractLedger.fields)
-            fields.push([key, value]);
-        return success(fields);
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain fields: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function getNamespacedDomainFields(publicDataProvider, _parentContractAddress, fullDomainName) {
-    try {
-        const domainContractAddressResult = await getResolverAddress(publicDataProvider, fullDomainName);
-        if (!domainContractAddressResult.success)
-            return failure(domainContractAddressResult.error);
-        return await getDomainFields(publicDataProvider, domainContractAddressResult.data);
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get namespaced domain fields: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function getDomainSettings(publicDataProvider, contractAddress) {
-    try {
-        const contractStateResult = await queryContractStateSafely(publicDataProvider, contractAddress);
-        if (!contractStateResult.success)
-            return failure(contractStateResult.error);
-        const contractLedger = ledger(contractStateResult.data.data);
-        return success({ coinColor: contractLedger.COIN_COLOR, domainCost: contractLedger.DOMAIN_COST });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain settings: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
-export async function getDomainProfile(publicDataProvider, fullDomain) {
-    try {
-        const normalized = normalizeDomain(fullDomain);
-        const [resolvedTargetResult, infoResult] = await Promise.all([
-            resolveDomain(publicDataProvider, normalized),
-            getDomainInfoByResolving(publicDataProvider, normalized)
-        ]);
-        const resolvedTarget = resolvedTargetResult.success ? resolvedTargetResult.data : null;
-        const info = infoResult.success ? infoResult.data : null;
-        if (info && info.contractAddress) {
-            const [fieldsResult, settingsResult] = await Promise.all([
-                getNamespacedDomainFields(publicDataProvider, info.contractAddress, normalized),
-                getDomainSettings(publicDataProvider, info.resolver)
-            ]);
-            const fields = fieldsResult.success ? fieldsResult.data : [];
-            const settings = settingsResult.success ? settingsResult.data : null;
-            return success({ fullDomain: normalized, resolvedTarget, info, fields, settings });
-        }
-        return success({ fullDomain: normalized, resolvedTarget, info, fields: [], settings: null });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain profile: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
-}
+export { resolveDomain, TESTNET_TLD_ADDRESS } from './modules/core.js';
+export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
+export { success, failure, isSuccess, isError, unwrap, unwrapOr } from './types.js';
+export { MidNamesError, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export * from './types.js';
 export * from './utils/domain.js';
 export * from './utils/address.js';
-export * from './core.js';
+export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
+export { resolveDomain, getDomainInfo, getDomainInfoByResolving, getDomainFields, getNamespacedDomainFields, getDomainSettings, getDomainProfile } from './modules/index.js';
+export { TESTNET_TLD_ADDRESS } from './modules/core.js';

package/dist/index.js

@@ -1,4 +1,10 @@
+// Types and utilities
 export * from './types.js';
 export * from './utils/domain.js';
 export * from './utils/address.js';
-export * from './core.js';
+// Provider management
+export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
+// Simplified API (provider optional)
+export { resolveDomain, getDomainInfo, getDomainInfoByResolving, getDomainFields, getNamespacedDomainFields, getDomainSettings, getDomainProfile } from './modules/index.js';
+// Constants
+export { TESTNET_TLD_ADDRESS } from './modules/core.js';

package/dist/info.d.ts

@@ -0,0 +1,5 @@
+export { getDomainInfo, getDomainInfoByResolving, getDomainFields, getNamespacedDomainFields, getDomainSettings, getDomainProfile, } from './modules/info.js';
+export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
+export type { DomainInfo, DomainSettings, DomainProfileData, Result } from './types.js';
+export { success, failure, isSuccess, isError, unwrap, unwrapOr } from './types.js';
+export { MidNamesError, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';

package/dist/info.js

@@ -0,0 +1,5 @@
+// Info module - domain info and profile functions
+export { getDomainInfo, getDomainInfoByResolving, getDomainFields, getNamespacedDomainFields, getDomainSettings, getDomainProfile, } from './modules/info.js';
+export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
+export { success, failure, isSuccess, isError, unwrap, unwrapOr } from './types.js';
+export { MidNamesError, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';

package/dist/modules/core.d.ts

@@ -0,0 +1,8 @@
+import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
+import type { Result } from '../types.js';
+export declare const TESTNET_TLD_ADDRESS = "0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01";
+export declare function getDefaultTldAddress(): string;
+export declare function resolveDomain(domain: string, options?: {
+    provider?: PublicDataProvider;
+    tldAddress?: string;
+}): Promise<Result<string>>;

package/dist/modules/core.js

@@ -0,0 +1,80 @@
+import { getNetworkId, getZswapNetworkId, NetworkId } from '@midnight-ntwrk/midnight-js-network-id';
+import { ShieldedCoinPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { ledger } from '../../managed/index.js';
+import { formatContractAddress } from '../utils/address.js';
+import { normalizeDomain } from '../utils/domain.js';
+import { success, failure, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from '../types.js';
+import { getProviderOrThrow } from '../provider.js';
+const TLD = 'night';
+export const TESTNET_TLD_ADDRESS = '0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01';
+export function getDefaultTldAddress() {
+    const currentNetwork = getNetworkId();
+    switch (currentNetwork) {
+        case NetworkId.TestNet:
+            return TESTNET_TLD_ADDRESS;
+        default:
+            throw new Error('Provide an address to use the resolver on a Standalone Network.');
+    }
+}
+function getTargetFromLedger(contractLedger) {
+    const target = contractLedger.DOMAIN_TARGET;
+    if (target.is_left) {
+        const coinPublicKey = new ShieldedCoinPublicKey(Buffer.from(target.left.bytes));
+        return ShieldedCoinPublicKey.codec.encode(getZswapNetworkId(), coinPublicKey).asString();
+    }
+    else {
+        return formatContractAddress(target.right.bytes);
+    }
+}
+async function queryContractStateSafely(publicDataProvider, contractAddress) {
+    try {
+        const contractState = await publicDataProvider.queryContractState(contractAddress);
+        if (contractState == null) {
+            return failure(new ContractNotFoundError(contractAddress));
+        }
+        return success(contractState);
+    }
+    catch (error) {
+        return failure(new ProviderError(`Failed to query contract state: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+export async function resolveDomain(domain, options = {}) {
+    const publicDataProvider = getProviderOrThrow(options.provider);
+    const tldContractAddress = options.tldAddress || getDefaultTldAddress();
+    const fullDomain = normalizeDomain(domain);
+    try {
+        const domainParts = fullDomain.split('.');
+        if (domainParts[domainParts.length - 1] !== TLD) {
+            return failure(new InvalidDomainError(fullDomain, `Domain must end with .${TLD}`));
+        }
+        const parsedDomain = domainParts.slice(0, -1).reverse();
+        let currentResolver = tldContractAddress;
+        if (parsedDomain.length === 0) {
+            const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
+            if (!contractStateResult.success)
+                return failure(contractStateResult.error);
+            const contractLedger = ledger(contractStateResult.data.data);
+            return success(getTargetFromLedger(contractLedger));
+        }
+        for (const part of parsedDomain) {
+            const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
+            if (!contractStateResult.success)
+                return failure(contractStateResult.error);
+            const contractLedger = ledger(contractStateResult.data.data);
+            if (!contractLedger.domains.member(part)) {
+                return failure(new DomainNotFoundError(`${part} in ${fullDomain}`));
+            }
+            const domainData = contractLedger.domains.lookup(part);
+            const resolverBytes = domainData.resolver.bytes;
+            currentResolver = formatContractAddress(resolverBytes);
+        }
+        const finalContractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
+        if (!finalContractStateResult.success)
+            return failure(finalContractStateResult.error);
+        const finalLedger = ledger(finalContractStateResult.data.data);
+        return success(getTargetFromLedger(finalLedger));
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to resolve domain: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}

package/dist/modules/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core.js';
+export * from './info.js';
+export * from '../provider.js';

package/dist/modules/index.js

@@ -0,0 +1,6 @@
+// Core resolution functions
+export * from './core.js';
+// Domain info functions  
+export * from './info.js';
+// Re-export provider utilities
+export * from '../provider.js';

package/dist/modules/info.d.ts

@@ -0,0 +1,20 @@
+import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
+import type { DomainInfo, DomainSettings, DomainProfileData, Result } from '../types.js';
+export declare function getDomainInfo(contractAddress: string, domainName: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainInfo>>;
+export declare function getDomainInfoByResolving(fullDomain: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainInfo>>;
+export declare function getDomainFields(contractAddress: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<Array<[string, string]>>>;
+export declare function getNamespacedDomainFields(_parentContractAddress: string, fullDomainName: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<Array<[string, string]>>>;
+export declare function getDomainSettings(contractAddress: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainSettings>>;
+export declare function getDomainProfile(fullDomain: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainProfileData>>;