/* eslint-disable */
import Long from 'long';
import _m0 from 'protobufjs/minimal';
import { PageRequest, PageResponse } from '../../../cosmos/base/query/v1beta1/pagination';
import { TxResponse, GasInfo, Result } from '../../../cosmos/base/abci/v1beta1/abci';
import { Tx } from '../../../cosmos/tx/v1beta1/tx';

export const protobufPackage = 'cosmos.tx.v1beta1';

/** BroadcastMode specifies the broadcast mode for the TxService.Broadcast RPC method. */
export enum BroadcastMode {
    /** BROADCAST_MODE_UNSPECIFIED - zero-value for mode ordering */
    BROADCAST_MODE_UNSPECIFIED = 0,
    /**
     * BROADCAST_MODE_BLOCK - BROADCAST_MODE_BLOCK defines a tx broadcasting mode where the client waits for
     * the tx to be committed in a block.
     */
    BROADCAST_MODE_BLOCK = 1,
    /**
     * BROADCAST_MODE_SYNC - BROADCAST_MODE_SYNC defines a tx broadcasting mode where the client waits for
     * a CheckTx execution response only.
     */
    BROADCAST_MODE_SYNC = 2,
    /**
     * BROADCAST_MODE_ASYNC - BROADCAST_MODE_ASYNC defines a tx broadcasting mode where the client returns
     * immediately.
     */
    BROADCAST_MODE_ASYNC = 3,
    UNRECOGNIZED = -1,
}

export function broadcastModeFromJSON(object: any): BroadcastMode {
    switch (object) {
        case 0:
        case 'BROADCAST_MODE_UNSPECIFIED':
            return BroadcastMode.BROADCAST_MODE_UNSPECIFIED;
        case 1:
        case 'BROADCAST_MODE_BLOCK':
            return BroadcastMode.BROADCAST_MODE_BLOCK;
        case 2:
        case 'BROADCAST_MODE_SYNC':
            return BroadcastMode.BROADCAST_MODE_SYNC;
        case 3:
        case 'BROADCAST_MODE_ASYNC':
            return BroadcastMode.BROADCAST_MODE_ASYNC;
        case -1:
        case 'UNRECOGNIZED':
        default:
            return BroadcastMode.UNRECOGNIZED;
    }
}

export function broadcastModeToJSON(object: BroadcastMode): string {
    switch (object) {
        case BroadcastMode.BROADCAST_MODE_UNSPECIFIED:
            return 'BROADCAST_MODE_UNSPECIFIED';
        case BroadcastMode.BROADCAST_MODE_BLOCK:
            return 'BROADCAST_MODE_BLOCK';
        case BroadcastMode.BROADCAST_MODE_SYNC:
            return 'BROADCAST_MODE_SYNC';
        case BroadcastMode.BROADCAST_MODE_ASYNC:
            return 'BROADCAST_MODE_ASYNC';
        default:
            return 'UNKNOWN';
    }
}

/**
 * GetTxsEventRequest is the request type for the Service.TxsByEvents
 * RPC method.
 */
export interface GetTxsEventRequest {
    /** events is the list of transaction event type. */
    events: string[];
    /** pagination defines an pagination for the request. */
    pagination?: PageRequest;
}

/**
 * GetTxsEventResponse is the response type for the Service.TxsByEvents
 * RPC method.
 */
export interface GetTxsEventResponse {
    /** txs is the list of queried transactions. */
    txs: Tx[];
    /** tx_responses is the list of queried TxResponses. */
    txResponses: TxResponse[];
    /** pagination defines an pagination for the response. */
    pagination?: PageResponse;
}

/**
 * BroadcastTxRequest is the request type for the Service.BroadcastTxRequest
 * RPC method.
 */
export interface BroadcastTxRequest {
    /** tx_bytes is the raw transaction. */
    txBytes: Uint8Array;
    mode: BroadcastMode;
}

/**
 * BroadcastTxResponse is the response type for the
 * Service.BroadcastTx method.
 */
export interface BroadcastTxResponse {
    /** tx_response is the queried TxResponses. */
    txResponse?: TxResponse;
}

/**
 * SimulateRequest is the request type for the Service.Simulate
 * RPC method.
 */
