@midnames/sdk 1.0.5 → 2.0.0-rc1

package/dist/operations.d.ts

@@ -1,49 +1,61 @@
 import { CompiledContract } from "@midnight-ntwrk/compact-js";
 import { type ContractProviders } from "@midnight-ntwrk/midnight-js-contracts";
-import { Leaf } from "@midnames/ns";
-import type { Result } from "./results.js";
-export declare const leafContractInstance: CompiledContract.CompiledContract<Leaf.Contract<any, any>, any, never>;
-export declare function buildKvs(fields: Array<[string, string]>): Array<{
+import { NS } from "./contract.js";
+import type { DomainTarget } from "./types.js";
+import type { PaymentConfig } from "./managed/contract/index.js";
+import { type Result } from "./results.js";
+export declare const nsContractInstance: CompiledContract.CompiledContract<NS.Contract<any, any>, any, never>;
+export interface OperationOptions {
+    contractAddress?: string;
+    secretKey?: string;
+}
+export declare function buildKvs(fields: Array<[string, string]>, size?: number): Array<{
     is_some: boolean;
     value: [string, string];
 }>;
-export declare function insertField(domain: string, key: string, value: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function createDomain(domainName: string, parentId: bigint, ownerAddress: {
+    bytes: Uint8Array;
+}, target: DomainTarget, paymentConfig: PaymentConfig, providers: ContractProviders<NS.Contract>, options?: OperationOptions & {
+    fields?: Array<[string, string]>;
+    defaultField?: string;
+}): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function clearField(domain: string, key: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function transferDomain(domainName: string, parentId: bigint, newOwner: Uint8Array, newOwnerAddress: {
+    bytes: Uint8Array;
+}, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function clearAllFields(domain: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function addDomainField(domainId: bigint, key: string, value: string, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function addMultipleFields(domain: string, fields: Array<[string, string]>, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function addMultipleFields(domainId: bigint, fields: Array<[string, string]>, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function updateDomainTarget(domain: string, targetAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function removeDomainField(domainId: bigint, key: string, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function updateDomainColor(domain: string, color: Uint8Array, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function clearDomainFields(domainId: bigint, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function updateDomainCosts(domain: string, costs: {
-    short: bigint;
-    medium: bigint;
-    long: bigint;
-}, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function updateDefaultField(domainId: bigint, field: string | null, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function transferDomainOwnership(parentDomain: string, subdomainName: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function updateDomainTarget(domainId: bigint, target: DomainTarget, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function setDomainResolver(parentDomain: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function updatePaymentConfig(domainId: bigint, config: PaymentConfig, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function registerDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function changeRootEnableSubdomains(enabled: boolean, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function buyDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, _paymentAmount: bigint, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function changeFieldLimit(limit: bigint | null, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;
-export declare function changeDomainOwner(domain: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function lockTarget(domainId: bigint, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function lockPaymentConfig(domainId: bigint, providers: ContractProviders<NS.Contract>, options?: OperationOptions): Promise<Result<{
     transactionId: string;
 }>>;

package/dist/operations.js

@@ -1,47 +1,33 @@
 import { CompiledContract } from "@midnight-ntwrk/compact-js";
 import { findDeployedContract, } from "@midnight-ntwrk/midnight-js-contracts";
-import { ShieldedCoinPublicKey, MidnightBech32m, } from "@midnight-ntwrk/wallet-sdk-address-format";
-import { isWalletAddress } from "./utils/address.js";
 import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
-import { Leaf, MANAGED_DIR } from "@midnames/ns";
+import { NS, MANAGED_DIR, witnesses, AddressType } from "./contract.js";
 import { success, failure } from "./results.js";
-import { NetworkError, InvalidDomainError } from "./errors.js";
-import { normalizeDomain, parseFullDomain, domainToKey } from "./utils/domain.js";
-import { getDomainInfo } from "./core.js";
-function validateDomain(domain) {
-    const normalized = normalizeDomain(domain);
-    const parsed = parseFullDomain(normalized);
-    if (!parsed.isValid) {
-        return failure(new InvalidDomainError(domain, "Invalid domain format"));
-    }
-    return success(normalized);
-}
-// Contract types and instances
-export const leafContractInstance = CompiledContract.make("leaf-contract", Leaf.Contract).pipe(CompiledContract.withVacantWitnesses, CompiledContract.withCompiledFileAssets(MANAGED_DIR));
-async function joinLeafContract(providers, contractAddress) {
+import { NetworkError } from "./errors.js";
+import { domainToKey } from "./utils/domain.js";
+import { parseAddressToBytes } from "./utils/address.js";
+import { getNetworkConfig } from "./provider.js";
+// ---- Contract instance ----
+export const nsContractInstance = CompiledContract.make("ns-contract", NS.Contract).pipe(CompiledContract.withWitnesses(witnesses), CompiledContract.withCompiledFileAssets(MANAGED_DIR));
+function getDefaultContractAddress() {
+    const currentNetwork = getNetworkId();
+    return getNetworkConfig(currentNetwork).contractAddress;
+}
+async function joinNsContract(providers, contractAddress, secretKey) {
+    const initialPrivateState = secretKey
+        ? { secretKey }
+        : { phantom: false };
     return await findDeployedContract(providers, {
-        contractAddress,
-        compiledContract: leafContractInstance,
-        privateStateId: "namespacePrivateState",
-        initialPrivateState: { phantom: false },
+        contractAddress: contractAddress ?? getDefaultContractAddress(),
+        compiledContract: nsContractInstance,
+        privateStateId: "nsPrivateState",
+        initialPrivateState,
     });
 }
-// --- Shared helpers ---
-async function withLeafContract(domain, providers, label, fn) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
+async function withContract(providers, label, fn, options) {
     try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await fn(contract, domainInfoResult.data);
-        return success(result);
+        const contract = await joinNsContract(providers, options?.contractAddress, options?.secretKey);
+        return success(await fn(contract));
     }
     catch (error) {
         return failure(new NetworkError(`Failed to ${label}: ${error instanceof Error ? error.message : String(error)}`, error));
@@ -50,89 +36,86 @@ async function withLeafContract(domain, providers, label, fn) {
 function txId(result) {
     return { transactionId: result.public.txId };
 }
-export function buildKvs(fields) {
-    return Array.from({ length: 10 }, (_, i) => ({
+function targetToContractArgs(target) {
+    const parsed = parseAddressToBytes(target.address);
+    switch (target.type) {
+        case "contract":
+            return { targetBytes: parsed.bytes, targetType: AddressType.ContractAddr };
+        case "shielded":
+            return { targetBytes: parsed.bytes, targetType: AddressType.ZswapCPKAddr };
+        case "unshielded":
+            return { targetBytes: parsed.bytes, targetType: AddressType.UnshieldedAddr };
+    }
+}
+export function buildKvs(fields, size = 10) {
+    return Array.from({ length: size }, (_, i) => ({
         is_some: i < fields.length,
         value: i < fields.length ? fields[i] : ["", ""],
     }));
 }
-function parseAddressToBytes(address) {
-    if (isWalletAddress(address)) {
-        const bech32Parsed = MidnightBech32m.parse(address);
-        const coinPublicKey = ShieldedCoinPublicKey.codec.decode(getNetworkId(), bech32Parsed);
-        return { bytes: new Uint8Array(coinPublicKey.data) };
-    }
-    else {
-        let hexString = address;
-        if (address.startsWith("0200")) {
-            hexString = address.slice(4);
-        }
-        const bytes = new Uint8Array(Buffer.from(hexString, "hex"));
-        return { bytes: bytes.length === 32 ? bytes : bytes.subarray(-32) };
-    }
-}
-function formatTargetForContract(address) {
-    const parsed = parseAddressToBytes(address);
-    const isLeft = isWalletAddress(address);
-    return {
-        is_left: isLeft,
-        left: isLeft ? parsed : { bytes: new Uint8Array(32) },
-        right: isLeft ? { bytes: new Uint8Array(32) } : parsed,
-    };
-}
-// --- Domain operations ---
-export async function insertField(domain, key, value, providers) {
-    return withLeafContract(domain, providers, "insert field", async (contract) => txId(await contract.callTx.insert_field(key, value)));
-}
-export async function clearField(domain, key, providers) {
-    return withLeafContract(domain, providers, "clear field", async (contract) => txId(await contract.callTx.clear_field(key)));
-}
-export async function clearAllFields(domain, providers) {
-    return withLeafContract(domain, providers, "clear all fields", async (contract) => txId(await contract.callTx.clear_all_fields()));
-}
-export async function addMultipleFields(domain, fields, providers) {
+// ---- Domain creation ----
+export async function createDomain(domainName, parentId, ownerAddress, target, paymentConfig, providers, options) {
+    const { key, len } = domainToKey(domainName);
+    const { targetBytes, targetType } = targetToContractArgs(target);
+    const kvs = buildKvs(options?.fields ?? [], 10);
+    const defaultField = options?.defaultField
+        ? { is_some: true, value: options.defaultField }
+        : { is_some: false, value: "" };
+    return withContract(providers, "create domain", async (contract) => txId(await contract.callTx.create_domain(ownerAddress, key, len, parentId, targetBytes, targetType, defaultField, paymentConfig, kvs)), options);
+}
+// ---- Domain updates ----
+export async function transferDomain(domainName, parentId, newOwner, newOwnerAddress, providers, options) {
+    const { key } = domainToKey(domainName);
+    return withContract(providers, "transfer domain", async (contract) => txId(await contract.callTx.transfer_domain(key, parentId, newOwner, newOwnerAddress)), options);
+}
+// ---- Field operations ----
+export async function addDomainField(domainId, key, value, providers, options) {
+    return withContract(providers, "add domain field", async (contract) => txId(await contract.callTx.add_domain_field(domainId, key, value)), options);
+}
+export async function addMultipleFields(domainId, fields, providers, options) {
     if (fields.length === 0) {
         return failure(new NetworkError("No fields provided"));
     }
     if (fields.length > 10) {
         return failure(new NetworkError("Maximum of 10 fields can be added at once"));
     }
-    return withLeafContract(domain, providers, "add multiple fields", async (contract) => txId(await contract.callTx.add_multiple_fields(buildKvs(fields))));
+    const kvs = buildKvs(fields, 10);
+    return withContract(providers, "add multiple fields", async (contract) => txId(await contract.callTx.add_multiple_fields(domainId, kvs)), options);
 }
-export async function updateDomainTarget(domain, targetAddress, providers) {
-    return withLeafContract(domain, providers, "update domain target", async (contract) => txId(await contract.callTx.update_domain_target(formatTargetForContract(targetAddress))));
+export async function removeDomainField(domainId, key, providers, options) {
+    return withContract(providers, "remove domain field", async (contract) => txId(await contract.callTx.remove_domain_field(domainId, key)), options);
 }
-export async function updateDomainColor(domain, color, providers) {
-    if (color.length !== 32) {
-        return failure(new NetworkError("Color must be exactly 32 bytes"));
-    }
-    return withLeafContract(domain, providers, "update domain color", async (contract) => txId(await contract.callTx.update_color(color)));
+export async function clearDomainFields(domainId, providers, options) {
+    return withContract(providers, "clear domain fields", async (contract) => txId(await contract.callTx.clear_domain_fields(domainId)), options);
 }
-export async function updateDomainCosts(domain, costs, providers) {
-    if (costs.short < BigInt(0) || costs.medium < BigInt(0) || costs.long < BigInt(0)) {
-        return failure(new NetworkError("Costs must be non-negative"));
-    }
-    return withLeafContract(domain, providers, "update domain costs", async (contract) => txId(await contract.callTx.update_costs(costs.short, costs.medium, costs.long)));
+export async function updateDefaultField(domainId, field, providers, options) {
+    const maybe = field !== null
+        ? { is_some: true, value: field }
+        : { is_some: false, value: "" };
+    return withContract(providers, "update default field", async (contract) => txId(await contract.callTx.update_domain_default_field(domainId, maybe)), options);
 }
-export async function transferDomainOwnership(parentDomain, subdomainName, newOwnerAddress, providers) {
-    return withLeafContract(parentDomain, providers, "transfer domain ownership", async (contract) => txId(await contract.callTx.transfer_domain(domainToKey(subdomainName).key, parseAddressToBytes(newOwnerAddress))));
+// ---- Granular update operations ----
+export async function updateDomainTarget(domainId, target, providers, options) {
+    const { targetBytes, targetType } = targetToContractArgs(target);
+    return withContract(providers, "update target", async (contract) => txId(await contract.callTx.update_target(domainId, targetBytes, targetType)), options);
 }
-export async function setDomainResolver(parentDomain, subdomainName, resolverAddress, providers) {
-    return withLeafContract(parentDomain, providers, "set domain resolver", async (contract) => txId(await contract.callTx.set_resolver(domainToKey(subdomainName).key, parseAddressToBytes(resolverAddress))));
+export async function updatePaymentConfig(domainId, config, providers, options) {
+    return withContract(providers, "update payment config", async (contract) => txId(await contract.callTx.update_payment_config(domainId, config)), options);
 }
-export async function registerDomainFor(parentDomain, ownerAddress, subdomainName, resolverAddress, providers) {
-    return withLeafContract(parentDomain, providers, "register domain", async (contract) => {
-        const { key, len } = domainToKey(subdomainName);
-        return txId(await contract.callTx.register_domain_for(parseAddressToBytes(ownerAddress), key, len, parseAddressToBytes(resolverAddress)));
-    });
+// ---- Root zone operations ----
+export async function changeRootEnableSubdomains(enabled, providers, options) {
+    return withContract(providers, "change root enable subdomains", async (contract) => txId(await contract.callTx.change_root_enable_subdomains(enabled)), options);
 }
-export async function buyDomainFor(parentDomain, ownerAddress, subdomainName, resolverAddress, _paymentAmount, providers) {
-    return withLeafContract(parentDomain, providers, "buy domain", async (contract) => {
-        const { key, len } = domainToKey(subdomainName);
-        return txId(await contract.callTx.register_domain_for(parseAddressToBytes(ownerAddress), key, len, parseAddressToBytes(resolverAddress)));
-    });
+export async function changeFieldLimit(limit, providers, options) {
+    const maybe = limit !== null
+        ? { is_some: true, value: limit }
+        : { is_some: false, value: 0n };
+    return withContract(providers, "change field limit", async (contract) => txId(await contract.callTx.change_field_limit(maybe)), options);
+}
+// ---- Lock operations ----
+export async function lockTarget(domainId, providers, options) {
+    return withContract(providers, "lock target", async (contract) => txId(await contract.callTx.lock_target(domainId)), options);
 }
-export async function changeDomainOwner(domain, newOwnerAddress, providers) {
-    return withLeafContract(domain, providers, "change domain owner", async (contract) => txId(await contract.callTx.change_owner(parseAddressToBytes(newOwnerAddress))));
+export async function lockPaymentConfig(domainId, providers, options) {
+    return withContract(providers, "lock payment config", async (contract) => txId(await contract.callTx.lock_payment_config(domainId)), options);
 }
-//# sourceMappingURL=operations.js.map

package/dist/provider.d.ts

@@ -2,15 +2,14 @@ import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
 export interface NetworkConfig {
     indexerUrl: string;
     indexerWsUrl: string;
-    tldAddress: string;
+    contractAddress: string;
 }
 export declare const NETWORK_REGISTRY: Record<string, NetworkConfig>;
-export interface ProviderConfig {
-    indexerUrl?: string;
-    indexerWsUrl?: string;
-    networkId?: string;
-}
 export declare function getNetworkConfig(networkId: string): NetworkConfig;
 export declare function getDefaultProvider(networkId?: string): PublicDataProvider;
 export declare function setDefaultProvider(provider: PublicDataProvider): void;
-export declare function createDefaultProvider(config?: ProviderConfig): PublicDataProvider;
+export declare function createDefaultProvider(config?: {
+    indexerUrl?: string;
+    indexerWsUrl?: string;
+    networkId?: string;
+}): PublicDataProvider;

package/dist/provider.js

@@ -1,26 +1,31 @@
-import { setNetworkId, } from "@midnight-ntwrk/midnight-js-network-id";
+import { setNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import { indexerPublicDataProvider } from "@midnight-ntwrk/midnight-js-indexer-public-data-provider";
 export const NETWORK_REGISTRY = {
     preview: {
         indexerUrl: "https://indexer.preview.midnight.network/api/v3/graphql",
         indexerWsUrl: "wss://indexer.preview.midnight.network/api/v3/graphql/ws",
-        tldAddress: "daa9fc4dfbd42ac9227f8b4358928532da68337689ea3b21b351d607890d9192",
+        contractAddress: "", // TODO: set after deployment
     },
     preprod: {
         indexerUrl: "https://indexer.preprod.midnight.network/api/v3/graphql",
         indexerWsUrl: "wss://indexer.preprod.midnight.network/api/v3/graphql/ws",
-        tldAddress: "53e332b013710de2dcc7df26262a6b323487984f9eca9d372241ce1d6027a233",
+        contractAddress: "cd74a2e9765e1f56e4ada5e2eaea37040212456c386e7f0e7671bcde23577c9c",
+    },
+    mainnet: {
+        indexerUrl: "https://indexer.mainnet.midnight.network/api/v3/graphql",
+        indexerWsUrl: "wss://indexer.mainnet.midnight.network/api/v3/graphql/ws",
+        contractAddress: "83b0d57aba442f92e12b5cdf92642adb9927ccd554a9061b5bd0992fc72596bb",
     },
 };
 export function getNetworkConfig(networkId) {
     const config = NETWORK_REGISTRY[networkId];
     if (!config) {
-        throw new Error(`Unknown network "${networkId}". Known networks: ${Object.keys(NETWORK_REGISTRY).join(", ")}. Use createDefaultProvider() with explicit URLs for custom networks.`);
+        throw new Error(`Unknown network "${networkId}". Known networks: ${Object.keys(NETWORK_REGISTRY).join(", ")}`);
     }
     return config;
 }
 let defaultProvider = null;
-export function getDefaultProvider(networkId = "preview") {
+export function getDefaultProvider(networkId = "mainnet") {
     if (!defaultProvider) {
         const net = getNetworkConfig(networkId);
         setNetworkId(networkId);
@@ -32,7 +37,7 @@ export function setDefaultProvider(provider) {
     defaultProvider = provider;
 }
 export function createDefaultProvider(config = {}) {
-    const networkId = config.networkId ?? "preview";
+    const networkId = config.networkId ?? "mainnet";
     const knownConfig = NETWORK_REGISTRY[networkId];
     const indexerUrl = config.indexerUrl ?? knownConfig?.indexerUrl;
     const indexerWsUrl = config.indexerWsUrl ?? knownConfig?.indexerWsUrl;
@@ -42,4 +47,3 @@ export function createDefaultProvider(config = {}) {
     setNetworkId(networkId);
     return indexerPublicDataProvider(indexerUrl, indexerWsUrl);
 }
-//# sourceMappingURL=provider.js.map

package/dist/react/DomainProfileWidget.d.ts

@@ -15,7 +15,7 @@ export type DomainProfileWidgetProps = {
     showDomainInfo?: boolean;
     showSocialLinks?: boolean;
     showCopyButtons?: boolean;
-    fields?: ('target' | 'owner' | 'resolver')[];
+    fields?: ('target' | 'owner')[];
     customFields?: string[];
     theme?: 'light' | 'dark' | 'auto';
     borderRadius?: 'none' | 'sm' | 'md' | 'lg';

package/dist/react/DomainProfileWidget.js

@@ -41,19 +41,7 @@ export function CopyableValue({ value, className, showCopy = true, onCopySuccess
     };
     return (_jsxs("span", { className: `${className} ${showCopy || onFieldClick ? 'midnames-copyable' : ''}`, onClick: handleClick, onMouseEnter: () => setHovered(true), onMouseLeave: () => setHovered(false), title: value, children: [truncate(value), showCopy && (_jsx("span", { className: "midnames-copy-icon-container", children: copied ? (_jsx(Check, { className: "midnames-copy-icon midnames-copy-success" })) : (_jsx(Copy, { className: `midnames-copy-icon midnames-copy-hover ${hovered ? 'midnames-copy-visible' : 'midnames-copy-invisible'}` })) }))] }));
 }
-export function DomainProfileWidget({ fullDomain, publicDataProvider, className, showStatus = true, onError, 
-// Variant and layout
-variant = 'full', 
-// Visibility controls
-showBanner = true, showAvatar = true, showBio = true, showDomainInfo = true, showSocialLinks = true, showCopyButtons = true, 
-// Field selection
-fields = ['target', 'owner', 'resolver'], customFields = [], 
-// Styling
-theme = 'auto', borderRadius = 'md', padding = 'md', 
-// Custom rendering
-renderActions, 
-// Event callbacks
-onFieldClick, onCopySuccess, }) {
+export function DomainProfileWidget({ fullDomain, publicDataProvider, className, showStatus = true, onError, variant = 'full', showBanner = true, showAvatar = true, showBio = true, showDomainInfo = true, showSocialLinks = true, showCopyButtons = true, fields = ['target', 'owner'], customFields = [], theme = 'auto', borderRadius = 'md', padding = 'md', renderActions, onFieldClick, onCopySuccess, }) {
     const [loading, setLoading] = useState(false);
     const [data, setData] = useState(null);
     const [error, setError] = useState(null);
@@ -105,12 +93,14 @@ onFieldClick, onCopySuccess, }) {
     const bannerUrl = fieldsMap['banner'] || fieldsMap['header'] || '';
     const epk = fieldsMap['epk'];
     const resolvedTarget = useMemo(() => {
-        if (!data?.resolvedTarget)
+        const target = data?.info?.target;
+        if (!target)
             return null;
-        if (epk)
-            return deriveShieldedAddress(data.resolvedTarget, epk) || data.resolvedTarget;
-        return data.resolvedTarget;
-    }, [data?.resolvedTarget, epk]);
+        if (target.type === 'shielded' && epk) {
+            return deriveShieldedAddress(target.address, epk) || target.address;
+        }
+        return target.address;
+    }, [data?.info?.target, epk]);
     const status = useMemo(() => {
         if (loading)
             return 'unknown';
@@ -118,39 +108,28 @@ onFieldClick, onCopySuccess, }) {
             return 'error';
         return data?.info ? 'registered' : 'available';
     }, [loading, data?.info, error]);
-    // Build CSS classes based on props
     const cardClasses = useMemo(() => {
         const classes = ['midnames-card'];
-        if (variant !== 'full') {
+        if (variant !== 'full')
             classes.push(`midnames-card-${variant}`);
-        }
-        if (theme !== 'auto') {
+        if (theme !== 'auto')
             classes.push(`midnames-theme-${theme}`);
-        }
-        if (borderRadius !== 'md') {
+        if (borderRadius !== 'md')
             classes.push(`midnames-border-${borderRadius}`);
-        }
-        if (padding !== 'md') {
+        if (padding !== 'md')
             classes.push(`midnames-padding-${padding}`);
-        }
-        if (className) {
+        if (className)
             classes.push(className);
-        }
         return classes.join(' ');
     }, [variant, theme, borderRadius, padding, className]);
-    // Filter fields to show
     const fieldsToShow = useMemo(() => {
         const fieldsData = [];
         if (fields.includes('target')) {
             fieldsData.push({ key: 'target', label: 'Resolved Target', value: resolvedTarget, fieldName: 'target' });
         }
         if (fields.includes('owner')) {
-            fieldsData.push({ key: 'owner', label: 'Owner', value: data?.info?.owner || null, fieldName: 'owner' });
-        }
-        if (fields.includes('resolver')) {
-            fieldsData.push({ key: 'resolver', label: 'Resolver', value: data?.info?.resolver || null, fieldName: 'resolver' });
+            fieldsData.push({ key: 'owner', label: 'Owner', value: data?.info?.ownerAddress || null, fieldName: 'owner' });
         }
-        // Add custom fields
         customFields.forEach(fieldKey => {
             const fieldValue = fieldsMap[fieldKey.toLowerCase()];
             if (fieldValue) {
@@ -164,4 +143,3 @@ onFieldClick, onCopySuccess, }) {
     }
     return (_jsxs("div", { className: cardClasses, children: [showBanner && bannerUrl && _jsx("img", { src: sanitizeUrl(bannerUrl), alt: "", className: "midnames-banner" }), _jsxs("div", { className: "midnames-header", children: [showAvatar && (_jsx("div", { className: "midnames-avatar", children: avatarUrl ? (_jsx("img", { src: sanitizeUrl(avatarUrl), alt: "", onError: (e) => (e.currentTarget.style.display = 'none') })) : (_jsx("span", { children: (displayName || data?.fullDomain || '?')[0]?.toUpperCase?.() ?? '?' })) })), _jsxs("div", { className: "midnames-ident", children: [_jsx("div", { className: "midnames-name", children: displayName || data?.fullDomain || fullDomain }), variant !== 'minimal' && _jsx("div", { className: "midnames-domain", children: data?.fullDomain || fullDomain })] }), showStatus && (_jsx("div", { className: `midnames-status midnames-status-${status}`, children: loading ? 'Checking…' : status === 'registered' ? 'Registered' : status === 'available' ? 'Available' : status === 'error' ? 'Error' : 'Unknown' }))] }), showBio && bio && _jsx("p", { className: "midnames-bio", children: bio }), showDomainInfo && fieldsToShow.length > 0 && (_jsx("div", { className: "midnames-grid", children: fieldsToShow.map((field) => (_jsxs("div", { className: "midnames-box", children: [_jsx("div", { className: "midnames-box-label", children: field.label }), _jsx(CopyableValue, { value: field.value, className: "midnames-box-value", showCopy: showCopyButtons, onCopySuccess: onCopySuccess, onFieldClick: onFieldClick, fieldName: field.fieldName })] }, field.key))) })), showSocialLinks && (website || twitter || github || location) && (_jsxs("div", { className: "midnames-links", children: [website && (_jsx("a", { className: "midnames-chip", href: sanitizeUrl(website.startsWith('http') ? website : `https://${website}`), target: "_blank", rel: "noreferrer", children: website.replace(/^https?:\/\//, '') })), twitter && (_jsxs("a", { className: "midnames-chip", href: `https://x.com/${twitter}`, target: "_blank", rel: "noreferrer", children: ["@", twitter] })), github && (_jsx("a", { className: "midnames-chip", href: `https://github.com/${github}`, target: "_blank", rel: "noreferrer", children: github })), location && _jsx("span", { className: "midnames-chip", children: location })] })), renderActions && (_jsx("div", { className: "midnames-actions", children: renderActions(data) }))] }));
 }
-//# sourceMappingURL=DomainProfileWidget.js.map

package/dist/react/HolographicCard.d.ts

@@ -1,36 +1,20 @@
 import React from 'react';
 import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
 import { MidnamesError } from '../errors.js';
-/**
- * HolographicCard props
- */
 export interface HolographicCardProps {
-    /** Domain name to resolve and display */
     domain: string;
-    /** Public data provider for fetching domain information */
     publicDataProvider?: PublicDataProvider;
-    /** Custom CSS gradient string for the background gradient effect */
     behindGradient?: string;
-    /** Custom CSS gradient string for the inner card gradient */
     innerGradient?: string;
-    /** Whether to display the background gradient effect */
     showBehindGradient?: boolean;
-    /** Additional CSS classes to apply to the card wrapper */
     className?: string;
-    /** Enable or disable the 3D tilt effect on mouse hover */
     enableTilt?: boolean;
-    /** Enable or disable the 3D tilt effect on mobile devices */
     enableMobileTilt?: boolean;
-    /** Sensitivity of the 3D tilt effect on mobile devices */
     mobileTiltSensitivity?: number;
-    /** Text displayed on the contact button */
     contactText?: string;
-    /** Whether to display the user information section */
     showUserInfo?: boolean;
-    /** Callback function called when the contact button is clicked */
     onContactClick?: () => void;
-    /** Callback function called when an error occurs */
     onError?: (error: MidnamesError) => void;
 }
-declare const HolographicCard: React.NamedExoticComponent<HolographicCardProps>;
+export declare const HolographicCard: React.NamedExoticComponent<HolographicCardProps>;
 export default HolographicCard;

package/dist/react/HolographicCard.js

@@ -21,11 +21,9 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
     const wrapRef = useRef(null);
     const cardRef = useRef(null);
     const lastXY = useRef(null);
-    // Domain data state
     const [loading, setLoading] = useState(false);
     const [data, setData] = useState(null);
     const [error, setError] = useState(null);
-    // Fetch domain data
     useEffect(() => {
         let mounted = true;
         setLoading(true);
@@ -58,7 +56,6 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
             mounted = false;
         };
     }, [publicDataProvider, domain, onError]);
-    // Extract fields from domain data
     const fieldsMap = useMemo(() => {
         const m = {};
         if (data?.fields) {
@@ -69,7 +66,6 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
     const displayName = fieldsMap['name'] || fieldsMap['displayname'] || fieldsMap['handle'] || '';
     const avatarUrl = fieldsMap['avatar'] || fieldsMap['image'] || fieldsMap['pfp'] || '';
     const handle = fieldsMap['handle'] || '';
-    // Animation logic
     const animation = useMemo(() => {
         if (!enableTilt)
             return null;
@@ -190,6 +186,5 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
     }), [showBehindGradient, behindGradient, innerGradient]);
     return (_jsx("div", { ref: wrapRef, className: `midnames-holo-card-wrapper ${className}`.trim(), style: cardStyle, children: _jsx("section", { ref: cardRef, className: "midnames-holo-card", children: _jsxs("div", { className: "midnames-holo-inside", children: [_jsx("div", { className: "midnames-holo-shine" }), _jsx("div", { className: "midnames-holo-glare" }), _jsxs("div", { className: "midnames-holo-content midnames-holo-avatar-content", children: [loading && (_jsx("div", { className: "midnames-holo-loading", children: "Loading domain..." })), error && !loading && (_jsxs("div", { className: "midnames-holo-error", children: [_jsx("div", { children: "Failed to load domain" }), _jsx("div", { style: { fontSize: '12px', opacity: 0.8, marginTop: '8px' }, children: error.message })] })), avatarUrl && !loading && !error && (_jsx("img", { className: "midnames-holo-avatar", src: sanitizeUrl(avatarUrl), alt: `${displayName || domain} avatar`, loading: "lazy", onError: (e) => { e.target.style.display = 'none'; } })), showUserInfo && !loading && !error && (displayName || handle || contactText) && (_jsxs("div", { className: "midnames-holo-user-info", children: [_jsxs("div", { className: "midnames-holo-user-details", children: [_jsx("div", { className: "midnames-holo-mini-avatar", children: _jsx("img", { src: sanitizeUrl(avatarUrl), alt: "mini", loading: "lazy", onError: (e) => { e.target.style.display = 'none'; } }) }), _jsxs("div", { className: "midnames-holo-user-text", children: [displayName && _jsx("div", { className: "midnames-holo-handle", children: displayName }), handle && _jsxs("div", { className: "midnames-holo-status", children: ["@", handle] }), _jsx("div", { className: "midnames-holo-status", children: domain })] })] }), _jsx("button", { className: "midnames-holo-contact-btn", onClick: onContactClick, type: "button", children: contactText })] }))] })] }) }) }));
 };
-const HolographicCard = React.memo(HolographicCardComponent);
+export const HolographicCard = React.memo(HolographicCardComponent);
 export default HolographicCard;
-//# sourceMappingURL=HolographicCard.js.map