@midnames/sdk 0.2.1 → 1.0.1

package/dist/controller-types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Controller Types for the Nameservice SDK
+ *
+ * These types define the interface for the LeafContractController
+ * which manages domain contract interactions with RxJS observable state.
+ *
+ * Note: The full LeafContractController implementation is in the frontend
+ * module at: modules/midnight/nameservice-sdk/api/leafContractController.ts
+ */
+import type { Observable, Subject } from 'rxjs';
+/**
+ * Target address - domains can point to either a wallet (CoinPublicKey) or another contract
+ */
+export interface EitherTarget {
+    is_left: boolean;
+    left: {
+        bytes: Uint8Array;
+    };
+    right: {
+        bytes: Uint8Array;
+    };
+}
+/**
+ * Subdomain data stored in the parent contract
+ */
+export interface SubdomainData {
+    owner: {
+        bytes: Uint8Array;
+    };
+    resolver: {
+        bytes: Uint8Array;
+    };
+}
+/**
+ * Observable state for a single domain contract
+ */
+export interface DomainState {
+    contractAddress: string;
+    target: EitherTarget;
+    fields: Map<string, string>;
+    subdomains: Map<string, SubdomainData>;
+    coinColor: Uint8Array;
+    domainCost: bigint;
+}
+/**
+ * Operation status for tracking async operations
+ */
+export type OperationStatus = {
+    type: 'idle';
+} | {
+    type: 'proving';
+    message?: string;
+} | {
+    type: 'signing';
+    message?: string;
+} | {
+    type: 'submitting';
+    message?: string;
+} | {
+    type: 'complete';
+    txHash?: string;
+} | {
+    type: 'error';
+    error: Error;
+};
+/**
+ * Result of a transaction operation
+ */
+export interface TxResult {
+    txHash: string;
+    blockHeight?: bigint;
+}
+/**
+ * Derived state combining contract state with operation status
+ */
+export interface DerivedDomainState {
+    domain: DomainState | null;
+    operationStatus: OperationStatus;
+}
+/**
+ * Interface for the LeafContractController
+ *
+ * This interface defines the contract for managing domain operations.
+ * The implementation uses RxJS observables for reactive state updates.
+ */
+export interface LeafContractControllerInterface {
+    /** The contract address this controller is connected to */
+    readonly contractAddress: string;
+    /** Observable stream of domain state */
+    readonly state$: Observable<DerivedDomainState>;
+    /** Subject for operation status updates */
+    readonly operations$: Subject<OperationStatus>;
+    updateTarget(target: EitherTarget): Promise<TxResult>;
+    insertField(key: string, value: string): Promise<TxResult>;
+    clearField(key: string): Promise<TxResult>;
+    clearAllFields(): Promise<TxResult>;
+    addMultipleFields(kvs: Array<[string, string]>): Promise<TxResult>;
+    registerDomainFor(ownerCoinPublicKey: Uint8Array, domainName: string, resolverAddress: string): Promise<TxResult>;
+    transferDomain(domainName: string, newOwnerCoinPublicKey: Uint8Array): Promise<TxResult>;
+}
+/**
+ * Empty initial state constant
+ */
+export declare const emptyDomainState: DerivedDomainState;

package/dist/controller-types.js

@@ -0,0 +1,16 @@
+/**
+ * Controller Types for the Nameservice SDK
+ *
+ * These types define the interface for the LeafContractController
+ * which manages domain contract interactions with RxJS observable state.
+ *
+ * Note: The full LeafContractController implementation is in the frontend
+ * module at: modules/midnight/nameservice-sdk/api/leafContractController.ts
+ */
+/**
+ * Empty initial state constant
+ */
+export const emptyDomainState = {
+    domain: null,
+    operationStatus: { type: 'idle' },
+};

package/dist/core.d.ts

@@ -1,22 +1,26 @@
-import type { PublicDataProvider } from '@midnight-ntwrk/midnight-js-types';
-import type { DomainInfo, DomainSettings, DomainProfileData, Result } from './types.js';
-export declare const TESTNET_TLD_ADDRESS = "0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01";
+import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
+import { type DomainData } from "../managed/index.js";
+import type { DomainInfo, DomainSettings, DomainProfileData } from "./types.js";
+import { Result } from "./results.js";
+export declare const TESTNET_TLD_ADDRESS: string;
+export declare const PREVIEW_TLD_ADDRESS: string;
+export declare function queryContractStateSafely(publicDataProvider: PublicDataProvider, contractAddress: string): Promise<Result<any>>;
 export declare function resolveDomain(domain: string, options?: {
     provider?: PublicDataProvider;
     tldAddress?: string;
 }): Promise<Result<string>>;
