@midnames/sdk 0.1.8 → 0.2.1

package/dist/core.d.ts

@@ -5,18 +5,15 @@ export declare function resolveDomain(domain: string, options?: {
     provider?: PublicDataProvider;
     tldAddress?: string;
 }): Promise<Result<string>>;
-export declare function getDomainInfo(contractAddress: string, domainName: string, options?: {
+export declare function getDomainInfoInContract(contractAddress: string, domainName: string, options?: {
     provider?: PublicDataProvider;
 }): Promise<Result<DomainInfo>>;
-export declare function getDomainInfoByResolving(fullDomain: string, options?: {
+export declare function getDomainInfo(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(fullDomainName: string, options?: {
-    provider?: PublicDataProvider;
-}): Promise<Result<Array<[string, string]>>>;
 export declare function getDomainSettings(contractAddress: string, options?: {
     provider?: PublicDataProvider;
 }): Promise<Result<DomainSettings>>;

package/dist/core.js

@@ -1,6 +1,6 @@
 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 { 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';
@@ -38,14 +38,24 @@ async function queryContractStateSafely(publicDataProvider, contractAddress) {
         return failure(new ProviderError(`Failed to query contract state: ${error instanceof Error ? error.message : String(error)}`, error));
     }
 }
-async function getResolverAddress(publicDataProvider, fullDomain) {
+async function traverseDomainHierarchy(publicDataProvider, fullDomain, returnFinalTarget = false) {
     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;
+        // 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) {
@@ -53,59 +63,40 @@ async function getResolverAddress(publicDataProvider, fullDomain) {
             }
             const contractLedger = ledger(contractStateResult.data.data);
             if (!contractLedger.domains.member(part)) {
-                return failure(new DomainNotFoundError(`${part} in ${currentResolver}`));
+                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 get resolver address: ${error instanceof Error ? error.message : String(error)}`, 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 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));
+    // 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 = {}) {
+export async function getDomainInfoInContract(contractAddress, domainName, options = {}) {
     const publicDataProvider = options.provider || getDefaultProvider();
     try {
         const contractStateResult = await queryContractStateSafely(publicDataProvider, contractAddress);
@@ -124,7 +115,7 @@ export async function getDomainInfo(contractAddress, domainName, options = {}) {
         return failure(new NetworkError(`Failed to get domain info: ${error instanceof Error ? error.message : String(error)}`, error));
     }
 }
-export async function getDomainInfoByResolving(fullDomain, options = {}) {
+export async function getDomainInfo(fullDomain, options = {}) {
     const publicDataProvider = options.provider || getDefaultProvider();
     try {
         const normalizedDomain = normalizeDomain(fullDomain);
@@ -135,7 +126,7 @@ export async function getDomainInfoByResolving(fullDomain, options = {}) {
         const parentContractAddressResult = await getResolverAddress(publicDataProvider, parsed.parentDomainPath);
         if (!parentContractAddressResult.success)
             return failure(parentContractAddressResult.error);
-        const infoResult = await getDomainInfo(parentContractAddressResult.data, parsed.domainName, { provider: publicDataProvider });
+        const infoResult = await getDomainInfoInContract(parentContractAddressResult.data, parsed.domainName, { provider: publicDataProvider });
         if (!infoResult.success)
             return failure(infoResult.error);
         return success({ ...infoResult.data, contractAddress: parentContractAddressResult.data });
@@ -160,18 +151,6 @@ export async function getDomainFields(contractAddress, options = {}) {
         return failure(new NetworkError(`Failed to get domain fields: ${error instanceof Error ? error.message : String(error)}`, error));
     }
 }
-export async function getNamespacedDomainFields(fullDomainName, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    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 = options.provider || getDefaultProvider();
     try {
@@ -191,13 +170,13 @@ export async function getDomainProfile(fullDomain, options = {}) {
         const normalized = normalizeDomain(fullDomain);
         const [resolvedTargetResult, infoResult] = await Promise.all([
             resolveDomain(normalized, { provider: publicDataProvider }),
-            getDomainInfoByResolving(normalized, { provider: publicDataProvider })
+            getDomainInfo(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(normalized, { provider: publicDataProvider }),
+                getDomainFields(info.resolver, { provider: publicDataProvider }),
                 getDomainSettings(info.resolver, { provider: publicDataProvider })
             ]);
             const fields = fieldsResult.success ? fieldsResult.data : [];

package/dist/provider.d.ts

@@ -8,4 +8,3 @@ export interface ProviderConfig {
 export declare function getDefaultProvider(): PublicDataProvider;
 export declare function setDefaultProvider(provider: PublicDataProvider): void;
 export declare function createDefaultProvider(config?: ProviderConfig): PublicDataProvider;
-export declare function setupDefaultProvider(config?: ProviderConfig): PublicDataProvider;

package/dist/provider.js

@@ -3,7 +3,11 @@ import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-p
 let defaultProvider = null;
 export function getDefaultProvider() {
     if (!defaultProvider) {
-        defaultProvider = createDefaultProvider();
+        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;
 }
@@ -15,8 +19,3 @@ export function createDefaultProvider(config = {}) {
     setNetworkId(networkId);
     return indexerPublicDataProvider(indexerUrl, indexerWsUrl);
 }
-export function setupDefaultProvider(config = {}) {
-    const provider = createDefaultProvider(config);
-    setDefaultProvider(provider);
-    return provider;
-}

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/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/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';

package/exported.md

@@ -7,37 +7,32 @@ This document contains all exported functions, types, interfaces, classes, and c
 ### Core
 
 ```typescript
-export function resolveDomain(publicDataProvider: PublicDataProvider, domain: string, tldAddress?: string): Promise<Result<string>>
+export function resolveDomain(domain: string, options?: { provider?: PublicDataProvider; tldAddress?: string }): Promise<Result<string>>
 ```
 Resolves a domain name to its target address.
 
 ```typescript
-export function getDomainInfo(publicDataProvider: PublicDataProvider, contractAddress: string, domainName: string): Promise<Result<DomainInfo>>
+export function getDomainInfoInContract(contractAddress: string, domainName: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainInfo>>
 ```
 Gets information about a domain from a specific contract.
 
 ```typescript
-export function getDomainInfoByResolving(publicDataProvider: PublicDataProvider, fullDomain: string): Promise<Result<DomainInfo>>
+export function getDomainInfo(fullDomain: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainInfo>>
 ```
 Gets domain information by resolving the full domain path.
 
 ```typescript
-export function getDomainFields(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<tuple[]>>
+export function getDomainFields(contractAddress: string, options?: { provider?: PublicDataProvider }): Promise<Result<Array<[string, string]>>>
 ```
 Gets all fields stored in a domain contract.
 
 ```typescript
-export function getNamespacedDomainFields(publicDataProvider: PublicDataProvider, _parentContractAddress: string, fullDomainName: string): Promise<Result<tuple[]>>
-```
-Gets fields for a domain by resolving its full namespace path.
-
-```typescript
-export function getDomainSettings(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<DomainSettings>>
+export function getDomainSettings(contractAddress: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainSettings>>
 ```
 Gets the settings (coin color, domain cost) for a domain contract.
 
 ```typescript
-export function getDomainProfile(publicDataProvider: PublicDataProvider, fullDomain: string): Promise<Result<DomainProfileData>>
+export function getDomainProfile(fullDomain: string, options?: { provider?: PublicDataProvider }): Promise<Result<DomainProfileData>>
 ```
 Gets the complete profile data for a domain.
 

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));
+}
+
+*/