@midnames/sdk 1.0.5 → 2.0.0-rc1

package/README.md

@@ -1,46 +1,7 @@
-># @midnames/sdk
+# Midnames SDK
 
-SDK to resolve Midnames domains, and render a profile widget.
+This project integrates with the Midnight Network.
 
-## Build
-
-Run the `build` script with `npm`, `bun`, etc.
-
-## Usage
-
-Resolve a domain:
-
-```ts
-import { resolveDomain, getDomainProfile } from '@midnames/sdk';
-import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
-
-async function demo(provider: PublicDataProvider) {
-  const target = await resolveDomain(provider, 'alice.night');
-  const profile = await getDomainProfile(provider, 'id.alice.night');
-  console.log(target, profile.fields);
-}
-```
-
-React widget:
-
-```tsx
-import '@midnames/sdk/styles.css';
-import { DomainProfileWidget } from '@midnames/sdk/react';
-
-<DomainProfileWidget fullDomain="id.alice.night" publicDataProvider={provider} />
-```
-
-Fields recognized for display: `name`, `bio`, `avatar`, `banner`, `website`, `twitter`, `github`, `location`, and `epk`.
-
-## API
-
-- `resolveDomain(provider, domain): Promise<string|null>`
-- `getDomainProfile(provider, fullDomain): Promise<{ fullDomain, resolvedTarget, info, fields, settings }>`
-
-```ts
-export interface DomainInfo { owner: string; resolver: string; contractAddress?: string; }
-export interface DomainSettings { coinColor: Uint8Array; costs: { short: bigint; medium: bigint; long: bigint }; }
-```
-
-Notes: Uses TestNet TLD contract by default. Provide a custom TLD address in `resolveDomain` if needed.
+Get your `name.night` and use it instead of your wallet address. Save your profile info, integrate with dApps, and share!
 
+You can find the docs [here](https://docs.midnight.domains)

package/dist/contract.d.ts

@@ -0,0 +1,5 @@
+export * as NS from "./managed/contract/index.js";
+export { type DomainData, type DomainReference, type Maybe, type PaymentConfig, type Witnesses, type Ledger, AddressType, ledger, Contract, } from "./managed/contract/index.js";
+export { domainToKey, keyToDomain } from "./utils/domain.js";
+export { witnesses, type DNSPrivateState } from "./witnesses.js";
+export declare const MANAGED_DIR: string;

package/dist/contract.js

@@ -0,0 +1,5 @@
+export * as NS from "./managed/contract/index.js";
+export { AddressType, ledger, Contract, } from "./managed/contract/index.js";
+export { domainToKey, keyToDomain } from "./utils/domain.js";
+export { witnesses } from "./witnesses.js";
+export const MANAGED_DIR = new URL("./managed", import.meta.url).href;

package/dist/core.d.ts

@@ -1,26 +1,44 @@
 import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
-import { type DomainData } from "@midnames/ns";
-import type { DomainInfo, DomainSettings, DomainProfileData } from "./types.js";
-import { Result } from "./results.js";
-export declare const TESTNET_TLD_ADDRESS: string;
-export declare const PREVIEW_TLD_ADDRESS: string;
-export declare function queryContractStateSafely(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<any>>;
+import { AddressType } from "./contract.js";
+import type { Ledger } from "./managed/contract/index.js";
+import type { DomainInfo, DomainSettings, DomainProfileData, DomainTarget } from "./types.js";
+import { type Result } from "./results.js";
+export declare function getTargetFromDomainData(data: {
+    target: Uint8Array;
+    target_type: AddressType;
+}): DomainTarget;
+export declare function queryContractState(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<any>>;
+export declare function getContractLedger(publicDataProvider: PublicDataProvider, contractAddress?: string): Promise<Result<Ledger>>;
+/**
+ * Resolve a full domain string (e.g. "sub.example.night") to its numeric ID
+ * within the contract ledger. Returns null if any part of the path is not found.
+ */
+export declare function resolveDomainIdInLedger(contractLedger: Ledger, fullDomain: string): bigint | null;
 export declare function resolveDomain(domain: string, options?: {
     provider?: PublicDataProvider;
-    tldAddress?: string;
-}): Promise<Result<string>>;
+    contractAddress?: string;
+}): Promise<Result<DomainTarget>>;
+export declare function resolveDefault(domain: string, options?: {
+    provider?: PublicDataProvider;
+    contractAddress?: string;
+}): Promise<Result<string | DomainTarget>>;
 export declare function getDomainInfo(fullDomain: string, options?: {
     provider?: PublicDataProvider;
+    contractAddress?: string;
 }): Promise<Result<DomainInfo>>;
 export declare function getDomainFields(fullDomain: string, options?: {
     provider?: PublicDataProvider;
+    contractAddress?: string;
 }): Promise<Result<Map<string, string>>>;
 export declare function getDomainSettings(fullDomain: string, options?: {
     provider?: PublicDataProvider;
+    contractAddress?: string;
 }): Promise<Result<DomainSettings>>;
 export declare function getDomainProfile(fullDomain: string, options?: {
     provider?: PublicDataProvider;
+    contractAddress?: string;
 }): Promise<Result<DomainProfileData>>;
 export declare function getSubdomains(fullDomain: string, options?: {
     provider?: PublicDataProvider;
-}): Promise<Result<Map<string, DomainData>>>;
+    contractAddress?: string;
+}): Promise<Result<Map<string, DomainInfo>>>;

