@clonegod/ttd-core 2.0.1

package/dist/market_price/estimate_token_amount.d.ts

@@ -0,0 +1,4 @@
+import { ArbCache, StandardTokenInfoType } from "../../types";
+export declare class EstimateAmountInToken {
+    static estimate_amount_in_token(arb_cache: ArbCache, token: StandardTokenInfoType, amount_in_usd: number, query_token_market_price_url?: string): Promise<string>;
+}

package/dist/market_price/estimate_token_amount.js

@@ -0,0 +1,109 @@
+"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.EstimateAmountInToken = void 0;
+const index_1 = require("../index");
+var tmp_token_price_cache = new Map();
+const PRICE_CACHE_EXPIRE_MILLS = 3 * 60 * 1000;
+setInterval(() => {
+    let expires = [];
+    let cur_time = new Date().getTime();
+    for (let [symbol, value] of tmp_token_price_cache) {
+        if (cur_time - value.create_time > PRICE_CACHE_EXPIRE_MILLS) {
+            expires.push(symbol);
+        }
+    }
+    expires.forEach(key => tmp_token_price_cache.delete(key));
+}, 5000);
+function set_tmp_market_price(token_with_price) {
+    if (!token_with_price || (0, index_1.isEmpty)(token_with_price.market_price)) {
+        return;
+    }
+    let symbol = token_with_price.symbol;
+    tmp_token_price_cache.set(symbol, {
+        token_with_price,
+        create_time: new Date().getTime()
+    });
+}
+class EstimateAmountInToken {
+    static estimate_amount_in_token(arb_cache_1, token_1, amount_in_usd_1) {
+        return __awaiter(this, arguments, void 0, function* (arb_cache, token, amount_in_usd, query_token_market_price_url = '') {
+            if (['USDT', 'USDC'].includes(token.symbol.toUpperCase())) {
+                return amount_in_usd + '';
+            }
+            if (index_1.LOG.debug) {
+                (0, index_1.log_debug)('estimate_amount_in_token, start');
+            }
+            let symbol = (0, index_1.format_symbol_name)(token.symbol);
+            let amountInToken;
+            let token_info;
+            try {
+                if (index_1.LOG.debug) {
+                    (0, index_1.log_debug)(`try-1 get market price from local cache`);
+                }
+                let tmp_token_price = tmp_token_price_cache.get(symbol);
+                if (tmp_token_price) {
+                    token_info = tmp_token_price.token_with_price;
+                    if (index_1.LOG.debug) {
+                        (0, index_1.log_debug)(`try-1 get market price from local cache, success, hit cache!`, {
+                            symbol, market_price: token_info.market_price
+                        });
+                    }
+                }
+                else {
+                    if (index_1.LOG.debug) {
+                        (0, index_1.log_debug)(`try-2 get market price from remote cache`);
+                    }
+                    token_info = yield arb_cache.get_token_market_price(symbol);
+                    set_tmp_market_price(token_info);
+                    if (index_1.LOG.debug) {
+                        (0, index_1.log_debug)(`try-2 get market price from remote cache, res=`, token_info);
+                    }
+                }
+                let market_price = token_info === null || token_info === void 0 ? void 0 : token_info.market_price;
+                if (market_price) {
+                    let result = (0, index_1.calc_amount_in_token)(amount_in_usd, market_price, token_info);
+                    amountInToken = result.amount_in_token;
+                }
+                if (!amountInToken) {
+                    try {
+                        let token_price_url = query_token_market_price_url;
+                        if (!token_price_url) {
+                            query_token_market_price_url = process.env.TOKEN_MARKET_PRICE_URL;
+                        }
+                        let url = `${token_price_url}?symbol=${symbol}&amount_in_usd=${amount_in_usd}`;
+                        if (index_1.LOG.debug) {
+                            (0, index_1.log_debug)(`try get market price from config-center, symbol=${symbol}, start`, { url });
+                        }
+                        let res = yield (yield fetch(url)).json();
+                        let price_with_amount = res['data'];
+                        amountInToken = price_with_amount.amount_in_token;
+                        set_tmp_market_price(price_with_amount.token_info);
+                        if (index_1.LOG.debug) {
+                            (0, index_1.log_debug)(`try get market price from config-center, symbol=${symbol}, res=`, res);
+                        }
+                    }
+                    catch (err) {
+                        (0, index_1.log_error)(`estimate_input_ui_amount error!`, err);
+                    }
+                }
+                return amountInToken.toString();
+            }
+            catch (err) {
+                let default_amount_in_token = 1;
+                (0, index_1.new_line)(5);
+                (0, index_1.log_error)(`estimate_input_ui_amount error! return default amount: ${default_amount_in_token}`, err);
+                return default_amount_in_token.toString();
+            }
+        });
+    }
+}
+exports.EstimateAmountInToken = EstimateAmountInToken;

