@clonegod/ttd-sol-common 1.0.24 → 1.0.26

package/dist/helius_sdk_v1.4.0/Helius.d.ts

@@ -1,7 +1,6 @@
 import { Webhook, CreateWebhookRequest, EditWebhookRequest, CreateCollectionWebhookRequest, MintlistRequest, MintlistResponse, MintApiRequest, MintApiResponse, MintApiAuthority, DelegateCollectionAuthorityRequest, RevokeCollectionAuthorityRequest, HeliusCluster, HeliusEndpoints } from './types';
 import { Connection } from '@solana/web3.js';
 import { RpcClient } from './RpcClient';
-import { SolanaTradeRuntimeType } from '../context';
 export declare class Helius {
     private apiKey?;
     readonly cluster: HeliusCluster;
@@ -10,7 +9,7 @@ export declare class Helius {
     readonly connection: Connection;
     readonly rpc: RpcClient;
     readonly mintApiAuthority: MintApiAuthority;
-    constructor(apiKey: string, cluster: HeliusCluster, id: string, url: string, solana_trade_runtime: SolanaTradeRuntimeType);
+    constructor(apiKey: string, cluster?: HeliusCluster, id?: string, url?: string);
     getAllWebhooks(): Promise<Webhook[]>;
     getWebhookByID(webhookID: string): Promise<Webhook>;
     createWebhook(createWebhookRequest: CreateWebhookRequest): Promise<Webhook>;

package/dist/helius_sdk_v1.4.0/Helius.js

@@ -45,7 +45,7 @@ const RpcClient_1 = require("./RpcClient");
 const mpl_token_metadata_1 = require("@metaplex-foundation/mpl-token-metadata");
 const mintApi_1 = require("./utils/mintApi");
 class Helius {
-    constructor(apiKey, cluster = 'mainnet-beta', id = 'helius-sdk', url = '', solana_trade_runtime) {
+    constructor(apiKey, cluster = 'mainnet-beta', id = 'helius-sdk', url = '') {
         this.cluster = cluster;
         this.endpoints = (0, utils_1.getHeliusEndpoints)(cluster);
         if (apiKey !== '') {
@@ -59,7 +59,7 @@ class Helius {
             throw Error('either `apiKey` or `url` is required');
         }
         this.endpoint = this.connection.rpcEndpoint;
-        this.rpc = new RpcClient_1.RpcClient(solana_trade_runtime, this.connection, id);
+        this.rpc = new RpcClient_1.RpcClient(this.connection, id);
         this.mintApiAuthority = (0, mintApi_1.mintApiAuthority)(cluster);
     }
     getAllWebhooks() {

package/dist/helius_sdk_v1.4.0/RpcClient.d.ts

@@ -11,10 +11,9 @@ export type SendAndConfirmTransactionResponse = {
     lastValidBlockHeight: number;
 };
 export declare class RpcClient {
-    protected readonly solana_trade_runtime: SolanaTradeRuntimeType;
     protected readonly connection: Connection;
     protected readonly id?: string;
-    constructor(solana_trade_runtime: SolanaTradeRuntimeType, connection: Connection, id?: string);
+    constructor(connection: Connection, id?: string);
     airdrop(publicKey: PublicKey, lamports: number, commitment?: Commitment): Promise<SendAndConfirmTransactionResponse>;
     getLatestBlockhash(commitmentOrConfig?: Commitment | GetLatestBlockhashConfig): Promise<BlockhashWithExpiryBlockHeight>;
     getCurrentTPS(): Promise<number>;
@@ -36,16 +35,16 @@ export declare class RpcClient {
     getPriorityFeeEstimate(params: GetPriorityFeeEstimateRequest): Promise<GetPriorityFeeEstimateResponse>;
     getComputeUnits(instructions: TransactionInstruction[], payer: PublicKey, lookupTables: AddressLookupTableAccount[], signers?: Signer[]): Promise<number | null>;
     pollTransactionConfirmation(txtSig: TransactionSignature, pollOptions?: PollTransactionOptions): Promise<TransactionSignature>;
-    createSmartTransaction(instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], feePayer?: Signer, serializeOptions?: SerializeConfig): Promise<SmartTransactionContext>;
-    sendSmartTransaction(instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], sendOptions?: SendOptions & {
+    createSmartTransaction(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], feePayer?: Signer, serializeOptions?: SerializeConfig): Promise<SmartTransactionContext>;
+    sendSmartTransaction(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], sendOptions?: SendOptions & {
         feePayer?: Signer;
         lastValidBlockHeightOffset?: number;
     }): Promise<TransactionSignature>;
     addTipInstruction(instructions: TransactionInstruction[], feePayer: PublicKey, tipAccount: string, tipAmount: number): void;
-    createSmartTransactionWithTip(instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], tipAmount?: number, feePayer?: Signer): Promise<SmartTransactionContext>;
+    createSmartTransactionWithTip(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], tipAmount?: number, feePayer?: Signer): Promise<SmartTransactionContext>;
     sendJitoBundle(serializedTransactions: string[], jitoApiUrl: string): Promise<string>;
     getBundleStatuses(bundleIds: string[], jitoApiUrl: string): Promise<any>;
-    sendSmartTransactionWithTip(instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], tipAmount?: number, region?: JitoRegion, feePayer?: Signer, lastValidBlockHeightOffset?: number): Promise<string>;
+    sendSmartTransactionWithTip(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[], signers: Signer[], lookupTables?: AddressLookupTableAccount[], tipAmount?: number, region?: JitoRegion, feePayer?: Signer, lastValidBlockHeightOffset?: number): Promise<string>;
     getNftEditions(params: DAS.GetNftEditionsRequest): Promise<DAS.GetNftEditionsResponse>;
     getTokenAccounts(params: DAS.GetTokenAccountsRequest): Promise<DAS.GetTokenAccountsResponse>;
     sendTransaction(transaction: Transaction | VersionedTransaction, options?: HeliusSendOptions): Promise<TransactionSignature>;

package/dist/helius_sdk_v1.4.0/RpcClient.js

@@ -20,8 +20,7 @@ const types_1 = require("./types");
 const get_signature_1 = require("../get_signature");
 const dist_1 = require("@clonegod/ttd-common/dist");
 class RpcClient {
-    constructor(solana_trade_runtime, connection, id) {
-        this.solana_trade_runtime = solana_trade_runtime;
+    constructor(connection, id) {
         this.connection = connection;
         this.id = id;
     }
@@ -352,8 +351,8 @@ class RpcClient {
             });
         });
     }
-    createSmartTransaction(instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], feePayer, serializeOptions = {
+    createSmartTransaction(solana_trade_runtime_1, instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], feePayer, serializeOptions = {
             requireAllSignatures: true,
             verifySignatures: true,
         }) {
@@ -408,7 +407,7 @@ class RpcClient {
                     throw new Error('Priority fee estimate not available');
                 }
             }), 0);