export interface SimulateRequest {
    /** tx is the transaction to simulate. */
    tx?: Tx;
}

/**
 * SimulateResponse is the response type for the
 * Service.SimulateRPC method.
 */
export interface SimulateResponse {
    /** gas_info is the information about gas used in the simulation. */
    gasInfo?: GasInfo;
    /** result is the result of the simulation. */
    result?: Result;
}

/**
 * GetTxRequest is the request type for the Service.GetTx
 * RPC method.
 */
export interface GetTxRequest {
    /** hash is the tx hash to query, encoded as a hex string. */
    hash: string;
}

/** GetTxResponse is the response type for the Service.GetTx method. */
export interface GetTxResponse {
    /** tx is the queried transaction. */
    tx?: Tx;
    /** tx_response is the queried TxResponses. */
    txResponse?: TxResponse;
}

const baseGetTxsEventRequest: object = { events: '' };

export const GetTxsEventRequest = {
    encode(message: GetTxsEventRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        for (const v of message.events) {
            writer.uint32(10).string(v!);
        }
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): GetTxsEventRequest {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseGetTxsEventRequest } as GetTxsEventRequest;
        message.events = [];
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.events.push(reader.string());
                    break;
                case 2:
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): GetTxsEventRequest {
        const message = { ...baseGetTxsEventRequest } as GetTxsEventRequest;
        message.events = [];
        if (object.events !== undefined && object.events !== null) {
            for (const e of object.events) {
                message.events.push(String(e));
            }
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromJSON(object.pagination);
        } else {
            message.pagination = undefined;
        }
        return message;
    },

    toJSON(message: GetTxsEventRequest): unknown {
        const obj: any = {};
        if (message.events) {
            obj.events = message.events.map((e) => e);
        } else {
            obj.events = [];
        }
        message.pagination !== undefined &&
            (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<GetTxsEventRequest>): GetTxsEventRequest {
        const message = { ...baseGetTxsEventRequest } as GetTxsEventRequest;
        message.events = [];
        if (object.events !== undefined && object.events !== null) {
            for (const e of object.events) {
                message.events.push(e);
            }
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageRequest.fromPartial(object.pagination);
        } else {
            message.pagination = undefined;
        }
        return message;
    },
};

const baseGetTxsEventResponse: object = {};

