@midnames/sdk 0.2.1 → 1.0.1

package/dist/managed/managed/leaf/contract/index.js.map

@@ -0,0 +1,8 @@
+{
+  "version": 3,
+  "file": "index.js",
+  "sourceRoot": "../../../../",
+  "sources": ["src/leaf.compact", "compiler/standard-library.compact"],
+  "names": [],
+  "mappings": "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"
+}

package/dist/managed/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function domainToKey(name: string): {
+    key: Uint8Array;
+    len: bigint;
+};
+export declare function keyToDomain(key: Uint8Array): string;

package/dist/managed/utils.js

@@ -0,0 +1,19 @@
+export function domainToKey(name) {
+    const bytes = new TextEncoder().encode(name);
+    if (bytes.length === 0 || bytes.length > 32)
+        throw new Error(`Domain name must be 1-32 bytes, got ${bytes.length}`);
+    const key = new Uint8Array(32).fill(255);
+    key.set(bytes);
+    return { key, len: BigInt(bytes.length) };
+}
+export function keyToDomain(key) {
+    let len = 32;
+    for (let i = 0; i < 32; i++) {
+        if (key[i] === 255) {
+            len = i;
+            break;
+        }
+    }
+    return new TextDecoder().decode(key.subarray(0, len));
+}
+//# sourceMappingURL=utils.js.map

package/dist/managed/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE;QACzC,MAAM,IAAI,KAAK,CAAC,uCAAuC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACzE,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,GAAe;IACzC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5B,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAAC,GAAG,GAAG,CAAC,CAAC;YAAC,MAAM;QAAC,CAAC;IACzC,CAAC;IACD,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AACxD,CAAC"}

package/dist/operations.d.ts

@@ -0,0 +1,49 @@
+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<{
+    is_some: boolean;
+    value: [string, string];
+}>;
+export declare function insertField(domain: string, key: string, value: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function clearField(domain: string, key: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function clearAllFields(domain: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function addMultipleFields(domain: string, fields: Array<[string, string]>, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function updateDomainTarget(domain: string, targetAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function updateDomainColor(domain: string, color: Uint8Array, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function updateDomainCosts(domain: string, costs: {
+    short: bigint;
+    medium: bigint;
+    long: bigint;
+}, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function transferDomainOwnership(parentDomain: string, subdomainName: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function setDomainResolver(parentDomain: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function registerDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function buyDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, _paymentAmount: bigint, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+export declare function changeDomainOwner(domain: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;

package/dist/operations.js

@@ -0,0 +1,137 @@
+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 } from "@midnames/ns";
+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/leaf"));
+async function joinLeafContract(providers, contractAddress) {
+    return await findDeployedContract(providers, {
+        contractAddress,
+        compiledContract: leafContractInstance,
+        privateStateId: "namespacePrivateState",
+        initialPrivateState: { phantom: false },
+    });
+}
+// --- Shared helpers ---
+async function withLeafContract(domain, providers, label, fn) {
+    const validated = validateDomain(domain);
+    if (!validated.success)
+        return failure(validated.error);
+    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);
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to ${label}: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+function txId(result) {
+    return { transactionId: result.public.txId };
+}
+export function buildKvs(fields) {
+    return Array.from({ length: 10 }, (_, 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) {
+    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))));
+}
+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 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 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 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))));
+}
+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 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)));
+    });
+}
+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 changeDomainOwner(domain, newOwnerAddress, providers) {
+    return withLeafContract(domain, providers, "change domain owner", async (contract) => txId(await contract.callTx.change_owner(parseAddressToBytes(newOwnerAddress))));
+}

package/dist/provider.d.ts

@@ -1,10 +1,16 @@
-import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
-import { NetworkId } from '@midnight-ntwrk/midnight-js-network-id';
+import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
+export interface NetworkConfig {
+    indexerUrl: string;
+    indexerWsUrl: string;
+    tldAddress: string;
+}
+export declare const NETWORK_REGISTRY: Record<string, NetworkConfig>;
 export interface ProviderConfig {
     indexerUrl?: string;
     indexerWsUrl?: string;
-    networkId?: NetworkId;
+    networkId?: string;
 }
-export declare function getDefaultProvider(): PublicDataProvider;
+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;

