@emeraldpay/api-node/lib/generated/blockchain_grpc_pb.js

Node client for Emerald gRPC APIs

// GENERATED CODE -- DO NOT EDIT!

'use strict';
var grpc = require('@grpc/grpc-js');
var blockchain_pb = require('./blockchain_pb.js');
var common_pb = require('./common_pb.js');

function serialize_emerald_AddressAllowance(arg) {
  if (!(arg instanceof blockchain_pb.AddressAllowance)) {
    throw new Error('Expected argument of type emerald.AddressAllowance');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_AddressAllowance(buffer_arg) {
  return blockchain_pb.AddressAllowance.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_AddressAllowanceRequest(arg) {
  if (!(arg instanceof blockchain_pb.AddressAllowanceRequest)) {
    throw new Error('Expected argument of type emerald.AddressAllowanceRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_AddressAllowanceRequest(buffer_arg) {
  return blockchain_pb.AddressAllowanceRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_AddressBalance(arg) {
  if (!(arg instanceof blockchain_pb.AddressBalance)) {
    throw new Error('Expected argument of type emerald.AddressBalance');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_AddressBalance(buffer_arg) {
  return blockchain_pb.AddressBalance.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_BalanceRequest(arg) {
  if (!(arg instanceof blockchain_pb.BalanceRequest)) {
    throw new Error('Expected argument of type emerald.BalanceRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_BalanceRequest(buffer_arg) {
  return blockchain_pb.BalanceRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_Chain(arg) {
  if (!(arg instanceof common_pb.Chain)) {
    throw new Error('Expected argument of type emerald.Chain');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_Chain(buffer_arg) {
  return common_pb.Chain.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_ChainHead(arg) {
  if (!(arg instanceof blockchain_pb.ChainHead)) {
    throw new Error('Expected argument of type emerald.ChainHead');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_ChainHead(buffer_arg) {
  return blockchain_pb.ChainHead.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_ChainStatus(arg) {
  if (!(arg instanceof blockchain_pb.ChainStatus)) {
    throw new Error('Expected argument of type emerald.ChainStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_ChainStatus(buffer_arg) {
  return blockchain_pb.ChainStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_DescribeRequest(arg) {
  if (!(arg instanceof blockchain_pb.DescribeRequest)) {
    throw new Error('Expected argument of type emerald.DescribeRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_DescribeRequest(buffer_arg) {
  return blockchain_pb.DescribeRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_DescribeResponse(arg) {
  if (!(arg instanceof blockchain_pb.DescribeResponse)) {
    throw new Error('Expected argument of type emerald.DescribeResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_DescribeResponse(buffer_arg) {
  return blockchain_pb.DescribeResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_EstimateFeeRequest(arg) {
  if (!(arg instanceof blockchain_pb.EstimateFeeRequest)) {
    throw new Error('Expected argument of type emerald.EstimateFeeRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_EstimateFeeRequest(buffer_arg) {
  return blockchain_pb.EstimateFeeRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_EstimateFeeResponse(arg) {
  if (!(arg instanceof blockchain_pb.EstimateFeeResponse)) {
    throw new Error('Expected argument of type emerald.EstimateFeeResponse');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_EstimateFeeResponse(buffer_arg) {
  return blockchain_pb.EstimateFeeResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_NativeCallReplyItem(arg) {
  if (!(arg instanceof blockchain_pb.NativeCallReplyItem)) {
    throw new Error('Expected argument of type emerald.NativeCallReplyItem');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_NativeCallReplyItem(buffer_arg) {
  return blockchain_pb.NativeCallReplyItem.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_NativeCallRequest(arg) {
  if (!(arg instanceof blockchain_pb.NativeCallRequest)) {
    throw new Error('Expected argument of type emerald.NativeCallRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_NativeCallRequest(buffer_arg) {
  return blockchain_pb.NativeCallRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_NativeSubscribeReplyItem(arg) {
  if (!(arg instanceof blockchain_pb.NativeSubscribeReplyItem)) {
    throw new Error('Expected argument of type emerald.NativeSubscribeReplyItem');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_NativeSubscribeReplyItem(buffer_arg) {
  return blockchain_pb.NativeSubscribeReplyItem.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_NativeSubscribeRequest(arg) {
  if (!(arg instanceof blockchain_pb.NativeSubscribeRequest)) {
    throw new Error('Expected argument of type emerald.NativeSubscribeRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_NativeSubscribeRequest(buffer_arg) {
  return blockchain_pb.NativeSubscribeRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_StatusRequest(arg) {
  if (!(arg instanceof blockchain_pb.StatusRequest)) {
    throw new Error('Expected argument of type emerald.StatusRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_StatusRequest(buffer_arg) {
  return blockchain_pb.StatusRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_TxStatus(arg) {
  if (!(arg instanceof blockchain_pb.TxStatus)) {
    throw new Error('Expected argument of type emerald.TxStatus');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_TxStatus(buffer_arg) {
  return blockchain_pb.TxStatus.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_emerald_TxStatusRequest(arg) {
  if (!(arg instanceof blockchain_pb.TxStatusRequest)) {
    throw new Error('Expected argument of type emerald.TxStatusRequest');
  }
  return Buffer.from(arg.serializeBinary());
}

function deserialize_emerald_TxStatusRequest(buffer_arg) {
  return blockchain_pb.TxStatusRequest.deserializeBinary(new Uint8Array(buffer_arg));
}


var BlockchainService = exports.BlockchainService = {
  subscribeHead: {
    path: '/emerald.Blockchain/SubscribeHead',
    requestStream: false,
    responseStream: true,
    requestType: common_pb.Chain,
    responseType: blockchain_pb.ChainHead,
    requestSerialize: serialize_emerald_Chain,
    requestDeserialize: deserialize_emerald_Chain,
    responseSerialize: serialize_emerald_ChainHead,
    responseDeserialize: deserialize_emerald_ChainHead,
  },
  subscribeBalance: {
    path: '/emerald.Blockchain/SubscribeBalance',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.BalanceRequest,
    responseType: blockchain_pb.AddressBalance,
    requestSerialize: serialize_emerald_BalanceRequest,
    requestDeserialize: deserialize_emerald_BalanceRequest,
    responseSerialize: serialize_emerald_AddressBalance,
    responseDeserialize: deserialize_emerald_AddressBalance,
  },
  subscribeTxStatus: {
    path: '/emerald.Blockchain/SubscribeTxStatus',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.TxStatusRequest,
    responseType: blockchain_pb.TxStatus,
    requestSerialize: serialize_emerald_TxStatusRequest,
    requestDeserialize: deserialize_emerald_TxStatusRequest,
    responseSerialize: serialize_emerald_TxStatus,
    responseDeserialize: deserialize_emerald_TxStatus,
  },
  getBalance: {
    path: '/emerald.Blockchain/GetBalance',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.BalanceRequest,
    responseType: blockchain_pb.AddressBalance,
    requestSerialize: serialize_emerald_BalanceRequest,
    requestDeserialize: deserialize_emerald_BalanceRequest,
    responseSerialize: serialize_emerald_AddressBalance,
    responseDeserialize: deserialize_emerald_AddressBalance,
  },
  // DEPRECATED, moved to token service
getAddressAllowance: {
    path: '/emerald.Blockchain/GetAddressAllowance',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.AddressAllowanceRequest,
    responseType: blockchain_pb.AddressAllowance,
    requestSerialize: serialize_emerald_AddressAllowanceRequest,
    requestDeserialize: deserialize_emerald_AddressAllowanceRequest,
    responseSerialize: serialize_emerald_AddressAllowance,
    responseDeserialize: deserialize_emerald_AddressAllowance,
  },
  // DEPRECATED, moved to token service
subscribeAddressAllowance: {
    path: '/emerald.Blockchain/SubscribeAddressAllowance',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.AddressAllowanceRequest,
    responseType: blockchain_pb.AddressAllowance,
    requestSerialize: serialize_emerald_AddressAllowanceRequest,
    requestDeserialize: deserialize_emerald_AddressAllowanceRequest,
    responseSerialize: serialize_emerald_AddressAllowance,
    responseDeserialize: deserialize_emerald_AddressAllowance,
  },
  // *
// Fee Estimation service. The server tries to estimate a fair fee based on the last N blocks.
estimateFee: {
    path: '/emerald.Blockchain/EstimateFee',
    requestStream: false,
    responseStream: false,
    requestType: blockchain_pb.EstimateFeeRequest,
    responseType: blockchain_pb.EstimateFeeResponse,
    requestSerialize: serialize_emerald_EstimateFeeRequest,
    requestDeserialize: deserialize_emerald_EstimateFeeRequest,
    responseSerialize: serialize_emerald_EstimateFeeResponse,
    responseDeserialize: deserialize_emerald_EstimateFeeResponse,
  },
  nativeCall: {
    path: '/emerald.Blockchain/NativeCall',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.NativeCallRequest,
    responseType: blockchain_pb.NativeCallReplyItem,
    requestSerialize: serialize_emerald_NativeCallRequest,
    requestDeserialize: deserialize_emerald_NativeCallRequest,
    responseSerialize: serialize_emerald_NativeCallReplyItem,
    responseDeserialize: deserialize_emerald_NativeCallReplyItem,
  },
  nativeSubscribe: {
    path: '/emerald.Blockchain/NativeSubscribe',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.NativeSubscribeRequest,
    responseType: blockchain_pb.NativeSubscribeReplyItem,
    requestSerialize: serialize_emerald_NativeSubscribeRequest,
    requestDeserialize: deserialize_emerald_NativeSubscribeRequest,
    responseSerialize: serialize_emerald_NativeSubscribeReplyItem,
    responseDeserialize: deserialize_emerald_NativeSubscribeReplyItem,
  },
  describe: {
    path: '/emerald.Blockchain/Describe',
    requestStream: false,
    responseStream: false,
    requestType: blockchain_pb.DescribeRequest,
    responseType: blockchain_pb.DescribeResponse,
    requestSerialize: serialize_emerald_DescribeRequest,
    requestDeserialize: deserialize_emerald_DescribeRequest,
    responseSerialize: serialize_emerald_DescribeResponse,
    responseDeserialize: deserialize_emerald_DescribeResponse,
  },
  subscribeStatus: {
    path: '/emerald.Blockchain/SubscribeStatus',
    requestStream: false,
    responseStream: true,
    requestType: blockchain_pb.StatusRequest,
    responseType: blockchain_pb.ChainStatus,
    requestSerialize: serialize_emerald_StatusRequest,
    requestDeserialize: deserialize_emerald_StatusRequest,
    responseSerialize: serialize_emerald_ChainStatus,
    responseDeserialize: deserialize_emerald_ChainStatus,
  },
};

exports.BlockchainClient = grpc.makeGenericClientConstructor(BlockchainService);