@caict/bop-typescript-sdk/src/bop-sdk/proto/bop-sdk-interface.ts

Xinghuo bop sdk

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.6.0
//   protoc               v3.20.3
// source: bop-sdk-interface.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import {
  SdkStatusCode,
  sdkStatusCodeFromJSON,
  sdkStatusCodeToJSON,
} from "./bop-sdk-common";

export const protobufPackage = "bopsdkinterface";

export enum ContractType {
  JAVASCRIPT = 0,
  EVM = 1,
  SYSTEM = 2,
  UNRECOGNIZED = -1,
}

export function contractTypeFromJSON(object: any): ContractType {
  switch (object) {
    case 0:
    case "JAVASCRIPT":
      return ContractType.JAVASCRIPT;
    case 1:
    case "EVM":
      return ContractType.EVM;
    case 2:
    case "SYSTEM":
      return ContractType.SYSTEM;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ContractType.UNRECOGNIZED;
  }
}

export function contractTypeToJSON(object: ContractType): string {
  switch (object) {
    case ContractType.JAVASCRIPT:
      return "JAVASCRIPT";
    case ContractType.EVM:
      return "EVM";
    case ContractType.SYSTEM:
      return "SYSTEM";
    case ContractType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum TxType {
  INCREASE_NONCE = 0,
  RANDOM_NONCE = 1,
  UNRECOGNIZED = -1,
}

export function txTypeFromJSON(object: any): TxType {
  switch (object) {
    case 0:
    case "INCREASE_NONCE":
      return TxType.INCREASE_NONCE;
    case 1:
    case "RANDOM_NONCE":
      return TxType.RANDOM_NONCE;
    case -1:
    case "UNRECOGNIZED":
    default:
      return TxType.UNRECOGNIZED;
  }
}

export function txTypeToJSON(object: TxType): string {
  switch (object) {
    case TxType.INCREASE_NONCE:
      return "INCREASE_NONCE";
    case TxType.RANDOM_NONCE:
      return "RANDOM_NONCE";
    case TxType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface ChainInfo {
  licenseVersion?: string | undefined;
  websocketPort?: number | undefined;
  chainVersion?: string | undefined;
  currentTime?: string | undefined;
  hashType?: string | undefined;
  ledgerVersion?: string | undefined;
  networkId?: string | undefined;
}

export interface GetChainInfoResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: ChainInfo | undefined;
}

export interface GetNetworkIdResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: string | undefined;
}

export interface LedgerHeader {
  seq?: number | undefined;
  hash?: string | undefined;
  previousHash?: string | undefined;
  accountTreeHash?: string | undefined;
  closeTime?: number | undefined;
  consensusValueHash?: string | undefined;
  version?: number | undefined;
  txCount?: number | undefined;
  validatorsHash?: string | undefined;
  feesHash?: string | undefined;
}

export interface LedgerResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: LedgerHeader | undefined;
}

export interface LedgerNumberResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: number | undefined;
}

export interface LedgerLeaderResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: string | undefined;
}

export interface LedgerValidatorsResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: string[] | undefined;
}

export interface LedgerTxHashesResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: string[] | undefined;
}

export interface Contract {
  type?: ContractType | undefined;
  payload?: string | undefined;
}

export interface Signer {
  address?: string | undefined;
  weight?: number | undefined;
}

export enum Signer_Limit {
  SIGNER_NONE = 0,
  SIGNER = 100,
  UNRECOGNIZED = -1,
}

export function signer_LimitFromJSON(object: any): Signer_Limit {
  switch (object) {
    case 0:
    case "SIGNER_NONE":
      return Signer_Limit.SIGNER_NONE;
    case 100:
    case "SIGNER":
      return Signer_Limit.SIGNER;
    case -1:
    case "UNRECOGNIZED":
    default:
      return Signer_Limit.UNRECOGNIZED;
  }
}

