@ocap/indexdb-elasticsearch 1.21.3 → 1.22.0

package/lib/db.js

@@ -19,6 +19,7 @@ const Rollup = require('./table/rollup');
 const RollupBlock = require('./table/rollup-block');
 const RollupValidator = require('./table/rollup-validator');
 const TokenDistribution = require('./table/token-distribution');
+const TokenFactory = require('./table/token-factory');
 
 const { name, version } = require('../package.json');
 const { formatQueryResult, getAuthHeaders, getTimeCondition } = require('./util');
@@ -94,6 +95,7 @@ class ESIndexDB extends BaseIndexDB {
     this.rollupBlock = new RollupBlock(this);
     this.rollupValidator = new RollupValidator(this);
     this.tokenDistribution = new TokenDistribution(this);
+    this.tokenFactory = new TokenFactory(this);
 
     this.attachReadyListeners();
   }
@@ -112,6 +114,7 @@ class ESIndexDB extends BaseIndexDB {
     rollupFilter = {},
     stakeFilter = {},
     delegationFilter = {},
+    tokenFactoryFilter = {},
   } = {}) {
     const pagination = formatPagination({ paging, defaultSortField: 'time' });
 
@@ -125,6 +128,7 @@ class ESIndexDB extends BaseIndexDB {
     const { rollups = [] } = rollupFilter;
     const { stakes = [] } = stakeFilter;
     const { delegations = [] } = delegationFilter;
+    const { tokenFactories = [] } = tokenFactoryFilter;
 
     // OR is spelled should
     // AND is spelled must
@@ -197,6 +201,10 @@ class ESIndexDB extends BaseIndexDB {
       conditions.push({ terms: { delegations } });
     }
 
+    if (tokenFactories.length) {
+      conditions.push({ terms: { tokenFactories } });
+    }
+
     const condition = getTimeCondition(timeFilter, ['time'], 'time');
     if (condition) {
       conditions.push(condition);
@@ -401,6 +409,48 @@ class ESIndexDB extends BaseIndexDB {
     return { tokens: items.map((x) => Token.formatAfterRead(x)), paging: nextPaging };
   }
 
+  async listTokenFactories({ owner, reserveAddress, tokenAddress, paging, timeFilter = {} } = {}) {
+    debug('listTokenFactories', { owner, reserveAddress, tokenAddress, paging });
+
+    const conditions = [];
+
+    if (owner) {
+      conditions.push({ term: { owner } });
+    }
+
+    if (reserveAddress) {
+      conditions.push({ term: { reserveAddress } });
+    }
+
+    if (tokenAddress) {
+      conditions.push({ term: { tokenAddress } });
+    }
+
+    const condition = getTimeCondition(timeFilter, ['genesisTime', 'renaissanceTime']);
+    if (condition) {
+      conditions.push(condition);
+    }
+
+    const pagination = formatPagination({
+      paging,
+      defaultSortField: 'renaissanceTime',
+      supportedSortFields: ['genesisTime', 'renaissanceTime', 'reserveBalance', 'currentSupply'],
+    });
+
+    const result = await this.tokenFactory.search({
+      from: pagination.cursor,
+      size: pagination.size,
+      body: {
+        track_total_hits: TRACK_TOTAL_HITS,
+        query: conditions.length ? { bool: { must: conditions } } : FALLBACK_QUERY,
+        sort: [{ [pagination.order.field]: { order: pagination.order.type } }],
+      },
+    });
+
+    const { items, paging: nextPaging } = formatQueryResult(result, pagination);
+    return { tokenFactories: items.map((x) => TokenFactory.formatAfterRead(x)), paging: nextPaging };
+  }
+
   async listFactories({ ownerAddress, addressList, paging, timeFilter = {} } = {}) {
     debug('listTokens', { ownerAddress, paging });
     const pagination = formatPagination({

package/lib/model/token-factory.js

@@ -0,0 +1,52 @@
+module.exports = () => ({
+  mappings: {
+    dynamic: false,
+    properties: {
+      address: { type: 'keyword' },
+      owner: { type: 'keyword' },
+      tokenAddress: { type: 'keyword' },
+      reserveAddress: { type: 'keyword' },
+      curve: {
+        type: 'nested',
+        properties: {
+          type: { type: 'keyword' },
+          basePrice: { type: 'keyword' },
+          fixedPrice: { type: 'keyword' },
+          slope: { type: 'keyword' },
+          constant: { type: 'long' },
+        },
+      },
+      feeRate: { type: 'keyword', index: false },
+      currentSupply: { type: 'keyword' },
+      reserveBalance: { type: 'keyword' },
+      status: { type: 'keyword' },
+      data: { type: 'object', enabled: false },
+      genesisTime: { type: 'date' },
+      renaissanceTime: { type: 'date' },
+      token: {
+        type: 'nested',
+        properties: {
+          address: { type: 'keyword' },
+          symbol: { type: 'keyword' },
+          decimal: { type: 'long' },
+          unit: { type: 'keyword' },
+        },
+      },
+      reserveToken: {
+        type: 'nested',
+        properties: {
+          address: { type: 'keyword' },
+          symbol: { type: 'keyword' },
+          decimal: { type: 'long' },
+          unit: { type: 'keyword' },
+        },
+      },
+    },
+  },
+  settings: {
+    index: {
+      number_of_shards: +(process.env.ES_SHARD_COUNT || 1),
+      number_of_replicas: +(process.env.ES_REPLICA_COUNT || 0),
+    },
+  },
+});

package/lib/model/token.js

@@ -10,6 +10,7 @@ module.exports = () => ({
       icon: { type: 'text', index: false },
       totalSupply: { type: 'keyword' },
       initialSupply: { type: 'keyword' },
+      tokenFactoryAddress: { type: 'keyword' },
       genesisTime: { type: 'date' },
       renaissanceTime: { type: 'date' },
       data: { type: 'object', enabled: false },

package/lib/model/tx.js

@@ -89,6 +89,7 @@ module.exports = () => ({
       stakes: { type: 'keyword' },
       rollups: { type: 'keyword' },
       delegations: { type: 'keyword' },
+      tokenFactories: { type: 'keyword' },
     },
   },
   settings: {

package/lib/table/token-factory.js

@@ -0,0 +1,49 @@
+const ESIndex = require('./base');
+const getParams = require('../model/token-factory');
+const { getTableName } = require('../util');
+
+class TokenFactory extends ESIndex {
+  constructor(db) {
+    super({
+      name: getTableName(db.config.prefix, 'token_factory'),
+      docId: 'address',
+      client: db.client,
+      http: db.http,
+      indexParams: getParams(),
+    });
+
+    this.tokenLength = db.config.tokenLength;
+  }
+
+  static formatBeforeUpdate(data, tokenLength) {
+    data.currentSupply = super.padBalance(data.currentSupply, tokenLength);
+    data.reserveBalance = super.padBalance(data.reserveBalance, tokenLength);
+
+    return data;
+  }
+
+  static formatAfterRead(data) {
+    if (data) {
+      data.currentSupply = super.trimBalance(data.currentSupply);
+      data.reserveBalance = super.trimBalance(data.reserveBalance);
+    }
+
+    return data;
+  }
+
+  batchInsert(rows) {
+    const formatted = rows.map((x) => TokenFactory.formatBeforeUpdate(x, this.tokenLength));
+    return super.batchInsert(formatted);
+  }
+
+  _insert(row) {
+    return super._insert(TokenFactory.formatBeforeUpdate(row, this.tokenLength));
+  }
+
+  async _get(key) {
+    const item = await super._get(key);
+    return TokenFactory.formatAfterRead(item);
+  }
+}
+
+module.exports = TokenFactory;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ocap/indexdb-elasticsearch",
   "description": "OCAP indexdb adapter that uses elasticsearch as backend",
-  "version": "1.21.3",
+  "version": "1.22.0",
   "author": "wangshijun <shijun@arcblock.io> (https://www.arcblock.io)",
   "bugs": {
     "url": "https://github.com/ArcBlock/blockchain/issues",
@@ -16,7 +16,7 @@
   "devDependencies": {
     "dotenv-flow": "^3.2.0",
     "jest": "^29.7.0",
-    "@ocap/indexdb-test": "1.21.3"
+    "@ocap/indexdb-test": "1.22.0"
   },
   "homepage": "https://github.com/ArcBlock/blockchain/tree/master/indexdb/elasticsearch",
   "keywords": [
@@ -40,9 +40,9 @@
     "bn.js": "^5.2.1",
     "debug": "^4.3.6",
     "lodash": "^4.17.21",
-    "@arcblock/did": "1.21.3",
-    "@ocap/indexdb": "1.21.3",
-    "@ocap/util": "1.21.3"
+    "@arcblock/did": "1.22.0",
+    "@ocap/indexdb": "1.22.0",
+    "@ocap/util": "1.22.0"
   },
   "scripts": {
     "lint": "eslint tests lib",