@midnames/sdk 0.2.1 → 1.0.0

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/operations.d.ts

@@ -0,0 +1,78 @@
+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>;
+/**
+ * Insert or update a field for a domain
+ */
+export declare function insertField(domain: string, key: string, value: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Clear a specific field for a domain
+ */
+export declare function clearField(domain: string, key: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Clear all fields for a domain
+ */
+export declare function clearAllFields(domain: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Add multiple fields to a domain in a single transaction
+ * Maximum of 10 fields can be added at once
+ */
+export declare function addMultipleFields(domain: string, fields: Array<[string, string]>, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Update domain target address
+ */
+export declare function updateDomainTarget(domain: string, targetAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Update domain cost (subdomain pricing)
+ */
+export declare function updateDomainCost(domain: string, cost: bigint, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Update domain color (accepted token type)
+ */
+export declare function updateDomainColor(domain: string, colorBytes: Uint8Array, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Transfer domain ownership (executed on parent contract)
+ */
+export declare function transferDomainOwnership(parentDomain: string, subdomainName: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Set resolver for a domain (executed on parent contract)
+ */
+export declare function setDomainResolver(parentDomain: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Register domain for an address (free for parent domain owner)
+ */
+export declare function registerDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Buy domain for an address (requires payment)
+ */
+export declare function buyDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, _paymentAmount: bigint, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;
+/**
+ * Change domain owner (executed on domain's own contract)
+ */
+export declare function changeDomainOwner(domain: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+    transactionId: string;
+}>>;

package/dist/operations.js

@@ -0,0 +1,421 @@
+import { CompiledContract } from "@midnight-ntwrk/compact-js";
+import { findDeployedContract, } from "@midnight-ntwrk/midnight-js-contracts";
+// Note: Payment coin creation is no longer needed - wallet handles payment balancing automatically
+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 } 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"));
+// Helper function to join a leaf contract
+async function joinLeafContract(providers, contractAddress) {
+    return await findDeployedContract(providers, {
+        contractAddress,
+        compiledContract: leafContractInstance,
+        privateStateId: "namespacePrivateState",
+        initialPrivateState: { phantom: false },
+    });
+}
+// Helper to parse address to bytes format
+function parseAddressToBytes(address) {
+    if (isWalletAddress(address)) {
+        // Wallet address (mn_ prefix)
+        const bech32Parsed = MidnightBech32m.parse(address);
+        const coinPublicKey = ShieldedCoinPublicKey.codec.decode(getNetworkId(), bech32Parsed);
+        return { bytes: new Uint8Array(coinPublicKey.data) };
+    }
+    else {
+        // Contract address (64-char hex string) - strip 0200 prefix for backward compat
+        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) };
+    }
+}
+// Helper to format target address for contract calls
+function formatTargetAddress(address) {
+    if (isWalletAddress(address)) {
+        // Wallet address (mn_ prefix)
+        return {
+            tag: "Left",
+            value: parseAddressToBytes(address),
+        };
+    }
+    else {
+        // Contract address (64-char hex string)
+        return {
+            tag: "Right",
+            value: parseAddressToBytes(address),
+        };
+    }
+}
+// Helper to create target Either for contract calls
+function createTargetEither(target) {
+    return target.tag === "Left"
+        ? {
+            is_left: true,
+            left: target.value,
+            right: { bytes: new Uint8Array(32) },
+        }
+        : {
+            is_left: false,
+            left: { bytes: new Uint8Array(32) },
+            right: target.value,
+        };
+}
+// Note: Payment coin creation is no longer needed
+// The wallet handles payment balancing automatically when using register_domain_for
+/**
+ * Insert or update a field for a domain
+ */
+export async function insertField(domain, key, value, providers) {
+    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 contract.callTx.insert_field(key, value);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to insert field: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Clear a specific field for a domain
+ */
+export async function clearField(domain, key, providers) {
+    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 contract.callTx.clear_field(key);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to clear field: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Clear all fields for a domain
+ */
+export async function clearAllFields(domain, providers) {
+    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 domainName = validated.data.split(".")[0];
+        const contract = await joinLeafContract(providers, contractAddress);
+        const result = await contract.callTx.clear_all_fields(domainName);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to clear all fields: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Add multiple fields to a domain in a single transaction
+ * Maximum of 10 fields can be added at once
+ */
+export async function addMultipleFields(domain, fields, providers) {
+    const validated = validateDomain(domain);
+    if (!validated.success)
+        return failure(validated.error);
+    try {
+        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"));
+        }
+        // Convert to the Vector<10, Maybe<[string, string]>> format
+        const kvs = [];
+        for (let i = 0; i < 10; i++) {
+            if (i < fields.length) {
+                kvs.push({
+                    is_some: true,
+                    value: fields[i],
+                });
+            }
+            else {
+                kvs.push({
+                    is_some: false,
+                    value: ["", ""], // Empty strings for unused slots
+                });
+            }
+        }
+        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 contract.callTx.add_multiple_fields(kvs);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to add multiple fields: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Update domain target address
+ */
+export async function updateDomainTarget(domain, targetAddress, providers) {
+    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 targetFormatted = formatTargetAddress(targetAddress);
+        const targetEither = createTargetEither(targetFormatted);
+        const contract = await joinLeafContract(providers, contractAddress);
+        const result = await contract.callTx.update_domain_target(targetEither);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to update domain target: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Update domain cost (subdomain pricing)
+ */
+export async function updateDomainCost(domain, cost, providers) {
+    const validated = validateDomain(domain);
+    if (!validated.success)
+        return failure(validated.error);
+    try {
+        if (cost < BigInt(0)) {
+            return failure(new NetworkError("Cost must be non-negative"));
+        }
+        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 contract.callTx.update_cost(cost);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to update domain cost: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Update domain color (accepted token type)
+ */
+export async function updateDomainColor(domain, colorBytes, providers) {
+    const validated = validateDomain(domain);
+    if (!validated.success)
+        return failure(validated.error);
+    try {
+        if (colorBytes.length !== 32) {
+            return failure(new NetworkError("Color must be exactly 32 bytes"));
+        }
+        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 contract.callTx.update_color(colorBytes);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to update domain color: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Transfer domain ownership (executed on parent contract)
+ */
+export async function transferDomainOwnership(parentDomain, subdomainName, newOwnerAddress, providers) {
+    const validated = validateDomain(parentDomain);
+    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 parentContractAddress = domainInfoResult.data.resolver;
+        const newOwnerBytes = parseAddressToBytes(newOwnerAddress);
+        const parentContract = await joinLeafContract(providers, parentContractAddress);
+        const result = await parentContract.callTx.transfer_domain(subdomainName, newOwnerBytes);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to transfer domain ownership: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Set resolver for a domain (executed on parent contract)
+ */
+export async function setDomainResolver(parentDomain, subdomainName, resolverAddress, providers) {
+    const validated = validateDomain(parentDomain);
+    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 parentContractAddress = domainInfoResult.data.resolver;
+        const resolverBytes = parseAddressToBytes(resolverAddress);
+        const parentContract = await joinLeafContract(providers, parentContractAddress);
+        const result = await parentContract.callTx.set_resolver(subdomainName, resolverBytes);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to set domain resolver: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Register domain for an address (free for parent domain owner)
+ */
+export async function registerDomainFor(parentDomain, ownerAddress, subdomainName, resolverAddress, providers) {
+    const validated = validateDomain(parentDomain);
+    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 parentContractAddress = domainInfoResult.data.resolver;
+        const ownerBytes = parseAddressToBytes(ownerAddress);
+        const resolverBytes = parseAddressToBytes(resolverAddress);
+        const parentContract = await joinLeafContract(providers, parentContractAddress);
+        const result = await parentContract.callTx.register_domain_for(ownerBytes, subdomainName, resolverBytes);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to register domain: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Buy domain for an address (requires payment)
+ */
+export async function buyDomainFor(parentDomain, ownerAddress, subdomainName, resolverAddress, _paymentAmount, providers) {
+    const validated = validateDomain(parentDomain);
+    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 parentContractAddress = domainInfoResult.data.resolver;
+        const ownerBytes = parseAddressToBytes(ownerAddress);
+        const resolverBytes = parseAddressToBytes(resolverAddress);
+        //const paymentCoin = createPaymentCoin(paymentAmount);
+        const parentContract = await joinLeafContract(providers, parentContractAddress);
+        const result = await parentContract.callTx.register_domain_for(ownerBytes, subdomainName, resolverBytes);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to buy domain: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+/**
+ * Change domain owner (executed on domain's own contract)
+ */
+export async function changeDomainOwner(domain, newOwnerAddress, providers) {
+    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 newOwnerBytes = parseAddressToBytes(newOwnerAddress);
+        const contract = await joinLeafContract(providers, contractAddress);
+        const result = await contract.callTx.change_owner(newOwnerBytes);
+        return success({
+            transactionId: result.public.txId,
+        });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to change domain owner: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}

package/dist/provider.d.ts

@@ -1,9 +1,8 @@
-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 ProviderConfig {
     indexerUrl?: string;
     indexerWsUrl?: string;
-    networkId?: NetworkId;
+    networkId?: string;
 }
 export declare function getDefaultProvider(): PublicDataProvider;
 export declare function setDefaultProvider(provider: PublicDataProvider): void;

package/dist/provider.js

@@ -1,12 +1,11 @@
-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";
 let defaultProvider = null;
 export function getDefaultProvider() {
     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;
-        setNetworkId(networkId);
+        const indexerUrl = "https://indexer.preprod.midnight.network/api/v3/graphql";
+        const indexerWsUrl = "wss://indexer.preprod.midnight.network/api/v3/graphql/ws";
+        setNetworkId("preprod");
         defaultProvider = indexerPublicDataProvider(indexerUrl, indexerWsUrl);
     }
     return defaultProvider;
@@ -15,7 +14,7 @@ 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;
+    const { indexerUrl = "https://indexer.preprod.midnight.network/api/v3/graphql", indexerWsUrl = "wss://indexer.preprod.midnight.network/api/v3/graphql/ws", networkId = "preprod", } = config;
     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,6 +1,6 @@
 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';
@@ -69,19 +69,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));

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,6 +1,6 @@
 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';
 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%)';
@@ -37,7 +37,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 +47,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));