@clonegod/ttd-core 2.0.1

package/dist/cache/arb_event_pub.d.ts

@@ -0,0 +1,14 @@
+import { RedisCommand, RedisConfigChangeEventMessageType, RedisOrderEventMessageType, RedisQuoteEventMessageType, TradeResponseType } from "../../types";
+import { CHAIN_ID, DEX_ID } from "../index";
+import { ArbCache } from "./arb_cache";
+export declare class ArbEventPublisher {
+    arb_cache: ArbCache;
+    chain_id: CHAIN_ID;
+    redis_cmd: RedisCommand;
+    constructor(arb_cache: ArbCache);
+    publish_config_change_event(message: RedisConfigChangeEventMessageType): Promise<void>;
+    publish_quote_price_event(chain_id: string, message: RedisQuoteEventMessageType): Promise<void>;
+    publish_order_event(group_id: string, pair: string, dex_id: DEX_ID, message: RedisOrderEventMessageType): Promise<void>;
+    publish_wallet_raw_tx_event(group_id: string, wallet: string, message: any): Promise<void>;
+    publish_tx_result_event(group_id: string, pair: string, message: TradeResponseType): Promise<void>;
+}

package/dist/cache/arb_event_pub.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArbEventPublisher = void 0;
+const index_1 = require("../index");
+class ArbEventPublisher {
+    constructor(arb_cache) {
+        this.arb_cache = arb_cache;
+        this.redis_cmd = arb_cache.redis_cmd;
+        this.chain_id = arb_cache.chain_id;
+    }
+    publish_config_change_event(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let channel = (0, index_1.get_config_channel_name)(this.chain_id);
+            yield this.redis_cmd.publish(channel, JSON.stringify(message));
+            (0, index_1.log_info)('publish_config_change_event', { channel, message });
+        });
+    }
+    publish_quote_price_event(chain_id, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_quote_channel_name)(chain_id);
+            yield this.redis_cmd.publish(channel, JSON.stringify(message));
+            (0, index_1.log_debug)(`publish_quote_event, success`, {
+                channel, message
+            });
+        });
+    }
+    publish_order_event(group_id, pair, dex_id, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_order_channel_name)(group_id, pair, dex_id);
+            yield this.redis_cmd.publish(channel, JSON.stringify(message));
+            (0, index_1.log_info)(`publish_order_event, success`, {
+                channel, message
+            });
+        });
+    }
+    publish_wallet_raw_tx_event(group_id, wallet, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_wallet_raw_tx_channel_name)(group_id, wallet);
+            let data = JSON.stringify(message);
+            yield this.redis_cmd.publish(channel, data);
+            if (index_1.LOG.trace) {
+                (0, index_1.log_info)(`publish_wallet_raw_tx_event, success`, {
+                    channel,
+                    txid: message === null || message === void 0 ? void 0 : message.txid,
+                    message
+                });
+                return;
+            }
+            (0, index_1.log_info)(`publish_wallet_raw_tx_event, success`, {
+                channel,
+                txid: message === null || message === void 0 ? void 0 : message.txid
+            });
+        });
+    }
+    publish_tx_result_event(group_id, pair, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_tx_result_channel_name)(group_id, pair);
+            yield this.redis_cmd.publish(channel, JSON.stringify(message));
+            (0, index_1.log_debug)(`publish_tx_result_event, success`, {
+                channel,
+                group_id,
+                pair,
+                txid: message.data.txid
+            });
+        });
+    }
+}
+exports.ArbEventPublisher = ArbEventPublisher;

package/dist/cache/arb_event_sub.d.ts

@@ -0,0 +1,17 @@
+import { ArbCache, RedisCommand, RedisConfigChangeEventMessageType } from "../../types";
+import { CHAIN_ID, DEX_ID } from "../index";
+export declare class ArbEventSubscriber {
+    arb_cache: ArbCache;
+    chain_id: CHAIN_ID;
+    redis_cmd: RedisCommand;
+    constructor(arb_cache: ArbCache);
+    pre_load_config_cache(): Promise<void>;
+    subscribe_config_change_event(callback?: Function): Promise<void>;
+    on_config_token_change_event(message: RedisConfigChangeEventMessageType): Promise<boolean>;
+    on_config_pool_change_event(message: RedisConfigChangeEventMessageType): Promise<boolean>;
+    on_config_group_change_event(message: RedisConfigChangeEventMessageType): Promise<boolean>;
+    subscribe_quote_event(chain_id: string, callback: Function): Promise<void>;
+    subscribe_order_event(group_id: string, pair: string, dex_id: DEX_ID, callback: Function): Promise<void>;
+    subscribe_wallet_raw_tx_result(group_id: string, wallet: string, callback: Function): Promise<void>;
+    subscribe_tx_result(group_id: string, pair: string, callback: Function): Promise<void>;
+}