package/dist/market_price/index.d.ts

@@ -0,0 +1 @@
+export * from './estimate_token_amount';

package/dist/market_price/index.js

@@ -0,0 +1,17 @@
+"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("./estimate_token_amount"), exports);

package/dist/pool/cache_pool_config.d.ts

@@ -0,0 +1,2 @@
+import { CHAIN_ID, DEX_ID, FormattedPoolInfo, FormattedTokenInfo } from "../index";
+export declare const cache_pool_config: (chain_id: CHAIN_ID, valid_tokens_map: Map<string, FormattedTokenInfo[]>, sol_pools_cache: Map<DEX_ID, FormattedPoolInfo[]>) => Promise<void>;

package/dist/pool/cache_pool_config.js

@@ -0,0 +1,116 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache_pool_config = void 0;
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+const is_not_arb_token_1 = require("../token/is_not_arb_token");
+const cache_pool_config = (chain_id, valid_tokens_map, sol_pools_cache) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, index_1.log_info)(`cache_pool_config start`);
+    let count = 0;
+    let skip_pool_list = [];
+    let config_pool_url = `http://${process.env.CONFIG_CENTER_HOST}/${chain_id}/config/pools`;
+    for (let [dex_id, pool_list] of sol_pools_cache) {
+        let batch_pools = (0, index_1.chunkArray)(pool_list, 10);
+        for (let one_pool_list of batch_pools) {
+            let valid_pool_list = [];
+            for (let pool of one_pool_list) {
+                let is_contains_unkown_symbol = !valid_tokens_map.has(pool.tokenA.symbol) || !valid_tokens_map.has(pool.tokenB.symbol);
+                if (is_contains_unkown_symbol || (0, is_not_arb_token_1.is_not_arb_token)(pool.pool_name)) {
+                    skip_pool_list.push(pool);
+                    continue;
+                }
+                let std_pool = {
+                    program_id: pool.program_id,
+                    authority: pool.authority,
+                    subscribe_type: 'grpc',
+                    pair: pool.pair,
+                    dex_id: dex_id,
+                    pool_name: pool.pool_name,
+                    pool_address: pool.pool_address,
+                    pool_address_hex: '',
+                    tokenA: null,
+                    tokenB: null,
+                    vaultA: pool.vaultA,
+                    vaultB: pool.vaultB,
+                    router_id: null,
+                    fee_rate: pool.fee_rate_bps,
+                    quote_token: pool.quote_token,
+                    quote_amount_usd: parseInt(process.env.QUOTE_AMOUNT_USD || '100'),
+                    quote_price_decimals: 18,
+                    is_reverse_token: null,
+                    cu_limit: get_cu_limit(dex_id),
+                    tvl: pool.tvl,
+                    vol_24h: pool.vol_24h,
+                    update_time: (0, index_1.getCurDateTime)(),
+                    enable: true,
+                };
+                valid_pool_list.push(std_pool);
+                count = count + 1;
+            }
+            if (valid_pool_list.length === 0) {
+                continue;
+            }
+            let body = [
+                {
+                    dex_id: dex_id,
+                    pool_list: valid_pool_list
+                }
+            ];
+            const res = (yield axios_1.default.post(config_pool_url, body, {
+                headers: { 'Content-Type': 'application/json' }
+            })).data;
+            (0, index_1.log_trace)('cache_pool_config, res', res);
+            yield (0, index_1.sleep)(200);
+        }
+    }
+    (0, index_1.log_info)(`cache_pool_config finished! sync pool count:${count}, skip: ${skip_pool_list.length}`);
+    skip_pool_list.sort((a, b) => a.pair.localeCompare(b.pair));
+    (0, index_1.writeFile)(`dist/${chain_id.toLowerCase()}_skip_pool_list.json`, JSON.stringify({
+        time: (0, index_1.getCurDateTime)(),
+        count: skip_pool_list.length,
+        data: skip_pool_list
+    }, null, 2));
+    let notify_config_change_url = `http://${process.env.CONFIG_CENTER_HOST}/${chain_id}/config/change?type=pool`;
+    let res = (yield axios_1.default.get(notify_config_change_url)).data;
+    (0, index_1.log_info)('fetch dex pools end, notify config change', {
+        notify_config_change_url,
+        res
+    });
+});
+exports.cache_pool_config = cache_pool_config;
+function get_cu_limit(dex_id) {
+    let cu_limit = 200000;
+    switch (dex_id) {
+        case index_1.DEX_ID.RAYDIUM_AMM:
+            cu_limit = 35000;
+            break;
+        case index_1.DEX_ID.RAYDIUM_CLMM:
+            cu_limit = 120000;
+            break;
+        case index_1.DEX_ID.RAYDIUM_CPMM:
+            cu_limit = 48000;
+            break;
+        case index_1.DEX_ID.ORCA_CLMM:
+            cu_limit = 80000;
+            break;
+        case index_1.DEX_ID.METEORA_DLMM:
+            cu_limit = 80000;
+            break;
+        case index_1.DEX_ID.PUMPFUN_AMM:
+            cu_limit = 80000;
+            break;
+    }
+    return cu_limit;
+}

