@clonegod/ttd-sol-common 1.0.12 → 1.0.14

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

@@ -0,0 +1,305 @@
+import type { BlockhashWithExpiryBlockHeight, Cluster, Keypair, Transaction, TransactionConfirmationStatus, TransactionError, VersionedTransaction, SendOptions as SolanaWebJsSendOptions } from '@solana/web3.js';
+import type { WebhookType, TokenStandard, TransactionType, Source, ProgramName, TransactionContext, TxnStatus, AccountWebhookEncoding, PriorityLevel, UiTransactionEncoding } from './enums';
+export type HeliusCluster = Omit<Cluster, 'testnet'>;
+export type SmartTransactionContext = {
+    transaction: Transaction | VersionedTransaction;
+    blockhash: BlockhashWithExpiryBlockHeight;
+    minContextSlot: number;
+};
+export interface HeliusEndpoints {
+    api: string;
+    rpc: string;
+}
+export type HeliusOptions = {
+    limit?: number;
+    paginationToken?: string;
+};
+export interface Webhook {
+    webhookID: string;
+    wallet: string;
+    project: string;
+    webhookURL: string;
+    transactionTypes: TransactionType[];
+    accountAddresses: string[];
+    accountAddressOwners?: string[];
+    webhookType?: WebhookType;
+    authHeader?: string;
+    txnStatus?: TxnStatus;
+    encoding?: AccountWebhookEncoding;
+}
+export type CollectionIdentifier = {
+    firstVerifiedCreators?: string[];
+    verifiedCollectionAddresses?: string[];
+};
+export type CreateWebhookRequest = Omit<Webhook, 'webhookID' | 'wallet' | 'project'>;
+export type EditWebhookRequest = Partial<Omit<Webhook, 'webhookID' | 'wallet' | 'project'>>;
+export interface CreateCollectionWebhookRequest extends CreateWebhookRequest {
+    collectionQuery: CollectionIdentifier;
+}
+export interface MintlistResponse {
+    result: MintlistItem[];
+    paginationToken: string;
+}
+export type MintlistRequest = {
+    query: CollectionIdentifier;
+    options?: HeliusOptions;
+};
+export interface MintlistItem {
+    mint: string;
+    name: string;
+}
+export interface RawTokenAmount {
+    tokenAmount: string;
+    decimals: number;
+}
+export interface TokenBalanceChange {
+    userAccount: string;
+    tokenAccount: string;
+    rawTokenAmount: RawTokenAmount;
+    mint: string;
+}
+export interface AccountData {
+    account: string;
+    nativeBalanceChange: number;
+    tokenBalanceChanges: TokenBalanceChange[] | null;
+}
+export interface TokenTransfer {
+    fromUserAccount: string | null;
+    toUserAccount: string | null;
+    fromTokenAccount: string | null;
+    toTokenAccount: string | null;
+    tokenAmount: number;
+    decimals: number;
+    tokenStandard: TokenStandard;
+    mint: string;
+}
+export interface NativeBalanceChange {
+    account: string;
+    amount: number;
+}
+export interface NativeTransfer {
+    fromUserAccount: string | null;
+    toUserAccount: string | null;
+    amount: number;
+}
+export type Instruction = {
+    accounts: string[];
+    data: string;
+    programId: string;
+    innerInstructions: InnerInstruction[];
+};
+export type InnerInstruction = {
+    accounts: string[];
+    data: string;
+    programId: string;
+};
+export interface ProgramInfo {
+    source: Source;
+    account: string;
+    programName: ProgramName;
+    instructionName: string;
+}
+export interface TokenSwap {
+    nativeInput: NativeTransfer | null;
+    nativeOutput: NativeTransfer | null;
+    tokenInputs: TokenTransfer[];
+    tokenOutputs: TokenTransfer[];
+    tokenFees: TokenTransfer[];
+    nativeFees: NativeTransfer[];
+    programInfo: ProgramInfo;
+}
+export interface SwapEvent {
+    nativeInput: NativeBalanceChange;
+    nativeOutput: NativeBalanceChange;
+    tokenInputs: TokenBalanceChange[];
+    tokenOutputs: TokenBalanceChange[];
+    tokenFees: TokenBalanceChange[];
+    nativeFees: NativeBalanceChange[];
+    innerSwaps: TokenSwap[];
+}
+export interface CompressedNftCreator {
+    address: string;
+    share: number;
+    verified: boolean;
+}
+export interface CompressedNftMetadata {
+    collection: {
+        key: string;
+        verified: boolean;
+    };
+    creators: CompressedNftCreator[];
+    isMutable: boolean;
+    name: string;
+    primarySaleHappened: boolean;
+    sellerFeeBasisPoints: number;
+    symbol: string;
+    tokenProgramVersion: string;
+    tokenStandard: TokenStandard;
+    uri: string;
+}
+export interface CompressedNftEvent {
+    type: TransactionType;
+    treeId: string;
+    leafIndex: number | null;
+    seq: number | null;
+    assetId: string | null;
+    instructionIndex: number | null;
+    innerInstructionIndex: number | null;
+    newLeafOwner: string | null;
+    oldLeafOwner: string | null;
+    newLeafDelegate: string | null;
+    oldLeafDelegate: string | null;
+    treeDelegate: string | null;
+    metadata: CompressedNftMetadata | null;
+}
+export interface Token {
+    mint: string;
+    tokenStandard: TokenStandard;
+}
+export interface NFTEvent {
+    seller: string;
+    buyer: string;
+    timestamp: number;
+    amount: number;
+    fee: number;
+    signature: string;
+    source: Source;
+    type: TransactionType;
+    saleType?: TransactionContext;
+    nfts: Token[];
+}
+export interface TransactionEvent {
+    nft: NFTEvent | null;
+    swap: SwapEvent | null;
+    compressed: CompressedNftEvent[] | null;
+}
+export interface EnrichedTransaction {
+    description: string;
+    type: TransactionType;
+    source: Source;
+    fee: number;
+    feePayer: string;
+    signature: string;
+    slot: number;
+    timestamp: number;
+    nativeTransfers: NativeTransfer[] | null;
+    tokenTransfers: TokenTransfer[] | null;
+    accountData: AccountData[];
+    transactionError: TransactionError | null;
+    instructions: Instruction[];
+    events: TransactionEvent;
+}
+export interface MintApiRequest {
+    name: string;
+    symbol: string;
+    description?: string;
+    owner: string;
+    delegate?: string;
+    collection?: string;
+    creators?: {
+        address: string;
+        share: number;
+    }[];
+    uri?: string;
+    sellerFeeBasisPoints?: number;
+    imageUrl?: string;
+    externalUrl?: string;
+    attributes?: {
+        trait_type: string;
+        value: string;
+    }[];
+    imagePath?: string;
+    walletPrivateKey?: string;
+}
+export interface MintApiResponse {
+    jsonrpc: string;
+    id: string;
+    result: {
+        signature: string;
+        minted: boolean;
+        assetId: string;
+    };
+}
+export interface DelegateCollectionAuthorityRequest {
+    collectionMint: string;
+    newCollectionAuthority?: string;
+    updateAuthorityKeypair: Keypair;
+    payerKeypair?: Keypair;
+}
+export interface RevokeCollectionAuthorityRequest {
+    collectionMint: string;
+    delegatedCollectionAuthority?: string;
+    revokeAuthorityKeypair: Keypair;
+    payerKeypair?: Keypair;
+}
+interface AssetControllerAccount {
+    address: string;
+    mint: string;
+    authority: string;
+    delegate: string;
+    version: number;
+    closed: boolean;
+}
+interface DataRegistryAccount {
+    address: string;
+    mint: string;
+    version: number;
+    closed: boolean;
+}
+interface IdentityRegistryAccount {
+    address: string;
+    mint: string;
+    authority: string;
+    delegate: string;
+    version: number;
+    closed: boolean;
+}
+interface PolicyEngine {
+    address: string;
+    mint: string;
+    authority: string;
+    delegate: string;
+    policies: string[];
+    version: number;
+    closed: boolean;
+}
+export interface FullRwaAccount {
+    asset_controller?: AssetControllerAccount;
+    data_registry?: DataRegistryAccount;
+    identity_registry?: IdentityRegistryAccount;
+    policy_engine?: PolicyEngine;
+}
+export interface GetPriorityFeeEstimateOptions {
+    priorityLevel?: PriorityLevel;
+    includeAllPriorityFeeLevels?: boolean;
+    transactionEncoding?: UiTransactionEncoding;
+    lookbackSlots?: number;
+    recommended?: boolean;
+}
+export interface GetPriorityFeeEstimateRequest {
+    transaction?: string;
+    accountKeys?: string[];
+    options?: GetPriorityFeeEstimateOptions;
+}
+export interface MicroLamportPriorityFeeLevels {
+    min: number;
+    low: number;
+    medium: number;
+    high: number;
+    veryHigh: number;
+    unsafeMax: number;
+}
+export interface GetPriorityFeeEstimateResponse {
+    priorityFeeEstimate?: number;
+    priorityFeeLevels?: MicroLamportPriorityFeeLevels;
+}
+export type JitoRegion = 'Default' | 'NY' | 'Amsterdam' | 'Frankfurt' | 'Tokyo';
+export type PollTransactionOptions = {
+    confirmationStatuses?: TransactionConfirmationStatus[];
+    timeout?: number;
+    interval?: number;
+};
+export interface HeliusSendOptions extends SolanaWebJsSendOptions {
+    validatorAcls?: string[];
+}
+export {};

