@clonegod/ttd-sol-common 2.0.11 → 2.0.12

package/dist/common/get_wallet_token_account.d.ts

@@ -0,0 +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 const create_token_account_if_not_exist: (connection: Connection, owner: Keypair, token_list: StandardTokenInfoType[]) => Promise<void>;

package/dist/common/get_wallet_token_account.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_token_account_if_not_exist = exports.get_token_program_id = void 0;
+exports.get_wallet_token_account = get_wallet_token_account;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const constants_1 = require("./constants");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const get_token_program_id = (token) => {
+    let programId = spl_token_1.TOKEN_PROGRAM_ID;
+    if (token.is_token2022) {
+        programId = spl_token_1.TOKEN_2022_PROGRAM_ID;
+    }
+    return programId;
+};
+exports.get_token_program_id = get_token_program_id;
+async 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());
+    }
+    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())) {
+            return;
+        }
+        try {
+            const mint = new web3_js_1.PublicKey(token.address);
+            let ata = await (0, spl_token_1.getAssociatedTokenAddress)(new web3_js_1.PublicKey(mint), owner.publicKey);
+            const account_data = await connection.getAccountInfo(ata);
+            if (account_data) {
+                (0, dist_1.log_info)(`token account already exist, skip!`, {
+                    owner: owner.publicKey.toBase58(),
+                    token,
+                    ata: ata.toBase58()
+                });
+            }
+            else {
+                (0, dist_1.log_info)(`token account not exist, create new one!`, {
+                    owner: owner.publicKey.toBase58(),
+                    token,
+                });
+                if (token.is_token2022) {
+                    ata = await (0, spl_token_1.createAssociatedTokenAccountIdempotent)(connection, owner, mint, owner.publicKey, {
+                        commitment: constants_1.COMMITMENT_LEVEL.CONFIRMED,
+                    }, spl_token_1.TOKEN_2022_PROGRAM_ID, spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+                }
+                else {
+                    ata = await (0, spl_token_1.createAssociatedTokenAccountIdempotent)(connection, owner, mint, owner.publicKey, {
+                        commitment: constants_1.COMMITMENT_LEVEL.CONFIRMED,
+                    }, spl_token_1.TOKEN_PROGRAM_ID, spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+                }
+                (0, dist_1.log_info)(`Create New Token Account`, {
+                    owner: owner.publicKey.toBase58(),
+                    token,
+                    ata: ata.toBase58()
+                });
+            }
+        }
+        catch (err) {
+            (0, dist_1.log_error)(`create_token_account_if_not_exist error!`, err);
+        }
+    });
+};
+exports.create_token_account_if_not_exist = create_token_account_if_not_exist;

package/dist/common/index.d.ts

@@ -1 +1,2 @@
 export * from './constants';
+export * from './get_wallet_token_account';

package/dist/common/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./constants"), exports);
+__exportStar(require("./get_wallet_token_account"), exports);

package/dist/quote/pricing/token_price_cache.js

@@ -1,13 +1,4 @@
 "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.TokenPriceCache = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
@@ -17,23 +8,21 @@ class TokenPriceCache {
         this.PRICE_CACHE_TIMEOUT_MILLS = parseInt(process.env.PRICE_CACHE_TIMEOUT_MILLS || Number(1000 * 60 * 60 * 1).toString());
         (0, dist_1.log_info)(`代币价格缓存超时时间: ${this.PRICE_CACHE_TIMEOUT_MILLS} ms`);
     }
