@caict/bop-typescript-sdk/src/bop/bop-proto/bop-ws.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-ws.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";

export const protobufPackage = "bopws";

/** 定义心跳消息、错误提示和订阅类型的枚举 */
export enum MessageType {
  /** HEARTBEAT - 心跳消息 */
  HEARTBEAT = 0,
  /** ERROR - 连接返回错误提示 */
  ERROR = -1,
  /** BLOCK_HEADER - 订阅区块头 */
  BLOCK_HEADER = 1,
  /** BID_TRANSACTION - 订阅指定bid的交易 */
  BID_TRANSACTION = 2,
  /** TLOG - 订阅TLOG */
  TLOG = 3,
  /** DISCARD_TRANSACTION - 订阅丢弃交易 */
  DISCARD_TRANSACTION = 4,
}

export function messageTypeFromJSON(object: any): MessageType {
  switch (object) {
    case 0:
    case "HEARTBEAT":
      return MessageType.HEARTBEAT;
    case -1:
    case "ERROR":
      return MessageType.ERROR;
    case 1:
    case "BLOCK_HEADER":
      return MessageType.BLOCK_HEADER;
    case 2:
    case "BID_TRANSACTION":
      return MessageType.BID_TRANSACTION;
    case 3:
    case "TLOG":
      return MessageType.TLOG;
    case 4:
    case "DISCARD_TRANSACTION":
      return MessageType.DISCARD_TRANSACTION;
    default:
      return MessageType.ERROR;
  }
}

export function messageTypeToJSON(object: MessageType): string {
  switch (object) {
    case MessageType.HEARTBEAT:
      return "HEARTBEAT";
    case MessageType.ERROR:
      return "ERROR";
    case MessageType.BLOCK_HEADER:
      return "BLOCK_HEADER";
    case MessageType.BID_TRANSACTION:
      return "BID_TRANSACTION";
    case MessageType.TLOG:
      return "TLOG";
    case MessageType.DISCARD_TRANSACTION:
      return "DISCARD_TRANSACTION";
    default:
      return "ERROR";
  }
}

/** 心跳消息（可以是ping或pong） */
export interface HeartbeatMessage {
  /** 可选的附加信息，如"ping"或"pong" */
  message?: string | undefined;
}

export interface SubscribeRequest {
  message?: string[] | undefined;
}

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

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

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

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

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

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 AccountPrivilege {
  masterWeight?: number | undefined;
  signers?: Signer[] | undefined;
  thresholds?: AccountThreshold | undefined;
}

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 {
  /** required, [-1,MAX(INT64)] -1: indicates no setting */
  txThreshold?: number | undefined;
  typeThresholds?: OperationTypeThreshold[] | 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?: Transaction_TxType | undefined;
  maxLedgerSeq?: number | undefined;
  operations?: Operation[] | undefined;
}

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

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

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

export interface Trigger {
  transactionType?: Trigger_TransactionType | undefined;
  /** If it is triggered by a specific block (temporarily not provided) */
  ledgerSeq?: number | undefined;
  /** If it's a transaction triggered */
  transaction?: Trigger_OperationTrigger | undefined;
}

export enum Trigger_TransactionType {
  NORMAL_TRANSACTION = 0,
  CONTRACT_TRANSACTION = 1,
  UNRECOGNIZED = -1,
}

export function trigger_TransactionTypeFromJSON(
  object: any,
): Trigger_TransactionType {
  switch (object) {
    case 0:
    case "NORMAL_TRANSACTION":
      return Trigger_TransactionType.NORMAL_TRANSACTION;
    case 1:
    case "CONTRACT_TRANSACTION":
      return Trigger_TransactionType.CONTRACT_TRANSACTION;
    case -1:
    case "UNRECOGNIZED":
    default:
      return Trigger_TransactionType.UNRECOGNIZED;
  }
}

