@beclab/olaresid 0.1.13 → 0.2.1

package/dist/domain/index.js

@@ -1,436 +1,196 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+/**
+ * Domain fetching functions
+ *
+ * This module provides three main functions for fetching domain data:
+ * 1. fetchDomain - Fetch a single domain by name or tokenId
+ * 2. fetchDomains - Fetch multiple domains with pagination
+ * 3. fetchAllFlat - Fetch all domains with flat structure
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PackageDomain = void 0;
-const ethers_1 = require("ethers");
-const index_1 = __importDefault(require("../tag/index"));
-const debug_1 = require("../debug");
-const getBase64 = (data) => {
-    const hex = data;
-    const arr = [];
-    for (let i = 0; i < hex.length; i += 2) {
-        const code = parseInt(hex.slice(i, i + 2), 16);
-        arr.push(code);
+exports.fetchDomain = fetchDomain;
+exports.fetchDomains = fetchDomains;
+exports.fetchDomainsByIndices = fetchDomainsByIndices;
+exports.fetchAllFlat = fetchAllFlat;
+const core_1 = require("./core");
+/**
+ * Fetch a single domain by name or tokenId
+ *
+ * @param console - DIDConsole instance
+ * @param nameOrTokenId - Domain name (e.g., "alice.olares.com") or tokenId (hex string or bigint)
+ * @param options - Fetch options
+ * @returns Domain data or null if not found
+ *
+ * @example
+ * // Fetch by domain name
+ * const domain = await fetchDomain(console, "alice.olares.com", { queryContractAddress });
+ *
+ * // Fetch by tokenId
+ * const domain = await fetchDomain(console, "0x123...", { queryContractAddress });
+ */
+async function fetchDomain(console, nameOrTokenId, options = {}) {
+    const { queryContractAddress } = options;
+    if (!queryContractAddress) {
+        throw new Error('queryContractAddress is required');
     }
-    debug_1.debug.info(arr);
-    let str = '';
-    for (let i = 0; i < arr.length; i++) {
-        const char = String.fromCharCode(arr[i]);
-        str += char;
+    // Step 1: Create query helper
+    const helper = new core_1.QueryContractHelper(queryContractAddress, console.getProvider());
+    // Step 2: Fetch single domain (supports both name and tokenId)
+    const rawDomain = await helper.getDomain(nameOrTokenId);
+    if (!rawDomain) {
+        return null;
     }
-    debug_1.debug.info(str);
-    const base64 = btoa(str);
-    debug_1.debug.info(base64);
-    return base64;
-};
-const getHex = (data) => {
-    let hex = '';
-    for (let i = 0; i < data.length; i++) {
-        const code = data.charCodeAt(i);
-        let hexCode = code.toString(16);
-        if (hexCode.length < 2) {
-            hexCode = '0' + hexCode;
-        }
-        hex += hexCode;
+    // Step 3: Collect field name hashes from this domain's tags
+    const fieldNameHashes = (0, core_1.collectFieldNameHashes)([rawDomain]);
+    // Step 4: Batch fetch field names
+    const contract = console.getContractDID();
+    const fieldNamesMap = await (0, core_1.batchFetchFieldNames)(contract, fieldNameHashes);
+    // Step 5: Parse domain (no parentId calculation for single domain)
+    const domain = (0, core_1.parseDomain)(rawDomain, fieldNamesMap);
+    return domain;
+}
+/**
+ * Fetch multiple domains with pagination
+ * Allows you to fetch a specific range of domains with offset and limit
+ *
+ * @param console - DIDConsole instance
+ * @param options - Fetch options including offset and limit
+ * @returns Array of domains in the specified range
+ *
+ * @example
+ * // Fetch first 10 domains
+ * const domains = await fetchDomains(console, {
+ *   queryContractAddress: "0x...",
+ *   offset: 0,
+ *   limit: 10
+ * });
+ *
+ * // Fetch next 10 domains
+ * const nextDomains = await fetchDomains(console, {
+ *   queryContractAddress: "0x...",
+ *   offset: 10,
+ *   limit: 10
+ * });
+ */
+async function fetchDomains(console, options) {
+    const { queryContractAddress, offset, limit } = options;
+    if (!queryContractAddress) {
+        throw new Error('queryContractAddress is required');
     }
-    debug_1.debug.info(hex);
-    return hex;
-};
-var PackageDomain;
-(function (PackageDomain) {
-    class Domain {
-        constructor(id, name, did, note, allowSubdomain, owner, subdomains, tags) {
-            this.id = id;
-            this.name = name;
-            this.did = did;
-            this.note = note;
-            this.allowSubdomain = allowSubdomain;
-            this.owner = owner;
-            this.subdomains = subdomains;
-            this.tags = tags;
-        }
+    if (offset < 0) {
+        throw new Error('offset must be >= 0');
     }
-    PackageDomain.Domain = Domain;
-    PackageDomain.syncById = (tokenId, contract) => new Promise(async (resolve, reject) => {
-        let meta = undefined;
-        let owner = undefined;
-        let times = 0;
-        while (tokenId == undefined ||
-            meta == undefined ||
-            owner == undefined) {
-            try {
-                meta = await contract.getMetadata(tokenId);
-                owner = await contract.ownerOf(tokenId);
-            }
-            catch (error) {
-                times++;
-                if (times >= 5) {
-                    throw new Error('network error');
-                }
-            }
-        }
-        // debug.info('meta', meta);
-        const domain = {
-            id: ethers_1.ethers.toBeHex(tokenId),
-            name: meta['0'],
-            did: meta['1'],
-            note: meta['2'],
-            allowSubdomain: meta['3'],
-            subdomains: [],
-            owner: owner,
-            tags: []
-        };
-        const tags = await PackageDomain.fetchAllTagType(domain, contract);
-        domain.tags = tags;
-        await PackageDomain.fetchAllTagValue(domain, contract);
-        resolve(domain);
-    });
-    PackageDomain.syncByName = (name, contract) => new Promise(async (resolve, reject) => {
-        let tokenId = await contract.tokenIdOf(name);
-        debug_1.debug.info('syncByName', name, tokenId);
-        if (tokenId == undefined) {
-            resolve(undefined);
-        }
-        else {
-            resolve(await PackageDomain.syncById(tokenId, contract));
-        }
-    });
-    PackageDomain.syncByIndex = (index, contract) => new Promise(async (resolve, reject) => {
-        let tokenId = undefined;
-        let times = 0;
-        while (tokenId == undefined) {
-            try {
-                tokenId = await contract.tokenByIndex(index);
-            }
-            catch (error) {
-                times++;
-                if (times >= 5) {
-                    throw new Error('network error');
-                }
-            }
-        }
-        resolve(await PackageDomain.syncById(tokenId, contract));
-    });
-    PackageDomain.buildTree = (allDomains) => {
-        allDomains.forEach((item) => {
-            const domains = PackageDomain.findSubdomain(item, allDomains);
-            item.subdomains = domains;
-        });
-        return allDomains.filter((item) => item.name.split('.').length == 1);
-    };
-    PackageDomain.findSubdomain = (domain, allDomains) => {
-        const arr = [];
-        allDomains.forEach((item) => {
-            if (item.name.endsWith('.' + domain.name) &&
-                domain.name.split('.').length + 1 == item.name.split('.').length) {
-                const subdomains = PackageDomain.findSubdomain(item, allDomains);
-                item.subdomains = subdomains;
-                arr.push(item);
-            }
-        });
-        return arr;
-    };
-    PackageDomain.findASubtree = (name, allDomains) => {
-        for (const domain of allDomains) {
-            if (domain.name == name) {
-                return domain;
-            }
-        }
-        return undefined;
-    };
-    PackageDomain.findSubtreesByOwner = (owner, allDomains) => {
-        let arr = [];
-        arr.push(...allDomains.filter((d) => d.owner.toLocaleLowerCase() == owner.toLocaleLowerCase()));
-        for (const d of allDomains) {
-            let subArr = PackageDomain.findSubtreesByOwner(owner, d.subdomains);
-            arr.push(...subArr);
-        }
-        return arr;
-    };
-    PackageDomain.findSubtreesByDid = (did, allDomains) => {
-        let arr = [];
-        arr.push(...allDomains.filter((d) => d.did.startsWith(did)));
-        for (const d of allDomains) {
-            let subArr = PackageDomain.findSubtreesByDid(did, d.subdomains);
-            arr.push(...subArr);
-        }
-        return arr;
-    };
-    PackageDomain.fetchAllTagType = (domain, contract) => new Promise(async (resolve, reject) => {
-        // debug.info('fetchAllTagType', domain);
-        let d = domain.name.split('.');
-        let fromArr = [''];
-        for (let index = 1; index <= d.length; index++) {
-            fromArr.push(d.slice(d.length - index).join('.'));
-        }
-        debug_1.debug.info('fromArr', fromArr);
-        let arr = [];
-        for (const from of fromArr) {
-            debug_1.debug.group(from);
-            let count = await contract.getDefinedTagCount(from);
-            debug_1.debug.info('count', count);
-            for (let i = 0; i < count; i++) {
-                let name = await contract.getDefinedTagNameByIndex(from, i);
-                debug_1.debug.info('name', name);
-                arr.push({
-                    from: from,
-                    to: domain.name,
-                    name: name,
-                    valueFormated: undefined,
-                    valueSource: undefined
-                });
-            }
-            debug_1.debug.groupEnd();
-        }
-        domain.tags = arr;
-        resolve(domain.tags);
-    });
-    PackageDomain.fetchTagStructure = (tag, contract) => new Promise(async (resolve, reject) => {
-        debug_1.debug.info('fetchTagStructure', tag.from, tag.to, tag.name);
-        const tagRawType = await contract.getTagABIType(tag.from, tag.name);
-        // debug.info(`tag type raw bytes:`);
-        // debug.info(tagRawType);
-        const tagType = index_1.default.doFormatType(tagRawType);
-        // debug.info(`tag type:`);
-        // debug.info(tagType);
-        if (tagType
-            .getAbiTypeString()
-            .includes('tuple')) {
-            let [_, fieldNamesHashs] = await contract.getTagType(tag.from, tag.name);
-            let fieldNames = [];
-            for (let hash of fieldNamesHashs) {
-                let blockNum = await contract.getFieldNamesEventBlock(hash);
-                // debug.info(`field name hash: ${hash}`);
-                // debug.info(`block num: ${blockNum}`);
-                const events = await contract.queryFilter('OffchainStringArray', Number(blockNum), Number(blockNum));
-                for (let event of events) {
-                    // debug.info('event', event);
-                    if (hash == event.args.hash) {
-                        fieldNames.push(event.args.value);
-                    }
-                }
-            }
-            // debug.info(`found field names:`);
-            // debug.info(fieldNames);
-            tagType.setFieldNames(fieldNames, 0);
-        }
-        resolve(tagType);
-    });
-    PackageDomain.fetchTagValue = (tag, contract) => new Promise(async (resolve, reject) => {
-        try {
-            debug_1.debug.info('fetchTagValue', tag.from, tag.to, tag.name);
-            const tagRawType = await contract.getTagABIType(tag.from, tag.name);
-            // debug.info(`tag type raw bytes:`);
-            // debug.info(tagRawType);
-            const tagType = index_1.default.doFormatType(tagRawType);
-            // debug.info(`tag type:`);
-            // debug.info(tagType);
-            const rawData = await contract.getTagElem(tag.from, tag.to, tag.name, []);
-            // debug.info(`tag raw value:`);
-            // debug.info(rawData);
-            tag.valueSource = rawData;
-            let data = tagType.parseValue(rawData);
-            data = data[0];
-            debug_1.debug.info('tag value:');
-            debug_1.debug.info(data);
-            if (tagType
-                .getAbiTypeString()
-                .includes('tuple')) {
-                let [_, fieldNamesHashs] = await contract.getTagType(tag.from, tag.name);
-                let fieldNames = [];
-                for (let hash of fieldNamesHashs) {
-                    let blockNum = await contract.getFieldNamesEventBlock(hash);
-                    // debug.info(`field name hash: ${hash}`);
-                    // debug.info(`block num: ${blockNum}`);
-                    const events = await contract.queryFilter('OffchainStringArray', Number(blockNum), Number(blockNum));
-                    for (let event of events) {
-                        // debug.info('event', event);
-                        if (hash == event.args.hash) {
-                            fieldNames.push(event.args.value);
-                        }
-                    }
-                }
-                // debug.info(`found field names:`);
-                // debug.info(fieldNames);
-                tagType.setFieldNames(fieldNames, 0);
-                data = tagType.hydration(rawData);
-                // data = data[0];
-                // debug.info('tag value with field names:');
-                // console.dir(data, { depth: null });
-            }
-            let strData = data;
-            if (data !== null && data !== undefined && typeof data !== 'string') {
-                strData = JSON.stringify(data);
-            }
-            tag.valueFormated = strData;
-            debug_1.debug.info(`✅ Successfully fetched value for tag: ${tag.name}`);
-            debug_1.debug.info('✅ Updated tag data:', tag);
-            resolve(tag);
-        }
-        catch (error) {
-            debug_1.debug.error(`❌ Failed to fetch value for tag "${tag.name}" (${tag.from} -> ${tag.to}): ${error instanceof Error ? error.message : String(error)}`);
-            tag.valueFormated = null;
-            tag.valueSource = null;
-            resolve(tag);
-        }
-    });
-    PackageDomain.fetchAllTagValue = (domain, contract) => new Promise(async (resolve, reject) => {
-        for (const tag of domain.tags) {
-            await PackageDomain.fetchTagValue(tag, contract);
-        }
-        resolve(domain.tags);
-    });
-    PackageDomain.defineTag = async (domain, tagName, value, contract, providerHolder) => {
-        debug_1.debug.info('abitype', await value.getAbiType(providerHolder));
-        debug_1.debug.info('field', await value.getFieldNames());
-        await contract.defineTag(domain?.name, tagName, await value.getAbiType(providerHolder), await value.getFieldNames());
-    };
-    PackageDomain.getAllSubdoamin = (domain) => {
-        let arr = [];
-        for (const d of domain.subdomains) {
-            arr.push(...PackageDomain.getAllSubdoamin(d));
-        }
-        arr.push(...domain.subdomains);
-        return arr;
-    };
-    PackageDomain.fetchOfficialExtendedInformation = (domain, contract) => new Promise(async (resolve, reject) => {
-        let ip = undefined;
-        let ipStr = '';
-        try {
-            ip = (await contract.getDnsARecord(domain.name));
-            ipStr = `${parseInt(ip.substring(2, 4), 16)}.${parseInt(ip.substring(4, 6), 16)}.${parseInt(ip.substring(6, 8), 16)}.${parseInt(ip.substring(8, 10), 16)}`;
-        }
-        catch (error) {
-            debug_1.debug.info(error instanceof Error ? error.message : String(error));
-        }
-        let rsaKey = undefined;
-        try {
-            rsaKey = (await contract.getRsaPubKey(domain.name));
-        }
-        catch (error) {
-            debug_1.debug.info(error instanceof Error ? error.message : String(error));
-        }
-        let pubKey = '';
-        try {
-            if (rsaKey != '0x' && rsaKey != undefined) {
-                // debug.info('rsaKey:');
-                const str = String.fromCharCode(...rsaKey
-                    .match(/.{1,2}/g)
-                    .map((byte) => parseInt(byte, 16)));
-                const encoded = btoa(str);
-                const base64 = getBase64(rsaKey.replaceAll('0x', ''));
-                // debug.info(encoded);
-                // debug.info(base64);
-                pubKey = `-----BEGIN RSA PUBLIC KEY-----
-                        ${base64}
-                        -----END RSA PUBLIC KEY-----`;
-            }
-        }
-        catch (error) {
-            debug_1.debug.error(error instanceof Error ? error.message : String(error));
-        }
-        let authenticatedAddress = [];
-        try {
-            authenticatedAddress =
-                await contract.getAuthenticationAddresses(domain.name);
-        }
-        catch (error) {
-            debug_1.debug.error(error instanceof Error ? error.message : String(error));
-        }
-        // debug.info('authenticatedAddress:');
-        // debug.info(authenticatedAddress);
-        let latestDID = '';
-        try {
-            latestDID = await contract.getLatestDID(domain.name);
-        }
-        catch (error) {
-            debug_1.debug.info(error instanceof Error ? error.message : String(error));
-        }
-        // debug.info('latestDID:', latestDID);
-        const officialExt = {
-            ip: ipStr,
-            rsaKey: pubKey,
-            authenticateds: authenticatedAddress,
-            latestDID: latestDID
-        };
-        debug_1.debug.info('officialExt: ', officialExt);
-        resolve(officialExt);
-    });
-    PackageDomain.updateIp = (domain, ipStr, contract) => new Promise(async (resolve, reject) => {
-        debug_1.debug.info('updateIp', ipStr);
-        const v2 = '((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))';
-        const v3 = '((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5]))\\.((\\d{1,2})|(1\\d{2})|(2[0-4]\\d)|(25[0-5])).((d{1,2})|(1d{2})|(2[0-4]d)|(25[0-5]))';
-        const reg = new RegExp(v3, 'g');
-        const reg2 = new RegExp(v2, 'g');
-        const isIp = ipStr.match(reg);
-        const isIp2 = ipStr.match(reg2);
-        if (isIp != null || isIp2 != null) {
-            const ipArr = ipStr.split('.');
-            const add0 = (str) => str.length == 1 ? '0' + str : str;
-            const ipBytes = `0x${add0(parseInt(ipArr[0]).toString(16))}${add0(parseInt(ipArr[1]).toString(16))}${add0(parseInt(ipArr[2]).toString(16))}${add0(parseInt(ipArr[3]).toString(16))}`;
-            debug_1.debug.info(ethers_1.ethers.getBytes(ipBytes));
-            debug_1.debug.info(ipBytes);
-            debug_1.debug.info(domain.name);
-            await contract
-                .setDnsARecord(domain.name, ipBytes)
-                .then((resp) => {
-                resolve('sumbit succeed');
-            })
-                .catch((error) => {
-                debug_1.debug.info('error1:');
-                debug_1.debug.info(error);
-                reject(error.message);
-            });
-        }
-        else {
-            reject('ip format error');
+    if (limit <= 0) {
+        throw new Error('limit must be > 0');
+    }
+    // Step 1: Create query helper
+    const helper = new core_1.QueryContractHelper(queryContractAddress, console.getProvider());
+    // Step 2: Fetch domains in the specified range
+    const rawDomains = await helper.getAllDomains(offset, limit);
+    // Return empty array if no domains found
+    if (rawDomains.length === 0) {
+        return [];
+    }
+    // Step 3: Collect field name hashes
+    const fieldNameHashes = (0, core_1.collectFieldNameHashes)(rawDomains);
+    // Step 4: Batch fetch field names
+    const contract = console.getContractDID();
+    const fieldNamesMap = await (0, core_1.batchFetchFieldNames)(contract, fieldNameHashes);
+    // Step 5: Parse domains (with parentId calculation)
+    const flatDomains = (0, core_1.parseAllDomains)(rawDomains, fieldNamesMap);
+    return flatDomains;
+}
+/**
+ * Fetch multiple domains by their indices
+ * Useful for fetching specific domains when you know their positions
+ *
+ * @param console - DIDConsole instance
+ * @param indices - Array of domain indices (e.g., [5, 6, 9, 10])
+ * @param options - Fetch options
+ * @returns Array of domains corresponding to the specified indices
+ *
+ * @example
+ * // Fetch domains at specific indices
+ * const domains = await fetchDomainsByIndices(console, [5, 6, 9, 10], {
+ *   queryContractAddress: "0x..."
+ * });
+ *
+ * // Result will contain domains at positions 5, 6, 9, and 10
+ * // indices[0] -> domains[0], indices[1] -> domains[1], etc.
+ */
+async function fetchDomainsByIndices(console, indices, options = {}) {
+    const { queryContractAddress } = options;
+    if (!queryContractAddress) {
+        throw new Error('queryContractAddress is required');
+    }
+    if (!Array.isArray(indices) || indices.length === 0) {
+        throw new Error('indices must be a non-empty array');
+    }
+    if (indices.length > 100) {
+        throw new Error(`Too many indices: ${indices.length}. Maximum is 100. Please split into multiple calls.`);
+    }
+    // Validate all indices are non-negative
+    for (const index of indices) {
+        if (index < 0 || !Number.isInteger(index)) {
+            throw new Error(`Invalid index: ${index}. All indices must be non-negative integers`);
         }
-    });
-    PackageDomain.updateRSAPublicKey = (domain, rsaPublicKey, contract) => new Promise(async (resolve, reject) => {
-        const regex1 = new RegExp('-----BEGIN PUBLIC KEY-----', 'g');
-        const regex2 = new RegExp('-----END PUBLIC KEY-----', 'g');
-        const regex3 = new RegExp('\n', 'g');
-        const keyBase64 = rsaPublicKey
-            .replace(regex1, '')
-            .replace(regex2, '')
-            .replace(regex3, '');
-        const keyHex = getHex(atob(rsaPublicKey));
-        debug_1.debug.info('keyHex:');
-        debug_1.debug.info(keyHex);
-        debug_1.debug.info(keyBase64);
-        debug_1.debug.info(rsaPublicKey);
-        await contract
-            .setRsaPubKey(domain.name, `0x${keyHex}`)
-            .then((resp) => {
-            resolve('sumbit succeed');
-        })
-            .catch((error) => {
-            reject(error.message);
-        });
-    });
-    PackageDomain.setValue = (tag, data, contract) => new Promise(async (resolve, reject) => {
-        await contract
-            .addTag(tag.from, tag.to, tag.name, data)
-            .then((resp) => {
-            debug_1.debug.info(resp);
-            resolve('sumbit succeed');
-        })
-            .catch((error) => {
-            reject(error.message);
-        });
-    });
-    PackageDomain.setTagger = (tag, tagger, contract) => new Promise(async (resolve, reject) => {
-        await contract
-            .setTagger(tag.from, tag.name, tagger)
-            .then((resp) => {
-            debug_1.debug.info(resp);
-            resolve('sumbit succeed');
-        })
-            .catch((error) => {
-            reject(error.message);
-        });
-    });
-})(PackageDomain || (exports.PackageDomain = PackageDomain = {}));
+    }
+    // Step 1: Create query helper
+    const helper = new core_1.QueryContractHelper(queryContractAddress, console.getProvider());
+    // Step 2: Fetch domains by indices (single RPC call)
+    const rawDomains = await helper.getDomainsByIndices(indices);
+    if (rawDomains.length === 0) {
+        return [];
+    }
+    // Step 3: Collect field name hashes
+    const fieldNameHashes = (0, core_1.collectFieldNameHashes)(rawDomains);
+    // Step 4: Batch fetch field names
+    const contract = console.getContractDID();
+    const fieldNamesMap = await (0, core_1.batchFetchFieldNames)(contract, fieldNameHashes);
+    // Step 5: Parse all domains
+    const domains = (0, core_1.parseAllDomains)(rawDomains, fieldNamesMap);
+    return domains;
+}
+/**
+ * Fetch all domains with flat structure using query contract
+ * Much more efficient than the old fetchAll method
+ *
+ * @param console - DIDConsole instance
+ * @param options - Fetch options
+ * @returns Array of all domains in flat structure
+ *
+ * @example
+ * const domains = await fetchAllFlat(console, {
+ *   queryContractAddress: "0x...",
+ *   batchSize: 100,
+ *   onProgress: (current, total) => console.log(`${current}/${total}`)
+ * });
+ */
+async function fetchAllFlat(console, options = {}) {
+    const { queryContractAddress, batchSize = 100, onProgress } = options;
+    if (!queryContractAddress) {
+        throw new Error('queryContractAddress is required');
+    }
+    // Step 1: Create query helper
+    const helper = new core_1.QueryContractHelper(queryContractAddress, console.getProvider());
+    // Step 2: Get total supply
+    const totalSupply = await helper.getTotalSupply();
+    onProgress?.(0, totalSupply);
+    // Step 3: Fetch all domains in batches
+    const allRawDomains = [];
+    for (let offset = 0; offset < totalSupply; offset += batchSize) {
+        const limit = Math.min(batchSize, totalSupply - offset);
+        const batch = await helper.getAllDomains(offset, limit);
+        allRawDomains.push(...batch);
+        onProgress?.(Math.min(offset + batchSize, totalSupply), totalSupply);
+    }
+    // Step 4: Collect all field name hashes
+    const fieldNameHashes = (0, core_1.collectFieldNameHashes)(allRawDomains);
+    // Step 5: Batch fetch field names
+    const contract = console.getContractDID();
+    const fieldNamesMap = await (0, core_1.batchFetchFieldNames)(contract, fieldNameHashes);
+    // Step 6: Parse all domains (with parentId calculation)
+    const flatDomains = (0, core_1.parseAllDomains)(allRawDomains, fieldNamesMap);
+    return flatDomains;
+}
 //# sourceMappingURL=index.js.map