@midnames/sdk 0.1.1

package/README.md

@@ -0,0 +1,46 @@
+># @midnames/sdk
+
+SDK to resolve Midnames domains, and render a profile widget.
+
+## 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; domainCost: bigint; }
+```
+
+Notes: Uses TestNet TLD contract by default. Provide a custom TLD address in `resolveDomain` if needed.
+

package/dist/core.d.ts

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

package/dist/core.js

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './utils/domain.js';
+export * from './utils/address.js';
+export * from './core.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './utils/domain.js';
+export * from './utils/address.js';
+export * from './core.js';

package/dist/managed/index.d.ts

@@ -0,0 +1,9 @@
+export { type DomainData as LeafDomainData } from "./leaf/contract/index.cjs";
+export * as Leaf from "./leaf/contract/index.cjs";
+import ContractModule from './leaf/contract/index.cjs';
+import type { Contract as ContractType, Witnesses } from './leaf/contract/index.cjs';
+export declare const ledger: typeof ContractModule.ledger;
+export declare const pureCircuits: ContractModule.PureCircuits;
+export declare const Contract: typeof ContractModule.Contract;
+export type Contract<T, W extends Witnesses<T> = Witnesses<T>> = ContractType<T, W>;
+export type Ledger = ContractModule.Ledger;

package/dist/managed/index.js

@@ -0,0 +1,6 @@
+export * as Leaf from "./leaf/contract/index.cjs";
+import ContractModule from './leaf/contract/index.cjs';
+export const ledger = ContractModule.ledger;
+export const pureCircuits = ContractModule.pureCircuits;
+export const { Contract } = ContractModule;
+//# sourceMappingURL=index.js.map