-    getTokenPrice(tokenAddress) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const now = Date.now();
-            const cachedData = this.tokenPriceCache.get(tokenAddress);
-            if (cachedData && (now - cachedData.timestamp) < this.PRICE_CACHE_TIMEOUT_MILLS) {
-                (0, dist_1.log_debug)(`use cached token price: ${tokenAddress}, price: ${cachedData.price}`, '');
-                return cachedData;
-            }
-            const priceMap = yield (0, dist_1.get_solana_token_price_info)([tokenAddress]);
-            const tokenPrice = priceMap.get(tokenAddress);
-            if (!tokenPrice || !tokenPrice.price || Number(tokenPrice.price) <= 0) {
-                throw new Error(`无法获取代币 ${tokenAddress} 的有效USD价格`);
-            }
-            const newPrice = { price: tokenPrice.price, timestamp: now };
-            this.tokenPriceCache.set(tokenAddress, newPrice);
-            return newPrice;
-        });
+    async getTokenPrice(tokenAddress) {
+        const now = Date.now();
+        const cachedData = this.tokenPriceCache.get(tokenAddress);
+        if (cachedData && (now - cachedData.timestamp) < this.PRICE_CACHE_TIMEOUT_MILLS) {
+            (0, dist_1.log_debug)(`use cached token price: ${tokenAddress}, price: ${cachedData.price}`, '');
+            return cachedData;
+        }
+        const priceMap = await (0, dist_1.get_solana_token_price_info)([tokenAddress]);
+        const tokenPrice = priceMap.get(tokenAddress);
+        if (!tokenPrice || !tokenPrice.price || Number(tokenPrice.price) <= 0) {
+            throw new Error(`无法获取代币 ${tokenAddress} 的有效USD价格`);
+        }
+        const newPrice = { price: tokenPrice.price, timestamp: now };
+        this.tokenPriceCache.set(tokenAddress, newPrice);
+        return newPrice;
     }
 }
 exports.TokenPriceCache = TokenPriceCache;

package/dist/trade/SolanaTradeAppConfig.d.ts

@@ -0,0 +1,11 @@
+import { StandardPoolInfoType } from "@clonegod/ttd-core";
+import { AbstractTradeAppConfig, DEX_ID } from "@clonegod/ttd-core/dist";
+import { Connection, Keypair } from "@solana/web3.js";
+import { SolanaPoolAccountUpdateEventData } from "../types";
+export declare class SolanaTradeAppConfig extends AbstractTradeAppConfig {
+    connection: Connection;
+    keypair: Keypair;
+    constructor();
+    subscribe_pool_events_from_multiple_providers(dex_id: DEX_ID, pool_list: StandardPoolInfoType[], callback: (eventData: SolanaPoolAccountUpdateEventData) => void): void;
+    subscribe_wallet_raw_txn_event(): void;
+}

package/dist/trade/SolanaTradeAppConfig.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaTradeAppConfig = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class SolanaTradeAppConfig extends dist_1.AbstractTradeAppConfig {
+    constructor() {
+        super();
+    }
+    subscribe_pool_events_from_multiple_providers(dex_id, pool_list, callback) {
+        const ws_url = process.env.SUBSCIBE_MULTIPLE_PROVIDERS_WS_URL || 'ws://127.0.0.1:10000';
+        const ws_client = new dist_1.WebSocketClient(ws_url);
+        ws_client.onOpen(() => {
+            pool_list.forEach(({ pair, pool_address }, _) => {
+                ws_client.send(JSON.stringify({ dex_id, pair, pool_address }));
+            });
+        });
+        ws_client.onMessage(((eventData) => {
+            if (!eventData.data) {
+                (0, dist_1.log_warn)(`[SolanaTradeAppConfig] subscribe_pool_events_from_multiple_providers: no data`, eventData);
+            }
+            else {
+                callback(eventData);
+            }
+        }));
+        ws_client.connect();
+    }
+    subscribe_wallet_raw_txn_event() {
+        return;
+    }
+}
+exports.SolanaTradeAppConfig = SolanaTradeAppConfig;

package/dist/trade/index.d.ts

@@ -1,2 +1,4 @@
 export * from './tx_result_check';
 export * from './tx_result_parse';
+export * from './SolanaTradeAppConfig';
+export * from './tx_builder';

package/dist/trade/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./tx_result_check"), exports);
 __exportStar(require("./tx_result_parse"), exports);
+__exportStar(require("./SolanaTradeAppConfig"), exports);
+__exportStar(require("./tx_builder"), exports);

package/dist/trade/tx_builder.d.ts

@@ -0,0 +1,18 @@
+import { TradeContext } from "@clonegod/ttd-core/dist";
+import { Connection, Keypair, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { SolanaTradeAppConfig } from "./SolanaTradeAppConfig";
+export declare class SolTransactionBuilder {
+    appConfig: SolanaTradeAppConfig;
+    protected connection: Connection;
+    protected keypair: Keypair;
+    protected recentBlockhash: string;
+    protected recentBlockheight: number;
+    constructor(appConfig: SolanaTradeAppConfig);
+    init(): Promise<void>;
+    private handleBlockUpdateEvent;
+    execute(context: TradeContext): Promise<string>;
+    getPreInstructions(context: TradeContext): TransactionInstruction[];
+    getPostInstructions(context: TradeContext): TransactionInstruction[];
+    buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[]): Transaction;
+    buildTransactionForTip(context: TradeContext, tipAccount: string, tipAmount: number, tipPayer: Keypair): Transaction;
+}