-            let priorityFeeEstimate = this.solana_trade_runtime.cu_price;
+            let priorityFeeEstimate = solana_trade_runtime.cu_price;
             const computeBudgetIx = web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
                 microLamports: priorityFeeEstimate,
             });
@@ -421,7 +420,7 @@ class RpcClient {
                     throw new Error(`Error fetching compute units for the instructions provided`);
                 }
             }), 0);
-            let units = this.solana_trade_runtime.cu_limit;
+            let units = solana_trade_runtime.cu_limit;
             const customersCU = units < 1000 ? 1000 : Math.ceil(units * 1.1);
             const computeUnitsIx = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
                 units: customersCU,
@@ -458,18 +457,18 @@ class RpcClient {
             };
         });
     }
-    sendSmartTransaction(instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], sendOptions = { skipPreflight: false, lastValidBlockHeightOffset: 150 }) {
+    sendSmartTransaction(solana_trade_runtime_1, instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], sendOptions = { skipPreflight: false, lastValidBlockHeightOffset: 150 }) {
             var _a;
             const lastValidBlockHeightOffset = (_a = sendOptions.lastValidBlockHeightOffset) !== null && _a !== void 0 ? _a : 150;
             if (lastValidBlockHeightOffset < 0)
                 throw new Error('expiryBlockOffset must be a positive integer');
             try {
-                const { transaction, blockhash, minContextSlot } = yield this.createSmartTransaction(instructions, signers, lookupTables, sendOptions.feePayer);
+                const { transaction, blockhash, minContextSlot } = yield this.createSmartTransaction(solana_trade_runtime, instructions, signers, lookupTables, sendOptions.feePayer);
                 let txid = (0, get_signature_1.getSignature)(transaction);
                 setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                     const commitment = (sendOptions === null || sendOptions === void 0 ? void 0 : sendOptions.preflightCommitment) || 'confirmed';
-                    const currentBlockHeight = yield this.solana_trade_runtime.connection.getBlockHeight();
+                    const currentBlockHeight = yield solana_trade_runtime.connection.getBlockHeight();
                     const lastValidBlockHeight = Math.min(blockhash.lastValidBlockHeight, currentBlockHeight + lastValidBlockHeightOffset);
                     let error;
                     do {
@@ -508,15 +507,15 @@ class RpcClient {
         });
         instructions.push(tipInstruction);
     }
-    createSmartTransactionWithTip(instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], tipAmount = 1000, feePayer) {
+    createSmartTransactionWithTip(solana_trade_runtime_1, instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], tipAmount = 1000, feePayer) {
             if (!signers.length) {
                 throw new Error('The transaction must have at least one signer');
             }
             const randomTipAccount = types_1.JITO_TIP_ACCOUNTS[Math.floor(Math.random() * types_1.JITO_TIP_ACCOUNTS.length)];
             const payerKey = feePayer ? feePayer.publicKey : signers[0].publicKey;
             this.addTipInstruction(instructions, payerKey, randomTipAccount, tipAmount);
-            return this.createSmartTransaction(instructions, signers, lookupTables, feePayer);
+            return this.createSmartTransaction(solana_trade_runtime, instructions, signers, lookupTables, feePayer);
         });
     }
     sendJitoBundle(serializedTransactions, jitoApiUrl) {
@@ -551,14 +550,14 @@ class RpcClient {
             return response.data.result;
         });
     }