export function signer_LimitToJSON(object: Signer_Limit): string {
  switch (object) {
    case Signer_Limit.SIGNER_NONE:
      return "SIGNER_NONE";
    case Signer_Limit.SIGNER:
      return "SIGNER";
    case Signer_Limit.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface OperationTypeThreshold {
  type?: OperationTypeThreshold_Type | undefined;
  threshold?: number | undefined;
}

export enum OperationTypeThreshold_Type {
  UNKNOWN = 0,
  CREATE_ACCOUNT = 1,
  SET_METADATA = 4,
  SET_SIGNER_WEIGHT = 5,
  SET_THRESHOLD = 6,
  PAY_COIN = 7,
  LOG = 8,
  SET_PRIVILEGE = 9,
  UPGRADE_CONTRACT = 10,
  SET_CONTROLLED_AREA = 11,
  AUTHORIZE_TRANSFER = 12,
  UNRECOGNIZED = -1,
}

export function operationTypeThreshold_TypeFromJSON(
  object: any,
): OperationTypeThreshold_Type {
  switch (object) {
    case 0:
    case "UNKNOWN":
      return OperationTypeThreshold_Type.UNKNOWN;
    case 1:
    case "CREATE_ACCOUNT":
      return OperationTypeThreshold_Type.CREATE_ACCOUNT;
    case 4:
    case "SET_METADATA":
      return OperationTypeThreshold_Type.SET_METADATA;
    case 5:
    case "SET_SIGNER_WEIGHT":
      return OperationTypeThreshold_Type.SET_SIGNER_WEIGHT;
    case 6:
    case "SET_THRESHOLD":
      return OperationTypeThreshold_Type.SET_THRESHOLD;
    case 7:
    case "PAY_COIN":
      return OperationTypeThreshold_Type.PAY_COIN;
    case 8:
    case "LOG":
      return OperationTypeThreshold_Type.LOG;
    case 9:
    case "SET_PRIVILEGE":
      return OperationTypeThreshold_Type.SET_PRIVILEGE;
    case 10:
    case "UPGRADE_CONTRACT":
      return OperationTypeThreshold_Type.UPGRADE_CONTRACT;
    case 11:
    case "SET_CONTROLLED_AREA":
      return OperationTypeThreshold_Type.SET_CONTROLLED_AREA;
    case 12:
    case "AUTHORIZE_TRANSFER":
      return OperationTypeThreshold_Type.AUTHORIZE_TRANSFER;
    case -1:
    case "UNRECOGNIZED":
    default:
      return OperationTypeThreshold_Type.UNRECOGNIZED;
  }
}

export function operationTypeThreshold_TypeToJSON(
  object: OperationTypeThreshold_Type,
): string {
  switch (object) {
    case OperationTypeThreshold_Type.UNKNOWN:
      return "UNKNOWN";
    case OperationTypeThreshold_Type.CREATE_ACCOUNT:
      return "CREATE_ACCOUNT";
    case OperationTypeThreshold_Type.SET_METADATA:
      return "SET_METADATA";
    case OperationTypeThreshold_Type.SET_SIGNER_WEIGHT:
      return "SET_SIGNER_WEIGHT";
    case OperationTypeThreshold_Type.SET_THRESHOLD:
      return "SET_THRESHOLD";
    case OperationTypeThreshold_Type.PAY_COIN:
      return "PAY_COIN";
    case OperationTypeThreshold_Type.LOG:
      return "LOG";
    case OperationTypeThreshold_Type.SET_PRIVILEGE:
      return "SET_PRIVILEGE";
    case OperationTypeThreshold_Type.UPGRADE_CONTRACT:
      return "UPGRADE_CONTRACT";
    case OperationTypeThreshold_Type.SET_CONTROLLED_AREA:
      return "SET_CONTROLLED_AREA";
    case OperationTypeThreshold_Type.AUTHORIZE_TRANSFER:
      return "AUTHORIZE_TRANSFER";
    case OperationTypeThreshold_Type.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface AccountThreshold {
  txThreshold?: number | undefined;
  typeThresholds?: OperationTypeThreshold[] | undefined;
}

export interface AccountPrivilege {
  masterWeight?: number | undefined;
  signers?: Signer[] | undefined;
  thresholds?: AccountThreshold | undefined;
}

export interface AccountInfo {
  address?: string | undefined;
  balance?: number | undefined;
  nonce?: number | undefined;
  authTransfer?: boolean | undefined;
  metadatasHash?: string | undefined;
  contract?: Contract | undefined;
  priv?: AccountPrivilege | undefined;
}

export interface GetAccountResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: AccountInfo | undefined;
}

export interface KeyPair {
  key?: string | undefined;
  value?: string | undefined;
  version?: number | undefined;
}

export interface GetAccountMetadataResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: KeyPair[] | undefined;
}

export interface GetAccountIncreaseNonceResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: number | undefined;
}

export interface GetAccountBalanceResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: number | undefined;
}

export interface GetAccountPrivResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: AccountPrivilege | undefined;
}

export interface GetTxPoolSizeResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: number | undefined;
}

export interface Signature {
  publicKey?: string | undefined;
  signData?: string | undefined;
}

export interface OperationCreateAccount {
  destAddress?: string | undefined;
  contract?: Contract | undefined;
  priv?: AccountPrivilege | undefined;
  metadatas?: KeyPair[] | undefined;
  initBalance?: number | undefined;
  initInput?: string | undefined;
}

export interface OperationPayCoin {
  destAddress?: string | undefined;
  amount?: number | undefined;
  input?: string | undefined;
}

export interface OperationSetMetadata {
  key?: string | undefined;
  value?: string | undefined;
  /** optional */
  version?: number | undefined;
  deleteFlag?: boolean | undefined;
}

export interface OperationUpgradeContract {
  destAddress?: string | undefined;
  payload?: string | undefined;
  type?: number | undefined;
}

export interface OperationSetSignerWeight {
  /** required, [-1,MAX(UINT32)] -1: indicates no setting */
  masterWeight?: number | undefined;
  /** address:weight, if weight is 0, it indicates deleting this signer */
  signers?: Signer[] | undefined;
}

