# Helper Methods
The `GraphQLClient` class is the primary interface for interacting with an OCAP-powered blockchain. It provides a comprehensive set of methods for querying the chain state, sending transactions, and subscribing to real-time events. It is designed to work seamlessly in both Node.js and browser environments.
```javascript Client Initialization icon=logos:javascript
const GraphQLClient = require('@ocap/client');
// Connect to the Beta chain
const client = new GraphQLClient('https://beta.abtnetwork.io/api');
(async () => {
const res = await client.getChainInfo();
console.log('Connected to chain:', res.info.network);
})();
```
This section provides a detailed reference for the core helper methods of the `GraphQLClient` class.
## Constructor
### new GraphQLClient(endpoint, autoInit)
Creates a new instance of the `GraphQLClient`.
**Parameters**
The absolute URL of the GraphQL endpoint for the blockchain node (e.g., `https://beta.abtnetwork.io/api`).
If `true`, the client will automatically fetch and cache essential chain information (the "context") upon initialization. This is recommended for most use cases.
**Example**
```javascript Creating a Client Instance icon=logos:javascript
const client = new GraphQLClient('https://beta.abtnetwork.io/api', true);
```
---
## Core Methods
These methods provide fundamental functionality for interacting with the client and the chain.
### getContext()
Fetches and caches essential chain information, such as the chain ID, native token details, and transaction fee configurations. This method is called automatically if `autoInit` is enabled in the constructor. Subsequent calls will return the cached context.
**Returns**
**Example**
```javascript Fetching Chain Context icon=logos:javascript
async function logChainToken() {
const context = await client.getContext();
console.log(`Native Token Symbol: ${context.token.symbol}`);
}
logChainToken();
```
### setGasPayer(wallet)
Configures a wallet to act as a "gas payer." When set, this wallet will sponsor the transaction fees for transactions sent through this client instance, enabling gasless experiences for users. For more details, see the [Gas Payment](./core-concepts-gas-payment.md) concept guide.
**Parameters**
A wallet object with `address`, `publicKey`, and `secretKey` properties, equipped with a `sign` method.
### decodeTx(input)
Deserializes a transaction from various formats into a human-readable JavaScript object.
**Parameters**
The transaction data to decode. Can be a `Buffer` or a string in `hex`, `base58`, or `base64` format.
**Returns**
### getType(name)
Retrieves the Protobuf message class for a given type name. This is useful for advanced scenarios where you need to manually construct or inspect Protobuf messages.
**Parameters**
**Returns**
---
## Event Subscription
The client supports real-time event subscriptions over WebSockets, allowing your application to react instantly to on-chain events.
### subscribe(topic, callback)
Establishes a WebSocket connection and subscribes to a specific event topic.
**Parameters**
### unsubscribe(topic, callback)
Removes a previously registered callback for a specific topic.
**Parameters**
**Example**
```javascript Subscribing to New Blocks icon=logos:javascript
const handleNewBlock = (block) => {
console.log(`New block received! Height: ${block.height}`);
// Unsubscribe after receiving one block
client.unsubscribe('newBlock', handleNewBlock);
console.log('Unsubscribed from newBlock events.');
};
client.subscribe('newBlock', handleNewBlock);
console.log('Subscribed to newBlock events...');
```
---
## Token Utility Methods
These helpers simplify conversions between the human-readable token amount and the on-chain base unit representation.
### fromUnitToToken(value)
Converts a value from the chain's base unit (a large integer string) to a standard decimal string, based on the native token's decimal places.
**Parameters**
**Returns**
### fromTokenToUnit(amount)
Converts a standard decimal amount into the chain's base unit representation (a BN.js instance).
**Parameters**
**Returns**
**Example**
```javascript Token Amount Conversion icon=logos:javascript
async function convertToken() {
// Convert 100 TBA to its base unit
const unitAmount = await client.fromTokenToUnit(100);
console.log(`100 TBA is ${unitAmount.toString()} in base units.`);
// Convert it back
const tokenAmount = await client.fromUnitToToken(unitAmount.toString());
console.log(`${unitAmount.toString()} base units is ${tokenAmount} TBA.`);
}
convertToken();
```
---
## Method Discovery
The client dynamically generates methods for every transaction type supported by the connected OCAP node. These discovery methods allow you to programmatically list all available transaction-related functions.
### getTxSendMethods()
Returns an array of all available `send...Tx` method names. These methods handle the full lifecycle of signing and sending a transaction.
### getTxEncodeMethods()
Returns an array of all available `encode...Tx` method names. These methods prepare and serialize a transaction into a buffer, but do not sign it.
### getTxSignMethods()
Returns an array of all available `sign...Tx` method names. These methods encode and then sign a transaction, returning the signed transaction object.
### getTxMultiSignMethods()
Returns an array of all available `multiSign...Tx` method names, used for multi-signature workflows.
**Example**
```javascript Listing Available Transaction Methods icon=logos:javascript
const sendMethods = client.getTxSendMethods();
console.log('Available send methods:', sendMethods);
// Example output: [ 'sendPokeTx', 'sendTransferTx', ... ]
```