@ocap/indexdb-sqlite 1.29.5

package/esm/db/base.mjs

@@ -0,0 +1,666 @@
+import { BaseIndexDB, formatDelegationAfterRead, formatNextPagination, formatPagination, parseDateTime } from "@ocap/indexdb";
+import { toChecksumAddress } from "@arcblock/did/lib/type";
+import { BN } from "@ocap/util";
+import { DEFAULT_TOKEN_DECIMAL } from "@ocap/util/lib/constant";
+import debugFactory from "debug";
+import omit from "lodash/omit.js";
+
+//#region src/db/base.ts
+const debug = debugFactory("@ocap/indexdb-sqlite");
+const MAX_REQUEST_FACTORY_ADDRESS_SIZE = 100;
+function buildPagingResult(total, pagination, itemCount) {
+	return {
+		cursor: String(pagination.cursor + itemCount),
+		next: itemCount >= pagination.size,
+		total
+	};
+}
+/**
+* Base SQLite IndexDB implementation
+* Contains all the list methods with SQL-based filtering
+*/
+var SqliteBaseIndexDB = class extends BaseIndexDB {
+	/**
+	* List transactions with filtering and pagination
+	*/
+	async listTransactions(params = {}) {
+		const { addressFilter = {}, paging = {}, timeFilter = {}, typeFilter = {}, assetFilter = {}, factoryFilter = {}, tokenFilter = {}, accountFilter = {}, validityFilter = {}, txFilter = {}, rollupFilter = {}, stakeFilter = {}, delegationFilter = {}, tokenFactoryFilter = {}, includeItxData = false } = params;
+		const { sender, receiver, direction = "UNION" } = addressFilter;
+		const { types = [] } = typeFilter;
+		const { factories = [] } = factoryFilter;
+		const { assets = [] } = assetFilter;
+		const { tokens = [] } = tokenFilter;
+		const { accounts = [] } = accountFilter;
+		const { txs = [] } = txFilter;
+		const { rollups = [] } = rollupFilter;
+		const { stakes = [] } = stakeFilter;
+		const { delegations = [] } = delegationFilter;
+		const { tokenFactories = [] } = tokenFactoryFilter;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "time"
+		});
+		debug("listTransactions", {
+			sender,
+			receiver,
+			pagination,
+			types,
+			factories,
+			assets,
+			tokens,
+			accounts,
+			rollups,
+			stakes,
+			delegations,
+			includeItxData
+		});
+		let qb = this.db.selectFrom("tx").selectAll();
+		if (sender && receiver) if (direction === "MUTUAL") qb = qb.where((eb) => eb.or([eb.and([eb("sender", "=", sender), eb("receiver", "=", receiver)]), eb.and([eb("sender", "=", receiver), eb("receiver", "=", sender)])]));
+		else if (direction === "ONE_WAY") qb = qb.where("sender", "=", sender).where("receiver", "=", receiver);
+		else qb = qb.where((eb) => eb.or([eb("sender", "=", sender), eb("receiver", "=", receiver)]));
+		else if (sender) qb = qb.where("sender", "=", sender);
+		else if (receiver) qb = qb.where("receiver", "=", receiver);
+		if (types.length) qb = qb.where("type", "in", types);
+		if (txs.length) qb = qb.where("hash", "in", txs);
+		const { startDateTime, endDateTime } = timeFilter;
+		const parsedStart = parseDateTime(startDateTime);
+		const parsedEnd = parseDateTime(endDateTime);
+		if (parsedStart && parsedEnd) qb = qb.where("time", ">", parsedStart).where("time", "<=", parsedEnd);
+		else if (parsedStart) qb = qb.where("time", ">", parsedStart);
+		else if (parsedEnd) qb = qb.where("time", "<=", parsedEnd);
+		const { validity } = validityFilter;
+		if (validity === "VALID") qb = qb.where("valid", "=", 1);
+		else if (validity === "INVALID") qb = qb.where("valid", "=", 0);
+		if (factories.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("factories")]).as("je")).select("je.value").where("je.value", "in", factories)));
+		if (assets.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("assets")]).as("je")).select("je.value").where("je.value", "in", assets)));
+		if (tokens.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("tokens")]).as("je")).select("je.value").where("je.value", "in", tokens)));
+		if (accounts.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("accounts")]).as("je")).select("je.value").where("je.value", "in", accounts)));
+		if (rollups.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("rollups")]).as("je")).select("je.value").where("je.value", "in", rollups)));
+		if (stakes.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("stakes")]).as("je")).select("je.value").where("je.value", "in", stakes)));
+		if (delegations.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("delegations")]).as("je")).select("je.value").where("je.value", "in", delegations)));
+		if (tokenFactories.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("tokenFactories")]).as("je")).select("je.value").where("je.value", "in", tokenFactories)));
+		const total = (await qb.clearSelect().select(this.db.fn.countAll().as("count")).executeTakeFirst())?.count ?? 0;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		let transactions = (await qb.execute()).map((row) => {
+			const tx = { ...row };
+			[
+				"receipts",
+				"tx",
+				"accounts",
+				"assets",
+				"tokens",
+				"tokenSymbols",
+				"factories",
+				"rollups",
+				"stakes",
+				"delegations",
+				"tokenFactories",
+				"data"
+			].forEach((field) => {
+				if (typeof tx[field] === "string") try {
+					tx[field] = JSON.parse(tx[field]);
+				} catch {}
+			});
+			return tx;
+		});
+		if (!includeItxData) transactions = transactions.map((tx) => {
+			const row = tx;
+			if (row.tx && row.tx?.itxJson) return {
+				...tx,
+				tx: {
+					...row.tx,
+					itxJson: omit(row.tx.itxJson, ["data"])
+				}
+			};
+			return tx;
+		});
+		return {
+			transactions,
+			paging: buildPagingResult(total, pagination, transactions.length)
+		};
+	}
+	/**
+	* Get related addresses for account migration tracking
+	*/
+	async getRelatedAddresses(address) {
+		let account = await this.account.get(address);
+		if (!account) return [];
+		const related = [address];
+		while (account?.migratedFrom && related.length <= 8) {
+			const migratedFrom = account.migratedFrom;
+			related.push(migratedFrom);
+			account = await this.account.get(migratedFrom);
+		}
+		return related.filter(Boolean);
+	}
+	/**
+	* List assets with filtering and pagination
+	*/
+	async listAssets(params = {}) {
+		const { ownerAddress, factoryAddress, paging, timeFilter = {} } = params;
+		if (!ownerAddress && !factoryAddress) return {
+			assets: [],
+			account: null,
+			paging: {
+				cursor: "0",
+				next: false,
+				total: 0
+			}
+		};
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime"
+		});
+		let qb = this.db.selectFrom("asset").selectAll();
+		if (ownerAddress) {
+			const possibleOwners = await this.getRelatedAddresses(ownerAddress);
+			if (possibleOwners.length) qb = qb.where("owner", "in", possibleOwners);
+			else return {
+				assets: [],
+				account: null,
+				paging: {
+					cursor: "0",
+					next: false,
+					total: 0
+				}
+			};
+		}
+		if (factoryAddress) qb = qb.where("parent", "=", factoryAddress);
+		const { startDateTime, endDateTime, field: rawField = "renaissanceTime" } = timeFilter;
+		const parsedStart = parseDateTime(startDateTime);
+		const parsedEnd = parseDateTime(endDateTime);
+		const timeField = [
+			"genesisTime",
+			"renaissanceTime",
+			"consumedTime"
+		].includes(rawField) ? rawField : "renaissanceTime";
+		if (parsedStart && parsedEnd) qb = qb.where(timeField, ">", parsedStart).where(timeField, "<=", parsedEnd);
+		else if (parsedStart) qb = qb.where(timeField, ">", parsedStart);
+		else if (parsedEnd) qb = qb.where(timeField, "<=", parsedEnd);
+		debug("listAssets", {
+			ownerAddress,
+			factoryAddress,
+			timeFilter,
+			paging,
+			pagination
+		});
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const assets = (await qb.execute()).map((row) => {
+			const asset = { ...row };
+			[
+				"display",
+				"tags",
+				"stake",
+				"data"
+			].forEach((field) => {
+				if (typeof asset[field] === "string") try {
+					asset[field] = JSON.parse(asset[field]);
+				} catch {}
+			});
+			return asset;
+		});
+		const countConditions = {};
+		if (ownerAddress) countConditions.owner = { $in: await this.getRelatedAddresses(ownerAddress) };
+		if (factoryAddress) countConditions.parent = factoryAddress;
+		const total = await this.asset.count(Object.keys(countConditions).length ? countConditions : void 0);
+		return {
+			assets,
+			account: ownerAddress ? await this.account.get(ownerAddress) : null,
+			paging: formatNextPagination(total, pagination)
+		};
+	}
+	/**
+	* List top accounts by token balance
+	*/
+	async listTopAccounts(params = {}) {
+		const { paging, tokenAddress } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "balance",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"balance"
+			]
+		});
+		debug("listTopAccounts", {
+			tokenAddress,
+			paging,
+			pagination
+		});
+		let qb = this.db.selectFrom("account").selectAll();
+		if (pagination.order.field !== "balance") {
+			const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+			qb = qb.orderBy(pagination.order.field, orderDir);
+		}
+		let accounts = (await qb.execute()).map((row) => {
+			const account = { ...row };
+			[
+				"stake",
+				"tokens",
+				"data"
+			].forEach((field) => {
+				if (typeof account[field] === "string") try {
+					account[field] = JSON.parse(account[field]);
+				} catch {}
+			});
+			if (Array.isArray(account.tokens)) account.tokens = account.tokens?.map((token) => {
+				token.decimal = typeof token.decimal === "undefined" ? DEFAULT_TOKEN_DECIMAL : token.decimal;
+				return token;
+			});
+			return account;
+		});
+		if (tokenAddress) accounts = accounts.filter((acc) => {
+			const tokens = acc.tokens;
+			if (!Array.isArray(tokens)) return false;
+			const owned = tokens.find((t) => t.address === tokenAddress);
+			return owned ? owned.balance > "0" : false;
+		});
+		if (pagination.order.field === "balance" && tokenAddress) {
+			const descending = pagination.order.type === "desc";
+			accounts.sort((a, b) => {
+				const tokensA = a.tokens;
+				const tokensB = b.tokens;
+				const tokenA = tokensA?.find((t) => t.address === tokenAddress);
+				const tokenB = tokensB?.find((t) => t.address === tokenAddress);
+				const balanceA = new BN(tokenA ? tokenA.balance : "0");
+				const balanceB = new BN(tokenB ? tokenB.balance : "0");
+				if (balanceB.gt(balanceA)) return descending ? 1 : -1;
+				if (balanceB.eq(balanceA)) return 0;
+				return descending ? -1 : 1;
+			});
+		}
+		const total = accounts.length;
+		accounts = accounts.slice(pagination.cursor, pagination.cursor + pagination.size);
+		return {
+			accounts,
+			paging: formatNextPagination(total, pagination)
+		};
+	}
+	/**
+	* List tokens with filtering and pagination
+	*/
+	async listTokens(params = {}) {
+		const { issuerAddress, paging } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"issuer",
+				"symbol",
+				"totalSupply"
+			]
+		});
+		debug("listTokens", {
+			issuerAddress,
+			paging,
+			pagination
+		});
+		let qb = this.db.selectFrom("token").selectAll();
+		if (issuerAddress) qb = qb.where("issuer", "=", issuerAddress);
+		const orderField = pagination.order.field === "totalSupply" ? "totalSupplyNum" : pagination.order.field;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(orderField, orderDir).offset(pagination.cursor).limit(pagination.size);
+		return {
+			tokens: (await qb.execute()).map((row) => {
+				const token = { ...row };
+				[
+					"foreignToken",
+					"metadata",
+					"spenders",
+					"minters",
+					"data"
+				].forEach((field) => {
+					if (typeof token[field] === "string") try {
+						token[field] = JSON.parse(token[field]);
+					} catch {}
+				});
+				const t = token;
+				t.decimal = typeof t.decimal === "undefined" ? DEFAULT_TOKEN_DECIMAL : t.decimal;
+				return t;
+			}),
+			paging: formatNextPagination(await this.token.count(issuerAddress ? { issuer: issuerAddress } : void 0), pagination)
+		};
+	}
+	/**
+	* List token factories (bonding curve)
+	*/
+	async listTokenFactories(params = {}) {
+		const { owner, reserveAddress, tokenAddress, paging } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"reserveBalance",
+				"currentSupply"
+			]
+		});
+		debug("listTokenFactories", {
+			owner,
+			reserveAddress,
+			tokenAddress,
+			paging,
+			pagination
+		});
+		let qb = this.db.selectFrom("tokenFactory").selectAll();
+		if (owner) qb = qb.where("owner", "=", owner);
+		if (reserveAddress) qb = qb.where("reserveAddress", "=", reserveAddress);
+		if (tokenAddress) qb = qb.where("tokenAddress", "=", tokenAddress);
+		const orderField = pagination.order.field === "reserveBalance" ? "reserveBalanceNum" : pagination.order.field === "currentSupply" ? "currentSupplyNum" : pagination.order.field;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(orderField, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const tokenFactories = (await qb.execute()).map((row) => {
+			const tf = { ...row };
+			[
+				"curve",
+				"token",
+				"reserveToken",
+				"input",
+				"output",
+				"data"
+			].forEach((field) => {
+				if (typeof tf[field] === "string") try {
+					tf[field] = JSON.parse(tf[field]);
+				} catch {}
+			});
+			return tf;
+		});
+		const conditions = {};
+		if (owner) conditions.owner = owner;
+		if (reserveAddress) conditions.reserveAddress = reserveAddress;
+		if (tokenAddress) conditions.tokenAddress = tokenAddress;
+		return {
+			tokenFactories,
+			paging: formatNextPagination(await this.tokenFactory.count(Object.keys(conditions).length ? conditions : void 0), pagination)
+		};
+	}
+	/**
+	* List asset factories
+	*/
+	async listFactories(params = {}) {
+		const { ownerAddress, addressList, paging } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: [
+				"genesisTime",
+				"renaissanceTime",
+				"owner",
+				"numMinted",
+				"limit",
+				"name"
+			]
+		});
+		debug("listFactories", {
+			ownerAddress,
+			paging,
+			pagination
+		});
+		let qb = this.db.selectFrom("factory").selectAll();
+		if (ownerAddress) qb = qb.where("owner", "=", ownerAddress);
+		if (Array.isArray(addressList) && addressList.length > 0) {
+			if (addressList.length > MAX_REQUEST_FACTORY_ADDRESS_SIZE) throw new Error(`The length of 'addressList' cannot exceed the length of ${MAX_REQUEST_FACTORY_ADDRESS_SIZE}`);
+			qb = qb.where("address", "in", addressList);
+		}
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const factories = (await qb.execute()).map((row) => {
+			const factory = { ...row };
+			[
+				"trustedIssuers",
+				"tokens",
+				"input",
+				"output",
+				"display",
+				"hooks",
+				"data"
+			].forEach((field) => {
+				if (typeof factory[field] === "string") try {
+					factory[field] = JSON.parse(factory[field]);
+				} catch {}
+			});
+			return factory;
+		});
+		const conditions = {};
+		if (ownerAddress) conditions.owner = ownerAddress;
+		if (Array.isArray(addressList) && addressList.length) conditions.address = { $in: addressList };
+		return {
+			factories,
+			paging: formatNextPagination(await this.factory.count(Object.keys(conditions).length ? conditions : void 0), pagination)
+		};
+	}
+	/**
+	* List stakes
+	*/
+	async listStakes(params = {}) {
+		const { addressFilter = {}, paging = {}, timeFilter = {}, assetFilter = {} } = params;
+		const { sender, receiver } = addressFilter;
+		const { assets = [] } = assetFilter;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		let qb = this.db.selectFrom("stake").selectAll();
+		if (sender && receiver) qb = qb.where("sender", "=", sender).where("receiver", "=", receiver);
+		else if (sender) qb = qb.where("sender", "=", sender);
+		else if (receiver) qb = qb.where("receiver", "=", receiver);
+		const { startDateTime, endDateTime } = timeFilter;
+		const parsedStart = parseDateTime(startDateTime);
+		const parsedEnd = parseDateTime(endDateTime);
+		if (parsedStart && parsedEnd) qb = qb.where("renaissanceTime", ">", parsedStart).where("renaissanceTime", "<=", parsedEnd);
+		else if (parsedStart) qb = qb.where("renaissanceTime", ">", parsedStart);
+		else if (parsedEnd) qb = qb.where("renaissanceTime", "<=", parsedEnd);
+		if (assets.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("assets")]).as("je")).select("je.value").where("je.value", "in", assets)));
+		const total = (await qb.clearSelect().select(this.db.fn.countAll().as("count")).executeTakeFirst())?.count ?? 0;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const stakes = (await qb.execute()).map((row) => {
+			const stake = { ...row };
+			[
+				"tokens",
+				"revokedTokens",
+				"assets",
+				"revokedAssets",
+				"slashers",
+				"data"
+			].forEach((field) => {
+				if (typeof stake[field] === "string") try {
+					stake[field] = JSON.parse(stake[field]);
+				} catch {}
+			});
+			return stake;
+		});
+		return {
+			stakes,
+			paging: buildPagingResult(total, pagination, stakes.length)
+		};
+	}
+	/**
+	* List rollups
+	*/
+	async listRollups(params = {}) {
+		const { paging, tokenAddress = "", erc20TokenAddress = "", foreignTokenAddress = "" } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		let qb = this.db.selectFrom("rollup").selectAll();
+		if (tokenAddress) qb = qb.where("tokenAddress", "=", tokenAddress);
+		const foreignTokenAddr = foreignTokenAddress || erc20TokenAddress;
+		if (foreignTokenAddr) {
+			const checksumAddr = toChecksumAddress(foreignTokenAddr);
+			const lowerAddr = foreignTokenAddr.toLowerCase();
+			qb = qb.where((eb) => eb.or([eb(eb.fn("json_extract", [eb.ref("foreignToken"), eb.val("$.contractAddress")]), "=", checksumAddr), eb(eb.fn("json_extract", [eb.ref("foreignToken"), eb.val("$.contractAddress")]), "=", lowerAddr)]));
+		}
+		debug("listRollups", {
+			paging,
+			pagination
+		});
+		const total = (await qb.clearSelect().select(this.db.fn.countAll().as("count")).executeTakeFirst())?.count ?? 0;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		return {
+			rollups: (await qb.execute()).map((row) => {
+				const rollup = { ...row };
+				[
+					"seedValidators",
+					"validators",
+					"foreignToken",
+					"tokenInfo",
+					"migrateHistory",
+					"vaultHistory",
+					"data"
+				].forEach((field) => {
+					if (typeof rollup[field] === "string") try {
+						rollup[field] = JSON.parse(rollup[field]);
+					} catch {}
+				});
+				return rollup;
+			}),
+			paging: formatNextPagination(total, pagination)
+		};
+	}
+	/**
+	* List rollup blocks
+	*/
+	async listRollupBlocks(params = {}) {
+		const { paging = {}, rollupAddress = "", tokenAddress = "", proposer = "", height = "", timeFilter = {}, txFilter = {}, validatorFilter = {} } = params;
+		const { txs = [] } = txFilter;
+		const { validators = [] } = validatorFilter;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "genesisTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		let qb = this.db.selectFrom("rollupBlock").selectAll();
+		if (rollupAddress) qb = qb.where("rollup", "=", rollupAddress);
+		if (Number(height) > 0) qb = qb.where("height", "=", Number(height));
+		if (proposer) qb = qb.where("proposer", "=", proposer);
+		const { startDateTime, endDateTime } = timeFilter;
+		const parsedStart = parseDateTime(startDateTime);
+		const parsedEnd = parseDateTime(endDateTime);
+		if (parsedStart && parsedEnd) qb = qb.where("genesisTime", ">", parsedStart).where("genesisTime", "<=", parsedEnd);
+		else if (parsedStart) qb = qb.where("genesisTime", ">", parsedStart);
+		else if (parsedEnd) qb = qb.where("genesisTime", "<=", parsedEnd);
+		if (txs.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("txs")]).as("je")).select("je.value").where("je.value", "in", txs)));
+		if (validators.length) qb = qb.where((eb) => eb.exists(eb.selectFrom(eb.fn("json_each", [eb.ref("validators")]).as("je")).select("je.value").where("je.value", "in", validators)));
+		if (tokenAddress) qb = qb.where((eb) => eb(eb.fn("json_extract", [eb.ref("tokenInfo"), eb.val("$.address")]), "=", tokenAddress));
+		const total = (await qb.clearSelect().select(this.db.fn.countAll().as("count")).executeTakeFirst())?.count ?? 0;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const blocks = (await qb.execute()).map((row) => {
+			const block = { ...row };
+			[
+				"signatures",
+				"txs",
+				"validators",
+				"tokenInfo",
+				"data"
+			].forEach((field) => {
+				if (typeof block[field] === "string") try {
+					block[field] = JSON.parse(block[field]);
+				} catch {}
+			});
+			return block;
+		});
+		return {
+			blocks,
+			paging: buildPagingResult(total, pagination, blocks.length)
+		};
+	}
+	/**
+	* List rollup validators
+	*/
+	async listRollupValidators(params = {}) {
+		const { paging = {}, rollupAddress = "" } = params;
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "genesisTime",
+			supportedSortFields: [
+				"joinTime",
+				"leaveTime",
+				"genesisTime",
+				"renaissanceTime"
+			]
+		});
+		let qb = this.db.selectFrom("rollupValidator").selectAll();
+		let countQb = this.db.selectFrom("rollupValidator").select((eb) => eb.fn.countAll().as("count"));
+		if (rollupAddress) {
+			qb = qb.where("rollup", "=", rollupAddress);
+			countQb = countQb.where("rollup", "=", rollupAddress);
+		}
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const [rawResults, countResult] = await Promise.all([qb.execute(), countQb.executeTakeFirst()]);
+		const validators = rawResults.map((row) => row);
+		return {
+			validators,
+			paging: buildPagingResult(Number(countResult?.count || 0), pagination, validators.length)
+		};
+	}
+	/**
+	* List delegations
+	*/
+	async listDelegations(params = {}) {
+		const { from, to, paging = {}, timeFilter = {} } = params;
+		if (!from && !to) return {
+			delegations: [],
+			paging: {
+				cursor: "0",
+				next: false,
+				total: 0
+			}
+		};
+		const pagination = formatPagination({
+			paging,
+			defaultSortField: "renaissanceTime",
+			supportedSortFields: ["genesisTime", "renaissanceTime"]
+		});
+		let qb = this.db.selectFrom("delegation").selectAll();
+		if (from && to) qb = qb.where("from_", "=", from).where("to_", "=", to);
+		else if (from) qb = qb.where("from_", "=", from);
+		else if (to) qb = qb.where("to_", "=", to);
+		const { startDateTime, endDateTime } = timeFilter;
+		const parsedStart = parseDateTime(startDateTime);
+		const parsedEnd = parseDateTime(endDateTime);
+		if (parsedStart && parsedEnd) qb = qb.where("renaissanceTime", ">", parsedStart).where("renaissanceTime", "<=", parsedEnd);
+		else if (parsedStart) qb = qb.where("renaissanceTime", ">", parsedStart);
+		else if (parsedEnd) qb = qb.where("renaissanceTime", "<=", parsedEnd);
+		const total = (await qb.clearSelect().select(this.db.fn.countAll().as("count")).executeTakeFirst())?.count ?? 0;
+		const orderDir = pagination.order.type === "desc" ? "desc" : "asc";
+		qb = qb.orderBy(pagination.order.field, orderDir).offset(pagination.cursor).limit(pagination.size);
+		const delegations = (await qb.execute()).map((row) => {
+			const delegation = { ...row };
+			delegation.from = delegation.from_;
+			delegation.to = delegation.to_;
+			delete delegation.from_;
+			delete delegation.to_;
+			[
+				"ops",
+				"context",
+				"data"
+			].forEach((field) => {
+				if (typeof delegation[field] === "string") try {
+					delegation[field] = JSON.parse(delegation[field]);
+				} catch {}
+			});
+			return formatDelegationAfterRead(delegation);
+		});
+		return {
+			delegations,
+			paging: buildPagingResult(total, pagination, delegations.length)
+		};
+	}
+};
+var base_default = SqliteBaseIndexDB;
+
+//#endregion
+export { base_default as default };