package/dist/trade/tx_builder.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolTransactionBuilder = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const web3_js_1 = require("@solana/web3.js");
+const LAMPORTS_PER_MICRO_LAMPORTS = 1000000;
+class SolTransactionBuilder {
+    constructor(appConfig) {
+        this.appConfig = appConfig;
+        this.connection = appConfig.connection;
+        this.keypair = appConfig.keypair;
+        this.init();
+    }
+    async init() {
+        this.appConfig.arb_event_subscriber.subscribe_new_block(dist_1.CHAIN_ID.SOLANA, this.handleBlockUpdateEvent.bind(this));
+    }
+    async handleBlockUpdateEvent(eventData) {
+        let blockUpdateEvent = JSON.parse(eventData);
+        const { blockHash, blockHeight } = blockUpdateEvent;
+        this.recentBlockhash = blockHash;
+        this.recentBlockheight = blockHeight;
+    }
+    execute(context) {
+        throw new Error('not implemented!!!');
+    }
+    getPreInstructions(context) {
+        const cu_limit = context.pool_info.cu_limit || 600000;
+        const sol_priority_fee_lamports = context.trade_runtime.settings.strategy.sol_priority_fee;
+        const priorityFeeMicroLamports = Math.floor((sol_priority_fee_lamports * LAMPORTS_PER_MICRO_LAMPORTS) / cu_limit);
+        const computeBudgetInstruction = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+            units: cu_limit,
+        });
+        const priorityFeeInstruction = web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: priorityFeeMicroLamports,
+        });
+        return [computeBudgetInstruction, priorityFeeInstruction];
+    }
+    getPostInstructions(context) {
+        return [];
+    }
+    buildTransactionForSwap(context, swapInstructions) {
+        const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset;
+        const swapTx = new web3_js_1.Transaction();
+        const preInstructions = this.getPreInstructions(context);
+        const postInstructions = this.getPostInstructions(context);
+        swapTx.add(...preInstructions, ...swapInstructions, ...postInstructions);
+        swapTx.recentBlockhash = this.recentBlockhash;
+        swapTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
+        swapTx.feePayer = this.keypair.publicKey;
+        swapTx.sign(this.keypair);
+        return swapTx;
+    }
+    buildTransactionForTip(context, tipAccount, tipAmount, tipPayer) {
+        const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset;
+        if (!tipPayer) {
+            tipPayer = this.keypair;
+        }
+        const tipTx = new web3_js_1.Transaction();
+        tipTx.add(web3_js_1.SystemProgram.transfer({
+            fromPubkey: tipPayer.publicKey,
+            toPubkey: new web3_js_1.PublicKey(tipAccount),
+            lamports: tipAmount,
+        }));
+        tipTx.recentBlockhash = this.recentBlockhash;
+        tipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset;
+        tipTx.feePayer = tipPayer.publicKey;
+        tipTx.sign(tipPayer);
+        return tipTx;
+    }
+}
+exports.SolTransactionBuilder = SolTransactionBuilder;

package/dist/trade/tx_result_check.js

@@ -1,13 +1,4 @@
 "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.TransactionResultChecker = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
@@ -39,11 +30,9 @@ class TransactionResultChecker extends dist_1.AbstractTransactionResultCheck {
         this.event_emitter.emit(dist_1.TRANSACTION_STATE_PROCESSING, empty_trade_result);
         return this;
     }
-    check() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.check_tx_result_interval();
-            this.on_subscibe_transaction();
-        });
+    async check() {
+        this.check_tx_result_interval();
+        this.on_subscibe_transaction();
     }
     on_subscibe_transaction() {
         this.event_emitter.once(dist_1.LOCAL_EVENT_NAME.EVENT_WALLET_TRANSACTION + '#' + this.txid, (messageStr) => {
@@ -84,57 +73,55 @@ class TransactionResultChecker extends dist_1.AbstractTransactionResultCheck {
             }
         });
     }