-    sendSmartTransactionWithTip(instructions_1, signers_1) {
-        return __awaiter(this, arguments, void 0, function* (instructions, signers, lookupTables = [], tipAmount = 1000, region = 'Default', feePayer, lastValidBlockHeightOffset = 150) {
+    sendSmartTransactionWithTip(solana_trade_runtime_1, instructions_1, signers_1) {
+        return __awaiter(this, arguments, void 0, function* (solana_trade_runtime, instructions, signers, lookupTables = [], tipAmount = 1000, region = 'Default', feePayer, lastValidBlockHeightOffset = 150) {
             if (lastValidBlockHeightOffset < 0)
                 throw new Error('lastValidBlockHeightOffset must be a positive integer');
             if (!signers.length) {
                 throw new Error('The transaction must have at least one signer');
             }
-            const { transaction, blockhash } = yield this.createSmartTransactionWithTip(instructions, signers, lookupTables, tipAmount, feePayer);
+            const { transaction, blockhash } = yield this.createSmartTransactionWithTip(solana_trade_runtime, instructions, signers, lookupTables, tipAmount, feePayer);
             let txid = (0, get_signature_1.getSignature)(transaction);
             setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                 const serializedTransaction = bs58_1.default.encode(transaction.serialize());
@@ -568,7 +567,7 @@ class RpcClient {
                     txid,
                     bundleId
                 });
-                const currentBlockHeight = yield this.solana_trade_runtime.connection.getBlockHeight();
+                const currentBlockHeight = yield solana_trade_runtime.connection.getBlockHeight();
                 const lastValidBlockHeight = Math.min(blockhash.lastValidBlockHeight, currentBlockHeight + lastValidBlockHeightOffset);
                 const timeout = 60000;
                 const interval = 5000;

package/dist/send_transaction.d.ts

@@ -7,9 +7,8 @@ export declare class HeliusClient {
     cluster: string;
     helius_mainnet: Helius;
     helius_staked: Helius;
-    trade_runtime: SolanaTradeRuntimeType;
-    constructor(signers: Signer[], trade_runtime: SolanaTradeRuntimeType);
-    send_transaction(instructions: TransactionInstruction[]): Promise<string>;
+    constructor(signers: Signer[]);
+    send_transaction(solana_trade_runtime: SolanaTradeRuntimeType, instructions: TransactionInstruction[]): Promise<string>;
     private send_smart_transaction;
     private send_transaction_by_jito;
 }

package/dist/send_transaction.js

@@ -14,10 +14,9 @@ const dist_1 = require("@clonegod/ttd-common/dist");
 const helius_sdk_v1_4_0_1 = require("./helius_sdk_v1.4.0");
 const strategy_util_1 = require("./strategy_util");
 class HeliusClient {
-    constructor(signers, trade_runtime) {
+    constructor(signers) {
         this.cluster = 'mainnet-beta';
         this.signers = signers;
-        this.trade_runtime = trade_runtime;
         this.sendOptions = {
             skipPreflight: true,
             maxRetries: 0
@@ -25,19 +24,19 @@ class HeliusClient {
         let helius_api_key = process.env.HELIUS_API_KEY;
         let helius_mainnet_endpoint = `https://mainnet.helius-rpc.com/?api-key=${helius_api_key}`;
         let helius_staked_endpoint = `https://staked.helius-rpc.com?api-key=${helius_api_key}`;
-        this.helius_mainnet = new helius_sdk_v1_4_0_1.Helius('', this.cluster, 'helius-sdk', helius_mainnet_endpoint, this.trade_runtime);
-        this.helius_staked = new helius_sdk_v1_4_0_1.Helius('', this.cluster, 'helius-sdk', helius_staked_endpoint, this.trade_runtime);
+        this.helius_mainnet = new helius_sdk_v1_4_0_1.Helius('', this.cluster, 'helius-sdk', helius_mainnet_endpoint);
+        this.helius_staked = new helius_sdk_v1_4_0_1.Helius('', this.cluster, 'helius-sdk', helius_staked_endpoint);
     }
-    send_transaction(instructions) {
+    send_transaction(solana_trade_runtime, instructions) {
         return __awaiter(this, void 0, void 0, function* () {
             let txid = '';
-            let { broadcast_type, speed } = this.trade_runtime.settings.strategy;
+            let { broadcast_type, speed } = solana_trade_runtime.settings.strategy;
             if (broadcast_type === 'rpc') {
                 let use_staked_endpint = speed === 'turbo' || speed === 'ultra';
-                txid = yield this.send_smart_transaction(instructions, use_staked_endpint);
+                txid = yield this.send_smart_transaction(solana_trade_runtime, instructions, use_staked_endpint);
             }
             else if (broadcast_type === 'jito') {
-                txid = yield this.send_transaction_by_jito(instructions);
+                txid = yield this.send_transaction_by_jito(solana_trade_runtime, instructions);
             }
             else {
                 throw new Error(`Not support broadcast_type: ${broadcast_type}`);
@@ -45,12 +44,12 @@ class HeliusClient {
             return txid;
         });
     }
-    send_smart_transaction(instructions, use_staked_endpint) {
+    send_smart_transaction(solana_trade_runtime, instructions, use_staked_endpint) {
         return __awaiter(this, void 0, void 0, function* () {
             (0, dist_1.log_info)(`send_smart_transaction, start`);
             let start_time = Date.now();
             let rpc = use_staked_endpint ? this.helius_staked.rpc : this.helius_mainnet.rpc;
-            let txid = yield rpc.sendSmartTransaction(instructions, this.signers, [], this.sendOptions);
+            let txid = yield rpc.sendSmartTransaction(solana_trade_runtime, instructions, this.signers, [], this.sendOptions);
             (0, dist_1.log_info)(`send_smart_transaction, end`, {
                 txid,
                 use_staked_endpint,
@@ -59,14 +58,14 @@ class HeliusClient {
             return txid;
         });
     }
-    send_transaction_by_jito(instructions) {
+    send_transaction_by_jito(solana_trade_runtime, instructions) {
         return __awaiter(this, void 0, void 0, function* () {
             (0, dist_1.log_info)(`send_transaction_by_jito, start`);
             let start_time = Date.now();
-            let tipAmount = this.trade_runtime.priority_fee;
+            let tipAmount = solana_trade_runtime.priority_fee;
             let jito_region = (0, strategy_util_1.get_jito_region)();
             let rpc = this.helius_mainnet.rpc;
-            let txid = yield rpc.sendSmartTransactionWithTip(instructions, this.signers, [], tipAmount, jito_region);
+            let txid = yield rpc.sendSmartTransactionWithTip(solana_trade_runtime, instructions, this.signers, [], tipAmount, jito_region);
             (0, dist_1.log_info)(`send_transaction_by_jito, end`, {
                 tipAmount,
                 jito_region,

package/dist/strategy_util.js

@@ -6,7 +6,7 @@ const constants_1 = require("./constants");
 function create_solana_trade_runtime(trade_runtime, connection) {
     let trade_strategy = trade_runtime.settings.strategy;
     let { cu_limit } = trade_runtime.settings;
-    if (cu_limit < 50000) {
+    if (isNaN(cu_limit) || cu_limit < 50000) {
         cu_limit = 50000;
     }
     let priority_fee = calculate_gas_fee(trade_strategy);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sol-common",
-    "version": "1.0.24",
+    "version": "1.0.26",
     "description": "",
     "main": "dist/index.js",
     "types": "types/index.d.ts",
@@ -13,7 +13,7 @@
         "push": "npm run build && npm publish"
     },
     "dependencies": {
-        "@clonegod/ttd-common": "1.0.134",
+        "@clonegod/ttd-common": "1.0.135",
         "@irys/sdk": "^0.2.10",
         "@metaplex-foundation/mpl-token-metadata": "^2.5.2",
         "axios": "^1.2.3",

package/types/index.d.ts

@@ -19,14 +19,5 @@ export declare class HeliusClient {
     get_dynamic_fee_by_speed(speed: string, estimate_priority_fee: number, fee_max_cap: number): number;
 }
 
-export declare class _Context {
-    read_connection: Connection;
-    set_read_connection(read_connection: Connection): void;
-    priority_fee: number;
-    set_priority_fee(priority_fee: any): void;
-    cu_price: number;
-    set_cu_price(cu_price: number): void;
-    cu_limit: number;
-    set_cu_limit(cu_limit: number): void;
-}
+