package/dist/provider.js

@@ -1,13 +1,30 @@
-import { NetworkId, setNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
-import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
+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",
+    },
+    preprod: {
+        indexerUrl: "https://indexer.preprod.midnight.network/api/v3/graphql",
+        indexerWsUrl: "wss://indexer.preprod.midnight.network/api/v3/graphql/ws",
+        tldAddress: "b00a62ce58c108b86af4670e662fa240844e0206c54009a539c64155d62e6b6a",
+    },
+};
+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.`);
+    }
+    return config;
+}
 let defaultProvider = null;
-export function getDefaultProvider() {
+export function getDefaultProvider(networkId = "preview") {
     if (!defaultProvider) {
-        const indexerUrl = "https://indexer.testnet-02.midnight.network/api/v1/graphql";
-        const indexerWsUrl = "wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws";
-        const networkId = NetworkId.TestNet;
+        const net = getNetworkConfig(networkId);
         setNetworkId(networkId);
-        defaultProvider = indexerPublicDataProvider(indexerUrl, indexerWsUrl);
+        defaultProvider = indexerPublicDataProvider(net.indexerUrl, net.indexerWsUrl);
     }
     return defaultProvider;
 }
@@ -15,7 +32,14 @@ export function setDefaultProvider(provider) {
     defaultProvider = provider;
 }
 export function createDefaultProvider(config = {}) {
-    const { indexerUrl = "https://indexer.testnet-02.midnight.network/api/v1/graphql", indexerWsUrl = "wss://indexer.testnet-02.midnight.network/api/v1/graphql/ws", networkId = NetworkId.TestNet } = config;
+    var _a, _b, _c;
+    const networkId = (_a = config.networkId) !== null && _a !== void 0 ? _a : "preview";
+    const knownConfig = NETWORK_REGISTRY[networkId];
+    const indexerUrl = (_b = config.indexerUrl) !== null && _b !== void 0 ? _b : knownConfig === null || knownConfig === void 0 ? void 0 : knownConfig.indexerUrl;
+    const indexerWsUrl = (_c = config.indexerWsUrl) !== null && _c !== void 0 ? _c : knownConfig === null || knownConfig === void 0 ? void 0 : knownConfig.indexerWsUrl;
+    if (!indexerUrl || !indexerWsUrl) {
+        throw new Error(`No indexer URLs for network "${networkId}". Provide indexerUrl and indexerWsUrl explicitly.`);
+    }
     setNetworkId(networkId);
     return indexerPublicDataProvider(indexerUrl, indexerWsUrl);
 }

package/dist/react/DomainProfileWidget.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
 import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
 import type { DomainProfileData } from '../types.js';
-import { MidNamesError } from '../types.js';
+import { MidnamesError } from '../errors.js';
 export type DomainProfileWidgetProps = {
     fullDomain: string;
     publicDataProvider?: PublicDataProvider;
     className?: string;
     showStatus?: boolean;
-    onError?: (error: MidNamesError) => void;
+    onError?: (error: MidnamesError) => void;
     variant?: 'full' | 'compact' | 'inline' | 'minimal';
     showBanner?: boolean;
     showAvatar?: boolean;

package/dist/react/DomainProfileWidget.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from 'react';
-import { MidNamesError } from '../types.js';
+import { MidnamesError } from '../errors.js';
 import { deriveShieldedAddress } from '../utils/address.js';
 import { Copy, Check } from 'lucide-react';
 import { getDomainProfile } from '../core.js';
 import { getDefaultProvider } from '../provider.js';
+import { sanitizeUrl } from '../utils/sanitize.js';
 function truncate(addr, head = 10, tail = 6) {
     if (!addr)
         return 'N/A';
@@ -69,19 +70,19 @@ onFieldClick, onCopySuccess, }) {
                     setData(d.data);
                 }
                 else {
-                    setError(new MidNamesError((_b = (_a = d.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Unknown error', (_d = (_c = d.error) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : 'UNKNOWN', d.error));
+                    setError(new MidnamesError((_b = (_a = d.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Unknown error', (_d = (_c = d.error) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : 'UNKNOWN', d.error));
                     if (onError)
-                        onError(new MidNamesError((_f = (_e = d.error) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : 'Unknown error', (_h = (_g = d.error) === null || _g === void 0 ? void 0 : _g.code) !== null && _h !== void 0 ? _h : 'UNKNOWN', d.error));
+                        onError(new MidnamesError((_f = (_e = d.error) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : 'Unknown error', (_h = (_g = d.error) === null || _g === void 0 ? void 0 : _g.code) !== null && _h !== void 0 ? _h : 'UNKNOWN', d.error));
                     setData(null);
                 }
             }
         })
             .catch((err) => {
             if (mounted) {
-                const midnamesError = err instanceof MidNamesError ? err : new MidNamesError('Unknown error', 'UNKNOWN', err);
-                setError(midnamesError);
+                const midnamesErr = err instanceof MidnamesError ? err : new MidnamesError('Unknown error', 'UNKNOWN', err);
+                setError(midnamesErr);
                 if (onError)
-                    onError(midnamesError);
+                    onError(midnamesErr);
             }
         })
             .finally(() => mounted && setLoading(false));
@@ -91,7 +92,9 @@ onFieldClick, onCopySuccess, }) {
     }, [publicDataProvider, fullDomain, onError]);
     const fieldsMap = useMemo(() => {
         const m = {};
-        ((data === null || data === void 0 ? void 0 : data.fields) || []).forEach(([k, v]) => (m[k.toLowerCase()] = v));
+        if (data === null || data === void 0 ? void 0 : data.fields) {
+            data.fields.forEach((v, k) => (m[k.toLowerCase()] = v));
+        }
         return m;
     }, [data]);
     const displayName = fieldsMap['name'] || fieldsMap['displayname'] || fieldsMap['handle'] || '';
@@ -162,5 +165,5 @@ onFieldClick, onCopySuccess, }) {
     if (error && !loading) {
         return (_jsx("div", { className: cardClasses, children: _jsxs("div", { className: "midnames-error", children: [_jsx("div", { className: "midnames-error-title", children: "Error loading domain" }), _jsx("div", { className: "midnames-error-message", children: error.message }), _jsxs("div", { className: "midnames-error-code", children: ["Code: ", error.code] })] }) }));
     }
-    return (_jsxs("div", { className: cardClasses, children: [showBanner && bannerUrl && _jsx("img", { src: bannerUrl, alt: "", className: "midnames-banner" }), _jsxs("div", { className: "midnames-header", children: [showAvatar && (_jsx("div", { className: "midnames-avatar", children: avatarUrl ? (_jsx("img", { src: avatarUrl, alt: "", onError: (e) => (e.currentTarget.style.display = 'none') })) : (_jsx("span", { children: (_c = (_b = (_a = (displayName || (data === null || data === void 0 ? void 0 : data.fullDomain) || '?')[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : '?' })) })), _jsxs("div", { className: "midnames-ident", children: [_jsx("div", { className: "midnames-name", children: displayName || (data === null || data === void 0 ? void 0 : data.fullDomain) || fullDomain }), variant !== 'minimal' && _jsx("div", { className: "midnames-domain", children: (data === null || data === void 0 ? void 0 : 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: 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) }))] }));
+    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: (_c = (_b = (_a = (displayName || (data === null || data === void 0 ? void 0 : data.fullDomain) || '?')[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : '?' })) })), _jsxs("div", { className: "midnames-ident", children: [_jsx("div", { className: "midnames-name", children: displayName || (data === null || data === void 0 ? void 0 : data.fullDomain) || fullDomain }), variant !== 'minimal' && _jsx("div", { className: "midnames-domain", children: (data === null || data === void 0 ? void 0 : 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) }))] }));
 }

package/dist/react/HolographicCard.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
-import { MidNamesError } from '../types.js';
+import { MidnamesError } from '../errors.js';
 /**
  * HolographicCard props
  */
@@ -30,7 +30,7 @@ export interface HolographicCardProps {
     /** Callback function called when the contact button is clicked */
     onContactClick?: () => void;
     /** Callback function called when an error occurs */
-    onError?: (error: MidNamesError) => void;
+    onError?: (error: MidnamesError) => void;
 }
 declare const HolographicCard: React.NamedExoticComponent<HolographicCardProps>;
 export default HolographicCard;

package/dist/react/HolographicCard.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React, { useEffect, useRef, useCallback, useMemo, useState } from 'react';
-import { MidNamesError } from '../types.js';
+import { MidnamesError } from '../errors.js';
 import { getDomainProfile } from '../core.js';
 import { getDefaultProvider } from '../provider.js';
+import { sanitizeUrl } from '../utils/sanitize.js';
 const DEFAULT_BEHIND_GRADIENT = 'radial-gradient(farthest-side circle at var(--midnames-holo-pointer-x) var(--midnames-holo-pointer-y),hsla(266,100%,90%,var(--midnames-holo-card-opacity)) 4%,hsla(266,50%,80%,calc(var(--midnames-holo-card-opacity)*0.75)) 10%,hsla(266,25%,70%,calc(var(--midnames-holo-card-opacity)*0.5)) 50%,hsla(266,0%,60%,0) 100%),radial-gradient(35% 52% at 55% 20%,#00ffaac4 0%,#073aff00 100%),radial-gradient(100% 100% at 50% 50%,#00c1ffff 1%,#073aff00 76%),conic-gradient(from 124deg at 50% 50%,#c137ffff 0%,#07c6ffff 40%,#07c6ffff 60%,#c137ffff 100%)';
 const DEFAULT_INNER_GRADIENT = 'linear-gradient(145deg,#60496e8c 0%,#71C4FF44 100%)';
 const ANIMATION_CONFIG = {
@@ -37,7 +38,7 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
                     setData(result.data);
                 }
                 else {
-                    const err = new MidNamesError((_b = (_a = result.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Unknown error', (_d = (_c = result.error) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : 'UNKNOWN', result.error);
+                    const err = new MidnamesError((_b = (_a = result.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'Unknown error', (_d = (_c = result.error) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : 'UNKNOWN', result.error);
                     setError(err);
                     if (onError)
                         onError(err);
@@ -47,10 +48,10 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
         })
             .catch((err) => {
             if (mounted) {
-                const midnamesError = err instanceof MidNamesError ? err : new MidNamesError('Unknown error', 'UNKNOWN', err);
-                setError(midnamesError);
+                const midnamesErr = err instanceof MidnamesError ? err : new MidnamesError('Unknown error', 'UNKNOWN', err);
+                setError(midnamesErr);
                 if (onError)
-                    onError(midnamesError);
+                    onError(midnamesErr);
             }
         })
             .finally(() => mounted && setLoading(false));
@@ -61,7 +62,9 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
     // Extract fields from domain data
     const fieldsMap = useMemo(() => {
         const m = {};
-        ((data === null || data === void 0 ? void 0 : data.fields) || []).forEach(([k, v]) => (m[k.toLowerCase()] = v));
+        if (data === null || data === void 0 ? void 0 : data.fields) {
+            data.fields.forEach((v, k) => (m[k.toLowerCase()] = v));
+        }
         return m;
     }, [data]);
     const displayName = fieldsMap['name'] || fieldsMap['displayname'] || fieldsMap['handle'] || '';
@@ -186,7 +189,7 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
         '--midnames-holo-behind-gradient': showBehindGradient ? (behindGradient !== null && behindGradient !== void 0 ? behindGradient : DEFAULT_BEHIND_GRADIENT) : 'none',
         '--midnames-holo-inner-gradient': innerGradient !== null && innerGradient !== void 0 ? innerGradient : DEFAULT_INNER_GRADIENT,
     }), [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: 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: 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 })] }))] })] }) }) }));
+    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 default HolographicCard;

package/dist/react/index.d.ts

@@ -1,3 +1,3 @@
-export * from './DomainProfileWidget.js';
+export { DomainProfileWidget } from './DomainProfileWidget.js';
+export type { DomainProfileWidgetProps } from './DomainProfileWidget.js';
 export { default as HolographicCard } from './HolographicCard.js';
-export { CopyableValue } from './DomainProfileWidget.js';

package/dist/react/index.js

@@ -1,3 +1,2 @@
-export * from './DomainProfileWidget.js';
+export { DomainProfileWidget } from './DomainProfileWidget.js';
 export { default as HolographicCard } from './HolographicCard.js';
-export { CopyableValue } from './DomainProfileWidget.js';

package/dist/results.d.ts

@@ -0,0 +1,38 @@
+import { MidnamesError } from "./errors.js";
+export type Result<T, E = MidnamesError> = {
+    success: true;
+    data: T;
+    error?: never;
+} | {
+    success: false;
+    data?: never;
+    error: E;
+};
+export declare function success<T, E = MidnamesError>(data: T): Result<T, E>;
+export declare function failure<E = MidnamesError>(error: E): Result<never, E>;
+export declare function match<T, E, U>(result: Result<T, E>, patterns: {
+    success: (data: T) => U;
+    error: (error: E) => U;
+}): U;
+export declare function map<T, U, E>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
+export declare function flatMap<T, U, E>(result: Result<T, E>, fn: (data: T) => Result<U, E>): Result<U, E>;
+export declare function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+export declare function recover<T, E>(result: Result<T, E>, fn: (error: E) => T): Result<T, never>;
+export declare function wrapAsync<T>(asyncFn: () => Promise<T>): Promise<Result<T>>;
+export declare class ResultChain<T, E = MidnamesError> {
+    private result;
+    constructor(result: Result<T, E>);
+    map<U>(fn: (data: T) => U): ResultChain<U, E>;
+    flatMap<U>(fn: (data: T) => Result<U, E>): ResultChain<U, E>;
+    mapError<F>(fn: (error: E) => F): ResultChain<T, F>;
+    recover(fn: (error: E) => T): ResultChain<T, never>;
+    match<U>(patterns: {
+        success: (data: T) => U;
+        error: (error: E) => U;
+    }): U;
+    unwrap(): Result<T, E>;
+}
+export declare function chain<T, E = MidnamesError>(result: Result<T, E>): ResultChain<T, E>;
+export declare function combine<T extends readonly unknown[], E>(results: {
+    [K in keyof T]: Result<T[K], E>;
+}): Result<T, E>;

package/dist/results.js

@@ -0,0 +1,88 @@
+import { MidnamesError } from "./errors.js";
+// Helper functions for Result type
+export function success(data) {
+    return { success: true, data };
+}
+export function failure(error) {
+    return { success: false, error };
+}
+// Enhanced pattern matching for Results
+export function match(result, patterns) {
+    if (result.success) {
+        return patterns.success(result.data);
+    }
+    else {
+        return patterns.error(result.error);
+    }
+}
+// Transform success value, keep error unchanged
+export function map(result, fn) {
+    return result.success
+        ? success(fn(result.data))
+        : result;
+}
+// Chain operations that can fail
+export function flatMap(result, fn) {
+    return result.success ? fn(result.data) : result;
+}
+// Transform error, keep success unchanged
+export function mapError(result, fn) {
+    return result.success ? result : failure(fn(result.error));
+}
+// Recover from error with a fallback value
+export function recover(result, fn) {
+    return result.success ? result : success(fn(result.error));
+}
+// Async result helpers
+export async function wrapAsync(asyncFn) {
+    try {
+        const data = await asyncFn();
+        return success(data);
+    }
+    catch (error) {
+        if (error instanceof MidnamesError) {
+            return failure(error);
+        }
+        return failure(new MidnamesError(error instanceof Error ? error.message : String(error), "UNKNOWN_ERROR", error));
+    }
+}
+// Chainable Result class for fluent API
+export class ResultChain {
+    constructor(result) {
+        this.result = result;
+    }
+    map(fn) {
+        return new ResultChain(map(this.result, fn));
+    }
+    flatMap(fn) {
+        return new ResultChain(flatMap(this.result, fn));
+    }
+    mapError(fn) {
+        return new ResultChain(mapError(this.result, fn));
+    }
+    recover(fn) {
+        return new ResultChain(recover(this.result, fn));
+    }
+    match(patterns) {
+        return match(this.result, patterns);
+    }
+    unwrap() {
+        return this.result;
+    }
+}
+// Helper function to start chain
+export function chain(result) {
+    return new ResultChain(result);
+}
+// Combine multiple Results
+export function combine(results) {
+    const data = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (!result.success) {
+            return result;
+        }
+        data[i] = result.data;
+    }
+    return success(data);
+}