-    check_tx_result_interval() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const check_start_time = Date.now();
-            const check_interval = parseInt(process.env.CHECK_TX_RESULT_INTERVAL_MILLS || '3000');
-            const check_timeout = parseInt(process.env.CHECK_TX_RESULT_TIMEOUT_MILLS || '10000');
-            (0, dist_1.log_info)(`check transaction start: check_interval=${check_interval}, check_timeout=${check_timeout}`);
-            if (check_interval >= check_timeout) {
-                (0, dist_1.log_warn)(`check_interval=${check_interval} >= check_timeout=${check_timeout}, check_tx_result_interval failed!`);
-                return;
-            }
-            const intervalId = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                this.check_count += 1;
-                (0, dist_1.log_info)(`check transaction: seq=[${this.check_count}], txhash= ${this.txid}, trace_id=${this.trace_id}`);
-                try {
-                    if (Date.now() - check_start_time < check_timeout) {
-                        let tx_result = yield this.connection.getParsedTransaction(this.txid, {
-                            commitment: common_1.COMMITMENT_LEVEL.CONFIRMED,
-                            maxSupportedTransactionVersion: 0,
-                        });
-                        if ((0, dist_1.isEmpty)(tx_result)) {
-                            return;
-                        }
-                        clearInterval(intervalId);
-                        let swap_result = this.transactionParser.parse_transaction_data(tx_result, this.pool_info);
-                        let trade_result = this.map_swap_result_to_tx_result(swap_result);
-                        if (this.trade_result_already_processed) {
-                            (0, dist_1.log_warn)(`trade_result_already_processed=${this.trade_result_already_processed}, ignore trade result fetch by interval check!`);
+    async check_tx_result_interval() {
+        const check_start_time = Date.now();
+        const check_interval = parseInt(process.env.CHECK_TX_RESULT_INTERVAL_MILLS || '3000');
+        const check_timeout = parseInt(process.env.CHECK_TX_RESULT_TIMEOUT_MILLS || '10000');
+        (0, dist_1.log_info)(`check transaction start: check_interval=${check_interval}, check_timeout=${check_timeout}`);
+        if (check_interval >= check_timeout) {
+            (0, dist_1.log_warn)(`check_interval=${check_interval} >= check_timeout=${check_timeout}, check_tx_result_interval failed!`);
+            return;
+        }
+        const intervalId = setInterval(async () => {
+            this.check_count += 1;
+            (0, dist_1.log_info)(`check transaction: seq=[${this.check_count}], txhash= ${this.txid}, trace_id=${this.trace_id}`);
+            try {
+                if (Date.now() - check_start_time < check_timeout) {
+                    let tx_result = await this.connection.getParsedTransaction(this.txid, {
+                        commitment: common_1.COMMITMENT_LEVEL.CONFIRMED,
+                        maxSupportedTransactionVersion: 0,
+                    });
+                    if ((0, dist_1.isEmpty)(tx_result)) {
+                        return;
+                    }
+                    clearInterval(intervalId);
+                    let swap_result = this.transactionParser.parse_transaction_data(tx_result, this.pool_info);
+                    let trade_result = this.map_swap_result_to_tx_result(swap_result);
+                    if (this.trade_result_already_processed) {
+                        (0, dist_1.log_warn)(`trade_result_already_processed=${this.trade_result_already_processed}, ignore trade result fetch by interval check!`);
+                    }
+                    else {
+                        if (trade_result.success) {
+                            this.event_emitter.emit(dist_1.TRANSACTION_STATE_SUCCESS, trade_result);
                         }
                         else {
-                            if (trade_result.success) {
-                                this.event_emitter.emit(dist_1.TRANSACTION_STATE_SUCCESS, trade_result);
-                            }
-                            else {
-                                this.event_emitter.emit(dist_1.TRANSACTION_STATE_FAILED, trade_result);
-                            }
-                            console.log('<====================================================');
-                            console.dir(trade_result, { depth: 8 });
-                            console.log('====================================================>');
+                            this.event_emitter.emit(dist_1.TRANSACTION_STATE_FAILED, trade_result);
                         }
-                    }
-                    else {
-                        clearInterval(intervalId);
+                        console.log('<====================================================');
+                        console.dir(trade_result, { depth: 8 });
+                        console.log('====================================================>');
                     }
                 }
-                catch (err) {
+                else {
                     clearInterval(intervalId);
-                    (0, dist_1.log_error)('parse transaction error!', err);
                 }
-            }), check_interval);
-            this.intervalId = intervalId;
-        });
+            }
+            catch (err) {
+                clearInterval(intervalId);
+                (0, dist_1.log_error)('parse transaction error!', err);
+            }
+        }, check_interval);
+        this.intervalId = intervalId;
     }
     map_swap_result_to_tx_result(swap_result) {
         let { success, error_code, wallet, block_number, block_time: order_block_time, txid, tx_price, tokenA, tokenB, gas_fee } = swap_result;

package/dist/types/index.d.ts

@@ -20,3 +20,18 @@ export interface SolanaBlockMetaUpdateEvent {
     executedTransactionCount: number;
     entriesCount: number;
 }
+export interface SolanaPoolAccountUpdateEventData {
+    type: string;
+    provider_id: string;
+    event_time: number;
+    dexId: string;
+    pair: string;
+    pool_address: string;
+    pool_name: string;
+    data: {
+        slot: number;
+        writeVersion: number;
+        transactionHash: string;
+        accountData: string;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clonegod/ttd-sol-common",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "description": "",
   "main": "dist/index.js",
   "types": "types/index.d.ts",

package/src/common/get_wallet_token_account.ts

@@ -0,0 +1,90 @@
+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 { Connection, Keypair, PublicKey } from "@solana/web3.js";
+
+
+export const get_token_program_id = (token: StandardTokenInfoType) => {
+    let programId: PublicKey = TOKEN_PROGRAM_ID
+    if(token.is_token2022) {
+        programId = TOKEN_2022_PROGRAM_ID
+    }
+    return programId
+}
+
+export async 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())
+    }
+    return account_map
+}
+
+
+
+/**
+ * 创建Token Account
+ */
+export const create_token_account_if_not_exist = async (connection:Connection, owner:Keypair, token_list: StandardTokenInfoType[]) => {
+    token_list.forEach(async token => {
+        if(['SOL','WSOL','USDC','USDT'].includes(token.symbol?.toUpperCase())) {
+            return
+        }
+        
+        try {
+            const mint = new PublicKey(token.address)
+            // calculate ATA
+            let ata = await getAssociatedTokenAddress(new PublicKey(mint), owner.publicKey)
+            const account_data = await connection.getAccountInfo(ata)
+            if(account_data) {
+                log_info(`token account already exist, skip!`, {
+                    owner: owner.publicKey.toBase58(),
+                    token,
+                    ata: ata.toBase58()
+                });
+            } else {
+                log_info(`token account not exist, create new one!`, {
+                    owner: owner.publicKey.toBase58(),
+                    token,
+                });
+                if(token.is_token2022) {
+                    ata = await createAssociatedTokenAccountIdempotent(
+                        connection,
+                        owner,
+                        mint,
+                        owner.publicKey,
+                        {
+                            commitment: COMMITMENT_LEVEL.CONFIRMED,
+                        },
+                        TOKEN_2022_PROGRAM_ID,
+                        ASSOCIATED_TOKEN_PROGRAM_ID
+                    )
+                } else {
+                    ata = await createAssociatedTokenAccountIdempotent(
+                        connection,
+                        owner,
+                        mint,
+                        owner.publicKey,
+                        {
+                            commitment: COMMITMENT_LEVEL.CONFIRMED,
+                        },
+                        TOKEN_PROGRAM_ID,
+                        ASSOCIATED_TOKEN_PROGRAM_ID
+                    )
+                }
+                log_info(`Create New Token Account`, {
+                    owner: owner.publicKey.toBase58(),
+                    token,
+                    ata: ata.toBase58()
+                });
+            }
+        } catch (err) {
+            log_error(`create_token_account_if_not_exist error!`, err)
+        }
+    })
+}
+