export interface OperationSetThreshold {
  txThreshold?: number | undefined;
  /** type:threshold, threshold:0 indicates deleting this type */
  typeThresholds?: OperationTypeThreshold[] | undefined;
}

export interface OperationLog {
  topic?: string | undefined;
  datas?: string[] | undefined;
  /** for evm */
  topics?: string[] | undefined;
}

export interface OperationSetPrivilege {
  masterWeight?: string | undefined;
  signers?: Signer[] | undefined;
  txThreshold?: string | undefined;
  typeThresholds?: OperationTypeThreshold[] | undefined;
}

export interface ControlledArea {
  trusted?: ControlledArea_trustFlag | undefined;
  status?: ControlledArea_statusFalg | undefined;
  attributes?: KeyPair[] | undefined;
}

export enum ControlledArea_trustFlag {
  UNCERT = 0,
  TRUSTED = 1,
  UNTRUSTED = 2,
  UNRECOGNIZED = -1,
}

export function controlledArea_trustFlagFromJSON(
  object: any,
): ControlledArea_trustFlag {
  switch (object) {
    case 0:
    case "UNCERT":
      return ControlledArea_trustFlag.UNCERT;
    case 1:
    case "TRUSTED":
      return ControlledArea_trustFlag.TRUSTED;
    case 2:
    case "UNTRUSTED":
      return ControlledArea_trustFlag.UNTRUSTED;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ControlledArea_trustFlag.UNRECOGNIZED;
  }
}

