@midnames/sdk 0.2.1 → 1.0.0

package/dist/results.d.ts

@@ -0,0 +1,38 @@
+import { MidnamesError } from "./errors.js";
+export type Result<T, E = MidnamesError> = {
+    success: true;
+    data: T;
+    error?: never;
+} | {
+    success: false;
+    data?: never;
+    error: E;
+};
+export declare function success<T, E = MidnamesError>(data: T): Result<T, E>;
+export declare function failure<E = MidnamesError>(error: E): Result<never, E>;
+export declare function match<T, E, U>(result: Result<T, E>, patterns: {
+    success: (data: T) => U;
+    error: (error: E) => U;
+}): U;
+export declare function map<T, U, E>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
+export declare function flatMap<T, U, E>(result: Result<T, E>, fn: (data: T) => Result<U, E>): Result<U, E>;
+export declare function mapError<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+export declare function recover<T, E>(result: Result<T, E>, fn: (error: E) => T): Result<T, never>;
+export declare function wrapAsync<T>(asyncFn: () => Promise<T>): Promise<Result<T>>;
+export declare class ResultChain<T, E = MidnamesError> {
+    private result;
+    constructor(result: Result<T, E>);
+    map<U>(fn: (data: T) => U): ResultChain<U, E>;
+    flatMap<U>(fn: (data: T) => Result<U, E>): ResultChain<U, E>;
+    mapError<F>(fn: (error: E) => F): ResultChain<T, F>;
+    recover(fn: (error: E) => T): ResultChain<T, never>;
+    match<U>(patterns: {
+        success: (data: T) => U;
+        error: (error: E) => U;
+    }): U;
+    unwrap(): Result<T, E>;
+}
+export declare function chain<T, E = MidnamesError>(result: Result<T, E>): ResultChain<T, E>;
+export declare function combine<T extends readonly unknown[], E>(results: {
+    [K in keyof T]: Result<T[K], E>;
+}): Result<T, E>;

package/dist/results.js

