@midnames/sdk 0.2.1 → 1.0.1

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+export type { DomainData } from "../managed/index.js";
 export interface DomainInfo {
     owner: string;
     resolver: string;
@@ -5,51 +6,16 @@ export interface DomainInfo {
 }
 export interface DomainSettings {
     coinColor: Uint8Array;
-    domainCost: bigint;
+    costs: {
+        short: bigint;
+        medium: bigint;
+        long: bigint;
+    };
 }
 export interface DomainProfileData {
     fullDomain: string;
     resolvedTarget: string | null;
     info: DomainInfo | null;
-    fields: Array<[string, string]>;
+    fields: Map<string, string>;
     settings: DomainSettings | null;
 }
-export declare class MidNamesError extends Error {
-    readonly code: string;
-    readonly details?: unknown | undefined;
-    constructor(message: string, code: string, details?: unknown | undefined);
-}
-export declare class NetworkError extends MidNamesError {
-    constructor(message: string, details?: unknown);
-}
-export declare class ContractNotFoundError extends MidNamesError {
-    constructor(contractAddress: string, details?: unknown);
-}
-export declare class DomainNotFoundError extends MidNamesError {
-    constructor(domain: string, details?: unknown);
-}
-export declare class InvalidDomainError extends MidNamesError {
-    constructor(domain: string, reason: string, details?: unknown);
-}
-export declare class ProviderError extends MidNamesError {
-    constructor(message: string, details?: unknown);
-}
-export type Result<T, E = MidNamesError> = {
-    success: true;
-    data: T;
-} | {
-    success: false;
-    error: E;
-};
-export declare function success<T>(data: T): Result<T>;
-export declare function failure<E = MidNamesError>(error: E): Result<never, E>;
-export declare function isSuccess<T, E>(result: Result<T, E>): result is {
-    success: true;
-    data: T;
-};
-export declare function isError<T, E>(result: Result<T, E>): result is {
-    success: false;
-    error: E;
-};
-export declare function unwrap<T>(result: Result<T>): T;
-export declare function unwrapOr<T>(result: Result<T>, defaultValue: T): T;

package/dist/types.js

@@ -1,61 +1 @@
-// Error handling types
-export class MidNamesError extends Error {
-    constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'MidNamesError';
-    }
-}
-export class NetworkError extends MidNamesError {
-    constructor(message, details) {
-        super(message, 'NETWORK_ERROR', details);
-        this.name = 'NetworkError';
-    }
-}
-export class ContractNotFoundError extends MidNamesError {
-    constructor(contractAddress, details) {
-        super(`Contract not found: ${contractAddress}`, 'CONTRACT_NOT_FOUND', details);
-        this.name = 'ContractNotFoundError';
-    }
-}
-export class DomainNotFoundError extends MidNamesError {
-    constructor(domain, details) {
-        super(`Domain not found: ${domain}`, 'DOMAIN_NOT_FOUND', details);
-        this.name = 'DomainNotFoundError';
-    }
-}
-export class InvalidDomainError extends MidNamesError {
-    constructor(domain, reason, details) {
-        super(`Invalid domain "${domain}": ${reason}`, 'INVALID_DOMAIN', details);
-        this.name = 'InvalidDomainError';
-    }
-}
-export class ProviderError extends MidNamesError {
-    constructor(message, details) {
-        super(message, 'PROVIDER_ERROR', details);
-        this.name = 'ProviderError';
-    }
-}
-// Helper functions for Result type
-export function success(data) {
-    return { success: true, data };
-}
-export function failure(error) {
-    return { success: false, error };
-}
-export function isSuccess(result) {
-    return result.success;
-}
-export function isError(result) {
-    return !result.success;
-}
-export function unwrap(result) {
-    if (isSuccess(result)) {
-        return result.data;
-    }
-    throw result.error;
-}
-export function unwrapOr(result, defaultValue) {
-    return isSuccess(result) ? result.data : defaultValue;
-}
+export {};

package/dist/utils/address.js