export function controlledArea_trustFlagToJSON(
  object: ControlledArea_trustFlag,
): string {
  switch (object) {
    case ControlledArea_trustFlag.UNCERT:
      return "UNCERT";
    case ControlledArea_trustFlag.TRUSTED:
      return "TRUSTED";
    case ControlledArea_trustFlag.UNTRUSTED:
      return "UNTRUSTED";
    case ControlledArea_trustFlag.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ControlledArea_statusFalg {
  ENABLED = 0,
  DISABLED = 1,
  UNRECOGNIZED = -1,
}

export function controlledArea_statusFalgFromJSON(
  object: any,
): ControlledArea_statusFalg {
  switch (object) {
    case 0:
    case "ENABLED":
      return ControlledArea_statusFalg.ENABLED;
    case 1:
    case "DISABLED":
      return ControlledArea_statusFalg.DISABLED;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ControlledArea_statusFalg.UNRECOGNIZED;
  }
}

export function controlledArea_statusFalgToJSON(
  object: ControlledArea_statusFalg,
): string {
  switch (object) {
    case ControlledArea_statusFalg.ENABLED:
      return "ENABLED";
    case ControlledArea_statusFalg.DISABLED:
      return "DISABLED";
    case ControlledArea_statusFalg.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface OperationSetControlledArea {
  destAddress?: string | undefined;
  sTrusted?: boolean | undefined;
  sStatus?: boolean | undefined;
  trusted?: ControlledArea_trustFlag | undefined;
  status?: ControlledArea_statusFalg | undefined;
  attributes?: KeyPair[] | undefined;
}

export interface OperationAuthorizeTransfer {
  destAddress?: string | undefined;
  auth?: boolean | undefined;
}

export interface Operation {
  type?: Operation_Type | undefined;
  sourceAddress?: string | undefined;
  metadata?: string | undefined;
  createAccount?: OperationCreateAccount | undefined;
  setMetadata?: OperationSetMetadata | undefined;
  setSignerWeight?: OperationSetSignerWeight | undefined;
  setThreshold?: OperationSetThreshold | undefined;
  payCoin?: OperationPayCoin | undefined;
  log?: OperationLog | undefined;
  setPrivilege?: OperationSetPrivilege | undefined;
  upgradeContract?: OperationUpgradeContract | undefined;
  setControlledArea?: OperationSetControlledArea | undefined;
  authorizeTransfer?: OperationAuthorizeTransfer | undefined;
}

export enum Operation_Type {
  UNKNOWN = 0,
  CREATE_ACCOUNT = 1,
  SET_METADATA = 4,
  SET_SIGNER_WEIGHT = 5,
  SET_THRESHOLD = 6,
  PAY_COIN = 7,
  LOG = 8,
  SET_PRIVILEGE = 9,
  UPGRADE_CONTRACT = 10,
  SET_CONTROLLED_AREA = 11,
  AUTHORIZE_TRANSFER = 12,
  UNRECOGNIZED = -1,
}

export function operation_TypeFromJSON(object: any): Operation_Type {
  switch (object) {
    case 0:
    case "UNKNOWN":
      return Operation_Type.UNKNOWN;
    case 1:
    case "CREATE_ACCOUNT":
      return Operation_Type.CREATE_ACCOUNT;
    case 4:
    case "SET_METADATA":
      return Operation_Type.SET_METADATA;
    case 5:
    case "SET_SIGNER_WEIGHT":
      return Operation_Type.SET_SIGNER_WEIGHT;
    case 6:
    case "SET_THRESHOLD":
      return Operation_Type.SET_THRESHOLD;
    case 7:
    case "PAY_COIN":
      return Operation_Type.PAY_COIN;
    case 8:
    case "LOG":
      return Operation_Type.LOG;
    case 9:
    case "SET_PRIVILEGE":
      return Operation_Type.SET_PRIVILEGE;
    case 10:
    case "UPGRADE_CONTRACT":
      return Operation_Type.UPGRADE_CONTRACT;
    case 11:
    case "SET_CONTROLLED_AREA":
      return Operation_Type.SET_CONTROLLED_AREA;
    case 12:
    case "AUTHORIZE_TRANSFER":
      return Operation_Type.AUTHORIZE_TRANSFER;
    case -1:
    case "UNRECOGNIZED":
    default:
      return Operation_Type.UNRECOGNIZED;
  }
}

export function operation_TypeToJSON(object: Operation_Type): string {
  switch (object) {
    case Operation_Type.UNKNOWN:
      return "UNKNOWN";
    case Operation_Type.CREATE_ACCOUNT:
      return "CREATE_ACCOUNT";
    case Operation_Type.SET_METADATA:
      return "SET_METADATA";
    case Operation_Type.SET_SIGNER_WEIGHT:
      return "SET_SIGNER_WEIGHT";
    case Operation_Type.SET_THRESHOLD:
      return "SET_THRESHOLD";
    case Operation_Type.PAY_COIN:
      return "PAY_COIN";
    case Operation_Type.LOG:
      return "LOG";
    case Operation_Type.SET_PRIVILEGE:
      return "SET_PRIVILEGE";
    case Operation_Type.UPGRADE_CONTRACT:
      return "UPGRADE_CONTRACT";
    case Operation_Type.SET_CONTROLLED_AREA:
      return "SET_CONTROLLED_AREA";
    case Operation_Type.AUTHORIZE_TRANSFER:
      return "AUTHORIZE_TRANSFER";
    case Operation_Type.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface Transaction {
  sourceAddress?: string | undefined;
  feeLimit?: number | undefined;
  gasPrice?: number | undefined;
  nonce?: string | undefined;
  metadata?: string | undefined;
  nonceType?: TxType | undefined;
  maxLedgerSeq?: number | undefined;
  operations?: Operation[] | undefined;
}

export interface ChainTransaction {
  status?: string | undefined;
  incomingTime?: string | undefined;
  hash?: string | undefined;
  signatures?: Signature[] | undefined;
  transaction?: Transaction | undefined;
}

export interface TransactionCacheChain {
  totalCount?: number | undefined;
  transactions?: ChainTransaction[] | undefined;
}

export interface GetTransactionCacheResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: TransactionCacheChain | undefined;
}

export interface TransactionEnv {
  hash?: string | undefined;
  actualFee?: number | undefined;
  closeTime?: number | undefined;
  contractTxHashes?: string[] | undefined;
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  ledgerSeq?: number | undefined;
  signatures?: Signature[] | undefined;
  transaction?: Transaction | undefined;
  txSize?: number | undefined;
  blob?: string | undefined;
}

export interface TransactionHistory {
  totalCount?: number | undefined;
  transactions?: TransactionEnv[] | undefined;
}

export interface GetTransactionHistoryResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: TransactionHistory | undefined;
}

export interface opBaseParams {
  nonceType?: TxType | undefined;
  ceilLedgerSeq?: number | undefined;
  gasPrice?: number | undefined;
  feeLimit?: number | undefined;
  remarks?: string | undefined;
}

export interface GetTxResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: string | undefined;
}

export interface OpCreateAccountParams {
  params?: opBaseParams | undefined;
  destAddress?: string | undefined;
  amount?: number | undefined;
}

export interface OpCreateContractParams {
  params?: opBaseParams | undefined;
  initBalance?: number | undefined;
  type?: ContractType | undefined;
  payload?: string | undefined;
  initInput?: string | undefined;
}

export interface OpGasSendParams {
  params?: opBaseParams | undefined;
  destAddress?: string | undefined;
  amount?: number | undefined;
}

export interface OpGasSend {
  destAddress?: string | undefined;
  amount?: number | undefined;
}

export interface OpContractInvokeParams {
  params?: opBaseParams | undefined;
  contractAddress?: string | undefined;
  input?: string | undefined;
  amount?: number | undefined;
}

export interface OpContractInvoke {
  contractAddress?: string | undefined;
  input?: string | undefined;
  amount?: number | undefined;
}

export interface OpSetMetadataParams {
  params?: opBaseParams | undefined;
  key?: string | undefined;
  value?: string | undefined;
  version?: number | undefined;
  deleteFlag?: boolean | undefined;
}

export interface OpSetPrivParams {
  params?: opBaseParams | undefined;
  masterWeight?: string | undefined;
  signers?: Signer[] | undefined;
  txThreshold?: string | undefined;
  typeThresholds?: OperationTypeThreshold[] | undefined;
}

export interface OpBatchGasSend {
  base?: opBaseParams | undefined;
  params?: OpGasSend[] | undefined;
}

export interface OpBatchContractInvoke {
  base?: opBaseParams | undefined;
  params?: OpContractInvoke[] | undefined;
}

export interface TxBlob {
  transactionBlob?: string | undefined;
  signatures?: Signature[] | undefined;
}

export interface SubmitTransactionParams {
  items?: TxBlob[] | undefined;
}

export interface SubmitTransaction {
  hash?: string | undefined;
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
}

export interface SubmitTransactionResponse {
  successCount?: number | undefined;
  results?: SubmitTransaction[] | undefined;
}

export interface CheckContractAccountResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: boolean | undefined;
}

export interface GetContractInfoResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: Contract | undefined;
}

export interface SignerSignResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: Signature | undefined;
}

