$ npm install @hiveio/hive-js --save

<script src="./hive.min.js"></script>
<script>
hive.api.getAccounts(['mahdiyari', 'hiveio'], function(err, response){
    console.log(err, response);
});
</script>

<script src="https://cdn.jsdelivr.net/npm/@hiveio/hive-js/dist/hive.min.js"></script>

hive.api.setOptions({ url: 'https://anyx.io' });
hive.config.set('address_prefix','STM');
hive.config.set('chain_id','beeab0de00000000000000000000000000000000000000000000000000000000');
hive.config.set('alternative_api_endpoints', ['https://api.hive.blog', 'https://anyx.io']);

hive.config.set('address_prefix','STM');

hive.config.get('chain_id');

hive.api.setOptions({ url: 'https://api.hive.blog' });

hive.api.call(method, params, callback);
// or
hive.api.callAsync(method, params).then(res => {});

hive.api.callAsync('condenser_api.get_accounts', [['mahdiyari']])
  .then((res) => console.log(res))

hive.api.setSubscribeCallback(callback, clearFilter, function(err, result) {
  console.log(err, result);
});

hive.api.setPendingTransactionCallback(cb, function(err, result) {
  console.log(err, result);
});

hive.api.setBlockAppliedCallback(cb, function(err, result) {
  console.log(err, result);
});

hive.api.cancelAllSubscriptions(function(err, result) {
  console.log(err, result);
});