@@ -0,0 +1,88 @@
+import { MidnamesError } from "./errors.js";
+// Helper functions for Result type
+export function success(data) {
+    return { success: true, data };
+}
+export function failure(error) {
+    return { success: false, error };
+}
+// Enhanced pattern matching for Results
+export function match(result, patterns) {
+    if (result.success) {
+        return patterns.success(result.data);
+    }
+    else {
+        return patterns.error(result.error);
+    }
+}
+// Transform success value, keep error unchanged
+export function map(result, fn) {
+    return result.success
+        ? success(fn(result.data))
+        : result;
+}
+// Chain operations that can fail
+export function flatMap(result, fn) {
+    return result.success ? fn(result.data) : result;
+}
+// Transform error, keep success unchanged
+export function mapError(result, fn) {
+    return result.success ? result : failure(fn(result.error));
+}
+// Recover from error with a fallback value
+export function recover(result, fn) {
+    return result.success ? result : success(fn(result.error));
+}
+// Async result helpers
+export async function wrapAsync(asyncFn) {
+    try {
+        const data = await asyncFn();
+        return success(data);
+    }
+    catch (error) {
+        if (error instanceof MidnamesError) {
+            return failure(error);
+        }
+        return failure(new MidnamesError(error instanceof Error ? error.message : String(error), "UNKNOWN_ERROR", error));
+    }
+}
+// Chainable Result class for fluent API
+export class ResultChain {
+    constructor(result) {
+        this.result = result;
+    }
+    map(fn) {
+        return new ResultChain(map(this.result, fn));
+    }
+    flatMap(fn) {
+        return new ResultChain(flatMap(this.result, fn));
+    }
+    mapError(fn) {
+        return new ResultChain(mapError(this.result, fn));
+    }
+    recover(fn) {
+        return new ResultChain(recover(this.result, fn));
+    }
+    match(patterns) {
+        return match(this.result, patterns);
+    }
+    unwrap() {
+        return this.result;
+    }
+}
+// Helper function to start chain
+export function chain(result) {
+    return new ResultChain(result);
+}
+// Combine multiple Results
+export function combine(results) {
+    const data = [];
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (!result.success) {
+            return result;
+        }
+        data[i] = result.data;
+    }
+    return success(data);
+}

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+export type { DomainData } from "../managed/index.js";
 export interface DomainInfo {
     owner: string;
     resolver: string;
@@ -11,45 +12,6 @@ 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;

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(/\.$/, '');

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) {
+    return new Promise(async (resolve) => {
+        let resolved = false;
+        let successCount = 0;
+        let totalGateways = DEFAULT_IPFS_GATEWAYS.length;
+        // Test each gateway concurrently
+        DEFAULT_IPFS_GATEWAYS.forEach(async (gateway) => {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 3000);
+                const res = await fetch(`${gateway}/${cid}`, {
+                    method: "HEAD",
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (res.ok && !resolved) {
+                    resolved = true;
+                    resolve(`${gateway}/${cid}`);
+                    return;
+                }
+            }
+            catch (error) {
+                // Gateway failed, continue to next
+            }
+            successCount++;
+            // If all failed, use fallback
+            if (successCount === totalGateways && !resolved) {
+                resolved = true;
+                resolve(`${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/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,16 @@
-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 Registry from "./managed/registry/contract/index.cjs";
+export * as Resolver from "./managed/resolver/contract/index.cjs";
+export * as UnifiedDomain from "./managed/unified-domain/contract/index.cjs";
+export * as NS from "./managed/ns/contract/index.cjs";
+export * from "./witnesses.js";
+export { type RegistryRecord } from "./managed/registry/contract/index.cjs";
+export { type ResolutionData } from "./managed/resolver/contract/index.cjs";
+export { type DomainData as UnifiedDomainData } from "./managed/unified-domain/contract/index.cjs";
+export {
+  type DomainData,
+  type DomainReference,
+} from "./managed/ns/contract/index.cjs";
+ */
+export * as Leaf from "./managed/leaf/contract/index.js";
+export { ledger, Contract } from "./managed/leaf/contract/index.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;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAML,MAAM,EACN,QAAQ,EACT,MAAM,yBAAyB,CAAC"}

package/managed/leaf.compact

@@ -1,6 +1,6 @@
-pragma language_version 0.17;
+pragma language_version 0.20;
 /// # Unshielded Nameservice
-/// 
+///
 /// Example:
 ///     The `domain.mid` register would be deployed with
 ///         - parent_domain:   "mid"
@@ -20,8 +20,8 @@ pragma language_version 0.17;
 ///         - target:          arbitrary
 ///         - domain:          "hyper"
 ///         - fields for the `hyper.sub.domain.mid` domain.
-///         
-/// 
+///
+///
 import CompactStandardLibrary;
 
 // This is sealed. If the domain is sold in the parent contract
@@ -30,8 +30,8 @@ export sealed ledger PARENT_DOMAIN: Maybe<Opaque<'string'>>;
 export sealed ledger PARENT_RESOLVER: ContractAddress;
 export sealed ledger DOMAIN: Maybe<Opaque<'string'>>;
 
-export ledger DOMAIN_OWNER: ZswapCoinPublicKey; 
-// This domain could target either a wallet or a contract 
+export ledger DOMAIN_OWNER: ZswapCoinPublicKey;
+// This domain could target either a wallet or a contract
 export ledger DOMAIN_TARGET: Either<ZswapCoinPublicKey, ContractAddress>;
 
 // Map<domain, (owner, resolver)>.
@@ -43,7 +43,7 @@ export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Opaque<'string'>>>;
 export ledger fields: Map<Opaque<'string'>, Opaque<'string'>>;
 
 
-export { DomainData, Either, Maybe, CoinInfo }
+export { DomainData, Either, Maybe }
 struct DomainData {
     owner: ZswapCoinPublicKey,
     resolver: ContractAddress
@@ -54,9 +54,9 @@ constructor(
     parent_domain: Maybe<Opaque<'string'>>,
     parent_resolver: ContractAddress,
     target: Either<ZswapCoinPublicKey, ContractAddress>,
-    domain: Maybe<Opaque<'string'>>, 
+    domain: Maybe<Opaque<'string'>>,
     coin_color: Bytes<32>,
-    domain_cost: Uint<64>,
+    domain_cost: Uint<128>,
     kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
 ) {
     DOMAIN_OWNER = ownPublicKey();
@@ -67,19 +67,18 @@ constructor(
     COIN_COLOR = disclose(coin_color);
     DOMAIN_COST = disclose(domain_cost);
     for (const kv of kvs) {
-        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
-            return;
+        if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
         }
-        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
     }
 }
 
-// =========================================== 
-//                  Circuits                  
-// =========================================== 
+// ===========================================
+//                  Circuits
+// ===========================================
 
 export ledger COIN_COLOR: Bytes<32>;
-export ledger DOMAIN_COST: Uint<64>;
+export ledger DOMAIN_COST: Uint<128>;
 
 export circuit update_color(c: Bytes<32>) : [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
@@ -92,39 +91,32 @@ export circuit update_cost(c: Uint<64>) : [] {
 }
 
 export circuit update_target_and_fields(
-    new_target: Either<ZswapCoinPublicKey, ContractAddress>,  
+    new_target: Either<ZswapCoinPublicKey, ContractAddress>,
     kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
 ) : [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
     for (const kv of kvs) {
-        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
-            return;
+        if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
         }
-        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
     }
         DOMAIN_TARGET = disclose(new_target);
 
 }
 
-export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress, payment: CoinInfo): [] {
+export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress): [] {
     assert(!domains.member(disclose(domain)), "Domain already exists");
 
-    const d_payment = disclose(payment);
-    assert(d_payment.value == DOMAIN_COST, "Wrong amount");
-    assert(d_payment.color == COIN_COLOR, "Wrong coin");
-    receive(d_payment);
-    sendImmediate(d_payment, left<ZswapCoinPublicKey, ContractAddress>(DOMAIN_OWNER), DOMAIN_COST);
-    
-    const d_owner = disclose(owner);
+    // receiveUnshielded(COIN_COLOR, DOMAIN_COST);
+    // sendUnshielded(COIN_COLOR, DOMAIN_COST, right<ContractAddress, UserAddress>(UserAddress { bytes: DOMAIN_OWNER.bytes }));
 
-    const domain_data = DomainData {
+    const d_owner = disclose(owner);
+        const domain_data = DomainData {
         d_owner,
         disclose(resolver)
     };
-    
-    domains.insert(disclose(domain), disclose(domain_data));
-    
-    // Track domains owned by address
+        domains.insert(disclose(domain), disclose(domain_data));
+        // Track domains owned by address
     if (!domains_owned.member(d_owner)) {
         domains_owned.insert(d_owner, default<Set<Opaque<'string'>>>);
     }
@@ -134,10 +126,9 @@ export circuit buy_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'
 export circuit add_multiple_fields(kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>) : [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
     for (const kv of kvs) {
-        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
-            return;
+        if (disclose(kv) != none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
         }
-        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
     }
 }
 
@@ -160,14 +151,14 @@ export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'st
     assert(!domains.member(disclose(domain)), "Domain already exists");
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
 
-    const d_owner = disclose(owner); 
+    const d_owner = disclose(owner);
     const domain_data = DomainData {
         d_owner,
         disclose(resolver)
     };
-    
+
     domains.insert(disclose(domain), disclose(domain_data));
-    
+
     // Track domains owned by address
     if (!domains_owned.member(d_owner)) {
         domains_owned.insert(d_owner, default<Set<Opaque<'string'>>>);
@@ -177,37 +168,37 @@ export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'st
 
 export circuit set_resolver(domain: Opaque<'string'>, resolver: ContractAddress): [] {
     assert(domains.member(disclose(domain)), "Domain does not exist");
-    
+
     const current_data = domains.lookup(disclose(domain));
     assert(current_data.owner == ownPublicKey(), "Not the domain owner");
-    
+
     const new_data = DomainData {
         current_data.owner,
         disclose(resolver)
     };
-    
+
     domains.insert(disclose(domain), disclose(new_data));
 }
 
 export circuit update_domain_target(new_target: Either<ZswapCoinPublicKey, ContractAddress>): [] {
     assert(DOMAIN_OWNER == ownPublicKey(), "Not the contract owner");
-    
+
     DOMAIN_TARGET = disclose(new_target);
 }
 
 export circuit transfer_domain(domain: Opaque<'string'>, new_owner: ZswapCoinPublicKey): [] {
     assert(domains.member(disclose(domain)), "Domain does not exist");
-    
+
     const current_data = domains.lookup(disclose(domain));
     assert(current_data.owner == ownPublicKey(), "Not the domain owner");
-    
+
     const new_data = DomainData {
         disclose(new_owner),
         current_data.resolver
     };
-    
+
     domains.insert(disclose(domain), disclose(new_data));
-    
+
     // Update ownership tracking
     domains_owned.lookup(ownPublicKey()).remove(disclose(domain));
     if (!domains_owned.member(disclose(new_owner))) {
@@ -255,4 +246,4 @@ export circuit addr_owns_domain(addr: ZswapCoinPublicKey, domain: Opaque<'string
     return domains_owned.lookup(disclose(addr)).member(disclose(domain));
 }
 
-*/
+*/