export interface OffLineTxResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: TxBlob | undefined;
}

export interface TestTransaction {
  transactionJson?: Transaction | undefined;
  signatureNumber?: number | undefined;
}

export interface TestTransactionRequest {
  items?: TestTransaction[] | undefined;
}

export interface TestTransactionResult {
  stat?: TestTransactionResult_Stat | undefined;
  hash?: string | undefined;
  txs?: TestTransactionResult_TestTx[] | undefined;
}

export interface TestTransactionResult_Stat {
  applyTime?: number | undefined;
  memoryUsage?: number | undefined;
  stackUsage?: number | undefined;
  step?: number | undefined;
}

export interface TestTransactionResult_TransactionEnv {
  transaction?: Transaction | undefined;
}

export interface TestTransactionResult_TestTx {
  gas?: number | undefined;
  transactionEnv?: TestTransactionResult_TransactionEnv | undefined;
  actualFee?: number | undefined;
}

export interface TestTransactionResponse {
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
  result?: TestTransactionResult | undefined;
}

export interface CallContractRequest {
  contractAddress?: string | undefined;
  input?: string | undefined;
  feeLimit?: number | undefined;
  gasPrice?: number | undefined;
  sourceAddress?: string | undefined;
  optType?: number | undefined;
}

export interface CallContractResultSystem {
  queryRets?: QueryReturnSystem[] | undefined;
}

export interface QueryReturnSystem {
  error?: Error | undefined;
  result?: SystemContractResult | undefined;
}

export interface SystemContractResult {
  data?: string | undefined;
}

export interface CallContractResultJs {
  queryRets?: QueryReturnJs[] | undefined;
}

/** 查询返回消息 */
export interface QueryReturnJs {
  error?: Error | undefined;
  result?: JsContractResult | undefined;
}

export interface JsContractResult {
  /** "string" 或 "bool" */
  type?: string | undefined;
  value?: string | undefined;
}

export interface CallContractResultEvm {
  queryRets?: QueryReturnEvm[] | undefined;
}

export interface QueryReturnEvm {
  error?: Error | undefined;
  result?: EvmContractResult | undefined;
}

export interface EvmContractResult {
  code?: number | undefined;
  data?: string | undefined;
  desc?: string | undefined;
  eumcode?: string | undefined;
  gasused?: number | undefined;
}

/** 错误消息 */
export interface Error {
  data?: string | undefined;
}

export interface QueryReturn {
  error?: string | undefined;
  result?: string | undefined;
}

export interface CallContractResult {
  queryRets?: QueryReturn[] | undefined;
}

export interface CallContractResponse {
  trace?: string | undefined;
  result?: CallContractResult | undefined;
  success?: boolean | undefined;
  errorCode?: SdkStatusCode | undefined;
  errorDesc?: string | undefined;
}

function createBaseChainInfo(): ChainInfo {
  return {
    licenseVersion: "",
    websocketPort: 0,
    chainVersion: "",
    currentTime: "",
    hashType: "",
    ledgerVersion: "",
    networkId: "",
  };
}

