@midnames/sdk 0.1.7 → 0.2.0

package/README.md

@@ -1,114 +1,46 @@
 ># @midnames/sdk
 
-SDK to resolve Midnames domains and render profile widgets with a clean, provider-optional API.
+SDK to resolve Midnames domains, and render a profile widget.
 
-## Quick Start
+## Build
 
-```ts
-import { getDomainProfile, setupDefaultProvider } from '@midnames/sdk';
+Run the `build` script with `npm`, `bun`, etc.
 
-// One-liner setup with testnet defaults
-setupDefaultProvider();
+## Usage
 
-// Now use functions without provider
-const result = await getDomainProfile('alice.night');
-if (result.success) {
-  console.log(result.data.fields);
-}
-```
+Resolve a domain:
 
-## Installation
+```ts
+import { resolveDomain, getDomainProfile } from '@midnames/sdk';
+import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
 
-```bash
-npm install @midnames/sdk
+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);
+}
 ```
 
-## Usage Examples
-
-### Basic Usage
-
-```ts
-import { resolveDomain, getDomainProfile, setupDefaultProvider } from '@midnames/sdk';
-
-// Setup once
-setupDefaultProvider();
+React widget:
 
-// Use without provider
-const target = await resolveDomain('alice.night');
-const profile = await getDomainProfile('alice.night');
+```tsx
+import '@midnames/sdk/styles.css';
+import { DomainProfileWidget } from '@midnames/sdk/react';
 
-if (profile.success) {
-  console.log('Domain:', profile.data.fullDomain);
-  console.log('Owner:', profile.data.info?.owner);
-  console.log('Fields:', profile.data.fields);
-}
+<DomainProfileWidget fullDomain="id.alice.night" publicDataProvider={provider} />
 ```
 
-### Custom Provider
+Fields recognized for display: `name`, `bio`, `avatar`, `banner`, `website`, `twitter`, `github`, `location`, and `epk`.
 