hive.api.getTrendingTags(afterTag, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getTrendingTags('', 2, function(err, result) {
  console.log(err, result);
});

[ { name: '', total_payouts: '37610793.383 SBD', net_votes: 4211122, top_posts: 411832, comments: 1344461, trending: '5549490701' },
  { name: 'life', total_payouts: '8722947.658 SBD', net_votes: 1498401, top_posts: 127103, comments: 54049, trending: '570954588' } ]

// Extract tags from the result into an array of tag name strings
var f = result.map(function(item) { return item.name; });
console.log(f);

// Get the last tag for subsequent calls to `getTrendingTags`
//   or use: f[f.length - 1]   if you used the extraction code above.
var lastKnownTag = result[result.length - 1].name;

// Use the last known tag to get the next group of tags
hive.api.TrendingTags(lastKnownTag, 2, function(err, result) {
  console.log(err, result);
});

hive.api.getBlog(account, entryId, limit, callback);

hive.api.getBlog("username", 10, 3, function(err, data) {
	console.log(err, data);
});

// In this case we have a call to get [3] posts, the newest of which is the one with index [10]
//			(that's the 11-th post, because the post indexes are zero based)
// That means that the results will be posts [10, 9 and 8]

[
  {
		blog:"username"
		comment: { /* Omited for simplicity */ }
		entry_id: 10
		reblog_on:"1970-01-01T00:00:00"
	},
	{
		blog:"username"
		comment: { /* Omited for simplicity */ }
		entry_id: 9
		reblog_on:"1970-01-01T00:00:00"
	},
	{
		blog:"username"
		comment: { /* Omited for simplicity */ }
		entry_id: 8
		reblog_on:"1970-01-01T00:00:00"
  }
]

hive.api.getBlogAuthors(blogAccount, callback);

hive.api.getBlogAuthors("username", function(err, data) {
	console.log(err, data);
});

[ [ 'username1', 1 ],
  [ 'username2', 1 ],
  [ 'username3', 3 ],
  [ 'username4', 2 ],
  [ 'username5', 1 ] ]

hive.api.getBlogEntries(account, entryId, limit, callback);

hive.api.getBlogEntries("username", 10, 3, function(err, data) {
	console.log(err, data);
});

// In this case we have a call to get [3] posts, the newest of which is the one with index [10]
//			(that's the 11-th post, because the post indexes are zero based)
// That means that the results will be posts [10, 9 and 8]

[ { author: 'username',
    permlink: 'post-permlink-10',
    blog: 'username',
    reblog_on: '1970-01-01T00:00:00',
    entry_id: 10 },
  { author: 'username',
    permlink: 'post-permlink-9',
    blog: 'username',
    reblog_on: '1970-01-01T00:00:00',
    entry_id: 9 },
  { author: 'username',
    permlink: 'post-permlink-8',
    blog: 'username',
    reblog_on: '1970-01-01T00:00:00',
    entry_id: 8 } ]

hive.api.getDiscussionsByTrending(query, function(err, result) {
  console.log(err, result);
});

var query = { limit : 3, tag : "hive" };
hive.api.getDiscussionsByTrending30(query, function(err, data) {
	console.log(err, data);
});

// NOTE! The default limit is 0. Not setting a limit will get you an empty result.

// the result is an array of big objects representing the comments

 [ { /* ommited for simplicity */ },
   { /* ommited for simplicity */ },
   { /* ommited for simplicity */ } ]

hive.api.getDiscussionsByCreated(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByActive(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByCashout(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByPayout(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByVotes(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByChildren(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByHot(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByFeed(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByBlog(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByComments(query, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByPromoted(query, callback);

var query = { limit : 3, tag : "hive" };
hive.api.getDiscussionsByPromoted(query, function(err, data) {
	console.log(err, data);
});

// NOTE! The default limit is 0. Not setting a limit will get you an empty result.

// the result is an array of big objects representing the comments

 [ { /* ommited for simplicity */ },
   { /* ommited for simplicity */ },
   { /* ommited for simplicity */ } ]

hive.api.getCommentDiscussionsByPayout(query, callback);

var query = { limit : 3, tag : "hive" };
hive.api.getCommentDiscussionsByPayout(query, function(err, data) {
	console.log(err, data);
});

// NOTE! The default limit is 0. Not setting a limit will get you an empty result.

// the result is an array of big objects representing the comments

 [ { /* ommited for simplicity */ },
   { /* ommited for simplicity */ },
   { /* ommited for simplicity */ } ]

hive.api.getPostDiscussionsByPayout(query, callback);

var query = { limit : 3, tag : "collorchallenge" };
hive.api.getPostDiscussionsByPayout(query, function(err, data) {
	console.log(err, data);
});

// NOTE! The default limit is 0. Not setting a limit will get you an empty result.

// the result is an array of big objects representing the comments

 [ { /* ommited for simplicity */ },
   { /* ommited for simplicity */ },
   { /* ommited for simplicity */ } ]

hive.api.getBlockHeader(blockNum, function(err, result) {
  console.log(err, result);
});

hive.api.getBlock(blockNum, function(err, result) {
  console.log(err, result);
});

hive.api.getOpsInBlock(blockNum, onlyVirtual, callback);

hive.api.getOpsInBlock(10000001, false, function(err, data) {
	console.log(err, data);
});

[ { trx_id: '4b688c13940fd5b4bb11356286ef12061f71976c',
    block: 10000001,
    trx_in_block: 0,
    op_in_trx: 0,
    virtual_op: 0,
    timestamp: '2017-03-08T17:34:24',
    op: [ 'vote', [Object] ] },
  { trx_id: 'a450debc8332c3b27935b3307891dfc509669edc',
    block: 10000001,
    trx_in_block: 2,
    op_in_trx: 0,
    virtual_op: 0,
    timestamp: '2017-03-08T17:34:24',
    op: [ 'vote', [Object] ] } ]

hive.api.getState(path, function(err, result) {
  console.log(err, result);
});

hive.api.getState("/@username", function(err, data) {
	console.log(err, data);
});

// Here are some valid calls:

hive.api.getState("/@username", function(err, data) { console.log(data); });

hive.api.getState("/@username/permlink-of-post", function(err, data) { console.log(data); });

hive.api.getState("/@username/comments", function(err, data) { console.log(data); });

hive.api.getState("/@username/recent-replies", function(err, data) { console.log(data); });

hive.api.getState("/trending", function(err, data) { console.log(data); });

hive.api.getState("/trending/collorchallenge", function(err, data) { console.log(data); });

// and others....

// The result is huge, and can have many variations depending on what you are getting the state of. It can't be documented briefly. Here is some basic information:
{	accounts: {username: {...}}
	content: {
		username/permlink1: {...},
		username/permlink2: {...}, 
		username/permlink3: {...} …}
	current_route:"/@username"
	discussion_idx: {...}
	error:""
	feed_price: {base: "3.889 HBD", quote: "1.000 HIVE"}
	pow_queue: []
	props: {...}
	tag_idx: { trending: [...] }
	tags:{...}
	witness_schedule: {...}
	witnesses: {...}	}

hive.api.getStateWith(options, callback);

hive.api.getStateWith({ path : "/@username" }, function(err, data) {
	console.log(err, data);
});

hive.api.getTrendingCategories(after, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getBestCategories(after, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getActiveCategories(after, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getRecentCategories(after, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getConfig(function(err, result) {
  console.log(err, result);
});

hive.api.getDynamicGlobalProperties(function(err, result) {
  console.log(err, result);
});

hive.api.getChainProperties(function(err, result) {
  console.log(err, result);
});

hive.api.getFeedEntries(account, entryId, limit, callback);

hive.api.getFeedEntries("username", 0, 2, function(err, data) {
	console.log(err, data);
});

[
  {
    author: 'otherusername',
    permlink: 'permlink',
    reblog_by: ['mahdiyari'], //full when post is in feed because it's reblogged
    reblog_on: '2018-02-11T18:42:54',
    entry_id: 10260
  },
  {
    author: 'otherusername',
    permlink: 'permlink',
    reblog_by: [], // false when post is in feed because user follows it's author
    reblog_on: '2018-02-11T18:39:24',
    entry_id: 10259
  }
]

hive.api.getFeedHistory(function(err, result) {
  console.log(err, result);
});

hive.api.getCurrentMedianHistoryPrice(function(err, result) {
  console.log(err, result);
});

hive.api.getTicker(callback);

hive.api.getTicker(function(err, data) {
	console.log(err, data);
});

{ latest: '0.89732142857142860',
  lowest_ask: '0.89684014869888484',
  highest_bid: '0.89600000000000002',
  percent_change: '-14.56712923228768730',
  hive_volume: '7397.697 HIVE',
  hbd_volume: '6662.316 HBD' }

hive.api.getTradeHistory(start, end, limit, callback);

var start = "2018-01-01T00:00:00";
var end = "2018-01-02T00:00:00";

hive.api.getTradeHistory(start, end, 5, function(err, data) {
	console.log(err, data);
});

 [ { date: '2018-01-01T00:00:09',
    current_pays: '10.192 HBD',
    open_pays: '25.650 HIVE' },
  { date: '2018-01-01T00:00:09',
    current_pays: '2.000 HBD',
    open_pays: '5.033 HIVE' },
  { date: '2018-01-01T00:00:12',
    current_pays: '13.560 HBD',
    open_pays: '34.128 HIVE' },
  { date: '2018-01-01T00:00:12',
    current_pays: '3.057 HBD',
    open_pays: '7.690 HIVE' },
  { date: '2018-01-01T00:00:12',
    current_pays: '6.908 HBD',
    open_pays: '17.375 HIVE' } ] 

hive.api.getVersion(callback);

hive.api.getVersion(function(err, data) {
	console.log(err, data);
});

{
  blockchain_version: '1.24.4',
  chain_id: 'beeab0de00000000000000000000000000000000000000000000000000000000',
  fc_revision: 'b91e5d490e3647cc816748a5565452b663c6aa73',
  hive_revision: 'b91e5d490e3647cc816748a5565452b663c6aa73'
}

hive.api.getVolume(callback);

hive.api.getVolume(function(err, data) {
	console.log(err, data);
});

{ hive_volume: '8101.888 HIVE',
	hbd_volume: '7287.268 HBD' }

hive.api.getHardforkVersion(function(err, result) {
  console.log(err, result);
});

'1.24.0'

hive.api.getNextScheduledHardfork(function(err, result) {
  console.log(err, result);
});

hive.api.getRewardFund(name, function(err, result) {
  console.log(err, result);
});

hive.broadcast.claimRewardBalance(wif, account, reward_hive, reward_hbd, reward_vests, callback);

hive.broadcast.claimRewardBalance("5Hupd....pp7vGY", "username", "0.000 HIVE", "0.000 HBD", "0.000006 VESTS", function(err, data) {
	console.log(err, data);
});

{ id: '052f.......c6c2f',
  block_num: 19756287,
  trx_num: 40,
  expired: false,
  ref_block_num: 29928,
  ref_block_prefix: 808836877,
  expiration: '2018-02-10T20:12:15',
  operations: [ [ 'claim_reward_balance', [Object] ] ],
  extensions: [],
  signatures: [ '205......614e' ] }

hive.broadcast.claimRewardBalanceWith(wif, options, callback);

var options = {
    account:"username",
    reward_hbd:"0.000 HBD",
    reward_hive:"0.000 HIVE",
    reward_vests:"0.000006 VESTS"
}
hive.broadcast.claimRewardBalanceWith("5Hupd....pp7vGY", options, function(err, data) {
	console.log(err, data);
});

 { id: '4b7b........034c7',
  block_num: 19756322,
  trx_num: 3,
  expired: false,
  ref_block_num: 29965,
  ref_block_prefix: 4245658614,
  expiration: '2018-02-10T20:14:00',
  operations: [ [ 'claim_reward_balance', [Object] ] ],
  extensions: [],
  signatures: [ '1f61a..........4f3d7' ] }

hive.api.getVestingDelegations(account, from, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getVestingDelegations('mahdiyari', '', 2, function(err, result) {
  console.log(err, result);
});

[
  {
    delegatee: 'dblog-io',
    delegator: 'mahdiyari',
    id: 980695,
    min_delegation_time: '2018-08-03T20:33:21',
    vesting_shares: '29429.940343 VESTS'
  },
  {
    delegatee: 'lokio',
    delegator: 'mahdiyari',
    id: 1359266,
    min_delegation_time: '2020-10-21T12:15:18',
    vesting_shares: '28832.135025 VESTS'
  }
]

// Extract delegatee names from the result into an array of account name strings
var f = result.map(function(item) { return item.delegatee; });
console.log(f);

// Get the last tag for subsequent calls to `getVestingDelegations`
//   or use: f[f.length - 1]   if you used the extraction code above.
var lastKnownDelegatee = result[result.length - 1].delegatee;

// Use the last known delegatee to get the next group of delegatees
hive.api.TrendingTags('mahdiyari', lastKnownDelegatee, 2, function(err, result) {
  console.log(err, result);
});

hive.api.getKeyReferences(key, function(err, result) {
  console.log(err, result);
});

hive.api.getAccounts(names, function(err, result) {
  console.log(err, result);
});

hive.api.getAccountReferences(accountId, function(err, result) {
  console.log(err, result);
});

hive.api.lookupAccountNames(accountNames, function(err, result) {
  console.log(err, result);
});

hive.api.lookupAccounts(lowerBoundName, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getAccountCount(function(err, result) {
  console.log(err, result);
});

hive.api.getConversionRequests(accountName, function(err, result) {
  console.log(err, result);
});

hive.api.getAccountHistory(account, from, limit, operation_filter_low, operation_filter_high, function(err, result) {
  console.log(err, result);
});

const { ChainTypes, makeBitMaskFilter } = require('@hiveio/hive-js/lib/auth/serializer')
const op = ChainTypes.operations
const walletOperationsBitmask = makeBitMaskFilter([
  op.transfer,
  op.transfer_to_vesting,
  op.withdraw_vesting,
  op.interest,
  op.liquidity_reward,
  op.transfer_to_savings,
  op.transfer_from_savings,
  op.escrow_transfer,
  op.cancel_transfer_from_savings,
  op.escrow_approve,
  op.escrow_dispute,
  op.escrow_release,
  op.fill_convert_request,
  op.fill_order,
  op.claim_reward_balance
])
hive.api.getAccountHistory(account, from, limit, ...walletOperationsBitmask, function(err, result) {
  console.log(err, result)
})

hive.api.getOwnerHistory(account, function(err, result) {
  console.log(err, result);
});

hive.api.getRecoveryRequest(account, function(err, result) {
  console.log(err, result);
});

hive.api.getAccountReputations(lowerBoundName, limit, callback);

hive.api.getAccountReputations("username", 2, function(err, data) {
	console.log(err, data);
});

 [ { account: 'username', reputation: '26727073581' },
   { account: 'username-taken', reputation: 0 } ]

hive.api.getOrderBook(limit, function(err, result) {
  console.log(err, result);
});

hive.api.getMarketOrderBook(limit, callback);

hive.api.getMarketOrderBook(2, function(err, data) {
	console.log(err, data);
});

{
  asks: [
    {
      created: '2020-11-03T15:24:54',
      hbd: 227,
      hive: 1915,
      order_price: [Object],
      real_price: '0.11853785900783290'
    },
    {
      created: '2020-11-03T15:20:51',
      hbd: 1244,
      hive: 10463,
      order_price: [Object],
      real_price: '0.11889515435343592'
    }
  ],
  bids: [
    {
      created: '2020-11-03T15:23:03',
      hbd: 2000,
      hive: 16948,
      order_price: [Object],
      real_price: '0.11800802454566911'
    },
    {
      created: '2020-11-03T15:21:51',
      hbd: 44673,
      hive: 378585,
      order_price: [Object],
      real_price: '0.11799992075755775'
    }
  ]
}

hive.api.getMarketOrderBookWith(options, callback);

hive.api.getMarketOrderBookWith({ limit: 1 }, function(err, data) {
	console.log(err, data);
});

{
  asks: [
    {
      created: '2020-11-03T15:24:54',
      hbd: 227,
      hive: 1915,
      order_price: [Object],
      real_price: '0.11853785900783290'
    }
  ],
  bids: [
    {
      created: '2020-11-03T15:29:30',
      hbd: 5990,
      hive: 50533,
      order_price: [Object],
      real_price: '0.11853640195515802'
    }
  ]
}

hive.api.getOpenOrders(owner, function(err, result) {
  console.log(err, result);
});

hive.api.getLiquidityQueue(startAccount, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getMarketHistoryBuckets(callback);

hive.api.getMarketHistoryBuckets(function(err, data) {
	console.log(err, data);
});

 [ 15, 60, 300, 3600, 86400 ]

hive.api.getTransactionHex(trx, function(err, result) {
  console.log(err, result);
});

hive.api.getTransaction(trxId, function(err, result) {
  console.log(err, result);
});

hive.api.getRequiredSignatures(trx, availableKeys, function(err, result) {
  console.log(err, result);
});

hive.api.getPotentialSignatures(trx, function(err, result) {
  console.log(err, result);
});

hive.api.verifyAuthority(trx, function(err, result) {
  console.log(err, result);
});

hive.api.verifyAccountAuthority(nameOrId, signers, function(err, result) {
  console.log(err, result);
});

hive.api.getActiveVotes(author, permlink, function(err, result) {
  console.log(err, result);
});

hive.api.getAccountVotes(voter, function(err, result) {
  console.log(err, result);
});

hive.api.getContent(author, permlink, function(err, result) {
  console.log(err, result);
});

hive.api.getContentReplies(author, permlink, function(err, result) {
  console.log(err, result);
});

hive.api.getDiscussionsByAuthorBeforeDate(author, startPermlink, beforeDate, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getRebloggedBy(author, permlink, callback);

hive.api.getRebloggedBy("author", "example-permlink", function(err, data) {
	console.log(err, data);
});

 [ 'author',
  'user1',
  'user2',
  'user3',
  'user4' ]

hive.api.getRepliesByLastUpdate(startAuthor, startPermlink, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getWitnesses(witnessIds, function(err, result) {
  console.log(err, result);
});

hive.api.getWitnessByAccount(accountName, function(err, result) {
  console.log(err, result);
});

hive.api.getWitnessesByVote(from, limit, function(err, result) {
  console.log(err, result);
});

hive.api.lookupWitnessAccounts(lowerBoundName, limit, function(err, result) {
  console.log(err, result);
});

hive.api.getWitnessSchedule(callback);

hive.api.getWitnessSchedule(function(err, data) {
  console.log(err,data);
})

{
  id: 0,
  current_virtual_time: '576908375209337450843859945',
  next_shuffle_block_num: 48367095,
  current_shuffled_witnesses: [
    'cervantes',   'themarkymark',
    'pharesim',    'stoodkev',
    'ausbitbank',  'followbtcnews',
    'anyx',        'gtg',
    'steempeak',   'therealwolf',
    'drakos',      'good-karma',
    'blocktrades', 'roelandp',
    'emrebeyler',  'ocd-witness',
    'arcange',     'someguy123',
    'steempress',  'yabapmatt',
    'abit'
  ],
  num_scheduled_witnesses: 21,
  elected_weight: 1,
  timeshare_weight: 5,
  miner_weight: 1,
  witness_pay_normalization_factor: 25,
  median_props: {
    account_creation_fee: '3.000 HIVE',
    maximum_block_size: 65536,
    hbd_interest_rate: 0,
    account_subsidy_budget: 797,
    account_subsidy_decay: 347321
  },
  majority_version: '1.24.2',
  max_voted_witnesses: 20,
  max_miner_witnesses: 0,
  max_runner_witnesses: 1,
  hardfork_required_witnesses: 17,
  account_subsidy_rd: {
    resource_unit: 10000,
    budget_per_time_unit: 797,
    pool_eq: 157691079,
    max_pool_size: 157691079,
    decay_params: {
      decay_per_time_unit: 347321,
      decay_per_time_unit_denom_shift: 36
    },
    min_decay: 0
  },
  account_subsidy_witness_rd: {
    resource_unit: 10000,
    budget_per_time_unit: 996,
    pool_eq: 9384019,
    max_pool_size: 9384019,
    decay_params: {
      decay_per_time_unit: 7293741,
      decay_per_time_unit_denom_shift: 36
    },
    min_decay: 216
  },
  min_witness_account_subsidy_decay: 0
}

hive.api.getWitnessCount(function(err, result) {
  console.log(err, result);
});

hive.api.getActiveWitnesses(function(err, result) {
  console.log(err, result);
});

hive.api.login('', '', function(err, result) {
  console.log(err, result);
});

hive.api.getApiByName(apiName, function(err, result) {
  console.log(err, result);
});

hive.api.getFollowers(following, startFollower, followType, limit, function(err, result) {
  console.log(err, result);
});

steem.api.getFollowers('username', '', 'blog', 2, function(err, result) {
  console.log(err, result);
});

[ { follower: 'user1', following: 'username', what: [ 'blog' ] },
  { follower: 'user2', following: 'username', what: [ 'blog' ] } ]

// Extract followers from the result into an array of account name strings
var f = result.map(function(item) { return item.follower; });
console.log(f);

// Get the last follower for subsequent calls to getFollowers
//   or use: f[f.length - 1]   if you used the extraction code above.
var lastKnownFollower = result[result.length - 1].follower;

// Use the last known follower to get the next group of followers
hive.api.getFollowers('username', lastKnownFollower, 'blog', 2, function(err, result) {
  console.log(err, result);
});

hive.api.getFollowing(follower, startFollowing, followType, limit, function(err, result) {
  console.log(err, result);
});

hvie.api.getFollowing('username', '', 'blog', 2, function(err, result) {
  console.log(err, result);
});

[ { follower: 'username', following: 'user1', what: [ 'blog' ] },
  { follower: 'username', following: 'user2', what: [ 'blog' ] } ]

// Extract followed accounts from the result into an array of account name strings
var f = result.map(function(item) { return item.following; });

hive.api.getFollowCount(account, function(err, result) {
  console.log(err, result);
});

hive.api.getFollowCount('username', function(err, result) {
  console.log(err, result);
});

{ account: 'username', follower_count: 16790, following_count: 913 }

hive.api.broadcastBlockWith(options, callback);

var options = { 
    b: {
        previous:"0000000000000000000000000000000000000000",
        timestamp:"1970-01-01T00:00:00",
        witness:"",
        transaction_merkle_root:"0000000000000000000000000000000000000000",
        extensions:[],
        witness_signature:
            "00000000000000000000000000000000000000000000000000000000000000000"+
            "00000000000000000000000000000000000000000000000000000000000000000",
        transactions: []
    }
};

hive.api.broadcastBlockWith(options, function(err, data) {
	console.log(err, data);
});

hive.api.broadcastTransactionSynchronous(trx, function(err, result) {
  console.log(err, result);
});

hive.api.broadcastBlock(b, function(err, result) {
  console.log(err, result);
});

hive.broadcast.accountCreate(wif, fee, creator, newAccountName, owner, active, posting, memoKey, jsonMetadata, function(err, result) {
  console.log(err, result);
});