-export declare function getDomainInfoInContract(contractAddress: string, domainName: string, options?: {
-    provider?: PublicDataProvider;
-}): Promise<Result<DomainInfo>>;
 export declare function getDomainInfo(fullDomain: string, options?: {
     provider?: PublicDataProvider;
 }): Promise<Result<DomainInfo>>;
-export declare function getDomainFields(contractAddress: string, options?: {
+export declare function getDomainFields(fullDomain: string, options?: {
     provider?: PublicDataProvider;
-}): Promise<Result<Array<[string, string]>>>;
-export declare function getDomainSettings(contractAddress: string, options?: {
+}): Promise<Result<Map<string, string>>>;
+export declare function getDomainSettings(fullDomain: string, options?: {
     provider?: PublicDataProvider;
 }): Promise<Result<DomainSettings>>;
 export declare function getDomainProfile(fullDomain: string, options?: {
     provider?: PublicDataProvider;
 }): Promise<Result<DomainProfileData>>;
+export declare function getSubdomains(fullDomain: string, options?: {
+    provider?: PublicDataProvider;
+}): Promise<Result<Map<string, DomainData>>>;

package/dist/core.js

@@ -1,47 +1,42 @@
-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, parseFullDomain } from './utils/domain.js';
-import { success, failure, NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, ProviderError } from './types.js';
-import { getDefaultProvider } from './provider.js';
-const TLD = 'night';
-export const TESTNET_TLD_ADDRESS = '0200c46ddd9a7fe134e7126132bf48d573e3e70a06fc2b82edb2c9f31584536efa01';
+import { getNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
+import { ShieldedCoinPublicKey } from "@midnight-ntwrk/wallet-sdk-address-format";
+import { ledger } from "./managed/index.js";
+import { formatContractAddress, bytesToHex } from "./utils/address.js";
+import { normalizeDomain, parseFullDomain, DEFAULT_TLD, isTLD, domainToKey, keyToDomain } from "./utils/domain.js";
+import { success, failure, wrapAsync } from "./results.js";
+import { NetworkError, ContractNotFoundError, DomainNotFoundError, InvalidDomainError, } from "./errors.js";
+import { getDefaultProvider, getNetworkConfig, NETWORK_REGISTRY } from "./provider.js";
+export const TESTNET_TLD_ADDRESS = NETWORK_REGISTRY.preprod.tldAddress;
+export const PREVIEW_TLD_ADDRESS = NETWORK_REGISTRY.preview.tldAddress;
 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.');
-    }
+    return getNetworkConfig(currentNetwork).tldAddress;
 }
 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();
+        return ShieldedCoinPublicKey.codec
+            .encode(getNetworkId(), coinPublicKey)
+            .asString();
     }
     else {
         return formatContractAddress(target.right.bytes);
     }
 }
