@midnames/sdk 1.0.0 → 1.0.1

package/dist/managed/managed/leaf/contract/index.js.map

@@ -4,5 +4,5 @@
   "sourceRoot": "../../../../",
   "sources": ["src/leaf.compact", "compiler/standard-library.compact"],
   "names": [],
-  "mappings": "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"
+  "mappings": "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"
 }

package/dist/managed/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function domainToKey(name: string): {
+    key: Uint8Array;
+    len: bigint;
+};
+export declare function keyToDomain(key: Uint8Array): string;

package/dist/managed/utils.js

@@ -0,0 +1,19 @@
+export function domainToKey(name) {
+    const bytes = new TextEncoder().encode(name);
+    if (bytes.length === 0 || bytes.length > 32)
+        throw new Error(`Domain name must be 1-32 bytes, got ${bytes.length}`);
+    const key = new Uint8Array(32).fill(255);
+    key.set(bytes);
+    return { key, len: BigInt(bytes.length) };
+}
+export function keyToDomain(key) {
+    let len = 32;
+    for (let i = 0; i < 32; i++) {
+        if (key[i] === 255) {
+            len = i;
+            break;
+        }
+    }
+    return new TextDecoder().decode(key.subarray(0, len));
+}
+//# sourceMappingURL=utils.js.map

package/dist/managed/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE;QACzC,MAAM,IAAI,KAAK,CAAC,uCAAuC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACzE,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,GAAe;IACzC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5B,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;YAAC,GAAG,GAAG,CAAC,CAAC;YAAC,MAAM;QAAC,CAAC;IACzC,CAAC;IACD,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AACxD,CAAC"}

package/dist/operations.d.ts

@@ -3,76 +3,47 @@ import { type ContractProviders } from "@midnight-ntwrk/midnight-js-contracts";
 import { Leaf } from "@midnames/ns";
 import type { Result } from "./results.js";
 export declare const leafContractInstance: CompiledContract.CompiledContract<Leaf.Contract<any, any>, any, never>;
