@clonegod/ttd-sol-common 2.0.51 → 2.0.53

package/dist/common/get_wallet_token_account.d.ts

@@ -1,5 +1,5 @@
 import { StandardPoolInfoType, StandardTokenInfoType } from "@clonegod/ttd-core";
 import { Connection, Keypair, PublicKey } from "@solana/web3.js";
 export declare const get_token_program_id: (token: StandardTokenInfoType) => PublicKey;
-export declare function get_wallet_token_account(wallet_pubkey: string, pool_list: StandardPoolInfoType[]): Promise<Map<string, string>>;
+export declare function get_wallet_token_account(wallet_pubkey: string, pool_list: StandardPoolInfoType[]): Map<string, string>;
 export declare const create_token_account_if_not_exist: (connection: Connection, owner: Keypair, token_list: StandardTokenInfoType[]) => Promise<void>;

package/dist/common/get_wallet_token_account.js

@@ -14,18 +14,32 @@ const get_token_program_id = (token) => {
     return programId;
 };
 exports.get_token_program_id = get_token_program_id;
-async function get_wallet_token_account(wallet_pubkey, pool_list) {
+const wallet_token_accounts_cache = new Map();
+function getWalletTokenAccountCacheKey(wallet_pubkey, token_address) {
+    return `${wallet_pubkey}_${token_address}}`;
+}
+function getCachedAtaAddress(wallet_pubkey, token_address, programId) {
+    const cacheKey = getWalletTokenAccountCacheKey(wallet_pubkey, token_address);
+    if (wallet_token_accounts_cache.has(cacheKey)) {
+        return wallet_token_accounts_cache.get(cacheKey);
+    }
+    const ataAddress = (0, spl_token_1.getAssociatedTokenAddressSync)(new web3_js_1.PublicKey(token_address), new web3_js_1.PublicKey(wallet_pubkey), false, programId).toBase58();
+    wallet_token_accounts_cache.set(cacheKey, ataAddress);
+    return ataAddress;
+}
+function get_wallet_token_account(wallet_pubkey, pool_list) {
     let account_map = new Map();
     for (let { tokenA, tokenB } of pool_list) {
-        account_map.set(tokenA.symbol, (await (0, spl_token_1.getAssociatedTokenAddress)(new web3_js_1.PublicKey(tokenA.address), new web3_js_1.PublicKey(wallet_pubkey), false, (0, exports.get_token_program_id)(tokenA))).toBase58());
-        account_map.set(tokenB.symbol, (await (0, spl_token_1.getAssociatedTokenAddress)(new web3_js_1.PublicKey(tokenB.address), new web3_js_1.PublicKey(wallet_pubkey), false, (0, exports.get_token_program_id)(tokenB))).toBase58());
+        const programIdA = (0, exports.get_token_program_id)(tokenA);
+        const programIdB = (0, exports.get_token_program_id)(tokenB);
+        account_map.set(tokenA.symbol, getCachedAtaAddress(wallet_pubkey, tokenA.address, programIdA));
+        account_map.set(tokenB.symbol, getCachedAtaAddress(wallet_pubkey, tokenB.address, programIdB));
     }
     return account_map;
 }
 const create_token_account_if_not_exist = async (connection, owner, token_list) => {
     token_list.forEach(async (token) => {
-        var _a;
-        if (['SOL', 'WSOL', 'USDC', 'USDT'].includes((_a = token.symbol) === null || _a === void 0 ? void 0 : _a.toUpperCase())) {
+        if (['SOL', 'WSOL', 'USDC', 'USDT'].includes(token.symbol?.toUpperCase())) {
             return;
         }
         try {

package/dist/trade/send/jito.js

@@ -77,7 +77,6 @@ const getJitoTipAccount = () => {
 exports.getJitoTipAccount = getJitoTipAccount;
 JitoUtils.init();
 const sendBundleWithJito = async (mainTxBase64, tipTxBase64) => {
-    var _a, _b;
     let url = process.env.JITO_SEND_BUNDLE_URL || 'https://tokyo.mainnet.block-engine.jito.wtf/api/v1/bundles';
     const client = (0, http_client_1.getHttpClient)(url);
     const requestData = {
@@ -99,8 +98,8 @@ const sendBundleWithJito = async (mainTxBase64, tipTxBase64) => {
     }
     catch (error) {
         if (error instanceof axios_1.AxiosError) {
-            const status = (_a = error.response) === null || _a === void 0 ? void 0 : _a.status;
-            const statusText = (_b = error.response) === null || _b === void 0 ? void 0 : _b.statusText;
+            const status = error.response?.status;
+            const statusText = error.response?.statusText;
             (0, dist_1.log_warn)(`[sendBundleWithJito] Request failed: ${status} - ${statusText}`);
         }
         else {

package/dist/trade/tx_result_check.js

@@ -36,7 +36,6 @@ class TransactionResultChecker extends dist_1.AbstractTransactionResultCheck {
     }
     on_subscibe_transaction() {
         this.event_emitter.once(dist_1.LOCAL_EVENT_NAME.EVENT_WALLET_TRANSACTION + '#' + this.txid, (message) => {
-            var _a, _b, _c;
             try {
                 this.trade_result_already_processed = true;
                 let messageObj = message;
@@ -60,9 +59,9 @@ class TransactionResultChecker extends dist_1.AbstractTransactionResultCheck {
                     result = messageObj.params.result;
                     _txid = result.signature;
                     slot = result.slot;
-                    transactionData = (_a = result.transaction) === null || _a === void 0 ? void 0 : _a.transaction;
-                    meta = (_b = result.transaction) === null || _b === void 0 ? void 0 : _b.meta;
-                    version = ((_c = result.transaction) === null || _c === void 0 ? void 0 : _c.version) !== undefined ? result.transaction.version : 0;
+                    transactionData = result.transaction?.transaction;
+                    meta = result.transaction?.meta;
+                    version = result.transaction?.version !== undefined ? result.transaction.version : 0;
                 }
                 else {
                     (0, dist_1.log_error)('Invalid message format: unrecognized structure', new Error(JSON.stringify(messageObj)));

package/dist/trade/tx_result_parse.js

@@ -66,16 +66,25 @@ class TransactionResultParser {
             block_number: slot,
             txid,
             pool_address,
-            tokenA: Object.assign(Object.assign({}, tokenA), { pre_bal: tokenA_PreBalance, post_bal: tokenA_PostBalance, change: tokenAChange }),
-            tokenB: Object.assign(Object.assign({}, tokenB), { pre_bal: tokenB_PreBalance, post_bal: tokenB_PostBalance, change: tokenBChange }),
+            tokenA: {
+                ...tokenA,
+                pre_bal: tokenA_PreBalance,
+                post_bal: tokenA_PostBalance,
+                change: tokenAChange
+            },
+            tokenB: {
+                ...tokenB,
+                pre_bal: tokenB_PreBalance,
+                post_bal: tokenB_PostBalance,
+                change: tokenBChange
+            },
             tx_price: price,
             gas_fee
         };
         return tradeResult;
     }
     getTokenBalance(owner, mint, tokenBalances) {
-        var _a, _b;
-        const balance = (_b = (_a = tokenBalances === null || tokenBalances === void 0 ? void 0 : tokenBalances.find((e) => e.owner === owner && e.mint == mint)) === null || _a === void 0 ? void 0 : _a.uiTokenAmount) === null || _b === void 0 ? void 0 : _b.uiAmount;
+        const balance = tokenBalances?.find((e) => e.owner === owner && e.mint == mint)?.uiTokenAmount?.uiAmount;
         if (typeof balance !== 'undefined' && balance !== null) {
             return balance;
         }

package/docs/clmm.md

@@ -0,0 +1,108 @@
+我想让你教会我完整分析CLMM池子的技术：
+1、有个叫bitmap的数据，是关于池子已经初始化的tick信息？
+2、bitmap -> tickArray -> currentTickIndex -> currentTickArray -> neiberhood TickArray 
+3、比如我通过监听链上池子account change，可以知道当前池子的current tickIndex, liqudity, sqrtprice。目前我只会根据3个数据来处略的做询价（比如100U的单子的ask,bid价格，为后面做交易参考）。跟你聊了之后，我想做到更好。
+4、另外，池子的一些基本信息，我可以在启动时初始化。池子的费率，池子的tickspace。
+5、我想能更加详细的在本地使用公式来计算出池子的报价：当前静态价格、按某个size询价得到的ask,bid价格（比如我固定按USDT计价。 SOL/USDT 的池子，ask : SOL->USDC, bid: USDC->SOL）
+6、需要有两种方式：简化计算，精确计算（这个依赖于本地能获取到更多的tick信息，我希望能看到每一个计算步骤，丛当前tick->tick移动->跨tickArray的流程日志）。
+7、我还希望能知道池子深度，也就是当前tick附近可交易买卖的USDC，SOL的数量。这个表达可能有问题，应该是当前tick状态下，比如在千分之15价格范围可买卖的USDC和SOL的个数。类似CEX ORDER BOOK上的数据那样。有价格，有深度。
+你能教会上上面的那些技术吗？
+
+-----------------------------
+
+
+## sqrtPrice
+
+同一个 tick 内，sqrtPrice 可以连续变化（每笔小单都产生新 sqrtPrice），所以单纯通过 tick 获取 sqrtPrice 确实有问题 ——它只能给你边界值，不是当前精确值。这就是为什么池子状态总是存 sqrtPriceX64 而非只存 tick。
+
+tick 的作用：tick 是“价格区间的标签”（discrete anchors）。
+每个 tick 对应一个精确的边界点，Uniswap V3 / Raydium / Orca 约定俗成：tickToSqrtPriceX64(i) 返回的是 tick i 的左边界（下边界），即价格区间的最小 sqrtPrice。
+公式（Orca/Uniswap V3）：P(i) = 1.0001^{i}
+
+sqrtPriceX64 = √P(i) × 2^{64}（下边界）。上边界 = √P(i + 1) × 2^{64}。
+sqrtPriceX64 的作用：这是当前精确价格（continuous），每笔交易后更新（连续偏移）。它总是在当前 tick 的 [下边界, 上边界) 内。  小单：sqrtPrice 在区间内小移，tick 不变。  
+累积小单：sqrtPrice 逐步推进，最终跨边界 → tick 更新。
+
+
+tickToSqrtPriceX64(tick) 只返回 边界（e.g., 下边界），不是当前真实 sqrtPrice。  
+如果用这个计算价格，会忽略区间内滑点（e.g., 同一个 tick，价格从边界起点滑到终点，变化 ~0.01% × spacing）。  
+
+总是优先用池子状态的 sqrtPriceX64 计算当前价格（实时精确）。  
+tick 只用于：边界检查、跨 tick 更新 L、初始化 tickArray。  
+转换工具：tick → sqrtPrice（边界），sqrtPrice → tick（floor 到当前区间）。
+
+当前真实 sqrtPriceX64 总是满足：
+tickToSqrtPriceX64(currentTick) ≤ sqrtPriceX64 < tickToSqrtPriceX64(currentTick + tickSpacing)
+
+-----------------------------
+pool config: tickspace, feerate, bitmap
+bitmap: 标记的是哪些 TickArray 已初始化（有至少一个 tick 被使用），而不是标记单个 tick。
+TickArray: 一组离散的Tick，不一定全初始化。核心参数：tick spacing（相邻tick之间的间距。 相邻tick之间的价差，指的是相邻tick的下边界sqrtprice的变化比率）
+TickIndex: 当前tick的索引，通过它可定位处于tick属于哪个TickArray。由于tick是边界，因此通过tickToSqrtPrice实际上计算出的是 [sqrtPrice_下边界，sqrtPrice_上边界]的价格区间。
+
+PoolState:
+currentTickIndex
+liqudity
+sqrtPriceX64
+
+-----------------------------
+在SOL/USDC这个池子进行“询价”：
+-- 询价，实际上就是模拟做一笔交易，预测'未来'进行一笔差不多大小的交易的可成交价。
+
+1、初始化
+- 初始化池子的配置信息：
+    tokenA, tokenB, feeRate
+    bitmap (一般在poolData中，不用单独订阅)
+- 初始化池子的状态信息（随时会变）：
+    tickArray
+    * 订阅当前tick前后相邻3个Tick Array的账户数据（根据currentTick动态调整被监控的TickArray账户列表）
+
+2、动态更新
+- 监听池子的状态变换，可获得池子的最新状态
+    current_tick_index
+    liqudity
+    sqrtPrice
+
+- 监听池子的事件
+ * solana 似乎没有基于事件监听的机制？比如监听池子的swap,burn,mint事件
+ 监听池子的交易，丛交易中解析是否存在burn,mint，如果有，则需要本地刷新bitmap,tickArray
+
+3、模拟交易量
+ - 输入100USDC
+ - 池子费率0.05%
+ - 扣除交易费用 100 * 0.05%，剩下的作为真正的inputAmount
+ - currentTick => currentTickOfTickArray
+ - neiberhoodTickArray => 相邻tickArray通过订阅
+ - 逐tick吃流动性，跨tick吃，跨tickArray吃
+ - inputAmount/outputAmount => usdc per SOL (用USDC计价)
+
+
+-------------------
+# CLMM 核心事实（2025版）
+
+1. sqrtPriceX64 是当前**真实价格**（连续），每笔交易都变
+   - 公式：price = (sqrtPriceX64 / 2^64)² → token1 ÷ token0
+   - 必须用这个算当前价格，不能用 tickToSqrtPriceX64
+
+2. tickIndex 是**当前价格所在的价格区间标签**（离散）
+   - tickToSqrtPriceX64(i) 返回的是 tick i 的**左边界**
+   - 真实关系：tickToSqrtPriceX64(currentTick) ≤ sqrtPriceX64 < tickToSqrtPriceX64(currentTick + spacing)
+
+3. 小单不会跨 tick，但 sqrtPrice 会连续下滑/上涨 → 价格实时滑点
+   累积小单最终会跨 tick → 更新 liquidity
+
+4. TickArray 是存储结构：
+   - Raydium / Orca：每个 account 存 88 个 tick slot
+   - bitmap（Raydium）标记哪些 TickArray 已初始化（不是单个 tick）
+
+5. 生产级实时监控方案：
+   - 订阅 whirlpool account → 实时 currentTick/liquidity/sqrtPrice
+   - 维护当前 ±5 个 TickArray（通过 bitmap 或 PDA 计算）
+   - 每笔询价都用最新 sqrtPrice + 当前 liquidity + 预加载的 tick 数据模拟
+
+6. 询价 = 模拟 swap：
+   输入 amountIn → 扣费 → 逐 tick 吃（跨 tick 更新 L，跨 array 加载下一个）→ 输出 amountOut + 最终价格
+
+
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-sol-common",
-  "version": "2.0.51",
+  "version": "2.0.53",
   "description": "",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -13,7 +13,7 @@
     "push": "npm run build && npm publish"
   },
   "dependencies": {
-    "@clonegod/ttd-core": "2.1.7",
+    "@clonegod/ttd-core": "2.1.8",
     "@solana/web3.js": "1.91.6",
     "rpc-websockets": "7.10.0",
     "axios": "^1.2.3",

package/src/common/get_wallet_token_account.ts

@@ -1,7 +1,7 @@
 import { StandardPoolInfoType, StandardTokenInfoType } from "@clonegod/ttd-core";
 import { log_info, log_error } from "@clonegod/ttd-core/dist";
 import { COMMITMENT_LEVEL } from "./constants";
-import { ASSOCIATED_TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotent, getAssociatedTokenAddress, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotent, getAssociatedTokenAddress, getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
 import { Connection, Keypair, PublicKey } from "@solana/web3.js";
 
 
@@ -13,13 +13,51 @@ export const get_token_program_id = (token: StandardTokenInfoType) => {
     return programId
 }
 
-export async function get_wallet_token_account(wallet_pubkey:string, pool_list:StandardPoolInfoType[]
+// 缓存 ATA 地址：key = `${wallet_pubkey}_${token_address}`
+const wallet_token_accounts_cache = new Map<string, string>()
+
+function getWalletTokenAccountCacheKey(wallet_pubkey: string, token_address: string): string {
+    return `${wallet_pubkey}_${token_address}}`
+}
+
+function getCachedAtaAddress(
+    wallet_pubkey: string,
+    token_address: string,
+    programId: PublicKey
+): string {
+    const cacheKey = getWalletTokenAccountCacheKey(wallet_pubkey, token_address)
+    
+    if (wallet_token_accounts_cache.has(cacheKey)) {
+        return wallet_token_accounts_cache.get(cacheKey)!
+    }
+    
+    const ataAddress = getAssociatedTokenAddressSync(
+        new PublicKey(token_address),
+        new PublicKey(wallet_pubkey),
+        false,
+        programId
+    ).toBase58()
+    
+    wallet_token_accounts_cache.set(cacheKey, ataAddress)
+    return ataAddress
+}
+
+export function get_wallet_token_account(wallet_pubkey:string, pool_list:StandardPoolInfoType[]
 ) {
     let account_map = new Map<string,string>()
 
     for(let {tokenA, tokenB} of pool_list) {
-        account_map.set(tokenA.symbol, (await getAssociatedTokenAddress(new PublicKey(tokenA.address), new PublicKey(wallet_pubkey), false, get_token_program_id(tokenA))).toBase58())
-        account_map.set(tokenB.symbol, (await getAssociatedTokenAddress(new PublicKey(tokenB.address), new PublicKey(wallet_pubkey), false, get_token_program_id(tokenB))).toBase58())
+        const programIdA = get_token_program_id(tokenA)
+        const programIdB = get_token_program_id(tokenB)
+        
+        account_map.set(
+            tokenA.symbol,
+            getCachedAtaAddress(wallet_pubkey, tokenA.address, programIdA)
+        )
+        account_map.set(
+            tokenB.symbol,
+            getCachedAtaAddress(wallet_pubkey, tokenB.address, programIdB)
+        )
     }
     return account_map
 }

package/src/common/index.ts

@@ -1,4 +1,4 @@
 export * from './constants'
 export * from './get_wallet_token_account'
 export * from './subscribe_account_update'
-export * from './get_signature'
+export * from './get_signature'

package/tsconfig.json

@@ -5,11 +5,10 @@
             "./types",
         ],
         "lib": [
-            "es2017",
-            "dom"
+            "es2020"
         ],
         "module": "CommonJS",
-        "target": "es2017",
+        "target": "es2020",
         "rootDirs": [
             "src"
         ],
@@ -20,6 +19,6 @@
         "resolveJsonModule": true,
         "removeComments": true
     },
-    "include": ["src/**/*"],
+    "include": ["src/**/*", "docs/clmm_local_calc.ts", "../ttd-sol-orca-clmm/src/quote/clmm_engine.ts"],
     "exclude": ["dist"]
   }