package/dist/pool/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './pool_util';
+export * from './cache_pool_config';

package/dist/pool/index.js

@@ -0,0 +1,19 @@
+"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("./types"), exports);
+__exportStar(require("./pool_util"), exports);
+__exportStar(require("./cache_pool_config"), exports);

package/dist/pool/pool_util.d.ts

@@ -0,0 +1,5 @@
+import { FormattedPoolInfo } from "./types";
+export declare function get_pair_name(native_token: string, pool_name: string): string;
+export declare function check_pool_token_address(pool: FormattedPoolInfo): void;
+export declare function get_quote_token(pair: string, pool_name: string): string;
+export declare function valid_fetch_pool_data(formatted_pool: FormattedPoolInfo, min_tvl: number, min_vol: number, native_token: string): void;

package/dist/pool/pool_util.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_pair_name = get_pair_name;
+exports.check_pool_token_address = check_pool_token_address;
+exports.get_quote_token = get_quote_token;
+exports.valid_fetch_pool_data = valid_fetch_pool_data;
+const token_1 = require("../token");
+const token_util_1 = require("../token/token_util");
+function get_pair_name(native_token, pool_name) {
+    let arr = pool_name.split('/');
+    if (pool_name.includes(native_token) && (pool_name.includes('USDC') || pool_name.includes('USDT'))) {
+        if (pool_name.endsWith(native_token)) {
+            arr.reverse();
+        }
+        return arr.join('/').replace('USDC', 'USDT');
+    }
+    const symbols = pool_name.split('/');
+    if (symbols.includes(native_token)) {
+        if (symbols[1] !== native_token) {
+            arr.reverse();
+        }
+        return arr.join('/');
+    }
+    if (symbols.includes('USDC') || symbols.includes('USDT')) {
+        if (symbols[1] !== 'USDC' && symbols[1] !== 'USDT') {
+            arr.reverse();
+        }
+        return arr.join('/').replace('USDC', 'USDT');
+    }
+    return pool_name;
+}
+function check_pool_token_address(pool) {
+    let { pool_name, pool_address, tokenA, tokenB } = pool;
+    for (let token of [tokenA, tokenB]) {
+        let is_fake_token = token_1.fixed_symbol_address.some(e => e.symbol === token.symbol && e.address !== token.address);
+        if (is_fake_token) {
+            throw new Error(`Invalid token address of ${token.symbol}: ${token.address}, ${pool_name}, ${pool_address}`);
+        }
+    }
+}
+function get_quote_token(pair, pool_name) {
+    let base_token = pair.split('/')[0];
+    let quote_token = pair.split('/')[1];
+    if (!pool_name.includes(quote_token)) {
+        quote_token = pool_name.split('/').find(e => e !== base_token) || '';
+    }
+    return quote_token;
+}
+function valid_fetch_pool_data(formatted_pool, min_tvl, min_vol, native_token) {
+    let { pool_name, pool_address, tokenA, tokenB, tvl, vol_24h } = formatted_pool;
+    let symbols = [tokenA.symbol, tokenB.symbol];
+    if ((tvl < min_tvl || vol_24h < min_vol)) {
+        throw new Error(`pool is too small: ${pool_name}, ${pool_address}, tvl=${tvl}, vol_24h=${vol_24h}`);
+    }
+    if (!symbols.includes(native_token) && !symbols.includes('USDC') && !symbols.includes('USDT')) {
+        throw new Error(`pool don't contains: SOL, USDC, USDT, ${pool_name}, ${pool_address}`);
+    }
+    if (!(0, token_util_1.is_valid_symbol)(tokenA.symbol)) {
+        throw new Error(`pool contains bad symbol: tokenA.symbol=${tokenA.symbol}, ${pool_name}, ${pool_address}`);
+    }
+    if (!(0, token_util_1.is_valid_symbol)(tokenB.symbol)) {
+        throw new Error(`pool contains bad symbol: tokenB.symbol=${tokenB.symbol}, ${pool_name}, ${pool_address}`);
+    }
+    check_pool_token_address(formatted_pool);
+}