package/dist/helius_sdk_v1.4.0/types/types.js

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

package/dist/helius_sdk_v1.4.0/utils/get-helius-endpoints.d.ts

@@ -0,0 +1,2 @@
+import { HeliusCluster, HeliusEndpoints } from '../types';
+export declare function getHeliusEndpoints(cluster: HeliusCluster): HeliusEndpoints;

package/dist/helius_sdk_v1.4.0/utils/get-helius-endpoints.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHeliusEndpoints = void 0;
+function getHeliusEndpoints(cluster) {
+    switch (cluster) {
+        case 'devnet':
+            return {
+                api: 'https://api-devnet.helius-rpc.com',
+                rpc: 'https://devnet.helius-rpc.com',
+            };
+        case 'mainnet-beta':
+            return {
+                api: 'https://api-mainnet.helius-rpc.com',
+                rpc: 'https://mainnet.helius-rpc.com',
+            };
+        default:
+            throw new Error(`Unknown cluster ${cluster}`);
+    }
+}
+exports.getHeliusEndpoints = getHeliusEndpoints;

package/dist/helius_sdk_v1.4.0/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './get-helius-endpoints';

package/dist/helius_sdk_v1.4.0/utils/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-helius-endpoints"), exports);

package/dist/helius_sdk_v1.4.0/utils/mintApi.d.ts

