@clonegod/ttd-core 2.0.56 → 2.0.58

package/dist/index.d.ts

@@ -56,7 +56,10 @@ export declare enum DEX_ID {
     LFJ_V1 = "LFJ-V1",
     LFJ_V2 = "LFJ-V2",
     BLACKHOLE_V2 = "BLACKHOLE-V2",
-    BLACKHOLE_V3 = "BLACKHOLE-V3"
+    BLACKHOLE_V3 = "BLACKHOLE-V3",
+    MOMENTUM = "MOMENTUM",
+    CETUS = "CETUS",
+    BLUEFIN = "BLUEFIN"
 }
 export declare enum GROUP_ID {
     TRON_DEV1 = "TRON-DEV1",

package/dist/index.js

@@ -141,6 +141,9 @@ var DEX_ID;
     DEX_ID["LFJ_V2"] = "LFJ-V2";
     DEX_ID["BLACKHOLE_V2"] = "BLACKHOLE-V2";
     DEX_ID["BLACKHOLE_V3"] = "BLACKHOLE-V3";
+    DEX_ID["MOMENTUM"] = "MOMENTUM";
+    DEX_ID["CETUS"] = "CETUS";
+    DEX_ID["BLUEFIN"] = "BLUEFIN";
 })(DEX_ID || (exports.DEX_ID = DEX_ID = {}));
 var GROUP_ID;
 (function (GROUP_ID) {

package/dist/token/price/defi_llama.d.ts

@@ -0,0 +1,2 @@
+import { FormattedTokenPrice } from "../../index";
+export declare function fetchPriceFromDefiLlama(network: string, addresses: string[]): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/defi_llama.js

@@ -0,0 +1,65 @@
+"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.fetchPriceFromDefiLlama = fetchPriceFromDefiLlama;
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../../index");
+function fetchPriceFromDefiLlama(network, addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = new Map();
+        const currentTime = (0, index_1.getCurDateTime)();
+        const timeout = 10000;
+        const maxRetries = 3;
+        const retrysleepMs = 1000;
+        const addressString = addresses.map(address => `${network.toLowerCase()}:${address}`).join(',');
+        const url = `https://coins.llama.fi/prices/current/${addressString}`;
+        console.log(url);
+        (0, index_1.log_debug)(`[fetchPriceFromDefiLlama] Requesting prices for ${addresses.length} tokens`);
+        let retryCount = 0;
+        while (retryCount <= maxRetries) {
+            try {
+                const response = yield axios_1.default.get(url, { timeout });
+                let tokenPrices = response.data['coins'];
+                if (tokenPrices) {
+                    for (const address of addresses) {
+                        let network_token_address = `${network.toLowerCase()}:${address}`;
+                        if (tokenPrices[network_token_address]) {
+                            result.set(address, {
+                                address: address,
+                                price: tokenPrices[network_token_address].price,
+                                symbol: tokenPrices[network_token_address].symbol,
+                                name: '',
+                                update_time: currentTime
+                            });
+                        }
+                    }
+                }
+                else {
+                    (0, index_1.log_debug)(`[fetchPriceFromDefiLlama] Invalid response format from DefiLlama API`);
+                }
+                break;
+            }
+            catch (error) {
+                retryCount++;
+                (0, index_1.log_warn)(`[fetchPriceFromDefiLlama] Request failed (attempt ${retryCount}/${maxRetries}): ${error instanceof Error ? error.message : String(error)}`);
+                if (retryCount <= maxRetries) {
+                    const currentRetrysleep = retrysleepMs * retryCount;
+                    (0, index_1.log_debug)(`[fetchPriceFromDefiLlama] Retrying in ${currentRetrysleep}ms...`);
+                    yield (0, index_1.sleep)(currentRetrysleep);
+                }
+            }
+        }
+        return result;
+    });
+}

package/dist/token/price/get_sui_token_price.d.ts

@@ -0,0 +1,2 @@
+import { FormattedTokenPrice } from "../types";
+export declare function get_sui_token_price_info(addresses: string[]): Promise<Map<string, FormattedTokenPrice>>;

package/dist/token/price/get_sui_token_price.js