package/dist/pool/types.d.ts

@@ -0,0 +1,20 @@
+import { FormattedTokenInfo } from "../token/types";
+export interface FormattedPoolInfo {
+    pair: string;
+    quote_token: string;
+    chain_id: string;
+    dex_id: string;
+    program_id: string;
+    pool_name: string;
+    pool_type: string;
+    pool_address: string;
+    tokenA: FormattedTokenInfo;
+    tokenB: FormattedTokenInfo;
+    fee_rate_bps: number;
+    tvl: number;
+    vol_24h: number;
+    vaultA: string;
+    vaultB: string;
+    authority: string;
+    lookupTableAccount?: string;
+}

package/dist/pool/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/quote/index.d.ts

@@ -0,0 +1 @@
+export * from './on_quote_response';

package/dist/quote/index.js

@@ -0,0 +1,17 @@
+"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("./on_quote_response"), exports);

package/dist/quote/log_quote_price.d.ts

@@ -0,0 +1,2 @@
+import { PriceMessageType } from "../../types";
+export declare function log_quote_price(event_source: string, price_message: PriceMessageType, tx_hash: string): Promise<void>;

package/dist/quote/log_quote_price.js

@@ -0,0 +1,29 @@
+"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.log_quote_price = log_quote_price;
+const __1 = require("..");
+function log_quote_price(event_source, price_message, tx_hash) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { unique_orderbook_id, pool_name, pair, fee_rate, price_id, quote_amount_usd, ask, bid, time } = price_message;
+        let price_time = new Date().getTime();
+        let price_time_str = (0, __1.parseToDateTime)(price_time);
+        let times = [
+            time.quote_start_time - time.stream_time,
+            time.quote_end_time - time.quote_start_time,
+            time.price_time - time.stream_time,
+        ];
+        if (event_source || tx_hash) {
+            console.log(`> [${event_source}] - ${tx_hash}`);
+        }
+        console.log(price_time_str, ' - ', unique_orderbook_id, ' - ', String(price_id).padEnd(32), ' - ', pool_name.padEnd(12), ' - ', pair.padEnd(12), ' - ', String(quote_amount_usd).padEnd(4), ' - ', String(ask.price).padEnd(8), ' - ', String(bid.price).padEnd(8), ' - ', `${times.join(',')} ms`, '\n');
+    });
+}

package/dist/quote/on_quote_response.d.ts

@@ -0,0 +1,3 @@
+import { StandardPoolInfoType, QuoteResultType } from "../../types";
+import { AppConfig } from "../app_config";
+export declare function on_quote_respose(appConfig: AppConfig, pool_info: StandardPoolInfoType, quote_amount_usd: number, execution_price: number, stream_time: number, quote_start_time: number, slot_info: string, result: [QuoteResultType, QuoteResultType, number], txid: string): void;