package/src/common/index.ts

@@ -1,2 +1,3 @@
 export * from './constants'
+export * from './get_wallet_token_account'
 

package/src/trade/SolanaTradeAppConfig.ts

@@ -0,0 +1,50 @@
+import { StandardPoolInfoType } from "@clonegod/ttd-core";
+import { AbstractTradeAppConfig, DEX_ID, log_warn, WebSocketClient } from "@clonegod/ttd-core/dist";
+import { Connection, Keypair } from "@solana/web3.js";
+import { SolanaPoolAccountUpdateEventData } from "../types";
+
+export class SolanaTradeAppConfig extends AbstractTradeAppConfig {
+
+    // 子类需要设置的属性
+    public connection: Connection;
+    public keypair: Keypair;
+
+    constructor() {
+        super();
+    }
+
+    /**
+     * 集中订阅方式，丛 solana-stream 获取池子变化事件，获得poolRawData 
+     * - 询价：基于池子数据计算价格
+     * - 交易使用：交易中需要池子的最新状态
+     */
+    subscribe_pool_events_from_multiple_providers(dex_id:DEX_ID, pool_list:StandardPoolInfoType[], callback:(eventData:SolanaPoolAccountUpdateEventData)=>void) {
+        const ws_url = process.env.SUBSCIBE_MULTIPLE_PROVIDERS_WS_URL || 'ws://127.0.0.1:10000';
+        const ws_client = new WebSocketClient(ws_url)
+        ws_client.onOpen(() => {
+            pool_list.forEach(({ pair, pool_address }, _) => {
+                ws_client.send(JSON.stringify({ dex_id, pair, pool_address }))
+            })
+        })
+        ws_client.onMessage(((eventData: SolanaPoolAccountUpdateEventData): void => {
+            if (!eventData.data) {
+                log_warn(`[SolanaTradeAppConfig] subscribe_pool_events_from_multiple_providers: no data`, eventData);
+            } else {
+                callback(eventData);
+            }
+        }));
+        ws_client.connect();
+    }
+
+
+    // 订阅 Wallet 在链上发生的tx data
+    subscribe_wallet_raw_txn_event(): void {
+        // not used
+        return;
+    }
+
+
+
+}
+
+