@@ -0,0 +1,2 @@
+import { HeliusCluster, MintApiAuthority } from '../types';
+export declare function mintApiAuthority(cluster: HeliusCluster): MintApiAuthority;

package/dist/helius_sdk_v1.4.0/utils/mintApi.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintApiAuthority = void 0;
+const types_1 = require("../types");
+function mintApiAuthority(cluster) {
+    switch (cluster) {
+        case 'devnet':
+            return types_1.MintApiAuthority.DEVNET;
+        case 'mainnet-beta':
+            return types_1.MintApiAuthority.MAINNET;
+        default:
+            throw new Error('Invalid cluster');
+    }
+}
+exports.mintApiAuthority = mintApiAuthority;

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { StandardPoolInfoType } from '@clonegod/ttd-common';
+import { Helius, JitoRegion } from "helius-sdk";
+import { TransactionInstruction, Signer, SendOptions, TransactionSignature } from "@solana/web3.js";
 export declare const ONE_SOL_IN_LAMPORTS = 1000000000;
 export declare enum COMMITMENT_LEVEL {
     PROCESSED = "processed",
@@ -11,3 +13,15 @@ export declare enum LOCAL_EVENT_NAME {
     EVENT_POOL_ACCOUNT_CHANGE = "EVENT_POOL_ACCOUNT_CHANGE"
 }
 export declare const subscribe_pool_change_by_geyser: (geyser_ws_url: string, pool_list: StandardPoolInfoType[], eventEmitter: EventEmitter) => Promise<void>;
+export declare class HeliusClient {
+    helius_mainnet: Helius;
+    helius_staked: Helius;
+    helius_qn: Helius;
+    signers: Signer[];
+    sendOptions: SendOptions;
+    jito_tip_max: number;
+    constructor(signers: Signer[], jito_tip_max?: number);
+    send_smart_transaction(instructions: TransactionInstruction[], use_staked_endpint?: boolean): Promise<string>;
+    send_transaction_by_jito(instructions: TransactionInstruction[], tipAmount: number): Promise<TransactionSignature>;
+}
+export declare const get_jito_region: () => JitoRegion;

package/dist/index.js

@@ -12,10 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribe_pool_change_by_geyser = exports.LOCAL_EVENT_NAME = exports.COMMITMENT_LEVEL = exports.ONE_SOL_IN_LAMPORTS = void 0;
+exports.get_jito_region = exports.HeliusClient = exports.subscribe_pool_change_by_geyser = exports.LOCAL_EVENT_NAME = exports.COMMITMENT_LEVEL = exports.ONE_SOL_IN_LAMPORTS = void 0;
 const ws_1 = __importDefault(require("ws"));
 const dist_1 = require("@clonegod/ttd-common/dist");
-exports.ONE_SOL_IN_LAMPORTS = 1e9;
+const helius_sdk_1 = require("helius-sdk");
+const web3_js_1 = require("@solana/web3.js");
+exports.ONE_SOL_IN_LAMPORTS = web3_js_1.LAMPORTS_PER_SOL;
 var COMMITMENT_LEVEL;
 (function (COMMITMENT_LEVEL) {
     COMMITMENT_LEVEL["PROCESSED"] = "processed";
@@ -101,3 +103,75 @@ const subscribe_pool_change_by_geyser = (geyser_ws_url, pool_list, eventEmitter)
     });
 });
 exports.subscribe_pool_change_by_geyser = subscribe_pool_change_by_geyser;