package/dist/quote/on_quote_response.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.on_quote_respose = on_quote_respose;
+const analyze_1 = require("../analyze");
+const log_quote_price_1 = require("./log_quote_price");
+const publish_quote_price_1 = require("./publish_quote_price");
+const to_price_message_1 = require("./to_price_message");
+function on_quote_respose(appConfig, pool_info, quote_amount_usd, execution_price, stream_time, quote_start_time, slot_info, result, txid) {
+    const quote_end_time = new Date().getTime();
+    const quote_ask_price = Number(result[0].price);
+    const quote_bid_price = Number(result[1].price);
+    const block_time = result[2];
+    const price_time = new Date().getTime();
+    const time = {
+        block_time,
+        stream_time,
+        quote_start_time,
+        quote_end_time,
+        price_time,
+        total_quote_time: price_time - stream_time
+    };
+    (0, to_price_message_1.to_price_message)(appConfig, quote_amount_usd, execution_price, quote_ask_price, quote_bid_price, pool_info, time, slot_info)
+        .then((price_msg) => {
+        (0, publish_quote_price_1.publish_quote_price)(appConfig, price_msg);
+        (0, log_quote_price_1.log_quote_price)(slot_info, price_msg, txid);
+        (0, analyze_1.report_trade_analyze_data)('PriceMessageType', Object.assign(Object.assign({}, price_msg), { quote_source: { slot: slot_info, block: null, txid } }));
+    });
+}

package/dist/quote/publish_quote_price.d.ts

@@ -0,0 +1,3 @@
+import { PriceMessageType } from "../../types";
+import { AppConfig } from "../app_config";
+export declare const publish_quote_price: (appConfig: AppConfig, price_msg: PriceMessageType) => void;

package/dist/quote/publish_quote_price.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publish_quote_price = void 0;
+const __1 = require("..");
+const publish_quote_price = (appConfig, price_msg) => {
+    const chain_id = appConfig.env_args.chain_id;
+    let price_id = price_msg.price_id;
+    let event = {
+        event_type: __1.REDIS_EVENT_TYPE_QUOTE.NEW_QUOTE_PRICE,
+        event_time: Date.now(),
+        chain_id,
+        data: price_msg
+    };
+    appConfig.arb_cache.redis_event_publisher.publish_quote_price_event(chain_id, event);
+    appConfig.arb_cache.cache_price_message(price_msg)
+        .then(() => (0, __1.log_debug)(`cache price success, price_id=${price_id}`))
+        .catch(err => (0, __1.log_error)(`cache price error! price_id=${price_id}`, err));
+};
+exports.publish_quote_price = publish_quote_price;

package/dist/quote/to_price_message.d.ts

@@ -0,0 +1,5 @@
+import { StandardPoolInfoType, QuoteTimeInfoType, PriceMessageType } from '../../types';
+import { AppConfig } from '../app_config';
+export declare const get_quote_token_decimals: (pool_info: StandardPoolInfoType) => number;
+export declare function to_price_message(appConfig: AppConfig, quote_amount_usd: number, tx_price: number, quote_ask_price: number, quote_bid_price: number, pool_info: StandardPoolInfoType, time: QuoteTimeInfoType, slot?: string): Promise<PriceMessageType>;
+export declare function normalize_pair_name(priceMessage: PriceMessageType): void;

package/dist/quote/to_price_message.js