package/src/trade/index.ts

@@ -1,2 +1,4 @@
 export * from './tx_result_check'
-export * from './tx_result_parse'
+export * from './tx_result_parse'
+export * from './SolanaTradeAppConfig'
+export * from './tx_builder'

package/src/trade/tx_builder.ts

@@ -0,0 +1,113 @@
+import { CHAIN_ID, TradeContext } from "@clonegod/ttd-core/dist";
+import { SolanaBlockMetaUpdateEvent } from "../types";
+import { ComputeBudgetProgram, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction, TransactionInstruction } from "@solana/web3.js";
+import { SolanaTradeAppConfig } from "./SolanaTradeAppConfig";
+
+
+// There are 10^6 micro-lamports in one lamport
+const LAMPORTS_PER_MICRO_LAMPORTS = 1000000;
+
+export class SolTransactionBuilder {
+    appConfig: SolanaTradeAppConfig
+    protected connection: Connection
+    protected keypair: Keypair
+
+    protected recentBlockhash: string
+    protected recentBlockheight: number
+
+    constructor(appConfig: SolanaTradeAppConfig) {
+        this.appConfig = appConfig
+        this.connection = appConfig.connection
+        this.keypair = appConfig.keypair
+        this.init()
+    }
+
+    public async init(): Promise<void> {
+        // 订阅区块更新事件
+        this.appConfig.arb_event_subscriber.subscribe_new_block(CHAIN_ID.SOLANA, this.handleBlockUpdateEvent.bind(this));
+    }
+
+    private async handleBlockUpdateEvent(eventData: string): Promise<void> {
+        let blockUpdateEvent = JSON.parse(eventData) as SolanaBlockMetaUpdateEvent;
+        const { blockHash, blockHeight } = blockUpdateEvent;
+        this.recentBlockhash = blockHash
+        this.recentBlockheight = blockHeight
+        // console.log(`handleBlockUpdateEvent, blockHeight: ${blockHeight}, blockHash: ${blockHash}`)
+    }
+
+    execute(context: TradeContext): Promise<string> {
+        throw new Error('not implemented!!!')
+    }
+
+
+    // pre-instructions
+    getPreInstructions(context: TradeContext): TransactionInstruction[] {
+        const cu_limit = context.pool_info.cu_limit || 600000
+        const sol_priority_fee_lamports = context.trade_runtime.settings.strategy.sol_priority_fee
+        const priorityFeeMicroLamports = Math.floor((sol_priority_fee_lamports * LAMPORTS_PER_MICRO_LAMPORTS) / cu_limit)
+        // console.log('getPreInstructions', { cu_limit, sol_priority_fee_lamports, priorityFeeMicroLamports, })
+
+        // set compute budget instruction
+        const computeBudgetInstruction = ComputeBudgetProgram.setComputeUnitLimit({
+            units: cu_limit,
+        })
+
+        // set priority fee instruction
+        const priorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: priorityFeeMicroLamports,
+        })
+
+        return [computeBudgetInstruction, priorityFeeInstruction]
+    }
+
+    
+    // post-instructions
+    getPostInstructions(context: TradeContext): TransactionInstruction[] {
+        return []
+    }
+
+
+    buildTransactionForSwap(context: TradeContext, swapInstructions: TransactionInstruction[]): Transaction {
+        const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset
+        // console.log(`buildTransactionForSwap, max_block_offset: ${max_block_offset}`)
+
+        const swapTx = new Transaction();
+
+        const preInstructions = this.getPreInstructions(context)
+        const postInstructions = this.getPostInstructions(context)
+
+        swapTx.add(...preInstructions, ...swapInstructions, ...postInstructions)
+        swapTx.recentBlockhash = this.recentBlockhash
+        swapTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
+        swapTx.feePayer = this.keypair.publicKey
+
+        swapTx.sign(this.keypair)
+
+        return swapTx
+    }
+
+    buildTransactionForTip(context: TradeContext, tipAccount: string, tipAmount: number, tipPayer: Keypair): Transaction {
+        const max_block_offset = context.trade_runtime.settings.strategy.max_block_offset
+
+        if(!tipPayer) {
+            tipPayer = this.keypair
+        }
+        
+        const tipTx = new Transaction();
+        tipTx.add(
+            SystemProgram.transfer({
+                fromPubkey: tipPayer.publicKey,
+                toPubkey: new PublicKey(tipAccount),
+                lamports: tipAmount,
+            }),
+        );
+        tipTx.recentBlockhash = this.recentBlockhash
+        tipTx.lastValidBlockHeight = this.recentBlockheight + max_block_offset
+        tipTx.feePayer = tipPayer.publicKey;
+
+        tipTx.sign(tipPayer)
+
+        return tipTx
+    }
+
+}