package/dist/cache/arb_event_sub.js

@@ -0,0 +1,166 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArbEventSubscriber = void 0;
+const index_1 = require("../index");
+class ArbEventSubscriber {
+    constructor(arb_cache) {
+        this.arb_cache = arb_cache;
+        this.redis_cmd = arb_cache.redis_cmd;
+        this.chain_id = arb_cache.chain_id;
+    }
+    pre_load_config_cache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.new_line)(5);
+            setTimeout(() => {
+                console.log(`=================================================================================`);
+                console.log(`|                              PRE-LOAD CONFIG CACHE                            |`);
+                console.log(`=================================================================================`);
+            }, 0);
+            if ((0, index_1.isEmpty)(this.arb_cache.token_list)) {
+                yield this.on_config_token_change_event(null);
+            }
+            else {
+                (0, index_1.log_info)(`skip pre-load token_list: arb_cache.token_list not empty, length=${this.arb_cache.token_list.length}`);
+            }
+            if ((0, index_1.isEmpty)(this.arb_cache.pool_list)) {
+                yield this.on_config_pool_change_event(null);
+            }
+            else {
+                (0, index_1.log_info)(`skip pre-load pool_list, arb_cache.pool_list not empty, length=${this.arb_cache.pool_list.length}`);
+            }
+            let group_ids = yield this.arb_cache.get_trade_group_id_list();
+            (0, index_1.log_info)(`pre_load_config_cache, all group ids in cache:`, group_ids);
+            for (let group_id of group_ids) {
+                yield this.on_config_group_change_event({
+                    event_type: index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.GROUP_CONFIG_CHANGE,
+                    event_time: Date.now(),
+                    group_id
+                });
+                yield (0, index_1.sleep)(1000);
+            }
+        });
+    }
+    subscribe_config_change_event() {
+        return __awaiter(this, arguments, void 0, function* (callback = () => { }) {
+            (0, index_1.new_line)(5);
+            setTimeout(() => {
+                console.log(`=================================================================================`);
+                console.log(`|                            SUBSCRIBE CONFIG CHANGE                            |`);
+                console.log(`=================================================================================`);
+            }, 0);
+            let channel = (0, index_1.get_config_channel_name)(this.chain_id);
+            const listener = (message, _channel) => {
+                (0, index_1.log_debug)('--------------------->>> subscribe_config_change_event => on event', { channel, message });
+                let event = JSON.parse(message);
+                switch (event.event_type) {
+                    case index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.TOKEN_CONFIG_CHANGE:
+                        this.on_config_token_change_event(event)
+                            .then((is_sussess) => callback(is_sussess, event))
+                            .catch(err => (0, index_1.log_error)(`handle TOKEN_CONFIG_CHANGE event error!!!`, err));
+                        break;
+                    case index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.POOL_CONFIG_CHANGE:
+                        this.on_config_pool_change_event(event)
+                            .then((is_sussess) => callback(is_sussess, event))
+                            .catch(err => (0, index_1.log_error)(`handle POOL_CONFIG_CHANGE event error!!!`, err));
+                        break;
+                    case index_1.REDIS_EVENT_TYPE_CONFIG_CHANGE.GROUP_CONFIG_CHANGE:
+                        this.on_config_group_change_event(event)
+                            .then((is_sussess) => callback(is_sussess, event))
+                            .catch(err => (0, index_1.log_error)(`handle GROUP_CONFIG_CHANGE event error!!!`, err));
+                        break;
+                    default:
+                        (0, index_1.log_warn)(`subscribe_config_change receive unkown type of message: ${message} `);
+                }
+            };
+            yield this.redis_cmd.subscribe(channel, listener);
+            (0, index_1.log_debug)(`subscribe_config_change_event, success`, { channel });
+        });
+    }
+    on_config_token_change_event(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_debug)(`on_config_token_change_event, refresh local token cache, start`, { message });
+            yield this.arb_cache.get_token_list_no_cache();
+            (0, index_1.log_debug)(`on_config_token_change_event, refresh local token cache, success`);
+            return true;
+        });
+    }
+    on_config_pool_change_event(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_debug)(`on_config_pool_change_event, refresh local pool cache, start`, { message });
+            yield this.arb_cache.get_pool_list_no_cache();
+            (0, index_1.log_debug)(`on_config_pool_change_event, refresh local pool cache, success`);
+            return true;
+        });
+    }
+    on_config_group_change_event(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let group_id_set_in_env = process.env.GROUP_ID;
+            let { group_id } = message;
+            if (group_id_set_in_env && group_id_set_in_env != group_id) {
+                (0, index_1.log_info)(`on_config_group_change_event, group_id not match, skip`, {
+                    group_id_set_in_env,
+                    group_id
+                });
+                return false;
+            }
+            (0, index_1.log_debug)(`on_config_group_change_event, refresh local group cache, start`, { message });
+            yield this.arb_cache.get_trade_service_by_group_id_no_cache(message.group_id);
+            (0, index_1.log_debug)(`on_config_group_change_event, refresh local group cache, success`);
+            return true;
+        });
+    }
+    subscribe_quote_event(chain_id, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_quote_channel_name)(chain_id);
+            const listener = (message, _channel) => {
+                (0, index_1.log_debug)('subscribe_quote_event => on event', { channel, message });
+                callback(message);
+            };
+            yield this.redis_cmd.subscribe(channel, listener);
+            (0, index_1.log_info)(`subscribe_quote_event, success`, { channel });
+        });
+    }
+    subscribe_order_event(group_id, pair, dex_id, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_order_channel_name)(group_id, pair, dex_id);
+            const listener = (message, _channel) => {
+                (0, index_1.log_info)('subscribe_order_event => on event', { channel, message });
+                callback(message);
+            };
+            yield this.redis_cmd.subscribe(channel, listener);
+            (0, index_1.log_info)(`subscribe_order_event, success`, { channel });
+        });
+    }
+    subscribe_wallet_raw_tx_result(group_id, wallet, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_wallet_raw_tx_channel_name)(group_id, wallet);
+            const listener = (message, _channel) => {
+                (0, index_1.log_debug)('subscribe_wallet_raw_tx_result => on event', { channel, message });
+                callback(message);
+            };
+            yield this.redis_cmd.subscribe(channel, listener);
+            (0, index_1.log_info)(`subscribe_wallet_raw_tx_result, success`, { channel });
+        });
+    }
+    subscribe_tx_result(group_id, pair, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = (0, index_1.get_tx_result_channel_name)(group_id, pair);
+            const listener = (message, _channel) => {
+                (0, index_1.log_info)('subscribe_tx_result => on event', { channel, message });
+                callback(message);
+            };
+            yield this.redis_cmd.subscribe(channel, listener);
+            (0, index_1.log_info)(`subscribe_tx_result, success`, { channel });
+        });
+    }
+}
+exports.ArbEventSubscriber = ArbEventSubscriber;

