@clonegod/ttd-sol-common 1.0.23 → 1.0.25

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

@@ -1,7 +1,6 @@
-import { Webhook, CreateWebhookRequest, EditWebhookRequest, CreateCollectionWebhookRequest, MintlistRequest, MintlistResponse, MintApiAuthority, HeliusCluster, HeliusEndpoints } from './types';
+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>;
@@ -20,6 +19,13 @@ export declare class Helius {
     removeAddressesFromWebhook(webhookID: string, addressesToRemove: string[]): Promise<Webhook>;
     createCollectionWebhook(request: CreateCollectionWebhookRequest): Promise<Webhook>;
     getMintlist(request: MintlistRequest): Promise<MintlistResponse>;
+    mintCompressedNft(mintApiRequest: MintApiRequest): Promise<MintApiResponse>;
+    delegateCollectionAuthority(request: DelegateCollectionAuthorityRequest): Promise<string>;
+    revokeCollectionAuthority(request: RevokeCollectionAuthorityRequest): Promise<string>;
     getApiEndpoint(path: string): string;
     private _editWebhook;
+    private handleImageUpload;
+    private uploadImageToArweave;
+    private getCollectionAuthorityRecord;
+    private getCollectionMetadataAccount;
 }

package/dist/helius_sdk_v1.4.0/Helius.js

@@ -1,4 +1,27 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -15,11 +38,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Helius = void 0;
 const axios_1 = __importDefault(require("axios"));
 const web3_js_1 = require("@solana/web3.js");
+const sdk_1 = __importDefault(require("@irys/sdk"));
+const fs = __importStar(require("fs"));
 const utils_1 = require("./utils");
 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 !== '') {
@@ -33,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() {
@@ -248,6 +274,95 @@ class Helius {
             }
         });
     }
+    mintCompressedNft(mintApiRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            yield this.handleImageUpload(mintApiRequest);
+            try {
+                const { data } = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: '2.0',
+                    id: 'helius-test',
+                    method: 'mintCompressedNft',
+                    params: Object.assign({}, mintApiRequest),
+                });
+                return data;
+            }
+            catch (err) {
+                if (axios_1.default.isAxiosError(err)) {
+                    throw new Error(`error during mintCompressedNft: ${((_a = err.response) === null || _a === void 0 ? void 0 : _a.data.error.message) || err}`);
+                }
+                else {
+                    throw new Error(`error during mintCompressedNft: ${err}`);
+                }
+            }
+        });
+    }
+    delegateCollectionAuthority(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let { collectionMint, updateAuthorityKeypair, newCollectionAuthority, payerKeypair, } = request;
+                payerKeypair = payerKeypair !== null && payerKeypair !== void 0 ? payerKeypair : updateAuthorityKeypair;
+                newCollectionAuthority = newCollectionAuthority !== null && newCollectionAuthority !== void 0 ? newCollectionAuthority : this.mintApiAuthority;
+                const collectionMintPubkey = new web3_js_1.PublicKey(collectionMint);
+                const collectionMetadata = this.getCollectionMetadataAccount(collectionMintPubkey);
+                const newCollectionAuthorityPubkey = new web3_js_1.PublicKey(newCollectionAuthority);
+                const collectionAuthorityRecord = this.getCollectionAuthorityRecord(collectionMintPubkey, newCollectionAuthorityPubkey);
+                const accounts = {
+                    collectionAuthorityRecord,
+                    newCollectionAuthority: newCollectionAuthorityPubkey,
+                    updateAuthority: updateAuthorityKeypair.publicKey,
+                    payer: payerKeypair.publicKey,
+                    metadata: collectionMetadata,
+                    mint: collectionMintPubkey,
+                };
+                const inx = (0, mpl_token_metadata_1.createApproveCollectionAuthorityInstruction)(accounts);
+                const tx = new web3_js_1.Transaction().add(inx);
+                tx.feePayer = payerKeypair.publicKey;
+                const sig = yield (0, web3_js_1.sendAndConfirmTransaction)(this.connection, tx, [payerKeypair, updateAuthorityKeypair], {
+                    commitment: 'confirmed',
+                    skipPreflight: true,
+                });
+                return sig;
+            }
+            catch (e) {
+                console.error('Failed to delegate collection authority: ', e);
+                throw e;
+            }
+        });
+    }
+    revokeCollectionAuthority(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let { collectionMint, revokeAuthorityKeypair, delegatedCollectionAuthority, payerKeypair, } = request;
+                payerKeypair = payerKeypair !== null && payerKeypair !== void 0 ? payerKeypair : revokeAuthorityKeypair;
+                delegatedCollectionAuthority =
+                    delegatedCollectionAuthority !== null && delegatedCollectionAuthority !== void 0 ? delegatedCollectionAuthority : this.mintApiAuthority;
+                const collectionMintPubkey = new web3_js_1.PublicKey(collectionMint);
+                const collectionAuthority = new web3_js_1.PublicKey(delegatedCollectionAuthority);
+                const collectionMetadata = this.getCollectionMetadataAccount(collectionMintPubkey);
+                const collectionAuthorityRecord = this.getCollectionAuthorityRecord(collectionMintPubkey, collectionAuthority);
+                const accounts = {
+                    collectionAuthorityRecord,
+                    delegateAuthority: collectionAuthority,
+                    revokeAuthority: revokeAuthorityKeypair.publicKey,
+                    metadata: collectionMetadata,
+                    mint: collectionMintPubkey,
+                };
+                const inx = (0, mpl_token_metadata_1.createRevokeCollectionAuthorityInstruction)(accounts);
+                const tx = new web3_js_1.Transaction().add(inx);
+                tx.feePayer = payerKeypair.publicKey;
+                const sig = yield (0, web3_js_1.sendAndConfirmTransaction)(this.connection, tx, [revokeAuthorityKeypair], {
+                    commitment: 'confirmed',
+                    skipPreflight: true,
+                });
+                return sig;
+            }
+            catch (e) {
+                console.error('Failed to revoke collection authority: ', e);
+                throw e;
+            }
+        });
+    }
     getApiEndpoint(path) {
         if (!path.startsWith('/v0') && !path.startsWith('/v1')) {
             throw new Error(`Invalid API path provided: ${path}. Path must start with '/v0' or '/v1'.`);
@@ -274,5 +389,67 @@ class Helius {
             return data;
         });
     }