+class HeliusClient {
+    constructor(signers, jito_tip_max = 500000) {
+        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}`;
+        let quicknode_endpoint = process.env.QUICKNODE_ENDPOINT;
+        this.helius_mainnet = new helius_sdk_1.Helius(null, null, null, helius_mainnet_endpoint);
+        this.helius_staked = new helius_sdk_1.Helius(null, null, null, helius_staked_endpoint);
+        this.helius_qn = new helius_sdk_1.Helius(null, null, null, quicknode_endpoint);
+        this.signers = signers;
+        this.sendOptions = {
+            skipPreflight: true,
+            maxRetries: 0
+        };
+        this.jito_tip_max = jito_tip_max;
+    }
+    send_smart_transaction(instructions_1) {
+        return __awaiter(this, arguments, void 0, function* (instructions, use_staked_endpint = false) {
+            (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);
+            (0, dist_1.log_info)(`send_smart_transaction, end`, {
+                txid,
+                use_staked_endpint,
+                take_time: Date.now() - start_time
+            });
+            return txid;
+        });
+    }
+    send_transaction_by_jito(instructions, tipAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (tipAmount > this.jito_tip_max) {
+                tipAmount = this.jito_tip_max;
+                (0, dist_1.log_warn)(`tipAmount too high!!! reset from ${tipAmount} to ${this.jito_tip_max}`);
+            }
+            (0, dist_1.log_info)(`send_transaction_by_jito, start`);
+            let start_time = Date.now();
+            let rpc = this.helius_qn.rpc;
+            let txid = yield rpc.sendSmartTransactionWithTip(instructions, this.signers, [], tipAmount, (0, exports.get_jito_region)());
+            (0, dist_1.log_info)(`send_transaction_by_jito, end`, {
+                txid,
+                take_time: Date.now() - start_time
+            });
+            return txid;
+        });
+    }
+}
+exports.HeliusClient = HeliusClient;
+const get_jito_region = () => {
+    let jito_region;
+    let server_info = (0, dist_1.getServerInfo)();
+    switch (server_info.region) {
+        case 'fra':
+            jito_region = 'Frankfurt';
+            break;
+        case 'virginia':
+            jito_region = 'NY';
+            break;
+        case 'jp':
+            jito_region = 'Tokyo';
+            break;
+        default:
+            jito_region = 'Default';
+    }
+    (0, dist_1.log_debug)(`get_jito_region`, {
+        server_info,
+        jito_region
+    });
+    return jito_region;
+};
+exports.get_jito_region = get_jito_region;

package/package.json

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