Skip to main content
The IHiveChainInterface extends IWaxBaseInterface with online chain access capabilities, including API calls, transaction broadcasting, and enhanced transaction creation with automatic TAPOS.

​
Inheritance

IHiveChainInterface extends all methods and properties from IWaxBaseInterface.

​
Properties

​
api

Access to all Hive blockchain APIs through typed interfaces. 
readonly api: {
  account_by_key_api: JsonRpcApiData<'account_by_key_api'>;
  block_api: JsonRpcApiData<'block_api'>;
  database_api: JsonRpcApiData<'database_api'>;
  network_broadcast_api: JsonRpcApiData<'network_broadcast_api'>;
  rc_api: JsonRpcApiData<'rc_api'>;
};

​
Available APIs

​
account_by_key_api
object
Account lookup by public key
​
block_api
object
Block data retrieval
​
database_api
object
Core database queries
​
network_broadcast_api
object
Transaction broadcasting
​
rc_api
object
Resource credit queries

​
restApi

Access to REST API endpoints for hafbe (Hive Application Framework Backend). 
readonly restApi: TDefaultRestApi;

​
Configuration

​
Setting endpoint URLs

You can customize endpoint URLs per API or globally: 
// Set endpoint for specific API
chain.api.database_api.endpointUrl = "https://custom-node.example.com";

// Reset to default
chain.api.database_api.endpointUrl = undefined;

// Set REST API endpoint
chain.restApi.endpointUrl = "https://custom-hafbe.example.com";

​
Enhanced transaction methods

​
createTransaction

Creates a transaction with automatic TAPOS using current head block. 
async createTransaction(expirationTime?: TTimestamp): Promise<IOnlineTransaction>;
​
expirationTime
TTimestamp
Optional expiration time. Can be:
  • Date object
  • Unix timestamp (number)
  • ISO 8601 string
  • Relative time: "+10s", "+30m", "+1h"
Defaults to "+1m"
​
Promise<IOnlineTransaction>
Promise<IOnlineTransaction>
Promise that resolves to an online transaction with verification capabilities

​
Usage example

// Create transaction with automatic TAPOS
const tx = await chain.createTransaction("+5m");

// Add operations
tx.pushOperation({
  vote: {
    voter: "alice",
    author: "bob",
    permlink: "example-post",
    weight: 10000
  }
});

// Sign with signature provider
const signature = await signer.signTransaction(tx.sigDigest);
tx.addSignature(signature);

// Broadcast
await chain.api.network_broadcast_api.broadcast_transaction({
  trx: tx.toApiJson()
});

​
API usage examples

​
Get dynamic global properties

const dgpo = await chain.api.database_api.get_dynamic_global_properties({});

console.log('Head block:', dgpo.head_block_number);
console.log('Head block ID:', dgpo.head_block_id);
console.log('Time:', dgpo.time);
console.log('Current witness:', dgpo.current_witness);

​
Find accounts

const result = await chain.api.database_api.find_accounts({
  accounts: ["alice", "bob"]
});

for (const account of result.accounts) {
  console.log(`Account: ${account.name}`);
  console.log(`Balance: ${account.balance.amount}`);
  console.log(`Vesting shares: ${account.vesting_shares.amount}`);
}

​
Get block

const block = await chain.api.block_api.get_block({
  block_num: 12345678
});

console.log('Block ID:', block.block.block_id);
console.log('Timestamp:', block.block.timestamp);
console.log('Transactions:', block.block.transactions.length);

​
Get key references

const result = await chain.api.account_by_key_api.get_key_references({
  keys: ["STM7Q2rLBqzPzFeteQZewv9Lu3NLE69fZoLeL6YK59t7UmssCBNTU"]
});

console.log('Accounts:', result.accounts);

​
Find RC accounts

const result = await chain.api.rc_api.find_rc_accounts({
  accounts: ["alice"]
});

for (const account of result.rc_accounts) {
  console.log(`Account: ${account.account}`);
  console.log(`Max RC: ${account.max_rc}`);
  console.log(`RC Manabar:`, account.rc_manabar);
}

​
Broadcast transaction

// Create and sign transaction
const tx = await chain.createTransaction();

tx.pushOperation({
  vote: {
    voter: "alice",
    author: "bob",
    permlink: "example-post",
    weight: 10000
  }
});

const signature = await signer.signTransaction(tx.sigDigest);
tx.addSignature(signature);

// Broadcast to network
try {
  await chain.api.network_broadcast_api.broadcast_transaction({
    trx: tx.toApiJson()
  });
  console.log('Transaction broadcasted successfully');
} catch (error) {
  console.error('Broadcast failed:', error);
}

​
Online transaction features

​
IOnlineTransaction

The IOnlineTransaction interface extends ITransaction with additional verification methods.

​
performOnChainVerification

Performs transaction checks that require chain API access. 
async performOnChainVerification(): Promise<void>;
Supported checks:
  • Private key leakage prevention
  • Authority validation

​
generateAuthorityVerificationTrace

Generates authority verification trace for the transaction. 
async generateAuthorityVerificationTrace(
  useLegacySerialization?: boolean,
  externalTx?: ITransaction
): Promise<IVerifyAuthorityTrace>;
​
useLegacySerialization
boolean
Optional flag to use legacy (pre-HF26) serialization
​
externalTx
ITransaction
Optional external transaction for verification
​
Promise<IVerifyAuthorityTrace>
Promise<IVerifyAuthorityTrace>
Authority verification trace data

​
Usage example

// Create and sign transaction
const tx = await chain.createTransaction();

tx.pushOperation({
  transfer: {
    from: "alice",
    to: "bob",
    amount: chain.hiveCoins(10),
    memo: "Test transfer"
  }
});

const signature = await signer.signTransaction(tx.sigDigest);
tx.addSignature(signature);

// Verify on-chain (checks for private key leakage)
try {
  await tx.performOnChainVerification();
  console.log('Transaction verified successfully');
} catch (error) {
  console.error('Verification failed:', error);
}

// Generate authority trace
const trace = await tx.generateAuthorityVerificationTrace();
console.log('Authority trace:', trace);

​
API customization

​
Extending APIs

You can extend the API with custom endpoints: 
// Add custom endpoint
chain.api.custom_api = {
  my_method: async (params) => {
    const response = await fetch(`${chain.api.endpointUrl}/custom_api.my_method`, {
      method: 'POST',
      body: JSON.stringify(params)
    });
    return response.json();
  }
};

​
Setting API timeout

API timeout is configured during chain creation: 
const chain = await createHiveChain({
  apiTimeout: 5000 // 5 seconds
});

​
Custom API caller header

Identify your application with the X-Wax-Api-Caller header: 
const chain = await createHiveChain({
  waxApiCaller: "my-awesome-app/1.0.0"
});

​
TypeScript types

type TTimestamp = Date | number | string;

interface IOnlineTransaction extends ITransactionBase {
  performOnChainVerification(): Promise<void>;
  generateAuthorityVerificationTrace(
    useLegacySerialization?: boolean,
    externalTx?: ITransaction
  ): Promise<IVerifyAuthorityTrace>;
}

interface IWaxOptionsChain extends IWaxOptions {
  apiEndpoint: string;
  restApiEndpoint: string;
  waxApiCaller?: string;
  apiTimeout: number;
}

​
Error handling

try {
  const result = await chain.api.database_api.find_accounts({
    accounts: ["nonexistent"]
  });
} catch (error) {
  if (error instanceof WaxError) {
    console.error('WAX error:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}

​
See also

Build docs developers (and LLMs) love

Get started for freeTalk to us