@solsdk/jito-ts

import { CallOptions, ChannelCredentials, Client, ClientDuplexStream, ClientOptions, ClientReadableStream, ClientUnaryCall, handleBidiStreamingCall, handleServerStreamingCall, handleUnaryCall, Metadata, ServiceError, UntypedServiceImplementation } from "@grpc/grpc-js"; import _m0 from "protobufjs/minimal"; import { BundleUuid } from "./bundle"; import { PacketBatch } from "./packet"; import { Header, Heartbeat } from "./shared"; export declare const protobufPackage = "block_engine"; export interface SubscribePacketsRequest { } export interface SubscribePacketsResponse { header: Header | undefined; batch: PacketBatch | undefined; } export interface SubscribeBundlesRequest { } export interface SubscribeBundlesResponse { bundles: BundleUuid[]; } export interface BlockBuilderFeeInfoRequest { } export interface BlockBuilderFeeInfoResponse { pubkey: string; /** commission (0-100) */ commission: number; } export interface AccountsOfInterest { /** use * for all accounts */ accounts: string[]; } export interface AccountsOfInterestRequest { } export interface AccountsOfInterestUpdate { accounts: string[]; } export interface ProgramsOfInterestRequest { } export interface ProgramsOfInterestUpdate { programs: string[]; } /** * A series of packets with an expiration attached to them. * The header contains a timestamp for when this packet was generated. * The expiry is how long the packet batches have before they expire and are forwarded to the validator. * This provides a more censorship resistant method to MEV than block engines receiving packets directly. */ export interface ExpiringPacketBatch { header: Header | undefined; batch: PacketBatch | undefined; expiryMs: number; } /** * Packets and heartbeats are sent over the same stream. * ExpiringPacketBatches have an expiration attached to them so the block engine can track * how long it has until the relayer forwards the packets to the validator. * Heartbeats contain a timestamp from the system and is used as a simple and naive time-sync mechanism * so the block engine has some idea on how far their clocks are apart. */ export interface PacketBatchUpdate { batches?: ExpiringPacketBatch | undefined; heartbeat?: Heartbeat | undefined; } export interface StartExpiringPacketStreamResponse { heartbeat: Heartbeat | undefined; } export declare const SubscribePacketsRequest: { encode(_: SubscribePacketsRequest, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): SubscribePacketsRequest; fromJSON(_: any): SubscribePacketsRequest; toJSON(_: SubscribePacketsRequest): unknown; create, I>>(base?: I): SubscribePacketsRequest; fromPartial, I>>(_: I): SubscribePacketsRequest; }; export declare const SubscribePacketsResponse: { encode(message: SubscribePacketsResponse, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): SubscribePacketsResponse; fromJSON(object: any): SubscribePacketsResponse; toJSON(message: SubscribePacketsResponse): unknown; create, I>>(base?: I): SubscribePacketsResponse; fromPartial, I>>(object: I): SubscribePacketsResponse; }; export declare const SubscribeBundlesRequest: { encode(_: SubscribeBundlesRequest, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeBundlesRequest; fromJSON(_: any): SubscribeBundlesRequest; toJSON(_: SubscribeBundlesRequest): unknown; create, I>>(base?: I): SubscribeBundlesRequest; fromPartial, I>>(_: I): SubscribeBundlesRequest; }; export declare const SubscribeBundlesResponse: { encode(message: SubscribeBundlesResponse, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeBundlesResponse; fromJSON(object: any): SubscribeBundlesResponse; toJSON(message: SubscribeBundlesResponse): unknown; create, I>>(base?: I): SubscribeBundlesResponse; fromPartial, I>>(object: I): SubscribeBundlesResponse; }; export declare const BlockBuilderFeeInfoRequest: { encode(_: BlockBuilderFeeInfoRequest, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): BlockBuilderFeeInfoRequest; fromJSON(_: any): BlockBuilderFeeInfoRequest; toJSON(_: BlockBuilderFeeInfoRequest): unknown; create, I>>(base?: I): BlockBuilderFeeInfoRequest; fromPartial, I>>(_: I): BlockBuilderFeeInfoRequest; }; export declare const BlockBuilderFeeInfoResponse: { encode(message: BlockBuilderFeeInfoResponse, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): BlockBuilderFeeInfoResponse; fromJSON(object: any): BlockBuilderFeeInfoResponse; toJSON(message: BlockBuilderFeeInfoResponse): unknown; create, I>>(base?: I): BlockBuilderFeeInfoResponse; fromPartial, I>>(object: I): BlockBuilderFeeInfoResponse; }; export declare const AccountsOfInterest: { encode(message: AccountsOfInterest, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): AccountsOfInterest; fromJSON(object: any): AccountsOfInterest; toJSON(message: AccountsOfInterest): unknown; create, I>>(base?: I): AccountsOfInterest; fromPartial, I>>(object: I): AccountsOfInterest; }; export declare const AccountsOfInterestRequest: { encode(_: AccountsOfInterestRequest, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): AccountsOfInterestRequest; fromJSON(_: any): AccountsOfInterestRequest; toJSON(_: AccountsOfInterestRequest): unknown; create, I>>(base?: I): AccountsOfInterestRequest; fromPartial, I>>(_: I): AccountsOfInterestRequest; }; export declare const AccountsOfInterestUpdate: { encode(message: AccountsOfInterestUpdate, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): AccountsOfInterestUpdate; fromJSON(object: any): AccountsOfInterestUpdate; toJSON(message: AccountsOfInterestUpdate): unknown; create, I>>(base?: I): AccountsOfInterestUpdate; fromPartial, I>>(object: I): AccountsOfInterestUpdate; }; export declare const ProgramsOfInterestRequest: { encode(_: ProgramsOfInterestRequest, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): ProgramsOfInterestRequest; fromJSON(_: any): ProgramsOfInterestRequest; toJSON(_: ProgramsOfInterestRequest): unknown; create, I>>(base?: I): ProgramsOfInterestRequest; fromPartial, I>>(_: I): ProgramsOfInterestRequest; }; export declare const ProgramsOfInterestUpdate: { encode(message: ProgramsOfInterestUpdate, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): ProgramsOfInterestUpdate; fromJSON(object: any): ProgramsOfInterestUpdate; toJSON(message: ProgramsOfInterestUpdate): unknown; create, I>>(base?: I): ProgramsOfInterestUpdate; fromPartial, I>>(object: I): ProgramsOfInterestUpdate; }; export declare const ExpiringPacketBatch: { encode(message: ExpiringPacketBatch, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): ExpiringPacketBatch; fromJSON(object: any): ExpiringPacketBatch; toJSON(message: ExpiringPacketBatch): unknown; create, I>>(base?: I): ExpiringPacketBatch; fromPartial, I>>(object: I): ExpiringPacketBatch; }; export declare const PacketBatchUpdate: { encode(message: PacketBatchUpdate, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): PacketBatchUpdate; fromJSON(object: any): PacketBatchUpdate; toJSON(message: PacketBatchUpdate): unknown; create, I>>(base?: I): PacketBatchUpdate; fromPartial, I>>(object: I): PacketBatchUpdate; }; export declare const StartExpiringPacketStreamResponse: { encode(message: StartExpiringPacketStreamResponse, writer?: _m0.Writer): _m0.Writer; decode(input: _m0.Reader | Uint8Array, length?: number): StartExpiringPacketStreamResponse; fromJSON(object: any): StartExpiringPacketStreamResponse; toJSON(message: StartExpiringPacketStreamResponse): unknown; create, I>>(base?: I): StartExpiringPacketStreamResponse; fromPartial, I>>(object: I): StartExpiringPacketStreamResponse; }; /** / Validators can connect to Block Engines to receive packets and bundles. */ export type BlockEngineValidatorService = typeof BlockEngineValidatorService; export declare const BlockEngineValidatorService: { /** / Validators can subscribe to the block engine to receive a stream of packets */ readonly subscribePackets: { readonly path: "/block_engine.BlockEngineValidator/SubscribePackets"; readonly requestStream: false; readonly responseStream: true; readonly requestSerialize: (value: SubscribePacketsRequest) => Buffer; readonly requestDeserialize: (value: Buffer) => SubscribePacketsRequest; readonly responseSerialize: (value: SubscribePacketsResponse) => Buffer; readonly responseDeserialize: (value: Buffer) => SubscribePacketsResponse; }; /** / Validators can subscribe to the block engine to receive a stream of simulated and profitable bundles */ readonly subscribeBundles: { readonly path: "/block_engine.BlockEngineValidator/SubscribeBundles"; readonly requestStream: false; readonly responseStream: true; readonly requestSerialize: (value: SubscribeBundlesRequest) => Buffer; readonly requestDeserialize: (value: Buffer) => SubscribeBundlesRequest; readonly responseSerialize: (value: SubscribeBundlesResponse) => Buffer; readonly responseDeserialize: (value: Buffer) => SubscribeBundlesResponse; }; /** * Block builders can optionally collect fees. This returns fee information if a block builder wants to * collect one. */ readonly getBlockBuilderFeeInfo: { readonly path: "/block_engine.BlockEngineValidator/GetBlockBuilderFeeInfo"; readonly requestStream: false; readonly responseStream: false; readonly requestSerialize: (value: BlockBuilderFeeInfoRequest) => Buffer; readonly requestDeserialize: (value: Buffer) => BlockBuilderFeeInfoRequest; readonly responseSerialize: (value: BlockBuilderFeeInfoResponse) => Buffer; readonly responseDeserialize: (value: Buffer) => BlockBuilderFeeInfoResponse; }; }; export interface BlockEngineValidatorServer extends UntypedServiceImplementation { /** / Validators can subscribe to the block engine to receive a stream of packets */ subscribePackets: handleServerStreamingCall<SubscribePacketsRequest, SubscribePacketsResponse>; /** / Validators can subscribe to the block engine to receive a stream of simulated and profitable bundles */ subscribeBundles: handleServerStreamingCall<SubscribeBundlesRequest, SubscribeBundlesResponse>; /** * Block builders can optionally collect fees. This returns fee information if a block builder wants to * collect one. */ getBlockBuilderFeeInfo: handleUnaryCall<BlockBuilderFeeInfoRequest, BlockBuilderFeeInfoResponse>; } export interface BlockEngineValidatorClient extends Client { /** / Validators can subscribe to the block engine to receive a stream of packets */ subscribePackets(request: SubscribePacketsRequest, options?: Partial<CallOptions>): ClientReadableStream<SubscribePacketsResponse>; subscribePackets(request: SubscribePacketsRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<SubscribePacketsResponse>; /** / Validators can subscribe to the block engine to receive a stream of simulated and profitable bundles */ subscribeBundles(request: SubscribeBundlesRequest, options?: Partial<CallOptions>): ClientReadableStream<SubscribeBundlesResponse>; subscribeBundles(request: SubscribeBundlesRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<SubscribeBundlesResponse>; /** * Block builders can optionally collect fees. This returns fee information if a block builder wants to * collect one. */ getBlockBuilderFeeInfo(request: BlockBuilderFeeInfoRequest, callback: (error: ServiceError | null, response: BlockBuilderFeeInfoResponse) => void): ClientUnaryCall; getBlockBuilderFeeInfo(request: BlockBuilderFeeInfoRequest, metadata: Metadata, callback: (error: ServiceError | null, response: BlockBuilderFeeInfoResponse) => void): ClientUnaryCall; getBlockBuilderFeeInfo(request: BlockBuilderFeeInfoRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: BlockBuilderFeeInfoResponse) => void): ClientUnaryCall; } export declare const BlockEngineValidatorClient: { new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): BlockEngineValidatorClient; service: typeof BlockEngineValidatorService; }; /** * / Relayers can forward packets to Block Engines. * / Block Engines provide an AccountsOfInterest field to only send transactions that are of interest. */ export type BlockEngineRelayerService = typeof BlockEngineRelayerService; export declare const BlockEngineRelayerService: { /** * / The block engine feeds accounts of interest (AOI) updates to the relayer periodically. * / For all transactions the relayer receives, it forwards transactions to the block engine which write-lock * / any of the accounts in the AOI. */ readonly subscribeAccountsOfInterest: { readonly path: "/block_engine.BlockEngineRelayer/SubscribeAccountsOfInterest"; readonly requestStream: false; readonly responseStream: true; readonly requestSerialize: (value: AccountsOfInterestRequest) => Buffer; readonly requestDeserialize: (value: Buffer) => AccountsOfInterestRequest; readonly responseSerialize: (value: AccountsOfInterestUpdate) => Buffer; readonly responseDeserialize: (value: Buffer) => AccountsOfInterestUpdate; }; readonly subscribeProgramsOfInterest: { readonly path: "/block_engine.BlockEngineRelayer/SubscribeProgramsOfInterest"; readonly requestStream: false; readonly responseStream: true; readonly requestSerialize: (value: ProgramsOfInterestRequest) => Buffer; readonly requestDeserialize: (value: Buffer) => ProgramsOfInterestRequest; readonly responseSerialize: (value: ProgramsOfInterestUpdate) => Buffer; readonly responseDeserialize: (value: Buffer) => ProgramsOfInterestUpdate; }; /** * Validators can subscribe to packets from the relayer and receive a multiplexed signal that contains a mixture * of packets and heartbeats. * NOTE: This is a bi-directional stream due to a bug with how Envoy handles half closed client-side streams. * The issue is being tracked here: https://github.com/envoyproxy/envoy/issues/22748. In the meantime, the * server will stream heartbeats to clients at some reasonable cadence. */ readonly startExpiringPacketStream: { readonly path: "/block_engine.BlockEngineRelayer/StartExpiringPacketStream"; readonly requestStream: true; readonly responseStream: true; readonly requestSerialize: (value: PacketBatchUpdate) => Buffer; readonly requestDeserialize: (value: Buffer) => PacketBatchUpdate; readonly responseSerialize: (value: StartExpiringPacketStreamResponse) => Buffer; readonly responseDeserialize: (value: Buffer) => StartExpiringPacketStreamResponse; }; }; export interface BlockEngineRelayerServer extends UntypedServiceImplementation { /** * / The block engine feeds accounts of interest (AOI) updates to the relayer periodically. * / For all transactions the relayer receives, it forwards transactions to the block engine which write-lock * / any of the accounts in the AOI. */ subscribeAccountsOfInterest: handleServerStreamingCall<AccountsOfInterestRequest, AccountsOfInterestUpdate>; subscribeProgramsOfInterest: handleServerStreamingCall<ProgramsOfInterestRequest, ProgramsOfInterestUpdate>; /** * Validators can subscribe to packets from the relayer and receive a multiplexed signal that contains a mixture * of packets and heartbeats. * NOTE: This is a bi-directional stream due to a bug with how Envoy handles half closed client-side streams. * The issue is being tracked here: https://github.com/envoyproxy/envoy/issues/22748. In the meantime, the * server will stream heartbeats to clients at some reasonable cadence. */ startExpiringPacketStream: handleBidiStreamingCall<PacketBatchUpdate, StartExpiringPacketStreamResponse>; } export interface BlockEngineRelayerClient extends Client { /** * / The block engine feeds accounts of interest (AOI) updates to the relayer periodically. * / For all transactions the relayer receives, it forwards transactions to the block engine which write-lock * / any of the accounts in the AOI. */ subscribeAccountsOfInterest(request: AccountsOfInterestRequest, options?: Partial<CallOptions>): ClientReadableStream<AccountsOfInterestUpdate>; subscribeAccountsOfInterest(request: AccountsOfInterestRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<AccountsOfInterestUpdate>; subscribeProgramsOfInterest(request: ProgramsOfInterestRequest, options?: Partial<CallOptions>): ClientReadableStream<ProgramsOfInterestUpdate>; subscribeProgramsOfInterest(request: ProgramsOfInterestRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<ProgramsOfInterestUpdate>; /** * Validators can subscribe to packets from the relayer and receive a multiplexed signal that contains a mixture * of packets and heartbeats. * NOTE: This is a bi-directional stream due to a bug with how Envoy handles half closed client-side streams. * The issue is being tracked here: https://github.com/envoyproxy/envoy/issues/22748. In the meantime, the * server will stream heartbeats to clients at some reasonable cadence. */ startExpiringPacketStream(): ClientDuplexStream<PacketBatchUpdate, StartExpiringPacketStreamResponse>; startExpiringPacketStream(options: Partial<CallOptions>): ClientDuplexStream<PacketBatchUpdate, StartExpiringPacketStreamResponse>; startExpiringPacketStream(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<PacketBatchUpdate, StartExpiringPacketStreamResponse>; } export declare const BlockEngineRelayerClient: { new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): BlockEngineRelayerClient; service: typeof BlockEngineRelayerService; }; type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial> : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]>; } : Partial<T>; type KeysOfUnion<T> = T extends T ? keyof T : never; export type Exact<P, I extends P> = P extends Builtin ? P : P & { [K in keyof P]: Exact<P[K], I[K]>; } & { [K in Exclude<keyof I, KeysOfUnion>]: never; }; export {};