> ## Documentation Index
> Fetch the complete documentation index at: https://docs.skale.space/llms.txt
> Use this file to discover all available pages before exploring further.

# BITE TypeScript SDK

> TypeScript SDK for encrypting transactions and messages using SKALE's Programmable Privacy — works in Node.js, Bun, and browser environments

<Note>
  TypeScript transpiles to JavaScript, so the SDK works in both TypeScript and JavaScript across Node.js, Bun, and browser environments.
  If you run into an issue, reach out in [Discord](https://discord.gg/skale) or open an issue on [GitHub](https://github.com/skalenetwork/bite-ts).
</Note>

The BITE TypeScript SDK (`@skalenetwork/bite`) lets applications and wallets encrypt EVM transactions using threshold encryption. It works with any SKALE chain that has Programmable Privacy enabled.

## Installation

```bash theme={null}
# npm
npm i @skalenetwork/bite

# yarn
yarn add @skalenetwork/bite

# pnpm
pnpm add @skalenetwork/bite

# Bun
bun add @skalenetwork/bite
```

<Note>
  The SDK works with any SKALE chain with Programmable Privacy. Currently, it is available on [SKALE Base Mainnet and Testnet](/get-started/quick-start/skale-on-base) only.
</Note>

## Quick Start

```typescript theme={null}
import { BITE } from '@skalenetwork/bite';

const providerUrl = 'https://your-fair-rpc';
const bite = new BITE(providerUrl);

// Encrypt a transaction
const tx = {
  to: '0x1234567890abcdef1234567890abcdef12345678',
  data: '0x1234abcd',
};
const encryptedTx = await bite.encryptTransaction(tx);

// Send via your wallet/provider
window.ethereum.request({ method: 'eth_sendTransaction', params: [encryptedTx] });

// Later, fetch revealed original fields after block finality
const result = await bite.getDecryptedTransactionData('<txHash>');
// result => { to: '0x...', data: '0x...' }
```

## API Reference

### `new BITE(endpoint)`

Creates a BITE instance configured with a JSON-RPC endpoint.

**Parameters:**

* `endpoint: string` — JSON-RPC endpoint

**Example:**

```typescript theme={null}
const bite = new BITE('https://your-skale-chain.skale.network');
```

### `bite.encryptTransaction(tx)`

Encrypts a transaction using BLS threshold encryption. The encrypted transaction will have its `to` field set to the magic address.

**Parameters:**

* `tx: { to: string; data: string; gasLimit?: number }` — Standard hex strings

**Returns:** `Promise<Transaction>` — Encrypted transaction safe to submit to `eth_sendTransaction`

**Encryption Process:**

1. RLP encodes original `data` and `to` fields
2. Encrypts encoded data using AES with randomly generated key
3. Encrypts AES key using BLS threshold encryption
4. Creates final payload: `[EPOCH_ID, ENCRYPTED_BITE_DATA]`

**Committee Behavior:**

* **Single Committee:** AES key encrypted with current BLS public key
* **Dual Committee:** During rotation, AES key encrypted twice (current + next committee keys)

<Warning>
  Set `gasLimit` manually. `estimateGas` does not return a reliable value for encrypted transactions. If `gasLimit` is omitted, defaults to **300000**.
</Warning>

### `BITE.encryptTransactionWithCommitteeInfo(tx, committees)`

Static method that encrypts using provided committee info, avoiding internal RPC call.

**Parameters:**

* `tx: object` — Transaction with `data` and `to` fields
* `committees: Array` — Committee info objects (from `getCommitteesInfo`)

**Returns:**

* `Promise<Transaction>` — Encrypted transaction

**Use Case:** Offline/cached encryption when committee info is already known.

### `bite.encryptMessage(message)`

Encrypts a raw hex-encoded message using BLS threshold encryption.

**Parameters:**

* `message: string` — Hex string to encrypt (with or without `0x` prefix)

**Returns:** `Promise<string>` — Encrypted hex string in RLP format with epoch and encryption data

**Example:**

```typescript theme={null}
const encryptedMessage = await bite.encryptMessage('0x48656c6c6f20576f726c64'); // "Hello World"
```

### `bite.getDecryptedTransactionData(transactionHash)`

Retrieves decrypted transaction data after consensus finality using `bite_getDecryptedTransactionData` JSON-RPC method.

**Parameters:**

* `transactionHash: string` — The transaction hash

**Returns:** `Promise<object>` — JSON with `data` and `to` keys containing original decrypted fields

**Example:**

```typescript theme={null}
const decryptedData = await bite.getDecryptedTransactionData('0x1234...abcd');
console.log('Original to:', decryptedData.to);
console.log('Original data:', decryptedData.data);
```

<Note>
  This method works only for encrypted transactions that have already been processed and decrypted by the network. If the transaction does not exist, or if decrypted data is unavailable, the call throws an error.
</Note>

### `bite.getCommitteesInfo()`

Fetches committee information using `bite_getCommitteesInfo` JSON-RPC method.

**Returns:** `Promise<Array>` — Array of 1-2 committee objects:

* `commonBLSPublicKey`: 256-char hex (128-byte BLS public key)
* `epochId`: Integer epoch identifier

**Array Contents:**

* **1 element:** Normal operation (single active committee)
* **2 elements:** Committee rotation period (scheduled for next 3 minutes)

**Example:**

```typescript theme={null}
const committeesInfo = await bite.getCommitteesInfo();
console.log('Current BLS Public Key:', committeesInfo[0].commonBLSPublicKey);

if (committeesInfo.length === 2) {
    console.log('Rotation in progress — dual encryption active');
}
```

## Transaction Structure

### Encrypted Transaction Format

```typescript theme={null}
interface BiteTransaction {
  to: string;      // Always set to the magic address
  data: string;    // Encrypted payload containing [EPOCH_ID, ENCRYPTED_DATA]
  from: string;    // Sender address (unchanged)
  value: string;   // ETH value (unchanged)
  gas: string;     // Gas limit (must be set manually)
  gasPrice: string; // Gas price (unchanged)
  nonce: number;   // Nonce (unchanged)
}
```

### Encryption Payload Structure

The encrypted `data` field contains RLP-encoded array:

```
[EPOCH_ID, ENCRYPTED_BITE_DATA]
```

* `EPOCH_ID` — Current committee epoch
* `ENCRYPTED_BITE_DATA` — AES-encrypted payload with BLS-encrypted AES key

## Best Practices

### Gas Limit Management

<Warning>
  Always set an explicit gas limit for encrypted transactions. Do not rely on `estimateGas()`.
</Warning>

```typescript theme={null}
// Always set an appropriate gas limit
const tx = {
    to: '0x...',
    data: '0x...',
    gasLimit: 200000,
};
const encryptedTx = await bite.encryptTransaction(tx);
```

### Browser Polyfills

When using the SDK in the browser, you may need to polyfill `Buffer`:

```bash theme={null}
npm install buffer
```

**Vite** — add to `vite.config.ts`:

```typescript theme={null}
import { defineConfig } from 'vite'
export default defineConfig({
  resolve: { alias: { buffer: 'buffer' } },
})
```

**Webpack 5** — add to `webpack.config.js`:

```javascript theme={null}
module.exports = {
  resolve: { fallback: { buffer: require.resolve('buffer/') } },
}
```

### Committee Rotation Monitoring

```typescript theme={null}
const INTERVAL_MS = 30000;

async function monitorCommitteeRotation() {
    const committees = await bite.getCommitteesInfo();
    if (committees.length === 2) {
        console.warn('Committee rotation in progress');
    }
    setTimeout(monitorCommitteeRotation, INTERVAL_MS);
}
```

## Common Use Cases

### Private Token Transfers

```typescript theme={null}
const transferData = iface.encodeFunctionData('transfer', [recipient, amount]);
const tx = { to: tokenAddress, data: transferData, gasLimit: 200000 };
const encryptedTx = await bite.encryptTransaction(tx);
```

### Confidential Contract Interactions

```typescript theme={null}
const callData = iface.encodeFunctionData('confidentialFunction', [secretParam]);
const tx = { to: contractAddress, data: callData, gasLimit: 300000 };
const encryptedTx = await bite.encryptTransaction(tx);
```

### Cached Committee Encryption

```typescript theme={null}
const committees = await bite.getCommitteesInfo();
const tx1 = await BITE.encryptTransactionWithCommitteeInfo(transaction1, committees);
const tx2 = await BITE.encryptTransactionWithCommitteeInfo(transaction2, committees);
```

## Resources

* **GitHub**: [github.com/skalenetwork/bite-ts](https://github.com/skalenetwork/bite-ts)
* **BITE Solidity SDK**: [npm: @skalenetwork/bite-solidity](/developers/sdks/skalenetwork-bite-solidity)
* **Programmable Privacy Intro**: [Overview](/developers/programmable-privacy/intro)