@@ -0,0 +1,103 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_quote_token_decimals = void 0;
+exports.to_price_message = to_price_message;
+exports.normalize_pair_name = normalize_pair_name;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const uuid_1 = require("uuid");
+const __1 = require("..");
+const get_quote_token_decimals = (pool_info) => {
+    let decimals = 9;
+    let { tokenA, tokenB, quote_token } = pool_info;
+    if (tokenA.symbol === quote_token) {
+        decimals = tokenA.decimals;
+    }
+    if (tokenB.symbol === quote_token) {
+        decimals = tokenB.decimals;
+    }
+    return decimals;
+};
+exports.get_quote_token_decimals = get_quote_token_decimals;
+function to_price_message(appConfig, quote_amount_usd, tx_price, quote_ask_price, quote_bid_price, pool_info, time, slot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let { pool_address, tokenA, tokenB } = pool_info;
+        let { dex_id, pool_name, fee_rate, is_reverse_token } = yield appConfig.arb_cache.get_one_pool_info(pool_address);
+        let _dex_id = dex_id;
+        let price_id = (0, uuid_1.v4)().replace(/-/gi, '');
+        let chain_id = appConfig.env_args.chain_id;
+        let unique_orderbook_id = (0, __1.format_unique_orderbook_id)(chain_id, _dex_id, pool_address, fee_rate);
+        time.price_time = new Date().getTime();
+        let fee_rate_bps = fee_rate / 100100;
+        let ask_price = getAskPrice(new decimal_js_1.default(quote_ask_price), fee_rate_bps * 0);
+        let bid_price = getBidPrice(new decimal_js_1.default(quote_bid_price), fee_rate_bps * 0);
+        let price_message = {
+            chain_id,
+            dex_id,
+            price_id,
+            pool_id: pool_address,
+            pool_name,
+            fee_rate,
+            pair: pool_name,
+            unique_orderbook_id,
+            is_reverse_token,
+            tokenA: {
+                symbol: tokenA.symbol,
+                address: tokenA.address,
+                address_hex: tokenA.address_hex,
+                decimals: tokenA.decimals,
+                name: tokenA.name,
+                enable: true,
+            },
+            tokenB: {
+                symbol: tokenB.symbol,
+                address: tokenB.address,
+                address_hex: tokenB.address_hex,
+                decimals: tokenB.decimals,
+                name: tokenB.name,
+                enable: true,
+            },
+            tx_price: tx_price === null || tx_price === void 0 ? void 0 : tx_price.toFixed(12),
+            quote_amount_usd,
+            ask: {
+                price: ask_price,
+                quantity: quote_amount_usd
+            },
+            bid: {
+                price: bid_price,
+                quantity: quote_amount_usd
+            },
+            time,
+            slot
+        };
+        normalize_pair_name(price_message);
+        return price_message;
+    });
+}
+const getAskPrice = (price, feeRate) => {
+    return price.mul(1 + feeRate).toFixed(12);
+};
+const getBidPrice = (price, feeRate) => {
+    return price.mul(1 - feeRate).toFixed(12);
+};
+function normalize_pair_name(priceMessage) {
+    let { pool_name, is_reverse_token } = priceMessage;
+    if (is_reverse_token) {
+        pool_name = pool_name.split('/')[1] + '/' + pool_name.split('/')[0];
+    }
+    const dex_pair_names = pool_name.split('/');
+    let cex_base_token = (0, __1.format_symbol_name)(dex_pair_names[0]);
+    let cex_qutoe_token = (0, __1.format_symbol_name)(dex_pair_names[1]);
+    priceMessage.pair = cex_base_token.toUpperCase() + '/' + cex_qutoe_token.toUpperCase();
+}

package/dist/test/test_is_empty.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/test_is_empty.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+const main = () => {
+    let set1 = new Set();
+    console.log('isEmpty Set', (0, index_1.isEmpty)(set1), set1);
+    let set2 = new Set();
+    set2.add(1);
+    console.log('isEmpty Set', (0, index_1.isEmpty)(set2), set2);
+    console.log('typeof Set: ', typeof set2);
+    console.log('keys in Set: ', Object.keys(set2));
+    let map1 = new Map();
+    console.log('isEmpty Map', (0, index_1.isEmpty)(map1), map1);
+    let map2 = new Map();
+    map2.set('SUN/TRX', 'xxxxxxxxx');
+    console.log('isEmpty Map', (0, index_1.isEmpty)(map2), map2);
+    console.log('typeof Map: ', typeof map2);
+    console.log('keys in Map: ', Object.keys(map2));
+    let arr1 = [];
+    let arr2 = [1];
+    console.log('isEmpty array', (0, index_1.isEmpty)(arr1), arr1);
+    console.log('isEmpty array', (0, index_1.isEmpty)(arr2), arr2);
+};
+main();

package/dist/test/test_log_level.d.ts

@@ -0,0 +1,3 @@
+export declare function xx(): void;
+export declare function yy(): void;
+export declare function zz(): void;