@@ -1,5 +1,5 @@
-import { MidnightBech32m, ShieldedCoinPublicKey, ShieldedAddress } from "@midnight-ntwrk/wallet-sdk-address-format";
-import { getZswapNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
+import { MidnightBech32m, ShieldedCoinPublicKey, ShieldedAddress, ShieldedEncryptionPublicKey } from "@midnight-ntwrk/wallet-sdk-address-format";
+import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 export function bytesToHex(bytes) {
     return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
 }
@@ -11,12 +11,13 @@ export function deriveShieldedAddress(coinPublicKeyAddress, encryptionPublicKey)
         const cpkParsed = MidnightBech32m.parse(coinPublicKeyAddress);
         if (cpkParsed.type !== 'shield-cpk')
             return null;
-        const coinPublicKey = ShieldedCoinPublicKey.codec.decode(getZswapNetworkId(), cpkParsed);
+        const coinPublicKey = ShieldedCoinPublicKey.codec.decode(getNetworkId(), cpkParsed);
         const epkParsed = MidnightBech32m.parse(encryptionPublicKey);
         if (epkParsed.type !== 'shield-epk')
             return null;
-        const shieldedAddress = new ShieldedAddress(coinPublicKey, epkParsed);
-        return ShieldedAddress.codec.encode(getZswapNetworkId(), shieldedAddress).asString();
+        const encPubKey = ShieldedEncryptionPublicKey.codec.decode(getNetworkId(), epkParsed);
+        const shieldedAddress = new ShieldedAddress(coinPublicKey, encPubKey);
+        return ShieldedAddress.codec.encode(getNetworkId(), shieldedAddress).asString();
     }
     catch {
         return null;

package/dist/utils/domain.d.ts

@@ -1,3 +1,4 @@
+export declare const DEFAULT_TLD = "night";
 export declare function normalizeDomain(input: string, assumeTld?: boolean): string;
 export interface ParsedDomain {
     isValid: boolean;
@@ -13,3 +14,8 @@ export declare function getParentDomain(fullDomain: string): string | null;
 export declare function getSubdomain(fullDomain: string): string;
 export declare function isTLD(domain: string, tld?: string): boolean;
 export declare function buildFullDomain(subdomain: string, parent: string): string;
+export declare function domainToKey(name: string): {
+    key: Uint8Array;
+    len: bigint;
+};
+export declare function keyToDomain(key: Uint8Array): string;

package/dist/utils/domain.js

@@ -1,4 +1,4 @@
-const DEFAULT_TLD = 'night';
+export const DEFAULT_TLD = 'night';
 export function normalizeDomain(input, assumeTld = true) {
     const trimmedInput = input.trim().toLowerCase();
     const cleaned = trimmedInput.replace(/\.+/g, '.').replace(/\.$/, '');
@@ -55,3 +55,21 @@ export function buildFullDomain(subdomain, parent) {
         return parent;
     return `${subdomain}.${parent}`;
 }
+export function domainToKey(name) {
+    const bytes = new TextEncoder().encode(name);
+    if (bytes.length === 0 || bytes.length > 32)
+        throw new Error(`Domain name must be 1-32 bytes, got ${bytes.length}`);
+    const key = new Uint8Array(32).fill(255);
+    key.set(bytes);
+    return { key, len: BigInt(bytes.length) };
+}
+export function keyToDomain(key) {
+    let len = 32;
+    for (let i = 0; i < 32; i++) {
+        if (key[i] === 255) {
+            len = i;
+            break;
+        }
+    }
+    return new TextDecoder().decode(key.subarray(0, len));
+}

package/dist/utils/imageResolver.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves a URL to an accessible HTTP(S) URL
+ * Handles IPFS URLs (ipfs://... and bare CIDs) by converting to gateway URLs
+ * Returns HTTP(S) URLs as-is
+ * @param url - The URL to resolve
+ * @returns Promise resolving to accessible URL
+ */
+export declare function resolveImageUrl(url: string): Promise<string>;

package/dist/utils/imageResolver.js

@@ -0,0 +1,89 @@
+/**
+ * Image resolution utilities for midnames-sdk
+ * Handles IPFS URLs and converts them to accessible HTTP(S) gateway URLs
+ */
+const DEFAULT_IPFS_GATEWAYS = [
+    "https://ipfs.io/ipfs",
+    "https://4everland.io/ipfs",
+    "https://dweb.link/ipfs",
+];
+/**
+ * Validates if a string is a valid IPFS CID
+ * @param cid - The string to validate
+ * @returns true if valid CID, false otherwise
+ */
+function isValidIPFSCid(cid) {
+    if (!cid || cid.length < 10)
+        return false;
+    // Basic CIDv0 (Qm...) and CIDv1 (b...) validation
+    const cidv0Regex = /^Qm[1-9A-HJ-NP-Za-km-z]{44}$/;
+    const cidv1Regex = /^b[A-Za-z2-7]{58}$/;
+    return cidv0Regex.test(cid) || cidv1Regex.test(cid);
+}
+/**
+ * Resolves an IPFS CID to an accessible gateway URL
+ * Tests multiple gateways concurrently and returns the first working one
+ * @param cid - The IPFS CID to resolve
+ * @returns Promise resolving to gateway URL
+ */
+async function resolveIPFS(cid) {
+    const controllers = DEFAULT_IPFS_GATEWAYS.map(() => new AbortController());
+    // Race all gateways — first successful response wins
+    const racePromise = new Promise((resolve, reject) => {
+        let pending = DEFAULT_IPFS_GATEWAYS.length;
+        DEFAULT_IPFS_GATEWAYS.forEach(async (gateway, i) => {
+            const timeoutId = setTimeout(() => controllers[i].abort(), 3000);
+            try {
+                const res = await fetch(`${gateway}/${cid}`, {
+                    method: "HEAD",
+                    signal: controllers[i].signal,
+                });
+                clearTimeout(timeoutId);
+                if (res.ok) {
+                    controllers.forEach((c) => c.abort());
+                    resolve(`${gateway}/${cid}`);
+                    return;
+                }
+            }
+            catch {
+                clearTimeout(timeoutId);
+            }
+            if (--pending === 0)
+                reject();
+        });
+    });
+    try {
+        return await racePromise;
+    }
+    catch {
+        return `${DEFAULT_IPFS_GATEWAYS[0]}/${cid}`;
+    }
+}
+/**
+ * Resolves a URL to an accessible HTTP(S) URL
+ * Handles IPFS URLs (ipfs://... and bare CIDs) by converting to gateway URLs
+ * Returns HTTP(S) URLs as-is
+ * @param url - The URL to resolve
+ * @returns Promise resolving to accessible URL
+ */
+export async function resolveImageUrl(url) {
+    if (!url || !url.trim()) {
+        return "";
+    }
+    const trimmedUrl = url.trim();
+    // Return HTTP(S) URLs as-is
+    if (/^https?:\/\//i.test(trimmedUrl)) {
+        return trimmedUrl;
+    }
+    // Handle IPFS protocol URLs
+    if (trimmedUrl.startsWith("ipfs://")) {
+        const cid = trimmedUrl.replace("ipfs://", "");
+        return resolveIPFS(cid);
+    }
+    // Handle bare IPFS CIDs
+    if (isValidIPFSCid(trimmedUrl)) {
+        return resolveIPFS(trimmedUrl);
+    }
+    // For other protocols or invalid formats, return as-is
+    return trimmedUrl;
+}

package/dist/utils/sanitize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sanitizes a URL to prevent javascript: and other dangerous protocols.
+ * Returns empty string for disallowed protocols.
+ * Decodes URL-encoded characters before checking to prevent bypasses like java%73cript:
+ */
+export declare function sanitizeUrl(url: string | undefined | null): string;

package/dist/utils/sanitize.js

@@ -0,0 +1,28 @@
+const ALLOWED_PROTOCOLS = /^(https?:\/\/|ipfs:\/\/|data:image\/)/i;
+/**
+ * Sanitizes a URL to prevent javascript: and other dangerous protocols.
+ * Returns empty string for disallowed protocols.
+ * Decodes URL-encoded characters before checking to prevent bypasses like java%73cript:
+ */
+export function sanitizeUrl(url) {
+    if (!url)
+        return '';
+    const trimmed = url.trim();
+    if (!trimmed)
+        return '';
+    // Decode URL-encoded characters to catch bypasses like java%73cript:
+    let decoded;
+    try {
+        decoded = decodeURIComponent(trimmed);
+    }
+    catch {
+        decoded = trimmed;
+    }
+    // Relative URLs and protocol-relative are fine
+    if (decoded.startsWith('/') || decoded.startsWith('./'))
+        return trimmed;
+    // Allow only safe protocols (check decoded version)
+    if (ALLOWED_PROTOCOLS.test(decoded))
+        return trimmed;
+    return '';
+}

package/exported.md

@@ -103,7 +103,7 @@ export type DomainProfileWidgetProps = {
   publicDataProvider: PublicDataProvider;
   className?: string;
   showStatus?: boolean;
-  onError?: (error: MidNamesError) => void;
+  onError?: (error: MidnamesError) => void;
 }
 
 export function DomainProfileWidget(props: DomainProfileWidgetProps): JSX.Element

package/managed/index.js

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

package/managed/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,IAAI,MAAM,mCAAmC,CAAC;AAE1D,OAAO,cAAc,MAAM,mCAAmC,CAAC;AAG/D,MAAM,CAAC,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;AAC5C,MAAM,CAAC,MAAM,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC;AACxD,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAML,MAAM,EACN,QAAQ,EACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}