@ocap/statedb-memory 1.28.9 → 1.29.1

package/README.md

@@ -1,6 +1,5 @@
 # [**@ocap/statedb-memory**](https://github.com/arcblock/blockchain)
 
-[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 
 > OCAP Adapter that stores data to the disk through [nedb](https://npmjs.org/package/nedb)
 
@@ -15,7 +14,7 @@ bun install @ocap/statedb-memory
 ## Usage
 
 ```js
-const MemoryStateDB = require('@ocap/statedb-memory');
+const MemoryStateDB = require('@ocap/statedb-memory').default;
 
 const statedb = new MemoryStateDB();
 ```

package/esm/db.d.mts

@@ -0,0 +1,31 @@
+import { StateDB } from "@ocap/statedb";
+import Lokijs from "lokijs";
+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 作为内存存储引擎
+ */
+declare class MemoryStateDB extends StateDB {
+  name: string;
+  version: string;
+  db: Lokijs;
+  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();
+}
+//#endregion
+export { MemoryStateDB as default };

package/esm/db.mjs

@@ -0,0 +1,101 @@
+import package_default 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";
+import Lokijs from "lokijs";
+
+//#region src/db.ts
+const { name, version } = package_default;
+let instanceCounter = 0;
+/**
+* 内存 StateDB 实现
+* 使用 LokiJS 作为内存存储引擎
+*/
+var MemoryStateDB = class extends StateDB {
+	constructor() {
+		super();
+		this.name = name;
+		this.version = version;
+		instanceCounter += 1;
+		this.db = new Lokijs(`ocap-memory-statedb-${instanceCounter}.db`);
+		this.balance = new balance_default({
+			name: "balance",
+			uniqIndex: ["address", "tokenAddress"],
+			db: this.db
+		});
+		this.account = new account_default({
+			name: "account",
+			uniqIndex: "address",
+			balanceTable: this.balance,
+			syncBalance: true,
+			db: this.db
+		});
+		this.factory = new base_default({
+			name: "factory",
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance,
+			db: this.db
+		});
+		this.stake = new base_default({
+			name: "stake",
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance,
+			db: this.db
+		});
+		this.asset = new base_default({
+			name: "asset",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.delegation = new base_default({
+			name: "delegation",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.tx = new base_default({
+			name: "tx",
+			uniqIndex: "hash",
+			db: this.db
+		});
+		this.token = new token_default({
+			name: "token",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.chain = new base_default({
+			name: "chain",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.rollup = new rollup_default({
+			name: "rollup",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.rollupBlock = new base_default({
+			name: "rollupBlock",
+			uniqIndex: "hash",
+			db: this.db
+		});
+		this.evidence = new base_default({
+			name: "evidence",
+			uniqIndex: "hash",
+			db: this.db
+		});
+		this.tokenFactory = new base_default({
+			name: "tokenFactory",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.attachReadyListeners();
+	}
+};
+var db_default = MemoryStateDB;
+
+//#endregion
+export { db_default as default };

package/esm/index.d.mts

@@ -0,0 +1,2 @@
+import MemoryStateDB from "./db.mjs";
+export { MemoryStateDB 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,69 @@
+//#region package.json
+var name = "@ocap/statedb-memory";
+var package_default = {
+	name,
+	description: "OCAP statedb adapter that uses memory as backend statedb, just for test purpose",
+	version: "1.20.2",
+	author: "wangshijun <shijun@arcblock.io> (https://www.arcblock.io)",
+	bugs: {
+		"url": "https://github.com/ArcBlock/blockchain/issues",
+		"email": "shijun@arcblock.io"
+	},
+	publishConfig: { "access": "public" },
+	contributors: ["wangshijun <shijun@arcblock.io> (https://www.arcblock.io)"],
+	devDependencies: { "@types/lokijs": "^1.5.14" },
+	homepage: "https://github.com/ArcBlock/blockchain/tree/master/statedb/memory",
+	keywords: [
+		"ocap",
+		"statedb",
+		"memory"
+	],
+	license: "Apache-2.0",
+	type: "module",
+	main: "./lib/index.cjs",
+	module: "./esm/index.mjs",
+	types: "./esm/index.d.mts",
+	exports: {
+		".": {
+			"types": "./esm/index.d.mts",
+			"import": "./esm/index.mjs",
+			"default": "./lib/index.cjs"
+		},
+		"./lib/*.js": {
+			"types": "./esm/*.d.mts",
+			"import": "./esm/*.mjs",
+			"default": "./lib/*.cjs"
+		},
+		"./lib/*": {
+			"types": "./esm/*.d.mts",
+			"import": "./esm/*.mjs",
+			"default": "./lib/*.cjs"
+		}
+	},
+	files: ["lib", "esm"],
+	repository: {
+		"type": "git",
+		"url": "https://github.com/ArcBlock/blockchain/tree/master/statedb/memory"
+	},
+	scripts: {
+		"build": "tsdown",
+		"prebuild": "rm -rf lib esm",
+		"lint": "biome check",
+		"lint:fix": "biome check --write",
+		"test": "bun test",
+		"coverage": "npm run test -- --coverage"
+	},
+	gitHead: "87990c8b5e215107fc587c1ced0d6b3e2cd2483e",
+	dependencies: {
+		"@ocap/state": "workspace:*",
+		"@ocap/statedb": "workspace:*",
+		"@ocap/types": "workspace:*",
+		"@ocap/util": "workspace:*",
+		"debug": "^4.4.3",
+		"lodash": "^4.17.23",
+		"lokijs": "^1.5.12"
+	}
+};
+
+//#endregion
+export { package_default as default, name };

package/esm/table/account.d.mts

@@ -0,0 +1,17 @@
+import MemoryTable from "./base.mjs";
+import { IAccountState, IOperationContext } from "@ocap/types";
+
+//#region src/table/account.d.ts
+interface AccountOperationContext extends IOperationContext {
+  traceMigration?: boolean;
+}
+/**
+ * Account 表
+ * 扩展基础表，增加账户迁移追踪功能
+ */
+declare class AccountStateDB extends MemoryTable<IAccountState> {
+  _get(address: string, context?: AccountOperationContext): Promise<IAccountState | null>;
+  _create(key: string, attrs?: Partial<IAccountState>, context?: IOperationContext): Promise<IAccountState>;
+}
+//#endregion
+export { AccountStateDB 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 AccountStateDB = 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 = {}, context) {
+		const address = ensureChecksumAddress(key);
+		return super._create(address, {
+			...attrs,
+			[this.uniqIndex]: address
+		}, context);
+	}
+};
+var account_default = AccountStateDB;
+
+//#endregion
+export { account_default as default };

package/esm/table/balance.d.mts

@@ -0,0 +1,23 @@
+import MemoryTable from "./base.mjs";
+import { IBalanceState, IOperationContext } from "@ocap/types";
+
+//#region src/table/balance.d.ts
+
+/**
+ * Balance 表
+ * 扩展基础表，增加余额管理功能
+ */
+declare class BalanceTable extends MemoryTable<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,43 @@
+import base_default from "./base.mjs";
+import { ensureChecksumAddress } from "@ocap/state/lib/states/account";
+
+//#region src/table/balance.ts
+/**
+* Balance 表
+* 扩展基础表，增加余额管理功能
+*/
+var BalanceTable = class extends base_default {
+	async getBalance(address, _context) {
+		return (await this.collection.find({ address: ensureChecksumAddress(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,37 @@
+import { StateDBTable } from "@ocap/statedb";
+import Lokijs from "lokijs";
+import { IBalanceTable, IOperationContext } from "@ocap/types";
+
+//#region src/table/base.d.ts
+interface TableOptions {
+  name: string;
+  uniqIndex: string | string[];
+  syncBalance?: boolean;
+  balanceTable?: IBalanceTable;
+  db: Lokijs;
+}
+/**
+ * 内存表基类
+ * 使用 LokiJS Collection 作为底层存储
+ */
+declare class MemoryTable<T = unknown> extends StateDBTable<T> {
+  name: string;
+  balanceTable?: IBalanceTable;
+  syncBalance: boolean;
+  collection: Collection<LokiObj & Record<string, unknown>>;
+  constructor({
+    name,
+    uniqIndex,
+    balanceTable,
+    syncBalance,
+    db
+  }: TableOptions);
+  _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, _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 { MemoryTable as default };

package/esm/table/base.mjs

@@ -0,0 +1,94 @@
+import { name } from "../package.mjs";
+import { StateDBTable } from "@ocap/statedb";
+import Debug from "debug";
+import omit from "lodash/omit.js";
+
+//#region src/table/base.ts
+const debug = Debug(name);
+/**
+* 内存表基类
+* 使用 LokiJS Collection 作为底层存储
+*/
+var MemoryTable = class MemoryTable extends StateDBTable {
+	constructor({ name: name$1, uniqIndex, balanceTable, syncBalance = false, db }) {
+		super(uniqIndex);
+		this.name = name$1;
+		this.balanceTable = balanceTable;
+		this.syncBalance = syncBalance;
+		if (this.syncBalance && !this.balanceTable) throw new Error("balanceTable is required when syncBalance is true");
+		if (!db) throw new Error("db is required for MemoryTable");
+		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 MemoryTable.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) ?? null;
+		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 MemoryTable.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.uniqIndex ?? []);
+		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 = MemoryTable;
+
+//#endregion
+export { base_default as default };

package/esm/table/rollup.d.mts

@@ -0,0 +1,14 @@
+import MemoryTable from "./base.mjs";
+import { IRollupState } from "@ocap/types";
+
+//#region src/table/rollup.d.ts
+
+/**
+ * Rollup 表
+ * 扩展基础表，增加按代币查询功能
+ */
+declare class RollupTable extends MemoryTable<IRollupState> {
+  existByToken(token?: string): 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 MemoryTable from "./base.mjs";
+import { ITokenState } from "@ocap/types";
+
+//#region src/table/token.d.ts
+
+/**
+ * Token 表
+ * 扩展基础表，增加按符号查询功能
+ */
+declare class TokenTable extends MemoryTable<ITokenState> {
+  existBySymbol(symbol: string): 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,104 @@
+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");
+let lokijs = require("lokijs");
+lokijs = require_rolldown_runtime.__toESM(lokijs);
+
+//#region src/db.ts
+const { name, version } = require_package.default;
+let instanceCounter = 0;
+/**
+* 内存 StateDB 实现
+* 使用 LokiJS 作为内存存储引擎
+*/
+var MemoryStateDB = class extends _ocap_statedb.StateDB {
+	constructor() {
+		super();
+		this.name = name;
+		this.version = version;
+		instanceCounter += 1;
+		this.db = new lokijs.default(`ocap-memory-statedb-${instanceCounter}.db`);
+		this.balance = new require_table_balance.default({
+			name: "balance",
+			uniqIndex: ["address", "tokenAddress"],
+			db: this.db
+		});
+		this.account = new require_table_account.default({
+			name: "account",
+			uniqIndex: "address",
+			balanceTable: this.balance,
+			syncBalance: true,
+			db: this.db
+		});
+		this.factory = new require_table_base.default({
+			name: "factory",
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance,
+			db: this.db
+		});
+		this.stake = new require_table_base.default({
+			name: "stake",
+			uniqIndex: "address",
+			syncBalance: true,
+			balanceTable: this.balance,
+			db: this.db
+		});
+		this.asset = new require_table_base.default({
+			name: "asset",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.delegation = new require_table_base.default({
+			name: "delegation",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.tx = new require_table_base.default({
+			name: "tx",
+			uniqIndex: "hash",
+			db: this.db
+		});
+		this.token = new require_table_token.default({
+			name: "token",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.chain = new require_table_base.default({
+			name: "chain",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.rollup = new require_table_rollup.default({
+			name: "rollup",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.rollupBlock = new require_table_base.default({
+			name: "rollupBlock",
+			uniqIndex: "hash",
+			db: this.db
+		});
+		this.evidence = new require_table_base.default({
+			name: "evidence",
+			uniqIndex: "hash",
+			db: this.db
+		});
+		this.tokenFactory = new require_table_base.default({
+			name: "tokenFactory",
+			uniqIndex: "address",
+			db: this.db
+		});
+		this.attachReadyListeners();
+	}
+};
+var db_default = MemoryStateDB;
+
+//#endregion
+exports.default = db_default;