@midnames/sdk 0.1.3 → 0.1.5

package/dist/modules/info.js

@@ -0,0 +1,152 @@
+import { getZswapNetworkId } 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 { getProviderOrThrow } from '../provider.js';
+import { resolveDomain, getDefaultTldAddress } from './core.js';
+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 getDomainInfo(contractAddress, domainName, options = {}) {
+    const publicDataProvider = getProviderOrThrow(options.provider);
+    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 = getProviderOrThrow(options.provider);
+    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 = getProviderOrThrow(options.provider);
+    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(_parentContractAddress, fullDomainName, options = {}) {
+    const publicDataProvider = getProviderOrThrow(options.provider);
+    try {
+        const domainContractAddressResult = await getResolverAddress(publicDataProvider, fullDomainName);
+        if (!domainContractAddressResult.success)
+            return failure(domainContractAddressResult.error);
+        return await getDomainFields(domainContractAddressResult.data, { provider: publicDataProvider });
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to get namespaced domain fields: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+export async function getDomainSettings(contractAddress, options = {}) {
+    const publicDataProvider = getProviderOrThrow(options.provider);
+    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 = getProviderOrThrow(options.provider);
+    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([
+                getNamespacedDomainFields(info.contractAddress, normalized, { 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/provider.d.ts

@@ -0,0 +1,11 @@
+import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
+import { NetworkId } from '@midnight-ntwrk/midnight-js-network-id';
+export interface ProviderConfig {
+    indexerUrl?: string;
+    indexerWsUrl?: string;
+    networkId?: NetworkId;
+}
+export declare function setupDefaultProvider(config?: ProviderConfig): PublicDataProvider;
+export declare function setDefaultProvider(provider: PublicDataProvider): void;
+export declare function getDefaultProvider(): PublicDataProvider | null;
+export declare function getProviderOrThrow(provider?: PublicDataProvider): PublicDataProvider;

package/dist/provider.js

@@ -0,0 +1,26 @@
+import { setNetworkId, NetworkId } 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 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().');
+}

package/dist/react/DomainProfileWidget.d.ts

@@ -4,7 +4,7 @@ import type { DomainProfileData } from '../types.js';
 import { MidNamesError } from '../types.js';
 export type DomainProfileWidgetProps = {
     fullDomain: string;
-    publicDataProvider: PublicDataProvider;
+    publicDataProvider?: PublicDataProvider;
     className?: string;
     showStatus?: boolean;
     onError?: (error: MidNamesError) => void;

package/dist/react/DomainProfileWidget.js

@@ -3,7 +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 '../core.js';
+import { getDomainProfile } from '../modules/index.js';
+import { getProviderOrThrow } from '../provider.js';
 function truncate(addr, head = 10, tail = 6) {
     if (!addr)
         return 'N/A';
@@ -60,7 +61,7 @@ onFieldClick, onCopySuccess, }) {
         let mounted = true;
         setLoading(true);
         setError(null);
-        getDomainProfile(publicDataProvider, fullDomain)
+        getDomainProfile(fullDomain, { provider: getProviderOrThrow(publicDataProvider) })
             .then((d) => {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             if (mounted) {

package/dist/react/HolographicCard.d.ts

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

package/dist/react/HolographicCard.js

@@ -1,7 +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 '../core.js';
+import { getDomainProfile } from '../modules/index.js';
+import { getProviderOrThrow } 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 = {
@@ -28,7 +29,7 @@ const HolographicCardComponent = ({ domain, publicDataProvider, behindGradient,
         let mounted = true;
         setLoading(true);
         setError(null);
-        getDomainProfile(publicDataProvider, domain)
+        getDomainProfile(domain, { provider: getProviderOrThrow(publicDataProvider) })
             .then((result) => {
             var _a, _b, _c, _d;
             if (mounted) {

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -0,0 +1,3 @@
+// Utils module - domain and address utilities
+export * from './utils/domain.js';
+export * from './utils/address.js';

package/managed/index.js

@@ -0,0 +1,6 @@
+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;
+//# sourceMappingURL=index.js.map

package/managed/index.js.map

@@ -0,0 +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"}

package/managed/leaf.compact

@@ -0,0 +1,258 @@
+pragma language_version 0.17;
+/// # Unshielded Nameservice
+/// 
+/// Example:
+///     The `domain.mid` register would be deployed with
+///         - parent_domain:   "mid"
+///         - parent_resolver: "mid" resolver
+///         - target:          arbitrary
+///         - domain:          "domain"
+///         - fields for the `domain.mid` domain.
+///     The `sub.domain.mid` register would be deployed with
+///         - parent_domain:   "domain"
+///         - parent_resolver: "domain" resolver
+///         - target:          arbitrary
+///         - domain:          "sub"
+///         - fields for the `sub.domain.mid` domain.
+///     The `hyper.sub.domain.mid` register would be deployed with
+///         - parent_domain:   "sub"
+///         - parent_resolver: "sub" resolver
+///         - 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
+// The new owner should deploy a new resolver.
+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_TARGET: Either<ZswapCoinPublicKey, ContractAddress>;
+
+// Map<domain, (owner, resolver)>.
+export ledger domains: Map<Opaque<'string'>, DomainData>;
+
+// Set of domains saved here owned by address.
+export ledger domains_owned: Map<ZswapCoinPublicKey, Set<Opaque<'string'>>>;
+
+export ledger fields: Map<Opaque<'string'>, Opaque<'string'>>;
+
+
+export { DomainData, Either, Maybe, CoinInfo }
+struct DomainData {
+    owner: ZswapCoinPublicKey,
+    resolver: ContractAddress
+}
+
+
+constructor(
+    parent_domain: Maybe<Opaque<'string'>>,
+    parent_resolver: ContractAddress,
+    target: Either<ZswapCoinPublicKey, ContractAddress>,
+    domain: Maybe<Opaque<'string'>>, 
+    coin_color: Bytes<32>,
+    domain_cost: Uint<64>,
+    kvs: Vector<10, Maybe<[Opaque<'string'>, Opaque<'string'>]>>
+) {
+    DOMAIN_OWNER = ownPublicKey();
+    PARENT_DOMAIN = disclose(parent_domain);
+    PARENT_RESOLVER = disclose(parent_resolver);
+    DOMAIN_TARGET = disclose(target);
+    DOMAIN = disclose(domain);
+    COIN_COLOR = disclose(coin_color);
+    DOMAIN_COST = disclose(domain_cost);
+    for (const kv of kvs) {
+        if (disclose(kv) == none<[Opaque<'string'>, Opaque<'string'>]>()) {
+            return;
+        }
+        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
+    }
+}
+
+// =========================================== 
+//                  Circuits                  
+// =========================================== 
+
+export ledger COIN_COLOR: Bytes<32>;
+export ledger DOMAIN_COST: Uint<64>;
+
+export circuit update_color(c: Bytes<32>) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
+    COIN_COLOR = disclose(c);
+}
+
+export circuit update_cost(c: Uint<64>) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the owner");
+    DOMAIN_COST = disclose(c);
+}
+
+export circuit update_target_and_fields(
+    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;
+        }
+        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): [] {
+    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);
+
+    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'>>>);
+    }
+    domains_owned.lookup(d_owner).insert(disclose(domain));
+}
+
+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;
+        }
+        fields.insert(disclose(kv.value[0]),disclose(kv.value[1]));
+    }
+}
+
+export circuit insert_field(k: Opaque<'string'>, v: Opaque<'string'>) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    fields.insert(disclose(k),disclose(v));
+}
+
+export circuit clear_field(k: Opaque<'string'>): [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    fields.remove(disclose(k));
+}
+
+export circuit clear_all_fields(domain: Opaque<'string'>): [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain owner");
+    fields.resetToDefault();
+}
+
+export circuit register_domain_for(owner: ZswapCoinPublicKey, domain: Opaque<'string'>, resolver: ContractAddress): [] {
+    assert(!domains.member(disclose(domain)), "Domain already exists");
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the domain 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'>>>);
+    }
+    domains_owned.lookup(d_owner).insert(disclose(domain));
+}
+
+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))) {
+        domains_owned.insert(disclose(new_owner), default<Set<Opaque<'string'>>>);
+    }
+    domains_owned.lookup(disclose(new_owner)).insert(disclose(domain));
+}
+
+
+export circuit change_owner(new_owner: ZswapCoinPublicKey) : [] {
+    assert(DOMAIN_OWNER == ownPublicKey(), "Not the contract owner");
+    DOMAIN_OWNER = disclose(new_owner);
+}
+
+
+/*
+Read only, but not pure, so let's not use those
+export circuit resolve(domain: Opaque<'string'>): DomainData {
+    assert(domains.member(disclose(domain)), "Domain does not exist");
+    return domains.lookup(disclose(domain));
+}
+
+export circuit get_parent_domain(): Maybe<Opaque<'string'>> {
+    return PARENT_DOMAIN;
+}
+
+export circuit get_contract_owner(): ZswapCoinPublicKey {
+    return DOMAIN_OWNER;
+}
+
+export circuit get_domain(): Maybe<Opaque<'string'>> {
+    return DOMAIN;
+}
+
+export circuit get_domain_target(): Either<ZswapCoinPublicKey, ContractAddress> {
+    return DOMAIN_TARGET;
+}
+
+export circuit get_parent_resolver(): ContractAddress {
+    return PARENT_RESOLVER;
+}
+
+export circuit addr_owns_domain(addr: ZswapCoinPublicKey, domain: Opaque<'string'>): Boolean {
+    assert(domains_owned.member(disclose(addr)), "Address does not own domains in this register");
+    return domains_owned.lookup(disclose(addr)).member(disclose(domain));
+}
+
+*/