@ocap/statedb-fs 1.28.8 → 1.29.0

package/README.md

@@ -1,6 +1,5 @@
 # [**@ocap/statedb-fs**](https://github.com/arcblock/blockchain)
 
-[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 
 > OCAP statedb adapter that stores data to the disk through lokijs
 
@@ -15,7 +14,7 @@ bun install @ocap/statedb-fs
 ## Usage
 
 ```js
-const FsStateDB = require('@ocap/statedb-fs');
+const FsStateDB = require('@ocap/statedb-fs').default;
 const statedb = new FsStateDB(os.tmpdir());
 
 statedb.account.create('123', { key: 'value' });

package/esm/db.d.mts

@@ -0,0 +1,29 @@
+import { StateDB } from "@ocap/statedb";
+import { IAccountState, IAssetFactoryState, IAssetState, IBalanceTable, IChainState, IDelegateState, IEvidenceState, IRollupBlock, IRollupTable, IStakeState, IStateTable, ITokenFactoryState, ITokenTable, ITxState } from "@ocap/types";
+
+//#region src/db.d.ts
+
+/**
+ * 文件系统 StateDB 实现
+ * 使用 LokiJS + FSAdapter 作为文件存储引擎
+ */
+declare class FsStateDB extends StateDB {
+  name: string;
+  version: string;
+  balance: IBalanceTable;
+  account: IStateTable<IAccountState>;
+  factory: IStateTable<IAssetFactoryState>;
+  stake: IStateTable<IStakeState>;
+  asset: IStateTable<IAssetState>;
+  delegation: IStateTable<IDelegateState>;
+  tx: IStateTable<ITxState>;
+  token: ITokenTable;
+  chain: IStateTable<IChainState>;
+  rollup: IRollupTable;
+  rollupBlock: IStateTable<IRollupBlock>;
+  evidence: IStateTable<IEvidenceState>;
+  tokenFactory: IStateTable<ITokenFactoryState>;
+  constructor(dataDir: string);
+}
+//#endregion
+export { FsStateDB as default };

package/esm/db.mjs

@@ -0,0 +1,96 @@
+import { name, version } from "./package.mjs";
+import base_default from "./table/base.mjs";
+import account_default from "./table/account.mjs";
+import balance_default from "./table/balance.mjs";
+import rollup_default from "./table/rollup.mjs";
+import token_default from "./table/token.mjs";
+import { StateDB } from "@ocap/statedb";
+
+//#region src/db.ts
+/**
+* 文件系统 StateDB 实现
+* 使用 LokiJS + FSAdapter 作为文件存储引擎
+*/
+var FsStateDB = class extends StateDB {
+	constructor(dataDir) {
+		super();
+		this.name = name;
+		this.version = version;
+		this.balance = new balance_default({
+			name: "balance",
+			dataDir,
+			uniqIndex: ["address", "tokenAddress"]
+		});
+		this.account = new account_default({
+			name: "account",
+			dataDir,
+			uniqIndex: "address",
+			balanceTable: this.balance,
+			syncBalance: true
+		});
+		this.factory = new base_default({
+			name: "factory",
+			dataDir,
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance
+		});
+		this.stake = new base_default({
+			name: "stake",
+			dataDir,
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance
+		});
+		this.asset = new base_default({
+			name: "asset",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.delegation = new base_default({
+			name: "delegation",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.tx = new base_default({
+			name: "tx",
+			dataDir,
+			uniqIndex: "hash"
+		});
+		this.token = new token_default({
+			name: "token",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.chain = new base_default({
+			name: "chain",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.rollup = new rollup_default({
+			name: "rollup",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.rollupBlock = new base_default({
+			name: "rollupBlock",
+			dataDir,
+			uniqIndex: "hash"
+		});
+		this.evidence = new base_default({
+			name: "evidence",
+			dataDir,
+			uniqIndex: "hash"
+		});
+		this.tokenFactory = new base_default({
+			name: "tokenFactory",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.attachReadyListeners();
+	}
+};
+var db_default = FsStateDB;
+
+//#endregion
+export { db_default as default };

package/esm/index.d.mts

@@ -0,0 +1,2 @@
+import FsStateDB from "./db.mjs";
+export { FsStateDB as default };

package/esm/index.mjs

@@ -0,0 +1,3 @@
+import db_default from "./db.mjs";
+
+export { db_default as default };

package/esm/package.mjs

@@ -0,0 +1,6 @@
+//#region package.json
+var name = "@ocap/statedb-fs";
+var version = "1.20.2";
+
+//#endregion
+export { name, version };

package/esm/table/account.d.mts

@@ -0,0 +1,17 @@
+import FsTable from "./base.mjs";
+import { IAccountState, IOperationContext } from "@ocap/types";
+
+//#region src/table/account.d.ts
+interface AccountOperationContext extends IOperationContext {
+  traceMigration?: boolean;
+}
+/**
+ * Account 表
+ * 扩展基础表，增加账户迁移追踪功能
+ */
+declare class AccountTable extends FsTable<IAccountState> {
+  _get(address: string | Record<string, unknown>, context?: AccountOperationContext): Promise<IAccountState | null>;
+  _create(key: string | Record<string, unknown>, attrs?: Partial<IAccountState>, ctx?: IOperationContext): Promise<IAccountState>;
+}
+//#endregion
+export { AccountTable as default };

package/esm/table/account.mjs

@@ -0,0 +1,27 @@
+import base_default from "./base.mjs";
+import { ensureChecksumAddress } from "@ocap/state/lib/states/account";
+
+//#region src/table/account.ts
+/**
+* Account 表
+* 扩展基础表，增加账户迁移追踪功能
+*/
+var AccountTable = class extends base_default {
+	async _get(address, context = {}) {
+		const { traceMigration = true, ...restContext } = context;
+		const current = await super._get(ensureChecksumAddress(address), restContext);
+		if (current && traceMigration && Array.isArray(current.migratedTo) && current.migratedTo.length) return this._get(current.migratedTo[0], context);
+		return current;
+	}
+	_create(key, attrs = {}, ctx) {
+		const address = ensureChecksumAddress(key);
+		return super._create(address, {
+			...attrs,
+			address
+		}, ctx);
+	}
+};
+var account_default = AccountTable;
+
+//#endregion
+export { account_default as default };

package/esm/table/balance.d.mts

@@ -0,0 +1,23 @@
+import FsTable from "./base.mjs";
+import { IBalanceState, IOperationContext } from "@ocap/types";
+
+//#region src/table/balance.d.ts
+
+/**
+ * Balance 表
+ * 扩展基础表，增加余额管理功能
+ */
+declare class BalanceTable extends FsTable<IBalanceState> {
+  getBalance(address: string, _context?: IOperationContext): Promise<Record<string, string>>;
+  updateBalance({
+    address,
+    tokens,
+    context
+  }: {
+    address: string;
+    tokens: Record<string, string>;
+    context?: unknown;
+  }, ctx?: IOperationContext): Promise<Record<string, string>>;
+}
+//#endregion
+export { BalanceTable as default };

package/esm/table/balance.mjs

@@ -0,0 +1,42 @@
+import base_default from "./base.mjs";
+
+//#region src/table/balance.ts
+/**
+* Balance 表
+* 扩展基础表，增加余额管理功能
+*/
+var BalanceTable = class extends base_default {
+	async getBalance(address, _context) {
+		return (await this.collection.find({ address }) || []).reduce((acc, token) => {
+			acc[token.tokenAddress] = token.balance;
+			return acc;
+		}, {});
+	}
+	async updateBalance({ address, tokens, context = {} }, ctx) {
+		if (!Object.keys(tokens).length) return {};
+		const tokenBalances = await this.getBalance(address);
+		const updatedTokens = Object.keys(tokens).filter((token) => tokenBalances[token] && tokenBalances[token] !== "0" || tokens[token] && tokens[token] !== "0").filter((token) => tokenBalances[token] !== tokens[token]);
+		await Promise.all(updatedTokens.map(async (token) => {
+			const key = {
+				address,
+				tokenAddress: token
+			};
+			if (tokenBalances[token]) await this.update(key, {
+				...key,
+				balance: tokens[token],
+				context
+			}, ctx);
+			else await this.create(key, {
+				...key,
+				balance: tokens[token],
+				context
+			}, ctx);
+			tokenBalances[token] = tokens[token];
+		}));
+		return tokens;
+	}
+};
+var balance_default = BalanceTable;
+
+//#endregion
+export { balance_default as default };

package/esm/table/base.d.mts

@@ -0,0 +1,38 @@
+import { StateDBTable } from "@ocap/statedb";
+import Lokijs from "lokijs";
+import { IBalanceTable, IOperationContext } from "@ocap/types";
+
+//#region src/table/base.d.ts
+interface FsTableOptions {
+  name: string;
+  dataDir: string;
+  uniqIndex: string | string[];
+  balanceTable?: IBalanceTable;
+  syncBalance?: boolean;
+}
+/**
+ * 文件系统表基类
+ * 使用 LokiJS + FSAdapter 作为底层存储
+ */
+declare class FsTable<T = unknown> extends StateDBTable<T> {
+  name: string;
+  dataDir: string;
+  collection: Lokijs.Collection | null;
+  balanceTable?: IBalanceTable;
+  syncBalance: boolean;
+  constructor({
+    name,
+    dataDir,
+    uniqIndex,
+    balanceTable,
+    syncBalance
+  }: FsTableOptions);
+  _create(key: string | Record<string, unknown>, attrs?: Partial<T>, _context?: IOperationContext): Promise<T>;
+  _get(key: string | Record<string, unknown>, _context?: IOperationContext): Promise<T | null>;
+  _history(_key?: string | Record<string, unknown>, _context?: IOperationContext): T[];
+  _update(key: string | Record<string, unknown>, updates: Partial<T>, _context?: IOperationContext): Promise<T>;
+  updateOrCreate(exist: unknown, state: Partial<T>, ctx?: IOperationContext): Promise<T>;
+  _reset(_context?: IOperationContext): void;
+}
+//#endregion
+export { FsTable as default };

package/esm/table/base.mjs

@@ -0,0 +1,108 @@
+import { name } from "../package.mjs";
+import { StateDBTable } from "@ocap/statedb";
+import path from "node:path";
+import omit from "lodash/omit.js";
+import Lokijs from "lokijs";
+import FsAdapter from "lokijs/src/loki-fs-structured-adapter.js";
+import Debug from "debug";
+
+//#region src/table/base.ts
+const debug = Debug(name);
+/**
+* 文件系统表基类
+* 使用 LokiJS + FSAdapter 作为底层存储
+*/
+var FsTable = class FsTable extends StateDBTable {
+	constructor({ name: name$1, dataDir, uniqIndex, balanceTable, syncBalance = false }) {
+		super(uniqIndex);
+		this.name = name$1;
+		this.dataDir = dataDir;
+		this.collection = null;
+		this.balanceTable = balanceTable;
+		this.syncBalance = syncBalance;
+		if (this.syncBalance && !this.balanceTable) throw new Error("balanceTable is required when syncBalance is true");
+		const adapter = new FsAdapter();
+		const db = new Lokijs(path.join(dataDir, `${name$1}.db`), {
+			adapter,
+			autoload: true,
+			autosave: true,
+			autosaveInterval: 1e3,
+			autoloadCallback: () => {
+				this.collection = db.getCollection(name$1);
+				if (this.collection === null) this.collection = db.addCollection(name$1, {
+					unique: [this.primaryKey],
+					clone: true
+				});
+				this.markReady();
+			}
+		});
+	}
+	async _create(key, attrs = {}, _context) {
+		const id = this.generatePrimaryKey(key);
+		if (await FsTable.prototype._get.call(this, id)) throw new Error(`${this.name} already exists: ${key}`);
+		debug(`insert ${this.name}`, attrs);
+		const insertAttrs = { ...attrs };
+		if (this.syncBalance) delete insertAttrs.tokens;
+		const result = await this.collection.insert({
+			[this.primaryKey]: id,
+			...insertAttrs
+		});
+		if (this.syncBalance && attrs.tokens) {
+			debug(`update balance for ${this.name}`, attrs);
+			result.tokens = await this.balanceTable.updateBalance({
+				address: attrs.address,
+				tokens: attrs.tokens,
+				context: attrs.context
+			});
+		}
+		return result;
+	}
+	async _get(key, _context) {
+		if (!key) return null;
+		const id = this.generatePrimaryKey(key);
+		const result = await this.collection.by(this.primaryKey, id);
+		if (result && this.syncBalance) {
+			const balance = await this.balanceTable.getBalance(result.address);
+			result.tokens = {
+				...result.tokens || {},
+				...balance
+			};
+		}
+		return result;
+	}
+	_history(_key, _context) {
+		return [];
+	}
+	async _update(key, updates, _context) {
+		const id = this.generatePrimaryKey(key);
+		const doc = await FsTable.prototype._get.call(this, id);
+		if (!doc) throw new Error(`${this.name} does not exists: ${key}`);
+		Object.assign(doc, updates);
+		const updateAttrs = { ...doc };
+		if (this.syncBalance) delete updateAttrs.tokens;
+		await this.collection.update(updateAttrs);
+		if (this.syncBalance && doc.tokens) {
+			debug(`update balance for ${this.name}`, doc);
+			doc.tokens = await this.balanceTable.updateBalance({
+				address: doc.address,
+				tokens: doc.tokens,
+				context: doc.context
+			});
+		}
+		return doc;
+	}
+	updateOrCreate(exist, state, ctx) {
+		const id = this.generatePrimaryKey(state);
+		const attrs = omit(state, this.primaryKey);
+		if (!id) throw new Error("Cannot update or create without uniq index");
+		if (exist) return this.update(id, attrs, ctx);
+		return this.create(id, attrs, ctx);
+	}
+	_reset(_context) {
+		this.collection.removeWhere({});
+	}
+};
+var base_default = FsTable;
+
+//#endregion
+export { base_default as default };

package/esm/table/rollup.d.mts

@@ -0,0 +1,14 @@
+import FsTable from "./base.mjs";
+import { IRollupState } from "@ocap/types";
+
+//#region src/table/rollup.d.ts
+
+/**
+ * Rollup 表
+ * 扩展基础表，增加按代币查询功能
+ */
+declare class RollupTable extends FsTable<IRollupState> {
+  existByToken(token?: string | null): Promise<boolean>;
+}
+//#endregion
+export { RollupTable as default };

package/esm/table/rollup.mjs

@@ -0,0 +1,20 @@
+import base_default from "./base.mjs";
+
+//#region src/table/rollup.ts
+/**
+* Rollup 表
+* 扩展基础表，增加按代币查询功能
+*/
+var RollupTable = class extends base_default {
+	async existByToken(token) {
+		if (!token) return false;
+		return this.collection.count({
+			tokenAddress: token,
+			paused: false
+		}) > 0;
+	}
+};
+var rollup_default = RollupTable;
+
+//#endregion
+export { rollup_default as default };

package/esm/table/token.d.mts

@@ -0,0 +1,14 @@
+import FsTable from "./base.mjs";
+import { ITokenState } from "@ocap/types";
+
+//#region src/table/token.d.ts
+
+/**
+ * Token 表
+ * 扩展基础表，增加按符号查询功能
+ */
+declare class TokenTable extends FsTable<ITokenState> {
+  existBySymbol(symbol?: string | null): Promise<boolean>;
+}
+//#endregion
+export { TokenTable as default };

package/esm/table/token.mjs

@@ -0,0 +1,17 @@
+import base_default from "./base.mjs";
+
+//#region src/table/token.ts
+/**
+* Token 表
+* 扩展基础表，增加按符号查询功能
+*/
+var TokenTable = class extends base_default {
+	async existBySymbol(symbol) {
+		if (!symbol) throw new Error("param symbol is required");
+		return this.collection.count({ symbol }) > 0;
+	}
+};
+var token_default = TokenTable;
+
+//#endregion
+export { token_default as default };

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/db.cjs

@@ -0,0 +1,98 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_package = require('./package.cjs');
+const require_table_base = require('./table/base.cjs');
+const require_table_account = require('./table/account.cjs');
+const require_table_balance = require('./table/balance.cjs');
+const require_table_rollup = require('./table/rollup.cjs');
+const require_table_token = require('./table/token.cjs');
+let _ocap_statedb = require("@ocap/statedb");
+
+//#region src/db.ts
+/**
+* 文件系统 StateDB 实现
+* 使用 LokiJS + FSAdapter 作为文件存储引擎
+*/
+var FsStateDB = class extends _ocap_statedb.StateDB {
+	constructor(dataDir) {
+		super();
+		this.name = require_package.name;
+		this.version = require_package.version;
+		this.balance = new require_table_balance.default({
+			name: "balance",
+			dataDir,
+			uniqIndex: ["address", "tokenAddress"]
+		});
+		this.account = new require_table_account.default({
+			name: "account",
+			dataDir,
+			uniqIndex: "address",
+			balanceTable: this.balance,
+			syncBalance: true
+		});
+		this.factory = new require_table_base.default({
+			name: "factory",
+			dataDir,
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance
+		});
+		this.stake = new require_table_base.default({
+			name: "stake",
+			dataDir,
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance
+		});
+		this.asset = new require_table_base.default({
+			name: "asset",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.delegation = new require_table_base.default({
+			name: "delegation",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.tx = new require_table_base.default({
+			name: "tx",
+			dataDir,
+			uniqIndex: "hash"
+		});
+		this.token = new require_table_token.default({
+			name: "token",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.chain = new require_table_base.default({
+			name: "chain",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.rollup = new require_table_rollup.default({
+			name: "rollup",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.rollupBlock = new require_table_base.default({
+			name: "rollupBlock",
+			dataDir,
+			uniqIndex: "hash"
+		});
+		this.evidence = new require_table_base.default({
+			name: "evidence",
+			dataDir,
+			uniqIndex: "hash"
+		});
+		this.tokenFactory = new require_table_base.default({
+			name: "tokenFactory",
+			dataDir,
+			uniqIndex: "address"
+		});
+		this.attachReadyListeners();
+	}
+};
+var db_default = FsStateDB;
+
+//#endregion
+exports.default = db_default;

package/lib/db.d.cts

@@ -0,0 +1,29 @@
+import { StateDB } from "@ocap/statedb";
+import { IAccountState, IAssetFactoryState, IAssetState, IBalanceTable, IChainState, IDelegateState, IEvidenceState, IRollupBlock, IRollupTable, IStakeState, IStateTable, ITokenFactoryState, ITokenTable, ITxState } from "@ocap/types";
+
+//#region src/db.d.ts
+
+/**
+ * 文件系统 StateDB 实现
+ * 使用 LokiJS + FSAdapter 作为文件存储引擎
+ */
+declare class FsStateDB extends StateDB {
+  name: string;
+  version: string;
+  balance: IBalanceTable;
+  account: IStateTable<IAccountState>;
+  factory: IStateTable<IAssetFactoryState>;
+  stake: IStateTable<IStakeState>;
+  asset: IStateTable<IAssetState>;
+  delegation: IStateTable<IDelegateState>;
+  tx: IStateTable<ITxState>;
+  token: ITokenTable;
+  chain: IStateTable<IChainState>;
+  rollup: IRollupTable;
+  rollupBlock: IStateTable<IRollupBlock>;
+  evidence: IStateTable<IEvidenceState>;
+  tokenFactory: IStateTable<ITokenFactoryState>;
+  constructor(dataDir: string);
+}
+//#endregion
+export { FsStateDB as default };

package/lib/index.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_db = require('./db.cjs');
+
+exports.default = require_db.default;

package/lib/index.d.cts

@@ -0,0 +1,2 @@
+import FsStateDB from "./db.cjs";
+export { FsStateDB as default };

package/lib/package.cjs

@@ -0,0 +1,18 @@
+
+//#region package.json
+var name = "@ocap/statedb-fs";
+var version = "1.20.2";
+
+//#endregion
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
+});