export const GetTxsEventResponse = {
    encode(message: GetTxsEventResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        for (const v of message.txs) {
            Tx.encode(v!, writer.uint32(10).fork()).ldelim();
        }
        for (const v of message.txResponses) {
            TxResponse.encode(v!, writer.uint32(18).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): GetTxsEventResponse {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseGetTxsEventResponse } as GetTxsEventResponse;
        message.txs = [];
        message.txResponses = [];
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.txs.push(Tx.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.txResponses.push(TxResponse.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): GetTxsEventResponse {
        const message = { ...baseGetTxsEventResponse } as GetTxsEventResponse;
        message.txs = [];
        message.txResponses = [];
        if (object.txs !== undefined && object.txs !== null) {
            for (const e of object.txs) {
                message.txs.push(Tx.fromJSON(e));
            }
        }
        if (object.txResponses !== undefined && object.txResponses !== null) {
            for (const e of object.txResponses) {
                message.txResponses.push(TxResponse.fromJSON(e));
            }
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromJSON(object.pagination);
        } else {
            message.pagination = undefined;
        }
        return message;
    },

    toJSON(message: GetTxsEventResponse): unknown {
        const obj: any = {};
        if (message.txs) {
            obj.txs = message.txs.map((e) => (e ? Tx.toJSON(e) : undefined));
        } else {
            obj.txs = [];
        }
        if (message.txResponses) {
            obj.txResponses = message.txResponses.map((e) => (e ? TxResponse.toJSON(e) : undefined));
        } else {
            obj.txResponses = [];
        }
        message.pagination !== undefined &&
            (obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<GetTxsEventResponse>): GetTxsEventResponse {
        const message = { ...baseGetTxsEventResponse } as GetTxsEventResponse;
        message.txs = [];
        message.txResponses = [];
        if (object.txs !== undefined && object.txs !== null) {
            for (const e of object.txs) {
                message.txs.push(Tx.fromPartial(e));
            }
        }
        if (object.txResponses !== undefined && object.txResponses !== null) {
            for (const e of object.txResponses) {
                message.txResponses.push(TxResponse.fromPartial(e));
            }
        }
        if (object.pagination !== undefined && object.pagination !== null) {
            message.pagination = PageResponse.fromPartial(object.pagination);
        } else {
            message.pagination = undefined;
        }
        return message;
    },
};

const baseBroadcastTxRequest: object = { mode: 0 };

export const BroadcastTxRequest = {
    encode(message: BroadcastTxRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.txBytes.length !== 0) {
            writer.uint32(10).bytes(message.txBytes);
        }
        if (message.mode !== 0) {
            writer.uint32(16).int32(message.mode);
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): BroadcastTxRequest {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseBroadcastTxRequest } as BroadcastTxRequest;
        message.txBytes = new Uint8Array();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.txBytes = reader.bytes();
                    break;
                case 2:
                    message.mode = reader.int32() as any;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): BroadcastTxRequest {
        const message = { ...baseBroadcastTxRequest } as BroadcastTxRequest;
        message.txBytes = new Uint8Array();
        if (object.txBytes !== undefined && object.txBytes !== null) {
            message.txBytes = bytesFromBase64(object.txBytes);
        }
        if (object.mode !== undefined && object.mode !== null) {
            message.mode = broadcastModeFromJSON(object.mode);
        } else {
            message.mode = 0;
        }
        return message;
    },

    toJSON(message: BroadcastTxRequest): unknown {
        const obj: any = {};
        message.txBytes !== undefined &&
            (obj.txBytes = base64FromBytes(message.txBytes !== undefined ? message.txBytes : new Uint8Array()));
        message.mode !== undefined && (obj.mode = broadcastModeToJSON(message.mode));
        return obj;
    },

    fromPartial(object: DeepPartial<BroadcastTxRequest>): BroadcastTxRequest {
        const message = { ...baseBroadcastTxRequest } as BroadcastTxRequest;
        if (object.txBytes !== undefined && object.txBytes !== null) {
            message.txBytes = object.txBytes;
        } else {
            message.txBytes = new Uint8Array();
        }
        if (object.mode !== undefined && object.mode !== null) {
            message.mode = object.mode;
        } else {
            message.mode = 0;
        }
        return message;
    },
};

const baseBroadcastTxResponse: object = {};

export const BroadcastTxResponse = {
    encode(message: BroadcastTxResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.txResponse !== undefined) {
            TxResponse.encode(message.txResponse, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): BroadcastTxResponse {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseBroadcastTxResponse } as BroadcastTxResponse;
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.txResponse = TxResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): BroadcastTxResponse {
        const message = { ...baseBroadcastTxResponse } as BroadcastTxResponse;
        if (object.txResponse !== undefined && object.txResponse !== null) {
            message.txResponse = TxResponse.fromJSON(object.txResponse);
        } else {
            message.txResponse = undefined;
        }
        return message;
    },

    toJSON(message: BroadcastTxResponse): unknown {
        const obj: any = {};
        message.txResponse !== undefined &&
            (obj.txResponse = message.txResponse ? TxResponse.toJSON(message.txResponse) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<BroadcastTxResponse>): BroadcastTxResponse {
        const message = { ...baseBroadcastTxResponse } as BroadcastTxResponse;
        if (object.txResponse !== undefined && object.txResponse !== null) {
            message.txResponse = TxResponse.fromPartial(object.txResponse);
        } else {
            message.txResponse = undefined;
        }
        return message;
    },
};

const baseSimulateRequest: object = {};

export const SimulateRequest = {
    encode(message: SimulateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.tx !== undefined) {
            Tx.encode(message.tx, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): SimulateRequest {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseSimulateRequest } as SimulateRequest;
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tx = Tx.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): SimulateRequest {
        const message = { ...baseSimulateRequest } as SimulateRequest;
        if (object.tx !== undefined && object.tx !== null) {
            message.tx = Tx.fromJSON(object.tx);
        } else {
            message.tx = undefined;
        }
        return message;
    },

    toJSON(message: SimulateRequest): unknown {
        const obj: any = {};
        message.tx !== undefined && (obj.tx = message.tx ? Tx.toJSON(message.tx) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<SimulateRequest>): SimulateRequest {
        const message = { ...baseSimulateRequest } as SimulateRequest;
        if (object.tx !== undefined && object.tx !== null) {
            message.tx = Tx.fromPartial(object.tx);
        } else {
            message.tx = undefined;
        }
        return message;
    },
};

const baseSimulateResponse: object = {};

export const SimulateResponse = {
    encode(message: SimulateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.gasInfo !== undefined) {
            GasInfo.encode(message.gasInfo, writer.uint32(10).fork()).ldelim();
        }
        if (message.result !== undefined) {
            Result.encode(message.result, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): SimulateResponse {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseSimulateResponse } as SimulateResponse;
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.gasInfo = GasInfo.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.result = Result.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): SimulateResponse {
        const message = { ...baseSimulateResponse } as SimulateResponse;
        if (object.gasInfo !== undefined && object.gasInfo !== null) {
            message.gasInfo = GasInfo.fromJSON(object.gasInfo);
        } else {
            message.gasInfo = undefined;
        }
        if (object.result !== undefined && object.result !== null) {
            message.result = Result.fromJSON(object.result);
        } else {
            message.result = undefined;
        }
        return message;
    },

    toJSON(message: SimulateResponse): unknown {
        const obj: any = {};
        message.gasInfo !== undefined && (obj.gasInfo = message.gasInfo ? GasInfo.toJSON(message.gasInfo) : undefined);
        message.result !== undefined && (obj.result = message.result ? Result.toJSON(message.result) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<SimulateResponse>): SimulateResponse {
        const message = { ...baseSimulateResponse } as SimulateResponse;
        if (object.gasInfo !== undefined && object.gasInfo !== null) {
            message.gasInfo = GasInfo.fromPartial(object.gasInfo);
        } else {
            message.gasInfo = undefined;
        }
        if (object.result !== undefined && object.result !== null) {
            message.result = Result.fromPartial(object.result);
        } else {
            message.result = undefined;
        }
        return message;
    },
};

const baseGetTxRequest: object = { hash: '' };

export const GetTxRequest = {
    encode(message: GetTxRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.hash !== '') {
            writer.uint32(10).string(message.hash);
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): GetTxRequest {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseGetTxRequest } as GetTxRequest;
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.hash = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): GetTxRequest {
        const message = { ...baseGetTxRequest } as GetTxRequest;
        if (object.hash !== undefined && object.hash !== null) {
            message.hash = String(object.hash);
        } else {
            message.hash = '';
        }
        return message;
    },

    toJSON(message: GetTxRequest): unknown {
        const obj: any = {};
        message.hash !== undefined && (obj.hash = message.hash);
        return obj;
    },

    fromPartial(object: DeepPartial<GetTxRequest>): GetTxRequest {
        const message = { ...baseGetTxRequest } as GetTxRequest;
        if (object.hash !== undefined && object.hash !== null) {
            message.hash = object.hash;
        } else {
            message.hash = '';
        }
        return message;
    },
};

const baseGetTxResponse: object = {};

export const GetTxResponse = {
    encode(message: GetTxResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.tx !== undefined) {
            Tx.encode(message.tx, writer.uint32(10).fork()).ldelim();
        }
        if (message.txResponse !== undefined) {
            TxResponse.encode(message.txResponse, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): GetTxResponse {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseGetTxResponse } as GetTxResponse;
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.tx = Tx.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.txResponse = TxResponse.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): GetTxResponse {
        const message = { ...baseGetTxResponse } as GetTxResponse;
        if (object.tx !== undefined && object.tx !== null) {
            message.tx = Tx.fromJSON(object.tx);
        } else {
            message.tx = undefined;
        }
        if (object.txResponse !== undefined && object.txResponse !== null) {
            message.txResponse = TxResponse.fromJSON(object.txResponse);
        } else {
            message.txResponse = undefined;
        }
        return message;
    },

    toJSON(message: GetTxResponse): unknown {
        const obj: any = {};
        message.tx !== undefined && (obj.tx = message.tx ? Tx.toJSON(message.tx) : undefined);
        message.txResponse !== undefined &&
            (obj.txResponse = message.txResponse ? TxResponse.toJSON(message.txResponse) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<GetTxResponse>): GetTxResponse {
        const message = { ...baseGetTxResponse } as GetTxResponse;
        if (object.tx !== undefined && object.tx !== null) {
            message.tx = Tx.fromPartial(object.tx);
        } else {
            message.tx = undefined;
        }
        if (object.txResponse !== undefined && object.txResponse !== null) {
            message.txResponse = TxResponse.fromPartial(object.txResponse);
        } else {
            message.txResponse = undefined;
        }
        return message;
    },
};

/** Service defines a gRPC service for interacting with transactions. */
export interface Service {
    /** Simulate simulates executing a transaction for estimating gas usage. */
    Simulate(request: SimulateRequest): Promise<SimulateResponse>;
    /** GetTx fetches a tx by hash. */
    GetTx(request: GetTxRequest): Promise<GetTxResponse>;
    /** BroadcastTx broadcast transaction. */
    BroadcastTx(request: BroadcastTxRequest): Promise<BroadcastTxResponse>;
    /** GetTxsEvent fetches txs by event. */
    GetTxsEvent(request: GetTxsEventRequest): Promise<GetTxsEventResponse>;
}

export class ServiceClientImpl implements Service {
    private readonly rpc: Rpc;
    constructor(rpc: Rpc) {
        this.rpc = rpc;
        this.Simulate = this.Simulate.bind(this);
        this.GetTx = this.GetTx.bind(this);
        this.BroadcastTx = this.BroadcastTx.bind(this);
        this.GetTxsEvent = this.GetTxsEvent.bind(this);
    }
    Simulate(request: SimulateRequest): Promise<SimulateResponse> {
        const data = SimulateRequest.encode(request).finish();
        const promise = this.rpc.request('cosmos.tx.v1beta1.Service', 'Simulate', data);
        return promise.then((data) => SimulateResponse.decode(new _m0.Reader(data)));
    }

    GetTx(request: GetTxRequest): Promise<GetTxResponse> {
        const data = GetTxRequest.encode(request).finish();
        const promise = this.rpc.request('cosmos.tx.v1beta1.Service', 'GetTx', data);
        return promise.then((data) => GetTxResponse.decode(new _m0.Reader(data)));
    }

    BroadcastTx(request: BroadcastTxRequest): Promise<BroadcastTxResponse> {
        const data = BroadcastTxRequest.encode(request).finish();
        const promise = this.rpc.request('cosmos.tx.v1beta1.Service', 'BroadcastTx', data);
        return promise.then((data) => BroadcastTxResponse.decode(new _m0.Reader(data)));
    }

    GetTxsEvent(request: GetTxsEventRequest): Promise<GetTxsEventResponse> {
        const data = GetTxsEventRequest.encode(request).finish();
        const promise = this.rpc.request('cosmos.tx.v1beta1.Service', 'GetTxsEvent', data);
        return promise.then((data) => GetTxsEventResponse.decode(new _m0.Reader(data)));
    }
}

interface Rpc {
    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}

declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
    if (typeof globalThis !== 'undefined') return globalThis;
    if (typeof self !== 'undefined') return self;
    if (typeof window !== 'undefined') return window;
    if (typeof global !== 'undefined') return global;
    throw 'Unable to locate global object';
})();

const atob: (b64: string) => string =
    globalThis.atob || ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));
function bytesFromBase64(b64: string): Uint8Array {
    const bin = atob(b64);
    const arr = new Uint8Array(bin.length);
    for (let i = 0; i < bin.length; ++i) {
        arr[i] = bin.charCodeAt(i);
    }
    return arr;
}

const btoa: (bin: string) => string =
    globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
function base64FromBytes(arr: Uint8Array): string {
    const bin: string[] = [];
    for (let i = 0; i < arr.byteLength; ++i) {
        bin.push(String.fromCharCode(arr[i]));
    }
    return btoa(bin.join(''));
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined | Long;
export type DeepPartial<T> = T extends Builtin
    ? T
    : T extends Array<infer U>
    ? Array<DeepPartial<U>>
    : T extends ReadonlyArray<infer U>
    ? ReadonlyArray<DeepPartial<U>>
    : T extends {}
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : Partial<T>;

if (_m0.util.Long !== Long) {
    _m0.util.Long = Long as any;
    _m0.configure();
}