BITE TypeScript SDK

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 or open an issue on GitHub.

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

# npm
npm i @skalenetwork/bite

# yarn
yarn add @skalenetwork/bite

# pnpm
pnpm add @skalenetwork/bite

# Bun
bun add @skalenetwork/bite

The SDK works with any SKALE chain with Programmable Privacy. Currently, it is available on SKALE Base Mainnet and Testnet only.

Quick Start

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:

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:

RLP encodes original data and to fields
Encrypts encoded data using AES with randomly generated key
Encrypts AES key using BLS threshold encryption
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)

Set gasLimit manually. estimateGas does not return a reliable value for encrypted transactions. If gasLimit is omitted, defaults to 300000.

`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:

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:

const decryptedData = await bite.getDecryptedTransactionData('0x1234...abcd');
console.log('Original to:', decryptedData.to);
console.log('Original data:', decryptedData.data);

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.

`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:

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

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

Always set an explicit gas limit for encrypted transactions. Do not rely on estimateGas().

// 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:

npm install buffer

Vite — add to vite.config.ts:

import { defineConfig } from 'vite'
export default defineConfig({
  resolve: { alias: { buffer: 'buffer' } },
})

Webpack 5 — add to webpack.config.js:

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

Committee Rotation Monitoring

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

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

Confidential Contract Interactions

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

Cached Committee Encryption

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
BITE Solidity SDK: npm: @skalenetwork/bite-solidity
Programmable Privacy Intro: Overview

Integrate SKALE

Resources

Programmable Privacy

SDKs

SKALE Bridge

Cryptography

Installation

Quick Start

API Reference

`new BITE(endpoint)`

`bite.encryptTransaction(tx)`

`BITE.encryptTransactionWithCommitteeInfo(tx, committees)`

`bite.encryptMessage(message)`

`bite.getDecryptedTransactionData(transactionHash)`

`bite.getCommitteesInfo()`

Transaction Structure

Encrypted Transaction Format

Encryption Payload Structure

Best Practices

Gas Limit Management

Browser Polyfills

Committee Rotation Monitoring

Common Use Cases

Private Token Transfers

Confidential Contract Interactions

Cached Committee Encryption

Resources

​Installation

​Quick Start

​API Reference

​new BITE(endpoint)

​bite.encryptTransaction(tx)

​BITE.encryptTransactionWithCommitteeInfo(tx, committees)

​bite.encryptMessage(message)

​bite.getDecryptedTransactionData(transactionHash)

​bite.getCommitteesInfo()

​Transaction Structure

​Encrypted Transaction Format

​Encryption Payload Structure

​Best Practices

​Gas Limit Management

​Browser Polyfills

​Committee Rotation Monitoring

​Common Use Cases

​Private Token Transfers

​Confidential Contract Interactions

​Cached Committee Encryption

​Resources

Installation

Quick Start

API Reference

`new BITE(endpoint)`

`bite.encryptTransaction(tx)`

`BITE.encryptTransactionWithCommitteeInfo(tx, committees)`

`bite.encryptMessage(message)`

`bite.getDecryptedTransactionData(transactionHash)`

`bite.getCommitteesInfo()`

Transaction Structure

Encrypted Transaction Format

Encryption Payload Structure

Best Practices

Gas Limit Management

Browser Polyfills

Committee Rotation Monitoring

Common Use Cases

Private Token Transfers

Confidential Contract Interactions

Cached Committee Encryption

Resources