export const ChainInfo: MessageFns<ChainInfo> = {
  encode(
    message: ChainInfo,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.licenseVersion !== undefined && message.licenseVersion !== "") {
      writer.uint32(10).string(message.licenseVersion);
    }
    if (message.websocketPort !== undefined && message.websocketPort !== 0) {
      writer.uint32(16).int64(message.websocketPort);
    }
    if (message.chainVersion !== undefined && message.chainVersion !== "") {
      writer.uint32(26).string(message.chainVersion);
    }
    if (message.currentTime !== undefined && message.currentTime !== "") {
      writer.uint32(34).string(message.currentTime);
    }
    if (message.hashType !== undefined && message.hashType !== "") {
      writer.uint32(42).string(message.hashType);
    }
    if (message.ledgerVersion !== undefined && message.ledgerVersion !== "") {
      writer.uint32(50).string(message.ledgerVersion);
    }
    if (message.networkId !== undefined && message.networkId !== "") {
      writer.uint32(58).string(message.networkId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ChainInfo {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseChainInfo();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.licenseVersion = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.websocketPort = longToNumber(reader.int64());
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.chainVersion = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.currentTime = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.hashType = reader.string();
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.ledgerVersion = reader.string();
          continue;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }

          message.networkId = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): ChainInfo {
    return {
      licenseVersion: isSet(object.license_version)
        ? globalThis.String(object.license_version)
        : "",
      websocketPort: isSet(object.websocket_port)
        ? globalThis.Number(object.websocket_port)
        : 0,
      chainVersion: isSet(object.chain_version)
        ? globalThis.String(object.chain_version)
        : "",
      currentTime: isSet(object.current_time)
        ? globalThis.String(object.current_time)
        : "",
      hashType: isSet(object.hash_type)
        ? globalThis.String(object.hash_type)
        : "",
      ledgerVersion: isSet(object.ledger_version)
        ? globalThis.String(object.ledger_version)
        : "",
      networkId: isSet(object.network_id)
        ? globalThis.String(object.network_id)
        : "",
    };
  },

  toJSON(message: ChainInfo): unknown {
    const obj: any = {};
    if (message.licenseVersion !== undefined && message.licenseVersion !== "") {
      obj.license_version = message.licenseVersion;
    }
    if (message.websocketPort !== undefined && message.websocketPort !== 0) {
      obj.websocket_port = Math.round(message.websocketPort);
    }
    if (message.chainVersion !== undefined && message.chainVersion !== "") {
      obj.chain_version = message.chainVersion;
    }
    if (message.currentTime !== undefined && message.currentTime !== "") {
      obj.current_time = message.currentTime;
    }
    if (message.hashType !== undefined && message.hashType !== "") {
      obj.hash_type = message.hashType;
    }
    if (message.ledgerVersion !== undefined && message.ledgerVersion !== "") {
      obj.ledger_version = message.ledgerVersion;
    }
    if (message.networkId !== undefined && message.networkId !== "") {
      obj.network_id = message.networkId;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<ChainInfo>, I>>(base?: I): ChainInfo {
    return ChainInfo.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ChainInfo>, I>>(
    object: I,
  ): ChainInfo {
    const message = createBaseChainInfo();
    message.licenseVersion = object.licenseVersion ?? "";
    message.websocketPort = object.websocketPort ?? 0;
    message.chainVersion = object.chainVersion ?? "";
    message.currentTime = object.currentTime ?? "";
    message.hashType = object.hashType ?? "";
    message.ledgerVersion = object.ledgerVersion ?? "";
    message.networkId = object.networkId ?? "";
    return message;
  },
};

function createBaseGetChainInfoResponse(): GetChainInfoResponse {
  return { errorCode: 0, errorDesc: "", result: undefined };
}

export const GetChainInfoResponse: MessageFns<GetChainInfoResponse> = {
  encode(
    message: GetChainInfoResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      writer.uint32(8).int32(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      writer.uint32(18).string(message.errorDesc);
    }
    if (message.result !== undefined) {
      ChainInfo.encode(message.result, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): GetChainInfoResponse {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetChainInfoResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.errorCode = reader.int32() as any;
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.errorDesc = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.result = ChainInfo.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): GetChainInfoResponse {
    return {
      errorCode: isSet(object.error_code)
        ? sdkStatusCodeFromJSON(object.error_code)
        : 0,
      errorDesc: isSet(object.error_desc)
        ? globalThis.String(object.error_desc)
        : "",
      result: isSet(object.result)
        ? ChainInfo.fromJSON(object.result)
        : undefined,
    };
  },

  toJSON(message: GetChainInfoResponse): unknown {
    const obj: any = {};
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      obj.error_code = sdkStatusCodeToJSON(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      obj.error_desc = message.errorDesc;
    }
    if (message.result !== undefined) {
      obj.result = ChainInfo.toJSON(message.result);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetChainInfoResponse>, I>>(
    base?: I,
  ): GetChainInfoResponse {
    return GetChainInfoResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetChainInfoResponse>, I>>(
    object: I,
  ): GetChainInfoResponse {
    const message = createBaseGetChainInfoResponse();
    message.errorCode = object.errorCode ?? 0;
    message.errorDesc = object.errorDesc ?? "";
    message.result =
      object.result !== undefined && object.result !== null
        ? ChainInfo.fromPartial(object.result)
        : undefined;
    return message;
  },
};

function createBaseGetNetworkIdResponse(): GetNetworkIdResponse {
  return { errorCode: 0, errorDesc: "", result: "" };
}

export const GetNetworkIdResponse: MessageFns<GetNetworkIdResponse> = {
  encode(
    message: GetNetworkIdResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      writer.uint32(8).int32(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      writer.uint32(18).string(message.errorDesc);
    }
    if (message.result !== undefined && message.result !== "") {
      writer.uint32(26).string(message.result);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): GetNetworkIdResponse {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGetNetworkIdResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.errorCode = reader.int32() as any;
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.errorDesc = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.result = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): GetNetworkIdResponse {
    return {
      errorCode: isSet(object.error_code)
        ? sdkStatusCodeFromJSON(object.error_code)
        : 0,
      errorDesc: isSet(object.error_desc)
        ? globalThis.String(object.error_desc)
        : "",
      result: isSet(object.result) ? globalThis.String(object.result) : "",
    };
  },

  toJSON(message: GetNetworkIdResponse): unknown {
    const obj: any = {};
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      obj.error_code = sdkStatusCodeToJSON(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      obj.error_desc = message.errorDesc;
    }
    if (message.result !== undefined && message.result !== "") {
      obj.result = message.result;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<GetNetworkIdResponse>, I>>(
    base?: I,
  ): GetNetworkIdResponse {
    return GetNetworkIdResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<GetNetworkIdResponse>, I>>(
    object: I,
  ): GetNetworkIdResponse {
    const message = createBaseGetNetworkIdResponse();
    message.errorCode = object.errorCode ?? 0;
    message.errorDesc = object.errorDesc ?? "";
    message.result = object.result ?? "";
    return message;
  },
};

function createBaseLedgerHeader(): LedgerHeader {
  return {
    seq: 0,
    hash: "",
    previousHash: "",
    accountTreeHash: "",
    closeTime: 0,
    consensusValueHash: "",
    version: 0,
    txCount: 0,
    validatorsHash: "",
    feesHash: "",
  };
}

export const LedgerHeader: MessageFns<LedgerHeader> = {
  encode(
    message: LedgerHeader,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.seq !== undefined && message.seq !== 0) {
      writer.uint32(8).int64(message.seq);
    }
    if (message.hash !== undefined && message.hash !== "") {
      writer.uint32(18).string(message.hash);
    }
    if (message.previousHash !== undefined && message.previousHash !== "") {
      writer.uint32(26).string(message.previousHash);
    }
    if (
      message.accountTreeHash !== undefined &&
      message.accountTreeHash !== ""
    ) {
      writer.uint32(34).string(message.accountTreeHash);
    }
    if (message.closeTime !== undefined && message.closeTime !== 0) {
      writer.uint32(40).int64(message.closeTime);
    }
    if (
      message.consensusValueHash !== undefined &&
      message.consensusValueHash !== ""
    ) {
      writer.uint32(50).string(message.consensusValueHash);
    }
    if (message.version !== undefined && message.version !== 0) {
      writer.uint32(56).int64(message.version);
    }
    if (message.txCount !== undefined && message.txCount !== 0) {
      writer.uint32(64).int64(message.txCount);
    }
    if (message.validatorsHash !== undefined && message.validatorsHash !== "") {
      writer.uint32(74).string(message.validatorsHash);
    }
    if (message.feesHash !== undefined && message.feesHash !== "") {
      writer.uint32(82).string(message.feesHash);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): LedgerHeader {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseLedgerHeader();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.seq = longToNumber(reader.int64());
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.hash = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.previousHash = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.accountTreeHash = reader.string();
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.closeTime = longToNumber(reader.int64());
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.consensusValueHash = reader.string();
          continue;
        }
        case 7: {
          if (tag !== 56) {
            break;
          }

          message.version = longToNumber(reader.int64());
          continue;
        }
        case 8: {
          if (tag !== 64) {
            break;
          }

          message.txCount = longToNumber(reader.int64());
          continue;
        }
        case 9: {
          if (tag !== 74) {
            break;
          }

          message.validatorsHash = reader.string();
          continue;
        }
        case 10: {
          if (tag !== 82) {
            break;
          }

          message.feesHash = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): LedgerHeader {
    return {
      seq: isSet(object.seq) ? globalThis.Number(object.seq) : 0,
      hash: isSet(object.hash) ? globalThis.String(object.hash) : "",
      previousHash: isSet(object.previous_hash)
        ? globalThis.String(object.previous_hash)
        : "",
      accountTreeHash: isSet(object.account_tree_hash)
        ? globalThis.String(object.account_tree_hash)
        : "",
      closeTime: isSet(object.close_time)
        ? globalThis.Number(object.close_time)
        : 0,
      consensusValueHash: isSet(object.consensus_value_hash)
        ? globalThis.String(object.consensus_value_hash)
        : "",
      version: isSet(object.version) ? globalThis.Number(object.version) : 0,
      txCount: isSet(object.tx_count) ? globalThis.Number(object.tx_count) : 0,
      validatorsHash: isSet(object.validators_hash)
        ? globalThis.String(object.validators_hash)
        : "",
      feesHash: isSet(object.fees_hash)
        ? globalThis.String(object.fees_hash)
        : "",
    };
  },

  toJSON(message: LedgerHeader): unknown {
    const obj: any = {};
    if (message.seq !== undefined && message.seq !== 0) {
      obj.seq = Math.round(message.seq);
    }
    if (message.hash !== undefined && message.hash !== "") {
      obj.hash = message.hash;
    }
    if (message.previousHash !== undefined && message.previousHash !== "") {
      obj.previous_hash = message.previousHash;
    }
    if (
      message.accountTreeHash !== undefined &&
      message.accountTreeHash !== ""
    ) {
      obj.account_tree_hash = message.accountTreeHash;
    }
    if (message.closeTime !== undefined && message.closeTime !== 0) {
      obj.close_time = Math.round(message.closeTime);
    }
    if (
      message.consensusValueHash !== undefined &&
      message.consensusValueHash !== ""
    ) {
      obj.consensus_value_hash = message.consensusValueHash;
    }
    if (message.version !== undefined && message.version !== 0) {
      obj.version = Math.round(message.version);
    }
    if (message.txCount !== undefined && message.txCount !== 0) {
      obj.tx_count = Math.round(message.txCount);
    }
    if (message.validatorsHash !== undefined && message.validatorsHash !== "") {
      obj.validators_hash = message.validatorsHash;
    }
    if (message.feesHash !== undefined && message.feesHash !== "") {
      obj.fees_hash = message.feesHash;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<LedgerHeader>, I>>(
    base?: I,
  ): LedgerHeader {
    return LedgerHeader.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<LedgerHeader>, I>>(
    object: I,
  ): LedgerHeader {
    const message = createBaseLedgerHeader();
    message.seq = object.seq ?? 0;
    message.hash = object.hash ?? "";
    message.previousHash = object.previousHash ?? "";
    message.accountTreeHash = object.accountTreeHash ?? "";
    message.closeTime = object.closeTime ?? 0;
    message.consensusValueHash = object.consensusValueHash ?? "";
    message.version = object.version ?? 0;
    message.txCount = object.txCount ?? 0;
    message.validatorsHash = object.validatorsHash ?? "";
    message.feesHash = object.feesHash ?? "";
    return message;
  },
};

function createBaseLedgerResponse(): LedgerResponse {
  return { errorCode: 0, errorDesc: "", result: undefined };
}

export const LedgerResponse: MessageFns<LedgerResponse> = {
  encode(
    message: LedgerResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      writer.uint32(8).int32(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      writer.uint32(18).string(message.errorDesc);
    }
    if (message.result !== undefined) {
      LedgerHeader.encode(message.result, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): LedgerResponse {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseLedgerResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.errorCode = reader.int32() as any;
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.errorDesc = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.result = LedgerHeader.decode(reader, reader.uint32());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): LedgerResponse {
    return {
      errorCode: isSet(object.error_code)
        ? sdkStatusCodeFromJSON(object.error_code)
        : 0,
      errorDesc: isSet(object.error_desc)
        ? globalThis.String(object.error_desc)
        : "",
      result: isSet(object.result)
        ? LedgerHeader.fromJSON(object.result)
        : undefined,
    };
  },

  toJSON(message: LedgerResponse): unknown {
    const obj: any = {};
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      obj.error_code = sdkStatusCodeToJSON(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      obj.error_desc = message.errorDesc;
    }
    if (message.result !== undefined) {
      obj.result = LedgerHeader.toJSON(message.result);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<LedgerResponse>, I>>(
    base?: I,
  ): LedgerResponse {
    return LedgerResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<LedgerResponse>, I>>(
    object: I,
  ): LedgerResponse {
    const message = createBaseLedgerResponse();
    message.errorCode = object.errorCode ?? 0;
    message.errorDesc = object.errorDesc ?? "";
    message.result =
      object.result !== undefined && object.result !== null
        ? LedgerHeader.fromPartial(object.result)
        : undefined;
    return message;
  },
};

function createBaseLedgerNumberResponse(): LedgerNumberResponse {
  return { errorCode: 0, errorDesc: "", result: 0 };
}

export const LedgerNumberResponse: MessageFns<LedgerNumberResponse> = {
  encode(
    message: LedgerNumberResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      writer.uint32(8).int32(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      writer.uint32(18).string(message.errorDesc);
    }
    if (message.result !== undefined && message.result !== 0) {
      writer.uint32(24).int64(message.result);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): LedgerNumberResponse {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseLedgerNumberResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.errorCode = reader.int32() as any;
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.errorDesc = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.result = longToNumber(reader.int64());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): LedgerNumberResponse {
    return {
      errorCode: isSet(object.error_code)
        ? sdkStatusCodeFromJSON(object.error_code)
        : 0,
      errorDesc: isSet(object.error_desc)
        ? globalThis.String(object.error_desc)
        : "",
      result: isSet(object.result) ? globalThis.Number(object.result) : 0,
    };
  },

  toJSON(message: LedgerNumberResponse): unknown {
    const obj: any = {};
    if (message.errorCode !== undefined && message.errorCode !== 0) {
      obj.error_code = sdkStatusCodeToJSON(message.errorCode);
    }
    if (message.errorDesc !== undefined && message.errorDesc !== "") {
      obj.error_desc = message.errorDesc;
    }
    if (message.result !== undefined && message.result !== 0) {
      obj.result = Math.round(message.result);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<LedgerNumberResponse>, I>>(
    base?: I,
  ): LedgerNumberResponse {
    return LedgerNumberResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<LedgerNumberResponse>, I>>(
    object: I,
  ): LedgerNumberResponse {
    const message = createBaseLedgerNumberResponse();
    message.errorCode = object.errorCode ?? 0;
    message.errorDesc = object.errorDesc ?? "";
    message.result = object.result ?? 0;
    r