package/src/types/index.ts

@@ -36,3 +36,22 @@ export interface SolanaBlockMetaUpdateEvent {
     entriesCount: number;
 }
 
+/**
+ * 推送给询价、交易进程的Account Change Event 结构
+ */
+export interface SolanaPoolAccountUpdateEventData {
+    type: string
+    provider_id: string
+    event_time: number
+    dexId: string
+    pair: string
+    pool_address: string
+    pool_name: string
+    data: {
+        slot: number
+        writeVersion: number
+        transactionHash: string
+        accountData: string
+    }
+}
+

package/tsconfig.json

@@ -5,10 +5,11 @@
             "./types",
         ],
         "lib": [
-            "es2015"
+            "es2017",
+            "dom"
         ],
         "module": "CommonJS",
-        "target": "es6",
+        "target": "es2017",
         "rootDirs": [
             "src"
         ],
@@ -17,6 +18,8 @@
         "esModuleInterop": true,
         "skipLibCheck": true,
         "resolveJsonModule": true,
-        "removeComments": true,
-    }
-}
+        "removeComments": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["dist"]
+  }

package/dist/quote/types.d.ts

@@ -1,22 +0,0 @@
-export interface SolanaAccountUpdateEvent {
-    recv_ms: number;
-    providerId: string;
-    slot: number;
-    writeVersion: number;
-    transactionHash: string;
-    dexId: string;
-    pair: string;
-    poolAddress: string;
-    poolName?: string;
-    accountData?: Buffer | string;
-}
-export interface SolanaBlockMetaUpdateEvent {
-    slot: number;
-    blockhash: string;
-    blockTime: number;
-    BlockHeight: number;
-    parentSlot: number;
-    parentBlockhash: string;
-    executedTransactionCount: number;
-    entriesCount: number;
-}

package/dist/quote/types.js

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