package/dist/core.js

@@ -1,283 +1,246 @@
 import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import { ShieldedCoinPublicKey } from "@midnight-ntwrk/wallet-sdk-address-format";
-import { ledger } from "@midnames/ns";
-import { formatContractAddress, bytesToHex } from "./utils/address.js";
+import { ledger, AddressType } from "./contract.js";
+import { formatContractAddress, bytesToHex, formatUnshieldedAddress } from "./utils/address.js";
 import { normalizeDomain, parseFullDomain, DEFAULT_TLD, isTLD, domainToKey, keyToDomain } from "./utils/domain.js";
 import { success, failure, wrapAsync } from "./results.js";
-import { NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, } from "./errors.js";
-import { getDefaultProvider, getNetworkConfig, NETWORK_REGISTRY } from "./provider.js";
-export const TESTNET_TLD_ADDRESS = NETWORK_REGISTRY.preprod.tldAddress;
-export const PREVIEW_TLD_ADDRESS = NETWORK_REGISTRY.preview.tldAddress;
-function getDefaultTldAddress() {
+import { ContractNotFoundError, DomainNotFoundError, InvalidDomainError, } from "./errors.js";
+import { getDefaultProvider, getNetworkConfig } from "./provider.js";
+function getDefaultContractAddress() {
     const currentNetwork = getNetworkId();
-    return getNetworkConfig(currentNetwork).tldAddress;
+    return getNetworkConfig(currentNetwork).contractAddress;
 }
-function getTargetFromLedger(contractLedger) {
-    const target = contractLedger.DOMAIN_TARGET;
-    if (target.is_left) {
-        const coinPublicKey = new ShieldedCoinPublicKey(Buffer.from(target.left.bytes));
-        return ShieldedCoinPublicKey.codec
-            .encode(getNetworkId(), coinPublicKey)
-            .asString();
-    }
-    else {
-        return formatContractAddress(target.right.bytes);
+export function getTargetFromDomainData(data) {
+    switch (data.target_type) {
+        case AddressType.ContractAddr:
+            return { type: "contract", address: formatContractAddress(data.target) };
+        case AddressType.ZswapCPKAddr: {
+            const coinPublicKey = new ShieldedCoinPublicKey(Buffer.from(data.target));
+            const address = ShieldedCoinPublicKey.codec.encode(getNetworkId(), coinPublicKey).asString();
+            return { type: "shielded", address };
+        }
+        case AddressType.UnshieldedAddr:
+            return { type: "unshielded", address: bytesToHex(data.target) };
     }
 }
-export async function queryContractStateSafely(publicDataProvider, contractAddress) {
+export async function queryContractState(publicDataProvider, contractAddress) {
     return wrapAsync(async () => {
         const contractState = await publicDataProvider.queryContractState(contractAddress);
         if (contractState == null) {
-            throw new ContractNotFoundError(contractAddress, undefined);
+            throw new ContractNotFoundError(contractAddress);
         }
         return contractState;
     });
 }
-async function traverseDomainHierarchy(publicDataProvider, fullDomain, returnFinalTarget = false) {
-    try {
-        const tldAddress = getDefaultTldAddress();
-        const domainParts = fullDomain.split(".");
-        const traversalParts = domainParts.slice(0, -1).reverse();
-        let currentResolver = tldAddress;
-        // If we're resolving the TLD itself and want the target
-        if (traversalParts.length === 0) {
-            if (returnFinalTarget) {
-                const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-                if (!contractStateResult.success)
-                    return failure(contractStateResult.error);
-                const contractLedger = ledger(contractStateResult.data.data);
-                return success(getTargetFromLedger(contractLedger));
-            }
-            return success(tldAddress);
-        }
-        // Traverse the domain hierarchy
-        for (const part of traversalParts) {
-            const contractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-            if (!contractStateResult.success) {
-                return failure(contractStateResult.error);
-            }
-            const contractLedger = ledger(contractStateResult.data.data);
-            if (!contractLedger.domains.member(domainToKey(part).key)) {
-                return failure(new DomainNotFoundError(`${part} in ${fullDomain}`));
-            }
-            const domainData = contractLedger.domains.lookup(domainToKey(part).key);
-            const resolverBytes = domainData.resolver.bytes;
-            // Use raw hex for queryContractState (no 0200 prefix)
-            currentResolver = bytesToHex(resolverBytes);
-        }
-        // Return either the final resolver address or the target it points to
-        if (returnFinalTarget) {
-            const finalContractStateResult = await queryContractStateSafely(publicDataProvider, currentResolver);
-            if (!finalContractStateResult.success)
-                return failure(finalContractStateResult.error);
-            const finalLedger = ledger(finalContractStateResult.data.data);
-            return success(getTargetFromLedger(finalLedger));
-        }
-        return success(currentResolver);
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to traverse domain hierarchy: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+export async function getContractLedger(publicDataProvider, contractAddress) {
+    const addr = contractAddress ?? getDefaultContractAddress();
+    const stateResult = await queryContractState(publicDataProvider, addr);
+    if (!stateResult.success)
+        return failure(stateResult.error);
+    return success(ledger(stateResult.data.data));
 }
-async function getResolverAddress(publicDataProvider, fullDomain) {
-    return traverseDomainHierarchy(publicDataProvider, fullDomain, false);
+/**
+ * Resolve a full domain string (e.g. "sub.example.night") to its numeric ID
+ * within the contract ledger. Returns null if any part of the path is not found.
+ */
+export function resolveDomainIdInLedger(contractLedger, fullDomain) {
+    const parts = fullDomain.split(".");
+    // Remove TLD, reverse to walk from root
+    const traversalParts = parts.slice(0, -1).reverse();
+    if (traversalParts.length === 0) {
+        return contractLedger.ROOT_ZONE_ID;
+    }
+    let parentId = contractLedger.ROOT_ZONE_ID;
+    for (const part of traversalParts) {
+        const ref = { domain: domainToKey(part).key, parent_id: parentId };
+        if (!contractLedger.name_to_id.member(ref))
+            return null;
+        parentId = contractLedger.name_to_id.lookup(ref);
+    }
+    return parentId;
 }
+// ---- Public read functions ----
 export async function resolveDomain(domain, options = {}) {
-    // Simple validation
     const normalized = normalizeDomain(domain);
     if (!normalized.endsWith(`.${DEFAULT_TLD}`)) {
-        return failure(new InvalidDomainError(domain, "Domain must end with .night", undefined));
+        return failure(new InvalidDomainError(domain, "Domain must end with .night"));
     }
-    // Use the simple wrapper
     return wrapAsync(async () => {
-        const result = await traverseDomainHierarchy(options.provider || getDefaultProvider(), normalized, true);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
+        if (!ledgerResult.success)
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const domainId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (domainId === null)
+            throw new DomainNotFoundError(normalized);
+        const domainData = contractLedger.id_to_data.lookup(domainId);
+        return getTargetFromDomainData(domainData);
     });
 }
-/** Looks up a subdomain's info (owner, resolver) within a specific parent contract. */
-async function getDomainInfoInContract(contractAddress, domainName, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    try {
-        const contractStateResult = await queryContractStateSafely(publicDataProvider, contractAddress);
-        if (!contractStateResult.success)
-            return failure(contractStateResult.error);
-        const contractLedger = ledger(contractStateResult.data.data);
-        if (!contractLedger.domains.member(domainToKey(domainName).key)) {
-            return failure(new DomainNotFoundError(domainName));
-        }
-        const domainData = contractLedger.domains.lookup(domainToKey(domainName).key);
-        const ownerCoinPublicKey = new ShieldedCoinPublicKey(Buffer.from(domainData.owner.bytes));
-        const ownerAddress = ShieldedCoinPublicKey.codec
-            .encode(getNetworkId(), ownerCoinPublicKey)
-            .asString();
-        return success({
-            owner: ownerAddress,
-            resolver: formatContractAddress(domainData.resolver.bytes),
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain info: ${error instanceof Error ? error.message : String(error)}`, error));
+export async function resolveDefault(domain, options = {}) {
+    const normalized = normalizeDomain(domain);
+    if (!normalized.endsWith(`.${DEFAULT_TLD}`)) {
+        return failure(new InvalidDomainError(domain, "Domain must end with .night"));
     }
+    return wrapAsync(async () => {
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
+        if (!ledgerResult.success)
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const domainId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (domainId === null)
+            throw new DomainNotFoundError(normalized);
+        const domainData = contractLedger.id_to_data.lookup(domainId);
+        // If there's a default field set, try to return its value
+        if (domainData.default_field.is_some) {
+            const fieldKey = domainData.default_field.value;
+            if (contractLedger.domain_fields.member(domainId) &&
+                contractLedger.domain_fields.lookup(domainId).member(fieldKey)) {
+                return contractLedger.domain_fields.lookup(domainId).lookup(fieldKey);
+            }
+        }
+        return getTargetFromDomainData(domainData);
+    });
 }
 export async function getDomainInfo(fullDomain, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    try {
-        const normalizedDomain = normalizeDomain(fullDomain);
-        const parsed = parseFullDomain(normalizedDomain);
+    const normalized = normalizeDomain(fullDomain);
+    if (!isTLD(normalized)) {
+        const parsed = parseFullDomain(normalized);
         if (!parsed.isValid) {
             return failure(new InvalidDomainError(fullDomain, "Invalid domain format"));
         }
-        const parentContractAddressResult = await getResolverAddress(publicDataProvider, parsed.parentDomainPath);
-        if (!parentContractAddressResult.success)
-            return failure(parentContractAddressResult.error);
-        const infoResult = await getDomainInfoInContract(parentContractAddressResult.data, parsed.domainName, { provider: publicDataProvider });
-        if (!infoResult.success)
-            return failure(infoResult.error);
-        return success({
-            ...infoResult.data,
-            contractAddress: parentContractAddressResult.data,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain info by resolving: ${error instanceof Error ? error.message : String(error)}`, error));
     }
-}
-async function readContractLedger(publicDataProvider, resolverAddress) {
-    const rawAddress = resolverAddress.startsWith('0200')
-        ? resolverAddress.slice(4)
-        : resolverAddress;
-    const contractStateResult = await queryContractStateSafely(publicDataProvider, rawAddress);
-    if (!contractStateResult.success)
-        return failure(contractStateResult.error);
-    return success(ledger(contractStateResult.data.data));
+    return wrapAsync(async () => {
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
+        if (!ledgerResult.success)
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const domainId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (domainId === null)
+            throw new DomainNotFoundError(normalized);
+        const domainData = contractLedger.id_to_data.lookup(domainId);
+        return {
+            id: domainId,
+            owner: bytesToHex(domainData.owner_public_key),
+            ownerAddress: formatUnshieldedAddress(domainData.owner_address.bytes),
+            target: getTargetFromDomainData(domainData),
+            targetLocked: domainData.target_locked,
+        };
+    });
 }
 export async function getDomainFields(fullDomain, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    try {
-        const normalized = normalizeDomain(fullDomain);
-        const infoResult = await getDomainInfo(normalized, { provider: publicDataProvider });
-        if (!infoResult.success)
-            return failure(infoResult.error);
-        const ledgerResult = await readContractLedger(publicDataProvider, infoResult.data.resolver);
+    const normalized = normalizeDomain(fullDomain);
+    return wrapAsync(async () => {
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
         if (!ledgerResult.success)
-            return failure(ledgerResult.error);
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const domainId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (domainId === null)
+            throw new DomainNotFoundError(normalized);
         const fields = new Map();
-        for (const [key, value] of ledgerResult.data.fields)
-            fields.set(key, value);
-        return success(fields);
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain fields: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+        if (contractLedger.domain_fields.member(domainId)) {
+            for (const [key, value] of contractLedger.domain_fields.lookup(domainId)) {
+                fields.set(key, value);
+            }
+        }
+        return fields;
+    });
 }
 export async function getDomainSettings(fullDomain, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    try {
-        const normalized = normalizeDomain(fullDomain, false);
-        // Special case: TLD itself — read settings directly from TLD contract
-        if (isTLD(normalized)) {
-            const tldAddress = getDefaultTldAddress();
-            const ledgerResult = await readContractLedger(publicDataProvider, tldAddress);
-            if (!ledgerResult.success)
-                return failure(ledgerResult.error);
-            return success({
-                coinColor: ledgerResult.data.COIN_COLOR,
-                costs: {
-                    short: ledgerResult.data.COST_SHORT,
-                    medium: ledgerResult.data.COST_MED,
-                    long: ledgerResult.data.COST_LONG,
-                },
-            });
-        }
-        // Normal case: subdomain — resolve via getDomainInfo
-        const normalizedFull = normalizeDomain(fullDomain);
-        const infoResult = await getDomainInfo(normalizedFull, { provider: publicDataProvider });
-        if (!infoResult.success)
-            return failure(infoResult.error);
-        const ledgerResult = await readContractLedger(publicDataProvider, infoResult.data.resolver);
+    const normalized = normalizeDomain(fullDomain);
+    return wrapAsync(async () => {
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
         if (!ledgerResult.success)
-            return failure(ledgerResult.error);
-        return success({
-            coinColor: ledgerResult.data.COIN_COLOR,
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const domainId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (domainId === null)
+            throw new DomainNotFoundError(normalized);
+        const data = contractLedger.id_to_data.lookup(domainId);
+        return {
+            coinColor: data.payment_config.coin_color,
             costs: {
-                short: ledgerResult.data.COST_SHORT,
-                medium: ledgerResult.data.COST_MED,
-                long: ledgerResult.data.COST_LONG,
+                short: data.payment_config.cost_short,
+                medium: data.payment_config.cost_med,
+                long: data.payment_config.cost_long,
             },
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain settings: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+            buyEnabled: data.payment_config.buy_enabled,
+            defaultField: data.default_field.is_some ? data.default_field.value : null,
+            paymentConfigLocked: data.payment_config_locked,
+        };
+    });
 }
 export async function getDomainProfile(fullDomain, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    try {
-        const normalized = normalizeDomain(fullDomain);
-        const [resolvedTargetResult, infoResult] = await Promise.all([
-            resolveDomain(normalized, { provider: publicDataProvider }),
-            getDomainInfo(normalized, { provider: publicDataProvider }),
-        ]);
-        const resolvedTarget = resolvedTargetResult.success
-            ? resolvedTargetResult.data
-            : null;
-        const info = infoResult.success ? infoResult.data : null;
-        if (info && info.resolver) {
-            const ledgerResult = await readContractLedger(publicDataProvider, info.resolver);
-            if (ledgerResult.success) {
-                const fields = new Map();
-                for (const [key, value] of ledgerResult.data.fields)
-                    fields.set(key, value);
-                const settings = {
-                    coinColor: ledgerResult.data.COIN_COLOR,
-                    costs: {
-                        short: ledgerResult.data.COST_SHORT,
-                        medium: ledgerResult.data.COST_MED,
-                        long: ledgerResult.data.COST_LONG,
-                    },
-                };
-                return success({
-                    fullDomain: normalized,
-                    resolvedTarget,
-                    info,
-                    fields,
-                    settings,
-                });
+    const normalized = normalizeDomain(fullDomain);
+    return wrapAsync(async () => {
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
+        if (!ledgerResult.success)
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const domainId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (domainId === null)
+            throw new DomainNotFoundError(normalized);
+        const domainData = contractLedger.id_to_data.lookup(domainId);
+        const info = {
+            id: domainId,
+            owner: bytesToHex(domainData.owner_public_key),
+            ownerAddress: formatUnshieldedAddress(domainData.owner_address.bytes),
+            target: getTargetFromDomainData(domainData),
+            targetLocked: domainData.target_locked,
+        };
+        const fields = new Map();
+        if (contractLedger.domain_fields.member(domainId)) {
+            for (const [key, value] of contractLedger.domain_fields.lookup(domainId)) {
+                fields.set(key, value);
             }
         }
-        return success({
-            fullDomain: normalized,
-            resolvedTarget,
-            info,
-            fields: new Map(),
-            settings: null,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get domain profile: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+        const settings = {
+            coinColor: domainData.payment_config.coin_color,
+            costs: {
+                short: domainData.payment_config.cost_short,
+                medium: domainData.payment_config.cost_med,
+                long: domainData.payment_config.cost_long,
+            },
+            buyEnabled: domainData.payment_config.buy_enabled,
+            defaultField: domainData.default_field.is_some
+                ? domainData.default_field.value
+                : null,
+            paymentConfigLocked: domainData.payment_config_locked,
+        };
+        return { fullDomain: normalized, info, fields, settings };
+    });
 }
 export async function getSubdomains(fullDomain, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    try {
-        const normalized = normalizeDomain(fullDomain);
-        const infoResult = await getDomainInfo(normalized, { provider: publicDataProvider });
-        if (!infoResult.success)
-            return failure(infoResult.error);
-        const ledgerResult = await readContractLedger(publicDataProvider, infoResult.data.resolver);
+    const normalized = normalizeDomain(fullDomain);
+    return wrapAsync(async () => {
+        const provider = options.provider || getDefaultProvider();
+        const ledgerResult = await getContractLedger(provider, options.contractAddress);
         if (!ledgerResult.success)
-            return failure(ledgerResult.error);
+            throw ledgerResult.error;
+        const contractLedger = ledgerResult.data;
+        const parentId = resolveDomainIdInLedger(contractLedger, normalized);
+        if (parentId === null)
+            throw new DomainNotFoundError(normalized);
         const subdomains = new Map();
-        for (const [name, data] of ledgerResult.data.domains) {
-            subdomains.set(keyToDomain(name), data);
+        for (const [ref, id] of contractLedger.name_to_id) {
+            if (ref.parent_id === parentId) {
+                const data = contractLedger.id_to_data.lookup(id);
+                subdomains.set(keyToDomain(ref.domain), {
+                    id,
+                    owner: bytesToHex(data.owner_public_key),
+                    ownerAddress: bytesToHex(data.owner_address.bytes),
+                    target: getTargetFromDomainData(data),
+                    targetLocked: data.target_locked,
+                });
+            }
         }
-        return success(subdomains);
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to get subdomains: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+        return subdomains;
+    });
 }
-//# sourceMappingURL=core.js.map

package/dist/errors.d.ts

@@ -15,6 +15,3 @@ export declare class DomainNotFoundError extends MidnamesError {
 export declare class InvalidDomainError extends MidnamesError {
     constructor(domain: string, reason: string, details?: unknown);
 }
-export declare class ProviderError extends MidnamesError {
-    constructor(message: string, details?: unknown);
-}