-async function queryContractStateSafely(publicDataProvider, contractAddress) {
-    try {
+export async function queryContractStateSafely(publicDataProvider, contractAddress) {
+    return wrapAsync(async () => {
         const contractState = await publicDataProvider.queryContractState(contractAddress);
         if (contractState == null) {
-            return failure(new ContractNotFoundError(contractAddress));
+            throw new ContractNotFoundError(contractAddress, undefined);
         }
-        return success(contractState);
-    }
-    catch (error) {
-        return failure(new ProviderError(`Failed to query contract state: ${error instanceof Error ? error.message : String(error)}`, error));
-    }
+        return contractState;
+    });
 }
 async function traverseDomainHierarchy(publicDataProvider, fullDomain, returnFinalTarget = false) {
     try {
         const tldAddress = getDefaultTldAddress();
-        const domainParts = fullDomain.split('.');
+        const domainParts = fullDomain.split(".");
         const traversalParts = domainParts.slice(0, -1).reverse();
         let currentResolver = tldAddress;
         // If we're resolving the TLD itself and want the target
@@ -62,12 +57,13 @@ async function traverseDomainHierarchy(publicDataProvider, fullDomain, returnFin
                 return failure(contractStateResult.error);
             }
             const contractLedger = ledger(contractStateResult.data.data);
-            if (!contractLedger.domains.member(part)) {
+            if (!contractLedger.domains.member(domainToKey(part).key)) {
                 return failure(new DomainNotFoundError(`${part} in ${fullDomain}`));
             }
-            const domainData = contractLedger.domains.lookup(part);
+            const domainData = contractLedger.domains.lookup(domainToKey(part).key);
             const resolverBytes = domainData.resolver.bytes;
-            currentResolver = formatContractAddress(resolverBytes);
+            // Use raw hex for queryContractState (no 0200 prefix)
+            currentResolver = bytesToHex(resolverBytes);
         }
         // Return either the final resolver address or the target it points to
         if (returnFinalTarget) {
@@ -87,29 +83,40 @@ async function getResolverAddress(publicDataProvider, fullDomain) {
     return traverseDomainHierarchy(publicDataProvider, fullDomain, false);
 }
 export async function resolveDomain(domain, options = {}) {
-    const publicDataProvider = options.provider || getDefaultProvider();
-    const fullDomain = normalizeDomain(domain);
-    // Validate TLD
-    const domainParts = fullDomain.split('.');
-    if (domainParts[domainParts.length - 1] !== TLD) {
-        return failure(new InvalidDomainError(fullDomain, `Domain must end with .${TLD}`));
+    // Simple validation
+    const normalized = normalizeDomain(domain);
+    if (!normalized.endsWith(`.${DEFAULT_TLD}`)) {
+        return failure(new InvalidDomainError(domain, "Domain must end with .night", undefined));
     }
-    return traverseDomainHierarchy(publicDataProvider, fullDomain, true);
+    // Use the simple wrapper
+    return wrapAsync(async () => {
+        const result = await traverseDomainHierarchy(options.provider || getDefaultProvider(), normalized, true);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    });
 }
-export async function getDomainInfoInContract(contractAddress, domainName, options = {}) {
+/** Looks up a subdomain's info (owner, resolver) within a specific parent contract. */
+async function getDomainInfoInContract(contractAddress, domainName, options = {}) {
     const publicDataProvider = options.provider || getDefaultProvider();
     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)) {
+        if (!contractLedger.domains.member(domainToKey(domainName).key)) {
             return failure(new DomainNotFoundError(domainName));
         }
-        const domainData = contractLedger.domains.lookup(domainName);
+        const domainData = contractLedger.domains.lookup(domainToKey(domainName).key);
         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) });
+        const ownerAddress = ShieldedCoinPublicKey.codec
+            .encode(getNetworkId(), 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));
@@ -121,7 +128,7 @@ export async function getDomainInfo(fullDomain, options = {}) {
         const normalizedDomain = normalizeDomain(fullDomain);
         const parsed = parseFullDomain(normalizedDomain);
         if (!parsed.isValid) {
-            return failure(new InvalidDomainError(fullDomain, 'Invalid domain format'));
+            return failure(new InvalidDomainError(fullDomain, "Invalid domain format"));
         }
         const parentContractAddressResult = await getResolverAddress(publicDataProvider, parsed.parentDomainPath);
         if (!parentContractAddressResult.success)
@@ -129,36 +136,78 @@ export async function getDomainInfo(fullDomain, options = {}) {
         const infoResult = await getDomainInfoInContract(parentContractAddressResult.data, parsed.domainName, { provider: publicDataProvider });
         if (!infoResult.success)
             return failure(infoResult.error);
-        return success({ ...infoResult.data, contractAddress: parentContractAddressResult.data });
+        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 = {}) {
+async function readContractLedger(publicDataProvider, resolverAddress) {
+    const rawAddress = resolverAddress.startsWith('0200')
+        ? resolverAddress.slice(4)
+        : resolverAddress;
+    const contractStateResult = await queryContractStateSafely(publicDataProvider, rawAddress);
+    if (!contractStateResult.success)
+        return failure(contractStateResult.error);
+    return success(ledger(contractStateResult.data.data));
+}
+export async function getDomainFields(fullDomain, options = {}) {
     const publicDataProvider = options.provider || getDefaultProvider();
     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]);
+        const normalized = normalizeDomain(fullDomain);
+        const infoResult = await getDomainInfo(normalized, { provider: publicDataProvider });
+        if (!infoResult.success)
+            return failure(infoResult.error);
+        const ledgerResult = await readContractLedger(publicDataProvider, infoResult.data.resolver);
+        if (!ledgerResult.success)
+            return failure(ledgerResult.error);
+        const fields = new Map();
+        for (const [key, value] of ledgerResult.data.fields)
+            fields.set(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 getDomainSettings(contractAddress, options = {}) {
+export async function getDomainSettings(fullDomain, options = {}) {
     const publicDataProvider = options.provider || getDefaultProvider();
     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 });
+        const normalized = normalizeDomain(fullDomain, false);
+        // Special case: TLD itself — read settings directly from TLD contract
+        if (isTLD(normalized)) {
+            const tldAddress = getDefaultTldAddress();
+            const ledgerResult = await readContractLedger(publicDataProvider, tldAddress);
+            if (!ledgerResult.success)
+                return failure(ledgerResult.error);
+            return success({
+                coinColor: ledgerResult.data.COIN_COLOR,
+                costs: {
+                    short: ledgerResult.data.COST_SHORT,
+                    medium: ledgerResult.data.COST_MED,
+                    long: ledgerResult.data.COST_LONG,
+                },
+            });
+        }
+        // Normal case: subdomain — resolve via getDomainInfo
+        const normalizedFull = normalizeDomain(fullDomain);
+        const infoResult = await getDomainInfo(normalizedFull, { provider: publicDataProvider });
+        if (!infoResult.success)
+            return failure(infoResult.error);
+        const ledgerResult = await readContractLedger(publicDataProvider, infoResult.data.resolver);
+        if (!ledgerResult.success)
+            return failure(ledgerResult.error);
+        return success({
+            coinColor: ledgerResult.data.COIN_COLOR,
+            costs: {
+                short: ledgerResult.data.COST_SHORT,
+                medium: ledgerResult.data.COST_MED,
+                long: ledgerResult.data.COST_LONG,
+            },
+        });
     }
     catch (error) {
         return failure(new NetworkError(`Failed to get domain settings: ${error instanceof Error ? error.message : String(error)}`, error));
@@ -170,22 +219,64 @@ export async function getDomainProfile(fullDomain, options = {}) {
         const normalized = normalizeDomain(fullDomain);
         const [resolvedTargetResult, infoResult] = await Promise.all([
             resolveDomain(normalized, { provider: publicDataProvider }),
-            getDomainInfo(normalized, { provider: publicDataProvider })
+            getDomainInfo(normalized, { provider: publicDataProvider }),
         ]);
-        const resolvedTarget = resolvedTargetResult.success ? resolvedTargetResult.data : null;
+        const resolvedTarget = resolvedTargetResult.success
+            ? resolvedTargetResult.data
+            : null;
         const info = infoResult.success ? infoResult.data : null;
-        if (info && info.contractAddress) {
-            const [fieldsResult, settingsResult] = await Promise.all([
-                getDomainFields(info.resolver, { 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 });
+        if (info && info.resolver) {
+            const ledgerResult = await readContractLedger(publicDataProvider, info.resolver);
+            if (ledgerResult.success) {
+                const fields = new Map();
+                for (const [key, value] of ledgerResult.data.fields)
+                    fields.set(key, value);
+                const settings = {
+                    coinColor: ledgerResult.data.COIN_COLOR,
+                    costs: {
+                        short: ledgerResult.data.COST_SHORT,
+                        medium: ledgerResult.data.COST_MED,
+                        long: ledgerResult.data.COST_LONG,
+                    },
+                };
+                return success({
+                    fullDomain: normalized,
+                    resolvedTarget,
+                    info,
+                    fields,
+                    settings,
+                });
+            }
         }
-        return success({ fullDomain: normalized, resolvedTarget, info, fields: [], settings: null });
+        return success({
+            fullDomain: normalized,
+            resolvedTarget,
+            info,
+            fields: new Map(),
+            settings: null,
+        });
     }
     catch (error) {
         return failure(new NetworkError(`Failed to get domain profile: ${error instanceof Error ? error.message : String(error)}`, error));
     }
 }
+export async function getSubdomains(fullDomain, options = {}) {
+    const publicDataProvider = options.provider || getDefaultProvider();
+    try {
+        const normalized = normalizeDomain(fullDomain);
+        const infoResult = await getDomainInfo(normalized, { provider: publicDataProvider });
+        if (!infoResult.success)
+            return failure(infoResult.error);
+        const ledgerResult = await readContractLedger(publicDataProvider, infoResult.data.resolver);
+        if (!ledgerResult.success)
+            return failure(ledgerResult.error);
+        const subdomains = new Map();
+        for (const [name, data] of ledgerResult.data.domains) {
+            subdomains.set(keyToDomain(name), data);
+        }
+        return success(subdomains);
+    }
+    catch (error) {
+        return failure(new NetworkError(`Failed to get subdomains: ${error instanceof Error ? error.message : String(error)}`, error));
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class MidnamesError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
+}
+export declare class NetworkError extends MidnamesError {
+    constructor(message: string, details?: unknown);
+}
+export declare class ContractNotFoundError extends MidnamesError {
+    constructor(contractAddress: string, details?: unknown);
+}
+export declare class DomainNotFoundError extends MidnamesError {
+    constructor(domain: string, details?: unknown);
+}
+export declare class InvalidDomainError extends MidnamesError {
+    constructor(domain: string, reason: string, details?: unknown);
+}
+export declare class ProviderError extends MidnamesError {
+    constructor(message: string, details?: unknown);
+}

package/dist/errors.js

@@ -0,0 +1,39 @@
+// Error handling types
+export class MidnamesError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'MidnamesError';
+    }
+}
+export class NetworkError extends MidnamesError {
+    constructor(message, details) {
+        super(message, 'NETWORK_ERROR', details);
+        this.name = 'NetworkError';
+    }
+}
+export class ContractNotFoundError extends MidnamesError {
+    constructor(contractAddress, details) {
+        super(`Contract not found: ${contractAddress}`, 'CONTRACT_NOT_FOUND', details);
+        this.name = 'ContractNotFoundError';
+    }
+}
+export class DomainNotFoundError extends MidnamesError {
+    constructor(domain, details) {
+        super(`Domain not found: ${domain}`, 'DOMAIN_NOT_FOUND', details);
+        this.name = 'DomainNotFoundError';
+    }
+}
+export class InvalidDomainError extends MidnamesError {
+    constructor(domain, reason, details) {
+        super(`Invalid domain "${domain}": ${reason}`, 'INVALID_DOMAIN', details);
+        this.name = 'InvalidDomainError';
+    }
+}
+export class ProviderError extends MidnamesError {
+    constructor(message, details) {
+        super(message, 'PROVIDER_ERROR', details);
+        this.name = 'ProviderError';
+    }
+}

package/dist/index.d.ts

@@ -3,3 +3,8 @@ export * from './utils/domain.js';
 export * from './utils/address.js';
 export * from './core.js';
 export * from './provider.js';
+export { buildKvs, insertField, clearField, clearAllFields, addMultipleFields, updateDomainTarget, updateDomainColor, updateDomainCosts, transferDomainOwnership, setDomainResolver, registerDomainFor, buyDomainFor, changeDomainOwner, } from './operations.js';
+export * from './results.js';
+export * from './errors.js';
+export * from './controller-types.js';
+export { resolveImageUrl } from './utils/imageResolver.js';

package/dist/index.js

@@ -3,3 +3,8 @@ export * from './utils/domain.js';
 export * from './utils/address.js';
 export * from './core.js';
 export * from './provider.js';
+export { buildKvs, insertField, clearField, clearAllFields, addMultipleFields, updateDomainTarget, updateDomainColor, updateDomainCosts, transferDomainOwnership, setDomainResolver, registerDomainFor, buyDomainFor, changeDomainOwner, } from './operations.js';
+export * from './results.js';
+export * from './errors.js';
+export * from './controller-types.js';
+export { resolveImageUrl } from './utils/imageResolver.js';

package/dist/managed/index.d.ts

@@ -1,9 +1,3 @@
-export { type DomainData as LeafDomainData } from "./managed/leaf/contract/index.cjs";
-export * as Leaf from "./managed/leaf/contract/index.cjs";
-import ContractModule from './managed/leaf/contract/index.cjs';
-import type { Contract as ContractType, Witnesses } from './managed/leaf/contract/index.cjs';
-export declare const ledger: typeof ContractModule.ledger;
-export declare const pureCircuits: ContractModule.PureCircuits;
-export declare const Contract: typeof ContractModule.Contract;
-export type Contract<T, W extends Witnesses<T> = Witnesses<T>> = ContractType<T, W>;
-export type Ledger = ContractModule.Ledger;
+export * as Leaf from "./managed/leaf/contract/index.js";
+export { type DomainData, type Either, type Maybe, type Witnesses, type Ledger, ledger, Contract } from "./managed/leaf/contract/index.js";
+export { domainToKey, keyToDomain } from "./utils.js";

package/dist/managed/index.js

@@ -1,6 +1,4 @@
-export * as Leaf from "./managed/leaf/contract/index.cjs";
-import ContractModule from './managed/leaf/contract/index.cjs';
-export const ledger = ContractModule.ledger;
-export const pureCircuits = ContractModule.pureCircuits;
-export const { Contract } = ContractModule;
+export * as Leaf from "./managed/leaf/contract/index.js";
+export { ledger, Contract } from "./managed/leaf/contract/index.js";
+export { domainToKey, keyToDomain } from "./utils.js";
 //# sourceMappingURL=index.js.map

package/dist/managed/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,IAAI,MAAM,mCAAmC,CAAC;AAE1D,OAAO,cAAc,MAAM,mCAAmC,CAAC;AAG/D,MAAM,CAAC,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;AAC5C,MAAM,CAAC,MAAM,YAAY,GAAG,cAAc,CAAC,YAAY,CAAC;AACxD,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAML,MAAM,EACN,QAAQ,EACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}