@@ -0,0 +1,102 @@
+"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.get_sui_token_price_info = get_sui_token_price_info;
+require('dotenv').config();
+const index_1 = require("../../index");
+const defi_llama_1 = require("./defi_llama");
+const gecko_terminal_1 = require("./gecko_terminal");
+const price_cache_1 = require("./price_cache");
+function get_sui_token_price_info(addresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, index_1.log_info)(`get_sui_token_price_info`, addresses);
+        const result = new Map();
+        const PRICE_CHANNELS = [
+            {
+                name: 'CachedPrice',
+                fetchFn: price_cache_1.fetchPriceFromCache,
+                batchSize: 100,
+                batchDelay: 1000,
+            },
+            {
+                name: 'DefiLlama',
+                fetchFn: (address_list) => (0, defi_llama_1.fetchPriceFromDefiLlama)(index_1.CHAIN_ID.SUI, address_list),
+                batchSize: 10,
+                batchDelay: 2000,
+            },
+            {
+                name: 'GeckoTerminal',
+                fetchFn: (address_list) => (0, gecko_terminal_1.fetchPriceFromGeckoTerminal)('sui-network', address_list),
+                batchSize: 10,
+                batchDelay: 2000,
+            },
+        ];
+        try {
+            for (const channel of PRICE_CHANNELS) {
+                if (addresses.length === 0)
+                    break;
+                (0, index_1.log_debug)(`[get_token_price_info] Processing ${addresses.length} tokens using ${channel.name}`);
+                const batches = (0, index_1.chunkArray)(addresses, channel.batchSize);
+                (0, index_1.log_debug)(`[get_token_price_info] Split into ${batches.length} batches of size ${channel.batchSize}`);
+                let remainingAddresses = [...addresses];
+                for (let i = 0; i < batches.length; i++) {
+                    const batch = batches[i];
+                    if (batch.length === 0)
+                        continue;
+                    (0, index_1.log_debug)(`[get_token_price_info] Processing batch ${i + 1}/${batches.length} (${batch.length} tokens) with ${channel.name}`);
+                    try {
+                        const channelResult = yield channel.fetchFn(batch);
+                        for (const [address, priceInfo] of channelResult.entries()) {
+                            result.set(address, priceInfo);
+                            remainingAddresses = remainingAddresses.filter(addr => addr !== address);
+                            if (channel.name !== 'CachedPrice') {
+                                (0, price_cache_1.cache_new_market_price)(address, priceInfo.price, channel.name);
+                            }
+                        }
+                        (0, index_1.log_debug)(`[get_token_price_info] ${channel.name} found prices for ${channelResult.size}/${batch.length} tokens in batch ${i + 1}`);
+                    }
+                    catch (error) {
+                        (0, index_1.log_warn)(`[get_token_price_info] Error processing batch ${i + 1} with ${channel.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    if (i < batches.length - 1) {
+                        yield (0, index_1.sleep)(channel.batchDelay);
+                    }
+                }
+                addresses = [...remainingAddresses];
+                if (addresses.length === 0) {
+                    (0, index_1.log_debug)(`[get_token_price_info] All token prices retrieved using ${channel.name}`);
+                    break;
+                }
+            }
+            if (result.size === 0) {
+                throw new Error(`Unable to get price information for any token: ${addresses.join(', ')}`);
+            }
+            if (addresses.length > 0) {
+                (0, index_1.log_warn)(`[get_token_price_info] Failed to get prices for ${addresses.length} tokens after trying all channels: ${addresses.join(', ')}`);
+            }
+            (0, index_1.log_debug)(`[get_token_price_info] Completed price fetching for ${result.size} tokens`);
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to get token price information: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+if (require.main === module) {
+    (() => __awaiter(void 0, void 0, void 0, function* () {
+        let addresses = [
+            "0x2::sui::SUI",
+            "0x375f70cf2ae4c00bf37117d0c85a2c71545e6ee05c4a5c7d282cd66a4504b068::usdt::USDT",
+            "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+            "0x356a26eb9e012a68958082340d4c4116e7f55615cf27affcff209cf0ae544f59::wal::WAL",
+        ];
+    }))();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-core",
-    "version": "2.0.56",
+    "version": "2.0.58",
     "description": "Common types and utilities for trading systems - use `npm run push` to publish",
     "main": "dist/index.js",
     "types": "types/index.d.ts",