-```ts
-import { getDomainProfile, setupDefaultProvider, setDefaultProvider } from '@midnames/sdk';
+## API
 
-// Manually create and set your own provider
-setupDefaultProvider({
-  indexerUrl: 'https://custom-indexer.com',
-  indexerWsUrl: 'wss://custom-indexer.com'
-});
+- `resolveDomain(provider, domain): Promise<string|null>`
+- `getDomainProfile(provider, fullDomain): Promise<{ fullDomain, resolvedTarget, info, fields, settings }>`
 
-// Or pass per-call
-const profile = await getDomainProfile('alice.night', { provider });
+```ts
+export interface DomainInfo { owner: string; resolver: string; contractAddress?: string; }
+export interface DomainSettings { coinColor: Uint8Array; domainCost: bigint; }
 ```
 
-### React Widget
-
-```tsx
-import '@midnames/sdk/styles.css';
-import { DomainProfileWidget, HolographicCard } from '@midnames/sdk/react';
-import { setupDefaultProvider } from '@midnames/sdk';
-
-// Setup provider once globally
-setupDefaultProvider();
-
-// Now widgets work without provider prop
-<DomainProfileWidget 
-  fullDomain="alice.night" 
-  variant="compact"
-  showStatus={true}
-/>
-
-<HolographicCard 
-  domain="alice.night"
-  enableTilt={true}
-/>
-
-// Or pass custom provider
-<DomainProfileWidget 
-  fullDomain="alice.night" 
-  publicDataProvider={customProvider}
-/>
-```
+Notes: Uses TestNet TLD contract by default. Provide a custom TLD address in `resolveDomain` if needed.
 
-## Widget Configuration
-
-The React widget recognizes these profile fields:
-- `name`, `bio`, `avatar`, `banner`
-- `website`, `twitter`, `github`, `location`
-- `epk` (Electronic Press Kit)
-
-### Widget Props
-
-#### DomainProfileWidget
-- `fullDomain`: Domain to display (required)
-- `publicDataProvider?`: Provider (optional if default is set)
-- `variant?`: `'full' | 'compact' | 'inline' | 'minimal'`
-- `showStatus?`: Show loading/error states
-- `showBanner?`: Display banner image
-- `onError?`: Error callback
-
-#### HolographicCard
-- `domain`: Domain to display (required)
-- `publicDataProvider?`: Provider (optional if default is set)
-- `enableTilt?`: Enable 3D tilt effect
-- `behindGradient?`: Background gradient
-- `innerGradient?`: Card gradient
-- `onError?`: Error callback

package/dist/core.d.ts

@@ -1,5 +1,22 @@
-export { resolveDomain, TESTNET_TLD_ADDRESS } from './modules/core.js';
-export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
-export type { Result } from './types.js';
-export { success, failure, isSuccess, isError, unwrap, unwrapOr } from './types.js';
-export { MidNamesError, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';
+import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
+import type { DomainInfo, DomainSettings, DomainProfileData, Result } from './types.js';
+export declare const TESTNET_TLD_ADDRESS = "0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01";
+export declare function resolveDomain(domain: string, options?: {
+    provider?: PublicDataProvider;
+    tldAddress?: string;
+}): Promise<Result<string>>;
+export declare function getDomainInfo(contractAddress: string, domainName: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainInfo>>;
+export declare function getDomainInfoByResolving(fullDomain: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainInfo>>;
+export declare function getDomainFields(contractAddress: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<Array<[string, string]>>>;
+export declare function getDomainSettings(contractAddress: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainSettings>>;
+export declare function getDomainProfile(fullDomain: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<DomainProfileData>>;

package/dist/core.js

@@ -1,4 +1,191 @@
-export { resolveDomain, TESTNET_TLD_ADDRESS } from './modules/core.js';
-export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
-export { success, failure, isSuccess, isError, unwrap, unwrapOr } from './types.js';
-export { MidNamesError, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';
+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';
+import { getDefaultProvider } from './provider.js';
+const TLD = 'night';
+export const TESTNET_TLD_ADDRESS = '0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01';
+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 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(part)) {
+                return failure(new DomainNotFoundError(`${part} in ${fullDomain}`));
+            }
+            const domainData = contractLedger.domains.lookup(part);
+            const resolverBytes = domainData.resolver.bytes;
+            currentResolver = formatContractAddress(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));
+    }
+}
+async function getResolverAddress(publicDataProvider, fullDomain) {
+    return traverseDomainHierarchy(publicDataProvider, fullDomain, false);
+}
+export async function resolveDomain(domain, options = {}) {
+    const publicDataProvider = options.provider || getDefaultProvider();
+    const fullDomain = normalizeDomain(domain);
+    // Validate TLD
+    const domainParts = fullDomain.split('.');
+    if (domainParts[domainParts.length - 1] !== TLD) {
+        return failure(new InvalidDomainError(fullDomain, `Domain must end with .${TLD}`));
+    }
+    return traverseDomainHierarchy(publicDataProvider, fullDomain, true);
+}
+export async function getDomainInfo(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(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(fullDomain, options = {}) {
+    const publicDataProvider = options.provider || getDefaultProvider();
+    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(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));
+    }
+}
+export async function getDomainFields(contractAddress, 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);
+        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 getDomainSettings(contractAddress, 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);
+        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(fullDomain, options = {}) {
+    const publicDataProvider = options.provider || getDefaultProvider();
+    try {
+        const normalized = normalizeDomain(fullDomain);
+        const [resolvedTargetResult, infoResult] = await Promise.all([
+            resolveDomain(normalized, { provider: publicDataProvider }),
+            getDomainInfoByResolving(normalized, { provider: publicDataProvider })
+        ]);
+        const resolvedTarget = resolvedTargetResult.success ? resolvedTargetResult.data : null;
+        const info = infoResult.success ? infoResult.data : null;
+        if (info && info.contractAddress) {
+            const [fieldsResult, settingsResult] = await Promise.all([
+                getDomainFields(info.resolver, { provider: publicDataProvider }),
+                getDomainSettings(info.resolver, { provider: publicDataProvider })
+            ]);
+            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

@@ -1,6 +1,5 @@
 export * from './types.js';
 export * from './utils/domain.js';
 export * from './utils/address.js';
-export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
-export { resolveDomain, getDomainInfo, getDomainInfoByResolving, getDomainFields, getNamespacedDomainFields, getDomainSettings, getDomainProfile } from './modules/index.js';
-export { TESTNET_TLD_ADDRESS } from './modules/core.js';
+export * from './core.js';
+export * from './provider.js';

package/dist/index.js

@@ -1,10 +1,5 @@
-// Types and utilities
 export * from './types.js';
 export * from './utils/domain.js';
 export * from './utils/address.js';
-// Provider management
-export { setDefaultProvider, getDefaultProvider, setupDefaultProvider } from './provider.js';
-// Simplified API (provider optional)
-export { resolveDomain, getDomainInfo, getDomainInfoByResolving, getDomainFields, getNamespacedDomainFields, getDomainSettings, getDomainProfile } from './modules/index.js';
-// Constants
-export { TESTNET_TLD_ADDRESS } from './modules/core.js';
+export * from './core.js';
+export * from './provider.js';

package/dist/provider.d.ts

@@ -5,7 +5,6 @@ export interface ProviderConfig {
     indexerWsUrl?: string;
     networkId?: NetworkId;
 }
-export declare function setupDefaultProvider(config?: ProviderConfig): PublicDataProvider;
+export declare function getDefaultProvider(): PublicDataProvider;
 export declare function setDefaultProvider(provider: PublicDataProvider): void;
-export declare function getDefaultProvider(): PublicDataProvider | null;
-export declare function getProviderOrThrow(provider?: PublicDataProvider): PublicDataProvider;
+export declare function createDefaultProvider(config?: ProviderConfig): PublicDataProvider;

package/dist/provider.js

@@ -1,26 +1,21 @@
-import { setNetworkId, NetworkId } from '@midnight-ntwrk/midnight-js-network-id';
+import { NetworkId, setNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
 import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
 let defaultProvider = null;
-export function setupDefaultProvider(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;
-    // Set network ID globally
-    setNetworkId(networkId);
-    // Create the provider with testnet defaults
-    const provider = indexerPublicDataProvider(indexerUrl, indexerWsUrl);
-    // Set it as the default
-    setDefaultProvider(provider);
-    return provider;
+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);
+        defaultProvider = indexerPublicDataProvider(indexerUrl, indexerWsUrl);
+    }
+    return defaultProvider;
 }
 export function setDefaultProvider(provider) {
     defaultProvider = provider;
 }
-export function getDefaultProvider() {
-    return defaultProvider;
-}
-export function getProviderOrThrow(provider) {
-    if (provider)
-        return provider;
-    if (defaultProvider)
-        return defaultProvider;
-    throw new Error('No provider specified. Either pass a provider parameter or set a default provider using setDefaultProvider().');
+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;
+    setNetworkId(networkId);
+    return indexerPublicDataProvider(indexerUrl, indexerWsUrl);
 }

package/dist/react/DomainProfileWidget/index.d.ts

@@ -0,0 +1,2 @@
+export { DomainProfileWidget, CopyableValue } from '../DomainProfileWidget.js';
+export type { DomainProfileWidgetProps } from '../DomainProfileWidget.js';

package/dist/react/DomainProfileWidget/index.js

@@ -0,0 +1 @@
+export { DomainProfileWidget, CopyableValue } from '../DomainProfileWidget.js';

package/dist/react/DomainProfileWidget.js

@@ -3,8 +3,8 @@ import { useEffect, useMemo, useState } from 'react';
 import { MidNamesError } from '../types.js';
 import { deriveShieldedAddress } from '../utils/address.js';
 import { Copy, Check } from 'lucide-react';
-import { getDomainProfile } from '../modules/index.js';
-import { getProviderOrThrow } from '../provider.js';
+import { getDomainProfile } from '../core.js';
+import { getDefaultProvider } from '../provider.js';
 function truncate(addr, head = 10, tail = 6) {
     if (!addr)
         return 'N/A';
@@ -61,7 +61,7 @@ onFieldClick, onCopySuccess, }) {
         let mounted = true;
         setLoading(true);
         setError(null);
-        getDomainProfile(fullDomain, { provider: getProviderOrThrow(publicDataProvider) })
+        getDomainProfile(fullDomain, { provider: publicDataProvider || getDefaultProvider() })
             .then((d) => {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             if (mounted) {

package/dist/react/HolographicCard/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from '../HolographicCard.js';
+export { default as HolographicCard } from '../HolographicCard.js';
+export type { HolographicCardProps } from '../HolographicCard.js';

package/dist/react/HolographicCard/index.js

@@ -0,0 +1,2 @@
+export { default } from '../HolographicCard.js';
+export { default as HolographicCard } from '../HolographicCard.js';

package/dist/react/HolographicCard.d.ts

@@ -7,7 +7,7 @@ import { MidNamesError } from '../types.js';
 export interface HolographicCardProps {
     /** Domain name to resolve and display */
     domain: string;
-    /** Public data provider for fetching domain information (optional if default provider is set) */
+    /** Public data provider for fetching domain information */
     publicDataProvider?: PublicDataProvider;
     /** Custom CSS gradient string for the background gradient effect */
     behindGradient?: string;

package/dist/react/HolographicCard.js

@@ -1,8 +1,8 @@
 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 { getDomainProfile } from '../modules/index.js';
-import { getProviderOrThrow } from '../provider.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%)';
 const DEFAULT_INNER_GRADIENT = 'linear-gradient(145deg,#60496e8c 0%,#71C4FF44 100%)';
 const ANIMATION_CONFIG = {
@@ -29,7 +29,7 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
         let mounted = true;
         setLoading(true);
         setError(null);
-        getDomainProfile(domain, { provider: getProviderOrThrow(publicDataProvider) })
+        getDomainProfile(domain, { provider: publicDataProvider || getDefaultProvider() })
             .then((result) => {
             var _a, _b, _c, _d;
             if (mounted) {

package/dist/utils/address.d.ts

@@ -1,3 +1,4 @@
 export declare function bytesToHex(bytes: Uint8Array): string;
 export declare function formatContractAddress(bytes: Uint8Array): string;
 export declare function deriveShieldedAddress(coinPublicKeyAddress: string, encryptionPublicKey: string): string | null;
+export declare function isWalletAddress(address: string): boolean;

package/dist/utils/address.js

@@ -22,3 +22,6 @@ export function deriveShieldedAddress(coinPublicKeyAddress, encryptionPublicKey)
         return null;
     }
 }
+export function isWalletAddress(address) {
+    return address.startsWith('mn_');
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './domain.js';
+export * from './address.js';

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from './domain.js';
+export * from './address.js';