export function trigger_TransactionTypeToJSON(
  object: Trigger_TransactionType,
): string {
  switch (object) {
    case Trigger_TransactionType.NORMAL_TRANSACTION:
      return "NORMAL_TRANSACTION";
    case Trigger_TransactionType.CONTRACT_TRANSACTION:
      return "CONTRACT_TRANSACTION";
    case Trigger_TransactionType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface Trigger_OperationTrigger {
  hash?: Uint8Array | undefined;
  index?: number | undefined;
}

export interface TransactionEnv {
  transaction?: Transaction | undefined;
  signatures?: Signature[] | undefined;
  trigger?: Trigger | undefined;
}

export interface TransactionEnvStoreMessage {
  transactionEnv?: TransactionEnv | undefined;
  errorCode?: number | undefined;
  errorDesc?: string | undefined;
  ledgerSeq?: number | undefined;
  closeTime?: number | undefined;
  /** for notify */
  hash?: string | undefined;
  actualFee?: number | undefined;
  contractTxHashes?: string[] | undefined;
}

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

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

export interface DropTxMessage {
  txHash?: string | undefined;
  source?: DropTxMessage_PoolType | undefined;
  timestamp?: number | undefined;
  /** 序列化Transaction数据 */
  tx?: string | undefined;
}

export enum DropTxMessage_PoolType {
  PLATFORM = 0,
  CHAIN = 1,
  UNRECOGNIZED = -1,
}

export function dropTxMessage_PoolTypeFromJSON(
  object: any,
): DropTxMessage_PoolType {
  switch (object) {
    case 0:
    case "PLATFORM":
      return DropTxMessage_PoolType.PLATFORM;
    case 1:
    case "CHAIN":
      return DropTxMessage_PoolType.CHAIN;
    case -1:
    case "UNRECOGNIZED":
    default:
      return DropTxMessage_PoolType.UNRECOGNIZED;
  }
}

export function dropTxMessage_PoolTypeToJSON(
  object: DropTxMessage_PoolType,
): string {
  switch (object) {
    case DropTxMessage_PoolType.PLATFORM:
      return "PLATFORM";
    case DropTxMessage_PoolType.CHAIN:
      return "CHAIN";
    case DropTxMessage_PoolType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

function createBaseHeartbeatMessage(): HeartbeatMessage {
  return { message: "" };
}

export const HeartbeatMessage: MessageFns<HeartbeatMessage> = {
  encode(
    message: HeartbeatMessage,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.message !== undefined && message.message !== "") {
      writer.uint32(10).string(message.message);
    }
    return writer;
  },

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

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

  fromJSON(object: any): HeartbeatMessage {
    return {
      message: isSet(object.message) ? globalThis.String(object.message) : "",
    };
  },

  toJSON(message: HeartbeatMessage): unknown {
    const obj: any = {};
    if (message.message !== undefined && message.message !== "") {
      obj.message = message.message;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<HeartbeatMessage>, I>>(
    base?: I,
  ): HeartbeatMessage {
    return HeartbeatMessage.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<HeartbeatMessage>, I>>(
    object: I,
  ): HeartbeatMessage {
    const message = createBaseHeartbeatMessage();
    message.message = object.message ?? "";
    return message;
  },
};

function createBaseSubscribeRequest(): SubscribeRequest {
  return { message: [] };
}

export const SubscribeRequest: MessageFns<SubscribeRequest> = {
  encode(
    message: SubscribeRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.message !== undefined && message.message.length !== 0) {
      for (const v of message.message) {
        writer.uint32(10).string(v!);
      }
    }
    return writer;
  },

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

          const el = reader.string();
          if (el !== undefined) {
            message.message!.push(el);
          }
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): SubscribeRequest {
    return {
      message: globalThis.Array.isArray(object?.message)
        ? object.message.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: SubscribeRequest): unknown {
    const obj: any = {};
    if (message.message?.length) {
      obj.message = message.message;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<SubscribeRequest>, I>>(
    base?: I,
  ): SubscribeRequest {
    return SubscribeRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<SubscribeRequest>, I>>(
    object: I,
  ): SubscribeRequest {
    const message = createBaseSubscribeRequest();
    message.message = object.message?.map((e) => e) || [];
    return message;
  },
};

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

export const LedgerHeaderMessage: MessageFns<LedgerHeaderMessage> = {
  encode(
    message: LedgerHeaderMessage,
    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,
  ): LedgerHeaderMessage {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseLedgerHeaderMessage();
    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): LedgerHeaderMessage {
    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: LedgerHeaderMessage): 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<LedgerHeaderMessage>, I>>(
    base?: I,
  ): LedgerHeaderMessage {
    return LedgerHeaderMessage.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<LedgerHeaderMessage>, I>>(
    object: I,
  ): LedgerHeaderMessage {
    const message = createBaseLedgerHeaderMessage();
    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 createBaseContract(): Contract {
  return { type: 0, payload: "" };
}

export const Contract: MessageFns<Contract> = {
  encode(
    message: Contract,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.type !== undefined && message.type !== 0) {
      writer.uint32(8).int32(message.type);
    }
    if (message.payload !== undefined && message.payload !== "") {
      writer.uint32(18).string(message.payload);
    }
    return writer;
  },

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

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

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

  fromJSON(object: any): Contract {
    return {
      type: isSet(object.type) ? contract_ContractTypeFromJSON(object.type) : 0,
      payload: isSet(object.payload) ? globalThis.String(object.payload) : "",
    };
  },

  toJSON(message: Contract): unknown {
    const obj: any = {};
    if (message.type !== undefined && message.type !== 0) {
      obj.type = contract_ContractTypeToJSON(message.type);
    }
    if (message.payload !== undefined && message.payload !== "") {
      obj.payload = message.payload;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Contract>, I>>(base?: I): Contract {
    return Contract.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Contract>, I>>(object: I): Contract {
    const message = createBaseContract();
    message.type = object.type ?? 0;
    message.payload = object.payload ?? "";
    return message;
  },
};

function createBaseSigner(): Signer {
  return { address: "", weight: 0 };
}

export const Signer: MessageFns<Signer> = {
  encode(
    message: Signer,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.address !== undefined && message.address !== "") {
      writer.uint32(10).string(message.address);
    }
    if (message.weight !== undefined && message.weight !== 0) {
      writer.uint32(16).int64(message.weight);
    }
    return writer;
  },

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

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

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

  fromJSON(object: any): Signer {
    return {
      address: isSet(object.address) ? globalThis.String(object.address) : "",
      weight: isSet(object.weight) ? globalThis.Number(object.weight) : 0,
    };
  },

  toJSON(message: Signer): unknown {
    const obj: any = {};
    if (message.address !== undefined && message.address !== "") {
      obj.address = message.address;
    }
    if (message.weight !== undefined && message.weight !== 0) {
      obj.weight = Math.round(message.weight);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<Signer>, I>>(base?: I): Signer {
    return Signer.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<Signer>, I>>(object: I): Signer {
    const message = createBaseSigner();
    message.address = object.address ?? "";
    message.weight = object.weight ?? 0;
    return message;
  },
};

function createBaseAccountPrivilege(): AccountPrivilege {
  return { masterWeight: 0, signers: [], thresholds: undefined };
}

export const AccountPrivilege: MessageFns<AccountPrivilege> = {
  encode(
    message: AccountPrivilege,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.masterWeight !== undefined && message.masterWeight !== 0) {
      writer.uint32(8).int64(message.masterWeight);
    }
    if (message.signers !== undefined && message.signers.length !== 0) {
      for (const v of message.signers) {
        Signer.encode(v!, writer.uint32(18).fork()).join();
      }
    }
    if (message.thresholds !== undefined) {
      AccountThreshold.encode(
        message.thresholds,
        writer.uint32(26).fork(),
      ).join();
    }
    return writer;
  },

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

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

          const el = Signer.decode(reader, reader.uint32());
          if (el !== undefined) {
            message.signers!.push(el);
          }
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

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

  fromJSON(object: any): AccountPrivilege {
    return {
      masterWeight: isSet(object.master_weight)
        ? globalThis.Number(object.master_weight)
        : 0,
      signers: globalThis.Array.isArray(object?.signers)
        ? object.signers.map((e: any) => Signer.fromJSON(e))
        : [],
      thresholds: isSet(object.thresholds)
        ? AccountThreshold.fromJSON(object.thresholds)
        : undefined,
    };
  },

  toJSON(message: AccountPrivilege): unknown {
    const obj: any = {};
    if (message.masterWeight !== undefined && message.masterWeight !== 0) {
      obj.master_weight = Math.round(message.masterWeight);
    }
    if (message.signers?.length) {
      obj.signers = message.signers.map((e) => Signer.toJSON(e));
    }
    if (message.thresholds !== undefined) {
      obj.thresholds = AccountThreshold.toJSON(message.thresholds);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AccountPrivilege>, I>>(
    base?: I,
  ): AccountPrivilege {
    return AccountPrivilege.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AccountPrivilege>, I>>(
    object: I,
  ): AccountPrivilege {
    const message = createBaseAccountPrivilege();
    message.masterWeight = object.masterWeight ?? 0;
    message.signers = object.signers?.map((e) => Signer.fromPartial(e)) || [];
    message.thresholds =
      object.thresholds !== undefined && object.thresholds !== null
        ? AccountThreshold.fromPartial(object.thresholds)
        : undefined;
    return message;
  },
};

function createBaseOperationTypeThreshold(): OperationTypeThreshold {
  return { type: 0, threshold: 0 };
}

export const OperationTypeThreshold: MessageFns<OperationTypeThreshold> = {
  encode(
    message: OperationTypeThreshold,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.type !== undefined && message.type !== 0) {
      writer.uint32(8).int32(message.type);
    }
    if (message.threshold !== undefined && message.threshold !== 0) {
      writer.uint32(16).int64(message.threshold);
    }
    return writer;
  },

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

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

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

  fromJSON(object: any): OperationTypeThreshold {
    return {
      type: isSet(object.type)
        ? operationTypeThreshold_TypeFromJSON(object.type)
        : 0,
      threshold: isSet(object.threshold)
        ? globalThis.Number(object.threshold)
        : 0,
    };
  },

  toJSON(message: OperationTypeThreshold): unknown {
    const obj: any = {};
    if (message.type !== undefined && message.type !== 0) {
      obj.type = operationTypeThreshold_TypeToJSON(message.type);
    }
    if (message.threshold !== undefined && message.threshold !== 0) {
      obj.threshold = Math.round(message.threshold);
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<OperationTypeThreshold>, I>>(
    base?: I,
  ): OperationTypeThreshold {
    return OperationTypeThreshold.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<OperationTypeThreshold>, I>>(
    object: I,
  ): OperationTypeThreshold {
    const message = createBaseOperationTypeThreshold();
    message.type = object.type ?? 0;
    message.threshold = object.threshold ?? 0;
    return message;
  },
};

function createBaseAccountThreshold(): AccountThreshold {
  return { txThreshold: 0, typeThresholds: [] };
}

export const AccountThreshold: MessageFns<AccountThreshold> = {
  encode(
    message: AccountThreshold,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.txThreshold !== undefined && message.txThreshold !== 0) {
      writer.uint32(8).int64(message.txThreshold);
    }
    if (
      message.typeThresholds !== undefined &&
      message.typeThresholds.length !== 0
    ) {
      for (const v of message.typeThresholds) {
        OperationTypeThreshold.encode(v!, writer.uint32(18).fork()).join();
      }
    }
    return writer;
  },

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

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

          const el = OperationTypeThreshold.decode(reader, reader.uint32());
          if (el !== undefined) {
            message.typeThresholds!.push(el);
          }
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): AccountThreshold {
    return {
      txThreshold: isSet(object.tx_threshold)
        ? globalThis.Number(object.tx_threshold)
        : 0,
      typeThresholds: globalThis.Array.isArray(object?.type_thresholds)
        ? object.type_thresholds.map((e: any) =>
            OperationTypeThreshold.fromJSON(e),
          )
        : [],
    };
  },

  toJSON(message: AccountThreshold): unknown {
    const obj: any = {};
    if (message.txThreshold !== undefined && message.txThreshold !== 0) {
      obj.tx_threshold = Math.round(message.txThreshold);
    }
    if (message.typeThresholds?.length) {
      obj.type_thresholds = message.typeThresholds.map((e) =>
        OperationTypeThreshold.toJSON(e),
      );
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<AccountThreshold>, I>>(
    base?: I,
  ): AccountThreshold {
    return AccountThreshold.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AccountThreshold>, I>>(
    object: I,
  ): AccountThreshold {
    const message = createBaseAccountThreshold();
    message.txThreshold = object.txThreshold ?? 0;
    message.typeThresholds =
      object.typeThresholds?.map((e) =>
        OperationTypeThreshold.fromPartial(e),
      ) || [];
    return message;
  },
};

function createBaseOperationCreateAccount(): OperationCreateAccount {
  return {
    destAddress: "",
    contract: undefined,
    priv: undefined,
    metadatas: [],
    initBalance: 0,
    initInput: "",
  };
}

export const OperationCreateAccount: MessageFns<OperationCreateAccount> = {
  encode(
    message: OperationCreateAccount,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.destAddress !== undefined && message.destAddress !== "") {
      writer.uint32(10).string(message.destAddress);
    }
    if (message.contract !== undefined) {
      Contract.encode(message.contract, writer.uint32(18).fork()).join();
    }
    if (message.priv !== undefined) {
      AccountPrivilege.encode(message.priv, writer.uint32(26).fork()).join();
    }
    if (message.metadatas !== undefined && message.metadatas.length !== 0) {
      for (const v of message.metadatas) {
        KeyPair.encode(v!, writer.uint32(34).fork()).join();
      }
    }
    if (message.initBalance !== undefined && message.initBalance !== 0) {
      writer.uint32(40).int64(message.initBalance);
    }
    if (message.initInput !== undefined && message.initInput !== "") {
      writer.uint32(50).string(message.initInput);
    }
    return writer;
  },

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

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

          message.contract = Contract.decode(reader, reader.uint32());
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.priv = AccountPrivilege.decode(reader, reader.uint32());
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          const el = KeyPair.decode(reader, reader.uint32());
          if (el !== undefined) {
            message.metadatas!.push(el);
          }
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

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

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

  fromJSON(object: any): OperationCreateAccount {
    return {
      destAddress: isSet(object.dest_address)
        ? globalThis.String(object.dest_address)
        : "",
      contract: isSet(object.contract)
        ? Contract.fromJSON(object.contract)
        : undefined,
      priv: isSet(object.priv)
        ? AccountPrivilege.fromJSON(object.priv)
        : undefined,
      metadatas: globalThis.Array.isArray(object?.metadatas)
        ? object.metadatas.map((e: any) => KeyPair.fromJSON(e))
        : [],
      initBalance: isSet(object.init_balance)
        ? globalThis.Number(object.init_balance)
        : 0,
      initInput: isSet(object.init_input)
        ? globalThis.String(object.init_input)
        : "",
    };
  },

  toJSON(message: OperationCreateAccount): unknown {
    const obj: any = {};
    if (message.destAddress !== undefined && message.destAddress !== "") {
      obj.dest_address = message.destAddress;
    }
    if (message.contract !== undefined) {
      obj.contract = Contract.toJSON(message.contract);
    }
    if (message.priv !== undefined) {
      obj.priv = AccountPrivilege.toJSON(message.priv);
    }
    if (message.metadatas?.length) {
      obj.metadatas = message.metadatas.map((e) => KeyPair.toJSON(e));
    }
    if (message.initBalance !== undefined && message.initBalance !== 0) {
      obj.init_balance = Math.round(message.initBalance);
    }
    if (message.initInput !== undefined && message.initInput !== "") {
      obj.init_input = message.initInput;
    }
    return obj;
  },

  create<I extends Exact<DeepPartial<OperationCreateAccount>, I>>(
    base?: I,
  ): OperationCreateAccount {
    return OperationCreateAccount.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<OperationCreateAccount>, I>>(
    object: I,
  ): OperationCreateAccount {
    const message = createBaseOperationCreateAccount();
    message.destAddress = object.destAddress ?? "";
    message.contract =
      object.contract !== undefined && object.contract !== null
        ? Contract.fromPartial(object.contract)
        : undefined;
    message.priv =
      object.priv !== undefined && object.priv !== null
        ? AccountPrivilege.fromPartial(object.priv)
        : undefined;
    message.metadatas =
      object.metadatas?.map((e) => KeyPair.fromPartial(e)) || [];
    message.initBalance = object.initBalance ?? 0;
    message.initInput = object.initInput ?? "";
    return message;
  },
};

function createBaseOperationPayCoin(): Opera