package/dist/cache/index.d.ts

@@ -0,0 +1,6 @@
+export * from './redis_client';
+export * from './redis_cmd';
+export * from './loading_cache';
+export * from './arb_cache';
+export * from './arb_event_pub';
+export * from './arb_event_sub';

package/dist/cache/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./redis_client"), exports);
+__exportStar(require("./redis_cmd"), exports);
+__exportStar(require("./loading_cache"), exports);
+__exportStar(require("./arb_cache"), exports);
+__exportStar(require("./arb_event_pub"), exports);
+__exportStar(require("./arb_event_sub"), exports);

package/dist/cache/loading_cache.d.ts

@@ -0,0 +1,62 @@
+import { RedisClientType } from "redis";
+import { CHAIN_ID } from "../index";
+export declare class LoadingCache {
+    redis_client: RedisClientType;
+    local_cache: Map<string, string>;
+    refresh_cache_timer: Map<string, any>;
+    constructor();
+    init(): Promise<void>;
+    get_key(chain_id: CHAIN_ID, cache_type: string, id: string): string;
+    set(chain_id: CHAIN_ID, cache_type: string, id: string, value: string): Promise<{
+        key: string;
+        res: string;
+    }>;
+    get(chain_id: CHAIN_ID, cache_type: string, id: string, skip_local?: boolean, auto_refresh?: boolean, refresh_interval_seconds?: number): Promise<{
+        key: string;
+        value: string;
+    }>;
+    refresh(key: string, interval_seconds: number): Promise<void>;
+    set_ex(chain_id: CHAIN_ID, cache_type: string, id: string, value: string, ttl: number): Promise<{
+        key: string;
+        res: string;
+        ttl: number;
+    }>;
+    get_hash_key(chain_id: CHAIN_ID, cache_type: string): string;
+    hset(chain_id: CHAIN_ID, cache_type: string, field: string, value: string): Promise<{
+        key: string;
+        field: string;
+        res: number[];
+        ttl: number;
+    }>;
+    hset_ex(chain_id: CHAIN_ID, cache_type: string, field: string, value: string, ttl?: number): Promise<{
+        key: string;
+        field: string;
+        res: number[];
+        ttl: number;
+    }>;
+    hdel(chain_id: CHAIN_ID, cache_type: string, field: string): Promise<number>;
+    hlen(chain_id: CHAIN_ID, cache_type: string): Promise<{
+        key: string;
+        value: number;
+    }>;
+    hkeys(chain_id: CHAIN_ID, cache_type: string): Promise<{
+        key: string;
+        value: string[];
+    }>;
+    hget(chain_id: CHAIN_ID, cache_type: string, field: string): Promise<{
+        key: string;
+        field: string;
+        value: string;
+    }>;
+    hmget(chain_id: CHAIN_ID, cache_type: string, fields: string[]): Promise<{
+        key: string;
+        fields: string[];
+        value: string[];
+    }>;
+    hget_all(chain_id: CHAIN_ID, cache_type: string): Promise<{
+        key: string;
+        value: {
+            [x: string]: string;
+        };
+    }>;
+}