+    handleImageUpload(mintApiRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (mintApiRequest.imagePath && mintApiRequest.imageUrl) {
+                throw new Error('Cannot provide both imagePath and imageUrl. Please only provide one.');
+            }
+            if (mintApiRequest.imagePath && !mintApiRequest.walletPrivateKey) {
+                throw new Error('Must provide wallet privateKey if providing imagePath.');
+            }
+            if (mintApiRequest.imagePath && mintApiRequest.walletPrivateKey) {
+                mintApiRequest.imageUrl = yield this.uploadImageToArweave(mintApiRequest.imagePath, mintApiRequest.walletPrivateKey);
+            }
+            delete mintApiRequest.imagePath;
+            delete mintApiRequest.walletPrivateKey;
+        });
+    }
+    uploadImageToArweave(imagePath, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const irys = new sdk_1.default({
+                url: this.cluster === 'mainnet-beta'
+                    ? 'https://node2.irys.xyz'
+                    : 'https://devnet.irys.xyz',
+                token: 'solana',
+                key: privateKey,
+                config: {
+                    providerUrl: this.endpoint,
+                },
+            });
+            const stats = fs.statSync(imagePath);
+            const fileSizeInBytes = stats.size;
+            const fileSizeInKB = fileSizeInBytes / 1000;
+            if (this.cluster === 'devnet' || fileSizeInKB >= 200) {
+                const price = yield irys.getPrice(fileSizeInBytes);
+                yield irys.fund(price, 1.1);
+            }
+            try {
+                const receipt = yield irys.uploadFile(imagePath);
+                const url = `https://arweave.net/${receipt.id}`;
+                return url;
+            }
+            catch (e) {
+                throw new Error(`error uploading image to Arweave: ${e}`);
+            }
+        });
+    }
+    getCollectionAuthorityRecord(collectionMint, collectionAuthority) {
+        const [collectionAuthRecordPda] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from('metadata'),
+            mpl_token_metadata_1.PROGRAM_ID.toBuffer(),
+            collectionMint.toBuffer(),
+            Buffer.from('collection_authority'),
+            collectionAuthority.toBuffer(),
+        ], mpl_token_metadata_1.PROGRAM_ID);
+        return collectionAuthRecordPda;
+    }
+    getCollectionMetadataAccount(collectionMint) {
+        const [collectionMetadataAccount] = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from('metadata', 'utf8'),
+            mpl_token_metadata_1.PROGRAM_ID.toBuffer(),
+            collectionMint.toBuffer(),
+        ], mpl_token_metadata_1.PROGRAM_ID);
+        return collectionMetadataAccount;
+    }
 }
 exports.Helius = Helius;

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sol-common",
-    "version": "1.0.23",
+    "version": "1.0.25",
     "description": "",
     "main": "dist/index.js",
     "types": "types/index.d.ts",
@@ -13,7 +13,9 @@
         "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",
         "bs58": "^6.0.0"
     },

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;
-}
+