-/**
- * Insert or update a field for a domain
- */
+export declare function buildKvs(fields: Array<[string, string]>): Array<{
+    is_some: boolean;
+    value: [string, string];
+}>;
 export declare function insertField(domain: string, key: string, value: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Clear a specific field for a domain
- */
 export declare function clearField(domain: string, key: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Clear all fields for a domain
- */
 export declare function clearAllFields(domain: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Add multiple fields to a domain in a single transaction
- * Maximum of 10 fields can be added at once
- */
 export declare function addMultipleFields(domain: string, fields: Array<[string, string]>, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Update domain target address
- */
 export declare function updateDomainTarget(domain: string, targetAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Update domain cost (subdomain pricing)
- */
-export declare function updateDomainCost(domain: string, cost: bigint, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function updateDomainColor(domain: string, color: Uint8Array, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Update domain color (accepted token type)
- */
-export declare function updateDomainColor(domain: string, colorBytes: Uint8Array, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
+export declare function updateDomainCosts(domain: string, costs: {
+    short: bigint;
+    medium: bigint;
+    long: bigint;
+}, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Transfer domain ownership (executed on parent contract)
- */
 export declare function transferDomainOwnership(parentDomain: string, subdomainName: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Set resolver for a domain (executed on parent contract)
- */
 export declare function setDomainResolver(parentDomain: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Register domain for an address (free for parent domain owner)
- */
 export declare function registerDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Buy domain for an address (requires payment)
- */
 export declare function buyDomainFor(parentDomain: string, ownerAddress: string, subdomainName: string, resolverAddress: string, _paymentAmount: bigint, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;
-/**
- * Change domain owner (executed on domain's own contract)
- */
 export declare function changeDomainOwner(domain: string, newOwnerAddress: string, providers: ContractProviders<Leaf.Contract>): Promise<Result<{
     transactionId: string;
 }>>;

package/dist/operations.js

@@ -1,13 +1,12 @@
 import { CompiledContract } from "@midnight-ntwrk/compact-js";
 import { findDeployedContract, } from "@midnight-ntwrk/midnight-js-contracts";
-// Note: Payment coin creation is no longer needed - wallet handles payment balancing automatically
 import { ShieldedCoinPublicKey, MidnightBech32m, } from "@midnight-ntwrk/wallet-sdk-address-format";
 import { isWalletAddress } from "./utils/address.js";
 import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
 import { Leaf } from "@midnames/ns";
 import { success, failure } from "./results.js";
 import { NetworkError, InvalidDomainError } from "./errors.js";
-import { normalizeDomain, parseFullDomain } from "./utils/domain.js";
+import { normalizeDomain, parseFullDomain, domainToKey } from "./utils/domain.js";
 import { getDomainInfo } from "./core.js";
 function validateDomain(domain) {
     const normalized = normalizeDomain(domain);
@@ -19,7 +18,6 @@ function validateDomain(domain) {
 }
 // Contract types and instances
 export const leafContractInstance = CompiledContract.make("leaf-contract", Leaf.Contract).pipe(CompiledContract.withVacantWitnesses, CompiledContract.withCompiledFileAssets("./managed/leaf"));
-// Helper function to join a leaf contract
 async function joinLeafContract(providers, contractAddress) {
     return await findDeployedContract(providers, {
         contractAddress,
@@ -28,16 +26,43 @@ async function joinLeafContract(providers, contractAddress) {
         initialPrivateState: { phantom: false },
     });
 }
-// Helper to parse address to bytes format
+// --- Shared helpers ---
+async function withLeafContract(domain, providers, label, fn) {
+    const validated = validateDomain(domain);
+    if (!validated.success)
+        return failure(validated.error);
+    try {
+        const domainInfoResult = await getDomainInfo(validated.data, {
+            provider: providers.publicDataProvider,
+        });
+        if (!domainInfoResult.success) {
+            return failure(domainInfoResult.error);
+        }
+        const contractAddress = domainInfoResult.data.resolver;
+        const contract = await joinLeafContract(providers, contractAddress);
+        const result = await fn(contract, domainInfoResult.data);
+        return success(result);
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to ${label}: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}
+function txId(result) {
+    return { transactionId: result.public.txId };
+}
+export function buildKvs(fields) {
+    return Array.from({ length: 10 }, (_, i) => ({
+        is_some: i < fields.length,
+        value: i < fields.length ? fields[i] : ["", ""],
+    }));
+}
 function parseAddressToBytes(address) {
     if (isWalletAddress(address)) {
-        // Wallet address (mn_ prefix)
         const bech32Parsed = MidnightBech32m.parse(address);
         const coinPublicKey = ShieldedCoinPublicKey.codec.decode(getNetworkId(), bech32Parsed);
         return { bytes: new Uint8Array(coinPublicKey.data) };
     }
     else {
-        // Contract address (64-char hex string) - strip 0200 prefix for backward compat
         let hexString = address;
         if (address.startsWith("0200")) {
             hexString = address.slice(4);
@@ -46,376 +71,67 @@ function parseAddressToBytes(address) {
         return { bytes: bytes.length === 32 ? bytes : bytes.subarray(-32) };
     }
 }
-// Helper to format target address for contract calls
-function formatTargetAddress(address) {
-    if (isWalletAddress(address)) {
-        // Wallet address (mn_ prefix)
-        return {
-            tag: "Left",
-            value: parseAddressToBytes(address),
-        };
-    }
-    else {
-        // Contract address (64-char hex string)
-        return {
-            tag: "Right",
-            value: parseAddressToBytes(address),
-        };
-    }
-}
-// Helper to create target Either for contract calls
-function createTargetEither(target) {
-    return target.tag === "Left"
-        ? {
-            is_left: true,
-            left: target.value,
-            right: { bytes: new Uint8Array(32) },
-        }
-        : {
-            is_left: false,
-            left: { bytes: new Uint8Array(32) },
-            right: target.value,
-        };
+function formatTargetForContract(address) {
+    const parsed = parseAddressToBytes(address);
+    const isLeft = isWalletAddress(address);
+    return {
+        is_left: isLeft,
+        left: isLeft ? parsed : { bytes: new Uint8Array(32) },
+        right: isLeft ? { bytes: new Uint8Array(32) } : parsed,
+    };
 }
-// Note: Payment coin creation is no longer needed
-// The wallet handles payment balancing automatically when using register_domain_for
-/**
- * Insert or update a field for a domain
- */
+// --- Domain operations ---
 export async function insertField(domain, key, value, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.insert_field(key, value);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to insert field: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(domain, providers, "insert field", async (contract) => txId(await contract.callTx.insert_field(key, value)));
 }
-/**
- * Clear a specific field for a domain
- */
 export async function clearField(domain, key, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.clear_field(key);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to clear field: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(domain, providers, "clear field", async (contract) => txId(await contract.callTx.clear_field(key)));
 }
-/**
- * Clear all fields for a domain
- */
 export async function clearAllFields(domain, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const domainName = validated.data.split(".")[0];
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.clear_all_fields(domainName);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to clear all fields: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(domain, providers, "clear all fields", async (contract) => txId(await contract.callTx.clear_all_fields()));
 }
-/**
- * Add multiple fields to a domain in a single transaction
- * Maximum of 10 fields can be added at once
- */
 export async function addMultipleFields(domain, fields, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        if (fields.length === 0) {
-            return failure(new NetworkError("No fields provided"));
-        }
-        if (fields.length > 10) {
-            return failure(new NetworkError("Maximum of 10 fields can be added at once"));
-        }
-        // Convert to the Vector<10, Maybe<[string, string]>> format
-        const kvs = [];
-        for (let i = 0; i < 10; i++) {
-            if (i < fields.length) {
-                kvs.push({
-                    is_some: true,
-                    value: fields[i],
-                });
-            }
-            else {
-                kvs.push({
-                    is_some: false,
-                    value: ["", ""], // Empty strings for unused slots
-                });
-            }
-        }
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.add_multiple_fields(kvs);
-        return success({
-            transactionId: result.public.txId,
-        });
+    if (fields.length === 0) {
+        return failure(new NetworkError("No fields provided"));
     }
-    catch (error) {
-        return failure(new NetworkError(`Failed to add multiple fields: ${error instanceof Error ? error.message : String(error)}`, error));
+    if (fields.length > 10) {
+        return failure(new NetworkError("Maximum of 10 fields can be added at once"));
     }
+    return withLeafContract(domain, providers, "add multiple fields", async (contract) => txId(await contract.callTx.add_multiple_fields(buildKvs(fields))));
 }
-/**
- * Update domain target address
- */
 export async function updateDomainTarget(domain, targetAddress, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const targetFormatted = formatTargetAddress(targetAddress);
-        const targetEither = createTargetEither(targetFormatted);
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.update_domain_target(targetEither);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to update domain target: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(domain, providers, "update domain target", async (contract) => txId(await contract.callTx.update_domain_target(formatTargetForContract(targetAddress))));
 }
-/**
- * Update domain cost (subdomain pricing)
- */
-export async function updateDomainCost(domain, cost, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        if (cost < BigInt(0)) {
-            return failure(new NetworkError("Cost must be non-negative"));
-        }
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.update_cost(cost);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to update domain cost: ${error instanceof Error ? error.message : String(error)}`, error));
+export async function updateDomainColor(domain, color, providers) {
+    if (color.length !== 32) {
+        return failure(new NetworkError("Color must be exactly 32 bytes"));
     }
+    return withLeafContract(domain, providers, "update domain color", async (contract) => txId(await contract.callTx.update_color(color)));
 }
-/**
- * Update domain color (accepted token type)
- */
-export async function updateDomainColor(domain, colorBytes, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        if (colorBytes.length !== 32) {
-            return failure(new NetworkError("Color must be exactly 32 bytes"));
-        }
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.update_color(colorBytes);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to update domain color: ${error instanceof Error ? error.message : String(error)}`, error));
+export async function updateDomainCosts(domain, costs, providers) {
+    if (costs.short < BigInt(0) || costs.medium < BigInt(0) || costs.long < BigInt(0)) {
+        return failure(new NetworkError("Costs must be non-negative"));
     }
+    return withLeafContract(domain, providers, "update domain costs", async (contract) => txId(await contract.callTx.update_costs(costs.short, costs.medium, costs.long)));
 }
-/**
- * Transfer domain ownership (executed on parent contract)
- */
 export async function transferDomainOwnership(parentDomain, subdomainName, newOwnerAddress, providers) {
-    const validated = validateDomain(parentDomain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const parentContractAddress = domainInfoResult.data.resolver;
-        const newOwnerBytes = parseAddressToBytes(newOwnerAddress);
-        const parentContract = await joinLeafContract(providers, parentContractAddress);
-        const result = await parentContract.callTx.transfer_domain(subdomainName, newOwnerBytes);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to transfer domain ownership: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(parentDomain, providers, "transfer domain ownership", async (contract) => txId(await contract.callTx.transfer_domain(domainToKey(subdomainName).key, parseAddressToBytes(newOwnerAddress))));
 }
-/**
- * Set resolver for a domain (executed on parent contract)
- */
 export async function setDomainResolver(parentDomain, subdomainName, resolverAddress, providers) {
-    const validated = validateDomain(parentDomain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const parentContractAddress = domainInfoResult.data.resolver;
-        const resolverBytes = parseAddressToBytes(resolverAddress);
-        const parentContract = await joinLeafContract(providers, parentContractAddress);
-        const result = await parentContract.callTx.set_resolver(subdomainName, resolverBytes);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to set domain resolver: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(parentDomain, providers, "set domain resolver", async (contract) => txId(await contract.callTx.set_resolver(domainToKey(subdomainName).key, parseAddressToBytes(resolverAddress))));
 }
-/**
- * Register domain for an address (free for parent domain owner)
- */
 export async function registerDomainFor(parentDomain, ownerAddress, subdomainName, resolverAddress, providers) {
-    const validated = validateDomain(parentDomain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const parentContractAddress = domainInfoResult.data.resolver;
-        const ownerBytes = parseAddressToBytes(ownerAddress);
-        const resolverBytes = parseAddressToBytes(resolverAddress);
-        const parentContract = await joinLeafContract(providers, parentContractAddress);
-        const result = await parentContract.callTx.register_domain_for(ownerBytes, subdomainName, resolverBytes);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to register domain: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(parentDomain, providers, "register domain", async (contract) => {
+        const { key, len } = domainToKey(subdomainName);
+        return txId(await contract.callTx.register_domain_for(parseAddressToBytes(ownerAddress), key, len, parseAddressToBytes(resolverAddress)));
+    });
 }
-/**
- * Buy domain for an address (requires payment)
- */
 export async function buyDomainFor(parentDomain, ownerAddress, subdomainName, resolverAddress, _paymentAmount, providers) {
-    const validated = validateDomain(parentDomain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const parentContractAddress = domainInfoResult.data.resolver;
-        const ownerBytes = parseAddressToBytes(ownerAddress);
-        const resolverBytes = parseAddressToBytes(resolverAddress);
-        //const paymentCoin = createPaymentCoin(paymentAmount);
-        const parentContract = await joinLeafContract(providers, parentContractAddress);
-        const result = await parentContract.callTx.register_domain_for(ownerBytes, subdomainName, resolverBytes);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to buy domain: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(parentDomain, providers, "buy domain", async (contract) => {
+        const { key, len } = domainToKey(subdomainName);
+        return txId(await contract.callTx.register_domain_for(parseAddressToBytes(ownerAddress), key, len, parseAddressToBytes(resolverAddress)));
+    });
 }
-/**
- * Change domain owner (executed on domain's own contract)
- */
 export async function changeDomainOwner(domain, newOwnerAddress, providers) {
-    const validated = validateDomain(domain);
-    if (!validated.success)
-        return failure(validated.error);
-    try {
-        const domainInfoResult = await getDomainInfo(validated.data, {
-            provider: providers.publicDataProvider,
-        });
-        if (!domainInfoResult.success) {
-            return failure(domainInfoResult.error);
-        }
-        const contractAddress = domainInfoResult.data.resolver;
-        const newOwnerBytes = parseAddressToBytes(newOwnerAddress);
-        const contract = await joinLeafContract(providers, contractAddress);
-        const result = await contract.callTx.change_owner(newOwnerBytes);
-        return success({
-            transactionId: result.public.txId,
-        });
-    }
-    catch (error) {
-        return failure(new NetworkError(`Failed to change domain owner: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+    return withLeafContract(domain, providers, "change domain owner", async (contract) => txId(await contract.callTx.change_owner(parseAddressToBytes(newOwnerAddress))));
 }

package/dist/provider.d.ts

@@ -1,9 +1,16 @@
 import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
+export interface NetworkConfig {
+    indexerUrl: string;
+    indexerWsUrl: string;
+    tldAddress: string;
+}
+export declare const NETWORK_REGISTRY: Record<string, NetworkConfig>;
 export interface ProviderConfig {
     indexerUrl?: string;
     indexerWsUrl?: string;
     networkId?: string;
 }
-export declare function getDefaultProvider(): PublicDataProvider;
+export declare function getNetworkConfig(networkId: string): NetworkConfig;
+export declare function getDefaultProvider(networkId?: string): PublicDataProvider;
 export declare function setDefaultProvider(provider: PublicDataProvider): void;
 export declare function createDefaultProvider(config?: ProviderConfig): PublicDataProvider;