package/dist/cache/loading_cache.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingCache = void 0;
+const index_1 = require("../index");
+const redis_client_1 = require("./redis_client");
+class LoadingCache {
+    constructor() {
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, index_1.log_info)('init redis client start');
+            this.local_cache = new Map();
+            this.refresh_cache_timer = new Map();
+            yield (0, index_1.sleep)(1000);
+            this.redis_client = yield (0, redis_client_1.getCache)('LoadingCache');
+            (0, index_1.log_info)('init redis client done');
+        });
+    }
+    get_key(chain_id, cache_type, id) {
+        if ((0, index_1.isEmpty)(chain_id) || (0, index_1.isEmpty)(cache_type) || (0, index_1.isEmpty)(id)) {
+            throw new Error(`set cache fialed! chain_id, cache_type, id is null or empty`);
+        }
+        return (0, index_1.get_cache_key)(chain_id, cache_type, id);
+    }
+    set(chain_id, cache_type, id, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.get_key(chain_id, cache_type, id);
+            this.local_cache.set(key, value);
+            let res = yield this.redis_client.set(key, value);
+            return {
+                key,
+                res
+            };
+        });
+    }
+    get(chain_id_1, cache_type_1, id_1) {
+        return __awaiter(this, arguments, void 0, function* (chain_id, cache_type, id, skip_local = false, auto_refresh = false, refresh_interval_seconds = 600) {
+            const key = this.get_key(chain_id, cache_type, id);
+            let value = '';
+            if (!skip_local) {
+                value = this.local_cache.get(key);
+            }
+            if (!value) {
+                if (index_1.LOG.debug) {
+                    (0, index_1.log_debug)(`!!! local cache missed, key=${key}`);
+                }
+                value = yield this.redis_client.get(key);
+                let ttl = yield this.redis_client.ttl(key);
+                if (ttl === -1) {
+                    this.local_cache.set(key, value);
+                }
+            }
+            if (!value) {
+                if (index_1.LOG.debug) {
+                    (0, index_1.log_debug)(`!!! redis cache missed, key=${key}`);
+                }
+            }
+            return {
+                key,
+                value
+            };
+        });
+    }
+    refresh(key, interval_seconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.refresh_cache_timer.has(key)) {
+                return;
+            }
+            let interval = Math.max(10, interval_seconds) * 1000;
+            let timeout_id = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.redis_client.get(key).then((new_value) => __awaiter(this, void 0, void 0, function* () {
+                        if (!new_value) {
+                            (0, index_1.log_debug)(`refresh cache: failed! key=${key}, get value from redis is empty! ignored`);
+                            return;
+                        }
+                        let pre_value = this.local_cache.get(key);
+                        let is_same = pre_value === new_value;
+                        (0, index_1.log_debug)(`refresh cache exeute! key=${key}, is_same=${is_same}, refresh interval=${interval}ms`);
+                        if (!is_same) {
+                            this.local_cache.set(key, new_value);
+                            (0, index_1.log_info)(`refresh cache: success! key=${key}`, { pre_value, new_value, is_same });
+                        }
+                    }));
+                }
+                catch (err) {
+                    (0, index_1.log_error)(`refresh cache: ${key} error`, err);
+                }
+            }), interval);
+            this.refresh_cache_timer.set(key, timeout_id);
+        });
+    }
+    set_ex(chain_id, cache_type, id, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ttl <= 0) {
+                throw new Error(`Invalid param: ttl=${ttl}! ttl must > 0`);
+            }
+            const key = this.get_key(chain_id, cache_type, id);
+            let res = yield this.redis_client.set(key, value, { EX: ttl });
+            return {
+                key,
+                res,
+                ttl
+            };
+        });
+    }
+    get_hash_key(chain_id, cache_type) {
+        if ((0, index_1.isEmpty)(chain_id) || (0, index_1.isEmpty)(cache_type)) {
+            throw new Error(`set cache fialed! chain_id, cache_type, id is null or empty`);
+        }
+        return (0, index_1.get_cache_key)(chain_id, cache_type, undefined);
+    }
+    hset(chain_id, cache_type, field, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.hset_ex(chain_id, cache_type, field, value);
+        });
+    }
+    hset_ex(chain_id_1, cache_type_1, field_1, value_1) {
+        return __awaiter(this, arguments, void 0, function* (chain_id, cache_type, field, value, ttl = -1) {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let res = [];
+            let res1 = yield this.redis_client.hSet(hkey, field, value);
+            res.push(res1);
+            if (ttl > 0) {
+                try {
+                    let res2 = yield this.redis_client.hExpire(hkey, field, ttl);
+                    res.push(res2);
+                }
+                catch (err) {
+                }
+            }
+            let data = {
+                key: hkey,
+                field,
+                res,
+                ttl
+            };
+            if (index_1.LOG.trace) {
+                (0, index_1.log_trace)('execute hSet, res=', data);
+            }
+            return data;
+        });
+    }
+    hdel(chain_id, cache_type, field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let res = yield this.redis_client.hDel(hkey, field);
+            return res;
+        });
+    }
+    hlen(chain_id, cache_type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let value = yield this.redis_client.hLen(hkey);
+            let data = {
+                key: hkey,
+                value
+            };
+            if (index_1.LOG.trace) {
+                (0, index_1.log_trace)('execute hLen, res=', data);
+            }
+            return data;
+        });
+    }
+    hkeys(chain_id, cache_type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let value = yield this.redis_client.hKeys(hkey);
+            let data = {
+                key: hkey,
+                value
+            };
+            if (index_1.LOG.trace) {
+                (0, index_1.log_trace)('execute hKeys, res=', data);
+            }
+            return data;
+        });
+    }
+    hget(chain_id, cache_type, field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let value = yield this.redis_client.hGet(hkey, field);
+            let data = {
+                key: hkey,
+                field,
+                value
+            };
+            if (index_1.LOG.trace) {
+                (0, index_1.log_trace)('execute hGet, res=', data);
+            }
+            return data;
+        });
+    }
+    hmget(chain_id, cache_type, fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let value = yield this.redis_client.hmGet(hkey, fields);
+            let data = {
+                key: hkey,
+                fields,
+                value
+            };
+            if (index_1.LOG.trace) {
+                (0, index_1.log_trace)('execute hGet, res=', data);
+            }
+            return data;
+        });
+    }
+    hget_all(chain_id, cache_type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hkey = (0, index_1.get_cache_key)(chain_id, cache_type, '');
+            let value = yield this.redis_client.hGetAll(hkey);
+            let data = {
+                key: hkey,
+                value
+            };
+            if (index_1.LOG.trace) {
+                (0, index_1.log_trace)('execute hGetAll, res=', data);
+            }
+            return data;
+        });
+    }
+}
+exports.LoadingCache = LoadingCache;

package/dist/cache/redis_client.d.ts

@@ -0,0 +1,3 @@
+import type { RedisClientType } from 'redis';
+declare function getCache(module_name?: string): Promise<RedisClientType>;
+export { getCache, };