@midnames/sdk 0.1.7 → 0.1.8

package/dist/modules/core.js

@@ -1,80 +0,0 @@
-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 } from '../utils/domain.js';
-import { success, failure, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from '../types.js';
-import { getProviderOrThrow } from '../provider.js';
-const TLD = 'night';
-export const TESTNET_TLD_ADDRESS = '0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01';
-export 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));
-    }
-}
-export async function resolveDomain(domain, options = {}) {
-    const publicDataProvider = getProviderOrThrow(options.provider);
-    const tldContractAddress = options.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));
-    }
-}

package/dist/modules/index.d.ts

@@ -1,3 +0,0 @@
-export * from './core.js';
-export * from './info.js';
-export * from '../provider.js';

package/dist/modules/index.js

@@ -1,6 +0,0 @@
-// Core resolution functions
-export * from './core.js';
-// Domain info functions  
-export * from './info.js';
-// Re-export provider utilities
-export * from '../provider.js';

package/dist/modules/info.d.ts

@@ -1,20 +0,0 @@
-import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
-import type { DomainInfo, DomainSettings, DomainProfileData, Result } from '../types.js';
-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 getNamespacedDomainFields(_parentContractAddress: string, fullDomainName: 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/modules/info.js

@@ -1,152 +0,0 @@
-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/utils.d.ts

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

package/dist/utils.js

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

package/managed/index.js

@@ -1,6 +0,0 @@
-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

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

@@ -1,258 +0,0 @@
-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));
-}
-
-*/